diff --git a/lib/src/core/design_system/components/atoms/surfaces/app_surface.dart b/lib/src/core/design_system/components/atoms/surfaces/app_surface.dart
new file mode 100644
index 00000000..d59924c2
--- /dev/null
+++ b/lib/src/core/design_system/components/atoms/surfaces/app_surface.dart
@@ -0,0 +1,47 @@
+import 'package:flutter/material.dart';
+import 'package:spark/src/core/design_system/tokens/shadows.dart';
+
+enum AppSurfaceVariant { outlined, raised }
+
+class AppSurface extends StatelessWidget {
+  const AppSurface({
+    required this.child,
+    super.key,
+    this.variant = AppSurfaceVariant.outlined,
+    this.margin = EdgeInsets.zero,
+    this.padding = EdgeInsets.zero,
+  });
+
+  final Widget child;
+  final AppSurfaceVariant variant;
+  final EdgeInsetsGeometry margin;
+  final EdgeInsetsGeometry padding;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+    final isDark = theme.brightness == Brightness.dark;
+    final borderRadius = BorderRadius.circular(16);
+
+    return Padding(
+      padding: margin,
+      child: DecoratedBox(
+        decoration: BoxDecoration(
+          color: isDark
+              ? colorScheme.surfaceContainerHighest
+              : colorScheme.surface,
+          borderRadius: borderRadius,
+          border: Border.all(color: colorScheme.outline),
+          boxShadow: variant == AppSurfaceVariant.raised
+              ? const [AppShadows.shadowXs]
+              : null,
+        ),
+        child: ClipRRect(
+          borderRadius: borderRadius,
+          child: Padding(padding: padding, child: child),
+        ),
+      ),
+    );
+  }
+}
diff --git a/lib/src/core/design_system/components/molecules/app_choice_group.dart b/lib/src/core/design_system/components/molecules/app_choice_group.dart
new file mode 100644
index 00000000..52bc2a95
--- /dev/null
+++ b/lib/src/core/design_system/components/molecules/app_choice_group.dart
@@ -0,0 +1,116 @@
+import 'package:flutter/material.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/interactive_pressable.dart';
+import 'package:spark/src/core/design_system/tokens/typography.dart';
+
+@immutable
+class AppChoiceOption<T> {
+  const AppChoiceOption({
+    required this.value,
+    required this.label,
+    this.enabled = true,
+  });
+
+  final T value;
+  final String label;
+  final bool enabled;
+}
+
+class AppChoiceGroup<T> extends StatelessWidget {
+  const AppChoiceGroup({
+    required this.value,
+    required this.options,
+    required this.onChanged,
+    super.key,
+    this.enabled = true,
+  }) : assert(options.length > 1);
+
+  final T value;
+  final List<AppChoiceOption<T>> options;
+  final ValueChanged<T> onChanged;
+  final bool enabled;
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      spacing: 6,
+      children: [
+        for (final option in options)
+          Expanded(
+            child: _ChoiceButton<T>(
+              option: option,
+              isSelected: option.value == value,
+              enabled: enabled && option.enabled,
+              onSelected: onChanged,
+            ),
+          ),
+      ],
+    );
+  }
+}
+
+class _ChoiceButton<T> extends StatelessWidget {
+  const _ChoiceButton({
+    required this.option,
+    required this.isSelected,
+    required this.enabled,
+    required this.onSelected,
+  });
+
+  final AppChoiceOption<T> option;
+  final bool isSelected;
+  final bool enabled;
+  final ValueChanged<T> onSelected;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final onTap = enabled ? () => onSelected(option.value) : null;
+    final backgroundColor = enabled
+        ? isSelected
+              ? colorScheme.primary
+              : colorScheme.surface
+        : colorScheme.onSurface.withValues(alpha: 0.12);
+    final foregroundColor = enabled
+        ? isSelected
+              ? colorScheme.onPrimary
+              : colorScheme.onSurface
+        : colorScheme.onSurface.withValues(alpha: 0.38);
+    final borderRadius = BorderRadius.circular(12);
+
+    return Semantics(
+      label: option.label,
+      button: true,
+      enabled: enabled,
+      selected: isSelected,
+      inMutuallyExclusiveGroup: true,
+      onTap: onTap,
+      child: ExcludeSemantics(
+        child: InteractivePressable(
+          onTap: onTap,
+          borderRadius: borderRadius,
+          child: Material(
+            color: backgroundColor,
+            elevation: isSelected && enabled ? 2 : 0,
+            shape: RoundedRectangleBorder(
+              borderRadius: borderRadius,
+              side: BorderSide(color: colorScheme.outline, width: 0.5),
+            ),
+            clipBehavior: Clip.antiAlias,
+            child: ConstrainedBox(
+              constraints: const BoxConstraints(minHeight: 40),
+              child: Align(
+                child: Text(
+                  option.label,
+                  overflow: TextOverflow.ellipsis,
+                  style: AppTypography.textExtraSmallBold.copyWith(
+                    color: foregroundColor,
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
diff --git a/lib/src/core/design_system/components/molecules/profile_avatar.dart b/lib/src/core/design_system/components/molecules/profile_avatar.dart
index 615df354..0a86472c 100644
--- a/lib/src/core/design_system/components/molecules/profile_avatar.dart
+++ b/lib/src/core/design_system/components/molecules/profile_avatar.dart
@@ -14,6 +14,7 @@ class ProfileAvatar extends StatelessWidget {
     this.onTap,
     this.showAddButton = false,
     this.onAddTap,
+    this.avatarBuilder,
   });
 
   final String? avatarUrl;
@@ -23,6 +24,7 @@ class ProfileAvatar extends StatelessWidget {
   final VoidCallback? onTap;
   final bool showAddButton;
   final VoidCallback? onAddTap;
+  final Widget Function(Widget avatar)? avatarBuilder;
 
   @override
   Widget build(BuildContext context) {
@@ -111,24 +113,22 @@ class ProfileAvatar extends StatelessWidget {
     required bool isDarkMode,
     required double avatarSize,
   }) {
-    if (avatarUrl != null && avatarUrl!.isNotEmpty) {
-      return ClipOval(
-        child: CachedNetworkImage(
-          fadeInDuration: Duration.zero,
-          fadeOutDuration: Duration.zero,
-          imageUrl: avatarUrl!,
-          width: avatarSize,
-          height: avatarSize,
-          fit: BoxFit.cover,
-          placeholder: (context, url) =>
-              _buildPlaceholder(context, isDarkMode, avatarSize),
-          errorWidget: (context, url, error) =>
-              _buildPlaceholder(context, isDarkMode, avatarSize),
-        ),
-      );
-    }
+    final avatar = avatarUrl != null && avatarUrl!.isNotEmpty
+        ? CachedNetworkImage(
+            fadeInDuration: Duration.zero,
+            fadeOutDuration: Duration.zero,
+            imageUrl: avatarUrl!,
+            width: avatarSize,
+            height: avatarSize,
+            fit: BoxFit.cover,
+            placeholder: (context, url) =>
+                _buildPlaceholder(context, isDarkMode, avatarSize),
+            errorWidget: (context, url, error) =>
+                _buildPlaceholder(context, isDarkMode, avatarSize),
+          )
+        : _buildPlaceholder(context, isDarkMode, avatarSize);
 
-    return _buildPlaceholder(context, isDarkMode, avatarSize);
+    return ClipOval(child: avatarBuilder?.call(avatar) ?? avatar);
   }
 
   Widget _buildPlaceholder(
diff --git a/lib/src/core/design_system/components/molecules/profile_card.dart b/lib/src/core/design_system/components/molecules/profile_card.dart
index f3c2fc82..9cd4eaa3 100644
--- a/lib/src/core/design_system/components/molecules/profile_card.dart
+++ b/lib/src/core/design_system/components/molecules/profile_card.dart
@@ -20,6 +20,7 @@ class ProfileCard extends StatelessWidget {
     this.onTap,
     this.hasStories = false,
     this.onAvatarTap,
+    this.avatarBuilder,
     super.key,
   });
 
@@ -37,6 +38,7 @@ class ProfileCard extends StatelessWidget {
     VoidCallback? onTap,
     bool hasStories = false,
     VoidCallback? onAvatarTap,
+    Widget Function(Widget avatar)? avatarBuilder,
     Key? key,
   }) : this(
          imageUrl: imageUrl,
@@ -51,6 +53,7 @@ class ProfileCard extends StatelessWidget {
          onTap: onTap,
          hasStories: hasStories,
          onAvatarTap: onAvatarTap,
+         avatarBuilder: avatarBuilder,
          key: key,
        );
 
@@ -66,6 +69,7 @@ class ProfileCard extends StatelessWidget {
   final VoidCallback? onTap;
   final bool hasStories;
   final VoidCallback? onAvatarTap;
+  final Widget Function(Widget avatar)? avatarBuilder;
 
   @override
   Widget build(BuildContext context) {
@@ -73,6 +77,14 @@ class ProfileCard extends StatelessWidget {
     final isDark = Theme.of(context).brightness == Brightness.dark;
     final radius = BorderRadius.circular(AppShapes.squircleRadius);
     final borderColor = isDark ? AppColors.grey800 : AppColors.grey200;
+    final avatar = ProfileAvatar(
+      avatarUrl: imageUrl.isNotEmpty ? imageUrl : null,
+      displayName: userName,
+      size: 36,
+      hasStories: hasStories,
+      onTap: onAvatarTap ?? onTap,
+      avatarBuilder: avatarBuilder,
+    );
 
     final Widget content = ConstrainedBox(
       constraints: const BoxConstraints(minHeight: 60),
@@ -97,13 +109,7 @@ class ProfileCard extends StatelessWidget {
                   child: Row(
                     crossAxisAlignment: CrossAxisAlignment.start,
                     children: [
-                      ProfileAvatar(
-                        avatarUrl: imageUrl.isNotEmpty ? imageUrl : null,
-                        displayName: userName,
-                        size: 36,
-                        hasStories: hasStories,
-                        onTap: onAvatarTap ?? onTap,
-                      ),
+                      avatar,
                       const SizedBox(width: 10),
                       Expanded(
                         child: Column(
diff --git a/lib/src/core/design_system/components/molecules/story_circle.dart b/lib/src/core/design_system/components/molecules/story_circle.dart
index 0344fec0..00105048 100644
--- a/lib/src/core/design_system/components/molecules/story_circle.dart
+++ b/lib/src/core/design_system/components/molecules/story_circle.dart
@@ -12,24 +12,28 @@ class StoryCircle extends StatelessWidget {
   final String userName;
   final String imageUrl;
   final String live;
+  final Widget Function(Widget avatar)? avatarBuilder;
 
   const StoryCircle._({
     required this.type,
     required this.userName,
     required this.imageUrl,
     required this.live,
+    this.avatarBuilder,
   });
 
   /// Constructor variant for an unread story with an accent border.
   factory StoryCircle.story({
     required String userName,
     required String imageUrl,
+    Widget Function(Widget avatar)? avatarBuilder,
   }) {
     return StoryCircle._(
       type: StoryType.story,
       userName: userName,
       imageUrl: imageUrl,
       live: '',
+      avatarBuilder: avatarBuilder,
     );
   }
 
@@ -38,22 +42,29 @@ class StoryCircle extends StatelessWidget {
     required String userName,
     required String imageUrl,
     required String live,
+    Widget Function(Widget avatar)? avatarBuilder,
   }) {
     return StoryCircle._(
       type: StoryType.live,
       userName: userName,
       imageUrl: imageUrl,
       live: live,
+      avatarBuilder: avatarBuilder,
     );
   }
 
   /// Constructor variant for a "Close Friends" story with a green border.
-  factory StoryCircle.cf({required String userName, required String imageUrl}) {
+  factory StoryCircle.cf({
+    required String userName,
+    required String imageUrl,
+    Widget Function(Widget avatar)? avatarBuilder,
+  }) {
     return StoryCircle._(
       type: StoryType.cf,
       userName: userName,
       imageUrl: imageUrl,
       live: '',
+      avatarBuilder: avatarBuilder,
     );
   }
 
@@ -62,12 +73,14 @@ class StoryCircle extends StatelessWidget {
   factory StoryCircle.create({
     required String userName,
     required String imageUrl,
+    Widget Function(Widget avatar)? avatarBuilder,
   }) {
     return StoryCircle._(
       type: StoryType.create,
       userName: userName,
       imageUrl: imageUrl,
       live: '',
+      avatarBuilder: avatarBuilder,
     );
   }
 
@@ -111,20 +124,9 @@ class StoryCircle extends StatelessWidget {
                     child: Padding(
                       padding: const EdgeInsets.all(_ringGap),
                       child: ClipOval(
-                        child: imageUrl.isNotEmpty
-                            ? CachedNetworkImage(
-                                fadeInDuration: Duration.zero,
-                                fadeOutDuration: Duration.zero,
-                                imageUrl: imageUrl,
-                                width: _imageSize,
-                                height: _imageSize,
-                                fit: BoxFit.cover,
-                                errorWidget: (context, url, error) =>
-                                    const DefaultProfileAvatar(
-                                      size: _imageSize,
-                                    ),
-                              )
-                            : const DefaultProfileAvatar(size: _imageSize),
+                        child:
+                            avatarBuilder?.call(_buildAvatar()) ??
+                            _buildAvatar(),
                       ),
                     ),
                   ),
@@ -160,6 +162,22 @@ class StoryCircle extends StatelessWidget {
         return null;
     }
   }
+
+  Widget _buildAvatar() {
+    if (imageUrl.isEmpty) {
+      return const DefaultProfileAvatar(size: _imageSize);
+    }
+    return CachedNetworkImage(
+      fadeInDuration: Duration.zero,
+      fadeOutDuration: Duration.zero,
+      imageUrl: imageUrl,
+      width: _imageSize,
+      height: _imageSize,
+      fit: BoxFit.cover,
+      errorWidget: (context, url, error) =>
+          const DefaultProfileAvatar(size: _imageSize),
+    );
+  }
 }
 
 class _LiveBadge extends StatelessWidget {
diff --git a/lib/src/core/design_system/templates/chat_list_page_template.dart b/lib/src/core/design_system/templates/chat_list_page_template.dart
index 8faf9a03..0ab11854 100644
--- a/lib/src/core/design_system/templates/chat_list_page_template.dart
+++ b/lib/src/core/design_system/templates/chat_list_page_template.dart
@@ -13,6 +13,7 @@ class ChatListItemData {
     this.avatarUrl,
     this.verified = false,
     this.unread = false,
+    this.avatarBuilder,
   });
 
   final String? avatarUrl;
@@ -22,6 +23,7 @@ class ChatListItemData {
   final String preview;
   final bool verified;
   final bool unread;
+  final Widget Function(Widget avatar)? avatarBuilder;
 }
 
 class ChatListPageTemplate extends StatelessWidget {
@@ -34,6 +36,7 @@ class ChatListPageTemplate extends StatelessWidget {
     this.loadingItemCount = 8,
     this.onAddTap,
     this.onRefresh,
+    this.itemWrapper,
   });
 
   const ChatListPageTemplate.loading({
@@ -42,6 +45,7 @@ class ChatListPageTemplate extends StatelessWidget {
     this.loadingItemCount = 8,
     this.onAddTap,
     this.onRefresh,
+    this.itemWrapper,
   }) : items = const [],
        onItemTap = _noopItemTap,
        loading = true;
@@ -53,6 +57,8 @@ class ChatListPageTemplate extends StatelessWidget {
   final int loadingItemCount;
   final VoidCallback? onAddTap;
   final Future<void> Function()? onRefresh;
+  final Widget Function(BuildContext context, int index, Widget child)?
+  itemWrapper;
 
   @override
   Widget build(BuildContext context) {
@@ -86,10 +92,13 @@ class ChatListPageTemplate extends StatelessWidget {
                       padding: EdgeInsets.zero,
                       itemCount: items.length,
                       separatorBuilder: (_, _) => const SizedBox.shrink(),
-                      itemBuilder: (context, index) => _ChatTile(
-                        data: items[index],
-                        onTap: () => onItemTap(index),
-                      ),
+                      itemBuilder: (context, index) {
+                        final tile = _ChatTile(
+                          data: items[index],
+                          onTap: () => onItemTap(index),
+                        );
+                        return itemWrapper?.call(context, index, tile) ?? tile;
+                      },
                     ),
                   ),
           ),
@@ -110,16 +119,17 @@ class _ChatTile extends StatelessWidget {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final onSurface = theme.colorScheme.onSurface;
+    final avatar = UserAvatar(
+      imageUrl: data.avatarUrl ?? '',
+      username: data.handle,
+      size: 50.45,
+    );
 
     return ListTile(
       onTap: onTap,
       horizontalTitleGap: 12,
       contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-      leading: UserAvatar(
-        imageUrl: data.avatarUrl ?? '',
-        username: data.handle,
-        size: 50.45,
-      ),
+      leading: data.avatarBuilder?.call(avatar) ?? avatar,
       title: Row(
         children: [
           Expanded(
diff --git a/lib/src/core/design_system/templates/info_bar_template.dart b/lib/src/core/design_system/templates/info_bar_template.dart
index 02683340..f5848df5 100644
--- a/lib/src/core/design_system/templates/info_bar_template.dart
+++ b/lib/src/core/design_system/templates/info_bar_template.dart
@@ -23,6 +23,7 @@ class InfoBarTemplate extends StatefulWidget {
     this.altAvailable = false,
     this.onAltTap,
     this.avatarUrl,
+    this.avatarBuilder,
   });
 
   /// Display name
@@ -57,6 +58,7 @@ class InfoBarTemplate extends StatefulWidget {
 
   /// Avatar shown on left of the name/handle.
   final String? avatarUrl;
+  final Widget Function(Widget avatar)? avatarBuilder;
 
   @override
   State<InfoBarTemplate> createState() => _InfoBarTemplateState();
@@ -95,6 +97,7 @@ class _InfoBarTemplateState extends State<InfoBarTemplate>
                         displayName: widget.displayName,
                         size: 32,
                         onTap: widget.onAvatarTap ?? widget.onTitleTap,
+                        avatarBuilder: widget.avatarBuilder,
                       ),
                     ),
 
diff --git a/lib/src/core/design_system/templates/profile_page_template.dart b/lib/src/core/design_system/templates/profile_page_template.dart
index e25ef529..98930153 100644
--- a/lib/src/core/design_system/templates/profile_page_template.dart
+++ b/lib/src/core/design_system/templates/profile_page_template.dart
@@ -24,6 +24,7 @@ class ProfilePageTemplate extends StatelessWidget {
     required this.tabsWidget,
     super.key,
     this.avatarUrl,
+    this.avatarBuilder,
     this.description,
     this.links,
     this.knownFollowers,
@@ -58,6 +59,7 @@ class ProfilePageTemplate extends StatelessWidget {
   final String followersCount;
   final String followingCount;
   final String? avatarUrl;
+  final Widget Function(Widget avatar)? avatarBuilder;
   final String? description;
   final List<String>? links;
   final KnownFollowers? knownFollowers;
@@ -119,6 +121,7 @@ class ProfilePageTemplate extends StatelessWidget {
                     followersCount: followersCount,
                     followingCount: followingCount,
                     avatarUrl: avatarUrl,
+                    avatarBuilder: avatarBuilder,
                     description: description,
                     links: links,
                     knownFollowers: knownFollowers,
@@ -169,6 +172,7 @@ class _ProfileHeaderSection extends StatelessWidget {
     required this.isBlocking,
     required this.isEarlySupporter,
     this.avatarUrl,
+    this.avatarBuilder,
     this.description,
     this.links,
     this.knownFollowers,
@@ -190,6 +194,7 @@ class _ProfileHeaderSection extends StatelessWidget {
   final String followersCount;
   final String followingCount;
   final String? avatarUrl;
+  final Widget Function(Widget avatar)? avatarBuilder;
   final String? description;
   final List<String>? links;
   final KnownFollowers? knownFollowers;
@@ -211,6 +216,17 @@ class _ProfileHeaderSection extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
+    final avatar = ProfileAvatar(
+      avatarUrl: avatarUrl,
+      displayName: displayName,
+      hasStories: hasStories,
+      size: 80,
+      onTap: onAvatarTap,
+      showAddButton: isCurrentUser,
+      onAddTap: onAddStoryTap,
+      avatarBuilder: avatarBuilder,
+    );
+
     return Padding(
       padding: const EdgeInsets.all(16),
       child: Column(
@@ -219,17 +235,7 @@ class _ProfileHeaderSection extends StatelessWidget {
           Row(
             crossAxisAlignment: CrossAxisAlignment.start,
             children: [
-              Skeleton.keep(
-                child: ProfileAvatar(
-                  avatarUrl: avatarUrl,
-                  displayName: displayName,
-                  hasStories: hasStories,
-                  size: 80,
-                  onTap: onAvatarTap,
-                  showAddButton: isCurrentUser,
-                  onAddTap: onAddStoryTap,
-                ),
-              ),
+              Skeleton.keep(child: avatar),
               const SizedBox(width: 16),
               Expanded(
                 child: Column(
diff --git a/lib/src/core/l10n/app_localizations.dart b/lib/src/core/l10n/app_localizations.dart
index d29b8bf6..cd68a7cc 100644
--- a/lib/src/core/l10n/app_localizations.dart
+++ b/lib/src/core/l10n/app_localizations.dart
@@ -274,6 +274,12 @@ abstract class AppLocalizations {
   /// **'Settings'**
   String get pageTitleSettings;
 
+  /// Moderation settings page title
+  ///
+  /// In en, this message translates to:
+  /// **'Moderation'**
+  String get pageTitleModeration;
+
   /// Story manager page title
   ///
   /// In en, this message translates to:
@@ -1730,6 +1736,216 @@ abstract class AppLocalizations {
     int count,
   );
 
+  /// Heading over content concealed by moderation
+  ///
+  /// In en, this message translates to:
+  /// **'Content warning'**
+  String get moderationContentWarning;
+
+  /// Generic fallback for a labeler notice with no localized label strings
+  ///
+  /// In en, this message translates to:
+  /// **'Content notice'**
+  String get moderationContentNotice;
+
+  /// Button that reveals moderated content
+  ///
+  /// In en, this message translates to:
+  /// **'View content'**
+  String get buttonViewContent;
+
+  /// Button that opens moderation label details
+  ///
+  /// In en, this message translates to:
+  /// **'Why am I seeing this?'**
+  String get buttonModerationDetails;
+
+  /// Message for an imperative or age-gated moderation decision
+  ///
+  /// In en, this message translates to:
+  /// **'This restriction cannot be overridden.'**
+  String get moderationCannotOverride;
+
+  /// Title of the moderation details sheet
+  ///
+  /// In en, this message translates to:
+  /// **'Moderation details'**
+  String get moderationDetailsTitle;
+
+  /// Label before the DID of the labeler that applied a label
+  ///
+  /// In en, this message translates to:
+  /// **'Applied by'**
+  String get moderationAppliedBy;
+
+  /// Label before a moderation label expiration timestamp
+  ///
+  /// In en, this message translates to:
+  /// **'Expires'**
+  String get moderationExpires;
+
+  /// Button for appealing a moderation label applied to the current user
+  ///
+  /// In en, this message translates to:
+  /// **'Appeal label'**
+  String get buttonAppealLabel;
+
+  /// Default text sent with a label appeal
+  ///
+  /// In en, this message translates to:
+  /// **'I am appealing this label.'**
+  String get moderationAppealReason;
+
+  /// Confirmation after a moderation label appeal succeeds
+  ///
+  /// In en, this message translates to:
+  /// **'Appeal sent'**
+  String get moderationAppealSent;
+
+  /// Error after a moderation label appeal fails
+  ///
+  /// In en, this message translates to:
+  /// **'Could not send the appeal'**
+  String get moderationAppealFailed;
+
+  /// Settings toggle for allowing configurable adult-only labels
+  ///
+  /// In en, this message translates to:
+  /// **'Show adult content'**
+  String get settingAdultContent;
+
+  /// Explanation for the adult content setting
+  ///
+  /// In en, this message translates to:
+  /// **'When off, adult-only labels are hidden and cannot be overridden.'**
+  String get settingAdultContentDescription;
+
+  /// Moderation preference that shows labeled content
+  ///
+  /// In en, this message translates to:
+  /// **'Show'**
+  String get labelShow;
+
+  /// Moderation preference that turns off treatment for a label
+  ///
+  /// In en, this message translates to:
+  /// **'Off'**
+  String get labelOff;
+
+  /// Moderation preference that warns before showing labeled content
+  ///
+  /// In en, this message translates to:
+  /// **'Warn'**
+  String get labelWarn;
+
+  /// Moderation preference that shows an informational badge on labeled content
+  ///
+  /// In en, this message translates to:
+  /// **'Badge'**
+  String get labelBadge;
+
+  /// Moderation preference that hides labeled content
+  ///
+  /// In en, this message translates to:
+  /// **'Hide'**
+  String get labelHide;
+
+  /// Explanation for a global label shown on a labeler settings page
+  ///
+  /// In en, this message translates to:
+  /// **'Configured in Moderation settings.'**
+  String get moderationConfiguredGlobally;
+
+  /// Name of the built-in porn moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Adult Content'**
+  String get moderationLabelPornName;
+
+  /// Description of the built-in porn moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Explicit sexual images.'**
+  String get moderationLabelPornDescription;
+
+  /// Name of the built-in sexually suggestive moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Sexually Suggestive'**
+  String get moderationLabelSexualName;
+
+  /// Description of the built-in sexually suggestive moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Does not include nudity.'**
+  String get moderationLabelSexualDescription;
+
+  /// Name of the built-in non-sexual nudity moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Non-sexual Nudity'**
+  String get moderationLabelNudityName;
+
+  /// Description of the built-in non-sexual nudity moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'For example, artistic nudes.'**
+  String get moderationLabelNudityDescription;
+
+  /// Name of the built-in graphic media moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Graphic Media'**
+  String get moderationLabelGraphicMediaName;
+
+  /// Description of the built-in graphic media moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Explicit or potentially disturbing media.'**
+  String get moderationLabelGraphicMediaDescription;
+
+  /// Name of the built-in gore moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Gore'**
+  String get moderationLabelGoreName;
+
+  /// Description of the built-in gore moderation label
+  ///
+  /// In en, this message translates to:
+  /// **'Graphic depictions of severe injury, blood, or death.'**
+  String get moderationLabelGoreDescription;
+
+  /// Error shown when a labeler cannot be resolved, validated, or saved
+  ///
+  /// In en, this message translates to:
+  /// **'Could not add that labeler. Check the DID or handle and try again.'**
+  String get errorAddingLabeler;
+
+  /// Label for choosing the service that receives a moderation report
+  ///
+  /// In en, this message translates to:
+  /// **'Moderation service'**
+  String get moderationService;
+
+  /// Fallback name for the app's default moderation service
+  ///
+  /// In en, this message translates to:
+  /// **'Default moderation service'**
+  String get moderationDefaultService;
+
+  /// Message when no subscribed moderation service supports a report
+  ///
+  /// In en, this message translates to:
+  /// **'None of your moderation services accepts this type of report.'**
+  String get moderationNoCompatibleService;
+
+  /// Error shown when compatible moderation services cannot be loaded
+  ///
+  /// In en, this message translates to:
+  /// **'Could not load moderation services.'**
+  String get moderationServiceLoadFailed;
+
   /// Send button text
   ///
   /// In en, this message translates to:
diff --git a/lib/src/core/l10n/app_localizations_en.dart b/lib/src/core/l10n/app_localizations_en.dart
index e305c7b0..2971881e 100644
--- a/lib/src/core/l10n/app_localizations_en.dart
+++ b/lib/src/core/l10n/app_localizations_en.dart
@@ -98,6 +98,9 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get pageTitleSettings => 'Settings';
 
+  @override
+  String get pageTitleModeration => 'Moderation';
+
   @override
   String get pageTitleStoryManager => 'Story Manager';
 
@@ -964,6 +967,119 @@ class AppLocalizationsEn extends AppLocalizations {
     return 'Followed by $firstName, $secondName, and $_temp0';
   }
 
+  @override
+  String get moderationContentWarning => 'Content warning';
+
+  @override
+  String get moderationContentNotice => 'Content notice';
+
+  @override
+  String get buttonViewContent => 'View content';
+
+  @override
+  String get buttonModerationDetails => 'Why am I seeing this?';
+
+  @override
+  String get moderationCannotOverride =>
+      'This restriction cannot be overridden.';
+
+  @override
+  String get moderationDetailsTitle => 'Moderation details';
+
+  @override
+  String get moderationAppliedBy => 'Applied by';
+
+  @override
+  String get moderationExpires => 'Expires';
+
+  @override
+  String get buttonAppealLabel => 'Appeal label';
+
+  @override
+  String get moderationAppealReason => 'I am appealing this label.';
+
+  @override
+  String get moderationAppealSent => 'Appeal sent';
+
+  @override
+  String get moderationAppealFailed => 'Could not send the appeal';
+
+  @override
+  String get settingAdultContent => 'Show adult content';
+
+  @override
+  String get settingAdultContentDescription =>
+      'When off, adult-only labels are hidden and cannot be overridden.';
+
+  @override
+  String get labelShow => 'Show';
+
+  @override
+  String get labelOff => 'Off';
+
+  @override
+  String get labelWarn => 'Warn';
+
+  @override
+  String get labelBadge => 'Badge';
+
+  @override
+  String get labelHide => 'Hide';
+
+  @override
+  String get moderationConfiguredGlobally =>
+      'Configured in Moderation settings.';
+
+  @override
+  String get moderationLabelPornName => 'Adult Content';
+
+  @override
+  String get moderationLabelPornDescription => 'Explicit sexual images.';
+
+  @override
+  String get moderationLabelSexualName => 'Sexually Suggestive';
+
+  @override
+  String get moderationLabelSexualDescription => 'Does not include nudity.';
+
+  @override
+  String get moderationLabelNudityName => 'Non-sexual Nudity';
+
+  @override
+  String get moderationLabelNudityDescription => 'For example, artistic nudes.';
+
+  @override
+  String get moderationLabelGraphicMediaName => 'Graphic Media';
+
+  @override
+  String get moderationLabelGraphicMediaDescription =>
+      'Explicit or potentially disturbing media.';
+
+  @override
+  String get moderationLabelGoreName => 'Gore';
+
+  @override
+  String get moderationLabelGoreDescription =>
+      'Graphic depictions of severe injury, blood, or death.';
+
+  @override
+  String get errorAddingLabeler =>
+      'Could not add that labeler. Check the DID or handle and try again.';
+
+  @override
+  String get moderationService => 'Moderation service';
+
+  @override
+  String get moderationDefaultService => 'Default moderation service';
+
+  @override
+  String get moderationNoCompatibleService =>
+      'None of your moderation services accepts this type of report.';
+
+  @override
+  String get moderationServiceLoadFailed =>
+      'Could not load moderation services.';
+
   @override
   String get buttonSend => 'Send';
 }
diff --git a/lib/src/core/l10n/intl_en.arb b/lib/src/core/l10n/intl_en.arb
index 4e955acc..b33fbf65 100644
--- a/lib/src/core/l10n/intl_en.arb
+++ b/lib/src/core/l10n/intl_en.arb
@@ -152,6 +152,11 @@
     "description": "Settings page title"
   },
 
+  "pageTitleModeration": "Moderation",
+  "@pageTitleModeration": {
+    "description": "Moderation settings page title"
+  },
+
   "pageTitleStoryManager": "Story Manager",
   "@pageTitleStoryManager": {
     "description": "Story manager page title"
@@ -1503,6 +1508,147 @@
     }
   },
 
+  "moderationContentWarning": "Content warning",
+  "@moderationContentWarning": {
+    "description": "Heading over content concealed by moderation"
+  },
+  "moderationContentNotice": "Content notice",
+  "@moderationContentNotice": {
+    "description": "Generic fallback for a labeler notice with no localized label strings"
+  },
+  "buttonViewContent": "View content",
+  "@buttonViewContent": {
+    "description": "Button that reveals moderated content"
+  },
+  "buttonModerationDetails": "Why am I seeing this?",
+  "@buttonModerationDetails": {
+    "description": "Button that opens moderation label details"
+  },
+  "moderationCannotOverride": "This restriction cannot be overridden.",
+  "@moderationCannotOverride": {
+    "description": "Message for an imperative or age-gated moderation decision"
+  },
+  "moderationDetailsTitle": "Moderation details",
+  "@moderationDetailsTitle": {
+    "description": "Title of the moderation details sheet"
+  },
+  "moderationAppliedBy": "Applied by",
+  "@moderationAppliedBy": {
+    "description": "Label before the DID of the labeler that applied a label"
+  },
+  "moderationExpires": "Expires",
+  "@moderationExpires": {
+    "description": "Label before a moderation label expiration timestamp"
+  },
+  "buttonAppealLabel": "Appeal label",
+  "@buttonAppealLabel": {
+    "description": "Button for appealing a moderation label applied to the current user"
+  },
+  "moderationAppealReason": "I am appealing this label.",
+  "@moderationAppealReason": {
+    "description": "Default text sent with a label appeal"
+  },
+  "moderationAppealSent": "Appeal sent",
+  "@moderationAppealSent": {
+    "description": "Confirmation after a moderation label appeal succeeds"
+  },
+  "moderationAppealFailed": "Could not send the appeal",
+  "@moderationAppealFailed": {
+    "description": "Error after a moderation label appeal fails"
+  },
+  "settingAdultContent": "Show adult content",
+  "@settingAdultContent": {
+    "description": "Settings toggle for allowing configurable adult-only labels"
+  },
+  "settingAdultContentDescription": "When off, adult-only labels are hidden and cannot be overridden.",
+  "@settingAdultContentDescription": {
+    "description": "Explanation for the adult content setting"
+  },
+  "labelShow": "Show",
+  "@labelShow": {
+    "description": "Moderation preference that shows labeled content"
+  },
+  "labelOff": "Off",
+  "@labelOff": {
+    "description": "Moderation preference that turns off treatment for a label"
+  },
+  "labelWarn": "Warn",
+  "@labelWarn": {
+    "description": "Moderation preference that warns before showing labeled content"
+  },
+  "labelBadge": "Badge",
+  "@labelBadge": {
+    "description": "Moderation preference that shows an informational badge on labeled content"
+  },
+  "labelHide": "Hide",
+  "@labelHide": {
+    "description": "Moderation preference that hides labeled content"
+  },
+  "moderationConfiguredGlobally": "Configured in Moderation settings.",
+  "@moderationConfiguredGlobally": {
+    "description": "Explanation for a global label shown on a labeler settings page"
+  },
+  "moderationLabelPornName": "Adult Content",
+  "@moderationLabelPornName": {
+    "description": "Name of the built-in porn moderation label"
+  },
+  "moderationLabelPornDescription": "Explicit sexual images.",
+  "@moderationLabelPornDescription": {
+    "description": "Description of the built-in porn moderation label"
+  },
+  "moderationLabelSexualName": "Sexually Suggestive",
+  "@moderationLabelSexualName": {
+    "description": "Name of the built-in sexually suggestive moderation label"
+  },
+  "moderationLabelSexualDescription": "Does not include nudity.",
+  "@moderationLabelSexualDescription": {
+    "description": "Description of the built-in sexually suggestive moderation label"
+  },
+  "moderationLabelNudityName": "Non-sexual Nudity",
+  "@moderationLabelNudityName": {
+    "description": "Name of the built-in non-sexual nudity moderation label"
+  },
+  "moderationLabelNudityDescription": "For example, artistic nudes.",
+  "@moderationLabelNudityDescription": {
+    "description": "Description of the built-in non-sexual nudity moderation label"
+  },
+  "moderationLabelGraphicMediaName": "Graphic Media",
+  "@moderationLabelGraphicMediaName": {
+    "description": "Name of the built-in graphic media moderation label"
+  },
+  "moderationLabelGraphicMediaDescription": "Explicit or potentially disturbing media.",
+  "@moderationLabelGraphicMediaDescription": {
+    "description": "Description of the built-in graphic media moderation label"
+  },
+  "moderationLabelGoreName": "Gore",
+  "@moderationLabelGoreName": {
+    "description": "Name of the built-in gore moderation label"
+  },
+  "moderationLabelGoreDescription": "Graphic depictions of severe injury, blood, or death.",
+  "@moderationLabelGoreDescription": {
+    "description": "Description of the built-in gore moderation label"
+  },
+  "errorAddingLabeler": "Could not add that labeler. Check the DID or handle and try again.",
+  "@errorAddingLabeler": {
+    "description": "Error shown when a labeler cannot be resolved, validated, or saved"
+  },
+  "moderationService": "Moderation service",
+  "@moderationService": {
+    "description": "Label for choosing the service that receives a moderation report"
+  },
+  "moderationDefaultService": "Default moderation service",
+  "@moderationDefaultService": {
+    "description": "Fallback name for the app's default moderation service"
+  },
+  "moderationNoCompatibleService": "None of your moderation services accepts this type of report.",
+  "@moderationNoCompatibleService": {
+    "description": "Message when no subscribed moderation service supports a report"
+  },
+  "moderationServiceLoadFailed": "Could not load moderation services.",
+  "@moderationServiceLoadFailed": {
+    "description": "Error shown when compatible moderation services cannot be loaded"
+  },
+
   "buttonSend": "Send",
   "@buttonSend": {
     "description": "Send button text"
diff --git a/lib/src/core/moderation/feed_generator_moderation.dart b/lib/src/core/moderation/feed_generator_moderation.dart
new file mode 100644
index 00000000..5755a7d2
--- /dev/null
+++ b/lib/src/core/moderation/feed_generator_moderation.dart
@@ -0,0 +1,10 @@
+import 'package:spark/src/core/moderation/moderation_subject.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+
+ModerationSubject feedGeneratorModerationSubject(GeneratorView generator) {
+  return ModerationSubject.content(
+    labels: generator.labels ?? const [],
+    authorLabels: generator.creator.labels ?? const [],
+    subjectDid: generator.creator.did,
+  );
+}
diff --git a/lib/src/core/moderation/moderated_content.dart b/lib/src/core/moderation/moderated_content.dart
new file mode 100644
index 00000000..e02c7f8a
--- /dev/null
+++ b/lib/src/core/moderation/moderated_content.dart
@@ -0,0 +1,141 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation_details_sheet.dart';
+import 'package:spark/src/core/moderation/moderation_engine.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+import 'package:spark/src/core/moderation/moderation_presentation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/moderation/moderation_subject.dart';
+
+/// Applies the same moderation decision and reveal rules to every surface.
+class ModeratedContent extends ConsumerStatefulWidget {
+  const ModeratedContent({
+    required this.subject,
+    required this.context,
+    required this.child,
+    super.key,
+    this.presentation = const ModerationPresentation.standard(),
+    this.filterReplacement = const SizedBox.shrink(),
+    this.onConcealChanged,
+  });
+
+  final ModerationSubject subject;
+  final ModerationContext context;
+  final Widget child;
+  final ModerationPresentation presentation;
+  final Widget filterReplacement;
+  final ValueChanged<bool>? onConcealChanged;
+
+  @override
+  ConsumerState<ModeratedContent> createState() => _ModeratedContentState();
+}
+
+class ModeratedProfileAvatar extends StatelessWidget {
+  const ModeratedProfileAvatar({
+    required this.labels,
+    required this.subjectDid,
+    required this.child,
+    super.key,
+  });
+
+  final List<Label> labels;
+  final String subjectDid;
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return ClipOval(
+      child: ModeratedContent(
+        subject: ModerationSubject.profile(
+          labels: labels,
+          subjectDid: subjectDid,
+        ),
+        context: ModerationContext.avatar,
+        presentation: const ModerationPresentation.compact(),
+        child: child,
+      ),
+    );
+  }
+}
+
+class _ModeratedContentState extends ConsumerState<ModeratedContent> {
+  String? _revealedKey;
+  bool? _lastConcealed;
+
+  @override
+  Widget build(BuildContext context) {
+    if (!widget.subject.hasLabels) {
+      _notifyConcealed(false);
+      return widget.child;
+    }
+
+    final engineState = ref.watch(moderationEngineProvider);
+    final engine = engineState.asData?.value;
+    if (engine == null) {
+      _notifyConcealed(true);
+      return ModerationPending(
+        hasError: engineState.hasError,
+        onRetry: () => ref.invalidate(moderationEngineProvider),
+        child: widget.child,
+      );
+    }
+
+    final locale = Localizations.localeOf(context).toLanguageTag();
+    final decision = widget.subject.evaluate(
+      engine,
+      preferredLocales: [locale],
+    );
+    final ui = decision.forContext(widget.context);
+    if (ui.filter) {
+      _notifyConcealed(true);
+      return widget.filterReplacement;
+    }
+    if (!ui.blur && !ui.alert && !ui.inform) {
+      _notifyConcealed(false);
+      return widget.child;
+    }
+
+    final causes = <ModerationCause>{
+      ...ui.blurs,
+      ...ui.alerts,
+      ...ui.informs,
+    }.toList();
+    final disclosureKey = widget.subject.disclosureKey(widget.context);
+    final concealed =
+        ui.blur && (ui.noOverride || _revealedKey != disclosureKey);
+    _notifyConcealed(concealed);
+
+    return widget.presentation.render(
+      child: widget.child,
+      concealed: concealed,
+      ui: ui,
+      causes: causes,
+      reveal: () => setState(() => _revealedKey = disclosureKey),
+      showDetails: () => _showDetails(decision, causes),
+    );
+  }
+
+  Future<void> _showDetails(
+    ModerationDecision decision,
+    List<ModerationCause> causes,
+  ) async {
+    await showModalBottomSheet<void>(
+      context: context,
+      showDragHandle: true,
+      isScrollControlled: true,
+      builder: (context) => ModerationDetailsSheet(
+        causes: causes,
+        mayAppeal: decision.isSubjectCurrentUser,
+      ),
+    );
+  }
+
+  void _notifyConcealed(bool concealed) {
+    if (_lastConcealed == concealed) return;
+    _lastConcealed = concealed;
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (mounted) widget.onConcealChanged?.call(concealed);
+    });
+  }
+}
diff --git a/lib/src/core/moderation/moderation.dart b/lib/src/core/moderation/moderation.dart
new file mode 100644
index 00000000..9595b822
--- /dev/null
+++ b/lib/src/core/moderation/moderation.dart
@@ -0,0 +1,8 @@
+export 'feed_generator_moderation.dart';
+export 'moderation_definitions.dart';
+export 'moderation_engine.dart';
+export 'moderation_label_events.dart';
+export 'moderation_label_localizations.dart';
+export 'moderation_models.dart';
+export 'moderation_presentation.dart';
+export 'moderation_subject.dart';
diff --git a/lib/src/core/moderation/moderation_appeal_service.dart b/lib/src/core/moderation/moderation_appeal_service.dart
new file mode 100644
index 00000000..8f058afe
--- /dev/null
+++ b/lib/src/core/moderation/moderation_appeal_service.dart
@@ -0,0 +1,69 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/admin/defs.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
+import 'package:poptart_lex/com/atproto/moderation/defs.dart';
+import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+
+final moderationAppealServiceProvider = Provider<ModerationAppealService>(
+  (ref) => ModerationAppealService(GetIt.I<SprkRepository>()),
+);
+
+final class ModerationAppealService {
+  const ModerationAppealService(this._repository);
+
+  final SprkRepository _repository;
+
+  static bool canAppeal(Label label) {
+    return label.src != _subjectDid(label) &&
+        label.src.startsWith('did:') &&
+        _reportSubject(label) != null;
+  }
+
+  Future<void> appeal(Label label, {required String reason}) async {
+    final subject = _reportSubject(label);
+    if (subject == null) return;
+
+    await _repository.repo.createReport(
+      input: ModerationCreateReportInput(
+        subject: subject,
+        reasonType: const ReasonType.knownValue(
+          data: KnownReasonType.comAtprotoModerationDefsReasonAppeal,
+        ),
+        reason: reason,
+      ),
+      serviceDid: label.src,
+    );
+  }
+}
+
+UModerationCreateReportSubject? _reportSubject(Label label) {
+  AtUri? uri;
+  try {
+    uri = AtUri.parse(label.uri);
+  } catch (_) {
+    return null;
+  }
+  if (uri.pathname.isEmpty) {
+    return UModerationCreateReportSubject.repoRef(
+      data: RepoRef(did: uri.hostname),
+    );
+  }
+  if (label.cid?.isNotEmpty ?? false) {
+    return UModerationCreateReportSubject.repoStrongRef(
+      data: RepoStrongRef(uri: uri, cid: label.cid!),
+    );
+  }
+  return null;
+}
+
+String _subjectDid(Label label) {
+  try {
+    return AtUri.parse(label.uri).hostname;
+  } catch (_) {
+    return label.uri;
+  }
+}
diff --git a/lib/src/core/moderation/moderation_definitions.dart b/lib/src/core/moderation/moderation_definitions.dart
new file mode 100644
index 00000000..63249c05
--- /dev/null
+++ b/lib/src/core/moderation/moderation_definitions.dart
@@ -0,0 +1,365 @@
+import 'dart:collection';
+
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+final class ModerationLabelDefinitions {
+  factory ModerationLabelDefinitions({
+    Iterable<ModerationLabelDefinition> definitions = const [],
+    bool includeBuiltIns = true,
+  }) {
+    final items = definitions.toList(growable: false);
+    return ModerationLabelDefinitions._(
+      definitions: items,
+      configuredLabelerDids: items
+          .map((definition) => definition.definedBy)
+          .nonNulls,
+      includeBuiltIns: includeBuiltIns,
+    );
+  }
+
+  ModerationLabelDefinitions._({
+    required Iterable<ModerationLabelDefinition> definitions,
+    required Iterable<String> configuredLabelerDids,
+    required bool includeBuiltIns,
+  }) {
+    final all = <ModerationLabelDefinition>[
+      if (includeBuiltIns) ...builtInLabelDefinitions,
+      ...definitions,
+    ];
+    final global = {
+      for (final definition in all.where((item) => item.definedBy == null))
+        definition.identifier: definition,
+    };
+    // Imperative meanings are protocol behavior, not labeler policy. Keep
+    // them authoritative even if a caller accidentally supplies a same-named
+    // global definition.
+    if (includeBuiltIns) {
+      for (final definition in builtInLabelDefinitions.where(
+        (item) => item.identifier.startsWith('!'),
+      )) {
+        global[definition.identifier] = definition;
+      }
+    }
+    _global = UnmodifiableMapView(global);
+    _bySource = UnmodifiableMapView({
+      for (final source in all.map((item) => item.definedBy).nonNulls.toSet())
+        source: UnmodifiableMapView({
+          for (final definition in all.where(
+            (item) => item.definedBy == source,
+          ))
+            definition.identifier: definition,
+        }),
+    });
+    _configuredLabelerDids = Set.unmodifiable(configuredLabelerDids);
+  }
+
+  factory ModerationLabelDefinitions.fromLabelers(
+    Map<String, Iterable<LabelValueDefinition>> definitionsByLabeler, {
+    bool includeBuiltIns = true,
+  }) {
+    return ModerationLabelDefinitions._(
+      includeBuiltIns: includeBuiltIns,
+      configuredLabelerDids: definitionsByLabeler.keys,
+      definitions: [
+        for (final entry in definitionsByLabeler.entries)
+          for (final definition in entry.value)
+            interpretLabelValueDefinition(definition, definedBy: entry.key),
+      ],
+    );
+  }
+
+  late final Map<String, ModerationLabelDefinition> _global;
+  late final Map<String, Map<String, ModerationLabelDefinition>> _bySource;
+  late final Set<String> _configuredLabelerDids;
+
+  Map<String, ModerationLabelDefinition> get global => _global;
+
+  Map<String, Map<String, ModerationLabelDefinition>> get bySource => _bySource;
+
+  bool isConfiguredSource(String did) => _configuredLabelerDids.contains(did);
+
+  ModerationLabelDefinition? lookup(Label label) {
+    if (label.val.startsWith('!')) return _global[label.val];
+    return _bySource[label.src]?[label.val] ?? _global[label.val];
+  }
+
+  ModerationLabelDefinition? lookupSelfLabel(
+    Label label, {
+    required String? labelerDid,
+  }) {
+    if (label.val.startsWith('!')) return _global[label.val];
+
+    // Only protocol-supported global values may be self-applied. For those
+    // values, use the configured labeler's metadata when it is available.
+    if (!globalAdultContentLabelValues.contains(label.val)) return null;
+    final builtIn = _global[label.val];
+    if (builtIn == null) return null;
+    return _bySource[labelerDid]?[label.val] ?? builtIn;
+  }
+}
+
+ModerationLabelDefinition interpretLabelValueDefinition(
+  LabelValueDefinition definition, {
+  required String definedBy,
+}) {
+  final severity = switch (definition.severity.toJson()) {
+    'alert' => ModerationSeverity.alert,
+    'inform' => ModerationSeverity.inform,
+    _ => ModerationSeverity.none,
+  };
+  final blurs = switch (definition.blurs.toJson()) {
+    'content' => ModerationBlur.content,
+    'media' => ModerationBlur.media,
+    _ => ModerationBlur.none,
+  };
+  final defaultSetting = switch (definition.defaultSetting?.toJson()) {
+    'hide' => ModerationSetting.hide,
+    'ignore' => ModerationSetting.ignore,
+    _ => ModerationSetting.warn,
+  };
+  final flags = <ModerationLabelFlag>{ModerationLabelFlag.noSelf};
+  if (definition.adultOnly ?? false) flags.add(ModerationLabelFlag.adult);
+
+  return ModerationLabelDefinition(
+    identifier: definition.identifier,
+    definedBy: definedBy,
+    severity: severity,
+    blurs: blurs,
+    defaultSetting: defaultSetting,
+    configurable: true,
+    flags: flags,
+    locales: definition.locales.map(ModerationLabelStrings.fromLexicon),
+    behaviors: _definitionBehaviors(
+      severity: severity,
+      blurs: blurs,
+      adultOnly: definition.adultOnly ?? false,
+    ),
+  );
+}
+
+final List<ModerationLabelDefinition>
+builtInLabelDefinitions = List.unmodifiable([
+  _imperativeDefinition(
+    identifier: '!hide',
+    defaultSetting: ModerationSetting.hide,
+    flags: const {ModerationLabelFlag.noOverride, ModerationLabelFlag.noSelf},
+  ),
+  _imperativeDefinition(
+    identifier: '!takedown',
+    defaultSetting: ModerationSetting.hide,
+    flags: const {ModerationLabelFlag.noOverride, ModerationLabelFlag.noSelf},
+  ),
+  _imperativeDefinition(
+    identifier: '!warn',
+    defaultSetting: ModerationSetting.warn,
+    flags: const {ModerationLabelFlag.noSelf},
+  ),
+  _imperativeDefinition(
+    identifier: '!no-unauthenticated',
+    defaultSetting: ModerationSetting.hide,
+    flags: const {
+      ModerationLabelFlag.noOverride,
+      ModerationLabelFlag.unauthenticated,
+    },
+  ),
+  ModerationLabelDefinition(
+    identifier: '!no-promote',
+    severity: ModerationSeverity.none,
+    blurs: ModerationBlur.none,
+    defaultSetting: ModerationSetting.hide,
+    configurable: false,
+    flags: const {ModerationLabelFlag.noPromote, ModerationLabelFlag.noSelf},
+    locales: const [],
+    behaviors: const {},
+  ),
+  _mediaDefinition(
+    identifier: 'porn',
+    defaultSetting: ModerationSetting.hide,
+    adultOnly: true,
+  ),
+  _mediaDefinition(
+    identifier: 'sexual',
+    defaultSetting: ModerationSetting.warn,
+    adultOnly: true,
+  ),
+  _mediaDefinition(
+    identifier: 'nudity',
+    defaultSetting: ModerationSetting.ignore,
+  ),
+  _mediaDefinition(
+    identifier: 'graphic-media',
+    defaultSetting: ModerationSetting.warn,
+    adultOnly: true,
+  ),
+  _mediaDefinition(
+    identifier: 'gore',
+    defaultSetting: ModerationSetting.warn,
+    adultOnly: true,
+  ),
+  _contentDefinition(
+    identifier: 'nsfl',
+    defaultSetting: ModerationSetting.warn,
+    adultOnly: true,
+  ),
+  _contentDefinition(
+    identifier: 'dmca-violation',
+    defaultSetting: ModerationSetting.hide,
+  ),
+  _contentDefinition(
+    identifier: 'doxxing',
+    defaultSetting: ModerationSetting.warn,
+  ),
+]);
+
+final Map<String, ModerationLabelDefinition> builtInLabelDefinitionsByValue =
+    UnmodifiableMapView({
+      for (final definition in builtInLabelDefinitions)
+        definition.identifier: definition,
+    });
+
+ModerationLabelDefinition _imperativeDefinition({
+  required String identifier,
+  required ModerationSetting defaultSetting,
+  required Set<ModerationLabelFlag> flags,
+}) {
+  final profileBlurred = ModerationBehavior({
+    ModerationContext.profileList: ModerationAction.blur,
+    ModerationContext.profileView: ModerationAction.blur,
+    ModerationContext.avatar: ModerationAction.blur,
+    ModerationContext.banner: ModerationAction.blur,
+    ModerationContext.displayName: ModerationAction.blur,
+  });
+  final contentBlurred = ModerationBehavior({
+    ModerationContext.contentList: ModerationAction.blur,
+    ModerationContext.contentView: ModerationAction.blur,
+    ModerationContext.contentMedia: ModerationAction.blur,
+  });
+  final accountBlurred = ModerationBehavior({
+    ...profileBlurred.actions,
+    ...contentBlurred.actions,
+  });
+  return ModerationLabelDefinition(
+    identifier: identifier,
+    severity: identifier == '!warn'
+        ? ModerationSeverity.none
+        : ModerationSeverity.alert,
+    blurs: ModerationBlur.content,
+    defaultSetting: defaultSetting,
+    configurable: false,
+    flags: flags,
+    locales: const [],
+    behaviors: {
+      ModerationTarget.account: accountBlurred,
+      ModerationTarget.profile: profileBlurred,
+      ModerationTarget.content: contentBlurred,
+    },
+  );
+}
+
+ModerationLabelDefinition _mediaDefinition({
+  required String identifier,
+  required ModerationSetting defaultSetting,
+  bool adultOnly = false,
+}) {
+  return ModerationLabelDefinition(
+    identifier: identifier,
+    severity: ModerationSeverity.none,
+    blurs: ModerationBlur.media,
+    defaultSetting: defaultSetting,
+    configurable: true,
+    flags: {if (adultOnly) ModerationLabelFlag.adult},
+    locales: const [],
+    behaviors: _definitionBehaviors(
+      severity: ModerationSeverity.none,
+      blurs: ModerationBlur.media,
+      adultOnly: adultOnly,
+    ),
+  );
+}
+
+ModerationLabelDefinition _contentDefinition({
+  required String identifier,
+  required ModerationSetting defaultSetting,
+  bool adultOnly = false,
+}) {
+  return ModerationLabelDefinition(
+    identifier: identifier,
+    severity: ModerationSeverity.alert,
+    blurs: ModerationBlur.content,
+    defaultSetting: defaultSetting,
+    configurable: true,
+    flags: {if (adultOnly) ModerationLabelFlag.adult},
+    locales: const [],
+    behaviors: _definitionBehaviors(
+      severity: ModerationSeverity.alert,
+      blurs: ModerationBlur.content,
+      adultOnly: adultOnly,
+    ),
+  );
+}
+
+Map<ModerationTarget, ModerationBehavior> _definitionBehaviors({
+  required ModerationSeverity severity,
+  required ModerationBlur blurs,
+  required bool adultOnly,
+}) {
+  final notice = switch (severity) {
+    ModerationSeverity.alert => ModerationAction.alert,
+    ModerationSeverity.inform => ModerationAction.inform,
+    ModerationSeverity.none => null,
+  };
+  final account = <ModerationContext, ModerationAction>{};
+  final profile = <ModerationContext, ModerationAction>{};
+  final content = <ModerationContext, ModerationAction>{};
+
+  switch (blurs) {
+    case ModerationBlur.content:
+      if (notice != null) {
+        account[ModerationContext.profileList] = notice;
+        account[ModerationContext.profileView] = notice;
+        profile[ModerationContext.profileList] = notice;
+        profile[ModerationContext.profileView] = notice;
+      }
+      account[ModerationContext.contentList] = ModerationAction.blur;
+      content[ModerationContext.contentList] = ModerationAction.blur;
+      if (adultOnly) {
+        account[ModerationContext.contentView] = ModerationAction.blur;
+        content[ModerationContext.contentView] = ModerationAction.blur;
+      } else if (notice != null) {
+        account[ModerationContext.contentView] = notice;
+        content[ModerationContext.contentView] = notice;
+      }
+    case ModerationBlur.media:
+      if (notice != null) {
+        account[ModerationContext.profileList] = notice;
+        account[ModerationContext.profileView] = notice;
+        profile[ModerationContext.profileList] = notice;
+        profile[ModerationContext.profileView] = notice;
+      }
+      account[ModerationContext.avatar] = ModerationAction.blur;
+      account[ModerationContext.banner] = ModerationAction.blur;
+      profile[ModerationContext.avatar] = ModerationAction.blur;
+      profile[ModerationContext.banner] = ModerationAction.blur;
+      content[ModerationContext.contentMedia] = ModerationAction.blur;
+      account[ModerationContext.contentView] = ModerationAction.blur;
+      content[ModerationContext.contentView] = ModerationAction.blur;
+    case ModerationBlur.none:
+      if (notice != null) {
+        account[ModerationContext.profileList] = notice;
+        account[ModerationContext.profileView] = notice;
+        account[ModerationContext.contentList] = notice;
+        account[ModerationContext.contentView] = notice;
+        profile[ModerationContext.profileList] = notice;
+        profile[ModerationContext.profileView] = notice;
+        content[ModerationContext.contentList] = notice;
+        content[ModerationContext.contentView] = notice;
+      }
+  }
+
+  return {
+    ModerationTarget.account: ModerationBehavior(account),
+    ModerationTarget.profile: ModerationBehavior(profile),
+    ModerationTarget.content: ModerationBehavior(content),
+  };
+}
diff --git a/lib/src/core/moderation/moderation_details_sheet.dart b/lib/src/core/moderation/moderation_details_sheet.dart
new file mode 100644
index 00000000..80db9cc9
--- /dev/null
+++ b/lib/src/core/moderation/moderation_details_sheet.dart
@@ -0,0 +1,107 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation_appeal_service.dart';
+import 'package:spark/src/core/moderation/moderation_label_localizations.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+class ModerationDetailsSheet extends ConsumerStatefulWidget {
+  const ModerationDetailsSheet({
+    required this.causes,
+    required this.mayAppeal,
+    super.key,
+  });
+
+  final List<ModerationCause> causes;
+  final bool mayAppeal;
+
+  @override
+  ConsumerState<ModerationDetailsSheet> createState() =>
+      _ModerationDetailsSheetState();
+}
+
+class _ModerationDetailsSheetState
+    extends ConsumerState<ModerationDetailsSheet> {
+  bool _submitting = false;
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context);
+    return SafeArea(
+      child: ListView(
+        shrinkWrap: true,
+        padding: const EdgeInsets.fromLTRB(20, 0, 20, 24),
+        children: [
+          Text(
+            l10n.moderationDetailsTitle,
+            style: Theme.of(context).textTheme.titleLarge,
+          ),
+          const SizedBox(height: 12),
+          for (final cause in widget.causes)
+            Card(
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      cause.localizedStrings(l10n)?.name ??
+                          l10n.moderationContentNotice,
+                      style: Theme.of(context).textTheme.titleMedium,
+                    ),
+                    if (cause.localizedStrings(l10n)?.description
+                        case final description?) ...[
+                      const SizedBox(height: 6),
+                      Text(description),
+                    ],
+                    const SizedBox(height: 8),
+                    SelectableText(
+                      '${l10n.moderationAppliedBy}: '
+                      '${cause.sourceHandle == null ? cause.sourceDid : '@${cause.sourceHandle}'}',
+                    ),
+                    if (cause.label.exp case final expires?)
+                      Text('${l10n.moderationExpires}: ${expires.toLocal()}'),
+                    if (cause.noOverride) ...[
+                      const SizedBox(height: 6),
+                      Text(l10n.moderationCannotOverride),
+                    ],
+                    if (widget.mayAppeal &&
+                        ModerationAppealService.canAppeal(cause.label)) ...[
+                      const SizedBox(height: 10),
+                      OutlinedButton(
+                        onPressed: _submitting ? null : () => _appeal(cause),
+                        child: Text(l10n.buttonAppealLabel),
+                      ),
+                    ],
+                  ],
+                ),
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _appeal(ModerationCause cause) async {
+    setState(() => _submitting = true);
+    final l10n = AppLocalizations.of(context);
+    try {
+      await ref
+          .read(moderationAppealServiceProvider)
+          .appeal(cause.label, reason: l10n.moderationAppealReason);
+      if (mounted) {
+        ScaffoldMessenger.of(
+          context,
+        ).showSnackBar(SnackBar(content: Text(l10n.moderationAppealSent)));
+      }
+    } catch (_) {
+      if (mounted) {
+        ScaffoldMessenger.of(
+          context,
+        ).showSnackBar(SnackBar(content: Text(l10n.moderationAppealFailed)));
+      }
+    } finally {
+      if (mounted) setState(() => _submitting = false);
+    }
+  }
+}
diff --git a/lib/src/core/moderation/moderation_engine.dart b/lib/src/core/moderation/moderation_engine.dart
new file mode 100644
index 00000000..bf97e2de
--- /dev/null
+++ b/lib/src/core/moderation/moderation_engine.dart
@@ -0,0 +1,269 @@
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation_definitions.dart';
+import 'package:spark/src/core/moderation/moderation_label_events.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+enum _ProfileLabelTarget { account, profile }
+
+final class ModerationEngine {
+  ModerationEngine({
+    required this.definitions,
+    required this.preferences,
+    this.currentUserDid,
+    this.selfLabelerDid,
+    Map<String, String> labelerHandles = const {},
+  }) : _labelerHandles = Map.unmodifiable(labelerHandles);
+
+  final ModerationLabelDefinitions definitions;
+  final ModerationPreferences preferences;
+  final String? currentUserDid;
+  final String? selfLabelerDid;
+  final Map<String, String> _labelerHandles;
+
+  ModerationDecision evaluate(
+    Iterable<Label> labels, {
+    required ModerationTarget target,
+    String? subjectDid,
+    Iterable<String> preferredLocales = const [],
+    DateTime? now,
+  }) {
+    final evaluationTime = (now ?? DateTime.now()).toUtc();
+    final causes = <ModerationCause>[];
+
+    for (final label in labels) {
+      if (!isLabelActiveAt(label, now: evaluationTime)) continue;
+
+      final isSelfLabel = subjectDid != null && label.src == subjectDid;
+      if (!isSelfLabel && !definitions.isConfiguredSource(label.src)) {
+        continue;
+      }
+      final definition = isSelfLabel
+          ? definitions.lookupSelfLabel(label, labelerDid: selfLabelerDid)
+          : definitions.lookup(label);
+      if (definition == null) continue;
+
+      if (isSelfLabel &&
+          definition.definedBy == null &&
+          definition.flags.contains(ModerationLabelFlag.noSelf)) {
+        continue;
+      }
+      if (definition.flags.contains(ModerationLabelFlag.unauthenticated) &&
+          preferences.authenticated) {
+        continue;
+      }
+
+      final setting = preferences.settingFor(
+        label,
+        definition,
+        labelerDid: isSelfLabel ? selfLabelerDid : null,
+      );
+      if (setting == ModerationSetting.ignore) continue;
+
+      final adultRestricted =
+          definition.adultOnly && !preferences.adultContentEnabled;
+      final noOverride = definition.noOverride || adultRestricted;
+      final behavior = definition.behaviorFor(target);
+      causes.add(
+        ModerationCause(
+          label: label,
+          definition: definition,
+          target: target,
+          setting: setting,
+          behavior: behavior,
+          noOverride: noOverride,
+          priority: _priorityFor(
+            setting: setting,
+            behavior: behavior,
+            noOverride: noOverride,
+          ),
+          strings: definition.stringsFor(preferredLocales),
+          sourceHandle: _labelerHandles[label.src],
+        ),
+      );
+    }
+
+    causes.sort((a, b) => a.priority.compareTo(b.priority));
+    return ModerationDecision(
+      causes: causes,
+      isSubjectCurrentUser: subjectDid != null && subjectDid == currentUserDid,
+    );
+  }
+
+  /// Evaluates the mixed account and profile-record labels returned on profile
+  /// views using their protocol-defined targets.
+  ModerationDecision evaluateProfileLabels(
+    Iterable<Label> labels, {
+    String? subjectDid,
+    Iterable<String> preferredLocales = const [],
+    DateTime? now,
+  }) {
+    final items = labels.toList(growable: false);
+    final accountLabels = <Label>[];
+    final profileLabels = <Label>[];
+    for (final label in items) {
+      switch (_profileLabelTarget(label)) {
+        case _ProfileLabelTarget.account:
+          accountLabels.add(label);
+        case _ProfileLabelTarget.profile:
+          profileLabels.add(label);
+      }
+    }
+    return ModerationDecision.merge([
+      evaluate(
+        accountLabels,
+        target: ModerationTarget.account,
+        subjectDid: subjectDid,
+        preferredLocales: preferredLocales,
+        now: now,
+      ),
+      evaluate(
+        profileLabels,
+        target: ModerationTarget.profile,
+        subjectDid: subjectDid,
+        preferredLocales: preferredLocales,
+        now: now,
+      ),
+    ]);
+  }
+}
+
+bool _isProfileRecordLabel(Label label) {
+  return label.uri.endsWith('/app.bsky.actor.profile/self') ||
+      label.uri.endsWith('/so.sprk.actor.profile/self');
+}
+
+_ProfileLabelTarget _profileLabelTarget(Label label) {
+  if (label.val == '!no-unauthenticated') return _ProfileLabelTarget.account;
+  return _isProfileRecordLabel(label)
+      ? _ProfileLabelTarget.profile
+      : _ProfileLabelTarget.account;
+}
+
+final class ModerationDecision {
+  ModerationDecision({
+    required Iterable<ModerationCause> causes,
+    required this.isSubjectCurrentUser,
+  }) : causes = List.unmodifiable(causes);
+
+  /// Combines decisions for different targets belonging to the same subject.
+  ///
+  /// For example, a post surface can merge its author's account decision with
+  /// the post's content decision before asking for [ModerationContext.contentView].
+  factory ModerationDecision.merge(Iterable<ModerationDecision> decisions) {
+    final items = decisions.toList();
+    final causes = items.expand((decision) => decision.causes).toList()
+      ..sort((a, b) => a.priority.compareTo(b.priority));
+    return ModerationDecision(
+      causes: causes,
+      isSubjectCurrentUser: items.any(
+        (decision) => decision.isSubjectCurrentUser,
+      ),
+    );
+  }
+
+  final List<ModerationCause> causes;
+  final bool isSubjectCurrentUser;
+
+  bool get excludeFromPromotion => causes.any(
+    (cause) => cause.definition.flags.contains(ModerationLabelFlag.noPromote),
+  );
+
+  bool get hideFromUnauthenticated => causes.any(
+    (cause) =>
+        cause.definition.flags.contains(ModerationLabelFlag.unauthenticated),
+  );
+
+  ModerationUI forContext(ModerationContext context) {
+    final filters = <ModerationCause>[];
+    final blurs = <ModerationCause>[];
+    final alerts = <ModerationCause>[];
+    final informs = <ModerationCause>[];
+
+    for (final cause in causes) {
+      final noPromote = cause.definition.flags.contains(
+        ModerationLabelFlag.noPromote,
+      );
+      if (!noPromote &&
+          cause.setting == ModerationSetting.hide &&
+          !isSubjectCurrentUser &&
+          _filtersContext(cause.target, context)) {
+        filters.add(cause);
+      }
+
+      switch (cause.behavior[context]) {
+        case ModerationAction.blur:
+          blurs.add(cause);
+        case ModerationAction.alert:
+          alerts.add(cause);
+        case ModerationAction.inform:
+          informs.add(cause);
+        case null:
+          break;
+      }
+
+      // Spark is media-first: ordinary warning labels at the warn preference
+      // add a blur even when their definition does not request one. Informational
+      // labels remain badge-only unless their definition explicitly adds a blur.
+      // Protocol imperatives such as !no-promote retain their special meaning.
+      if (!noPromote &&
+          cause.setting == ModerationSetting.warn &&
+          cause.definition.severity != ModerationSeverity.inform &&
+          _warnBlurApplies(cause.target, context) &&
+          !blurs.contains(cause)) {
+        blurs.add(cause);
+      }
+    }
+
+    return ModerationUI(
+      filters: filters,
+      blurs: blurs,
+      alerts: alerts,
+      informs: informs,
+      noOverride:
+          !isSubjectCurrentUser && blurs.any((cause) => cause.noOverride),
+    );
+  }
+}
+
+bool _filtersContext(ModerationTarget target, ModerationContext context) {
+  return switch (context) {
+    ModerationContext.profileList => target == ModerationTarget.account,
+    ModerationContext.contentList =>
+      target == ModerationTarget.account || target == ModerationTarget.content,
+    _ => false,
+  };
+}
+
+bool _warnBlurApplies(ModerationTarget target, ModerationContext context) {
+  return switch (target) {
+    ModerationTarget.account => true,
+    ModerationTarget.profile =>
+      context == ModerationContext.profileList ||
+          context == ModerationContext.profileView ||
+          context == ModerationContext.avatar ||
+          context == ModerationContext.banner ||
+          context == ModerationContext.displayName,
+    ModerationTarget.content =>
+      context == ModerationContext.contentList ||
+          context == ModerationContext.contentView ||
+          context == ModerationContext.contentMedia,
+  };
+}
+
+int _priorityFor({
+  required ModerationSetting setting,
+  required ModerationBehavior behavior,
+  required bool noOverride,
+}) {
+  if (noOverride) return 1;
+  if (setting == ModerationSetting.hide) return 2;
+  if (behavior[ModerationContext.profileView] == ModerationAction.blur ||
+      behavior[ModerationContext.contentView] == ModerationAction.blur) {
+    return 5;
+  }
+  if (behavior[ModerationContext.contentList] == ModerationAction.blur ||
+      behavior[ModerationContext.contentMedia] == ModerationAction.blur) {
+    return 7;
+  }
+  return 8;
+}
diff --git a/lib/src/core/moderation/moderation_label_events.dart b/lib/src/core/moderation/moderation_label_events.dart
new file mode 100644
index 00000000..454b6e2e
--- /dev/null
+++ b/lib/src/core/moderation/moderation_label_events.dart
@@ -0,0 +1,46 @@
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+
+/// Merges label event streams to the latest event for each label identity.
+List<Label> mergeLatestLabelEvents({
+  required Iterable<Label> existing,
+  required Iterable<Label> incoming,
+  required DateTime now,
+}) {
+  final evaluationTime = now.toUtc();
+  final latestByIdentity = <({String src, String uri, String val}), Label>{};
+  for (final event in existing.followedBy(incoming)) {
+    final identity = (src: event.src, uri: event.uri, val: event.val);
+    final current = latestByIdentity[identity];
+    if (current == null ||
+        _labelShouldReplace(event, current, evaluationTime)) {
+      latestByIdentity[identity] = event;
+    }
+  }
+  return latestByIdentity.values.toList(growable: false);
+}
+
+/// Selects asserted, unexpired labels from a reconciled event snapshot.
+List<Label> activeLabelsFromEvents(
+  Iterable<Label> events, {
+  required DateTime now,
+}) {
+  final evaluationTime = now.toUtc();
+  return events
+      .where((label) => isLabelActiveAt(label, now: evaluationTime))
+      .toList(growable: false);
+}
+
+/// Whether a label assertion applies at [now].
+bool isLabelActiveAt(Label label, {required DateTime now}) {
+  final evaluationTime = now.toUtc();
+  return !label.isNeg && (label.exp?.toUtc().isAfter(evaluationTime) ?? true);
+}
+
+bool _labelShouldReplace(Label candidate, Label existing, DateTime now) {
+  final comparison = candidate.cts.toUtc().compareTo(existing.cts.toUtc());
+  if (comparison != 0) return comparison > 0;
+
+  final candidateInactive = !isLabelActiveAt(candidate, now: now);
+  final existingInactive = !isLabelActiveAt(existing, now: now);
+  return candidateInactive || !existingInactive;
+}
diff --git a/lib/src/core/moderation/moderation_label_localizations.dart b/lib/src/core/moderation/moderation_label_localizations.dart
new file mode 100644
index 00000000..8f9e22f3
--- /dev/null
+++ b/lib/src/core/moderation/moderation_label_localizations.dart
@@ -0,0 +1,45 @@
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+extension ModerationLabelLocalizations on AppLocalizations {
+  ModerationLabelStrings? globalModerationLabelStrings(String identifier) {
+    final (name, description) = switch (identifier) {
+      'porn' => (moderationLabelPornName, moderationLabelPornDescription),
+      'sexual' => (moderationLabelSexualName, moderationLabelSexualDescription),
+      'nudity' => (moderationLabelNudityName, moderationLabelNudityDescription),
+      'graphic-media' => (
+        moderationLabelGraphicMediaName,
+        moderationLabelGraphicMediaDescription,
+      ),
+      'gore' => (moderationLabelGoreName, moderationLabelGoreDescription),
+      _ => (null, null),
+    };
+    if (name == null || description == null) return null;
+
+    return ModerationLabelStrings(
+      lang: localeName,
+      name: name,
+      description: description,
+    );
+  }
+}
+
+extension LocalizedModerationLabelDefinition on ModerationLabelDefinition {
+  ModerationLabelStrings? localizedStrings(
+    AppLocalizations localizations, {
+    Iterable<String> preferredLocales = const [],
+  }) {
+    final publishedStrings = stringsFor(preferredLocales);
+    if (definedBy != null && publishedStrings != null) return publishedStrings;
+    return localizations.globalModerationLabelStrings(identifier) ??
+        publishedStrings;
+  }
+}
+
+extension LocalizedModerationCause on ModerationCause {
+  ModerationLabelStrings? localizedStrings(AppLocalizations localizations) {
+    if (definition.definedBy != null && strings != null) return strings;
+    return localizations.globalModerationLabelStrings(definition.identifier) ??
+        strings;
+  }
+}
diff --git a/lib/src/core/moderation/moderation_models.dart b/lib/src/core/moderation/moderation_models.dart
new file mode 100644
index 00000000..9b13825d
--- /dev/null
+++ b/lib/src/core/moderation/moderation_models.dart
@@ -0,0 +1,273 @@
+import 'dart:collection';
+
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs/content_label_pref.dart';
+
+enum ModerationTarget { account, profile, content }
+
+enum ModerationContext {
+  contentList,
+  contentView,
+  contentMedia,
+  profileList,
+  profileView,
+  avatar,
+  banner,
+  displayName,
+}
+
+enum ModerationAction { blur, alert, inform }
+
+enum ModerationSetting { ignore, warn, hide }
+
+enum ModerationSeverity { none, inform, alert }
+
+enum ModerationBlur { none, media, content }
+
+/// Canonical labels configured globally from the adult-content settings.
+const globalAdultContentLabelValues = <String>{
+  'porn',
+  'sexual',
+  'graphic-media',
+  'nudity',
+};
+
+enum ModerationLabelFlag {
+  noOverride,
+  adult,
+  unauthenticated,
+  noSelf,
+  noPromote,
+}
+
+final class ModerationLabelStrings {
+  const ModerationLabelStrings({
+    required this.lang,
+    required this.name,
+    required this.description,
+  });
+
+  final String lang;
+  final String name;
+  final String description;
+
+  factory ModerationLabelStrings.fromLexicon(
+    LabelValueDefinitionStrings strings,
+  ) {
+    return ModerationLabelStrings(
+      lang: strings.lang,
+      name: strings.name,
+      description: strings.description,
+    );
+  }
+}
+
+final class ModerationBehavior {
+  ModerationBehavior([
+    Map<ModerationContext, ModerationAction> actions = const {},
+  ]) : _actions = UnmodifiableMapView(Map.of(actions));
+
+  final Map<ModerationContext, ModerationAction> _actions;
+
+  Map<ModerationContext, ModerationAction> get actions => _actions;
+
+  ModerationAction? operator [](ModerationContext context) => _actions[context];
+
+  bool get isEmpty => _actions.isEmpty;
+}
+
+final class ModerationLabelDefinition {
+  ModerationLabelDefinition({
+    required this.identifier,
+    required this.severity,
+    required this.blurs,
+    required this.defaultSetting,
+    required this.configurable,
+    required Iterable<ModerationLabelFlag> flags,
+    required Iterable<ModerationLabelStrings> locales,
+    required Map<ModerationTarget, ModerationBehavior> behaviors,
+    this.definedBy,
+  }) : flags = Set.unmodifiable(flags),
+       locales = List.unmodifiable(locales),
+       behaviors = UnmodifiableMapView(Map.of(behaviors));
+
+  final String identifier;
+  final String? definedBy;
+  final ModerationSeverity severity;
+  final ModerationBlur blurs;
+  final ModerationSetting defaultSetting;
+  final bool configurable;
+  final Set<ModerationLabelFlag> flags;
+  final List<ModerationLabelStrings> locales;
+  final Map<ModerationTarget, ModerationBehavior> behaviors;
+
+  bool get adultOnly => flags.contains(ModerationLabelFlag.adult);
+
+  bool get noOverride => flags.contains(ModerationLabelFlag.noOverride);
+
+  ModerationBehavior behaviorFor(ModerationTarget target) {
+    return behaviors[target] ?? ModerationBehavior();
+  }
+
+  /// Selects definition-published strings using BCP 47 lookup-style fallback.
+  ModerationLabelStrings? stringsFor(Iterable<String> preferredLocales) {
+    if (locales.isEmpty) return null;
+
+    final normalized = <String, ModerationLabelStrings>{};
+    for (final strings in locales) {
+      normalized.putIfAbsent(_normalizeLocale(strings.lang), () => strings);
+    }
+
+    for (final preferred in preferredLocales) {
+      var candidate = _normalizeLocale(preferred);
+      while (candidate.isNotEmpty) {
+        final exact = normalized[candidate];
+        if (exact != null) return exact;
+        final separator = candidate.lastIndexOf('-');
+        if (separator == -1) break;
+        candidate = candidate.substring(0, separator);
+      }
+
+      final language = candidate;
+      if (language.isNotEmpty) {
+        for (final entry in normalized.entries) {
+          if (entry.key.split('-').first == language) return entry.value;
+        }
+      }
+    }
+
+    return normalized['en'] ??
+        normalized.entries
+            .where((entry) => entry.key.split('-').first == 'en')
+            .map((entry) => entry.value)
+            .firstOrNull ??
+        locales.first;
+  }
+
+  static String _normalizeLocale(String locale) {
+    return locale.trim().replaceAll('_', '-').toLowerCase();
+  }
+}
+
+final class ModerationLabelPreference {
+  const ModerationLabelPreference({
+    required this.value,
+    required this.setting,
+    this.labelerDid,
+  });
+
+  final String value;
+  final String? labelerDid;
+  final ModerationSetting setting;
+}
+
+final class ModerationPreferences {
+  ModerationPreferences({
+    required Iterable<ModerationLabelPreference> labels,
+    required this.adultContentEnabled,
+    required this.authenticated,
+  }) : labels = List.unmodifiable(labels);
+
+  factory ModerationPreferences.fromContentLabelPrefs(
+    Iterable<ContentLabelPref> labels, {
+    required bool adultContentEnabled,
+    required bool authenticated,
+  }) {
+    return ModerationPreferences(
+      labels: labels.map(
+        (preference) => ModerationLabelPreference(
+          value: preference.label,
+          labelerDid: preference.labelerDid,
+          setting: switch (preference.visibility.toJson()) {
+            'hide' => ModerationSetting.hide,
+            'warn' => ModerationSetting.warn,
+            _ => ModerationSetting.ignore,
+          },
+        ),
+      ),
+      adultContentEnabled: adultContentEnabled,
+      authenticated: authenticated,
+    );
+  }
+
+  final List<ModerationLabelPreference> labels;
+  final bool adultContentEnabled;
+  final bool authenticated;
+
+  ModerationSetting settingFor(
+    Label label,
+    ModerationLabelDefinition definition, {
+    String? labelerDid,
+  }) {
+    if (!definition.configurable) return definition.defaultSetting;
+    if (definition.adultOnly && !adultContentEnabled) {
+      return ModerationSetting.hide;
+    }
+
+    ModerationLabelPreference? global;
+    ModerationLabelPreference? sourceSpecific;
+    for (final preference in labels) {
+      if (preference.value != label.val) continue;
+      if (preference.labelerDid == (labelerDid ?? label.src)) {
+        sourceSpecific = preference;
+      }
+      if (preference.labelerDid == null) global ??= preference;
+    }
+    if (globalAdultContentLabelValues.contains(label.val) && global != null) {
+      return global.setting;
+    }
+    return sourceSpecific?.setting ??
+        global?.setting ??
+        definition.defaultSetting;
+  }
+}
+
+final class ModerationCause {
+  const ModerationCause({
+    required this.label,
+    required this.definition,
+    required this.target,
+    required this.setting,
+    required this.behavior,
+    required this.noOverride,
+    required this.priority,
+    this.strings,
+    this.sourceHandle,
+  });
+
+  final Label label;
+  final ModerationLabelDefinition definition;
+  final ModerationTarget target;
+  final ModerationSetting setting;
+  final ModerationBehavior behavior;
+  final bool noOverride;
+  final int priority;
+  final ModerationLabelStrings? strings;
+  final String? sourceHandle;
+
+  String get sourceDid => label.src;
+}
+
+final class ModerationUI {
+  ModerationUI({
+    required Iterable<ModerationCause> filters,
+    required Iterable<ModerationCause> blurs,
+    required Iterable<ModerationCause> alerts,
+    required Iterable<ModerationCause> informs,
+    required this.noOverride,
+  }) : filters = List.unmodifiable(filters),
+       blurs = List.unmodifiable(blurs),
+       alerts = List.unmodifiable(alerts),
+       informs = List.unmodifiable(informs);
+
+  final List<ModerationCause> filters;
+  final List<ModerationCause> blurs;
+  final List<ModerationCause> alerts;
+  final List<ModerationCause> informs;
+  final bool noOverride;
+
+  bool get filter => filters.isNotEmpty;
+  bool get blur => blurs.isNotEmpty;
+  bool get alert => alerts.isNotEmpty;
+  bool get inform => informs.isNotEmpty;
+}
diff --git a/lib/src/core/moderation/moderation_presentation.dart b/lib/src/core/moderation/moderation_presentation.dart
new file mode 100644
index 00000000..7cea0448
--- /dev/null
+++ b/lib/src/core/moderation/moderation_presentation.dart
@@ -0,0 +1,294 @@
+import 'dart:ui';
+
+import 'package:flutter/material.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation_label_localizations.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+sealed class ModerationPresentation {
+  const ModerationPresentation();
+
+  const factory ModerationPresentation.standard({Widget? blurredChild}) =
+      StandardModerationPresentation;
+
+  const factory ModerationPresentation.compact({
+    Widget? blurredChild,
+    VoidCallback? onConcealedTap,
+  }) = CompactModerationPresentation;
+
+  Widget render({
+    required Widget child,
+    required bool concealed,
+    required ModerationUI ui,
+    required List<ModerationCause> causes,
+    required VoidCallback reveal,
+    required VoidCallback showDetails,
+  });
+}
+
+final class StandardModerationPresentation extends ModerationPresentation {
+  const StandardModerationPresentation({this.blurredChild});
+
+  final Widget? blurredChild;
+
+  @override
+  Widget render({
+    required Widget child,
+    required bool concealed,
+    required ModerationUI ui,
+    required List<ModerationCause> causes,
+    required VoidCallback reveal,
+    required VoidCallback showDetails,
+  }) {
+    return Stack(
+      fit: StackFit.passthrough,
+      children: [
+        if (concealed)
+          IgnorePointer(
+            child:
+                blurredChild ??
+                ImageFiltered(
+                  imageFilter: ImageFilter.blur(sigmaX: 40, sigmaY: 40),
+                  child: child,
+                ),
+          )
+        else
+          child,
+        if (concealed)
+          Positioned.fill(
+            child: _ModerationCover(
+              causes: causes,
+              noOverride: ui.noOverride,
+              onReveal: ui.noOverride ? null : reveal,
+              onDetails: showDetails,
+            ),
+          )
+        else if (ui.alert || ui.inform)
+          Positioned(
+            left: 12,
+            top: 12,
+            child: _ModerationNotice(causes: causes, onTap: showDetails),
+          ),
+      ],
+    );
+  }
+}
+
+final class CompactModerationPresentation extends ModerationPresentation {
+  const CompactModerationPresentation({this.blurredChild, this.onConcealedTap});
+
+  final Widget? blurredChild;
+  final VoidCallback? onConcealedTap;
+
+  @override
+  Widget render({
+    required Widget child,
+    required bool concealed,
+    required ModerationUI ui,
+    required List<ModerationCause> causes,
+    required VoidCallback reveal,
+    required VoidCallback showDetails,
+  }) {
+    return Stack(
+      fit: StackFit.passthrough,
+      children: [
+        if (concealed)
+          blurredChild ??
+              ImageFiltered(
+                imageFilter: ImageFilter.blur(sigmaX: 18, sigmaY: 18),
+                child: child,
+              )
+        else
+          child,
+        if (concealed)
+          Positioned.fill(
+            child: Material(
+              color: Colors.black.withValues(alpha: 0.38),
+              child: InkWell(
+                onTap: onConcealedTap ?? (ui.noOverride ? showDetails : reveal),
+                child: const Center(
+                  child: Icon(
+                    Icons.visibility_off_outlined,
+                    color: Colors.white,
+                  ),
+                ),
+              ),
+            ),
+          )
+        else if (ui.alert || ui.inform)
+          Positioned(
+            left: 4,
+            top: 4,
+            child: _CompactModerationNotice(onTap: showDetails),
+          ),
+      ],
+    );
+  }
+}
+
+class ModerationPending extends StatelessWidget {
+  const ModerationPending({
+    required this.hasError,
+    required this.onRetry,
+    required this.child,
+    super.key,
+  });
+
+  final bool hasError;
+  final VoidCallback onRetry;
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      fit: StackFit.passthrough,
+      children: [
+        IgnorePointer(
+          child: ExcludeSemantics(child: Opacity(opacity: 0, child: child)),
+        ),
+        Positioned.fill(
+          child: Material(
+            color: Colors.black87,
+            child: hasError
+                ? Semantics(
+                    button: true,
+                    label: AppLocalizations.of(context).buttonRetry,
+                    child: InkWell(
+                      onTap: onRetry,
+                      child: const Center(child: Icon(Icons.refresh)),
+                    ),
+                  )
+                : const Center(
+                    child: SizedBox.square(
+                      dimension: 24,
+                      child: CircularProgressIndicator(strokeWidth: 2),
+                    ),
+                  ),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _CompactModerationNotice extends StatelessWidget {
+  const _CompactModerationNotice({required this.onTap});
+
+  final VoidCallback onTap;
+
+  @override
+  Widget build(BuildContext context) {
+    return Semantics(
+      button: true,
+      label: AppLocalizations.of(context).buttonModerationDetails,
+      child: Material(
+        color: Theme.of(context).colorScheme.surfaceContainerHighest,
+        shape: const CircleBorder(),
+        child: InkResponse(
+          onTap: onTap,
+          radius: 16,
+          child: const Padding(
+            padding: EdgeInsets.all(5),
+            child: Icon(Icons.info_outline, size: 16),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+class _ModerationCover extends StatelessWidget {
+  const _ModerationCover({
+    required this.causes,
+    required this.noOverride,
+    required this.onReveal,
+    required this.onDetails,
+  });
+
+  final List<ModerationCause> causes;
+  final bool noOverride;
+  final VoidCallback? onReveal;
+  final VoidCallback onDetails;
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context);
+    final names = causes
+        .map((cause) => cause.localizedStrings(l10n)?.name)
+        .nonNulls
+        .toList();
+    return ColoredBox(
+      color: Colors.black.withValues(alpha: 0.7),
+      child: Center(
+        child: SingleChildScrollView(
+          padding: const EdgeInsets.all(24),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              const Icon(
+                Icons.warning_amber_rounded,
+                color: Colors.white,
+                size: 44,
+              ),
+              const SizedBox(height: 12),
+              Text(
+                l10n.moderationContentWarning,
+                style: const TextStyle(
+                  color: Colors.white,
+                  fontSize: 22,
+                  fontWeight: FontWeight.bold,
+                ),
+                textAlign: TextAlign.center,
+              ),
+              if (names.isNotEmpty) ...[
+                const SizedBox(height: 8),
+                Text(
+                  names.join(', '),
+                  style: const TextStyle(color: Colors.white, fontSize: 15),
+                  textAlign: TextAlign.center,
+                ),
+              ],
+              const SizedBox(height: 18),
+              if (onReveal != null)
+                FilledButton(
+                  onPressed: onReveal,
+                  child: Text(l10n.buttonViewContent),
+                )
+              else if (noOverride)
+                Text(
+                  l10n.moderationCannotOverride,
+                  style: const TextStyle(color: Colors.white70),
+                  textAlign: TextAlign.center,
+                ),
+              TextButton(
+                onPressed: onDetails,
+                child: Text(l10n.buttonModerationDetails),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+class _ModerationNotice extends StatelessWidget {
+  const _ModerationNotice({required this.causes, required this.onTap});
+
+  final List<ModerationCause> causes;
+  final VoidCallback onTap;
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context);
+    final name = causes
+        .map((cause) => cause.localizedStrings(l10n)?.name)
+        .nonNulls
+        .firstOrNull;
+    return ActionChip(
+      avatar: const Icon(Icons.info_outline, size: 18),
+      label: Text(name ?? l10n.moderationContentNotice),
+      onPressed: onTap,
+    );
+  }
+}
diff --git a/lib/src/core/moderation/moderation_provider.dart b/lib/src/core/moderation/moderation_provider.dart
new file mode 100644
index 00000000..d6600715
--- /dev/null
+++ b/lib/src/core/moderation/moderation_provider.dart
@@ -0,0 +1,55 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/network/atproto/data/services/appview_labeler_headers.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+
+/// The moderation engine for the current preference snapshot.
+///
+/// Definitions are deliberately keyed by their labeler DID. A failed labeler
+/// policy request cannot make another labeler's same-named value take over.
+final moderationEngineProvider = FutureProvider<ModerationEngine>((ref) async {
+  final preferences = await ref.watch(userPreferencesProvider.future);
+  final repository = GetIt.I<SprkRepository>();
+  final logger = GetIt.I<LogService>().getLogger('ModerationEngine');
+  final labelerDids = AppViewLabelerHeaders.normalize(
+    defaultLabelerDid: repository.modDid,
+    labelerDids:
+        preferences.labelers?.map((labeler) => labeler.did) ?? const [],
+  );
+
+  final definitions = <String, Iterable<LabelValueDefinition>>{};
+  final labelerHandles = <String, String>{};
+  await Future.wait(
+    labelerDids.map((did) async {
+      try {
+        final service = await repository.labeler.getServicesDetailed([did]);
+        definitions[did] = service.policies.labelValueDefinitions ?? const [];
+        labelerHandles[did] = service.creator.handle;
+      } catch (error, stackTrace) {
+        logger.w(
+          'Could not load label definitions for $did',
+          error: error,
+          stackTrace: stackTrace,
+        );
+        rethrow;
+      }
+    }),
+  );
+
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers(definitions),
+    preferences: ModerationPreferences.fromContentLabelPrefs(
+      preferences.contentLabelPrefs ?? const [],
+      adultContentEnabled: preferences.adultContentEnabled,
+      authenticated: repository.authRepository.isAuthenticated,
+    ),
+    currentUserDid: repository.authRepository.did,
+    selfLabelerDid: labelerDids.first,
+    labelerHandles: labelerHandles,
+  );
+});
diff --git a/lib/src/core/moderation/moderation_report_catalog.dart b/lib/src/core/moderation/moderation_report_catalog.dart
new file mode 100644
index 00000000..718fcef4
--- /dev/null
+++ b/lib/src/core/moderation/moderation_report_catalog.dart
@@ -0,0 +1,291 @@
+import 'package:poptart_lex/com/atproto/moderation/defs.dart';
+
+enum ReportCategory {
+  violence('Violence'),
+  sexual('Sexual Content'),
+  childSafety('Child Safety'),
+  harassment('Harassment'),
+  misleading('Misleading'),
+  ruleViolations('Rule Violations'),
+  selfHarm('Self-Harm'),
+  other('Other');
+
+  const ReportCategory(this.displayName);
+  final String displayName;
+}
+
+class ReportReason {
+  final String value;
+  final String displayName;
+  final String? description;
+  final KnownReasonType? knownType;
+
+  const ReportReason({
+    required this.value,
+    required this.displayName,
+    this.description,
+    this.knownType,
+  });
+
+  ReasonType get reasonType => knownType != null
+      ? ReasonType.knownValue(data: knownType!)
+      : ReasonType.unknown(data: value);
+}
+
+final Map<ReportCategory, List<ReportReason>> reportCategoryReasons = {
+  ReportCategory.violence: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceAnimal',
+      displayName: 'Animal Abuse',
+      description: 'Content depicting harm to animals',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceAnimal,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceThreats',
+      displayName: 'Threats',
+      description: 'Threats of violence',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceThreats,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceGraphicContent',
+      displayName: 'Graphic Content',
+      description: 'Graphic or violent imagery',
+      knownType:
+          KnownReasonType.toolsOzoneReportDefsReasonViolenceGraphicContent,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceGlorification',
+      displayName: 'Glorification of Violence',
+      description: 'Content that glorifies violence',
+      knownType:
+          KnownReasonType.toolsOzoneReportDefsReasonViolenceGlorification,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceExtremistContent',
+      displayName: 'Extremist Content',
+      description: 'Content promoting extremist ideologies',
+      knownType:
+          KnownReasonType.toolsOzoneReportDefsReasonViolenceExtremistContent,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceTrafficking',
+      displayName: 'Trafficking',
+      description: 'Content related to human trafficking',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceTrafficking,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonViolenceOther',
+      displayName: 'Other Violence',
+      description: 'Other violent content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceOther,
+    ),
+  ],
+  ReportCategory.sexual: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSexualAbuseContent',
+      displayName: 'Abuse Content',
+      description: 'Sexual abuse content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualAbuseContent,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSexualNCII',
+      displayName: 'Non-Consensual Intimate Images',
+      description: 'Sharing intimate images without consent',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualNCII,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSexualDeepfake',
+      displayName: 'Deepfake',
+      description: 'AI-generated sexual content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualDeepfake,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSexualAnimal',
+      displayName: 'Animal Sexual Content',
+      description: 'Sexual content involving animals',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualAnimal,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSexualUnlabeled',
+      displayName: 'Unlabeled Sexual Content',
+      description: 'Sexual content without proper warnings',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualUnlabeled,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSexualOther',
+      displayName: 'Other Sexual Content',
+      description: 'Other sexual content violations',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualOther,
+    ),
+  ],
+  ReportCategory.childSafety: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonChildSafetyCSAM',
+      displayName: 'CSAM',
+      description: 'Child sexual abuse material',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyCSAM,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonChildSafetyGroom',
+      displayName: 'Grooming',
+      description: 'Grooming behavior targeting minors',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyGroom,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonChildSafetyPrivacy',
+      displayName: 'Privacy Violation',
+      description: 'Sharing private information about minors',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyPrivacy,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonChildSafetyHarassment',
+      displayName: 'Harassment',
+      description: 'Harassment targeting minors',
+      knownType:
+          KnownReasonType.toolsOzoneReportDefsReasonChildSafetyHarassment,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonChildSafetyOther',
+      displayName: 'Other Child Safety',
+      description: 'Other child safety concerns',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyOther,
+    ),
+  ],
+  ReportCategory.harassment: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonHarassmentTroll',
+      displayName: 'Trolling',
+      description: 'Trolling or disruptive behavior',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentTroll,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonHarassmentTargeted',
+      displayName: 'Targeted Harassment',
+      description: 'Targeted harassment or bullying',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentTargeted,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonHarassmentHateSpeech',
+      displayName: 'Hate Speech',
+      description: 'Hate speech or discriminatory content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentHateSpeech,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonHarassmentDoxxing',
+      displayName: 'Doxxing',
+      description: 'Sharing private information without consent',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentDoxxing,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonHarassmentOther',
+      displayName: 'Other Harassment',
+      description: 'Other harassment violations',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentOther,
+    ),
+  ],
+  ReportCategory.misleading: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonMisleadingBot',
+      displayName: 'Bot Account',
+      description: 'Automated or bot account',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingBot,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonMisleadingImpersonation',
+      displayName: 'Impersonation',
+      description: 'Impersonating another person or entity',
+      knownType:
+          KnownReasonType.toolsOzoneReportDefsReasonMisleadingImpersonation,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonMisleadingSpam',
+      displayName: 'Spam',
+      description: 'Spam or repetitive content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingSpam,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonMisleadingScam',
+      displayName: 'Scam',
+      description: 'Fraudulent or scam content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingScam,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonMisleadingElections',
+      displayName: 'Election Misinformation',
+      description: 'False information about elections',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingElections,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonMisleadingOther',
+      displayName: 'Other Misleading',
+      description: 'Other misleading content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingOther,
+    ),
+  ],
+  ReportCategory.ruleViolations: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonRuleSiteSecurity',
+      displayName: 'Site Security',
+      description: 'Violation of site security rules',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleSiteSecurity,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonRuleProhibitedSales',
+      displayName: 'Prohibited Sales',
+      description: 'Prohibited goods or services',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleProhibitedSales,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonRuleBanEvasion',
+      displayName: 'Ban Evasion',
+      description: 'Attempting to evade a ban',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleBanEvasion,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonRuleOther',
+      displayName: 'Other Rule Violation',
+      description: 'Other rule violations',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleOther,
+    ),
+  ],
+  ReportCategory.selfHarm: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSelfHarmContent',
+      displayName: 'Self-Harm Content',
+      description: 'Content promoting self-harm',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmContent,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSelfHarmED',
+      displayName: 'Eating Disorder',
+      description: 'Content promoting eating disorders',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmED,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSelfHarmStunts',
+      displayName: 'Dangerous Stunts',
+      description: 'Content showing dangerous stunts',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmStunts,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSelfHarmSubstances',
+      displayName: 'Substance Abuse',
+      description: 'Content promoting substance abuse',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmSubstances,
+    ),
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonSelfHarmOther',
+      displayName: 'Other Self-Harm',
+      description: 'Other self-harm related content',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmOther,
+    ),
+  ],
+  ReportCategory.other: [
+    const ReportReason(
+      value: 'tools.ozone.report.defs#reasonOther',
+      displayName: 'Other',
+      description: 'Other issues not listed above',
+      knownType: KnownReasonType.toolsOzoneReportDefsReasonOther,
+    ),
+  ],
+};
diff --git a/lib/src/core/moderation/moderation_report_service.dart b/lib/src/core/moderation/moderation_report_service.dart
new file mode 100644
index 00000000..5180fa0b
--- /dev/null
+++ b/lib/src/core/moderation/moderation_report_service.dart
@@ -0,0 +1,71 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
+import 'package:poptart_lex/com/atproto/moderation/defs.dart';
+import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+
+typedef ModerationReportSubmitter =
+    Future<void> Function(ModerationCreateReportInput input, String serviceDid);
+
+final moderationReportServiceProvider = Provider<ModerationReportService>(
+  (ref) => ModerationReportService(GetIt.I<SprkRepository>()),
+);
+
+final class ModerationReportOptions {
+  const ModerationReportOptions(this.services);
+
+  final List<CompatibleModerationService> services;
+
+  String? get defaultServiceDid => services.firstOrNull?.did;
+}
+
+final class ModerationReportService {
+  const ModerationReportService(this._repository);
+
+  final SprkRepository _repository;
+
+  Future<ModerationReportOptions> loadOptions({
+    required UModerationCreateReportSubject subject,
+    required ReasonType reasonType,
+    String? fallbackServiceDid,
+  }) async {
+    final subjectData = subject.data;
+    final isBskyRecord =
+        subjectData is RepoStrongRef &&
+        subjectData.uri.collection.toString().startsWith('app.bsky');
+    final fallbackProxyDid =
+        fallbackServiceDid ??
+        (isBskyRecord ? _repository.bskyModDid : _repository.modDid);
+    final fallbackDid = fallbackProxyDid.split('#').first;
+    final services = await _repository.labeler.getCompatibleModerationServices(
+      _repository.labelerDids,
+      ModerationServiceQuery.forReport(
+        fallbackDid: fallbackDid,
+        subject: subject,
+        reasonType: reasonType.toJson(),
+      ),
+    );
+    return ModerationReportOptions(services);
+  }
+
+  Future<void> submit({
+    required UModerationCreateReportSubject subject,
+    required ReasonType reasonType,
+    required String serviceDid,
+    String? reason,
+    ModerationReportSubmitter? submitter,
+  }) async {
+    final input = ModerationCreateReportInput(
+      subject: subject,
+      reasonType: reasonType,
+      reason: reason,
+    );
+    if (submitter != null) {
+      await submitter(input, serviceDid);
+      return;
+    }
+    await _repository.repo.createReport(input: input, serviceDid: serviceDid);
+  }
+}
diff --git a/lib/src/core/moderation/moderation_subject.dart b/lib/src/core/moderation/moderation_subject.dart
new file mode 100644
index 00000000..c48224c7
--- /dev/null
+++ b/lib/src/core/moderation/moderation_subject.dart
@@ -0,0 +1,90 @@
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation_engine.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+enum _ModerationSubjectKind { content, profile }
+
+/// A typed moderation input that owns how protocol labels are evaluated.
+final class ModerationSubject {
+  ModerationSubject._(
+    this._kind, {
+    required this.subjectDid,
+    required Iterable<Label> labels,
+    required Iterable<Label> authorLabels,
+  }) : labels = List.unmodifiable(labels),
+       authorLabels = List.unmodifiable(authorLabels);
+
+  factory ModerationSubject.content({
+    required String? subjectDid,
+    required Iterable<Label> labels,
+    Iterable<Label> authorLabels = const [],
+  }) {
+    return ModerationSubject._(
+      _ModerationSubjectKind.content,
+      subjectDid: subjectDid,
+      labels: labels,
+      authorLabels: authorLabels,
+    );
+  }
+
+  factory ModerationSubject.profile({
+    required String? subjectDid,
+    required Iterable<Label> labels,
+  }) {
+    return ModerationSubject._(
+      _ModerationSubjectKind.profile,
+      subjectDid: subjectDid,
+      labels: labels,
+      authorLabels: const [],
+    );
+  }
+
+  final _ModerationSubjectKind _kind;
+  final String? subjectDid;
+  final List<Label> labels;
+  final List<Label> authorLabels;
+
+  bool get hasLabels => labels.isNotEmpty || authorLabels.isNotEmpty;
+
+  ModerationDecision evaluate(
+    ModerationEngine engine, {
+    Iterable<String> preferredLocales = const [],
+  }) {
+    return switch (_kind) {
+      _ModerationSubjectKind.profile => engine.evaluateProfileLabels(
+        labels,
+        subjectDid: subjectDid,
+        preferredLocales: preferredLocales,
+      ),
+      _ModerationSubjectKind.content => ModerationDecision.merge([
+        engine.evaluate(
+          labels,
+          target: ModerationTarget.content,
+          subjectDid: subjectDid,
+          preferredLocales: preferredLocales,
+        ),
+        if (authorLabels.isNotEmpty)
+          engine.evaluateProfileLabels(
+            authorLabels,
+            subjectDid: subjectDid,
+            preferredLocales: preferredLocales,
+          ),
+      ]),
+    };
+  }
+
+  String disclosureKey(ModerationContext context) {
+    return <String?>[
+      subjectDid,
+      _kind.name,
+      context.name,
+      ...labels.map(_labelSignature),
+      ...authorLabels.map(_labelSignature),
+    ].join('|');
+  }
+}
+
+String _labelSignature(Label label) {
+  return '${label.src}|${label.uri}|${label.cid}|${label.val}|${label.neg}|'
+      '${label.cts.toUtc().toIso8601String()}|${label.exp}';
+}
diff --git a/lib/src/core/network/atproto/data/adapters/bsky/actor_adapter.dart b/lib/src/core/network/atproto/data/adapters/bsky/actor_adapter.dart
index 9c73a54c..2f3a0ff6 100644
--- a/lib/src/core/network/atproto/data/adapters/bsky/actor_adapter.dart
+++ b/lib/src/core/network/atproto/data/adapters/bsky/actor_adapter.dart
@@ -19,11 +19,13 @@ class BskyActorAdapter {
   /// Get a single profile from Bluesky and convert to Spark format
   Future<ProfileViewDetailed> getProfileFromBluesky(
     PoptartClient bluesky,
-    String did,
-  ) async {
+    String did, {
+    Map<String, String>? headers,
+  }) async {
     final profile = await bluesky.call(
       bsky_actor_get_profile.appBskyActorGetProfile,
       parameters: bsky_actor_get_profile.ActorGetProfileInput(actor: did),
+      headers: headers,
     );
     return convertBskyProfileToSpark(profile.data.toJson());
   }
@@ -31,11 +33,13 @@ class BskyActorAdapter {
   /// Get multiple profiles from Bluesky and convert to Spark format
   Future<List<ProfileViewDetailed>> getProfilesFromBluesky(
     PoptartClient bluesky,
-    List<String> dids,
-  ) async {
+    List<String> dids, {
+    Map<String, String>? headers,
+  }) async {
     final profiles = await bluesky.call(
       bsky_actor_get_profiles.appBskyActorGetProfiles,
       parameters: bsky_actor_get_profiles.ActorGetProfilesInput(actors: dids),
+      headers: headers,
     );
     return profiles.data.profiles
         .map((p) => convertBskyProfileToSpark(p.toJson()))
diff --git a/lib/src/core/network/atproto/data/adapters/bsky/feed_adapter.dart b/lib/src/core/network/atproto/data/adapters/bsky/feed_adapter.dart
index 90b2e5c9..4c46b622 100644
--- a/lib/src/core/network/atproto/data/adapters/bsky/feed_adapter.dart
+++ b/lib/src/core/network/atproto/data/adapters/bsky/feed_adapter.dart
@@ -573,7 +573,7 @@ class BskyFeedAdapter {
     switch (parent) {
       case bsky_defs.UThreadViewPostParentThreadViewPost(:final data):
         return convertBskyThreadToSparkThread(
-          thread: UFeedGetPostThreadThread.threadViewPost(data: data),
+          thread: UFeedGetPostThreadOutputThread.threadViewPost(data: data),
           uri: uri,
         );
       case bsky_defs.UThreadViewPostParentNotFoundPost(:final data):
@@ -595,11 +595,11 @@ class BskyFeedAdapter {
   /// to Spark Thread models. Handles all thread types: normal posts,
   /// not found posts, and blocked posts.
   Thread convertBskyThreadToSparkThread({
-    required UFeedGetPostThreadThread thread,
+    required UFeedGetPostThreadOutputThread thread,
     required AtUri uri,
   }) {
     switch (thread) {
-      case UFeedGetPostThreadThreadThreadViewPost(:final data):
+      case UFeedGetPostThreadOutputThreadThreadViewPost(:final data):
         try {
           var embed = data.post.embed;
           if (data.post.embed is bsky_defs.UPostViewEmbedEmbedExternalView) {
@@ -659,7 +659,7 @@ class BskyFeedAdapter {
                         return null;
                       }
                       return convertBskyThreadToSparkThread(
-                        thread: UFeedGetPostThreadThread.threadViewPost(
+                        thread: UFeedGetPostThreadOutputThread.threadViewPost(
                           data: data,
                         ),
                         uri: data.post.uri,
@@ -688,9 +688,9 @@ class BskyFeedAdapter {
         } catch (e) {
           rethrow;
         }
-      case UFeedGetPostThreadThreadNotFoundPost(:final data):
+      case UFeedGetPostThreadOutputThreadNotFoundPost(:final data):
         return Thread.notFoundPost(uri: data.uri, notFound: true);
-      case UFeedGetPostThreadThreadBlockedPost(:final data):
+      case UFeedGetPostThreadOutputThreadBlockedPost(:final data):
         return Thread.blockedPost(
           uri: data.uri,
           blocked: true,
diff --git a/lib/src/core/network/atproto/data/models/feed_models.dart b/lib/src/core/network/atproto/data/models/feed_models.dart
index ef484b36..024265e2 100644
--- a/lib/src/core/network/atproto/data/models/feed_models.dart
+++ b/lib/src/core/network/atproto/data/models/feed_models.dart
@@ -589,6 +589,11 @@ sealed class ThreadPost with _$ThreadPost {
     ThreadReplyView(:final reply) => reply.indexedAt,
   };
 
+  List<Label>? get labels => switch (this) {
+    ThreadPostView(:final post) => post.labels,
+    ThreadReplyView(:final reply) => reply.labels,
+  };
+
   String get videoUrl => switch (this) {
     ThreadPostView(:final post) => post.videoUrl,
     ThreadReplyView() => '', // Replies cannot have videos
@@ -630,7 +635,7 @@ sealed class Thread with _$Thread {
   /// Delegates to [bskyFeedAdapter.convertBskyThreadToSparkThread] which
   /// handles all Bluesky-specific conversion logic.
   factory Thread.fromBsky({
-    required UFeedGetPostThreadThread thread,
+    required UFeedGetPostThreadOutputThread thread,
     required AtUri uri,
   }) {
     return bskyFeedAdapter.convertBskyThreadToSparkThread(
diff --git a/lib/src/core/network/atproto/data/models/labeler_models.dart b/lib/src/core/network/atproto/data/models/labeler_models.dart
index ab1d5f40..0059700f 100644
--- a/lib/src/core/network/atproto/data/models/labeler_models.dart
+++ b/lib/src/core/network/atproto/data/models/labeler_models.dart
@@ -1,88 +1,6 @@
-import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:sprk_poptart/so/sprk/labeler/defs.dart' as labeler_defs;
 
-part 'labeler_models.freezed.dart';
-part 'labeler_models.g.dart';
-
 typedef LabelerView = labeler_defs.LabelerView;
 typedef LabelerViewDetailed = labeler_defs.LabelerViewDetailed;
 typedef LabelerViewerState = labeler_defs.LabelerViewerState;
 typedef LabelerPolicies = labeler_defs.LabelerPolicies;
-
-const defaultLabels = [
-  '!hide',
-  '!no-promote',
-  '!warn',
-  '!no-unauthenticated',
-  'dmca-violation',
-  'doxxing',
-  'porn',
-  'sexual',
-  'nudity',
-  'nsfl',
-  'gore',
-];
-
-enum Blurs {
-  content('content'),
-  media('media'),
-  none('none');
-
-  final String value;
-  const Blurs(this.value);
-
-  static Blurs fromValue(String value) {
-    if (Blurs.values.any((e) => e.value == value)) {
-      return Blurs.values.firstWhere((e) => e.value == value);
-    }
-    throw Exception('Invalid blur: $value');
-  }
-}
-
-enum Severity {
-  alert('alert'),
-  inform('inform'),
-  none('none');
-
-  final String value;
-  const Severity(this.value);
-
-  static Severity fromValue(String value) {
-    if (Severity.values.any((e) => e.value == value)) {
-      return Severity.values.firstWhere((e) => e.value == value);
-    }
-    throw Exception('Invalid severity: $value');
-  }
-}
-
-enum Setting {
-  hide('hide'),
-  warn('warn'),
-  ignore('ignore');
-
-  final String value;
-  const Setting(this.value);
-
-  static Setting fromValue(String value) {
-    if (Setting.values.any((e) => e.value == value)) {
-      return Setting.values.firstWhere((e) => e.value == value);
-    }
-    throw Exception('Invalid default setting: $value');
-  }
-}
-
-@freezed
-abstract class LabelPreference with _$LabelPreference {
-  factory LabelPreference({
-    required String value,
-    required Blurs blurs,
-    required Severity severity,
-    required Setting defaultSetting,
-    required Setting setting,
-    required bool adultOnly,
-  }) = _LabelPreference;
-  const LabelPreference._();
-
-  factory LabelPreference.fromJson(Map<String, dynamic> json) =>
-      _$LabelPreferenceFromJson(json);
-}
diff --git a/lib/src/core/network/atproto/data/models/moderated_story_view.dart b/lib/src/core/network/atproto/data/models/moderated_story_view.dart
new file mode 100644
index 00000000..f276e7eb
--- /dev/null
+++ b/lib/src/core/network/atproto/data/models/moderated_story_view.dart
@@ -0,0 +1,29 @@
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:poptart/poptart.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/record_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/story_embed_models.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+/// App-owned story data layered around the generated protocol view.
+final class ModeratedStoryView {
+  ModeratedStoryView({
+    required this.story,
+    Iterable<Label> moderationLabels = const [],
+  }) : moderationLabels = List.unmodifiable(moderationLabels);
+
+  final StoryView story;
+  final List<Label> moderationLabels;
+
+  AtUri get uri => story.uri;
+  String get cid => story.cid;
+  ProfileViewBasic get author => story.author;
+  DateTime get indexedAt => story.indexedAt;
+  Map<String, dynamic> get record => story.record;
+  StoryRecord? get localRecord => story.localRecord;
+  List<StoryEmbedView>? get localEmbeds => story.localEmbeds;
+  bool get isVideoStory => story.isVideoStory;
+  String get videoUrl => story.videoUrl;
+  String get imageUrl => story.imageUrl;
+  String get thumbnailUrl => story.thumbnailUrl;
+}
diff --git a/lib/src/core/network/atproto/data/models/pref_models.dart b/lib/src/core/network/atproto/data/models/pref_models.dart
index cdff5bc6..c7ddf5f3 100644
--- a/lib/src/core/network/atproto/data/models/pref_models.dart
+++ b/lib/src/core/network/atproto/data/models/pref_models.dart
@@ -1,4 +1,5 @@
 import 'package:poptart/poptart.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs/adult_content_pref.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs/content_label_pref.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs/content_label_pref_visibility.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs/labeler_pref_item.dart';
@@ -10,6 +11,7 @@ import 'package:sprk_poptart/so/sprk/actor/defs/saved_feeds_pref.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs/union_preferences.dart';
 import 'package:sprk_poptart/so/sprk/actor/get_preferences/output.dart';
 
+export 'package:sprk_poptart/so/sprk/actor/defs/adult_content_pref.dart';
 export 'package:sprk_poptart/so/sprk/actor/defs/content_label_pref.dart';
 export 'package:sprk_poptart/so/sprk/actor/defs/content_label_pref_visibility.dart';
 export 'package:sprk_poptart/so/sprk/actor/defs/feed_view_pref.dart';
@@ -74,7 +76,18 @@ Preference contentLabelPreference({
   );
 }
 
+Preference adultContentPreference({required bool enabled}) =>
+    Preference.adultContentPref(data: AdultContentPref(enabled: enabled));
+
 extension PreferencesConvenience on Preferences {
+  bool get adultContentEnabled {
+    for (final preference in preferences) {
+      final adultContentPref = preference.adultContentPref;
+      if (adultContentPref != null) return adultContentPref.enabled;
+    }
+    return false;
+  }
+
   List<ContentLabelPref>? get contentLabelPrefs {
     final prefs = preferences
         .map((preference) => preference.contentLabelPref)
@@ -153,7 +166,3 @@ extension PreferencesConvenience on Preferences {
 extension SavedFeedConvenience on SavedFeed {
   String get typeValue => type.toJson();
 }
-
-extension ContentLabelPrefConvenience on ContentLabelPref {
-  String get visibilityValue => visibility.toJson();
-}
diff --git a/lib/src/core/network/atproto/data/models/record_models.dart b/lib/src/core/network/atproto/data/models/record_models.dart
index c8dd4e26..2e4ba95c 100644
--- a/lib/src/core/network/atproto/data/models/record_models.dart
+++ b/lib/src/core/network/atproto/data/models/record_models.dart
@@ -77,6 +77,8 @@ abstract class Record with _$Record {
 }
 
 extension StoryRecordConvenience on StoryRecord {
+  List<SelfLabel>? get selfLabels => labels?.selfLabels?.values;
+
   List<StoryEmbed> get localEmbeds =>
       embeds
           ?.map(
diff --git a/lib/src/core/network/atproto/data/repositories/actor_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/actor_repository_impl.dart
index 70c5a2ca..71b04a7b 100644
--- a/lib/src/core/network/atproto/data/repositories/actor_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/actor_repository_impl.dart
@@ -58,6 +58,7 @@ class ActorRepositoryImpl implements ActorRepository {
         final profile = await bskyActorAdapter.getProfileFromBluesky(
           blueskyClient,
           did,
+          headers: _client.appViewHeaders(_client.bskyDid),
         );
         _logger.d('Profile retrieved successfully from Bluesky');
         return profile;
@@ -67,7 +68,7 @@ class ActorRepositoryImpl implements ActorRepository {
       final result = await atproto.call(
         sprk_get_profile.soSprkActorGetProfile,
         parameters: sprk_get_profile.ActorGetProfileInput(actor: did),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       _logger.d('Profile retrieved successfully from Spark');
       return result.data;
@@ -100,7 +101,7 @@ class ActorRepositoryImpl implements ActorRepository {
       final result = await atproto.call(
         soSprkActorSearchActors,
         parameters: ActorSearchActorsInput(q: query, cursor: cursor),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
 
       _logger.d('Actor search completed successfully');
@@ -127,7 +128,7 @@ class ActorRepositoryImpl implements ActorRepository {
           q: query,
           limit: clampedLimit,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
 
       _logger.d('Actor typeahead search completed successfully');
@@ -151,6 +152,7 @@ class ActorRepositoryImpl implements ActorRepository {
     final response = await client.call(
       soSprkActorSearchActorsTypeahead,
       parameters: ActorSearchActorsTypeaheadInput(q: query, limit: limit),
+      headers: _client.appViewHeaders(null),
     );
 
     return response.data;
@@ -253,6 +255,7 @@ class ActorRepositoryImpl implements ActorRepository {
         final profiles = await bskyActorAdapter.getProfilesFromBluesky(
           blueskyClient,
           dids,
+          headers: _client.appViewHeaders(_client.bskyDid),
         );
         _logger.d('Profiles retrieved successfully from Bluesky');
         return profiles;
@@ -262,7 +265,7 @@ class ActorRepositoryImpl implements ActorRepository {
       final result = await atproto.call(
         sprk_get_profiles.soSprkActorGetProfiles,
         parameters: sprk_get_profiles.ActorGetProfilesInput(actors: dids),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       _logger.d('Profiles retrieved successfully from Spark');
       return result.data.profiles;
diff --git a/lib/src/core/network/atproto/data/repositories/feed_repository.dart b/lib/src/core/network/atproto/data/repositories/feed_repository.dart
index f7440ff6..8044b279 100644
--- a/lib/src/core/network/atproto/data/repositories/feed_repository.dart
+++ b/lib/src/core/network/atproto/data/repositories/feed_repository.dart
@@ -145,6 +145,7 @@ abstract class FeedRepository {
   /// [crosspostToBsky] Whether to also post to Bluesky
   /// [facets] Optional list of facets for text formatting (mentions, links, etc.)
   /// [soundRef] Optional reusable sound reference for Spark image/carousel posts.
+  /// [selfLabels] Optional author-applied content warnings.
   Future<RepoStrongRef> postImages(
     String text,
     List<XFile> imageFiles,
@@ -152,6 +153,7 @@ abstract class FeedRepository {
     bool crosspostToBsky = false,
     List<Facet> facets = const [],
     RepoStrongRef? soundRef,
+    List<SelfLabel>? selfLabels,
   });
 
   /// Upload images to the server
@@ -218,19 +220,6 @@ abstract class FeedRepository {
     String sort = 'newest',
   });
 
-  /// Get labels for a list of URIs
-  ///
-  /// [uris] List of post URIs to fetch labels for
-  /// [sources] Optional list of label sources (DIDs) to filter on.
-  /// [limit] Optional limit on the number of labels to return.
-  /// [cursor] Optional pagination cursor.
-  Future<({List<Label> labels, String? cursor})> getLabels(
-    List<AtUri> uris, {
-    List<String>? sources,
-    int? limit,
-    String? cursor,
-  });
-
   /// Search for posts
   /// [query] The search query string
   /// [limit] The number of items to return (default 20)
diff --git a/lib/src/core/network/atproto/data/repositories/feed_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/feed_repository_impl.dart
index 393705bc..c6b53e68 100644
--- a/lib/src/core/network/atproto/data/repositories/feed_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/feed_repository_impl.dart
@@ -2,8 +2,6 @@ import 'dart:typed_data';
 import 'dart:ui' as ui;
 
 import 'package:poptart_lex/com/atproto/label/defs.dart';
-import 'package:poptart_lex/com/atproto/label/query_labels.dart'
-    as label_query_labels;
 import 'package:bluesky_poptart/app/bsky/feed/get_author_feed.dart'
     as bsky_feed_get_author_feed;
 import 'package:bluesky_poptart/app/bsky/feed/get_feed.dart'
@@ -87,12 +85,6 @@ class FeedRepositoryImpl implements FeedRepository {
   final DateTime Function() _now;
   late final VideoUploadService _videoUploadService;
 
-  /// Formats labeler DIDs into the atproto-accept-labelers header format
-  /// Format: "did1,did2,did3" (comma-separated list)
-  String _formatLabelerHeader(List<String> labelerDids) {
-    return labelerDids.join(',');
-  }
-
   bool _postViewHasMedia(PostView post) => post.hasSupportedMedia;
 
   bool _feedViewPostHasMedia(FeedViewPost feedViewPost) {
@@ -217,6 +209,7 @@ class FeedRepositoryImpl implements FeedRepository {
       final posts = await blueskyClient.call(
         bsky_feed_get_posts.appBskyFeedGetPosts,
         parameters: bsky_feed_get_posts.FeedGetPostsInput(uris: uris),
+        headers: _client.appViewHeaders(_client.bskyDid),
       );
 
       // Use adapter to process Bluesky posts
@@ -237,13 +230,10 @@ class FeedRepositoryImpl implements FeedRepository {
         throw Exception('AtProto not initialized');
       }
 
-      final headers = <String, String>{'atproto-proxy': _client.sprkDid};
-      // Note: labeler header could be added here if needed for getPosts
-
       final result = await atproto.call(
         sprk_get_posts.soSprkFeedGetPosts,
         parameters: sprk_get_posts.FeedGetPostsInput(uris: uris),
-        headers: headers,
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final posts = result.data.toJson()['posts']! as List<dynamic>;
       _logger.d(
@@ -326,12 +316,13 @@ class FeedRepositoryImpl implements FeedRepository {
             limit: limit,
             cursor: cursor,
             filter: videosOnly
-                ? sprk_get_author_feed.FeedGetAuthorFeedFilter.valueOf(
+                ? sprk_get_author_feed
+                      .FeedGetAuthorFeedParametersFilter.valueOf(
                     'posts_with_video',
                   )
                 : null,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
         final output = result.data;
         final outputJson = output.toJson();
@@ -387,10 +378,12 @@ class FeedRepositoryImpl implements FeedRepository {
                 limit: limit,
                 cursor: cursor,
                 filter:
-                    bsky_feed_get_author_feed.FeedGetAuthorFeedFilter.valueOf(
+                    bsky_feed_get_author_feed
+                        .FeedGetAuthorFeedParametersFilter.valueOf(
                       videosOnly ? 'posts_with_video' : 'posts_with_media',
                     ),
               ),
+              headers: _client.appViewHeaders(_client.bskyDid),
             );
 
         // Use adapter to process Bluesky author feed
@@ -425,18 +418,16 @@ class FeedRepositoryImpl implements FeedRepository {
         throw Exception('AtProto not initialized');
       }
 
-      final headers = <String, String>{'atproto-proxy': _client.sprkDid};
-      if (labelerDids != null && labelerDids.isNotEmpty) {
-        headers['atproto-accept-labelers'] = _formatLabelerHeader(labelerDids);
-      }
-
       final result = await atproto.call(
         sprk_get_timeline.soSprkFeedGetTimeline,
         parameters: sprk_get_timeline.FeedGetTimelineInput(
           limit: limit,
           cursor: cursor,
         ),
-        headers: headers,
+        headers: _client.appViewHeaders(
+          _client.sprkDid,
+          labelerDids: labelerDids,
+        ),
       );
       final output = result.data;
       final feedData = output.toJson()['feed'] as List<dynamic>;
@@ -496,12 +487,10 @@ class FeedRepositoryImpl implements FeedRepository {
       final isBskyFeed =
           feedUri.collection == NSID.parse('app.bsky.feed.generator');
 
-      final headers = <String, String>{
-        'atproto-proxy': isBskyFeed ? _client.bskyDid : _client.sprkDid,
-      };
-      if (!isBskyFeed && labelerDids != null && labelerDids.isNotEmpty) {
-        headers['atproto-accept-labelers'] = _formatLabelerHeader(labelerDids);
-      }
+      final headers = _client.appViewHeaders(
+        isBskyFeed ? _client.bskyDid : _client.sprkDid,
+        labelerDids: labelerDids,
+      );
 
       final FeedView feedView;
       if (isBskyFeed) {
@@ -575,9 +564,9 @@ class FeedRepositoryImpl implements FeedRepository {
         throw Exception('AtProto not initialized');
       }
 
-      final headers = isBskyFeed
-          ? {'atproto-proxy': _client.bskyDid}
-          : {'atproto-proxy': _client.sprkDid};
+      final headers = _client.appViewHeaders(
+        isBskyFeed ? _client.bskyDid : _client.sprkDid,
+      );
       if (isBskyFeed) {
         final response = await atproto.call(
           bsky_feed_get_feed_generator.appBskyFeedGetFeedGenerator,
@@ -624,9 +613,9 @@ class FeedRepositoryImpl implements FeedRepository {
         throw Exception('AtProto not initialized');
       }
 
-      final headers = bluesky
-          ? {'atproto-proxy': _client.bskyDid}
-          : {'atproto-proxy': _client.sprkDid};
+      final headers = _client.appViewHeaders(
+        bluesky ? _client.bskyDid : _client.sprkDid,
+      );
       final List<dynamic> feedsData;
       if (bluesky) {
         final response = await atproto.call(
@@ -682,9 +671,9 @@ class FeedRepositoryImpl implements FeedRepository {
         throw Exception('AtProto not initialized');
       }
 
-      final headers = bluesky
-          ? {'atproto-proxy': _client.bskyDid}
-          : {'atproto-proxy': _client.sprkDid};
+      final headers = _client.appViewHeaders(
+        bluesky ? _client.bskyDid : _client.sprkDid,
+      );
       final List<dynamic> feedsData;
       if (bluesky) {
         final response = await atproto.call(
@@ -1043,6 +1032,7 @@ class FeedRepositoryImpl implements FeedRepository {
     bool crosspostToBsky = false,
     List<Facet> facets = const [],
     RepoStrongRef? soundRef,
+    List<SelfLabel>? selfLabels,
   }) async {
     if (imageFiles.isEmpty) {
       _logger.e('No images provided for image post');
@@ -1070,6 +1060,7 @@ class FeedRepositoryImpl implements FeedRepository {
       media: Media.images(images: uploadedImageMaps),
       createdAt: _now().toUtc(),
       sound: soundRef,
+      selfLabels: selfLabels,
     );
 
     final result = await _client.repo.createRecord(
@@ -1090,6 +1081,7 @@ class FeedRepositoryImpl implements FeedRepository {
           result,
           altTexts,
           facets,
+          selfLabels,
         );
         finalResult = await _client.repo.editRecordJson(
           uri: result.uri,
@@ -1251,6 +1243,7 @@ class FeedRepositoryImpl implements FeedRepository {
     RepoStrongRef sparkPostData,
     Map<String, String> altTexts,
     List<Facet> sparkFacets,
+    List<SelfLabel>? selfLabels,
   ) async {
     _logger.d('Crossposting to Bluesky with ${sparkImages.length} images');
 
@@ -1307,9 +1300,14 @@ class FeedRepositoryImpl implements FeedRepository {
       facets: bskyFacets.isNotEmpty ? bskyFacets : null,
     );
 
+    final bskyPostJson = bskyPost.toJson();
+    if (selfLabels != null && selfLabels.isNotEmpty) {
+      bskyPostJson['labels'] = SelfLabels(values: selfLabels).toJson();
+    }
+
     final bskyResult = await _client.repo.createRecord(
       collection: 'app.bsky.feed.post',
-      record: bskyPost.toJson(),
+      record: bskyPostJson,
       rkey: sparkPostData.uri.rkey,
     );
 
@@ -1397,6 +1395,7 @@ class FeedRepositoryImpl implements FeedRepository {
             depth: depth,
             parentHeight: parentHeight,
           ),
+          headers: _client.appViewHeaders(_client.bskyDid),
         );
         // Use adapter to convert Bluesky thread to Spark thread
         return bskyFeedAdapter.convertBskyThreadToSparkThread(
@@ -1411,7 +1410,7 @@ class FeedRepositoryImpl implements FeedRepository {
           depth: depth,
           parentHeight: parentHeight,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final threadItems = response.data.toJson()['thread']! as List<dynamic>;
       return Thread.fromSparkFlatList(threadItems: threadItems);
@@ -1454,13 +1453,12 @@ class FeedRepositoryImpl implements FeedRepository {
             anchor: anchor,
             depth: depth,
             parentHeight: parentHeight,
-            sort: sprk_get_crosspost_thread.FeedGetCrosspostThreadSort.valueOf(
-              sort,
-            ),
+            sort: sprk_get_crosspost_thread
+                .FeedGetCrosspostThreadParametersSort.valueOf(sort),
             limit: 100,
             cursor: cursor,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
 
         final pageItems =
@@ -1485,64 +1483,6 @@ class FeedRepositoryImpl implements FeedRepository {
     });
   }
 
-  @override
-  Future<({List<Label> labels, String? cursor})> getLabels(
-    List<AtUri> uris, {
-    List<String>? sources,
-    int? limit,
-    String? cursor,
-  }) async {
-    return _client.executeWithRetry(() async {
-      if (!_client.authRepository.isAuthenticated) {
-        _logger.w('Not authenticated');
-        throw Exception('Not authenticated');
-      }
-
-      final atproto = _client.authRepository.atproto;
-      if (atproto == null) {
-        _logger.e('AtProto not initialized');
-        throw Exception('AtProto not initialized');
-      }
-
-      final labels = <Label>[];
-
-      // Use modDid from repository as fallback if no sources provided
-      final defaultLabelerDid = _client.modDid.split('#').first;
-      final labelers = sources?.isNotEmpty ?? true
-          ? sources!
-          : [defaultLabelerDid];
-
-      final parameters = label_query_labels.LabelQueryLabelsInput(
-        uriPatterns: uris.map((uri) => uri.toString()).toList(),
-        sources: labelers,
-        limit: limit ?? 50,
-        cursor: cursor,
-      );
-
-      final response = await atproto.call(
-        label_query_labels.comAtprotoLabelQueryLabels,
-        headers: {'atproto-proxy': _client.modDid},
-        parameters: parameters,
-      );
-      final responseJson = response.data.toJson();
-      _logger
-        ..d('parameters: ${parameters.toJson()}')
-        ..d('Labels retrieved: $responseJson');
-
-      for (final label in responseJson['labels']! as List<dynamic>) {
-        final cleanLabel = label as Map<String, Object?>
-          ..remove('sig')
-          ..putIfAbsent(
-            'src',
-            () => defaultLabelerDid,
-          ); // Use default labeler DID if src is missing from response
-        labels.add(Label.fromJson(cleanLabel));
-      }
-
-      return (labels: labels, cursor: responseJson['cursor'] as String?);
-    });
-  }
-
   @override
   Future<({List<PostView> posts, String? cursor})> searchPosts(
     String query, {
@@ -1572,10 +1512,10 @@ class FeedRepositoryImpl implements FeedRepository {
         parameters: sprk_search_posts.FeedSearchPostsInput(
           q: query,
           limit: limit,
-          sort: sprk_search_posts.FeedSearchPostsSort.valueOf(sort),
+          sort: sprk_search_posts.FeedSearchPostsParametersSort.valueOf(sort),
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
 
       final output = response.data;
@@ -1621,7 +1561,7 @@ class FeedRepositoryImpl implements FeedRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final output = result.data;
       _logger.d('Likes retrieved successfully: ${output.likes.length} actors');
@@ -1664,7 +1604,7 @@ class FeedRepositoryImpl implements FeedRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final output = result.data;
       final rawFeed = output.toJson()['feed']! as List<dynamic>;
@@ -1733,7 +1673,7 @@ class FeedRepositoryImpl implements FeedRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final output = result.data;
       final rawFeed = output.toJson()['feed']! as List<dynamic>;
diff --git a/lib/src/core/network/atproto/data/repositories/graph_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/graph_repository_impl.dart
index 87936c4c..4ba220d9 100644
--- a/lib/src/core/network/atproto/data/repositories/graph_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/graph_repository_impl.dart
@@ -61,7 +61,7 @@ class GraphRepositoryImpl implements GraphRepository {
             actor: did,
             cursor: cursor,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
         _logger.d('Followers retrieved successfully');
         return result.data;
@@ -98,7 +98,7 @@ class GraphRepositoryImpl implements GraphRepository {
             actor: did,
             cursor: cursor,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
         _logger.d('Known followers retrieved successfully');
         return result.data;
@@ -137,7 +137,7 @@ class GraphRepositoryImpl implements GraphRepository {
             actor: did,
             cursor: cursor,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
         _logger.d('Follows retrieved successfully');
         return result.data;
@@ -256,7 +256,7 @@ class GraphRepositoryImpl implements GraphRepository {
         final result = await atproto.call(
           sprk_get_blocks.soSprkGraphGetBlocks,
           parameters: sprk_get_blocks.GraphGetBlocksInput(cursor: cursor),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
         _logger.d('Blocks retrieved successfully');
         return result.data;
diff --git a/lib/src/core/network/atproto/data/repositories/labeler_repository.dart b/lib/src/core/network/atproto/data/repositories/labeler_repository.dart
index bb6b9e8e..b6ec930f 100644
--- a/lib/src/core/network/atproto/data/repositories/labeler_repository.dart
+++ b/lib/src/core/network/atproto/data/repositories/labeler_repository.dart
@@ -1,7 +1,91 @@
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/admin/defs.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
+import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
 
+class LabelerServiceUnavailableException implements Exception {
+  const LabelerServiceUnavailableException(this.message);
+
+  final String message;
+
+  @override
+  String toString() => message;
+}
+
+final class ModerationServiceQuery {
+  const ModerationServiceQuery({
+    required this.fallbackDid,
+    required this.subjectType,
+    required this.reasonType,
+    this.subjectCollection,
+  });
+
+  final String fallbackDid;
+  final String subjectType;
+  final String reasonType;
+  final String? subjectCollection;
+
+  factory ModerationServiceQuery.forReport({
+    required String fallbackDid,
+    required UModerationCreateReportSubject subject,
+    required String reasonType,
+  }) {
+    final data = subject.data;
+    return switch (data) {
+      RepoStrongRef(:final uri) => ModerationServiceQuery(
+        fallbackDid: fallbackDid,
+        subjectType: 'record',
+        subjectCollection: uri.collection.toString(),
+        reasonType: reasonType,
+      ),
+      RepoRef() => ModerationServiceQuery(
+        fallbackDid: fallbackDid,
+        subjectType: 'account',
+        reasonType: reasonType,
+      ),
+      _ => throw ArgumentError.value(
+        data,
+        'subject',
+        'Unsupported report subject',
+      ),
+    };
+  }
+}
+
+final class CompatibleModerationService {
+  const CompatibleModerationService({
+    required this.did,
+    required this.displayName,
+    required this.isDefault,
+  });
+
+  final String did;
+  final String displayName;
+  final bool isDefault;
+}
+
 /// Interface for Feed-related API endpoints
 abstract class LabelerRepository {
+  /// Resolves a DID or handle to the canonical service DID.
+  Future<String> resolveIdentifier(String identifier);
+
+  /// Verifies that [did] is advertised by the configured labeler appview.
+  Future<void> validateService(String did);
+
   Future<LabelerView> getServices(List<String> dids);
   Future<LabelerViewDetailed> getServicesDetailed(List<String> dids);
+
+  Future<({List<Label> labels, String? cursor})> queryLabels(
+    List<AtUri> uris, {
+    List<String>? sources,
+    int? limit,
+    String? cursor,
+  });
+
+  Future<List<CompatibleModerationService>> getCompatibleModerationServices(
+    Iterable<String> dids,
+    ModerationServiceQuery query,
+  );
 }
diff --git a/lib/src/core/network/atproto/data/repositories/labeler_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/labeler_repository_impl.dart
index b5ce3b04..cd0131f8 100644
--- a/lib/src/core/network/atproto/data/repositories/labeler_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/labeler_repository_impl.dart
@@ -1,4 +1,9 @@
 import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/identity/resolve_handle.dart'
+    as identity_resolve_handle;
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:poptart_lex/com/atproto/label/query_labels.dart'
+    as label_query_labels;
 import 'package:get_it/get_it.dart';
 import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
@@ -7,7 +12,7 @@ import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 import 'package:sprk_poptart/so/sprk/labeler/get_services.dart'
     as sprk_get_services;
-import 'package:sprk_poptart/so/sprk/labeler/get_services/union_main_views.dart';
+import 'package:sprk_poptart/so/sprk/labeler/get_services/union_main_output_views.dart';
 
 class LabelerRepositoryImpl extends LabelerRepository {
   LabelerRepositoryImpl(this._client, {SparkLogger? logger})
@@ -16,6 +21,91 @@ class LabelerRepositoryImpl extends LabelerRepository {
   }
   final SprkRepository _client;
   final SparkLogger _logger;
+  final Map<String, Future<LabelerViewDetailed>> _detailedServiceCache = {};
+
+  @override
+  Future<String> resolveIdentifier(String identifier) async {
+    final normalized = identifier.trim().replaceFirst(RegExp(r'^@'), '');
+    if (normalized.startsWith('did:')) {
+      return normalized.split('#').first;
+    }
+    if (normalized.isEmpty) {
+      throw ArgumentError.value(identifier, 'identifier', 'Cannot be empty');
+    }
+
+    return _client.executeWithRetry(() async {
+      final atproto = _client.authRepository.atproto;
+      if (atproto == null) {
+        throw Exception('AtProto not initialized');
+      }
+      final result = await atproto.call(
+        identity_resolve_handle.comAtprotoIdentityResolveHandle,
+        parameters: identity_resolve_handle.IdentityResolveHandleInput(
+          handle: normalized,
+        ),
+      );
+      return result.data.did;
+    });
+  }
+
+  @override
+  Future<void> validateService(String did) async {
+    final service = await getServicesDetailed([did]);
+    if (service.creator.did != did) {
+      throw const LabelerServiceUnavailableException(
+        'Labeler service DID does not match requested DID',
+      );
+    }
+    if (service.labels?.any(
+          (label) => label.val == '!takedown' && label.neg != true,
+        ) ??
+        false) {
+      throw LabelerServiceUnavailableException(
+        'Labeler service is taken down: $did',
+      );
+    }
+  }
+
+  @override
+  Future<({List<Label> labels, String? cursor})> queryLabels(
+    List<AtUri> uris, {
+    List<String>? sources,
+    int? limit,
+    String? cursor,
+  }) async {
+    return _client.executeWithRetry(() async {
+      if (!_client.authRepository.isAuthenticated) {
+        _logger.w('Not authenticated');
+        throw Exception('Not authenticated');
+      }
+
+      final atproto = _client.authRepository.atproto;
+      if (atproto == null) {
+        _logger.e('AtProto not initialized');
+        throw Exception('AtProto not initialized');
+      }
+
+      final labelers = sources != null && sources.isNotEmpty
+          ? sources
+          : _client.labelerDids;
+      final parameters = label_query_labels.LabelQueryLabelsInput(
+        uriPatterns: uris.map((uri) => uri.toString()).toList(),
+        sources: labelers,
+        limit: limit ?? 50,
+        cursor: cursor,
+      );
+      final response = await atproto.call(
+        label_query_labels.comAtprotoLabelQueryLabels,
+        headers: {'atproto-proxy': _client.modDid},
+        parameters: parameters,
+      );
+      _logger
+        ..d('parameters: ${parameters.toJson()}')
+        ..d('Labels retrieved: ${response.data.toJson()}');
+
+      return (labels: response.data.labels, cursor: response.data.cursor);
+    });
+  }
 
   @override
   Future<LabelerView> getServices(List<String> dids) async {
@@ -38,18 +128,22 @@ class LabelerRepositoryImpl extends LabelerRepository {
           dids: dids,
           detailed: false,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       if (result.status != HttpStatus.ok) {
         _logger.e('Failed to retrieve labeler services for DIDs: $dids');
         throw Exception('Failed to retrieve labeler services for DIDs: $dids');
       }
       if (result.data.views.isEmpty) {
-        throw Exception('No labeler services returned for DIDs: $dids');
+        throw LabelerServiceUnavailableException(
+          'No labeler services returned for DIDs: $dids',
+        );
       }
       final view = result.data.views.first.labelerView;
       if (view == null) {
-        throw Exception('No basic labeler service returned for DIDs: $dids');
+        throw LabelerServiceUnavailableException(
+          'No basic labeler service returned for DIDs: $dids',
+        );
       }
       _logger.d('Labeler services retrieved successfully');
       return view;
@@ -58,6 +152,23 @@ class LabelerRepositoryImpl extends LabelerRepository {
 
   @override
   Future<LabelerViewDetailed> getServicesDetailed(List<String> dids) async {
+    if (dids.length != 1) return _fetchServicesDetailed(dids);
+
+    final did = dids.single;
+    final request = _detailedServiceCache.putIfAbsent(
+      did,
+      () => _fetchServicesDetailed(dids),
+    );
+    try {
+      return await request;
+    } finally {
+      if (identical(_detailedServiceCache[did], request)) {
+        _detailedServiceCache.remove(did);
+      }
+    }
+  }
+
+  Future<LabelerViewDetailed> _fetchServicesDetailed(List<String> dids) async {
     _logger.d('Getting detailed labeler services for DIDs: $dids');
     return _client.executeWithRetry(() async {
       if (!_client.authRepository.isAuthenticated) {
@@ -77,21 +188,88 @@ class LabelerRepositoryImpl extends LabelerRepository {
           dids: dids,
           detailed: true,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       if (result.status != HttpStatus.ok) {
         _logger.e('Failed to retrieve labeler services for DIDs: $dids');
         throw Exception('Failed to retrieve labeler services for DIDs: $dids');
       }
       if (result.data.views.isEmpty) {
-        throw Exception('No labeler services returned for DIDs: $dids');
+        throw LabelerServiceUnavailableException(
+          'No labeler services returned for DIDs: $dids',
+        );
       }
       final view = result.data.views.first.labelerViewDetailed;
       if (view == null) {
-        throw Exception('No detailed labeler service returned for DIDs: $dids');
+        throw LabelerServiceUnavailableException(
+          'No detailed labeler service returned for DIDs: $dids',
+        );
       }
       _logger.d('Labeler services retrieved successfully');
       return view;
     });
   }
+
+  @override
+  Future<List<CompatibleModerationService>> getCompatibleModerationServices(
+    Iterable<String> dids,
+    ModerationServiceQuery query,
+  ) async {
+    final fallbackDid = query.fallbackDid.split('#').first;
+    final candidates = <String>{fallbackDid, ...dids};
+    final services = await Future.wait([
+      for (final did in candidates)
+        _compatibleService(did, fallbackDid: fallbackDid, query: query),
+    ]);
+    final compatible = services.nonNulls.toList()
+      ..sort((left, right) {
+        if (left.isDefault != right.isDefault) {
+          return left.isDefault ? -1 : 1;
+        }
+        return left.displayName.compareTo(right.displayName);
+      });
+    return compatible;
+  }
+
+  Future<CompatibleModerationService?> _compatibleService(
+    String did, {
+    required String fallbackDid,
+    required ModerationServiceQuery query,
+  }) async {
+    try {
+      final service = await getServicesDetailed([did]);
+      final subjectTypes = service.subjectTypes?.map((type) => type.toJson());
+      if (subjectTypes != null && !subjectTypes.contains(query.subjectType)) {
+        return null;
+      }
+      if (query.subjectCollection != null &&
+          service.subjectCollections != null &&
+          !service.subjectCollections!.contains(query.subjectCollection)) {
+        return null;
+      }
+      final reasonTypes = service.reasonTypes?.map((type) => type.toJson());
+      if (reasonTypes != null && !reasonTypes.contains(query.reasonType)) {
+        return null;
+      }
+      return CompatibleModerationService(
+        did: did,
+        displayName: service.creator.displayName ?? service.creator.handle,
+        isDefault: did == fallbackDid,
+      );
+    } catch (error, stackTrace) {
+      _logger.w(
+        'Unable to inspect moderation service capabilities for $did',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      if (did == fallbackDid) {
+        return CompatibleModerationService(
+          did: did,
+          displayName: did,
+          isDefault: true,
+        );
+      }
+      return null;
+    }
+  }
 }
diff --git a/lib/src/core/network/atproto/data/repositories/notification_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/notification_repository_impl.dart
index 17be026d..0b073597 100644
--- a/lib/src/core/network/atproto/data/repositories/notification_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/notification_repository_impl.dart
@@ -65,7 +65,7 @@ class NotificationRepositoryImpl implements NotificationRepository {
           priority: priority,
           reasons: reasons == null || reasons.isEmpty ? null : reasons,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
 
       _logger.d('Notifications retrieved successfully');
@@ -93,7 +93,7 @@ class NotificationRepositoryImpl implements NotificationRepository {
         parameters: sprk_get_unread_count.NotificationGetUnreadCountInput(
           priority: priority,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
 
       final output = result.data;
@@ -160,10 +160,10 @@ class NotificationRepositoryImpl implements NotificationRepository {
         serviceDid: serviceDid,
         token: token,
         platform:
-            sprk_register_push.NotificationRegisterPushPlatform.valueOf(
+            sprk_register_push.NotificationRegisterPushInputPlatform.valueOf(
               platform,
             ) ??
-            sprk_register_push.NotificationRegisterPushPlatform.unknown(
+            sprk_register_push.NotificationRegisterPushInputPlatform.unknown(
               data: platform,
             ),
         appId: appId,
@@ -205,10 +205,10 @@ class NotificationRepositoryImpl implements NotificationRepository {
         serviceDid: serviceDid,
         token: token,
         platform:
-            sprk_unregister_push.NotificationUnregisterPushPlatform.valueOf(
-              platform,
-            ) ??
-            sprk_unregister_push.NotificationUnregisterPushPlatform.unknown(
+            sprk_unregister_push
+                .NotificationUnregisterPushInputPlatform.valueOf(platform) ??
+            sprk_unregister_push
+                .NotificationUnregisterPushInputPlatform.unknown(
               data: platform,
             ),
         appId: appId,
diff --git a/lib/src/core/network/atproto/data/repositories/repo_repository.dart b/lib/src/core/network/atproto/data/repositories/repo_repository.dart
index 7e44ac3e..e5239e7a 100644
--- a/lib/src/core/network/atproto/data/repositories/repo_repository.dart
+++ b/lib/src/core/network/atproto/data/repositories/repo_repository.dart
@@ -73,11 +73,10 @@ abstract class RepoRepository {
   /// [subject] The subject of the report (content or account)
   /// [reasonType] The reason for the report
   /// [reason] Optional additional context about the violation
-  /// [service] Optional moderation service to use
+  /// [serviceDid] Moderation service receiving the report
   ///
-  /// Returns true if the report was successfully created
-  Future<bool> createReport({
+  Future<void> createReport({
     required ModerationCreateReportInput input,
-    dynamic service,
+    required String serviceDid,
   });
 }
diff --git a/lib/src/core/network/atproto/data/repositories/repo_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/repo_repository_impl.dart
index 91438f39..0c069a39 100644
--- a/lib/src/core/network/atproto/data/repositories/repo_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/repo_repository_impl.dart
@@ -259,9 +259,9 @@ class RepoRepositoryImpl implements RepoRepository {
   }
 
   @override
-  Future<bool> createReport({
+  Future<void> createReport({
     required ModerationCreateReportInput input,
-    dynamic service,
+    required String serviceDid,
   }) async {
     _logger.i('Creating moderation report for reason: ${input.reasonType}');
 
@@ -275,61 +275,35 @@ class RepoRepositoryImpl implements RepoRepository {
       if (atproto == null || atproto.oAuthSession == null) {
         _logger.e('AtProto not initialized');
         throw Exception('AtProto not initialized');
-      } else if (service != null) {
-        _logger.d('Using provided moderation service');
-        try {
-          final report = await service.createReport(
-            subject: input.subject,
-            reasonType: input.reasonType,
-            reason: input.reason,
-          );
-          return report.status.code == 200;
-        } catch (e) {
-          _logger.e('Error creating report with service', error: e);
-          throw Exception('Failed to create report: $e');
-        }
-      } else {
-        _logger.d('Using direct API call for moderation report');
-        final subjectData = input.subject.data;
-        if (subjectData is! RepoStrongRef) {
-          _logger.e('Invalid subject data type: ${subjectData.runtimeType}');
-          throw Exception('Invalid subject data');
-        }
+      }
 
-        // Check if this is a Bluesky post and route to appropriate moderation service
-        final isBskyPost = subjectData.uri.collection.toString().startsWith(
-          'app.bsky',
-        );
-        final modServiceDid = isBskyPost ? _client.bskyModDid : _client.modDid;
-        _logger.d(
-          'Routing report to ${isBskyPost ? 'Bluesky' : 'Spark'} moderation '
-          'service: $modServiceDid',
-        );
+      _logger.d('Routing report to moderation service: $serviceDid');
+      final headers = {'atproto-proxy': _moderationProxyDid(serviceDid)};
 
-        final headers = {'atproto-proxy': modServiceDid};
+      try {
+        final response = await atproto.call(
+          comAtprotoModerationCreateReport,
+          headers: headers,
+          input: input,
+        );
 
-        try {
-          final response = await atproto.call(
-            comAtprotoModerationCreateReport,
-            headers: headers,
-            input: input,
+        if (response.status != HttpStatus.ok) {
+          _logger.e(
+            'Failed to create report: ${response.data}',
+            error: 'HTTP ${response.status}',
           );
-
-          if (response.status != HttpStatus.ok) {
-            _logger.e(
-              'Failed to create report: ${response.data}',
-              error: 'HTTP ${response.status}',
-            );
-            throw Exception('Failed to create report: ${response.data}');
-          }
-
-          _logger.i('Report created successfully');
-          return true;
-        } catch (e) {
-          _logger.e('Error creating report', error: e);
-          throw Exception('Failed to create report: $e');
+          throw Exception('Failed to create report: ${response.data}');
         }
+
+        _logger.i('Report created successfully');
+      } catch (e) {
+        _logger.e('Error creating report', error: e);
+        throw Exception('Failed to create report: $e');
       }
     });
   }
+
+  String _moderationProxyDid(String did) {
+    return did.contains('#') ? did : '$did#atproto_labeler';
+  }
 }
diff --git a/lib/src/core/network/atproto/data/repositories/sound_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/sound_repository_impl.dart
index 3985cc36..33eaabb8 100644
--- a/lib/src/core/network/atproto/data/repositories/sound_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/sound_repository_impl.dart
@@ -81,7 +81,7 @@ class SoundRepositoryImpl implements SoundRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final response = AudioPostsResponse.fromJson(result.data.toJson());
 
@@ -115,7 +115,7 @@ class SoundRepositoryImpl implements SoundRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final response = TrendingAudiosResponse.fromJson(result.data.toJson());
 
@@ -158,7 +158,7 @@ class SoundRepositoryImpl implements SoundRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final response = SearchAudiosResponse.fromJson(result.data.toJson());
 
diff --git a/lib/src/core/network/atproto/data/repositories/sprk_repository.dart b/lib/src/core/network/atproto/data/repositories/sprk_repository.dart
index ab6f423d..cf5ffea6 100644
--- a/lib/src/core/network/atproto/data/repositories/sprk_repository.dart
+++ b/lib/src/core/network/atproto/data/repositories/sprk_repository.dart
@@ -25,6 +25,18 @@ abstract class SprkRepository {
   String get modDid;
   String get bskyModDid;
 
+  /// The labeler subscriptions used for all Spark and Bluesky appview reads.
+  List<String> get labelerDids;
+
+  /// Replaces the active labeler subscriptions after preferences change.
+  void configureLabelers(Iterable<String> labelerDids);
+
+  /// Builds headers for an appview request while preserving proxy routing.
+  Map<String, String> appViewHeaders(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  });
+
   ActorRepository get actor;
   RepoRepository get repo;
   FeedRepository get feed;
diff --git a/lib/src/core/network/atproto/data/repositories/sprk_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/sprk_repository_impl.dart
index bd3bcf03..0d9d85a7 100644
--- a/lib/src/core/network/atproto/data/repositories/sprk_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/sprk_repository_impl.dart
@@ -19,6 +19,7 @@ import 'package:spark/src/core/network/atproto/data/repositories/sound_repositor
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/story_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/story_repository_impl.dart';
+import 'package:spark/src/core/network/atproto/data/services/appview_labeler_headers.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 
@@ -27,6 +28,9 @@ class SprkRepositoryImpl implements SprkRepository {
   SprkRepositoryImpl(this._authRepository, {SparkLogger? logger})
     : _sprkDid = _getSprkDid(),
       _bskyDid = _getBskyDid(),
+      _labelerHeaders = AppViewLabelerHeaders(
+        defaultLabelerDid: AppConfig.modDid,
+      ),
       _logger =
           logger ?? GetIt.instance<LogService>().getLogger('SprkRepository') {
     _logger.d('SprkRepository initialized with DID: $_sprkDid');
@@ -34,6 +38,7 @@ class SprkRepositoryImpl implements SprkRepository {
   final AuthRepository _authRepository;
   final String _sprkDid;
   final String _bskyDid;
+  final AppViewLabelerHeaders _labelerHeaders;
   final SparkLogger _logger;
 
   // Cached repository instances
@@ -63,6 +68,20 @@ class SprkRepositoryImpl implements SprkRepository {
   @override
   String get bskyModDid => AppConfig.bskyModDid;
 
+  @override
+  List<String> get labelerDids => _labelerHeaders.labelerDids;
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {
+    _labelerHeaders.configure(labelerDids);
+  }
+
+  @override
+  Map<String, String> appViewHeaders(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  }) => _labelerHeaders.forAppView(proxyDid, labelerDids: labelerDids);
+
   static String _getSprkDid() {
     final sprkAppView = Uri.parse(AppConfig.appViewUrl);
     return 'did:web:${sprkAppView.host}#sprk_appview';
diff --git a/lib/src/core/network/atproto/data/repositories/story_repository.dart b/lib/src/core/network/atproto/data/repositories/story_repository.dart
index 860f1c1c..f2d3dc8a 100644
--- a/lib/src/core/network/atproto/data/repositories/story_repository.dart
+++ b/lib/src/core/network/atproto/data/repositories/story_repository.dart
@@ -1,7 +1,7 @@
 import 'package:poptart_lex/com/atproto/label/defs.dart';
 import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:poptart/poptart.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/network/atproto/data/models/models.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 
@@ -39,14 +39,17 @@ abstract class StoryRepository {
   /// [limit] The number of items to return (default 30)
   /// [cursor] Pagination cursor for the next set of results
   Future<
-    ({String? cursor, Map<ProfileViewBasic, List<StoryView>> storiesByAuthor})
+    ({
+      String? cursor,
+      Map<ProfileViewBasic, List<ModeratedStoryView>> storiesByAuthor,
+    })
   >
   getStoriesTimeline({int limit = 30, String? cursor});
 
   /// Gets story views for a specified list of stories (by AT-URI).
   ///
   /// [storyUris] List of story URIs to fetch
-  Future<List<StoryView>> getStoryViews(List<AtUri> storyUris);
+  Future<List<ModeratedStoryView>> getStoryViews(List<AtUri> storyUris);
 
   Future<StoryRecordPage> listStoryRecords({
     required String did,
diff --git a/lib/src/core/network/atproto/data/repositories/story_repository_impl.dart b/lib/src/core/network/atproto/data/repositories/story_repository_impl.dart
index b596f648..3ef6ffd3 100644
--- a/lib/src/core/network/atproto/data/repositories/story_repository_impl.dart
+++ b/lib/src/core/network/atproto/data/repositories/story_repository_impl.dart
@@ -3,8 +3,10 @@ import 'package:poptart_lex/com/atproto/repo/list_records.dart'
     as repo_list_records;
 import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:poptart/poptart.dart';
+import 'package:spark/src/core/moderation/moderation_label_events.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/atproto/data/models/models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/network/atproto/data/models/record_write_adapters.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/story_repository.dart';
@@ -77,7 +79,10 @@ class StoryRepositoryImpl implements StoryRepository {
 
   @override
   Future<
-    ({String? cursor, Map<ProfileViewBasic, List<StoryView>> storiesByAuthor})
+    ({
+      String? cursor,
+      Map<ProfileViewBasic, List<ModeratedStoryView>> storiesByAuthor,
+    })
   >
   getStoriesTimeline({int limit = 30, String? cursor}) {
     return _client.executeWithRetry(() async {
@@ -96,7 +101,7 @@ class StoryRepositoryImpl implements StoryRepository {
           limit: limit,
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final response = (() {
         final jsonMap = rawResponse.data.toJson();
@@ -155,12 +160,27 @@ class StoryRepositoryImpl implements StoryRepository {
         );
       })();
 
-      return response;
+      final labelsByUri = await _getModerationLabels(
+        response.storiesByAuthor.values.expand((stories) => stories),
+      );
+      return (
+        storiesByAuthor: {
+          for (final entry in response.storiesByAuthor.entries)
+            entry.key: [
+              for (final story in entry.value)
+                ModeratedStoryView(
+                  story: story,
+                  moderationLabels: _labelsForStory(labelsByUri, story),
+                ),
+            ],
+        },
+        cursor: response.cursor,
+      );
     });
   }
 
   @override
-  Future<List<StoryView>> getStoryViews(List<AtUri> storyUris) {
+  Future<List<ModeratedStoryView>> getStoryViews(List<AtUri> storyUris) {
     return _client.executeWithRetry(() async {
       if (!_client.authRepository.isAuthenticated) {
         throw Exception('Not authenticated');
@@ -174,7 +194,7 @@ class StoryRepositoryImpl implements StoryRepository {
       final rawResponse = await atproto.call(
         sprk_get_stories.soSprkStoryGetStories,
         parameters: sprk_get_stories.StoryGetStoriesInput(uris: storyUris),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
       final response = (() {
         final jsonMap = rawResponse.data.toJson();
@@ -201,10 +221,59 @@ class StoryRepositoryImpl implements StoryRepository {
             .toList();
       })();
 
-      return response;
+      final labelsByUri = await _getModerationLabels(response);
+      return [
+        for (final story in response)
+          ModeratedStoryView(
+            story: story,
+            moderationLabels: _labelsForStory(labelsByUri, story),
+          ),
+      ];
     });
   }
 
+  Future<Map<String, List<Label>>> _getModerationLabels(
+    Iterable<StoryView> stories,
+  ) async {
+    final uris = stories.map((story) => story.uri).toSet().toList();
+    if (uris.isEmpty) return const {};
+
+    final labelsByUri = <String, List<Label>>{};
+    final seenCursors = <String>{};
+    String? cursor;
+    do {
+      if (cursor != null && !seenCursors.add(cursor)) {
+        throw StateError('Label query returned a repeated cursor');
+      }
+      final page = await _client.labeler.queryLabels(
+        uris,
+        limit: 250,
+        cursor: cursor,
+      );
+      for (final label in page.labels) {
+        labelsByUri.putIfAbsent(label.uri, () => []).add(label);
+      }
+      cursor = page.cursor;
+    } while (cursor != null && cursor.isNotEmpty);
+
+    return labelsByUri;
+  }
+
+  Iterable<Label> _labelsForStory(
+    Map<String, List<Label>> labelsByUri,
+    StoryView story,
+  ) {
+    final now = _now().toUtc();
+    final latest = mergeLatestLabelEvents(
+      existing: const [],
+      incoming: (labelsByUri[story.uri.toString()] ?? const []).where(
+        (label) => label.cid == null || label.cid == story.cid,
+      ),
+      now: now,
+    );
+    return activeLabelsFromEvents(latest, now: now);
+  }
+
   @override
   Future<RepoStrongRef> postStory(
     Media media, {
diff --git a/lib/src/core/network/atproto/data/services/appview_labeler_headers.dart b/lib/src/core/network/atproto/data/services/appview_labeler_headers.dart
new file mode 100644
index 00000000..82f8fa84
--- /dev/null
+++ b/lib/src/core/network/atproto/data/services/appview_labeler_headers.dart
@@ -0,0 +1,67 @@
+const String atprotoAcceptLabelersHeader = 'atproto-accept-labelers';
+
+/// Owns the labeler subscription header shared by every appview repository.
+///
+/// The AT Protocol header accepts at most 20 comma-separated labeler DIDs. The
+/// app's required default moderation service is always kept first so it cannot
+/// be displaced by user subscriptions.
+class AppViewLabelerHeaders {
+  AppViewLabelerHeaders({required String defaultLabelerDid})
+    : _defaultLabelerDid = _normalizeDid(defaultLabelerDid),
+      _labelerDids = normalize(
+        defaultLabelerDid: defaultLabelerDid,
+        labelerDids: const [],
+      );
+
+  static const int maxLabelers = 20;
+
+  final String _defaultLabelerDid;
+  List<String> _labelerDids;
+
+  List<String> get labelerDids => List.unmodifiable(_labelerDids);
+
+  void configure(Iterable<String> labelerDids) {
+    _labelerDids = normalize(
+      defaultLabelerDid: _defaultLabelerDid,
+      labelerDids: labelerDids,
+    );
+  }
+
+  Map<String, String> forAppView(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  }) {
+    final accepted = labelerDids == null
+        ? _labelerDids
+        : normalize(
+            defaultLabelerDid: _defaultLabelerDid,
+            labelerDids: labelerDids,
+          );
+    final headers = <String, String>{
+      if (accepted.isNotEmpty) atprotoAcceptLabelersHeader: accepted.join(','),
+    };
+    if (proxyDid != null) {
+      headers['atproto-proxy'] = proxyDid;
+    }
+    return headers;
+  }
+
+  static List<String> normalize({
+    required String defaultLabelerDid,
+    required Iterable<String> labelerDids,
+  }) {
+    final normalized = <String>{_normalizeDid(defaultLabelerDid)};
+    for (final did in labelerDids) {
+      final value = _normalizeDid(did);
+      if (value.isNotEmpty) {
+        normalized.add(value);
+      }
+      if (normalized.length == maxLabelers) {
+        break;
+      }
+    }
+    return normalized.toList(growable: false);
+  }
+
+  static String _normalizeDid(String did) => did.trim().split('#').first;
+}
diff --git a/lib/src/core/network/messages/data/repository/messages_repository_xrpc.dart b/lib/src/core/network/messages/data/repository/messages_repository_xrpc.dart
index d867f375..842a886a 100644
--- a/lib/src/core/network/messages/data/repository/messages_repository_xrpc.dart
+++ b/lib/src/core/network/messages/data/repository/messages_repository_xrpc.dart
@@ -17,7 +17,7 @@ import 'package:sprk_poptart/chat/sprk/convo/get_convo_for_members/output.dart'
     as get_convo_for_members;
 import 'package:sprk_poptart/chat/sprk/convo/get_messages/output.dart'
     as get_messages;
-import 'package:sprk_poptart/chat/sprk/convo/get_messages/union_main_messages.dart'
+import 'package:sprk_poptart/chat/sprk/convo/get_messages/union_main_output_messages.dart'
     as get_messages_union;
 import 'package:sprk_poptart/chat/sprk/convo/list_convos/output.dart'
     as list_convos;
@@ -314,16 +314,18 @@ class MessagesRepositoryXrpc implements MessagesRepository {
 }
 
 ChatMessageView _chatMessageFromChat(
-  get_messages_union.UConvoGetMessagesMessages message,
+  get_messages_union.UConvoGetMessagesOutputMessages message,
 ) {
   return switch (message) {
-    get_messages_union.UConvoGetMessagesMessagesMessageView(:final data) =>
+    get_messages_union.UConvoGetMessagesOutputMessagesMessageView(
+      :final data,
+    ) =>
       ChatMessageView.message(data: MessageView.fromChat(data)),
-    get_messages_union.UConvoGetMessagesMessagesDeletedMessageView(
+    get_messages_union.UConvoGetMessagesOutputMessagesDeletedMessageView(
       :final data,
     ) =>
       ChatMessageView.deleted(data: DeletedMessageView.fromChat(data)),
-    get_messages_union.UConvoGetMessagesMessagesUnknown(:final data) =>
+    get_messages_union.UConvoGetMessagesOutputMessagesUnknown(:final data) =>
       ChatMessageView.unsupportedFromRaw(data),
   };
 }
diff --git a/lib/src/core/providers/preferences_provider.dart b/lib/src/core/providers/preferences_provider.dart
new file mode 100644
index 00000000..48e834c9
--- /dev/null
+++ b/lib/src/core/providers/preferences_provider.dart
@@ -0,0 +1,153 @@
+import 'package:get_it/get_it.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/pref_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/core/utils/logging/logger.dart';
+
+part 'preferences_provider.g.dart';
+
+/// Central provider for user preferences.
+///
+/// This provider loads preferences once at startup and holds them in memory.
+/// All services that need preferences should watch this provider instead of
+/// calling getPreferences() directly.
+///
+/// When preferences are updated (via [updatePreferences]), all watchers are
+/// automatically notified of the change.
+@Riverpod(keepAlive: true)
+class UserPreferences extends _$UserPreferences {
+  late final PrefRepository _prefRepository;
+  late final SprkRepository _sprkRepository;
+  late final SparkLogger _logger;
+  Future<void> _operationTail = Future<void>.value();
+
+  @override
+  Future<Preferences> build() async {
+    _prefRepository = GetIt.instance<PrefRepository>();
+    _sprkRepository = GetIt.instance<SprkRepository>();
+    _logger = GetIt.instance<LogService>().getLogger('UserPreferences');
+
+    // Wait for auth to be initialized
+    await _sprkRepository.authRepository.initializationComplete;
+
+    if (!_sprkRepository.authRepository.isAuthenticated) {
+      return _configureLabelers(Preferences(preferences: []));
+    }
+
+    try {
+      final preferences = await _prefRepository.getPreferences();
+      return _configureLabelers(preferences);
+    } catch (e) {
+      _logger.e('Error loading preferences: $e');
+      rethrow;
+    }
+  }
+
+  /// Gets the current preferences synchronously if available.
+  /// Returns null if preferences have never loaded successfully.
+  Preferences? get currentPreferences => state.asData?.value;
+
+  /// Refreshes preferences from the server.
+  /// This should be called when logging in or when syncing from another device.
+  Future<void> refresh() => _enqueue(() async {
+    try {
+      final preferences = await _prefRepository.getPreferences();
+      state = AsyncValue.data(_configureLabelers(preferences));
+    } catch (e) {
+      _logger.e('Error refreshing preferences: $e');
+      rethrow;
+    }
+  });
+
+  /// Replaces the complete preference document on the server and in local state.
+  /// Feature-level edits should use [updatePreferencesWithFn] so their document
+  /// transformation runs after any earlier mutation has completed.
+  Future<Preferences> updatePreferences(Preferences preferences) =>
+      _enqueue(() => _persistPreferences(preferences));
+
+  Future<Preferences> _persistPreferences(Preferences preferences) async {
+    try {
+      await _prefRepository.putPreferences(preferences);
+      final committed = _configureLabelers(preferences);
+      state = AsyncValue.data(committed);
+      return committed;
+    } catch (e) {
+      _logger.e('Error updating preferences: $e');
+      rethrow;
+    }
+  }
+
+  /// Updates preferences by applying a transformation function.
+  /// This is useful for making partial updates without fetching first.
+  Future<Preferences> updatePreferencesWithFn(
+    Preferences Function(Preferences current) updater,
+  ) => _enqueue(() async {
+    final current = state.asData?.value;
+    if (current == null) {
+      throw Exception('Cannot update preferences: not loaded yet');
+    }
+
+    final updated = updater(current);
+    if (identical(updated, current)) return current;
+    return _persistPreferences(updated);
+  });
+
+  Future<void> setAdultContentEnabled(bool enabled) async {
+    await updatePreferencesWithFn((current) {
+      final retained = current.preferences.where((preference) {
+        return !preference.isAdultContentPref;
+      });
+      return Preferences(
+        preferences: [
+          ...retained,
+          adultContentPreference(enabled: enabled),
+        ],
+      );
+    });
+  }
+
+  Future<void> setGlobalLabelPreference(
+    String label,
+    ModerationSetting setting,
+  ) async {
+    if (!globalAdultContentLabelValues.contains(label)) {
+      throw ArgumentError.value(label, 'label', 'Not a global adult label');
+    }
+
+    await updatePreferencesWithFn((current) {
+      final retained = current.preferences.where((preference) {
+        final contentLabelPref = preference.contentLabelPref;
+        return contentLabelPref == null || contentLabelPref.label != label;
+      });
+      return Preferences(
+        preferences: [
+          ...retained,
+          contentLabelPreference(
+            labelerDid: null,
+            label: label,
+            visibility: setting.name,
+          ),
+        ],
+      );
+    });
+  }
+
+  Future<T> _enqueue<T>(Future<T> Function() operation) {
+    final result = _operationTail.then((_) => operation());
+    _operationTail = result.then<void>(
+      (_) {},
+      onError: (Object _, StackTrace _) {},
+    );
+    return result;
+  }
+
+  Preferences _configureLabelers(Preferences preferences) {
+    _sprkRepository.configureLabelers(
+      preferences.labelers?.map((labeler) => labeler.did) ?? const [],
+    );
+    return preferences;
+  }
+}
diff --git a/lib/src/core/routing/app_router.dart b/lib/src/core/routing/app_router.dart
index b31c34ff..b081eb74 100644
--- a/lib/src/core/routing/app_router.dart
+++ b/lib/src/core/routing/app_router.dart
@@ -8,6 +8,7 @@ import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
 import 'package:spark/src/core/auth/data/repositories/onboarding_repository.dart';
 import 'package:spark/src/core/network/atproto/atproto.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/routing/pages.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
@@ -109,6 +110,7 @@ class AppRouter extends RootStackRouter {
     AutoRoute(page: SettingsRoute.page, path: '/settings'),
     AutoRoute(page: LegalRoute.page, path: '/settings/legal'),
     AutoRoute(page: FeedListRoute.page, path: '/settings/feeds'),
+    AutoRoute(page: ModerationRoute.page, path: '/settings/moderation'),
     AutoRoute(page: LabelerManagementRoute.page, path: '/settings/labelers'),
     AutoRoute(page: BlocksRoute.page, path: '/settings/blocks'),
 
diff --git a/lib/src/core/routing/pages.dart b/lib/src/core/routing/pages.dart
index 19d9243c..8bb859bb 100644
--- a/lib/src/core/routing/pages.dart
+++ b/lib/src/core/routing/pages.dart
@@ -32,6 +32,7 @@ export 'package:spark/src/features/settings/ui/pages/feed_list_page.dart';
 export 'package:spark/src/features/settings/ui/pages/labeler_label_settings_page.dart';
 export 'package:spark/src/features/settings/ui/pages/legal_page.dart';
 export 'package:spark/src/features/settings/ui/pages/labeler_management_page.dart';
+export 'package:spark/src/features/settings/ui/pages/moderation_page.dart';
 export 'package:spark/src/features/settings/ui/pages/settings_page.dart';
 export 'package:spark/src/features/sound/ui/pages/sound_page.dart';
 export 'package:spark/src/features/stories/ui/pages/all_stories_page.dart';
diff --git a/lib/src/core/storage/preferences/default_preferences.dart b/lib/src/core/storage/preferences/default_preferences.dart
index e31fa259..bedb1912 100644
--- a/lib/src/core/storage/preferences/default_preferences.dart
+++ b/lib/src/core/storage/preferences/default_preferences.dart
@@ -25,50 +25,6 @@ class DefaultPreferences {
       ),
     ];
 
-    // Default label preferences
-    final defaultLabelPrefs = [
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: '!hide',
-        visibility: 'hide',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: '!no-promote',
-        visibility: 'hide',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: '!warn',
-        visibility: 'warn',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: '!no-unauthenticated',
-        visibility: 'ignore',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: 'dmca-violation',
-        visibility: 'hide',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: 'doxxing',
-        visibility: 'warn',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: 'nsfl',
-        visibility: 'warn',
-      ),
-      contentLabelPreference(
-        labelerDid: labelerDid,
-        label: 'gore',
-        visibility: 'warn',
-      ),
-    ];
-
     // Default labelers
     final defaultLabelers = [LabelerPrefItem(did: labelerDid)];
 
@@ -76,7 +32,6 @@ class DefaultPreferences {
       preferences: [
         savedFeedsPreference(defaultFeeds),
         labelersPreference(defaultLabelers),
-        ...defaultLabelPrefs,
       ],
     );
   }
diff --git a/lib/src/core/ui/widgets/content_warning_overlay.dart b/lib/src/core/ui/widgets/content_warning_overlay.dart
deleted file mode 100644
index d14c097b..00000000
--- a/lib/src/core/ui/widgets/content_warning_overlay.dart
+++ /dev/null
@@ -1,97 +0,0 @@
-import 'dart:ui';
-
-import 'package:flutter/material.dart';
-import 'package:spark/src/core/design_system/tokens/colors.dart';
-
-class ContentWarningOverlay extends StatelessWidget {
-  const ContentWarningOverlay({
-    required this.onViewContent,
-    required this.warningLabels,
-    super.key,
-    this.shouldBlur = false,
-    this.child,
-  });
-
-  final VoidCallback onViewContent;
-  final List<String> warningLabels;
-  final Widget? child;
-  final bool shouldBlur; // content blur
-
-  @override
-  Widget build(BuildContext context) {
-    return Stack(
-      children: [
-        // Original content (blurred/hidden)
-        if (child != null)
-          if (shouldBlur)
-            ImageFiltered(
-              imageFilter: ImageFilter.blur(sigmaX: 40, sigmaY: 40),
-              child: child,
-            )
-          else
-            child!,
-        // Warning overlay
-        if (shouldBlur)
-          Positioned.fill(
-            child: Center(
-              child: Padding(
-                padding: const EdgeInsets.all(24),
-                child: Column(
-                  mainAxisAlignment: MainAxisAlignment.center,
-                  children: [
-                    const Icon(
-                      Icons.warning_amber_rounded,
-                      color: AppColors.white,
-                      size: 48,
-                    ),
-                    const SizedBox(height: 16),
-                    const Text(
-                      'Content Warning',
-                      style: TextStyle(
-                        color: AppColors.white,
-                        fontSize: 24,
-                        fontWeight: FontWeight.bold,
-                      ),
-                      textAlign: TextAlign.center,
-                    ),
-                    const SizedBox(height: 12),
-                    Text(
-                      'This content has been flagged for:\n'
-                      '${warningLabels.join(', ')}',
-                      style: const TextStyle(
-                        color: AppColors.white,
-                        fontSize: 16,
-                      ),
-                      textAlign: TextAlign.center,
-                    ),
-                    const SizedBox(height: 24),
-                    ElevatedButton(
-                      onPressed: onViewContent,
-                      style: ElevatedButton.styleFrom(
-                        backgroundColor: AppColors.white,
-                        foregroundColor: AppColors.black,
-                        padding: const EdgeInsets.symmetric(
-                          horizontal: 32,
-                          vertical: 12,
-                        ),
-                        shape: RoundedRectangleBorder(
-                          borderRadius: BorderRadius.circular(24),
-                        ),
-                      ),
-                      child: const Text(
-                        'View Content',
-                        style: TextStyle(
-                          fontSize: 16,
-                          fontWeight: FontWeight.w600,
-                        ),
-                      ),
-                    ),
-                  ],
-                ),
-              ),
-            ),
-          ),
-      ],
-    );
-  }
-}
diff --git a/lib/src/core/ui/widgets/report_dialog.dart b/lib/src/core/ui/widgets/report_dialog.dart
index 7cda6727..7b50d53f 100644
--- a/lib/src/core/ui/widgets/report_dialog.dart
+++ b/lib/src/core/ui/widgets/report_dialog.dart
@@ -1,65 +1,28 @@
+import 'dart:async';
+
 import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
-import 'package:poptart_lex/com/atproto/moderation/defs.dart';
-import 'package:poptart/poptart.dart';
 import 'package:auto_route/auto_route.dart';
-import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:get_it/get_it.dart';
 import 'package:spark/src/core/design_system/components/atoms/buttons/app_button.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
-import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/moderation/moderation_report_catalog.dart';
+import 'package:spark/src/core/moderation/moderation_report_service.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 
-typedef ReportSubmitCallback =
-    void Function(
-      UModerationCreateReportSubject subject,
-      ReasonType reasonType,
-      String? reason,
-    );
-
-enum ReportCategory {
-  violence('Violence'),
-  sexual('Sexual Content'),
-  childSafety('Child Safety'),
-  harassment('Harassment'),
-  misleading('Misleading'),
-  ruleViolations('Rule Violations'),
-  selfHarm('Self-Harm'),
-  other('Other');
-
-  const ReportCategory(this.displayName);
-  final String displayName;
-}
-
-class ReportReason {
-  final String value;
-  final String displayName;
-  final String? description;
-  final KnownReasonType? knownType;
-
-  const ReportReason({
-    required this.value,
-    required this.displayName,
-    this.description,
-    this.knownType,
-  });
-}
-
 class ReportDialog extends ConsumerStatefulWidget {
   const ReportDialog({
-    required this.postUri,
-    required this.postCid,
+    required this.subject,
+    this.fallbackServiceDid,
     super.key,
     this.onSubmit,
   });
-  final String postUri;
-  final String postCid;
+  final UModerationCreateReportSubject subject;
+  final String? fallbackServiceDid;
 
-  /// Callback for report submission. Uses [ReasonType] directly to support
-  /// known & unknown reason types.
-  final ReportSubmitCallback? onSubmit;
+  final ModerationReportSubmitter? onSubmit;
 
   @override
   ConsumerState<ReportDialog> createState() => _ReportDialogState();
@@ -75,269 +38,8 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
       TextEditingController();
   bool _isSubmitting = false;
   String? _errorMessage;
-
-  // Map categories to their reasons
-  static final Map<ReportCategory, List<ReportReason>> _categoryReasons = {
-    ReportCategory.violence: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceAnimal',
-        displayName: 'Animal Abuse',
-        description: 'Content depicting harm to animals',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceAnimal,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceThreats',
-        displayName: 'Threats',
-        description: 'Threats of violence',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceThreats,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceGraphicContent',
-        displayName: 'Graphic Content',
-        description: 'Graphic or violent imagery',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonViolenceGraphicContent,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceGlorification',
-        displayName: 'Glorification of Violence',
-        description: 'Content that glorifies violence',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonViolenceGlorification,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceExtremistContent',
-        displayName: 'Extremist Content',
-        description: 'Content promoting extremist ideologies',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonViolenceExtremistContent,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceTrafficking',
-        displayName: 'Trafficking',
-        description: 'Content related to human trafficking',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonViolenceTrafficking,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonViolenceOther',
-        displayName: 'Other Violence',
-        description: 'Other violent content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonViolenceOther,
-      ),
-    ],
-    ReportCategory.sexual: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSexualAbuseContent',
-        displayName: 'Abuse Content',
-        description: 'Sexual abuse content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualAbuseContent,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSexualNCII',
-        displayName: 'Non-Consensual Intimate Images',
-        description: 'Sharing intimate images without consent',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualNCII,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSexualDeepfake',
-        displayName: 'Deepfake',
-        description: 'AI-generated sexual content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualDeepfake,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSexualAnimal',
-        displayName: 'Animal Sexual Content',
-        description: 'Sexual content involving animals',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualAnimal,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSexualUnlabeled',
-        displayName: 'Unlabeled Sexual Content',
-        description: 'Sexual content without proper warnings',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualUnlabeled,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSexualOther',
-        displayName: 'Other Sexual Content',
-        description: 'Other sexual content violations',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSexualOther,
-      ),
-    ],
-    ReportCategory.childSafety: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonChildSafetyCSAM',
-        displayName: 'CSAM',
-        description: 'Child sexual abuse material',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyCSAM,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonChildSafetyGroom',
-        displayName: 'Grooming',
-        description: 'Grooming behavior targeting minors',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyGroom,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonChildSafetyPrivacy',
-        displayName: 'Privacy Violation',
-        description: 'Sharing private information about minors',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyPrivacy,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonChildSafetyHarassment',
-        displayName: 'Harassment',
-        description: 'Harassment targeting minors',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonChildSafetyHarassment,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonChildSafetyOther',
-        displayName: 'Other Child Safety',
-        description: 'Other child safety concerns',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonChildSafetyOther,
-      ),
-    ],
-    ReportCategory.harassment: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonHarassmentTroll',
-        displayName: 'Trolling',
-        description: 'Trolling or disruptive behavior',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentTroll,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonHarassmentTargeted',
-        displayName: 'Targeted Harassment',
-        description: 'Targeted harassment or bullying',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentTargeted,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonHarassmentHateSpeech',
-        displayName: 'Hate Speech',
-        description: 'Hate speech or discriminatory content',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonHarassmentHateSpeech,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonHarassmentDoxxing',
-        displayName: 'Doxxing',
-        description: 'Sharing private information without consent',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentDoxxing,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonHarassmentOther',
-        displayName: 'Other Harassment',
-        description: 'Other harassment violations',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonHarassmentOther,
-      ),
-    ],
-    ReportCategory.misleading: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonMisleadingBot',
-        displayName: 'Bot Account',
-        description: 'Automated or bot account',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingBot,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonMisleadingImpersonation',
-        displayName: 'Impersonation',
-        description: 'Impersonating another person or entity',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonMisleadingImpersonation,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonMisleadingSpam',
-        displayName: 'Spam',
-        description: 'Spam or repetitive content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingSpam,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonMisleadingScam',
-        displayName: 'Scam',
-        description: 'Fraudulent or scam content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingScam,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonMisleadingElections',
-        displayName: 'Election Misinformation',
-        description: 'False information about elections',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonMisleadingElections,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonMisleadingOther',
-        displayName: 'Other Misleading',
-        description: 'Other misleading content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonMisleadingOther,
-      ),
-    ],
-    ReportCategory.ruleViolations: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonRuleSiteSecurity',
-        displayName: 'Site Security',
-        description: 'Violation of site security rules',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleSiteSecurity,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonRuleProhibitedSales',
-        displayName: 'Prohibited Sales',
-        description: 'Prohibited goods or services',
-        knownType:
-            KnownReasonType.toolsOzoneReportDefsReasonRuleProhibitedSales,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonRuleBanEvasion',
-        displayName: 'Ban Evasion',
-        description: 'Attempting to evade a ban',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleBanEvasion,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonRuleOther',
-        displayName: 'Other Rule Violation',
-        description: 'Other rule violations',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonRuleOther,
-      ),
-    ],
-    ReportCategory.selfHarm: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSelfHarmContent',
-        displayName: 'Self-Harm Content',
-        description: 'Content promoting self-harm',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmContent,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSelfHarmED',
-        displayName: 'Eating Disorder',
-        description: 'Content promoting eating disorders',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmED,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSelfHarmStunts',
-        displayName: 'Dangerous Stunts',
-        description: 'Content showing dangerous stunts',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmStunts,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSelfHarmSubstances',
-        displayName: 'Substance Abuse',
-        description: 'Content promoting substance abuse',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmSubstances,
-      ),
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonSelfHarmOther',
-        displayName: 'Other Self-Harm',
-        description: 'Other self-harm related content',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonSelfHarmOther,
-      ),
-    ],
-    ReportCategory.other: [
-      const ReportReason(
-        value: 'tools.ozone.report.defs#reasonOther',
-        displayName: 'Other',
-        description: 'Other issues not listed above',
-        knownType: KnownReasonType.toolsOzoneReportDefsReasonOther,
-      ),
-    ],
-  };
+  Future<ModerationReportOptions>? _reportOptionsFuture;
+  String? _selectedServiceDid;
 
   @override
   void dispose() {
@@ -353,27 +55,54 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
   }
 
   void _selectReason(ReportReason reason) {
+    final optionsFuture = ref
+        .read(moderationReportServiceProvider)
+        .loadOptions(
+          subject: widget.subject,
+          reasonType: reason.reasonType,
+          fallbackServiceDid: widget.fallbackServiceDid,
+        );
     setState(() {
       _selectedReason = reason;
+      _reportOptionsFuture = optionsFuture;
+      _selectedServiceDid = null;
     });
+    unawaited(_selectDefaultService(optionsFuture, reason));
+  }
+
+  Future<void> _selectDefaultService(
+    Future<ModerationReportOptions> optionsFuture,
+    ReportReason reason,
+  ) async {
+    try {
+      final options = await optionsFuture;
+      if (!mounted || _selectedReason != reason) return;
+      setState(() {
+        _selectedServiceDid = options.defaultServiceDid;
+      });
+    } catch (error, stackTrace) {
+      _logger.w(
+        'Could not select a default moderation service',
+        error: error,
+        stackTrace: stackTrace,
+      );
+    }
   }
 
   void _goBack() {
     setState(() {
       _selectedCategory = null;
       _selectedReason = null;
+      _reportOptionsFuture = null;
+      _selectedServiceDid = null;
     });
   }
 
   Future<void> _submitReport() async {
-    if (_selectedReason == null) return;
+    if (_selectedReason == null || _selectedServiceDid == null) return;
 
-    final subject = UModerationCreateReportSubject.repoStrongRef(
-      data: RepoStrongRef(
-        cid: widget.postCid,
-        uri: AtUri.parse(widget.postUri),
-      ),
-    );
+    final l10n = AppLocalizations.of(context);
+    final subject = widget.subject;
     final reason = _additionalInfoController.text.isNotEmpty
         ? _additionalInfoController.text
         : null;
@@ -384,40 +113,23 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
     });
 
     try {
-      // Build the ReasonType: use known type if available, otherwise unknown
-      // with the raw value
-      final reasonType = _selectedReason!.knownType != null
-          ? ReasonType.knownValue(data: _selectedReason!.knownType!)
-          : ReasonType.unknown(data: _selectedReason!.value);
-
-      if (widget.onSubmit != null) {
-        // Use the callback if provided - now passing ReasonType directly
-        widget.onSubmit!(subject, reasonType, reason);
-        if (mounted) {
-          context.router.maybePop();
-        }
-      } else {
-        // Get the repository directly and create the report
-        final repoRepository = GetIt.instance<SprkRepository>().repo;
-        _logger.d('Creating report with reason: ${_selectedReason!.value}');
-
-        final success = await repoRepository.createReport(
-          input: ModerationCreateReportInput(
+      await ref
+          .read(moderationReportServiceProvider)
+          .submit(
             subject: subject,
-            reasonType: reasonType,
+            reasonType: _selectedReason!.reasonType,
             reason: reason,
-          ),
-        );
-
-        if (success && mounted) {
-          context.router.maybePop();
-        }
+            serviceDid: _selectedServiceDid!,
+            submitter: widget.onSubmit,
+          );
+      if (mounted) {
+        context.router.maybePop();
       }
     } catch (e) {
       _logger.e('Error creating report', error: e);
       if (mounted) {
         setState(() {
-          _errorMessage = 'Error: $e';
+          _errorMessage = l10n.errorGeneric;
         });
       }
     } finally {
@@ -438,7 +150,7 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
         (theme.brightness == Brightness.dark ? Colors.white : Colors.black);
     final isStep2 = _selectedCategory != null;
     final reasons = isStep2
-        ? (_categoryReasons[_selectedCategory!] ?? <ReportReason>[])
+        ? (reportCategoryReasons[_selectedCategory!] ?? <ReportReason>[])
         : <ReportReason>[];
 
     return AlertDialog(
@@ -477,79 +189,129 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
       contentPadding: const EdgeInsets.fromLTRB(12, 8, 12, 8),
       content: SizedBox(
         width: double.maxFinite,
-        child: Column(
-          mainAxisSize: MainAxisSize.min,
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            if (!isStep2)
-              // Step 1: Category selection
-              ...ReportCategory.values.map(
-                (category) => _CategoryTile(
-                  category: category,
-                  selectedCategory: _selectedCategory,
-                  onTap: () => _selectCategory(category),
+        child: SingleChildScrollView(
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              if (!isStep2)
+                // Step 1: Category selection
+                ...ReportCategory.values.map(
+                  (category) => _CategoryTile(
+                    category: category,
+                    selectedCategory: _selectedCategory,
+                    onTap: () => _selectCategory(category),
+                  ),
+                )
+              else
+                // Step 2: Reason selection
+                ...reasons.map(
+                  (reason) => _ReasonTile(
+                    reason: reason,
+                    selectedReason: _selectedReason,
+                    onChanged: (value) {
+                      if (value != null) {
+                        _selectReason(value);
+                      }
+                    },
+                  ),
                 ),
-              )
-            else
-              // Step 2: Reason selection
-              ...reasons.map(
-                (reason) => _ReasonTile(
-                  reason: reason,
-                  selectedReason: _selectedReason,
-                  onChanged: (value) {
-                    if (value != null) {
-                      _selectReason(value);
+
+              if (isStep2 && _selectedReason != null) ...[
+                const SizedBox(height: 8),
+                FutureBuilder<ModerationReportOptions>(
+                  future: _reportOptionsFuture,
+                  builder: (context, snapshot) {
+                    if (snapshot.connectionState != ConnectionState.done) {
+                      return const Center(
+                        child: Padding(
+                          padding: EdgeInsets.all(8),
+                          child: CircularProgressIndicator(strokeWidth: 2),
+                        ),
+                      );
                     }
+                    if (snapshot.hasError) {
+                      return Text(l10n.moderationServiceLoadFailed);
+                    }
+                    final services = snapshot.data?.services ?? const [];
+                    if (services.isEmpty) {
+                      return Text(l10n.moderationNoCompatibleService);
+                    }
+                    return DropdownButtonFormField<String>(
+                      key: ValueKey(
+                        '${_selectedReason!.value}:${_selectedServiceDid ?? ''}',
+                      ),
+                      initialValue: _selectedServiceDid,
+                      decoration: InputDecoration(
+                        labelText: l10n.moderationService,
+                        border: const OutlineInputBorder(),
+                      ),
+                      items: [
+                        for (final service in services)
+                          DropdownMenuItem(
+                            value: service.did,
+                            child: Text(
+                              service.isDefault &&
+                                      service.displayName == service.did
+                                  ? l10n.moderationDefaultService
+                                  : service.displayName,
+                            ),
+                          ),
+                      ],
+                      onChanged: (value) {
+                        setState(() {
+                          _selectedServiceDid = value;
+                        });
+                      },
+                    );
                   },
                 ),
-              ),
-
-            if (isStep2 && _selectedReason != null) ...[
-              const SizedBox(height: 8),
-              TextField(
-                controller: _additionalInfoController,
-                maxLines: 3,
-                style: theme.textTheme.bodySmall?.copyWith(color: textColor),
-                decoration: InputDecoration(
-                  hintText: l10n.hintAdditionalDetails,
-                  contentPadding: const EdgeInsets.symmetric(
-                    horizontal: 8,
-                    vertical: 8,
-                  ),
-                  border: const OutlineInputBorder(),
-                  hintStyle: theme.textTheme.bodySmall?.copyWith(
-                    color: theme.hintColor,
+                const SizedBox(height: 8),
+                TextField(
+                  controller: _additionalInfoController,
+                  maxLines: 3,
+                  style: theme.textTheme.bodySmall?.copyWith(color: textColor),
+                  decoration: InputDecoration(
+                    hintText: l10n.hintAdditionalDetails,
+                    contentPadding: const EdgeInsets.symmetric(
+                      horizontal: 8,
+                      vertical: 8,
+                    ),
+                    border: const OutlineInputBorder(),
+                    hintStyle: theme.textTheme.bodySmall?.copyWith(
+                      color: theme.hintColor,
+                    ),
+                    fillColor: theme.colorScheme.surface,
+                    filled: true,
                   ),
-                  fillColor: theme.colorScheme.surface,
-                  filled: true,
                 ),
-              ),
-            ],
+              ],
 
-            if (_errorMessage != null)
-              Padding(
-                padding: const EdgeInsets.only(top: 8),
-                child: Container(
-                  padding: const EdgeInsets.all(8),
-                  decoration: BoxDecoration(
-                    color: theme.colorScheme.error.withAlpha(25),
-                    border: Border.all(color: theme.colorScheme.error),
-                    borderRadius: BorderRadius.circular(4),
-                  ),
-                  child: Text(
-                    _errorMessage!,
-                    style: TextStyle(
-                      color: theme.colorScheme.error,
-                      fontSize: 12,
+              if (_errorMessage != null)
+                Padding(
+                  padding: const EdgeInsets.only(top: 8),
+                  child: Container(
+                    padding: const EdgeInsets.all(8),
+                    decoration: BoxDecoration(
+                      color: theme.colorScheme.error.withAlpha(25),
+                      border: Border.all(color: theme.colorScheme.error),
+                      borderRadius: BorderRadius.circular(4),
+                    ),
+                    child: Text(
+                      _errorMessage!,
+                      style: TextStyle(
+                        color: theme.colorScheme.error,
+                        fontSize: 12,
+                      ),
                     ),
                   ),
                 ),
-              ),
-          ],
+            ],
+          ),
         ),
       ),
       actions: [
-        if (isStep2 && _selectedReason != null)
+        if (isStep2 && _selectedReason != null && _selectedServiceDid != null)
           _isSubmitting
               ? const SizedBox(
                   width: 16,
diff --git a/lib/src/core/ui/widgets/widgets.dart b/lib/src/core/ui/widgets/widgets.dart
index 6bf86179..c7de6b9b 100644
--- a/lib/src/core/ui/widgets/widgets.dart
+++ b/lib/src/core/ui/widgets/widgets.dart
@@ -1,5 +1,4 @@
 export 'alt_text_editor_dialog.dart';
-export 'content_warning_overlay.dart';
 export 'custom_text_field.dart';
 export 'elastic_pinch_zoom.dart';
 export 'heart_animation.dart';
diff --git a/lib/src/core/utils/label_utils.dart b/lib/src/core/utils/label_utils.dart
deleted file mode 100644
index c8e52285..00000000
--- a/lib/src/core/utils/label_utils.dart
+++ /dev/null
@@ -1,173 +0,0 @@
-import 'package:poptart_lex/com/atproto/label/defs.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
-
-/// Utility class for working with labels.
-///
-/// All methods that need preferences now take them as a parameter instead of
-/// fetching them. This ensures preferences are loaded once and passed down
-/// from the [UserPreferencesProvider].
-class LabelUtils {
-  /// Gets a label preference from the given preferences.
-  /// Returns null if not found instead of throwing.
-  static LabelPreference? getLabelPreferenceFromPrefs(
-    Preferences preferences,
-    String value,
-  ) {
-    final contentLabelPrefs = preferences.contentLabelPrefs ?? [];
-    try {
-      final contentLabelPref = contentLabelPrefs.firstWhere(
-        (pref) => pref.label == value,
-      );
-      return LabelPreference(
-        value: contentLabelPref.label,
-        blurs: _visibilityToBlurs(contentLabelPref.visibilityValue),
-        severity: _visibilityToSeverity(contentLabelPref.visibilityValue),
-        defaultSetting: _visibilityToSetting(contentLabelPref.visibilityValue),
-        setting: _visibilityToSetting(contentLabelPref.visibilityValue),
-        adultOnly: _isAdultOnlyLabel(value),
-      );
-    } catch (e) {
-      return null;
-    }
-  }
-
-  static Setting _visibilityToSetting(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Setting.ignore;
-      case 'warn':
-        return Setting.warn;
-      case 'hide':
-        return Setting.hide;
-      default:
-        return Setting.ignore;
-    }
-  }
-
-  static Blurs _visibilityToBlurs(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Blurs.none;
-      case 'warn':
-        return Blurs.media;
-      case 'hide':
-        return Blurs.content;
-      default:
-        return Blurs.none;
-    }
-  }
-
-  static Severity _visibilityToSeverity(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Severity.none;
-      case 'warn':
-        return Severity.alert;
-      case 'hide':
-        return Severity.alert;
-      default:
-        return Severity.none;
-    }
-  }
-
-  static bool _isAdultOnlyLabel(String label) {
-    const adultOnlyLabels = {'porn', 'sexual', 'nsfl'};
-    return adultOnlyLabels.contains(label);
-  }
-
-  /// Checks if any label should show a warning.
-  /// Takes preferences as a parameter instead of fetching.
-  static bool shouldShowWarning(Preferences preferences, List<Label> labels) {
-    if (labels.isEmpty) return false;
-
-    for (final label in labels) {
-      final preference = getLabelPreferenceFromPrefs(preferences, label.val);
-      if (preference != null &&
-          preference.severity == Severity.alert &&
-          preference.setting == Setting.warn) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /// Checks if content should be blurred.
-  /// Takes preferences as a parameter instead of fetching.
-  static bool shouldBlurContent(Preferences preferences, List<Label> labels) {
-    if (labels.isEmpty) return false;
-
-    for (final label in labels) {
-      final preference = getLabelPreferenceFromPrefs(preferences, label.val);
-      if (preference != null &&
-          (preference.blurs == Blurs.content ||
-              (preference.blurs == Blurs.media &&
-                  preference.setting == Setting.warn))) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /// Gets labels that should show warnings.
-  /// Takes preferences as a parameter instead of fetching.
-  static List<String> getWarningLabels(
-    Preferences preferences,
-    List<Label> labels,
-  ) {
-    if (labels.isEmpty) return [];
-
-    final warningLabels = <String>[];
-
-    for (final label in labels) {
-      final preference = getLabelPreferenceFromPrefs(preferences, label.val);
-      if (preference != null &&
-          preference.severity == Severity.alert &&
-          preference.setting == Setting.warn) {
-        warningLabels.add(label.val);
-      }
-    }
-
-    return warningLabels;
-  }
-
-  /// Gets labels that should show info.
-  /// Takes preferences as a parameter instead of fetching.
-  static List<String> getInformLabels(
-    Preferences preferences,
-    List<Label> labels,
-  ) {
-    if (labels.isEmpty) return [];
-
-    final informLabels = <String>[];
-
-    for (final label in labels) {
-      final preference = getLabelPreferenceFromPrefs(preferences, label.val);
-      if (preference != null &&
-          preference.severity == Severity.inform &&
-          preference.setting == Setting.warn) {
-        informLabels.add(label.val);
-      }
-    }
-
-    return informLabels;
-  }
-
-  /// Checks if content should be hidden.
-  /// Takes preferences as a parameter instead of fetching.
-  static bool shouldHideContent(Preferences preferences, List<Label> labels) {
-    if (labels.isEmpty) return false;
-
-    for (final label in labels) {
-      final preference = getLabelPreferenceFromPrefs(preferences, label.val);
-      if (preference != null &&
-          (preference.setting == Setting.hide || preference.adultOnly)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-}
diff --git a/lib/src/features/comments/ui/widgets/comment_item.dart b/lib/src/features/comments/ui/widgets/comment_item.dart
index ef64d39d..52d65b76 100644
--- a/lib/src/features/comments/ui/widgets/comment_item.dart
+++ b/lib/src/features/comments/ui/widgets/comment_item.dart
@@ -1,4 +1,5 @@
 import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
+import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:poptart/poptart.dart';
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
@@ -7,8 +8,9 @@ import 'package:get_it/get_it.dart';
 import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
 import 'package:spark/src/core/design_system/components/atoms/icons.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/design_system/tokens/colors.dart';
 import 'package:spark/src/core/ui/widgets/image_content.dart';
@@ -37,21 +39,29 @@ class CommentItem extends ConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final commentState = ref.watch(commentProvider(thread));
 
-    return Column(
-      crossAxisAlignment: CrossAxisAlignment.start,
-      children: [
-        CommentBody(
-          thread: thread,
-          mainPostUri: mainPostUri,
-          isHighlighted: isHighlighted,
-        ),
+    final post = commentState.thread.post;
+    return ModeratedContent(
+      subject: ModerationSubject.content(
+        labels: post.labels ?? const [],
+        authorLabels: post.author.labels ?? const [],
+        subjectDid: post.author.did,
+      ),
+      context: ModerationContext.contentList,
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          CommentBody(
+            thread: thread,
+            mainPostUri: mainPostUri,
+            isHighlighted: isHighlighted,
+          ),
 
-        if (commentState.thread.post.replyCount != null &&
-            commentState.thread.post.replyCount! > 0)
-          _RepliesSection(commentState),
+          if (post.replyCount != null && post.replyCount! > 0)
+            _RepliesSection(commentState),
 
-        Container(height: 0.5, color: Theme.of(context).colorScheme.surface),
-      ],
+          Container(height: 0.5, color: Theme.of(context).colorScheme.surface),
+        ],
+      ),
     );
   }
 }
@@ -94,25 +104,15 @@ class _CommentBodyState extends ConsumerState<CommentBody> {
   }
 
   void _handleReportComment() {
-    final sprkRepository = GetIt.instance<SprkRepository>();
     showDialog<void>(
       context: context,
       builder: (context) => ReportDialog(
-        postUri: commentState.thread.post.uri.toString(),
-        postCid: commentState.thread.post.cid,
-        onSubmit: (subject, reasonType, reason) async {
-          try {
-            await sprkRepository.repo.createReport(
-              input: ModerationCreateReportInput(
-                subject: subject,
-                reasonType: reasonType,
-                reason: reason,
-              ),
-            );
-          } catch (e) {
-            _logger.e('Error creating report', error: e);
-          }
-        },
+        subject: UModerationCreateReportSubject.repoStrongRef(
+          data: RepoStrongRef(
+            uri: commentState.thread.post.uri,
+            cid: commentState.thread.post.cid,
+          ),
+        ),
       ),
     );
   }
@@ -427,10 +427,15 @@ class _Avatar extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return UserAvatar(
-      imageUrl: thread.post.author.avatar.toString(),
-      username: thread.post.author.handle,
-      size: 36,
+    final author = thread.post.author;
+    return ModeratedProfileAvatar(
+      labels: author.labels ?? const [],
+      subjectDid: author.did,
+      child: UserAvatar(
+        imageUrl: author.avatar.toString(),
+        username: author.handle,
+        size: 36,
+      ),
     );
   }
 }
diff --git a/lib/src/features/feed/providers/feed_provider.dart b/lib/src/features/feed/providers/feed_provider.dart
index ee3dea27..ff6cf15b 100644
--- a/lib/src/features/feed/providers/feed_provider.dart
+++ b/lib/src/features/feed/providers/feed_provider.dart
@@ -6,21 +6,21 @@ import 'package:poptart/poptart.dart';
 import 'package:get_it/get_it.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/storage/cache/download_manager_interface.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 import 'package:spark/src/features/feed/providers/feed_state.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
 import 'package:spark/src/features/settings/providers/settings_provider.dart';
 
 part 'feed_provider.g.dart';
 
 abstract interface class FeedSettingsGateway {
   Future<List<String>> getLabelers();
-
-  Future<LabelPreference> getLabelPreference(String value);
 }
 
 class _RiverpodFeedSettingsGateway implements FeedSettingsGateway {
@@ -33,7 +33,7 @@ class _RiverpodFeedSettingsGateway implements FeedSettingsGateway {
   Future<List<String>> getLabelers() async {
     try {
       return await ref
-          .read(settingsProvider.notifier)
+          .read(labelerSettingsControllerProvider)
           .getLabelers()
           .timeout(const Duration(seconds: 5), onTimeout: _fallbackLabelers);
     } catch (_) {
@@ -44,11 +44,6 @@ class _RiverpodFeedSettingsGateway implements FeedSettingsGateway {
   List<String> _fallbackLabelers() {
     return [sprkRepository.modDid.split('#').first];
   }
-
-  @override
-  Future<LabelPreference> getLabelPreference(String value) {
-    return ref.read(settingsProvider.notifier).getLabelPreference(value);
-  }
 }
 
 final feedSettingsGatewayProvider = Provider<FeedSettingsGateway>((ref) {
@@ -215,65 +210,40 @@ class FeedNotifier extends _$FeedNotifier {
     try {
       // Labels are already included in post views from the appview
       // We just need to merge them with self-labels and process them
-      final allLabels = <Label>[];
+      final now = DateTime.now().toUtc();
+      final extraInfo = replaceExisting
+          ? LinkedHashMap<AtUri, ({List<Label> postLabels})>()
+          : LinkedHashMap<AtUri, ({List<Label> postLabels})>.from(
+              state.extraInfo,
+            );
       final postsWithMergedLabels = <PostView>[];
 
       for (final post in posts) {
         final key = post.uri.toString();
-        // Start with labels from the post view (from appview)
-        final postLabels = <Label>[...?post.labels];
+        final incomingLabels = <Label>[...?post.labels];
 
         // Add self-labels from the post record
         if (post.selfLabels != null) {
           for (final selfLabel in post.selfLabels!) {
-            postLabels.add(
+            incomingLabels.add(
               Label(
                 uri: key,
                 val: selfLabel.val,
-                src: key,
+                src: post.author.did,
                 cts: post.indexedAt,
               ),
             );
           }
         }
 
-        allLabels.addAll(postLabels);
-        postsWithMergedLabels.add(post.copyWith(labels: postLabels));
-      }
-
-      final extraInfo = LinkedHashMap<AtUri, ({List<Label> postLabels})>.from(
-        state.extraInfo,
-      );
-
-      for (final newLabel in allLabels) {
-        final uri = AtUri.parse(newLabel.uri);
-        extraInfo.update(uri, (value) {
-          final existingLabels = value.postLabels;
-
-          // if new label in existing labels,
-          //check if it should replace existing one
-          if (existingLabels.any((label) => label.val == newLabel.val)) {
-            final existingLabel = existingLabels.firstWhere(
-              (label) => label.val == newLabel.val,
-            );
-
-            // if new label says that existing one is negated or expired,
-            // replace the existing one
-            if (((newLabel.ver ?? 0) > (existingLabel.ver ?? 0) &&
-                    newLabel.isNeg) ||
-                existingLabel.exp != null &&
-                    existingLabel.exp!.isBefore(DateTime.now())) {
-              existingLabels.remove(existingLabel);
-              return (postLabels: [...existingLabels, newLabel]);
-            } else {
-              // if the new label is the same as the existing one, do nothing
-              return value;
-            }
-          } else {
-            // if the new label is not in the existing labels, add it
-            return (postLabels: [...existingLabels, newLabel]);
-          }
-        }, ifAbsent: () => (postLabels: [newLabel]));
+        final latestLabels = mergeLatestLabelEvents(
+          existing: extraInfo[post.uri]?.postLabels ?? const [],
+          incoming: incomingLabels,
+          now: now,
+        );
+        final activeLabels = activeLabelsFromEvents(latestLabels, now: now);
+        extraInfo[post.uri] = (postLabels: latestLabels);
+        postsWithMergedLabels.add(post.copyWith(labels: activeLabels));
       }
 
       final filteredPosts = await _filterHiddenPosts(
@@ -289,29 +259,34 @@ class FeedNotifier extends _$FeedNotifier {
         return false;
       }
 
-      if (filteredPosts.isEmpty) {
-        if (generation == null || generation == _fetchGeneration) {
-          state = state.copyWith(
-            cursor: cursor,
-            extraInfo: extraInfo,
-            loadingFirstLoad: false,
-          );
-        }
-        return false;
-      }
-
+      final receivedUris = postsWithMergedLabels
+          .map((post) => post.uri)
+          .toSet();
       final updatedPosts = replaceExisting
           ? filteredPosts
-          : [...state.loadedPosts, ...filteredPosts];
+          : [
+              ...state.loadedPosts.where(
+                (post) => !receivedUris.contains(post.uri),
+              ),
+              ...filteredPosts,
+            ];
+      final updatedIndex = updatedPosts.isEmpty
+          ? 0
+          : state.index.clamp(0, updatedPosts.length - 1);
       if (generation == null || generation == _fetchGeneration) {
         state = state.copyWith(
           loadedPosts: updatedPosts,
+          index: updatedIndex,
           cursor: cursor,
           extraInfo: extraInfo,
           loadingFirstLoad: false,
         );
       }
 
+      if (filteredPosts.isEmpty) {
+        return false;
+      }
+
       for (final post in filteredPosts) {
         _downloadManager.submitTask(
           DownloadTask(
@@ -560,47 +535,30 @@ class FeedNotifier extends _$FeedNotifier {
     );
   }
 
-  /// Checks if a post should be hidden based on its labels and user preferences
-  Future<bool> _shouldHidePost(AtUri uri, List<Label> postLabels) async {
-    for (final label in postLabels) {
-      try {
-        final labelPreference = await _settingsGateway.getLabelPreference(
-          label.val,
-        );
-        if (labelPreference.setting == Setting.hide ||
-            labelPreference.adultOnly) {
-          return true;
-        }
-      } catch (e) {
-        // Label preference not found, continue checking other labels
-        continue;
-      }
-    }
-    return false;
-  }
-
   /// Filters based on label preferences, removing posts that should be hidden
   Future<List<PostView>> _filterHiddenPosts(
     List<PostView> posts,
     LinkedHashMap<AtUri, ({List<Label> postLabels})> extraInfo,
   ) async {
-    final filteredPosts = <PostView>[];
-
-    for (final post in posts) {
-      final postExtraInfo = extraInfo[post.uri];
-      if (postExtraInfo != null) {
-        final shouldHide = await _shouldHidePost(
-          post.uri,
-          postExtraInfo.postLabels,
-        );
-        if (!shouldHide) {
-          filteredPosts.add(post);
-        }
-      } else {
-        filteredPosts.add(post);
-      }
+    try {
+      final engine = await ref.read(moderationEngineProvider.future);
+      return posts.where((post) {
+        final labels = extraInfo[post.uri]?.postLabels;
+        if (labels == null) return true;
+        final decision = ModerationSubject.content(
+          labels: labels,
+          authorLabels: post.author.labels ?? const [],
+          subjectDid: post.author.did,
+        ).evaluate(engine);
+        return !decision.forContext(ModerationContext.contentList).filter;
+      }).toList();
+    } catch (error, stackTrace) {
+      _logger.w(
+        'Could not moderate feed page',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      return posts;
     }
-
-    return filteredPosts;
   }
 }
diff --git a/lib/src/features/feed/providers/visible_pinned_feeds_provider.dart b/lib/src/features/feed/providers/visible_pinned_feeds_provider.dart
new file mode 100644
index 00000000..c45903ea
--- /dev/null
+++ b/lib/src/features/feed/providers/visible_pinned_feeds_provider.dart
@@ -0,0 +1,57 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/features/settings/providers/settings_provider.dart';
+
+typedef VisiblePinnedFeedsState = ({
+  Feed effectiveActiveFeed,
+  List<Feed> feeds,
+  bool shouldPersistEffectiveActiveFeed,
+});
+
+final visiblePinnedFeedsProvider = Provider<VisiblePinnedFeedsState>((ref) {
+  final settings = ref.watch(settingsProvider);
+  final engine = ref.watch(moderationEngineProvider).asData?.value;
+  var activeFeedModerationUnresolved = false;
+
+  final feeds = settings.feeds
+      .where((feed) {
+        if (!feed.config.pinned) return false;
+
+        final generator = feed.view;
+        if (generator == null) return true;
+
+        final subject = feedGeneratorModerationSubject(generator);
+        if (!subject.hasLabels) return true;
+        if (engine == null) {
+          if (feed.config.id == settings.activeFeed.config.id) {
+            activeFeedModerationUnresolved = true;
+          }
+          return false;
+        }
+
+        return !subject
+            .evaluate(engine)
+            .forContext(ModerationContext.contentList)
+            .filter;
+      })
+      .toList(growable: false);
+  final activeFeedIndex = feeds.indexWhere(
+    (feed) => feed.config.id == settings.activeFeed.config.id,
+  );
+  Feed effectiveActiveFeed = settings.activeFeed;
+  if (activeFeedIndex >= 0) {
+    effectiveActiveFeed = feeds[activeFeedIndex];
+  } else if (feeds.isNotEmpty) {
+    effectiveActiveFeed = feeds.first;
+  }
+
+  return (
+    effectiveActiveFeed: effectiveActiveFeed,
+    feeds: feeds,
+    shouldPersistEffectiveActiveFeed:
+        effectiveActiveFeed.config.id != settings.activeFeed.config.id &&
+        !activeFeedModerationUnresolved,
+  );
+});
diff --git a/lib/src/features/feed/ui/pages/feed_page.dart b/lib/src/features/feed/ui/pages/feed_page.dart
index 39399660..a2250036 100644
--- a/lib/src/features/feed/ui/pages/feed_page.dart
+++ b/lib/src/features/feed/ui/pages/feed_page.dart
@@ -11,12 +11,12 @@ import 'package:spark/src/features/feed/ui/widgets/feed/snappy_page_scroll_physi
 import 'package:spark/src/features/feed/ui/widgets/post/feed_post_skeleton.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/feed_post_widget.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/no_more_posts.dart';
-import 'package:spark/src/features/settings/providers/settings_provider.dart';
 
 class FeedPage extends ConsumerStatefulWidget {
-  const FeedPage({required this.feed, super.key});
+  const FeedPage({required this.feed, required this.isActive, super.key});
 
   final Feed feed;
+  final bool isActive;
 
   @override
   ConsumerState<FeedPage> createState() => _FeedPageState();
@@ -91,9 +91,7 @@ class _FeedPageState extends ConsumerState<FeedPage>
     final l10n = AppLocalizations.of(context);
     final state = ref.watch(feedProvider(widget.feed));
     final notifier = ref.read(feedProvider(widget.feed).notifier);
-    final shouldBeActive = ref.watch(
-      settingsProvider.select((settings) => settings.activeFeed == widget.feed),
-    );
+    final shouldBeActive = widget.isActive;
 
     ref.listen(feedRefreshTriggerProvider(widget.feed), (previous, next) {
       if (previous != next) {
diff --git a/lib/src/features/feed/ui/pages/feeds_page.dart b/lib/src/features/feed/ui/pages/feeds_page.dart
index b69cb334..8ecddc76 100644
--- a/lib/src/features/feed/ui/pages/feeds_page.dart
+++ b/lib/src/features/feed/ui/pages/feeds_page.dart
@@ -1,8 +1,11 @@
+import 'dart:async';
+
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/tokens/colors.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/features/feed/providers/visible_pinned_feeds_provider.dart';
 import 'package:spark/src/features/feed/ui/pages/feed_page.dart';
 import 'package:spark/src/features/feed/ui/widgets/feed/cacheable_page_view.dart';
 import 'package:spark/src/features/feed/ui/widgets/feed/feeds_bar.dart';
@@ -22,6 +25,7 @@ class _FeedsPageState extends ConsumerState<FeedsPage> {
   Feed? _lastActiveFeed;
   List<Feed>? _lastFeedsList;
   bool _isPageControllerUpdating = false;
+  String? _scheduledActiveFeedId;
 
   @override
   void initState() {
@@ -97,10 +101,12 @@ class _FeedsPageState extends ConsumerState<FeedsPage> {
 
   @override
   Widget build(BuildContext context) {
-    final settings = ref.watch(settingsProvider);
-    // Only show pinned feeds in the home view
-    final feeds = settings.feeds.where((feed) => feed.config.pinned).toList();
-    final activeFeed = settings.activeFeed;
+    final visiblePinnedFeeds = ref.watch(visiblePinnedFeedsProvider);
+    final feeds = visiblePinnedFeeds.feeds;
+    final activeFeed = visiblePinnedFeeds.effectiveActiveFeed;
+    if (visiblePinnedFeeds.shouldPersistEffectiveActiveFeed) {
+      _scheduleActiveFeed(activeFeed);
+    }
 
     // Check if we need to initialize or update the page controller
     final needsInitialization = !_isInitialized;
@@ -164,7 +170,10 @@ class _FeedsPageState extends ConsumerState<FeedsPage> {
                   // Use feed ID as key to preserve state across reordering
                   return KeyedSubtree(
                     key: ValueKey(feeds[index].config.id),
-                    child: FeedPage(feed: feeds[index]),
+                    child: FeedPage(
+                      feed: feeds[index],
+                      isActive: feeds[index].config.id == activeFeed.config.id,
+                    ),
                   );
                 }
                 return const DecoratedBox(
@@ -179,4 +188,16 @@ class _FeedsPageState extends ConsumerState<FeedsPage> {
             ),
     );
   }
+
+  void _scheduleActiveFeed(Feed feed) {
+    if (_scheduledActiveFeedId == feed.config.id) return;
+    _scheduledActiveFeedId = feed.config.id;
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (!mounted) return;
+      _scheduledActiveFeedId = null;
+      final current = ref.read(settingsProvider).activeFeed;
+      if (current.config.id == feed.config.id) return;
+      unawaited(ref.read(settingsProvider.notifier).setActiveFeed(feed));
+    });
+  }
 }
diff --git a/lib/src/features/feed/ui/pages/standalone_post_page.dart b/lib/src/features/feed/ui/pages/standalone_post_page.dart
index ba3f4403..a5057c9b 100644
--- a/lib/src/features/feed/ui/pages/standalone_post_page.dart
+++ b/lib/src/features/feed/ui/pages/standalone_post_page.dart
@@ -8,19 +8,18 @@ import 'package:spark/src/core/design_system/components/atoms/buttons/app_overla
 import 'package:spark/src/core/design_system/tokens/constants.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
 import 'package:spark/src/core/media/media_playback_gate.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_video_aspect_ratio.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/design_system/tokens/colors.dart';
-import 'package:spark/src/core/ui/widgets/content_warning_overlay.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
 import 'package:spark/src/features/feed/providers/post_updates.dart';
 import 'package:spark/src/features/feed/navigation/standalone_post_navigation_resolver.dart';
 import 'package:spark/src/features/feed/ui/widgets/images/image_carousel.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/post_overlay.dart';
 import 'package:spark/src/features/feed/ui/widgets/videos/video_player.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
 
 @RoutePage()
 class StandalonePostPage extends ConsumerStatefulWidget {
@@ -41,9 +40,7 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
   Future<ResolvedStandalonePost>? _postFuture;
   final GlobalKey<PostVideoPlayerState> _videoPlayerKey =
       GlobalKey<PostVideoPlayerState>();
-  bool _showWarningOverlay = false;
-  List<String> _warningLabels = [];
-  bool _shouldBlurContent = false;
+  bool _moderationConcealed = true;
   bool _hasOpenedHighlightedReply = false;
   String? _activePostUri;
   ProviderSubscription<int>? _anchorUpdateSubscription;
@@ -67,13 +64,12 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
   }
 
   void _loadPost() {
+    _moderationConcealed = true;
     _postFuture = _loadResolvedPost();
     _postFuture?.then((resolvedPost) {
       if (mounted) {
         _activePostUri = resolvedPost.post.uri.toString();
         _bindResolvedPostUpdates(_activePostUri);
-        _checkContentWarning(resolvedPost.post);
-        _openHighlightedReplyIfNeeded(resolvedPost);
       }
     });
   }
@@ -163,40 +159,6 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
     );
   }
 
-  void _checkContentWarning(PostView postData) {
-    final labels = postData.labels ?? [];
-    final preferences = ref.read(userPreferencesProvider).asData?.value;
-
-    if (labels.isNotEmpty && preferences != null) {
-      final shouldShowWarning = LabelUtils.shouldShowWarning(
-        preferences,
-        labels,
-      );
-      final shouldBlurContent = LabelUtils.shouldBlurContent(
-        preferences,
-        labels,
-      );
-      if (shouldShowWarning) {
-        final warningLabels = LabelUtils.getWarningLabels(preferences, labels);
-        setState(() {
-          _showWarningOverlay = true;
-          _warningLabels = warningLabels;
-          _shouldBlurContent = shouldBlurContent;
-        });
-      } else {
-        setState(() {
-          _showWarningOverlay = false;
-          _warningLabels = [];
-        });
-      }
-    } else {
-      setState(() {
-        _showWarningOverlay = false;
-        _warningLabels = [];
-      });
-    }
-  }
-
   @override
   Widget build(BuildContext context) {
     final l10n = AppLocalizations.of(context);
@@ -210,14 +172,15 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
         Widget content;
 
         if (snapshot.connectionState == ConnectionState.done &&
-            snapshot.hasData) {
+            resolvedPost != null &&
+            postData != null) {
           final mainContent = Stack(
             children: [
               // Main content
               Positioned.fill(
-                child: postData!.videoUrl.isNotEmpty
+                child: postData.videoUrl.isNotEmpty
                     ? MediaPlaybackGate(
-                        isActive: true,
+                        isActive: !_moderationConcealed,
                         builder: (context, shouldPlay) {
                           return PostVideoPlayer(
                             key: _videoPlayerKey,
@@ -247,20 +210,24 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
             ],
           );
 
-          if (_showWarningOverlay && _warningLabels.isNotEmpty) {
-            content = ContentWarningOverlay(
-              onViewContent: () {
-                setState(() {
-                  _showWarningOverlay = false;
-                });
-              },
-              warningLabels: _warningLabels,
-              shouldBlur: _shouldBlurContent,
-              child: mainContent,
-            );
-          } else {
-            content = mainContent;
-          }
+          content = ModeratedContent(
+            key: ValueKey(postData.uri.toString()),
+            subject: ModerationSubject.content(
+              labels: postData.labels ?? const [],
+              authorLabels: postData.author.labels ?? const [],
+              subjectDid: postData.author.did,
+            ),
+            context: ModerationContext.contentView,
+            onConcealChanged: (concealed) {
+              if (!concealed) {
+                _openHighlightedReplyIfNeeded(resolvedPost);
+              }
+              if (mounted && _moderationConcealed != concealed) {
+                setState(() => _moderationConcealed = concealed);
+              }
+            },
+            child: mainContent,
+          );
         } else if (snapshot.hasError) {
           content = Center(
             child: Column(
@@ -292,15 +259,17 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
               ? null
               : _CommentBar(
                   bottomPadding: bottomPadding,
-                  onTap: () {
-                    context.router.push(
-                      CommentsRoute(
-                        postUri: postData.uri.toString(),
-                        isSprk: postData.isSprk,
-                        post: postData,
-                      ),
-                    );
-                  },
+                  onTap: _moderationConcealed
+                      ? null
+                      : () {
+                          context.router.push(
+                            CommentsRoute(
+                              postUri: postData.uri.toString(),
+                              isSprk: postData.isSprk,
+                              post: postData,
+                            ),
+                          );
+                        },
                 ),
         );
       },
@@ -312,7 +281,7 @@ class _CommentBar extends StatelessWidget {
   const _CommentBar({required this.bottomPadding, required this.onTap});
 
   final double bottomPadding;
-  final VoidCallback onTap;
+  final VoidCallback? onTap;
 
   @override
   Widget build(BuildContext context) {
diff --git a/lib/src/features/feed/ui/widgets/action_buttons/side_action_bar.dart b/lib/src/features/feed/ui/widgets/action_buttons/side_action_bar.dart
index 1161e9f9..e105697d 100644
--- a/lib/src/features/feed/ui/widgets/action_buttons/side_action_bar.dart
+++ b/lib/src/features/feed/ui/widgets/action_buttons/side_action_bar.dart
@@ -1,4 +1,6 @@
 import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
+import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
@@ -311,8 +313,9 @@ class SideActionBarState extends ConsumerState<SideActionBar> {
     showDialog<void>(
       context: context,
       builder: (context) => ReportDialog(
-        postUri: currentPost.uri.toString(),
-        postCid: currentPost.cid,
+        subject: UModerationCreateReportSubject.repoStrongRef(
+          data: RepoStrongRef(uri: currentPost.uri, cid: currentPost.cid),
+        ),
       ),
     );
   }
diff --git a/lib/src/features/feed/ui/widgets/feed/feeds_bar.dart b/lib/src/features/feed/ui/widgets/feed/feeds_bar.dart
index 03a82631..c6815175 100644
--- a/lib/src/features/feed/ui/widgets/feed/feeds_bar.dart
+++ b/lib/src/features/feed/ui/widgets/feed/feeds_bar.dart
@@ -1,11 +1,14 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/design_system/components/molecules/feed_tag_list.dart';
 import 'package:spark/src/core/design_system/templates/feeds_bar_template.dart';
 import 'package:spark/src/features/posting/utils/create_media_actions.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/features/feed/providers/feed_refresh_trigger_provider.dart';
+import 'package:spark/src/features/feed/providers/visible_pinned_feeds_provider.dart';
 import 'package:spark/src/features/settings/providers/settings_provider.dart';
 
 export 'package:spark/src/core/design_system/templates/feeds_bar_template.dart'
@@ -150,19 +153,28 @@ class _FeedsBarState extends ConsumerState<FeedsBar> {
   @override
   Widget build(BuildContext context) {
     final l10n = AppLocalizations.of(context);
-    final settings = ref.watch(settingsProvider);
+    final visiblePinnedFeedsState = ref.watch(visiblePinnedFeedsProvider);
+    final visiblePinnedFeeds = visiblePinnedFeedsState.feeds;
+    final effectiveActiveFeed = visiblePinnedFeedsState.effectiveActiveFeed;
+    final engine = ref.watch(moderationEngineProvider).asData?.value;
+    final locale = Localizations.localeOf(context).toLanguageTag();
 
-    // Only show pinned feeds in the home view
-    final pinnedFeeds = settings.feeds
-        .where((feed) => feed.config.pinned)
-        .toList();
-
-    final tags = pinnedFeeds.map((feed) {
+    final tags = visiblePinnedFeeds.map((feed) {
       final isTimeline =
           feed.type == 'timeline' && feed.config.value == 'following';
+      final generator = feed.view;
+      var text = generator?.displayName ?? l10n.labelFollowing;
+      if (engine != null && generator != null) {
+        final decision = feedGeneratorModerationSubject(
+          generator,
+        ).evaluate(engine, preferredLocales: [locale]);
+        if (decision.forContext(ModerationContext.contentList).blur) {
+          text = l10n.moderationContentNotice;
+        }
+      }
       return FeedTagData(
         id: feed.config.id,
-        text: feed.view != null ? feed.view!.displayName : l10n.labelFollowing,
+        text: text,
         isTimeline: isTimeline,
         isLiked: feed.view?.viewer?.like != null,
         canDelete: !isTimeline,
@@ -171,23 +183,25 @@ class _FeedsBarState extends ConsumerState<FeedsBar> {
 
     return FeedsBarTemplate(
       tags: tags,
-      selectedTagId: settings.activeFeed.config.id,
+      selectedTagId: effectiveActiveFeed.config.id,
       onLeadingPressed: CreateMediaActions.onRecord(context, storyMode: false),
       onTagTap: (tagId) {
-        final feed = pinnedFeeds.firstWhere((f) => f.config.id == tagId);
+        final feed = visiblePinnedFeeds.firstWhere((f) => f.config.id == tagId);
 
-        if (settings.activeFeed == feed) {
+        if (effectiveActiveFeed.config.id == feed.config.id) {
           ref.read(feedRefreshTriggerProvider(feed).notifier).trigger();
         } else {
           ref.read(settingsProvider.notifier).setActiveFeed(feed);
-          final feedIndex = pinnedFeeds.indexOf(feed);
+          final feedIndex = visiblePinnedFeeds.indexOf(feed);
           if (feedIndex != -1 && widget.pageController.hasClients) {
             widget.pageController.jumpToPage(feedIndex);
           }
         }
       },
       onLongPress: (tagData) {
-        final feed = pinnedFeeds.firstWhere((f) => f.config.id == tagData.id);
+        final feed = visiblePinnedFeeds.firstWhere(
+          (f) => f.config.id == tagData.id,
+        );
         _showFeedOptionsSheet(context, feed);
       },
     );
diff --git a/lib/src/features/feed/ui/widgets/post/feed_post_widget.dart b/lib/src/features/feed/ui/widgets/post/feed_post_widget.dart
index 60f5d0f8..2e63406f 100644
--- a/lib/src/features/feed/ui/widgets/post/feed_post_widget.dart
+++ b/lib/src/features/feed/ui/widgets/post/feed_post_widget.dart
@@ -3,18 +3,17 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/design_system/tokens/colors.dart';
-import 'package:spark/src/core/ui/widgets/content_warning_overlay.dart';
 import 'package:spark/src/core/ui/widgets/heart_animation.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
 import 'package:spark/src/features/feed/providers/feed_provider.dart';
 import 'package:spark/src/features/feed/providers/like_post.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/post_media_viewer.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/post_overlay.dart';
 import 'package:spark/src/features/home/providers/feed_settings_visibility_provider.dart';
 import 'package:spark/src/features/home/providers/navigation_provider.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
 
 class FeedPostWidget extends ConsumerStatefulWidget {
   const FeedPostWidget({required this.index, required this.feed, super.key});
@@ -32,9 +31,7 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
   final GlobalKey<PostMediaViewerState> _mediaViewerKey =
       GlobalKey<PostMediaViewerState>();
   bool _isAnimatingHeart = false;
-  bool _showWarningOverlay = false;
-  bool _userDismissedWarning = false;
-  List<String> _warningLabels = [];
+  bool _moderationConcealed = false;
   // Local UI override for like state to avoid needing a GlobalKey
   bool? _overrideIsLiked;
 
@@ -53,6 +50,7 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
       _lastPostUri = currentUri;
       _postFuture = Future.value(post);
       _overrideIsLiked = null;
+      _moderationConcealed = false;
     }
   }
 
@@ -106,49 +104,6 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
     }
   }
 
-  void _checkContentWarning(String postUri) {
-    final feedState = ref.read(feedProvider(widget.feed));
-    final preferences = ref.read(userPreferencesProvider).asData?.value;
-
-    if (widget.index < feedState.loadedPosts.length) {
-      final post = feedState.loadedPosts[widget.index];
-      if (post.uri.toString() != postUri) {
-        return;
-      }
-      final extraInfo = feedState.extraInfo[post.uri];
-
-      if (extraInfo != null &&
-          extraInfo.postLabels.isNotEmpty &&
-          !_userDismissedWarning &&
-          preferences != null) {
-        final shouldShowWarning = LabelUtils.shouldShowWarning(
-          preferences,
-          extraInfo.postLabels,
-        );
-        if (shouldShowWarning) {
-          final warningLabels = LabelUtils.getWarningLabels(
-            preferences,
-            extraInfo.postLabels,
-          );
-          setState(() {
-            _showWarningOverlay = true;
-            _warningLabels = warningLabels;
-          });
-        } else {
-          setState(() {
-            _showWarningOverlay = false;
-            _warningLabels = [];
-          });
-        }
-      } else {
-        setState(() {
-          _showWarningOverlay = false;
-          _warningLabels = [];
-        });
-      }
-    }
-  }
-
   @override
   Widget build(BuildContext context) {
     final l10n = AppLocalizations.of(context);
@@ -171,7 +126,6 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
         WidgetsBinding.instance.addPostFrameCallback((_) {
           if (mounted) {
             setState(_loadPost);
-            _checkContentWarning(currentUri);
           }
         });
       }
@@ -191,13 +145,6 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
             snapshot.hasData) {
           final postData = snapshot.data!;
 
-          // Check for content warning on post load
-          WidgetsBinding.instance.addPostFrameCallback((_) {
-            if (mounted) {
-              _checkContentWarning(postData.uri.toString());
-            }
-          });
-
           // Get labels for the overlay and use the latest post from feed state
           var labels = <Label>[];
           // Use the post from feed state as it has the latest updates (e.g., after like/repost)
@@ -216,7 +163,7 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
               isOnFeedsTab &&
               feedState.index == widget.index &&
               !feedSettingsVisible &&
-              !_showWarningOverlay;
+              !_moderationConcealed;
 
           final mainContent = HeartAnimation(
             isAnimating: _isAnimatingHeart,
@@ -265,23 +212,21 @@ class _FeedPostWidgetState extends ConsumerState<FeedPostWidget> {
             ),
           );
 
-          // Return main content with warning overlay if needed
-          if (_showWarningOverlay && _warningLabels.isNotEmpty) {
-            return ContentWarningOverlay(
-              onViewContent: () {
-                setState(() {
-                  _showWarningOverlay = false;
-                  _userDismissedWarning =
-                      true; // User has dismissed the warning
-                });
-              },
-              warningLabels: _warningLabels,
-              shouldBlur: true,
-              child: mainContent,
-            );
-          }
-
-          return mainContent;
+          return ModeratedContent(
+            key: ValueKey(currentPost.uri.toString()),
+            subject: ModerationSubject.content(
+              labels: labels,
+              authorLabels: currentPost.author.labels ?? const [],
+              subjectDid: currentPost.author.did,
+            ),
+            context: ModerationContext.contentList,
+            onConcealChanged: (concealed) {
+              if (mounted && _moderationConcealed != concealed) {
+                setState(() => _moderationConcealed = concealed);
+              }
+            },
+            child: mainContent,
+          );
         }
         if (snapshot.hasError) {
           return DecoratedBox(
diff --git a/lib/src/features/feed/ui/widgets/post/info_bar.dart b/lib/src/features/feed/ui/widgets/post/info_bar.dart
index 800cfaba..7866ebcc 100644
--- a/lib/src/features/feed/ui/widgets/post/info_bar.dart
+++ b/lib/src/features/feed/ui/widgets/post/info_bar.dart
@@ -21,6 +21,7 @@ class InfoBar extends StatelessWidget {
     this.onHashtagTap,
     this.onDescriptionExpandToggle,
     this.audio,
+    this.avatarBuilder,
   });
   final String username;
   final String displayName;
@@ -35,6 +36,7 @@ class InfoBar extends StatelessWidget {
   final ValueChanged<String>? onHashtagTap;
   final ValueChanged<bool>? onDescriptionExpandToggle;
   final AudioView? audio;
+  final Widget Function(Widget avatar)? avatarBuilder;
 
   @override
   Widget build(BuildContext context) {
@@ -44,6 +46,7 @@ class InfoBar extends StatelessWidget {
       description: description,
       informLabels: informLabels,
       avatarUrl: avatarUrl,
+      avatarBuilder: avatarBuilder,
       audio: audio,
       onTitleTap: onUsernameTap,
       onHandleTap: onUsernameTap,
diff --git a/lib/src/features/feed/ui/widgets/post/post_overlay.dart b/lib/src/features/feed/ui/widgets/post/post_overlay.dart
index 9750e303..a1fccd14 100644
--- a/lib/src/features/feed/ui/widgets/post/post_overlay.dart
+++ b/lib/src/features/feed/ui/widgets/post/post_overlay.dart
@@ -3,12 +3,14 @@ import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/known_interactions_bar.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/routing/app_router.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
 import 'package:spark/src/features/feed/ui/widgets/action_buttons/side_action_bar.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/info_bar.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
 
 class PostOverlay extends ConsumerWidget {
   const PostOverlay({
@@ -55,7 +57,7 @@ class PostOverlay extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final bottomPadding = MediaQuery.of(context).padding.bottom;
-    final preferences = ref.watch(userPreferencesProvider).asData?.value;
+    final engine = ref.watch(moderationEngineProvider).asData?.value;
 
     return Stack(
       children: [
@@ -111,17 +113,37 @@ class PostOverlay extends ConsumerWidget {
                         // Author info and caption
                         Builder(
                           builder: (context) {
-                            final informLabels = preferences != null
-                                ? LabelUtils.getInformLabels(
-                                    preferences,
-                                    labels,
-                                  )
-                                : <String>[];
+                            final l10n = AppLocalizations.of(context);
+                            final locale = Localizations.localeOf(
+                              context,
+                            ).toLanguageTag();
+                            final informLabels =
+                                engine
+                                    ?.evaluate(
+                                      labels,
+                                      target: ModerationTarget.content,
+                                      subjectDid: post.author.did,
+                                      preferredLocales: [locale],
+                                    )
+                                    .forContext(ModerationContext.contentView)
+                                    .informs
+                                    .map(
+                                      (cause) =>
+                                          cause.localizedStrings(l10n)?.name,
+                                    )
+                                    .nonNulls
+                                    .toList() ??
+                                const <String>[];
                             return InfoBar(
                               username: post.author.handle,
                               displayName:
                                   post.author.displayName ?? post.author.handle,
                               avatarUrl: post.author.avatar?.toString(),
+                              avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                                labels: post.author.labels ?? const [],
+                                subjectDid: post.author.did,
+                                child: avatar,
+                              ),
                               description: post.displayText,
                               hashtags: post.hashtags,
                               informLabels: informLabels,
diff --git a/lib/src/features/feed/ui/widgets/post_likes_sheet.dart b/lib/src/features/feed/ui/widgets/post_likes_sheet.dart
index 05304496..dcea3b00 100644
--- a/lib/src/features/feed/ui/widgets/post_likes_sheet.dart
+++ b/lib/src/features/feed/ui/widgets/post_likes_sheet.dart
@@ -3,6 +3,8 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/profile_card.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/feed/providers/post_likes_provider.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
@@ -115,33 +117,46 @@ class _PostLikesSheetState extends ConsumerState<_PostLikesSheet> {
                   }
 
                   final actor = state.likes[index].actor;
-                  return Padding(
-                    padding: const EdgeInsets.symmetric(
-                      horizontal: 16,
-                      vertical: 4,
+                  return ModeratedContent(
+                    subject: ModerationSubject.profile(
+                      labels: actor.labels ?? const [],
+                      subjectDid: actor.did,
                     ),
-                    child: ProfileCard(
-                      imageUrl: actor.avatar?.toString() ?? '',
-                      userName: actor.displayName ?? actor.handle,
-                      userHandle: '@${actor.handle}',
-                      description: actor.description,
-                      isFollowing: actor.viewer?.following != null,
-                      showFollowButton: false,
-                      onTap: () {
-                        final router = context.router;
-                        Navigator.of(context).pop();
-                        router.push(
-                          ProfileRoute(
-                            did: actor.did,
-                            initialProfile: ProfileViewBasic(
+                    context: ModerationContext.profileList,
+                    child: Padding(
+                      padding: const EdgeInsets.symmetric(
+                        horizontal: 16,
+                        vertical: 4,
+                      ),
+                      child: ProfileCard(
+                        imageUrl: actor.avatar?.toString() ?? '',
+                        avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                          labels: actor.labels ?? const [],
+                          subjectDid: actor.did,
+                          child: avatar,
+                        ),
+                        userName: actor.displayName ?? actor.handle,
+                        userHandle: '@${actor.handle}',
+                        description: actor.description,
+                        isFollowing: actor.viewer?.following != null,
+                        showFollowButton: false,
+                        onTap: () {
+                          final router = context.router;
+                          Navigator.of(context).pop();
+                          router.push(
+                            ProfileRoute(
                               did: actor.did,
-                              handle: actor.handle,
-                              displayName: actor.displayName,
-                              avatar: actor.avatar,
+                              initialProfile: ProfileViewBasic(
+                                did: actor.did,
+                                handle: actor.handle,
+                                displayName: actor.displayName,
+                                avatar: actor.avatar,
+                                labels: actor.labels,
+                              ),
                             ),
-                          ),
-                        );
-                      },
+                          );
+                        },
+                      ),
                     ),
                   );
                 },
diff --git a/lib/src/features/messages/ui/pages/messages_page.dart b/lib/src/features/messages/ui/pages/messages_page.dart
index 1b222661..89963324 100644
--- a/lib/src/features/messages/ui/pages/messages_page.dart
+++ b/lib/src/features/messages/ui/pages/messages_page.dart
@@ -5,6 +5,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:get_it/get_it.dart';
 import 'package:spark/src/core/design_system/templates/chat_list_page_template.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/utils/logging/logging.dart';
 import 'package:spark/src/features/messages/providers/conversations_provider.dart';
@@ -57,6 +59,11 @@ class _MessagesPageState extends ConsumerState<MessagesPage> {
             timestamp: ts,
             preview: preview,
             unread: (convo.unreadCount) > 0,
+            avatarBuilder: (avatar) => ModeratedProfileAvatar(
+              labels: profile.labels ?? const [],
+              subjectDid: profile.did,
+              child: avatar,
+            ),
           );
         }).toList();
 
@@ -84,6 +91,17 @@ class _MessagesPageState extends ConsumerState<MessagesPage> {
           },
           onAddTap: _openNewChat,
           onRefresh: refreshAndInvalidate,
+          itemWrapper: (context, index, child) {
+            final profile = data.conversations[index].$1;
+            return ModeratedContent(
+              subject: ModerationSubject.profile(
+                labels: profile.labels ?? const [],
+                subjectDid: profile.did,
+              ),
+              context: ModerationContext.profileList,
+              child: child,
+            );
+          },
         );
       },
       loading: () => ChatListPageTemplate.loading(onAddTap: _openNewChat),
diff --git a/lib/src/features/messages/ui/pages/new_chat_search_page.dart b/lib/src/features/messages/ui/pages/new_chat_search_page.dart
index cfe5f35f..ae82f295 100644
--- a/lib/src/features/messages/ui/pages/new_chat_search_page.dart
+++ b/lib/src/features/messages/ui/pages/new_chat_search_page.dart
@@ -9,6 +9,8 @@ import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 import 'package:spark/src/core/network/messages/data/repository/messages_repository.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/features/search/providers/search_provider.dart';
 
 @RoutePage()
@@ -238,16 +240,28 @@ class _UserResultsState extends ConsumerState<_UserResults> {
 
         final actor = state.searchResults[index];
 
-        return Padding(
-          padding: const EdgeInsets.only(bottom: 8),
-          child: ProfileCard(
-            imageUrl: actor.avatar?.toString() ?? '',
-            userName: actor.displayName ?? actor.handle,
-            userHandle: '@${actor.handle}',
-            description: actor.description ?? '',
-            isFollowing: false,
-            showFollowButton: false, // Not relevant when starting a chat
-            onTap: () => _startChat(actor),
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: actor.labels ?? const [],
+            subjectDid: actor.did,
+          ),
+          context: ModerationContext.profileList,
+          child: Padding(
+            padding: const EdgeInsets.only(bottom: 8),
+            child: ProfileCard(
+              imageUrl: actor.avatar?.toString() ?? '',
+              avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                labels: actor.labels ?? const [],
+                subjectDid: actor.did,
+                child: avatar,
+              ),
+              userName: actor.displayName ?? actor.handle,
+              userHandle: '@${actor.handle}',
+              description: actor.description ?? '',
+              isFollowing: false,
+              showFollowButton: false, // Not relevant when starting a chat
+              onTap: () => _startChat(actor),
+            ),
           ),
         );
       },
diff --git a/lib/src/features/messages/ui/widgets/messages_list.dart b/lib/src/features/messages/ui/widgets/messages_list.dart
index 4ce95862..f7fe94f1 100644
--- a/lib/src/features/messages/ui/widgets/messages_list.dart
+++ b/lib/src/features/messages/ui/widgets/messages_list.dart
@@ -10,6 +10,8 @@ import 'package:spark/src/core/design_system/components/molecules/post_tile.dart
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/messages/data/models/message_models.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/ui/widgets/image_content.dart';
 import 'package:spark/src/core/ui/widgets/video_content.dart';
@@ -712,20 +714,29 @@ class _PostEmbedPreview extends ConsumerWidget {
           return _embedUnavailableIndicator(context);
         }
 
-        final (thumbUrl, isVideo) = _deriveThumb(post);
+        final (thumbUrl, _) = _deriveThumb(post);
 
         final screenWidth = MediaQuery.of(context).size.width;
         final double targetWidth = math.min(screenWidth * 0.5, 170);
-        return SizedBox(
-          width: targetWidth,
-          child: AspectRatio(
-            aspectRatio: 9 / 16,
-            child: PostTile(
-              thumbnailUrl: thumbUrl ?? '',
-              likes: post.likeCount ?? 0,
-              seen: false,
-              onTap: () =>
-                  context.router.push(StandalonePostRoute(postUri: atUri)),
+        return ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: post.labels ?? const [],
+            authorLabels: post.author.labels ?? const [],
+            subjectDid: post.author.did,
+          ),
+          context: ModerationContext.contentList,
+          presentation: const ModerationPresentation.compact(),
+          child: SizedBox(
+            width: targetWidth,
+            child: AspectRatio(
+              aspectRatio: 9 / 16,
+              child: PostTile(
+                thumbnailUrl: thumbUrl ?? '',
+                likes: post.likeCount ?? 0,
+                seen: false,
+                onTap: () =>
+                    context.router.push(StandalonePostRoute(postUri: atUri)),
+              ),
             ),
           ),
         );
diff --git a/lib/src/features/notifications/ui/widgets/notification_item.dart b/lib/src/features/notifications/ui/widgets/notification_item.dart
index d745a399..1f094f5f 100644
--- a/lib/src/features/notifications/ui/widgets/notification_item.dart
+++ b/lib/src/features/notifications/ui/widgets/notification_item.dart
@@ -5,6 +5,8 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/atoms/icons.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/notification_models.dart'
     as models;
 import 'package:spark/src/core/notifications/notification_navigation.dart';
@@ -399,11 +401,19 @@ class _NotificationItemState extends ConsumerState<NotificationItem> {
 
       return SizedBox(
         width: 40,
-        child: UserAvatar(
-          imageUrl: avatarUrl,
-          username: username,
-          size: 32,
-          backgroundColor: getAvatarColor(handleHash),
+        child: ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: author.labels ?? const [],
+            subjectDid: author.did,
+          ),
+          context: ModerationContext.avatar,
+          presentation: const ModerationPresentation.compact(),
+          child: UserAvatar(
+            imageUrl: avatarUrl,
+            username: username,
+            size: 32,
+            backgroundColor: getAvatarColor(handleHash),
+          ),
         ),
       );
     }
@@ -429,11 +439,19 @@ class _NotificationItemState extends ConsumerState<NotificationItem> {
 
             return Positioned(
               left: index * overlapStep,
-              child: UserAvatar(
-                imageUrl: avatarUrl,
-                username: username,
-                size: avatarSize,
-                backgroundColor: getAvatarColor(handleHash),
+              child: ModeratedContent(
+                subject: ModerationSubject.profile(
+                  labels: author.labels ?? const [],
+                  subjectDid: author.did,
+                ),
+                context: ModerationContext.avatar,
+                presentation: const ModerationPresentation.compact(),
+                child: UserAvatar(
+                  imageUrl: avatarUrl,
+                  username: username,
+                  size: avatarSize,
+                  backgroundColor: getAvatarColor(handleHash),
+                ),
               ),
             );
           }),
@@ -489,132 +507,140 @@ class _NotificationItemState extends ConsumerState<NotificationItem> {
     final primaryAuthor = notification.author;
     final username = primaryAuthor.displayName ?? primaryAuthor.handle;
 
-    return Material(
-      color: widget.groupedNotification.isRead
-          ? Colors.transparent
-          : AppColors.pink.withValues(alpha: 0.15),
-      child: InkWell(
-        onTap: () => _handleTap(context),
-        child: Padding(
-          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
-          child: Row(
-            crossAxisAlignment: CrossAxisAlignment.start,
-            children: [
-              // Action icon on the left (fixed width for alignment)
-              SizedBox(
-                width: 24,
-                child: Padding(
-                  padding: const EdgeInsets.only(top: 2),
-                  child: reasonIcon,
+    return ModeratedContent(
+      subject: ModerationSubject.content(
+        labels: notification.labels ?? const [],
+        authorLabels: notification.author.labels ?? const [],
+        subjectDid: primaryAuthor.did,
+      ),
+      context: ModerationContext.contentList,
+      child: Material(
+        color: widget.groupedNotification.isRead
+            ? Colors.transparent
+            : AppColors.pink.withValues(alpha: 0.15),
+        child: InkWell(
+          onTap: () => _handleTap(context),
+          child: Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+            child: Row(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                // Action icon on the left (fixed width for alignment)
+                SizedBox(
+                  width: 24,
+                  child: Padding(
+                    padding: const EdgeInsets.only(top: 2),
+                    child: reasonIcon,
+                  ),
                 ),
-              ),
-              const SizedBox(width: 12),
-              // Avatars section
-              _buildAvatarsSection(),
-              const SizedBox(width: 12),
-              // Main content
-              Expanded(
-                child: Column(
-                  crossAxisAlignment: CrossAxisAlignment.start,
-                  children: [
-                    // Username, action, and timestamp in one line
-                    Builder(
-                      builder: (context) {
-                        final theme = Theme.of(context);
-                        final colorScheme = theme.colorScheme;
-                        return Wrap(
-                          crossAxisAlignment: WrapCrossAlignment.center,
-                          spacing: 4,
-                          children: [
-                            Text(
-                              username,
-                              style: TextStyle(
-                                color: colorScheme.onSurface,
-                                fontWeight: FontWeight.bold,
-                                fontSize: 15,
-                              ),
-                            ),
-                            Text(
-                              reasonText,
-                              style: TextStyle(
-                                color: colorScheme.onSurface.withAlpha(179),
-                                fontSize: 15,
-                              ),
-                            ),
-                            Text(
-                              '· $timeAgo',
-                              style: TextStyle(
-                                color: colorScheme.onSurface.withAlpha(102),
-                                fontSize: 14,
-                              ),
-                            ),
-                          ],
-                        );
-                      },
-                    ),
-                    // Content preview below (if available)
-                    if (contentPreview != null &&
-                        contentPreview.isNotEmpty) ...[
-                      const SizedBox(height: 8),
+                const SizedBox(width: 12),
+                // Avatars section
+                _buildAvatarsSection(),
+                const SizedBox(width: 12),
+                // Main content
+                Expanded(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      // Username, action, and timestamp in one line
                       Builder(
                         builder: (context) {
                           final theme = Theme.of(context);
                           final colorScheme = theme.colorScheme;
-                          return Text(
-                            contentPreview,
-                            style: TextStyle(
-                              color: colorScheme.onSurface.withAlpha(153),
-                              fontSize: 14,
-                            ),
-                            maxLines: 3,
-                            overflow: TextOverflow.ellipsis,
+                          return Wrap(
+                            crossAxisAlignment: WrapCrossAlignment.center,
+                            spacing: 4,
+                            children: [
+                              Text(
+                                username,
+                                style: TextStyle(
+                                  color: colorScheme.onSurface,
+                                  fontWeight: FontWeight.bold,
+                                  fontSize: 15,
+                                ),
+                              ),
+                              Text(
+                                reasonText,
+                                style: TextStyle(
+                                  color: colorScheme.onSurface.withAlpha(179),
+                                  fontSize: 15,
+                                ),
+                              ),
+                              Text(
+                                '· $timeAgo',
+                                style: TextStyle(
+                                  color: colorScheme.onSurface.withAlpha(102),
+                                  fontSize: 14,
+                                ),
+                              ),
+                            ],
                           );
                         },
                       ),
+                      // Content preview below (if available)
+                      if (contentPreview != null &&
+                          contentPreview.isNotEmpty) ...[
+                        const SizedBox(height: 8),
+                        Builder(
+                          builder: (context) {
+                            final theme = Theme.of(context);
+                            final colorScheme = theme.colorScheme;
+                            return Text(
+                              contentPreview,
+                              style: TextStyle(
+                                color: colorScheme.onSurface.withAlpha(153),
+                                fontSize: 14,
+                              ),
+                              maxLines: 3,
+                              overflow: TextOverflow.ellipsis,
+                            );
+                          },
+                        ),
+                      ],
                     ],
-                  ],
+                  ),
                 ),
-              ),
-              // Media thumbnail on the right (if available)
-              if (mediaUrl != null) ...[
-                const SizedBox(width: 12),
-                ClipRRect(
-                  borderRadius: BorderRadius.circular(8),
-                  child: Image.network(
-                    mediaUrl,
-                    width: 56,
-                    height: 56,
-                    fit: BoxFit.cover,
-                    errorBuilder: (context, error, stackTrace) {
-                      // If image fails to load, don't show anything
-                      return const SizedBox.shrink();
-                    },
-                    loadingBuilder: (context, child, loadingProgress) {
-                      if (loadingProgress == null) return child;
-                      final theme = Theme.of(context);
-                      final colorScheme = theme.colorScheme;
-                      return Container(
-                        width: 56,
-                        height: 56,
-                        color: colorScheme.surfaceContainerHighest,
-                        child: Center(
-                          child: SizedBox(
-                            width: 20,
-                            height: 20,
-                            child: CircularProgressIndicator(
-                              strokeWidth: 2,
-                              color: colorScheme.onSurfaceVariant.withAlpha(
-                                138,
+                // Media thumbnail on the right (if available)
+                if (mediaUrl != null) ...[
+                  const SizedBox(width: 12),
+                  ClipRRect(
+                    borderRadius: BorderRadius.circular(8),
+                    child: Image.network(
+                      mediaUrl,
+                      width: 56,
+                      height: 56,
+                      fit: BoxFit.cover,
+                      errorBuilder: (context, error, stackTrace) {
+                        // If image fails to load, don't show anything
+                        return const SizedBox.shrink();
+                      },
+                      loadingBuilder: (context, child, loadingProgress) {
+                        if (loadingProgress == null) return child;
+                        final theme = Theme.of(context);
+                        final colorScheme = theme.colorScheme;
+                        return Container(
+                          width: 56,
+                          height: 56,
+                          color: colorScheme.surfaceContainerHighest,
+                          child: Center(
+                            child: SizedBox(
+                              width: 20,
+                              height: 20,
+                              child: CircularProgressIndicator(
+                                strokeWidth: 2,
+                                color: colorScheme.onSurfaceVariant.withAlpha(
+                                  138,
+                                ),
                               ),
                             ),
                           ),
-                        ),
-                      );
-                    },
+                        );
+                      },
+                    ),
                   ),
-                ),
+                ],
               ],
-            ],
+            ),
           ),
         ),
       ),
diff --git a/lib/src/features/posting/providers/video_upload_provider.dart b/lib/src/features/posting/providers/video_upload_provider.dart
index 1825240b..8ece52d8 100644
--- a/lib/src/features/posting/providers/video_upload_provider.dart
+++ b/lib/src/features/posting/providers/video_upload_provider.dart
@@ -241,19 +241,6 @@ Future<RepoStrongRef?> _postVideoRecord({
   return finalResult;
 }
 
-/// Crosspost video to Bluesky using same blob but Bluesky models
-@riverpod
-Future<RepoStrongRef> _crosspostVideoToBlueSky(
-  Ref _,
-  String text,
-  Blob blob,
-  String altText,
-  String rkey,
-  List<Facet> sparkFacets,
-) async {
-  return _crosspostVideoToBlueSkyRecord(text, blob, altText, rkey, sparkFacets);
-}
-
 Future<RepoStrongRef> _crosspostVideoToBlueSkyRecord(
   String text,
   Blob blob,
diff --git a/lib/src/features/profile/providers/profile_provider.dart b/lib/src/features/profile/providers/profile_provider.dart
index 33f3fb43..0e392dfa 100644
--- a/lib/src/features/profile/providers/profile_provider.dart
+++ b/lib/src/features/profile/providers/profile_provider.dart
@@ -291,6 +291,7 @@ class ProfileNotifier extends _$ProfileNotifier {
   Future<bool> createReport({
     required String did,
     required ReasonType reasonType,
+    required String serviceDid,
     String? reason,
   }) async {
     if (!authRepository.isAuthenticated) {
@@ -307,15 +308,16 @@ class ProfileNotifier extends _$ProfileNotifier {
       final subject = UModerationCreateReportSubject.repoRef(
         data: RepoRef(did: did),
       );
-      final result = await sprkRepository.repo.createReport(
+      await sprkRepository.repo.createReport(
         input: ModerationCreateReportInput(
           subject: subject,
           reasonType: reasonType,
           reason: reason,
         ),
+        serviceDid: serviceDid,
       );
       logger.i('Report created successfully for $did');
-      return result;
+      return true;
     } catch (e, s) {
       logger.e('Error creating report for $did', error: e, stackTrace: s);
       throw Exception('Failed to create report: $e');
diff --git a/lib/src/features/profile/ui/pages/profile_page.dart b/lib/src/features/profile/ui/pages/profile_page.dart
index 03bbd82c..f1a47cf5 100644
--- a/lib/src/features/profile/ui/pages/profile_page.dart
+++ b/lib/src/features/profile/ui/pages/profile_page.dart
@@ -1,4 +1,6 @@
 import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/admin/defs.dart';
+import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
@@ -17,6 +19,8 @@ import 'package:spark/src/core/utils/blocking_utils.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/utils/text_formatter.dart';
 import 'package:spark/src/features/auth/providers/auth_providers.dart';
 import 'package:spark/src/features/posting/ui/pages/recording_page.dart';
@@ -57,6 +61,7 @@ class _ProfilePageState extends ConsumerState<ProfilePage> {
   late final SparkLogger _logger = GetIt.instance<LogService>().getLogger(
     'ProfilePage',
   );
+  late final SprkRepository _sprkRepository = GetIt.instance<SprkRepository>();
   late final IdentityRepository _identityRepository =
       GetIt.instance<IdentityRepository>();
   late final ScrollController _scrollController = ScrollController();
@@ -254,191 +259,212 @@ class _ProfilePageState extends ConsumerState<ProfilePage> {
         final links = TextFormatter.extractUrls(description);
         final uniqueLinks = links.toSet().toList();
 
-        return ProfilePageTemplate(
-          displayName: profile.displayName ?? profile.handle,
-          handle: profile.handle,
-          postsCount: TextFormatter.formatCount(profile.postsCount),
-          followersCount: TextFormatter.formatCount(profile.followersCount),
-          followingCount: TextFormatter.formatCount(profile.followsCount),
-          avatarUrl: profile.avatar?.toString(),
-          description: description.isNotEmpty ? description : null,
-          links: uniqueLinks.isNotEmpty ? uniqueLinks : null,
-          knownFollowers: profile.viewer?.knownFollowers,
-          onKnownFollowersTap: () => context.router.push(
-            UserListRoute(did: widget.did, type: UserListType.knownFollowers),
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: profile.labels ?? const [],
+            subjectDid: profile.did,
           ),
-          hasStories: profile.stories?.isNotEmpty ?? false,
-          isCurrentUser: isCurrentUser,
-          isFollowing: profile.viewer?.following != null,
-          isBlocking: isBlocking(profile.viewer),
-          onAvatarTap: (profile.stories?.isNotEmpty ?? false)
-              ? () => _openStoriesViewer(profile)
-              : null,
-          onFollowersTap: () => context.router.push(
-            UserListRoute(did: widget.did, type: UserListType.followers),
-          ),
-          onFollowingTap: () => context.router.push(
-            UserListRoute(did: widget.did, type: UserListType.following),
-          ),
-          onEditTap: () {
-            context.router.push(EditProfileRoute(profile: profile)).then((
-              updated,
-            ) {
-              if (updated == true) {
-                notifier.refreshProfile();
+          context: ModerationContext.profileView,
+          child: ProfilePageTemplate(
+            displayName: profile.displayName ?? profile.handle,
+            handle: profile.handle,
+            postsCount: TextFormatter.formatCount(profile.postsCount),
+            followersCount: TextFormatter.formatCount(profile.followersCount),
+            followingCount: TextFormatter.formatCount(profile.followsCount),
+            avatarUrl: profile.avatar?.toString(),
+            avatarBuilder: (avatar) => ModeratedProfileAvatar(
+              labels: profile.labels ?? const [],
+              subjectDid: profile.did,
+              child: avatar,
+            ),
+            description: description.isNotEmpty ? description : null,
+            links: uniqueLinks.isNotEmpty ? uniqueLinks : null,
+            knownFollowers: profile.viewer?.knownFollowers,
+            onKnownFollowersTap: () => context.router.push(
+              UserListRoute(did: widget.did, type: UserListType.knownFollowers),
+            ),
+            hasStories: profile.stories?.isNotEmpty ?? false,
+            isCurrentUser: isCurrentUser,
+            isFollowing: profile.viewer?.following != null,
+            isBlocking: isBlocking(profile.viewer),
+            onAvatarTap: (profile.stories?.isNotEmpty ?? false)
+                ? () => _openStoriesViewer(profile)
+                : null,
+            onFollowersTap: () => context.router.push(
+              UserListRoute(did: widget.did, type: UserListType.followers),
+            ),
+            onFollowingTap: () => context.router.push(
+              UserListRoute(did: widget.did, type: UserListType.following),
+            ),
+            onEditTap: () {
+              context.router.push(EditProfileRoute(profile: profile)).then((
+                updated,
+              ) {
+                if (updated == true) {
+                  notifier.refreshProfile();
+                }
+              });
+            },
+            onFollowingChanged: (following) async {
+              try {
+                await notifier.setFollowing(following: following);
+              } catch (e) {
+                _logger.e('Error updating follow state', error: e);
               }
-            });
-          },
-          onFollowingChanged: (following) async {
-            try {
-              await notifier.setFollowing(following: following);
-            } catch (e) {
-              _logger.e('Error updating follow state', error: e);
-            }
-          },
-          onUnblockTap: () async {
-            try {
-              await notifier.toggleBlock();
-            } catch (e) {
-              _logger.e('Error unblocking profile', error: e);
-            }
-          },
-          onMentionTap: _handleUsernameTap,
-          onAddStoryTap: isCurrentUser ? () => _handleAddStory(context) : null,
-          appBarTitle: profile.handle,
-          leading: isCurrentUser && !context.router.canPop()
-              ? SizedBox(
-                  width: 40,
-                  height: 40,
-                  child: IconButton(
-                    padding: EdgeInsets.zero,
-                    constraints: const BoxConstraints(),
-                    splashColor: Colors.transparent,
-                    highlightColor: Colors.transparent,
-                    onPressed: CreateMediaActions.onRecord(
-                      context,
-                      storyMode: false,
+            },
+            onUnblockTap: () async {
+              try {
+                await notifier.toggleBlock();
+              } catch (e) {
+                _logger.e('Error unblocking profile', error: e);
+              }
+            },
+            onMentionTap: _handleUsernameTap,
+            onAddStoryTap: isCurrentUser
+                ? () => _handleAddStory(context)
+                : null,
+            appBarTitle: profile.handle,
+            leading: isCurrentUser && !context.router.canPop()
+                ? SizedBox(
+                    width: 40,
+                    height: 40,
+                    child: IconButton(
+                      padding: EdgeInsets.zero,
+                      constraints: const BoxConstraints(),
+                      splashColor: Colors.transparent,
+                      highlightColor: Colors.transparent,
+                      onPressed: CreateMediaActions.onRecord(
+                        context,
+                        storyMode: false,
+                      ),
+                      icon: AppIcons.addPostFilled(size: 28),
                     ),
-                    icon: AppIcons.addPostFilled(size: 28),
-                  ),
+                  )
+                : null,
+            appBarActions: [
+              if (isCurrentUser)
+                IconButton(
+                  padding: EdgeInsets.zero,
+                  constraints: const BoxConstraints(),
+                  splashColor: Colors.transparent,
+                  highlightColor: Colors.transparent,
+                  onPressed: () => context.router.push(const SettingsRoute()),
+                  icon: AppIcons.gear(color: colorScheme.onSurface, size: 28),
                 )
-              : null,
-          appBarActions: [
-            if (isCurrentUser)
-              IconButton(
-                padding: EdgeInsets.zero,
-                constraints: const BoxConstraints(),
-                splashColor: Colors.transparent,
-                highlightColor: Colors.transparent,
-                onPressed: () => context.router.push(const SettingsRoute()),
-                icon: AppIcons.gear(color: colorScheme.onSurface, size: 28),
-              )
-            else
-              IconButton(
-                onPressed: () => OptionsPanel.show(
-                  context: context,
-                  onReport: () => showDialog<void>(
+              else
+                IconButton(
+                  onPressed: () => OptionsPanel.show(
                     context: context,
-                    useRootNavigator: false,
-                    builder: (dContext) => ReportDialog(
-                      postUri:
-                          'at://${profile.did}/app.bsky.actor.profile/self',
-                      postCid: profile.did,
-                      onSubmit: (subject, reasonType, reason) async {
-                        try {
+                    onReport: () => showDialog<void>(
+                      context: context,
+                      useRootNavigator: false,
+                      builder: (dContext) => ReportDialog(
+                        subject: UModerationCreateReportSubject.repoRef(
+                          data: RepoRef(did: profile.did),
+                        ),
+                        fallbackServiceDid: widget.bsky
+                            ? _sprkRepository.bskyModDid
+                            : _sprkRepository.modDid,
+                        onSubmit: (input, serviceDid) async {
                           await notifier.createReport(
                             did: profile.did,
-                            reasonType: reasonType,
-                            reason: reason,
+                            reasonType: input.reasonType,
+                            reason: input.reason,
+                            serviceDid: serviceDid,
                           );
-                        } catch (e) {
-                          _logger.e('Error creating report', error: e);
-                        }
-                      },
+                        },
+                      ),
                     ),
-                  ),
-                  onBlock: () async {
-                    final wasBlocked = isBlocking(profile.viewer);
-
-                    // Show confirmation dialog
-                    final confirmed = await showDialog<bool>(
-                      context: context,
-                      builder: (context) {
-                        final dialogL10n = AppLocalizations.of(context);
-                        return AlertDialog(
-                          title: Text(
-                            wasBlocked
-                                ? dialogL10n.dialogUnblockUser
-                                : dialogL10n.dialogBlockUser,
-                          ),
-                          content: Text(
-                            wasBlocked
-                                ? dialogL10n.dialogUnblockUserConfirm
-                                : dialogL10n.dialogBlockUserConfirm,
-                          ),
-                          actions: [
-                            TextButton(
-                              onPressed: () => Navigator.of(context).pop(false),
-                              child: Text(dialogL10n.buttonCancel),
+                    onBlock: () async {
+                      final wasBlocked = isBlocking(profile.viewer);
+
+                      // Show confirmation dialog
+                      final confirmed = await showDialog<bool>(
+                        context: context,
+                        builder: (context) {
+                          final dialogL10n = AppLocalizations.of(context);
+                          return AlertDialog(
+                            title: Text(
+                              wasBlocked
+                                  ? dialogL10n.dialogUnblockUser
+                                  : dialogL10n.dialogBlockUser,
                             ),
-                            TextButton(
-                              onPressed: () => Navigator.of(context).pop(true),
-                              style: TextButton.styleFrom(
-                                foregroundColor: wasBlocked ? null : Colors.red,
+                            content: Text(
+                              wasBlocked
+                                  ? dialogL10n.dialogUnblockUserConfirm
+                                  : dialogL10n.dialogBlockUserConfirm,
+                            ),
+                            actions: [
+                              TextButton(
+                                onPressed: () =>
+                                    Navigator.of(context).pop(false),
+                                child: Text(dialogL10n.buttonCancel),
                               ),
-                              child: Text(
-                                wasBlocked
-                                    ? dialogL10n.buttonUnblock
-                                    : dialogL10n.buttonBlock,
+                              TextButton(
+                                onPressed: () =>
+                                    Navigator.of(context).pop(true),
+                                style: TextButton.styleFrom(
+                                  foregroundColor: wasBlocked
+                                      ? null
+                                      : Colors.red,
+                                ),
+                                child: Text(
+                                  wasBlocked
+                                      ? dialogL10n.buttonUnblock
+                                      : dialogL10n.buttonBlock,
+                                ),
                               ),
-                            ),
-                          ],
+                            ],
+                          );
+                        },
+                      );
+
+                      if (confirmed != true) return;
+
+                      try {
+                        await notifier.toggleBlock();
+                      } catch (e) {
+                        _logger.e(
+                          'Error blocking/unblocking profile',
+                          error: e,
                         );
-                      },
-                    );
-
-                    if (confirmed != true) return;
-
-                    try {
-                      await notifier.toggleBlock();
-                    } catch (e) {
-                      _logger.e('Error blocking/unblocking profile', error: e);
-                    }
-                  },
-                  isBlocked: isBlocking(profile.viewer),
-                  isProfile: true,
-                ),
-                padding: EdgeInsets.zero,
-                constraints: const BoxConstraints(),
-                splashColor: Colors.transparent,
-                highlightColor: Colors.transparent,
-                icon: AppIcons.moreHoriz(
-                  color: colorScheme.onSurface,
-                  size: 28,
+                      }
+                    },
+                    isBlocked: isBlocking(profile.viewer),
+                    isProfile: true,
+                  ),
+                  padding: EdgeInsets.zero,
+                  constraints: const BoxConstraints(),
+                  splashColor: Colors.transparent,
+                  highlightColor: Colors.transparent,
+                  icon: AppIcons.moreHoriz(
+                    color: colorScheme.onSurface,
+                    size: 28,
+                  ),
                 ),
+            ],
+            tabsWidget: ProfileTabBar(
+              selectedIndex: _activeTabIndex,
+              tabs: _buildTabItems(
+                context,
+                _activeTabIndex,
+                isCurrentUser: isCurrentUser,
               ),
-          ],
-          tabsWidget: ProfileTabBar(
-            selectedIndex: _activeTabIndex,
-            tabs: _buildTabItems(
-              context,
-              _activeTabIndex,
-              isCurrentUser: isCurrentUser,
             ),
+            onTabChanged: (index) {
+              setState(() {
+                _activeTabIndex = index;
+              });
+            },
+            contentWidget:
+                const SizedBox.shrink(), // Not used when contentSlivers provided
+            contentSlivers: contentSlivers,
+            scrollController: _scrollController,
+            onRefresh: () async {
+              await notifier.refreshProfile();
+              ref.invalidate(profileFeedProvider);
+            },
           ),
-          onTabChanged: (index) {
-            setState(() {
-              _activeTabIndex = index;
-            });
-          },
-          contentWidget:
-              const SizedBox.shrink(), // Not used when contentSlivers provided
-          contentSlivers: contentSlivers,
-          scrollController: _scrollController,
-          onRefresh: () async {
-            await notifier.refreshProfile();
-            ref.invalidate(profileFeedProvider);
-          },
         );
       },
       loading: () {
@@ -448,11 +474,18 @@ class _ProfilePageState extends ConsumerState<ProfilePage> {
         final isCurrentUserLoading =
             currentUserDid != null && currentUserDid == widget.did;
 
-        return ProfilePageTemplate(
+        final page = ProfilePageTemplate(
           isLoading: true,
           displayName: initial?.displayName ?? initial?.handle ?? 'Loading...',
           handle: initial?.handle ?? 'loading',
           avatarUrl: initial?.avatar?.toString(),
+          avatarBuilder: initial == null
+              ? null
+              : (avatar) => ModeratedProfileAvatar(
+                  labels: initial.labels ?? const [],
+                  subjectDid: initial.did,
+                  child: avatar,
+                ),
           postsCount: '0',
           followersCount: '0',
           followingCount: '0',
@@ -482,6 +515,16 @@ class _ProfilePageState extends ConsumerState<ProfilePage> {
               contentSlivers, // Tabs load even while profile is loading
           scrollController: _scrollController,
         );
+
+        if (initial == null) return page;
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: initial.labels ?? const [],
+            subjectDid: initial.did,
+          ),
+          context: ModerationContext.profileView,
+          child: page,
+        );
       },
       error: (error, stackTrace) {
         // Check if this is the current user's profile to show settings button
@@ -603,6 +646,7 @@ class _ProfilePageState extends ConsumerState<ProfilePage> {
         displayName: profile.displayName,
         avatar: profile.avatar,
         viewer: profile.viewer,
+        labels: profile.labels,
       );
 
       if (mounted) {
diff --git a/lib/src/features/profile/ui/widgets/blocks_list_view.dart b/lib/src/features/profile/ui/widgets/blocks_list_view.dart
index 8d571f41..b29f3491 100644
--- a/lib/src/features/profile/ui/widgets/blocks_list_view.dart
+++ b/lib/src/features/profile/ui/widgets/blocks_list_view.dart
@@ -3,6 +3,8 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/profile_card.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/profile/providers/blocks_provider.dart';
@@ -41,26 +43,41 @@ class BlocksListView extends ConsumerWidget {
           );
         }
         final user = users[index];
-        return Padding(
-          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-          child: ProfileCard(
-            imageUrl: user.avatar?.toString() ?? '',
-            userName: user.displayName ?? user.handle,
-            userHandle: '@${user.handle}',
-            description: user.description,
-            isFollowing: false,
-            isBlocking: true,
-            onUnblock: () {
-              ref.read(blocksProvider(did: did).notifier).unblockUser(user.did);
-            },
-            onTap: () => context.router.push(
-              ProfileRoute(
-                did: user.did,
-                initialProfile: ProfileViewBasic(
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: user.labels ?? const [],
+            subjectDid: user.did,
+          ),
+          context: ModerationContext.profileList,
+          child: Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+            child: ProfileCard(
+              imageUrl: user.avatar?.toString() ?? '',
+              avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                labels: user.labels ?? const [],
+                subjectDid: user.did,
+                child: avatar,
+              ),
+              userName: user.displayName ?? user.handle,
+              userHandle: '@${user.handle}',
+              description: user.description,
+              isFollowing: false,
+              isBlocking: true,
+              onUnblock: () {
+                ref
+                    .read(blocksProvider(did: did).notifier)
+                    .unblockUser(user.did);
+              },
+              onTap: () => context.router.push(
+                ProfileRoute(
                   did: user.did,
-                  handle: user.handle,
-                  displayName: user.displayName,
-                  avatar: user.avatar,
+                  initialProfile: ProfileViewBasic(
+                    did: user.did,
+                    handle: user.handle,
+                    displayName: user.displayName,
+                    avatar: user.avatar,
+                    labels: user.labels,
+                  ),
                 ),
               ),
             ),
diff --git a/lib/src/features/profile/ui/widgets/profile_feed_post_widget.dart b/lib/src/features/profile/ui/widgets/profile_feed_post_widget.dart
index 43df5029..a8dfdf11 100644
--- a/lib/src/features/profile/ui/widgets/profile_feed_post_widget.dart
+++ b/lib/src/features/profile/ui/widgets/profile_feed_post_widget.dart
@@ -5,16 +5,15 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:get_it/get_it.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/design_system/tokens/colors.dart';
-import 'package:spark/src/core/ui/widgets/content_warning_overlay.dart';
 import 'package:spark/src/core/ui/widgets/heart_animation.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
 import 'package:spark/src/features/feed/providers/like_post.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/post_media_viewer.dart';
 import 'package:spark/src/features/feed/ui/widgets/post/post_overlay.dart';
 import 'package:spark/src/features/home/providers/feed_settings_visibility_provider.dart';
 import 'package:spark/src/features/profile/providers/profile_feed_index_provider.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
 
 class ProfileFeedPostWidget extends ConsumerStatefulWidget {
   const ProfileFeedPostWidget({
@@ -48,9 +47,7 @@ class _ProfileFeedPostWidgetState extends ConsumerState<ProfileFeedPostWidget> {
   final GlobalKey<PostMediaViewerState> _mediaViewerKey =
       GlobalKey<PostMediaViewerState>();
   bool _isAnimatingHeart = false;
-  bool _showWarningOverlay = false;
-  bool _shouldBlurContent = false;
-  List<String> _warningLabels = [];
+  bool _moderationConcealed = false;
   bool? _overrideIsLiked;
   PostView? _currentPost;
   Future<PostView?>? _postFuture;
@@ -59,11 +56,6 @@ class _ProfileFeedPostWidgetState extends ConsumerState<ProfileFeedPostWidget> {
   void initState() {
     super.initState();
     _postFuture = _loadPostWithFallback();
-    _postFuture!.then((post) {
-      if (post != null && mounted) {
-        _checkContentWarning(post);
-      }
-    });
   }
 
   Future<PostView?> _loadPostWithFallback() async {
@@ -127,48 +119,6 @@ class _ProfileFeedPostWidgetState extends ConsumerState<ProfileFeedPostWidget> {
     }
   }
 
-  void _checkContentWarning(PostView postData) {
-    final labels = postData.labels ?? [];
-    final preferences = ref.read(userPreferencesProvider).asData?.value;
-
-    if (labels.isNotEmpty && preferences != null) {
-      final shouldShowWarning = LabelUtils.shouldShowWarning(
-        preferences,
-        labels,
-      );
-
-      final shouldBlurContent = LabelUtils.shouldBlurContent(
-        preferences,
-        labels,
-      );
-
-      if (shouldShowWarning) {
-        final warningLabels = LabelUtils.getWarningLabels(preferences, labels);
-        if (mounted) {
-          setState(() {
-            _showWarningOverlay = true;
-            _warningLabels = warningLabels;
-            _shouldBlurContent = shouldBlurContent;
-          });
-        }
-      } else {
-        if (mounted) {
-          setState(() {
-            _showWarningOverlay = false;
-            _warningLabels = [];
-          });
-        }
-      }
-    } else {
-      if (mounted) {
-        setState(() {
-          _showWarningOverlay = false;
-          _warningLabels = [];
-        });
-      }
-    }
-  }
-
   @override
   Widget build(BuildContext context) {
     return FutureBuilder<PostView?>(
@@ -202,7 +152,7 @@ class _ProfileFeedPostWidgetState extends ConsumerState<ProfileFeedPostWidget> {
         final feedSettingsVisible = ref.watch(feedSettingsVisibilityProvider);
         final isMediaActive =
             !feedSettingsVisible &&
-            !_showWarningOverlay &&
+            !_moderationConcealed &&
             (widget.index == null ||
                 profileFeedIndex == widget.index ||
                 (profileFeedIndex == -1 && widget.isInitialPost));
@@ -251,20 +201,21 @@ class _ProfileFeedPostWidgetState extends ConsumerState<ProfileFeedPostWidget> {
           ),
         );
 
-        if (_showWarningOverlay) {
-          return ContentWarningOverlay(
-            onViewContent: () {
-              setState(() {
-                _showWarningOverlay = false;
-              });
-            },
-            warningLabels: _warningLabels,
-            shouldBlur: _shouldBlurContent,
-            child: mainContent,
-          );
-        }
-
-        return mainContent;
+        return ModeratedContent(
+          key: ValueKey(post.uri.toString()),
+          subject: ModerationSubject.content(
+            labels: post.labels ?? const [],
+            authorLabels: post.author.labels ?? const [],
+            subjectDid: post.author.did,
+          ),
+          context: ModerationContext.contentList,
+          onConcealChanged: (concealed) {
+            if (mounted && _moderationConcealed != concealed) {
+              setState(() => _moderationConcealed = concealed);
+            }
+          },
+          child: mainContent,
+        );
       },
     );
   }
diff --git a/lib/src/features/profile/ui/widgets/profile_grid_widget.dart b/lib/src/features/profile/ui/widgets/profile_grid_widget.dart
index fe082eda..cae1b921 100644
--- a/lib/src/features/profile/ui/widgets/profile_grid_widget.dart
+++ b/lib/src/features/profile/ui/widgets/profile_grid_widget.dart
@@ -5,6 +5,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:skeletonizer/skeletonizer.dart';
 import 'package:spark/src/core/design_system/components/molecules/post_tile.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/features/profile/providers/profile_feed_provider.dart';
 
@@ -148,7 +150,7 @@ List<Widget> buildProfileGridSlivers({
   );
 }
 
-class ProfileGridTile extends StatelessWidget {
+class ProfileGridTile extends ConsumerWidget {
   const ProfileGridTile({
     required this.postView,
     required this.onTap,
@@ -157,42 +159,58 @@ class ProfileGridTile extends StatelessWidget {
   final PostView postView;
   final VoidCallback onTap;
 
-  /// Check for adult content labels synchronously without network calls
-  bool _hasAdultLabel() {
-    final labels = postView.labels;
-    if (labels == null || labels.isEmpty) return false;
-
-    // Check for common adult content labels synchronously
-    const adultLabels = {'porn', 'sexual', 'nudity', 'nsfw', 'adult'};
-    return labels.any((label) => adultLabels.contains(label.val.toLowerCase()));
-  }
-
   @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context, WidgetRef ref) {
     final thumbnailUrl = postView.thumbnailUrl;
-    final shouldBlur = _hasAdultLabel();
 
     // Use like count as a proxy for views, or 0 if not available
     final likeCount = postView.likeCount ?? 0;
 
     if (thumbnailUrl.isEmpty) {
-      return GestureDetector(
-        onTap: onTap,
-        child: ColoredBox(
-          color: Theme.of(context).colorScheme.surfaceContainerHighest,
-          child: const Center(
-            child: Icon(FluentIcons.image_off_24_regular, size: 20),
+      return ModeratedContent(
+        subject: ModerationSubject.content(
+          labels: postView.labels ?? const [],
+          authorLabels: postView.author.labels ?? const [],
+          subjectDid: postView.author.did,
+        ),
+        context: ModerationContext.contentList,
+        presentation: const ModerationPresentation.compact(),
+        child: GestureDetector(
+          onTap: onTap,
+          child: ColoredBox(
+            color: Theme.of(context).colorScheme.surfaceContainerHighest,
+            child: const Center(
+              child: Icon(FluentIcons.image_off_24_regular, size: 20),
+            ),
           ),
         ),
       );
     }
 
-    return PostTile(
-      thumbnailUrl: thumbnailUrl,
-      likes: likeCount,
-      seen: false,
-      nsfwBlur: shouldBlur,
-      onTap: onTap,
+    return ModeratedContent(
+      subject: ModerationSubject.content(
+        labels: postView.labels ?? const [],
+        authorLabels: postView.author.labels ?? const [],
+        subjectDid: postView.author.did,
+      ),
+      context: ModerationContext.contentList,
+      presentation: ModerationPresentation.compact(
+        onConcealedTap: onTap,
+        blurredChild: PostTile(
+          thumbnailUrl: thumbnailUrl,
+          likes: likeCount,
+          seen: false,
+          nsfwBlur: true,
+          onTap: onTap,
+        ),
+      ),
+      child: PostTile(
+        thumbnailUrl: thumbnailUrl,
+        likes: likeCount,
+        seen: false,
+        nsfwBlur: false,
+        onTap: onTap,
+      ),
     );
   }
 }
diff --git a/lib/src/features/profile/ui/widgets/user_list_view.dart b/lib/src/features/profile/ui/widgets/user_list_view.dart
index 1f0d182d..41ed5c5f 100644
--- a/lib/src/features/profile/ui/widgets/user_list_view.dart
+++ b/lib/src/features/profile/ui/widgets/user_list_view.dart
@@ -3,6 +3,8 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/profile_card.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/profile/providers/user_list_provider.dart';
@@ -58,40 +60,56 @@ class UserListView extends ConsumerWidget {
         }
         final user = users[index];
         final hasStories = user.stories?.isNotEmpty ?? false;
-        return Padding(
-          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-          child: ProfileCard(
-            imageUrl: user.avatar?.toString() ?? '',
-            userName: user.displayName ?? user.handle,
-            userHandle: '@${user.handle}',
-            description: user.description,
-            isFollowing: user.viewer?.following != null,
-            onFollowingChanged: (shouldFollow) {
-              final notifier = ref.read(
-                userListProvider(did: did, type: type).notifier,
-              );
-              if (shouldFollow) {
-                notifier.followUser(user.did);
-              } else {
-                notifier.unfollowUser(user.did);
-              }
-            },
-            showFollowButton: !ref
-                .read(userListProvider(did: did, type: type).notifier)
-                .isCurrentUser(user.did),
-            hasStories: hasStories,
-            onAvatarTap: hasStories
-                ? () =>
-                      openStoriesForProfile(context, user, source: 'user list')
-                : null,
-            onTap: () => context.router.push(
-              ProfileRoute(
-                did: user.did,
-                initialProfile: ProfileViewBasic(
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: user.labels ?? const [],
+            subjectDid: user.did,
+          ),
+          context: ModerationContext.profileList,
+          child: Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+            child: ProfileCard(
+              imageUrl: user.avatar?.toString() ?? '',
+              avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                labels: user.labels ?? const [],
+                subjectDid: user.did,
+                child: avatar,
+              ),
+              userName: user.displayName ?? user.handle,
+              userHandle: '@${user.handle}',
+              description: user.description,
+              isFollowing: user.viewer?.following != null,
+              onFollowingChanged: (shouldFollow) {
+                final notifier = ref.read(
+                  userListProvider(did: did, type: type).notifier,
+                );
+                if (shouldFollow) {
+                  notifier.followUser(user.did);
+                } else {
+                  notifier.unfollowUser(user.did);
+                }
+              },
+              showFollowButton: !ref
+                  .read(userListProvider(did: did, type: type).notifier)
+                  .isCurrentUser(user.did),
+              hasStories: hasStories,
+              onAvatarTap: hasStories
+                  ? () => openStoriesForProfile(
+                      context,
+                      user,
+                      source: 'user list',
+                    )
+                  : null,
+              onTap: () => context.router.push(
+                ProfileRoute(
                   did: user.did,
-                  handle: user.handle,
-                  displayName: user.displayName,
-                  avatar: user.avatar,
+                  initialProfile: ProfileViewBasic(
+                    did: user.did,
+                    handle: user.handle,
+                    displayName: user.displayName,
+                    avatar: user.avatar,
+                    labels: user.labels,
+                  ),
                 ),
               ),
             ),
diff --git a/lib/src/features/search/data/repositories/post_search_repository.dart b/lib/src/features/search/data/repositories/post_search_repository.dart
index 3465c6f3..e74d547b 100644
--- a/lib/src/features/search/data/repositories/post_search_repository.dart
+++ b/lib/src/features/search/data/repositories/post_search_repository.dart
@@ -1,8 +1,6 @@
 import 'package:bluesky_poptart/app/bsky/feed/defs.dart' as bsky_feed_defs;
 import 'package:bluesky_poptart/app/bsky/feed/search_posts.dart'
     as bsky_feed_search_posts;
-import 'package:poptart/poptart.dart';
-import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
 import 'package:spark/src/core/network/atproto/atproto.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
@@ -21,12 +19,12 @@ abstract interface class PostSearchRepository {
 class PostSearchRepositoryImpl implements PostSearchRepository {
   PostSearchRepositoryImpl(
     this._feedRepository,
-    this._authRepository,
+    this._sprkRepository,
     this._logger,
   );
 
   final FeedRepository _feedRepository;
-  final AuthRepository _authRepository;
+  final SprkRepository _sprkRepository;
   final SparkLogger _logger;
 
   @override
@@ -52,23 +50,27 @@ class PostSearchRepositoryImpl implements PostSearchRepository {
     String? cursor,
     required String sort,
   }) async {
-    final atproto = _authRepository.atproto;
-    if (atproto?.oAuthSession == null) {
-      throw StateError('Post search requires an authenticated session');
-    }
-    final api = PoptartClient.fromOAuthSession(atproto!.oAuthSession!);
-    final response = await api.call(
-      bsky_feed_search_posts.appBskyFeedSearchPosts,
-      parameters: bsky_feed_search_posts.FeedSearchPostsInput(
-        q: query,
-        sort: bsky_feed_search_posts.FeedSearchPostsSort.unknown(data: sort),
-        cursor: cursor,
-      ),
-    );
-    return (
-      posts: _convertBskyPosts(response.data.posts),
-      cursor: response.data.cursor,
-    );
+    return _sprkRepository.executeWithRetry(() async {
+      final atproto = _sprkRepository.authRepository.atproto;
+      if (!_sprkRepository.authRepository.isAuthenticated || atproto == null) {
+        throw StateError('Post search requires an authenticated session');
+      }
+      final response = await atproto.call(
+        bsky_feed_search_posts.appBskyFeedSearchPosts,
+        parameters: bsky_feed_search_posts.FeedSearchPostsInput(
+          q: query,
+          sort: bsky_feed_search_posts.FeedSearchPostsParametersSort.unknown(
+            data: sort,
+          ),
+          cursor: cursor,
+        ),
+        headers: _sprkRepository.appViewHeaders(_sprkRepository.bskyDid),
+      );
+      return (
+        posts: _convertBskyPosts(response.data.posts),
+        cursor: response.data.cursor,
+      );
+    });
   }
 
   List<PostView> _convertBskyPosts(List<bsky_feed_defs.PostView> posts) {
diff --git a/lib/src/features/search/providers/post_search_provider.dart b/lib/src/features/search/providers/post_search_provider.dart
index 651c2baf..11aedc6f 100644
--- a/lib/src/features/search/providers/post_search_provider.dart
+++ b/lib/src/features/search/providers/post_search_provider.dart
@@ -1,32 +1,26 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart' show Provider;
 import 'package:get_it/get_it.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
-import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/providers/debounce_scheduler.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 import 'package:spark/src/features/search/data/repositories/post_search_repository.dart';
 import 'package:spark/src/features/search/providers/post_search_state.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
 
 part 'post_search_provider.g.dart';
 
 final postSearchRepositoryProvider = Provider<PostSearchRepository>((ref) {
   return PostSearchRepositoryImpl(
     GetIt.instance<SprkRepository>().feed,
-    GetIt.instance<AuthRepository>(),
+    GetIt.instance<SprkRepository>(),
     GetIt.instance<LogService>().getLogger('PostSearchRepository'),
   );
 });
 
-final postSearchPreferencesProvider = Provider<Preferences?>((ref) {
-  return ref.watch(userPreferencesProvider).asData?.value;
-});
-
 /// Search provider for post search functionality
 @riverpod
 class PostSearch extends _$PostSearch {
@@ -107,23 +101,20 @@ class PostSearch extends _$PostSearch {
   /// Search for posts with the given query
   Future<void> _searchPosts(String query, {required int requestToken}) async {
     if (query.isEmpty) return;
-    if (requestToken != _activeSearchToken || state.query != query) {
-      return;
-    }
+    if (!_isCurrentRequest(query, requestToken)) return;
 
     state = state.copyWith(isLoading: true, error: null);
 
     try {
       final response = await _repository.search(query);
 
-      if (!ref.mounted ||
-          requestToken != _activeSearchToken ||
-          state.query != query) {
-        return;
-      }
+      if (!_isCurrentRequest(query, requestToken)) return;
 
-      final filteredSprkPosts = _filterHiddenPosts(response.sprk.posts);
-      final filteredBskyPosts = _filterHiddenPosts(response.bsky.posts);
+      final filteredSprkPosts = await _filterHiddenPosts(response.sprk.posts);
+      if (!_isCurrentRequest(query, requestToken)) return;
+
+      final filteredBskyPosts = await _filterHiddenPosts(response.bsky.posts);
+      if (!_isCurrentRequest(query, requestToken)) return;
 
       final combinedPosts = [...filteredSprkPosts, ...filteredBskyPosts];
 
@@ -140,11 +131,7 @@ class PostSearch extends _$PostSearch {
         await _loadMorePostsForToken(requestToken);
       }
     } catch (e) {
-      if (!ref.mounted ||
-          requestToken != _activeSearchToken ||
-          state.query != query) {
-        return;
-      }
+      if (!_isCurrentRequest(query, requestToken)) return;
 
       _logger.e('Error searching posts: $e');
       state = state.copyWith(error: e.toString(), isLoading: false);
@@ -190,13 +177,11 @@ class PostSearch extends _$PostSearch {
     if (sprkCursor != null && sprkCursor.isNotEmpty) {
       final response = await _repository.searchSprk(query, cursor: sprkCursor);
 
-      if (!ref.mounted ||
-          requestToken != _activeSearchToken ||
-          state.query != query) {
-        return;
-      }
+      if (!_isCurrentRequest(query, requestToken)) return;
+
+      final filteredPosts = await _filterHiddenPosts(response.posts);
+      if (!_isCurrentRequest(query, requestToken)) return;
 
-      final filteredPosts = _filterHiddenPosts(response.posts);
       state = state.copyWith(
         searchResults: [...state.searchResults, ...filteredPosts],
         sprkNextCursor: response.cursor,
@@ -214,14 +199,12 @@ class PostSearch extends _$PostSearch {
     if (bskyCursor != null && bskyCursor.isNotEmpty) {
       final response = await _repository.searchBsky(query, cursor: bskyCursor);
 
-      if (!ref.mounted ||
-          requestToken != _activeSearchToken ||
-          state.query != query) {
-        return;
-      }
+      if (!_isCurrentRequest(query, requestToken)) return;
 
       final initialCount = state.searchResults.length;
-      final filteredBskyPosts = _filterHiddenPosts(response.posts);
+      final filteredBskyPosts = await _filterHiddenPosts(response.posts);
+      if (!_isCurrentRequest(query, requestToken)) return;
+
       state = state.copyWith(
         searchResults: [...state.searchResults, ...filteredBskyPosts],
         bskyNextCursor: response.cursor,
@@ -236,19 +219,30 @@ class PostSearch extends _$PostSearch {
     }
   }
 
-  List<PostView> _filterHiddenPosts(List<PostView> posts) {
-    final preferences = ref.read(postSearchPreferencesProvider);
-    if (preferences == null) {
-      return posts; // Can't filter without preferences
-    }
+  bool _isCurrentRequest(String query, int requestToken) {
+    return ref.mounted &&
+        requestToken == _activeSearchToken &&
+        state.query == query;
+  }
 
-    final filteredPosts = <PostView>[];
-    for (final post in posts) {
-      if (!LabelUtils.shouldHideContent(preferences, post.labels ?? [])) {
-        filteredPosts.add(post);
-      }
+  Future<List<PostView>> _filterHiddenPosts(List<PostView> posts) async {
+    try {
+      final engine = await ref.read(moderationEngineProvider.future);
+      return posts.where((post) {
+        final decision = ModerationSubject.content(
+          labels: post.labels ?? const [],
+          authorLabels: post.author.labels ?? const [],
+          subjectDid: post.author.did,
+        ).evaluate(engine);
+        return !decision.forContext(ModerationContext.contentList).filter;
+      }).toList();
+    } catch (error, stackTrace) {
+      _logger.w(
+        'Could not moderate search results',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      return posts;
     }
-
-    return filteredPosts;
   }
 }
diff --git a/lib/src/features/search/providers/suggested_feeds_provider.dart b/lib/src/features/search/providers/suggested_feeds_provider.dart
index 63a6c02e..dc942c29 100644
--- a/lib/src/features/search/providers/suggested_feeds_provider.dart
+++ b/lib/src/features/search/providers/suggested_feeds_provider.dart
@@ -1,5 +1,8 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:get_it/get_it.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
@@ -8,6 +11,34 @@ import 'package:spark/src/core/utils/logging/logger.dart';
 
 part 'suggested_feeds_provider.g.dart';
 
+final promotableSuggestedFeedsProvider =
+    Provider.autoDispose<AsyncValue<List<GeneratorView>>>((ref) {
+      final suggestedFeeds = ref.watch(suggestedFeedsProvider);
+      final feeds = suggestedFeeds.value;
+      if (feeds == null ||
+          !feeds.any(
+            (feed) => feedGeneratorModerationSubject(feed).hasLabels,
+          )) {
+        return suggestedFeeds;
+      }
+
+      return ref
+          .watch(moderationEngineProvider)
+          .when(
+            data: (engine) => suggestedFeeds.whenData(
+              (feeds) => feeds
+                  .where(
+                    (feed) => !feedGeneratorModerationSubject(
+                      feed,
+                    ).evaluate(engine).excludeFromPromotion,
+                  )
+                  .toList(growable: false),
+            ),
+            error: AsyncValue.error,
+            loading: AsyncValue.loading,
+          );
+    });
+
 /// Provider for fetching suggested Spark feeds
 @riverpod
 class SuggestedFeeds extends _$SuggestedFeeds {
diff --git a/lib/src/features/search/ui/pages/post_results.dart b/lib/src/features/search/ui/pages/post_results.dart
index 6146dca8..2e1bed4b 100644
--- a/lib/src/features/search/ui/pages/post_results.dart
+++ b/lib/src/features/search/ui/pages/post_results.dart
@@ -2,11 +2,11 @@ import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/post_tile.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/routing/app_router.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
 import 'package:spark/src/features/search/providers/post_search_provider.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
 
 class PostResults extends ConsumerStatefulWidget {
   const PostResults({super.key});
@@ -182,26 +182,25 @@ class _PostResultsState extends ConsumerState<PostResults>
               }
 
               final post = state.searchResults[index];
-              final preferences = ref
-                  .read(userPreferencesProvider)
-                  .asData
-                  ?.value;
-              final labels = post.labels ?? [];
-              final shouldBlur =
-                  preferences != null &&
-                  labels.isNotEmpty &&
-                  LabelUtils.shouldBlurContent(preferences, labels);
-
-              return PostTile(
-                thumbnailUrl: post.thumbnailUrl,
-                likes: post.likeCount ?? 0,
-                seen: false,
-                nsfwBlur: shouldBlur,
-                onTap: () {
-                  context.router.push(
-                    StandalonePostRoute(postUri: post.uri.toString()),
-                  );
-                },
+              return ModeratedContent(
+                subject: ModerationSubject.content(
+                  labels: post.labels ?? const [],
+                  authorLabels: post.author.labels ?? const [],
+                  subjectDid: post.author.did,
+                ),
+                context: ModerationContext.contentList,
+                presentation: const ModerationPresentation.compact(),
+                child: PostTile(
+                  thumbnailUrl: post.thumbnailUrl,
+                  likes: post.likeCount ?? 0,
+                  seen: false,
+                  nsfwBlur: false,
+                  onTap: () {
+                    context.router.push(
+                      StandalonePostRoute(postUri: post.uri.toString()),
+                    );
+                  },
+                ),
               );
             }, childCount: state.searchResults.length),
           ),
diff --git a/lib/src/features/search/ui/pages/search_page.dart b/lib/src/features/search/ui/pages/search_page.dart
index 9729bfcf..092e61ed 100644
--- a/lib/src/features/search/ui/pages/search_page.dart
+++ b/lib/src/features/search/ui/pages/search_page.dart
@@ -6,6 +6,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/atoms/user_avatar.dart';
 import 'package:spark/src/core/design_system/templates/explore_page_template.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/search/providers/actor_typeahead_provider.dart';
 import 'package:spark/src/features/search/providers/actor_typeahead_state.dart';
@@ -154,7 +156,7 @@ class _SearchPageState extends ConsumerState<SearchPage> {
   }
 }
 
-class _ActorTypeaheadSuggestions extends StatelessWidget {
+class _ActorTypeaheadSuggestions extends ConsumerWidget {
   const _ActorTypeaheadSuggestions({
     required this.state,
     required this.onSuggestionSelected,
@@ -164,7 +166,7 @@ class _ActorTypeaheadSuggestions extends StatelessWidget {
   final ValueChanged<ProfileViewBasic> onSuggestionSelected;
 
   @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context, WidgetRef ref) {
     final theme = Theme.of(context);
 
     if (state.isLoading && state.results.isEmpty) {
@@ -212,15 +214,26 @@ class _ActorTypeaheadSuggestions extends StatelessWidget {
       itemBuilder: (context, index) {
         final actor = state.results[index];
 
-        return ListTile(
-          onTap: () => onSuggestionSelected(actor),
-          contentPadding: const EdgeInsets.symmetric(vertical: 4),
-          leading: UserAvatar(
-            imageUrl: actor.avatar?.toString() ?? '',
-            size: 36,
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: actor.labels ?? const [],
+            subjectDid: actor.did,
+          ),
+          context: ModerationContext.profileList,
+          child: ListTile(
+            onTap: () => onSuggestionSelected(actor),
+            contentPadding: const EdgeInsets.symmetric(vertical: 4),
+            leading: ModeratedProfileAvatar(
+              labels: actor.labels ?? const [],
+              subjectDid: actor.did,
+              child: UserAvatar(
+                imageUrl: actor.avatar?.toString() ?? '',
+                size: 36,
+              ),
+            ),
+            title: Text(actor.displayName ?? actor.handle),
+            subtitle: Text('@${actor.handle}'),
           ),
-          title: Text(actor.displayName ?? actor.handle),
-          subtitle: Text('@${actor.handle}'),
         );
       },
     );
diff --git a/lib/src/features/search/ui/pages/user_results.dart b/lib/src/features/search/ui/pages/user_results.dart
index 20a0d0e3..cf41bb20 100644
--- a/lib/src/features/search/ui/pages/user_results.dart
+++ b/lib/src/features/search/ui/pages/user_results.dart
@@ -3,6 +3,8 @@ import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/profile_card.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/search/providers/search_provider.dart';
@@ -187,51 +189,64 @@ class _UserResultsState extends ConsumerState<UserResults>
         final isFollowing = actor.viewer?.following != null;
         final hasStories = actor.stories?.isNotEmpty ?? false;
 
-        return Padding(
-          padding: const EdgeInsets.only(bottom: 8),
-          child: ProfileCard(
-            imageUrl: actor.avatar?.toString() ?? '',
-            userName: actor.displayName ?? actor.handle,
-            userHandle: '@${actor.handle}',
-            description: actor.description ?? '',
-            isFollowing: isFollowing,
-            onFollowingChanged: (shouldFollow) {
-              final notifier = ref.read(searchProvider.notifier);
-              if (shouldFollow) {
-                notifier.followUser(actor.did);
-              } else {
-                notifier.unfollowUser(
-                  actor.did,
-                  actor.viewer?.following ?? AtUri.parse(''),
-                );
-              }
-            },
-            showFollowButton: !ref
-                .read(searchProvider.notifier)
-                .isCurrentUser(actor.did),
-            hasStories: hasStories,
-            onAvatarTap: hasStories
-                ? () => openStoriesForProfile(
-                    context,
-                    actor,
-                    source: 'user search',
-                  )
-                : null,
-            onTap: () {
-              if (actor.did.isNotEmpty) {
-                context.router.push(
-                  ProfileRoute(
-                    did: actor.did,
-                    initialProfile: ProfileViewBasic(
+        return ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: actor.labels ?? const [],
+            subjectDid: actor.did,
+          ),
+          context: ModerationContext.profileList,
+          child: Padding(
+            padding: const EdgeInsets.only(bottom: 8),
+            child: ProfileCard(
+              imageUrl: actor.avatar?.toString() ?? '',
+              avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                labels: actor.labels ?? const [],
+                subjectDid: actor.did,
+                child: avatar,
+              ),
+              userName: actor.displayName ?? actor.handle,
+              userHandle: '@${actor.handle}',
+              description: actor.description ?? '',
+              isFollowing: isFollowing,
+              onFollowingChanged: (shouldFollow) {
+                final notifier = ref.read(searchProvider.notifier);
+                if (shouldFollow) {
+                  notifier.followUser(actor.did);
+                } else {
+                  notifier.unfollowUser(
+                    actor.did,
+                    actor.viewer?.following ?? AtUri.parse(''),
+                  );
+                }
+              },
+              showFollowButton: !ref
+                  .read(searchProvider.notifier)
+                  .isCurrentUser(actor.did),
+              hasStories: hasStories,
+              onAvatarTap: hasStories
+                  ? () => openStoriesForProfile(
+                      context,
+                      actor,
+                      source: 'user search',
+                    )
+                  : null,
+              onTap: () {
+                if (actor.did.isNotEmpty) {
+                  context.router.push(
+                    ProfileRoute(
                       did: actor.did,
-                      handle: actor.handle,
-                      displayName: actor.displayName,
-                      avatar: actor.avatar,
+                      initialProfile: ProfileViewBasic(
+                        did: actor.did,
+                        handle: actor.handle,
+                        displayName: actor.displayName,
+                        avatar: actor.avatar,
+                        labels: actor.labels,
+                      ),
                     ),
-                  ),
-                );
-              }
-            },
+                  );
+                }
+              },
+            ),
           ),
         );
       },
diff --git a/lib/src/features/search/ui/widgets/suggested_feeds_list.dart b/lib/src/features/search/ui/widgets/suggested_feeds_list.dart
index ac46bd70..a66f21f7 100644
--- a/lib/src/features/search/ui/widgets/suggested_feeds_list.dart
+++ b/lib/src/features/search/ui/widgets/suggested_feeds_list.dart
@@ -3,6 +3,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/feed_card.dart';
 import 'package:spark/src/core/design_system/templates/explore_loading_skeletons.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/features/search/providers/suggested_feeds_provider.dart';
 import 'package:spark/src/features/settings/providers/settings_provider.dart';
@@ -12,7 +14,7 @@ class SuggestedFeedsList extends ConsumerWidget {
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    final suggestedFeedsAsync = ref.watch(suggestedFeedsProvider);
+    final suggestedFeedsAsync = ref.watch(promotableSuggestedFeedsProvider);
     final settingsState = ref.watch(settingsProvider);
 
     return Column(
@@ -99,65 +101,71 @@ class SuggestedFeedsList extends ConsumerWidget {
                         view: generatorView,
                       );
 
-                return Padding(
-                  padding: const EdgeInsets.only(bottom: 12),
-                  child: FeedCard(
-                    feed: feed,
-                    isAdded: isAdded,
-                    onAdd: () async {
-                      await ref.read(settingsProvider.notifier).addFeed(feed);
-                    },
-                    onPin: () async {
-                      // Update the feed to be pinned
-                      final existingFeed = settingsState.feeds.firstWhere(
-                        (f) => f.config.value == savedFeed.value,
-                      );
-                      final updatedFeed = Feed(
-                        type: existingFeed.type,
-                        config: existingFeed.config.copyWith(pinned: true),
-                        view: existingFeed.view,
-                      );
-                      await ref
-                          .read(settingsProvider.notifier)
-                          .setActiveFeed(updatedFeed);
-                    },
-                    onUnpin: () async {
-                      // Remove entirely when unpinning from suggested feeds
-                      final existingFeed = settingsState.feeds.firstWhere(
-                        (f) => f.config.value == savedFeed.value,
-                      );
-                      // Find another feed to set as active if was active feed
-                      if (settingsState.activeFeed.config.id ==
-                          existingFeed.config.id) {
-                        final otherFeed = settingsState.feeds.firstWhere(
-                          (f) => f.config.id != existingFeed.config.id,
-                          orElse: () => Feed(
-                            type: 'timeline',
-                            config: makeSavedFeed(
+                return ModeratedContent(
+                  subject: feedGeneratorModerationSubject(generatorView),
+                  context: ModerationContext.contentList,
+                  child: Padding(
+                    padding: const EdgeInsets.only(bottom: 12),
+                    child: FeedCard(
+                      feed: feed,
+                      isAdded: isAdded,
+                      onAdd: () async {
+                        await ref.read(settingsProvider.notifier).addFeed(feed);
+                      },
+                      onPin: () async {
+                        // Update the feed to be pinned
+                        final existingFeed = settingsState.feeds.firstWhere(
+                          (f) => f.config.value == savedFeed.value,
+                        );
+                        final updatedFeed = Feed(
+                          type: existingFeed.type,
+                          config: existingFeed.config.copyWith(pinned: true),
+                          view: existingFeed.view,
+                        );
+                        await ref
+                            .read(settingsProvider.notifier)
+                            .setActiveFeed(updatedFeed);
+                      },
+                      onUnpin: () async {
+                        // Remove entirely when unpinning from suggested feeds
+                        final existingFeed = settingsState.feeds.firstWhere(
+                          (f) => f.config.value == savedFeed.value,
+                        );
+                        // Find another feed to set as active if was active feed
+                        if (settingsState.activeFeed.config.id ==
+                            existingFeed.config.id) {
+                          final otherFeed = settingsState.feeds.firstWhere(
+                            (f) => f.config.id != existingFeed.config.id,
+                            orElse: () => Feed(
                               type: 'timeline',
-                              value: 'following',
-                              pinned: true,
+                              config: makeSavedFeed(
+                                type: 'timeline',
+                                value: 'following',
+                                pinned: true,
+                              ),
                             ),
-                          ),
-                        );
+                          );
+                          await ref
+                              .read(settingsProvider.notifier)
+                              .setActiveFeed(otherFeed);
+                        }
+                        // Remove the feed entirely
                         await ref
                             .read(settingsProvider.notifier)
-                            .setActiveFeed(otherFeed);
-                      }
-                      // Remove the feed entirely
-                      await ref
-                          .read(settingsProvider.notifier)
-                          .removeFeed(existingFeed);
-                    },
-                    onTap: () async {
-                      // Add feed if not already added, then set as active
-                      if (!isAdded) {
-                        await ref.read(settingsProvider.notifier).addFeed(feed);
-                      }
-                      await ref
-                          .read(settingsProvider.notifier)
-                          .setActiveFeed(feed);
-                    },
+                            .removeFeed(existingFeed);
+                      },
+                      onTap: () async {
+                        // Add feed if not already added, then set as active
+                        if (!isAdded) {
+                          await ref
+                              .read(settingsProvider.notifier)
+                              .addFeed(feed);
+                        }
+                        await ref
+                            .read(settingsProvider.notifier)
+                            .setActiveFeed(feed);
+                      },
+                    ),
                   ),
                 );
               },
diff --git a/lib/src/features/settings/providers/labeler_policy_preferences.dart b/lib/src/features/settings/providers/labeler_policy_preferences.dart
new file mode 100644
index 00000000..6a72deaa
--- /dev/null
+++ b/lib/src/features/settings/providers/labeler_policy_preferences.dart
@@ -0,0 +1,22 @@
+import 'package:spark/src/core/moderation/moderation.dart';
+
+final class LabelerPreferenceSnapshot {
+  const LabelerPreferenceSnapshot({
+    required this.settings,
+    required this.definitions,
+  });
+
+  final Map<String, ModerationSetting> settings;
+  final Map<String, ModerationLabelDefinition> definitions;
+}
+
+ModerationSetting moderationSettingFromPolicy({
+  required ModerationSetting? savedSetting,
+  required ModerationSetting? globalSetting,
+  required ModerationLabelDefinition? definition,
+}) {
+  return globalSetting ??
+      savedSetting ??
+      definition?.defaultSetting ??
+      ModerationSetting.warn;
+}
diff --git a/lib/src/features/settings/providers/labeler_settings_controller.dart b/lib/src/features/settings/providers/labeler_settings_controller.dart
new file mode 100644
index 00000000..d4e72edf
--- /dev/null
+++ b/lib/src/features/settings/providers/labeler_settings_controller.dart
@@ -0,0 +1,297 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:get_it/get_it.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/network/atproto/data/services/appview_labeler_headers.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/core/utils/logging/logger.dart';
+import 'package:spark/src/features/settings/providers/labeler_policy_preferences.dart';
+
+final labelerSettingsControllerProvider = Provider<LabelerSettingsController>(
+  (ref) => LabelerSettingsController(
+    ref,
+    GetIt.I<SprkRepository>(),
+    GetIt.I<LogService>().getLogger('LabelerSettings'),
+  ),
+);
+
+final class LabelerSettingsController {
+  LabelerSettingsController(this._ref, this._repository, this._logger);
+
+  final Ref _ref;
+  final SprkRepository _repository;
+  final SparkLogger _logger;
+  bool _defaultEnsured = false;
+
+  String get _defaultDid => _repository.modDid.split('#').first;
+
+  void resetSessionCache() {
+    _defaultEnsured = false;
+  }
+
+  Future<Preferences> _preferences() async {
+    return _ref.read(userPreferencesProvider).asData?.value ??
+        _ref.read(userPreferencesProvider.future);
+  }
+
+  Future<Preferences> _update(
+    Preferences Function(Preferences current) updater,
+  ) {
+    return _ref
+        .read(userPreferencesProvider.notifier)
+        .updatePreferencesWithFn(updater);
+  }
+
+  Future<List<String>> getLabelers() async {
+    final preferences = await _preferences();
+    var labelers =
+        preferences.labelers?.map((labeler) => labeler.did).toList() ?? [];
+
+    if (!_defaultEnsured) {
+      if (!labelers.contains(_defaultDid)) {
+        final updated = await _update((current) {
+          final currentLabelers =
+              current.labelers?.map((labeler) => labeler.did) ?? const [];
+          final normalized = _normalizeLabelers(currentLabelers);
+          if (_sameLabelers(currentLabelers, normalized)) return current;
+          return _withLabelers(current, normalized);
+        });
+        labelers =
+            updated.labelers?.map((labeler) => labeler.did).toList() ?? [];
+      }
+      _defaultEnsured = true;
+    }
+
+    return _normalizeLabelers(labelers);
+  }
+
+  Future<void> addLabeler(String identifier) async {
+    try {
+      final did = await _repository.labeler.resolveIdentifier(identifier);
+      final preferences = await _preferences();
+      final current = preferences.labelers ?? [];
+      if (current.any((labeler) => labeler.did == did)) return;
+      if (current.length >= AppViewLabelerHeaders.maxLabelers) {
+        throw StateError(
+          'Cannot subscribe to more than '
+          '${AppViewLabelerHeaders.maxLabelers} labelers',
+        );
+      }
+      await _repository.labeler.validateService(did);
+      await _update((latest) {
+        final latestLabelers = latest.labelers ?? const [];
+        if (latestLabelers.any((labeler) => labeler.did == did)) return latest;
+        if (latestLabelers.length >= AppViewLabelerHeaders.maxLabelers) {
+          throw StateError(
+            'Cannot subscribe to more than '
+            '${AppViewLabelerHeaders.maxLabelers} labelers',
+          );
+        }
+        return _withLabelers(latest, [
+          ...latestLabelers.map((labeler) => labeler.did),
+          did,
+        ]);
+      });
+    } catch (error, stackTrace) {
+      _logger.e(
+        'Could not add labeler $identifier',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      rethrow;
+    }
+  }
+
+  Future<void> removeLabeler(String did) async {
+    if (did == _defaultDid) {
+      throw Exception('Cannot remove the default moderation service');
+    }
+    await _update((current) {
+      final currentLabelers = current.labelers ?? const [];
+      if (!currentLabelers.any((labeler) => labeler.did == did)) return current;
+      return _withLabelers(
+        current,
+        currentLabelers
+            .map((labeler) => labeler.did)
+            .where((labelerDid) => labelerDid != did),
+      );
+    });
+  }
+
+  Future<void> syncLabelers() async {
+    resetSessionCache();
+    await _ref.read(userPreferencesProvider.notifier).refresh();
+    final preferences = await _preferences();
+    final labelers = _normalizeLabelers(
+      (preferences.labelers ?? const []).map((labeler) => labeler.did),
+    );
+
+    final unavailable = (await Future.wait([
+      for (final did in labelers)
+        if (did != _defaultDid)
+          () async {
+            try {
+              await _repository.labeler.validateService(did);
+              return null;
+            } on LabelerServiceUnavailableException catch (error, stackTrace) {
+              _logger.w(
+                'Removing unavailable labeler $did',
+                error: error,
+                stackTrace: stackTrace,
+              );
+              return did;
+            }
+          }(),
+    ])).nonNulls.toSet();
+
+    await _update((current) {
+      final currentLabelers =
+          current.labelers?.map((labeler) => labeler.did) ?? const [];
+      final available = _normalizeLabelers(
+        currentLabelers.where((did) => !unavailable.contains(did)),
+      );
+      if (_sameLabelers(currentLabelers, available)) return current;
+      return _withLabelers(current, available);
+    });
+    _defaultEnsured = true;
+  }
+
+  Future<Map<String, ModerationSetting>> getLabelSettings(
+    String labelerDid,
+  ) async {
+    final preferences = await _preferences();
+    return _savedSettings(preferences, labelerDid);
+  }
+
+  Future<LabelerPreferenceSnapshot> getPreferenceSnapshot(
+    String labelerDid,
+  ) async {
+    final service = await _repository.labeler.getServicesDetailed([labelerDid]);
+    final labelValues = service.policies.labelValues
+        .map<String>((value) => value.toJson())
+        .toList(growable: false);
+    if (labelValues.isEmpty) {
+      throw StateError('No label values found for labeler');
+    }
+    final definitions = ModerationLabelDefinitions.fromLabelers({
+      labelerDid: service.policies.labelValueDefinitions ?? const [],
+    });
+    final definitionMap = <String, ModerationLabelDefinition>{
+      for (final value in labelValues)
+        value:
+            ?definitions.bySource[labelerDid]?[value] ??
+            definitions.global[value],
+    };
+    final preferences = await _preferences();
+    final saved = _savedSettings(preferences, labelerDid);
+    final global = _savedSettings(preferences, null);
+    return LabelerPreferenceSnapshot(
+      definitions: definitionMap,
+      settings: {
+        for (final value in labelValues)
+          value: moderationSettingFromPolicy(
+            savedSetting: saved[value],
+            globalSetting: globalAdultContentLabelValues.contains(value)
+                ? global[value]
+                : null,
+            definition: definitionMap[value],
+          ),
+      },
+    );
+  }
+
+  Future<void> setLabelPreference(
+    String labelerDid,
+    String value,
+    ModerationSetting setting,
+  ) async {
+    await _update((current) {
+      final updated = <Preference>[];
+      var replaced = false;
+      for (final preference in current.preferences) {
+        final contentLabel = preference.contentLabelPref;
+        if (contentLabel?.labelerDid == labelerDid &&
+            contentLabel?.label == value) {
+          updated.add(
+            contentLabelPreference(
+              labelerDid: labelerDid,
+              label: value,
+              visibility: setting.name,
+            ),
+          );
+          replaced = true;
+        } else {
+          updated.add(preference);
+        }
+      }
+      if (!replaced) {
+        updated.add(
+          contentLabelPreference(
+            labelerDid: labelerDid,
+            label: value,
+            visibility: setting.name,
+          ),
+        );
+      }
+      return Preferences(preferences: updated);
+    });
+  }
+
+  Map<String, ModerationSetting> _savedSettings(
+    Preferences preferences,
+    String? labelerDid,
+  ) {
+    final result = <String, ModerationSetting>{};
+    for (final preference
+        in preferences.contentLabelPrefs ?? const <ContentLabelPref>[]) {
+      if (preference.labelerDid == labelerDid) {
+        result[preference.label] = switch (preference.visibility.toJson()) {
+          'hide' => ModerationSetting.hide,
+          'warn' => ModerationSetting.warn,
+          _ => ModerationSetting.ignore,
+        };
+      }
+    }
+    return result;
+  }
+
+  Preferences _withLabelers(
+    Preferences preferences,
+    Iterable<String> labelers,
+  ) {
+    final normalized = labelers.toList(growable: false);
+    final subscribed = normalized.toSet();
+    return Preferences(
+      preferences: [
+        ...preferences.preferences.where((preference) {
+          if (preference.isLabelersPref) return false;
+          final labelerDid = preference.contentLabelPref?.labelerDid;
+          return labelerDid == null || subscribed.contains(labelerDid);
+        }),
+        labelersPreference([
+          for (final did in normalized) LabelerPrefItem(did: did),
+        ]),
+      ],
+    );
+  }
+
+  bool _sameLabelers(Iterable<String> left, Iterable<String> right) {
+    final leftItems = left.toList(growable: false);
+    final rightItems = right.toList(growable: false);
+    if (leftItems.length != rightItems.length) return false;
+    for (var index = 0; index < leftItems.length; index++) {
+      if (leftItems[index] != rightItems[index]) return false;
+    }
+    return true;
+  }
+
+  List<String> _normalizeLabelers(Iterable<String> labelers) {
+    return AppViewLabelerHeaders.normalize(
+      defaultLabelerDid: _defaultDid,
+      labelerDids: labelers,
+    );
+  }
+}
diff --git a/lib/src/features/settings/providers/preferences_provider.dart b/lib/src/features/settings/providers/preferences_provider.dart
deleted file mode 100644
index 2006f3a4..00000000
--- a/lib/src/features/settings/providers/preferences_provider.dart
+++ /dev/null
@@ -1,92 +0,0 @@
-import 'package:get_it/get_it.dart';
-import 'package:riverpod_annotation/riverpod_annotation.dart';
-import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
-import 'package:spark/src/core/network/atproto/data/repositories/pref_repository.dart';
-import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
-import 'package:spark/src/core/utils/logging/log_service.dart';
-import 'package:spark/src/core/utils/logging/logger.dart';
-
-part 'preferences_provider.g.dart';
-
-/// Central provider for user preferences.
-///
-/// This provider loads preferences once at startup and holds them in memory.
-/// All services that need preferences should watch this provider instead of
-/// calling getPreferences() directly.
-///
-/// When preferences are updated (via [updatePreferences]), all watchers are
-/// automatically notified of the change.
-@Riverpod(keepAlive: true)
-class UserPreferences extends _$UserPreferences {
-  late final PrefRepository _prefRepository;
-  late final SprkRepository _sprkRepository;
-  late final SparkLogger _logger;
-
-  @override
-  Future<Preferences> build() async {
-    _prefRepository = GetIt.instance<PrefRepository>();
-    _sprkRepository = GetIt.instance<SprkRepository>();
-    _logger = GetIt.instance<LogService>().getLogger('UserPreferences');
-
-    // Wait for auth to be initialized
-    await _sprkRepository.authRepository.initializationComplete;
-
-    if (!_sprkRepository.authRepository.isAuthenticated) {
-      return Preferences(preferences: []);
-    }
-
-    try {
-      final preferences = await _prefRepository.getPreferences();
-      return preferences;
-    } catch (e) {
-      _logger.e('Error loading preferences: $e');
-      rethrow;
-    }
-  }
-
-  /// Gets the current preferences synchronously if available.
-  /// Returns null if preferences haven't been loaded yet or there was an error.
-  Preferences? get currentPreferences => state.asData?.value;
-
-  /// Refreshes preferences from the server.
-  /// This should be called when logging in or when syncing from another device.
-  Future<void> refresh() async {
-    state = const AsyncValue.loading();
-
-    try {
-      final preferences = await _prefRepository.getPreferences();
-      state = AsyncValue.data(preferences);
-    } catch (e, st) {
-      _logger.e('Error refreshing preferences: $e');
-      state = AsyncValue.error(e, st);
-      rethrow;
-    }
-  }
-
-  /// Updates preferences on the server and in local state.
-  /// This should be called whenever preferences are modified.
-  Future<void> updatePreferences(Preferences preferences) async {
-    try {
-      await _prefRepository.putPreferences(preferences);
-      state = AsyncValue.data(preferences);
-    } catch (e, st) {
-      _logger.e('Error updating preferences: $e');
-      state = AsyncValue.error(e, st);
-      rethrow;
-    }
-  }
-
-  /// Updates preferences by applying a transformation function.
-  /// This is useful for making partial updates without fetching first.
-  Future<void> updatePreferencesWithFn(
-    Preferences Function(Preferences current) updater,
-  ) async {
-    final current = state.asData?.value;
-    if (current == null) {
-      throw Exception('Cannot update preferences: not loaded yet');
-    }
-
-    final updated = updater(current);
-    await updatePreferences(updated);
-  }
-}
diff --git a/lib/src/features/settings/providers/settings_provider.dart b/lib/src/features/settings/providers/settings_provider.dart
index d1479be5..3ab8b6e7 100644
--- a/lib/src/features/settings/providers/settings_provider.dart
+++ b/lib/src/features/settings/providers/settings_provider.dart
@@ -1,8 +1,6 @@
-import 'package:poptart/poptart.dart';
 import 'package:get_it/get_it.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/models.dart';
 import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/pref_repository.dart';
@@ -11,10 +9,9 @@ import 'package:spark/src/core/storage/preferences/default_preferences.dart';
 import 'package:spark/src/core/storage/preferences/storage_manager.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
 import 'package:spark/src/features/settings/providers/settings_state.dart';
-import 'package:sprk_poptart/so/sprk/labeler/get_services.dart'
-    as sprk_get_services;
 
 part 'settings_provider.g.dart';
 
@@ -39,13 +36,6 @@ class Settings extends _$Settings {
   SparkLogger? _logger;
   Feed? _defaultFeed;
 
-  /// Tracks labelers whose policies have already been fetched and set.
-  /// This prevents repeated network calls to getServices for the same labelers.
-  final Set<String> _labelerPoliciesChecked = {};
-
-  /// Tracks if the default labeler has been ensured this session
-  bool _defaultLabelerEnsured = false;
-
   /// Tracks if settings have been loaded to prevent resetting state on rebuild
   bool _hasLoadedSettings = false;
 
@@ -92,20 +82,21 @@ class Settings extends _$Settings {
 
   /// Updates preferences through the UserPreferences provider.
   /// This ensures all watchers are notified of changes.
-  Future<void> _updatePreferences(Preferences preferences) async {
-    await ref
+  Future<Preferences> _updatePreferences(
+    Preferences Function(Preferences current) updater,
+  ) {
+    return ref
         .read(userPreferencesProvider.notifier)
-        .updatePreferences(preferences);
+        .updatePreferencesWithFn(updater);
   }
 
-  Future<Preferences> _getCurrentPreferencesForFeedUpdate() async {
+  Future<void> _refreshPreferencesForFeedUpdate() async {
     try {
       await ref.read(userPreferencesProvider.notifier).refresh();
       final preferences = _currentPreferences;
       if (preferences == null) {
         throw const SavedFeedsUnavailableException();
       }
-      return preferences;
     } catch (e, st) {
       logger.e(
         'Cannot update feeds because current saved feeds could not be loaded',
@@ -119,16 +110,19 @@ class Settings extends _$Settings {
   Future<List<Feed>> _updateSavedFeeds(
     List<SavedFeed> Function(List<SavedFeed> currentSavedFeeds) update,
   ) async {
-    final preferences = await _getCurrentPreferencesForFeedUpdate();
-    final updatedSavedFeeds = update(
-      List<SavedFeed>.of(_getSavedFeedsFromPreferences(preferences)),
-    );
-
-    final updatedPreferencesList =
-        preferences.preferences.where((pref) => !pref.isSavedFeedsPref).toList()
-          ..add(savedFeedsPreference(updatedSavedFeeds));
-
-    await _updatePreferences(Preferences(preferences: updatedPreferencesList));
+    await _refreshPreferencesForFeedUpdate();
+    final updatedPreferences = await _updatePreferences((current) {
+      final updatedSavedFeeds = update(
+        List<SavedFeed>.of(_getSavedFeedsFromPreferences(current)),
+      );
+      final updatedPreferencesList =
+          current.preferences
+              .where((preference) => !preference.isSavedFeedsPref)
+              .toList()
+            ..add(savedFeedsPreference(updatedSavedFeeds));
+      return Preferences(preferences: updatedPreferencesList);
+    });
+    final updatedSavedFeeds = _getSavedFeedsFromPreferences(updatedPreferences);
     return _loadFeedsFromSavedFeeds(updatedSavedFeeds);
   }
 
@@ -255,11 +249,29 @@ class Settings extends _$Settings {
           final defaultPrefs = DefaultPreferences.defaultPreferences(
             modServiceDid: modServiceDid,
           );
-          await _updatePreferences(defaultPrefs);
+          final updatedPreferences = await _updatePreferences((current) {
+            if (_getSavedFeedsFromPreferences(current).isNotEmpty) {
+              return current;
+            }
+            return Preferences(
+              preferences: [
+                ...current.preferences.where(
+                  (preference) => !preference.isSavedFeedsPref,
+                ),
+                ...defaultPrefs.preferences.where((preference) {
+                  if (preference.isSavedFeedsPref) return true;
+                  if (preference.isLabelersPref) {
+                    return current.labelers == null;
+                  }
+                  if (preference.isContentLabelPref) {
+                    return current.contentLabelPrefs == null;
+                  }
+                  return false;
+                }),
+              ],
+            );
+          });
 
-          // Get updated preferences from provider
-          final updatedPreferences =
-              ref.read(userPreferencesProvider).asData?.value ?? defaultPrefs;
           final updatedSavedFeeds = _getSavedFeedsFromPreferences(
             updatedPreferences,
           );
@@ -412,7 +424,7 @@ class Settings extends _$Settings {
       // Reset flags to handle race conditions (e.g., login while loading)
       _hasLoadedSettings = false;
       _isLoadingSettings = false;
-      _defaultLabelerEnsured = false;
+      ref.read(labelerSettingsControllerProvider).resetSessionCache();
       // Refresh preferences from server - use Future to avoid modifying
       // provider during widget build phase
       await Future(() async {
@@ -546,574 +558,10 @@ class Settings extends _$Settings {
     }
   }
 
-  // Public methods for other providers to use
-
-  Future<List<String>> getLabelers() async {
-    final preferences = await _getPreferences();
-    var labelers =
-        preferences.labelers?.map((labeler) => labeler.did).toList() ?? [];
-
-    // Ensure default mod service labeler is always present
-    // Only check once per session to avoid unnecessary putPreferences calls
-    final modServiceDid = _defaultModServiceDid;
-    if (!_defaultLabelerEnsured) {
-      _defaultLabelerEnsured = true;
-      final isMissing = !labelers.contains(modServiceDid);
-      if (isMissing) {
-        logger.d('Default mod service labeler not found, adding it');
-        labelers = [modServiceDid, ...labelers];
-
-        // Update preferences to include default labeler
-        final updatedLabelers = <LabelerPrefItem>[
-          LabelerPrefItem(did: modServiceDid),
-          ...(preferences.labelers ?? []),
-        ];
-        final updatedPreferencesList =
-            preferences.preferences
-                .where((pref) => !pref.isLabelersPref)
-                .toList()
-              ..add(labelersPreference(updatedLabelers));
-
-        await _updatePreferences(
-          Preferences(preferences: updatedPreferencesList),
-        );
-      }
-    } else if (!labelers.contains(modServiceDid)) {
-      // Already checked this session but still need to include it in return
-      labelers = [modServiceDid, ...labelers];
-    }
-
-    // Ensure all labelers' label values are set as preferences
-    // Do this asynchronously to avoid blocking
-    Future.microtask(() => _ensureAllLabelersPoliciesSet(labelers));
-
-    return labelers;
-  }
-
-  /// Ensures all label values from all subscribed labelers have prefs set.
-  /// Only fetch policies for labelers that haven't been checked this session.
-  Future<void> _ensureAllLabelersPoliciesSet(List<String> labelerDids) async {
-    final uncheckedLabelers = labelerDids
-        .where((did) => !_labelerPoliciesChecked.contains(did))
-        .toList();
-
-    if (uncheckedLabelers.isEmpty) {
-      return;
-    }
-
-    for (final did in uncheckedLabelers) {
-      try {
-        await _fetchLabelerPoliciesAndSetDefaults(did);
-        _labelerPoliciesChecked.add(did);
-      } catch (e) {
-        logger.w('Error ensuring label values for labeler $did: $e');
-      }
-    }
-  }
-
-  /// Adds a labeler to the user's subscribed labelers list
-  Future<void> addLabeler(String did) async {
-    try {
-      logger.d('Adding labeler: $did');
-      final preferences = await _getPreferences();
-      final currentLabelers = preferences.labelers ?? [];
-
-      // Check if labeler already exists
-      if (currentLabelers.any((labeler) => labeler.did == did)) {
-        logger.w('Labeler already exists: $did');
-        return;
-      }
-
-      // Create updated preferences with new labeler
-      final updatedLabelers = [...currentLabelers, LabelerPrefItem(did: did)];
-      final updatedPreferencesList =
-          preferences.preferences.where((pref) => !pref.isLabelersPref).toList()
-            ..add(labelersPreference(updatedLabelers));
-
-      await _updatePreferences(
-        Preferences(preferences: updatedPreferencesList),
-      );
-      logger.d('Labeler added successfully: $did');
-
-      // Fetch and set default label preferences for this labeler
-      await _fetchLabelerPoliciesAndSetDefaults(did);
-      _labelerPoliciesChecked.add(did);
-    } catch (e) {
-      logger.e('Error adding labeler: $e');
-      rethrow;
-    }
-  }
-
-  /// Removes a labeler from the user's subscribed labelers list
-  Future<void> removeLabeler(String did) async {
-    try {
-      // Prevent removal of default mod service labeler
-      if (did == _defaultModServiceDid) {
-        logger.w(
-          'Attempted to remove default mod service labeler, '
-          'which is not allowed',
-        );
-        throw Exception('Cannot remove the default mod service labeler');
-      }
-
-      logger.d('Removing labeler: $did');
-      final preferences = await _getPreferences();
-      final currentLabelers = preferences.labelers ?? [];
-
-      // Remove the labeler
-      final updatedLabelers = currentLabelers
-          .where((labeler) => labeler.did != did)
-          .toList();
-
-      // Create updated preferences
-      final updatedPreferencesList =
-          preferences.preferences.where((pref) => !pref.isLabelersPref).toList()
-            ..add(labelersPreference(updatedLabelers));
-
-      await _updatePreferences(
-        Preferences(preferences: updatedPreferencesList),
-      );
-      logger.d('Labeler removed successfully: $did');
-    } catch (e) {
-      logger.e('Error removing labeler: $e');
-      rethrow;
-    }
-  }
-
-  /// Syncs labelers from server (useful for manual refresh)
-  Future<void> syncLabelers() async {
-    try {
-      logger.d('Syncing labelers from server...');
-      // Clear the caches so we re-check everything
-      _labelerPoliciesChecked.clear();
-      _defaultLabelerEnsured = false;
-      // Refresh preferences from server first
-      await ref.read(userPreferencesProvider.notifier).refresh();
-
-      final preferences = await _getPreferences();
-      final labelers =
-          preferences.labelers?.map((labeler) => labeler.did).toList() ?? [];
-
-      // Ensure default mod service labeler is present
-      final modServiceDid = _defaultModServiceDid;
-      _defaultLabelerEnsured = true;
-      if (!labelers.contains(modServiceDid)) {
-        labelers.insert(0, modServiceDid);
-        final updatedLabelers = <LabelerPrefItem>[
-          LabelerPrefItem(did: modServiceDid),
-          ...(preferences.labelers ?? []),
-        ];
-        final updatedPreferencesList =
-            preferences.preferences
-                .where((pref) => !pref.isLabelersPref)
-                .toList()
-              ..add(labelersPreference(updatedLabelers));
-        await _updatePreferences(
-          Preferences(preferences: updatedPreferencesList),
-        );
-      }
-
-      logger.d(
-        'Syncing label value preferences for ${labelers.length} labelers',
-      );
-
-      // Ensure all labelers' label values are set as preferences
-      await _ensureAllLabelersPoliciesSet(labelers);
-
-      logger.d('Labelers synced successfully');
-    } catch (e) {
-      logger.e('Error syncing labelers: $e');
-      rethrow;
-    }
-  }
-
-  Future<LabelPreference> getLabelPreference(String value) async {
-    final preferences = await _getPreferences();
-    final contentLabelPrefs = preferences.contentLabelPrefs ?? [];
-    final contentLabelPref = contentLabelPrefs.firstWhere(
-      (pref) => pref.label == value,
-      orElse: () => throw Exception('Label preference not found'),
-    );
-    return LabelPreference(
-      value: contentLabelPref.label,
-      blurs: _visibilityToBlurs(contentLabelPref.visibilityValue),
-      severity: _visibilityToSeverity(contentLabelPref.visibilityValue),
-      defaultSetting: _visibilityToSetting(contentLabelPref.visibilityValue),
-      setting: _visibilityToSetting(contentLabelPref.visibilityValue),
-      adultOnly: _isAdultOnlyLabel(value),
-    );
-  }
-
-  Future<void> setLabelPreference(
-    String value,
-    Blurs blurs,
-    Severity severity,
-    bool adultOnly,
-    Setting setting,
-  ) async {
-    final preferences = await _getPreferences();
-    final updatedPreferencesList = preferences.preferences
-        .where((pref) => !pref.isContentLabelPref)
-        .toList();
-    final existingContentPrefs = preferences.contentLabelPrefs ?? [];
-    for (final pref in existingContentPrefs) {
-      if (pref.label == value) {
-        updatedPreferencesList.add(
-          contentLabelPreference(
-            labelerDid: pref.labelerDid,
-            label: value,
-            visibility: _settingToVisibility(setting),
-          ),
-        );
-      } else {
-        updatedPreferencesList.add(
-          contentLabelPreference(
-            labelerDid: pref.labelerDid,
-            label: pref.label,
-            visibility: pref.visibilityValue,
-          ),
-        );
-      }
-    }
-    if (!existingContentPrefs.any((pref) => pref.label == value)) {
-      updatedPreferencesList.add(
-        contentLabelPreference(
-          labelerDid: _defaultModServiceDid,
-          label: value,
-          visibility: _settingToVisibility(setting),
-        ),
-      );
-    }
-    await _updatePreferences(Preferences(preferences: updatedPreferencesList));
-  }
-
-  /// Gets label preferences for a specific labeler
-  Future<Map<String, LabelPreference>> getLabelPreferencesForLabeler(
-    String labelerDid,
-  ) async {
-    final preferences = await _getPreferences();
-
-    // Get content label preferences from the main preferences list
-    final contentLabelPrefsMap = <String, String>{}; // label -> visibility
-    for (final pref in preferences.preferences) {
-      final contentLabelPref = pref.contentLabelPref;
-      if (contentLabelPref != null &&
-          contentLabelPref.labelerDid == labelerDid) {
-        contentLabelPrefsMap[contentLabelPref.label] =
-            contentLabelPref.visibilityValue;
-      }
-    }
-
-    // Also check contentLabelPrefs property
-    final contentLabelPrefsFromProperty = preferences.contentLabelPrefs ?? [];
-    for (final pref in contentLabelPrefsFromProperty) {
-      final prefLabelerDid = pref.labelerDid;
-      final prefLabel = pref.label;
-      final prefVisibility = pref.visibilityValue;
-      if (prefLabelerDid == labelerDid &&
-          !contentLabelPrefsMap.containsKey(prefLabel)) {
-        contentLabelPrefsMap[prefLabel] = prefVisibility;
-      }
-    }
-
-    final result = <String, LabelPreference>{};
-    for (final entry in contentLabelPrefsMap.entries) {
-      final label = entry.key;
-      final visibility = entry.value;
-
-      // Get the actual saved setting from visibility
-      final setting = _visibilityToSetting(visibility);
-
-      // For blur, we need to infer it from the setting
-      // If setting is 'warn', default to media blur, otherwise none
-      final blurs = setting == Setting.warn ? Blurs.media : Blurs.none;
-
-      result[label] = LabelPreference(
-        value: label,
-        blurs: blurs,
-        severity: _visibilityToSeverity(visibility),
-        defaultSetting: setting, // TODO: should come from label definitions
-        setting: setting,
-        adultOnly: _isAdultOnlyLabel(label),
-      );
-    }
-    return result;
-  }
-
-  /// Sets label preference for a specific labeler
-  Future<void> setLabelPreferenceForLabeler(
-    String labelerDid,
-    String value,
-    Blurs blurs,
-    Severity severity,
-    bool adultOnly,
-    Setting setting,
-  ) async {
-    final preferences = await _getPreferences();
-
-    // Get all non-content-label preferences
-    final updatedPreferencesList = preferences.preferences
-        .where((pref) => !pref.isContentLabelPref)
-        .toList();
-
-    // Get all existing content label preferences from preferences
-    final existingContentLabelPreferences = preferences.preferences
-        .where((pref) => pref.isContentLabelPref)
-        .toList();
-
-    // Track if we found the preference to update
-    var found = false;
-
-    // Preserve all other content label prefs & update the one we're changing
-    for (final pref in existingContentLabelPreferences) {
-      final contentLabelPref = pref.contentLabelPref;
-      if (contentLabelPref != null) {
-        if (contentLabelPref.labelerDid == labelerDid &&
-            contentLabelPref.label == value) {
-          // Update this specific preference
-          updatedPreferencesList.add(
-            contentLabelPreference(
-              labelerDid: labelerDid,
-              label: value,
-              visibility: _settingToVisibility(setting),
-            ),
-          );
-          found = true;
-        } else {
-          // Keep other preferences as-is
-          updatedPreferencesList.add(pref);
-        }
-      }
-    }
-
-    // If preference doesn't exist, add it
-    if (!found) {
-      updatedPreferencesList.add(
-        contentLabelPreference(
-          labelerDid: labelerDid,
-          label: value,
-          visibility: _settingToVisibility(setting),
-        ),
-      );
-    }
-
-    await _updatePreferences(Preferences(preferences: updatedPreferencesList));
-  }
-
   Future<Feed> getActiveFeed() async {
     final preferences = await _getPreferences();
     final savedFeeds = _getSavedFeedsFromPreferences(preferences);
     final feeds = await _loadFeedsFromSavedFeeds(savedFeeds);
     return _getActiveFeedFromFeeds(feeds, savedFeeds);
   }
-
-  // Helper conversion methods
-
-  String _settingToVisibility(Setting setting) {
-    switch (setting) {
-      case Setting.ignore:
-        return 'ignore';
-      case Setting.warn:
-        return 'warn';
-      case Setting.hide:
-        return 'hide';
-    }
-  }
-
-  Setting _visibilityToSetting(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Setting.ignore;
-      case 'warn':
-        return Setting.warn;
-      case 'hide':
-        return Setting.hide;
-      default:
-        return Setting.ignore;
-    }
-  }
-
-  Blurs _visibilityToBlurs(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Blurs.none;
-      case 'warn':
-        return Blurs.media;
-      case 'hide':
-        return Blurs.content;
-      default:
-        return Blurs.none;
-    }
-  }
-
-  Severity _visibilityToSeverity(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Severity.none;
-      case 'warn':
-        return Severity.alert;
-      case 'hide':
-        return Severity.alert;
-      default:
-        return Severity.none;
-    }
-  }
-
-  bool _isAdultOnlyLabel(String label) {
-    const adultOnlyLabels = {'porn', 'sexual', 'nsfl'};
-    return adultOnlyLabels.contains(label);
-  }
-
-  /// Fetches labeler policies and sets default content label preferences
-  /// for label values that don't already have preferences
-  Future<void> _fetchLabelerPoliciesAndSetDefaults(String did) async {
-    try {
-      final rawResponse = await sprkRepository.executeWithRetry(() async {
-        if (!sprkRepository.authRepository.isAuthenticated) {
-          throw Exception('Not authenticated');
-        }
-        final atproto = sprkRepository.authRepository.atproto;
-        if (atproto == null) {
-          throw Exception('AtProto not initialized');
-        }
-        final result = await atproto.call(
-          sprk_get_services.soSprkLabelerGetServices,
-          parameters: sprk_get_services.LabelerGetServicesInput(
-            dids: [did],
-            detailed: true,
-          ),
-          headers: {'atproto-proxy': sprkRepository.sprkDid},
-        );
-        if (result.status != HttpStatus.ok) {
-          throw Exception('Failed to retrieve labeler services');
-        }
-        return result.data.toJson();
-      });
-
-      final viewsJson = rawResponse['views'] as List<dynamic>?;
-      if (viewsJson == null || viewsJson.isEmpty) {
-        return;
-      }
-
-      final viewJson = viewsJson.first as Map<String, dynamic>;
-      final policiesJson = viewJson['policies'] as Map<String, dynamic>?;
-
-      if (policiesJson == null) {
-        return;
-      }
-
-      final labelValuesJson = policiesJson['labelValues'] as List<dynamic>?;
-      if (labelValuesJson == null || labelValuesJson.isEmpty) {
-        return;
-      }
-
-      final labelValues = labelValuesJson.map((v) => v as String).toList();
-
-      final labelValueDefinitionsJson =
-          policiesJson['labelValueDefinitions'] as List<dynamic>?;
-      final labelDefinitionMap = <String, Map<String, dynamic>>{};
-      if (labelValueDefinitionsJson != null) {
-        for (final defJson in labelValueDefinitionsJson) {
-          final def = defJson as Map<String, dynamic>;
-          final identifier = def['identifier'] as String?;
-          if (identifier != null) {
-            labelDefinitionMap[identifier] = def;
-          }
-        }
-      }
-
-      final preferences = await _getPreferences();
-
-      // Get all existing content label preferences from both sources
-      final existingContentLabelPreferences = preferences.preferences
-          .where((pref) => pref.isContentLabelPref)
-          .toList();
-      final existingContentPrefsFromProperty =
-          preferences.contentLabelPrefs ?? [];
-
-      // Build a map of existing preferences by labelerDid:label
-      final existingPrefsMap =
-          <String, String>{}; // "labelerDid:label" -> "visibility"
-      for (final pref in existingContentLabelPreferences) {
-        final contentLabelPref = pref.contentLabelPref;
-        if (contentLabelPref != null) {
-          existingPrefsMap['${contentLabelPref.labelerDid}:'
-                  '${contentLabelPref.label}'] =
-              contentLabelPref.visibilityValue;
-        }
-      }
-      for (final pref in existingContentPrefsFromProperty) {
-        final key = '${pref.labelerDid}:${pref.label}';
-        if (!existingPrefsMap.containsKey(key)) {
-          existingPrefsMap[key] = pref.visibilityValue;
-        }
-      }
-
-      final preferencesToAdd = <Preference>[];
-
-      for (final labelValue in labelValues) {
-        final key = '$did:$labelValue';
-        final hasExistingPref = existingPrefsMap.containsKey(key);
-
-        if (!hasExistingPref) {
-          String defaultVisibility;
-          final definition = labelDefinitionMap[labelValue];
-          if (definition != null) {
-            defaultVisibility =
-                definition['defaultSetting'] as String? ?? 'warn';
-          } else {
-            defaultVisibility = _getDefaultVisibilityForLabel(labelValue);
-          }
-
-          preferencesToAdd.add(
-            contentLabelPreference(
-              labelerDid: did,
-              label: labelValue,
-              visibility: defaultVisibility,
-            ),
-          );
-        }
-      }
-
-      if (preferencesToAdd.isNotEmpty) {
-        // Preserve all existing preferences and add new ones
-        final updatedPreferencesList = [
-          ...preferences.preferences.where((pref) => !pref.isContentLabelPref),
-          ...existingContentLabelPreferences,
-          ...preferencesToAdd,
-        ];
-        await _updatePreferences(
-          Preferences(preferences: updatedPreferencesList),
-        );
-      }
-    } catch (e) {
-      logger.e('Error fetching labeler policies for $did: $e');
-    }
-  }
-
-  /// Determines default visibility setting for a label value
-  String _getDefaultVisibilityForLabel(String labelValue) {
-    // Use similar logic to LabelSettingsPage._createDefaultLabelPreference
-    switch (labelValue) {
-      case '!hide':
-      case 'dmca-violation':
-        return 'hide';
-      case '!no-promote':
-        return 'hide';
-      case '!warn':
-      case 'doxxing':
-      case 'porn':
-      case 'sexual':
-      case 'nsfl':
-      case 'gore':
-        return 'warn';
-      case '!no-unauthenticated':
-        return 'ignore';
-      case 'nudity':
-        return 'ignore';
-      default:
-        // For unknown labels, default to warn
-        return 'warn';
-    }
-  }
 }
diff --git a/lib/src/features/settings/ui/pages/labeler_label_settings_page.dart b/lib/src/features/settings/ui/pages/labeler_label_settings_page.dart
index 0385b025..14a974e9 100644
--- a/lib/src/features/settings/ui/pages/labeler_label_settings_page.dart
+++ b/lib/src/features/settings/ui/pages/labeler_label_settings_page.dart
@@ -1,20 +1,19 @@
-import 'package:poptart/poptart.dart';
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:get_it/get_it.dart';
 import 'package:spark/src/core/design_system/components/atoms/buttons/app_leading_button.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/actor_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/design_system/components/atoms/user_avatar.dart';
 import 'package:spark/src/core/utils/logging/logging.dart';
-import 'package:spark/src/features/settings/providers/settings_provider.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
 import 'package:spark/src/features/settings/ui/widgets/widgets.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
-import 'package:sprk_poptart/so/sprk/labeler/get_services.dart'
-    as sprk_get_services;
 
 @RoutePage()
 class LabelerLabelSettingsPage extends ConsumerStatefulWidget {
@@ -34,9 +33,10 @@ class _LabelerLabelSettingsPageState
   final SprkRepository _sprkRepository = GetIt.instance<SprkRepository>();
 
   ProfileViewDetailed? _labelerProfile;
-  Map<String, LabelPreference> _labelPreferences = {};
-  Map<String, Map<String, dynamic>> _labelDefinitions = {};
+  Map<String, ModerationSetting> _labelSettings = {};
+  Map<String, ModerationLabelDefinition> _labelDefinitions = {};
   bool _isLoading = true;
+  bool _isSaving = false;
   String? _errorMessage;
 
   String get _defaultModServiceDid {
@@ -63,6 +63,7 @@ class _LabelerLabelSettingsPageState
       // Fetch labeler profile
       try {
         final profiles = await _actorRepository.getProfiles([widget.did]);
+        if (!mounted) return;
         if (profiles.isNotEmpty) {
           setState(() {
             _labelerProfile = profiles.firstWhere(
@@ -74,104 +75,21 @@ class _LabelerLabelSettingsPageState
       } catch (e) {
         _logger.w('Could not fetch labeler profile: $e');
       }
+      if (!mounted) return;
 
-      // Fetch labeler policies
-      final rawResponse = await _sprkRepository.executeWithRetry(() async {
-        if (!_sprkRepository.authRepository.isAuthenticated) {
-          throw Exception('Not authenticated');
-        }
-        final atproto = _sprkRepository.authRepository.atproto;
-        if (atproto == null) {
-          throw Exception('AtProto not initialized');
-        }
-        final result = await atproto.call(
-          sprk_get_services.soSprkLabelerGetServices,
-          parameters: sprk_get_services.LabelerGetServicesInput(
-            dids: [widget.did],
-            detailed: true,
-          ),
-          headers: {'atproto-proxy': _sprkRepository.sprkDid},
-        );
-        if (result.status != HttpStatus.ok) {
-          throw Exception('Failed to retrieve labeler services');
-        }
-        return result.data.toJson();
-      });
-
-      final viewsJson = rawResponse['views'] as List<dynamic>?;
-      if (viewsJson == null || viewsJson.isEmpty) {
-        throw Exception('No labeler views returned');
-      }
-
-      final viewJson = viewsJson.first as Map<String, dynamic>;
-      final policiesJson = viewJson['policies'] as Map<String, dynamic>?;
-
-      if (policiesJson == null) {
-        throw Exception('No policies found for labeler');
-      }
-
-      final labelValuesJson = policiesJson['labelValues'] as List<dynamic>?;
-      if (labelValuesJson == null || labelValuesJson.isEmpty) {
-        throw Exception('No label values found for labeler');
-      }
-
-      final labelValues = labelValuesJson.map((v) => v as String).toList();
-
-      // Extract labelValueDefinitions
-      final labelValueDefinitionsJson =
-          policiesJson['labelValueDefinitions'] as List<dynamic>?;
-      final labelDefinitionMap = <String, Map<String, dynamic>>{};
-      if (labelValueDefinitionsJson != null) {
-        for (final defJson in labelValueDefinitionsJson) {
-          final def = defJson as Map<String, dynamic>;
-          final identifier = def['identifier'] as String?;
-          if (identifier != null) {
-            labelDefinitionMap[identifier] = def;
-          }
-        }
-      }
-
-      // Get existing preferences for this labeler
-      final settings = ref.read(settingsProvider.notifier);
-      final existingPrefs = await settings.getLabelPreferencesForLabeler(
-        widget.did,
-      );
-      final preferences = <String, LabelPreference>{};
-
-      // Create preferences for all label values
-      for (final labelValue in labelValues) {
-        if (existingPrefs.containsKey(labelValue)) {
-          preferences[labelValue] = existingPrefs[labelValue]!;
-        } else {
-          // Create default preference
-          String defaultVisibility;
-          final definition = labelDefinitionMap[labelValue];
-          if (definition != null) {
-            defaultVisibility =
-                definition['defaultSetting'] as String? ?? 'warn';
-          } else {
-            defaultVisibility = _getDefaultVisibilityForLabel(labelValue);
-          }
-
-          final defaultPref = LabelPreference(
-            value: labelValue,
-            blurs: _visibilityToBlurs(defaultVisibility),
-            severity: _visibilityToSeverity(defaultVisibility),
-            defaultSetting: _visibilityToSetting(defaultVisibility),
-            setting: _visibilityToSetting(defaultVisibility),
-            adultOnly: _isAdultOnlyLabel(labelValue),
-          );
-          preferences[labelValue] = defaultPref;
-        }
-      }
+      final snapshot = await ref
+          .read(labelerSettingsControllerProvider)
+          .getPreferenceSnapshot(widget.did);
+      if (!mounted) return;
 
       setState(() {
-        _labelPreferences = preferences;
-        _labelDefinitions = labelDefinitionMap;
+        _labelSettings = snapshot.settings;
+        _labelDefinitions = snapshot.definitions;
         _isLoading = false;
       });
     } catch (e) {
       _logger.e('Error loading labeler settings: $e');
+      if (!mounted) return;
       setState(() {
         _errorMessage = e.toString();
         _isLoading = false;
@@ -179,106 +97,28 @@ class _LabelerLabelSettingsPageState
     }
   }
 
-  String _getDefaultVisibilityForLabel(String labelValue) {
-    switch (labelValue) {
-      case '!hide':
-      case 'dmca-violation':
-        return 'hide';
-      case '!no-promote':
-        return 'hide';
-      case '!warn':
-      case 'doxxing':
-      case 'porn':
-      case 'sexual':
-      case 'nsfl':
-      case 'gore':
-        return 'warn';
-      case '!no-unauthenticated':
-        return 'ignore';
-      case 'nudity':
-        return 'ignore';
-      default:
-        return 'warn';
-    }
-  }
-
-  Setting _visibilityToSetting(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Setting.ignore;
-      case 'warn':
-        return Setting.warn;
-      case 'hide':
-        return Setting.hide;
-      default:
-        return Setting.ignore;
-    }
-  }
-
-  Blurs _visibilityToBlurs(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Blurs.none;
-      case 'warn':
-        return Blurs.media;
-      case 'hide':
-        return Blurs.content;
-      default:
-        return Blurs.none;
-    }
-  }
-
-  Severity _visibilityToSeverity(String visibility) {
-    switch (visibility) {
-      case 'ignore':
-        return Severity.none;
-      case 'warn':
-        return Severity.alert;
-      case 'hide':
-        return Severity.alert;
-      default:
-        return Severity.none;
-    }
-  }
-
-  bool _isAdultOnlyLabel(String label) {
-    const adultOnlyLabels = {'porn', 'sexual', 'nsfl'};
-    return adultOnlyLabels.contains(label);
-  }
-
   Future<void> _updateLabelPreference(
-    String label, {
-    Setting? setting,
-    Blurs? blurs,
-    Severity? severity,
-  }) async {
-    try {
-      final currentPref = _labelPreferences[label];
-      if (currentPref != null) {
-        final newSetting = setting ?? currentPref.setting;
-        final newBlurs = blurs ?? currentPref.blurs;
-        final newSeverity = severity ?? currentPref.severity;
+    String label,
+    ModerationSetting setting,
+  ) async {
+    if (_isSaving) return;
+    setState(() => _isSaving = true);
 
-        final settings = ref.read(settingsProvider.notifier);
-        await settings.setLabelPreferenceForLabeler(
-          widget.did,
-          label,
-          newBlurs,
-          newSeverity,
-          currentPref.adultOnly,
-          newSetting,
-        );
+    try {
+      if (_labelSettings.containsKey(label)) {
+        await ref
+            .read(labelerSettingsControllerProvider)
+            .setLabelPreference(widget.did, label, setting);
 
+        if (!mounted) return;
         setState(() {
-          _labelPreferences[label] = currentPref.copyWith(
-            setting: newSetting,
-            blurs: newBlurs,
-            severity: newSeverity,
-          );
+          _labelSettings[label] = setting;
         });
       }
     } catch (e) {
       _logger.e('Error updating label preference: $e');
+    } finally {
+      if (mounted) setState(() => _isSaving = false);
     }
   }
 
@@ -287,6 +127,9 @@ class _LabelerLabelSettingsPageState
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
     final l10n = AppLocalizations.of(context);
+    final adultContentEnabled =
+        ref.watch(userPreferencesProvider).asData?.value.adultContentEnabled ??
+        false;
 
     if (_isLoading) {
       return Scaffold(
@@ -464,7 +307,7 @@ class _LabelerLabelSettingsPageState
             ),
 
             // Label preferences
-            if (_labelPreferences.isEmpty)
+            if (_labelSettings.isEmpty)
               Card(
                 margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
                 child: Padding(
@@ -498,32 +341,39 @@ class _LabelerLabelSettingsPageState
                 ),
               )
             else
-              ..._labelPreferences.entries
+              ..._labelSettings.entries
                   .where((entry) => !entry.key.startsWith('!'))
                   .map((entry) {
                     final definition = _labelDefinitions[entry.key];
-                    String? labelName;
-                    String? labelDescription;
-
-                    if (definition != null) {
-                      final locales = definition['locales'] as List<dynamic>?;
-                      if (locales != null && locales.isNotEmpty) {
-                        // TODO: match user's locale instead of first
-                        final firstLocale =
-                            locales.first as Map<String, dynamic>;
-                        labelName = firstLocale['name'] as String?;
-                        labelDescription =
-                            firstLocale['description'] as String?;
-                      }
-                    }
+                    final configuredGlobally = globalAdultContentLabelValues
+                        .contains(entry.key);
+                    final strings = definition?.localizedStrings(
+                      l10n,
+                      preferredLocales: [
+                        Localizations.localeOf(context).toLanguageTag(),
+                      ],
+                    );
 
                     return LabelSettingTile(
+                      key: Key('labeler-label-${entry.key}'),
                       label: entry.key,
-                      preference: entry.value,
-                      onPreferenceUpdate: _updateLabelPreference,
-                      labelName: labelName,
-                      labelDescription: labelDescription,
-                      showSeverity: false,
+                      controlContext:
+                          definition?.severity == ModerationSeverity.inform
+                          ? LabelSettingTileContext.informLabel
+                          : LabelSettingTileContext.label,
+                      setting: entry.value,
+                      onChanged: (setting) =>
+                          _updateLabelPreference(entry.key, setting),
+                      labelName: strings?.name,
+                      labelDescription: strings?.description,
+                      disabledMessage: configuredGlobally
+                          ? l10n.moderationConfiguredGlobally
+                          : null,
+                      enabled:
+                          !_isSaving &&
+                          !configuredGlobally &&
+                          (!(definition?.adultOnly ?? false) ||
+                              adultContentEnabled),
                     );
                   }),
 
diff --git a/lib/src/features/settings/ui/pages/labeler_management_page.dart b/lib/src/features/settings/ui/pages/labeler_management_page.dart
index 56ec953b..9b23a1cc 100644
--- a/lib/src/features/settings/ui/pages/labeler_management_page.dart
+++ b/lib/src/features/settings/ui/pages/labeler_management_page.dart
@@ -10,7 +10,7 @@ import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/design_system/components/atoms/user_avatar.dart';
 import 'package:spark/src/core/utils/logging/logging.dart';
-import 'package:spark/src/features/settings/providers/settings_provider.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 
 @RoutePage()
@@ -50,8 +50,9 @@ class _LabelerManagementPageState extends ConsumerState<LabelerManagementPage>
   Future<void> _loadLabelers() async {
     try {
       setState(() => _isLoading = true);
-      final settings = ref.read(settingsProvider.notifier);
-      final labelerDids = await settings.getLabelers();
+      final labelerDids = await ref
+          .read(labelerSettingsControllerProvider)
+          .getLabelers();
 
       setState(() {
         _labelerDids = labelerDids;
@@ -142,26 +143,19 @@ class _LabelerManagementPageState extends ConsumerState<LabelerManagementPage>
       if (result == null || result.isEmpty) {
         return;
       }
-      final did = result.trim();
-
-      // If it's a handle, try to resolve it to a DID
-      if (did.startsWith('@')) {
-        // TODO: add handle resolution in the future
-        return;
-      }
-
-      // Validate DID format
-      if (!did.startsWith('did:')) {
-        return;
-      }
-
-      final settings = ref.read(settingsProvider.notifier);
-      await settings.addLabeler(did);
+      await ref
+          .read(labelerSettingsControllerProvider)
+          .addLabeler(result.trim());
 
       // Refresh the list
       await _loadLabelers();
     } catch (e) {
       _logger.e('Error adding labeler: $e');
+      if (mounted) {
+        ScaffoldMessenger.of(
+          context,
+        ).showSnackBar(SnackBar(content: Text(l10n.errorAddingLabeler)));
+      }
     } finally {
       didController.dispose();
     }
@@ -194,8 +188,7 @@ class _LabelerManagementPageState extends ConsumerState<LabelerManagementPage>
     if (confirmed != true) return;
 
     try {
-      final settings = ref.read(settingsProvider.notifier);
-      await settings.removeLabeler(did);
+      await ref.read(labelerSettingsControllerProvider).removeLabeler(did);
 
       // Refresh the list
       await _loadLabelers();
diff --git a/lib/src/features/settings/ui/pages/moderation_page.dart b/lib/src/features/settings/ui/pages/moderation_page.dart
new file mode 100644
index 00000000..7b183cea
--- /dev/null
+++ b/lib/src/features/settings/ui/pages/moderation_page.dart
@@ -0,0 +1,205 @@
+import 'package:auto_route/auto_route.dart';
+import 'package:fluentui_system_icons/fluentui_system_icons.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:get_it/get_it.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/app_leading_button.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/routing/app_router.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/ui/widgets/widgets.dart';
+
+@RoutePage()
+class ModerationPage extends ConsumerStatefulWidget {
+  const ModerationPage({super.key});
+
+  @override
+  ConsumerState<ModerationPage> createState() => _ModerationPageState();
+}
+
+class _ModerationPageState extends ConsumerState<ModerationPage> {
+  static const _adultLabels = ['porn', 'sexual', 'graphic-media', 'nudity'];
+  bool _isSaving = false;
+
+  Future<void> _setAdultContentEnabled(bool enabled) async {
+    if (_isSaving) return;
+    final l10n = AppLocalizations.of(context);
+    final logger = GetIt.instance<LogService>().getLogger('ModerationPage');
+    setState(() => _isSaving = true);
+
+    try {
+      await ref
+          .read(userPreferencesProvider.notifier)
+          .setAdultContentEnabled(enabled);
+    } catch (error, stackTrace) {
+      logger.e(
+        'Failed to update adult content preference',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      if (!mounted) return;
+      ScaffoldMessenger.of(
+        context,
+      ).showSnackBar(SnackBar(content: Text(l10n.errorGeneric)));
+    } finally {
+      if (mounted) setState(() => _isSaving = false);
+    }
+  }
+
+  Future<void> _setGlobalLabelPreference(
+    String label,
+    ModerationSetting setting,
+  ) async {
+    if (_isSaving) return;
+    final l10n = AppLocalizations.of(context);
+    final logger = GetIt.instance<LogService>().getLogger('ModerationPage');
+    setState(() => _isSaving = true);
+
+    try {
+      await ref
+          .read(userPreferencesProvider.notifier)
+          .setGlobalLabelPreference(label, setting);
+    } catch (error, stackTrace) {
+      logger.e(
+        'Failed to update global label preference for $label',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      if (!mounted) return;
+      ScaffoldMessenger.of(
+        context,
+      ).showSnackBar(SnackBar(content: Text(l10n.errorGeneric)));
+    } finally {
+      if (mounted) setState(() => _isSaving = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context);
+    final preferences = ref.watch(userPreferencesProvider).asData?.value;
+    final colorScheme = Theme.of(context).colorScheme;
+    final adultContentEnabled = preferences?.adultContentEnabled ?? false;
+
+    return Scaffold(
+      backgroundColor: colorScheme.surface,
+      appBar: AppBar(
+        backgroundColor: colorScheme.surface,
+        elevation: 0,
+        leading: const AppLeadingButton(),
+        title: Text(l10n.pageTitleModeration),
+        centerTitle: true,
+      ),
+      body: ListView(
+        padding: EdgeInsets.zero,
+        children: [
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+            child: Material(
+              key: const Key('adult-content-settings-group'),
+              color: colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+              borderRadius: BorderRadius.circular(12),
+              clipBehavior: Clip.antiAlias,
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+                  SwitchListTile.adaptive(
+                    title: Text(
+                      l10n.settingAdultContent,
+                      style: const TextStyle(
+                        fontSize: 16,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    subtitle: Text(l10n.settingAdultContentDescription),
+                    value: adultContentEnabled,
+                    onChanged: preferences == null || _isSaving
+                        ? null
+                        : _setAdultContentEnabled,
+                  ),
+                  if (adultContentEnabled) ...[
+                    const Divider(height: 1),
+                    for (final label in _adultLabels) ...[
+                      Builder(
+                        builder: (context) {
+                          final definition =
+                              builtInLabelDefinitionsByValue[label]!;
+                          final strings = definition.localizedStrings(l10n)!;
+                          return LabelSettingTile(
+                            key: Key('global-label-$label'),
+                            label: label,
+                            labelName: strings.name,
+                            labelDescription: strings.description,
+                            controlContext:
+                                LabelSettingTileContext.adultContentFilter,
+                            setting: _effectiveSetting(
+                              preferences!,
+                              definition,
+                            ),
+                            enabled: !_isSaving,
+                            onChanged: (setting) =>
+                                _setGlobalLabelPreference(label, setting),
+                          );
+                        },
+                      ),
+                    ],
+                    const SizedBox(height: 10),
+                  ],
+                ],
+              ),
+            ),
+          ),
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+            child: Material(
+              color: colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+              borderRadius: BorderRadius.circular(12),
+              clipBehavior: Clip.antiAlias,
+              child: ListTile(
+                splashColor: Colors.transparent,
+                title: Text(
+                  l10n.pageTitleLabelers,
+                  style: const TextStyle(
+                    fontSize: 16,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+                trailing: const Icon(FluentIcons.tag_24_regular),
+                onTap: () =>
+                    context.router.push(const LabelerManagementRoute()),
+                contentPadding: const EdgeInsets.symmetric(
+                  horizontal: 16,
+                  vertical: 4,
+                ),
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  ModerationSetting _effectiveSetting(
+    Preferences preferences,
+    ModerationLabelDefinition definition,
+  ) {
+    ModerationSetting? sourceSetting;
+    for (final preference
+        in preferences.contentLabelPrefs ?? const <ContentLabelPref>[]) {
+      if (preference.label != definition.identifier) continue;
+      final setting = switch (preference.visibility.toJson()) {
+        'hide' => ModerationSetting.hide,
+        'warn' => ModerationSetting.warn,
+        _ => ModerationSetting.ignore,
+      };
+      if (preference.labelerDid == null) return setting;
+      if (preference.labelerDid == definition.definedBy) {
+        sourceSetting = setting;
+      }
+    }
+    return sourceSetting ?? definition.defaultSetting;
+  }
+}
diff --git a/lib/src/features/settings/ui/pages/settings_page.dart b/lib/src/features/settings/ui/pages/settings_page.dart
index 51faeb26..8ae51c8c 100644
--- a/lib/src/features/settings/ui/pages/settings_page.dart
+++ b/lib/src/features/settings/ui/pages/settings_page.dart
@@ -143,15 +143,14 @@ class _SettingsPageState extends ConsumerState<SettingsPage> {
               child: ListTile(
                 splashColor: Colors.transparent,
                 title: Text(
-                  l10n.pageTitleLabelers,
+                  l10n.pageTitleModeration,
                   style: const TextStyle(
                     fontSize: 16,
                     fontWeight: FontWeight.bold,
                   ),
                 ),
-                trailing: const Icon(FluentIcons.tag_24_regular),
-                onTap: () =>
-                    context.router.push(const LabelerManagementRoute()),
+                trailing: const Icon(FluentIcons.shield_24_regular),
+                onTap: () => context.router.push(const ModerationRoute()),
                 contentPadding: const EdgeInsets.symmetric(
                   horizontal: 16,
                   vertical: 4,
diff --git a/lib/src/features/settings/ui/widgets/label_setting_tile.dart b/lib/src/features/settings/ui/widgets/label_setting_tile.dart
index f75432b1..f645ece2 100644
--- a/lib/src/features/settings/ui/widgets/label_setting_tile.dart
+++ b/lib/src/features/settings/ui/widgets/label_setting_tile.dart
@@ -1,137 +1,92 @@
 import 'package:flutter/material.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/design_system/components/atoms/surfaces/app_surface.dart';
+import 'package:spark/src/core/design_system/components/molecules/app_choice_group.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+
+enum LabelSettingTileContext { adultContentFilter, label, informLabel }
 
 class LabelSettingTile extends StatelessWidget {
   const LabelSettingTile({
     required this.label,
-    required this.preference,
-    required this.onPreferenceUpdate,
+    required this.setting,
+    required this.onChanged,
+    required this.controlContext,
     this.labelName,
     this.labelDescription,
-    this.showSeverity = true,
+    this.disabledMessage,
+    this.enabled = true,
     super.key,
   });
   final String label;
-  final LabelPreference preference;
-  final Future<void> Function(
-    String label, {
-    Setting? setting,
-    Blurs? blurs,
-    Severity? severity,
-  })
-  onPreferenceUpdate;
+  final ModerationSetting setting;
+  final ValueChanged<ModerationSetting> onChanged;
+  final LabelSettingTileContext controlContext;
   final String? labelName;
   final String? labelDescription;
-  final bool showSeverity;
+  final String? disabledMessage;
+  final bool enabled;
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
+    final l10n = AppLocalizations.of(context);
+    final (ignoreLabel, warnLabel) = switch (controlContext) {
+      LabelSettingTileContext.adultContentFilter => (
+        l10n.labelShow,
+        l10n.labelWarn,
+      ),
+      LabelSettingTileContext.label => (l10n.labelOff, l10n.labelWarn),
+      LabelSettingTileContext.informLabel => (l10n.labelOff, l10n.labelBadge),
+    };
+    final actions = <AppChoiceOption<ModerationSetting>>[
+      AppChoiceOption(value: ModerationSetting.ignore, label: ignoreLabel),
+      AppChoiceOption(value: ModerationSetting.warn, label: warnLabel),
+      AppChoiceOption(value: ModerationSetting.hide, label: l10n.labelHide),
+    ];
 
-    return Card(
-      margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-      child: Padding(
-        padding: const EdgeInsets.all(16),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            // Title and description
+    return AppSurface(
+      margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 6),
+      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            labelName ?? label,
+            style: TextStyle(
+              fontWeight: FontWeight.w600,
+              color: colorScheme.onSurface,
+            ),
+          ),
+          if (labelDescription != null) ...[
             Text(
-              labelName ?? label,
+              labelDescription!,
               style: TextStyle(
-                fontWeight: FontWeight.w600,
-                color: colorScheme.onSurface,
+                color: colorScheme.onSurface.withAlpha(200),
+                fontSize: 12,
               ),
             ),
-            if (labelDescription != null) ...[
-              const SizedBox(height: 4),
-              Text(
-                labelDescription!,
-                style: TextStyle(
-                  color: colorScheme.onSurface.withAlpha(200),
-                  fontSize: 12,
-                ),
+          ],
+          if (disabledMessage != null) ...[
+            const SizedBox(height: 4),
+            Text(
+              disabledMessage!,
+              style: TextStyle(
+                color: colorScheme.onSurfaceVariant,
+                fontSize: 12,
+                fontStyle: FontStyle.italic,
               ),
-            ],
-            const SizedBox(height: 16),
-            Row(
-              children: Setting.values.map((setting) {
-                final isSelected = preference.setting == setting;
-                return Expanded(
-                  child: Padding(
-                    padding: const EdgeInsets.symmetric(horizontal: 4),
-                    child: ElevatedButton(
-                      onPressed: () =>
-                          onPreferenceUpdate(label, setting: setting),
-                      style: ElevatedButton.styleFrom(
-                        backgroundColor: isSelected
-                            ? colorScheme.primary
-                            : colorScheme.surface,
-                        foregroundColor: isSelected
-                            ? colorScheme.onPrimary
-                            : colorScheme.onSurface,
-                        elevation: isSelected ? 2 : 0,
-                        side: BorderSide(
-                          color: colorScheme.outline,
-                          width: 0.5,
-                        ),
-                      ),
-                      child: Text(
-                        setting.value.toUpperCase(),
-                        style: const TextStyle(fontSize: 12),
-                      ),
-                    ),
-                  ),
-                );
-              }).toList(),
             ),
-
-            // Severity Settings (only show if showSeverity is true)
-            if (showSeverity) ...[
-              const SizedBox(height: 16),
-              Text(
-                'Severity Level',
-                style: TextStyle(
-                  fontWeight: FontWeight.w600,
-                  color: colorScheme.onSurface,
-                ),
-              ),
-              const SizedBox(height: 8),
-              Row(
-                children: Severity.values.map((sev) {
-                  final isSelected = preference.severity == sev;
-                  return Expanded(
-                    child: Padding(
-                      padding: const EdgeInsets.symmetric(horizontal: 4),
-                      child: ElevatedButton(
-                        onPressed: () =>
-                            onPreferenceUpdate(label, severity: sev),
-                        style: ElevatedButton.styleFrom(
-                          backgroundColor: isSelected
-                              ? colorScheme.tertiary
-                              : colorScheme.surface,
-                          foregroundColor: isSelected
-                              ? colorScheme.onTertiary
-                              : colorScheme.onSurface,
-                          elevation: isSelected ? 2 : 0,
-                          side: BorderSide(
-                            color: colorScheme.outline,
-                            width: 0.5,
-                          ),
-                        ),
-                        child: Text(
-                          sev.value.toUpperCase(),
-                          style: const TextStyle(fontSize: 10),
-                        ),
-                      ),
-                    ),
-                  );
-                }).toList(),
-              ),
-            ],
           ],
-        ),
+          const SizedBox(height: 8),
+          AppChoiceGroup<ModerationSetting>(
+            value: setting,
+            options: actions,
+            enabled: enabled,
+            onChanged: onChanged,
+          ),
+        ],
       ),
     );
   }
diff --git a/lib/src/features/settings/ui/widgets/settings_feed_card.dart b/lib/src/features/settings/ui/widgets/settings_feed_card.dart
index ef97b375..05ed4447 100644
--- a/lib/src/features/settings/ui/widgets/settings_feed_card.dart
+++ b/lib/src/features/settings/ui/widgets/settings_feed_card.dart
@@ -7,6 +7,8 @@ import 'package:spark/src/core/design_system/tokens/colors.dart';
 import 'package:spark/src/core/design_system/tokens/shapes.dart';
 import 'package:spark/src/core/design_system/tokens/typography.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/features/settings/providers/settings_provider.dart';
 
@@ -91,7 +93,7 @@ class SettingsFeedCard extends ConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final l10n = AppLocalizations.of(context);
 
-    return _SettingsFeedCardView(
+    final card = _SettingsFeedCardView(
       title: _getTitle(l10n),
       subtitle: _getSubtitle(l10n),
       avatarUrl: _generator?.avatar?.toString() ?? '',
@@ -112,6 +114,13 @@ class SettingsFeedCard extends ConsumerWidget {
           ? (liked) => _setLiked(context, ref, liked: liked)
           : null,
     );
+    final generator = _generator;
+    if (generator == null) return card;
+    return ModeratedContent(
+      subject: feedGeneratorModerationSubject(generator),
+      context: ModerationContext.contentList,
+      child: card,
+    );
   }
 }
 
diff --git a/lib/src/features/sound/ui/pages/sound_page.dart b/lib/src/features/sound/ui/pages/sound_page.dart
index e31cbd02..a7da4f11 100644
--- a/lib/src/features/sound/ui/pages/sound_page.dart
+++ b/lib/src/features/sound/ui/pages/sound_page.dart
@@ -6,6 +6,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/atoms/buttons/app_leading_button.dart';
 import 'package:spark/src/core/design_system/components/molecules/post_tile.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/sound/providers/sound_page_provider.dart';
@@ -62,17 +64,26 @@ class _SoundPageState extends ConsumerState<SoundPage> {
         leading: const AppLeadingButton(),
         actions: [
           soundState.maybeWhen(
-            data: (state) => IconButton(
-              tooltip: l10n.buttonAddSound,
-              onPressed: state.audio.audio == null
-                  ? null
-                  : () => context.router.push(
-                      RecordingRoute(
-                        storyMode: false,
-                        initialSound: state.audio,
+            data: (state) => ModeratedContent(
+              subject: ModerationSubject.content(
+                labels: state.audio.labels ?? const [],
+                authorLabels: state.audio.author.labels ?? const [],
+                subjectDid: state.audio.author.did,
+              ),
+              context: ModerationContext.contentView,
+              presentation: const ModerationPresentation.compact(),
+              child: IconButton(
+                tooltip: l10n.buttonAddSound,
+                onPressed: state.audio.audio == null
+                    ? null
+                    : () => context.router.push(
+                        RecordingRoute(
+                          storyMode: false,
+                          initialSound: state.audio,
+                        ),
                       ),
-                    ),
-              icon: const Icon(FluentIcons.camera_24_regular),
+                icon: const Icon(FluentIcons.camera_24_regular),
+              ),
             ),
             orElse: () => const SizedBox(width: 48),
           ),
@@ -86,7 +97,17 @@ class _SoundPageState extends ConsumerState<SoundPage> {
             controller: _scrollController,
             slivers: [
               // Header Card
-              SliverToBoxAdapter(child: SoundHeaderCard(audio: state.audio)),
+              SliverToBoxAdapter(
+                child: ModeratedContent(
+                  subject: ModerationSubject.content(
+                    labels: state.audio.labels ?? const [],
+                    authorLabels: state.audio.author.labels ?? const [],
+                    subjectDid: state.audio.author.did,
+                  ),
+                  context: ModerationContext.contentView,
+                  child: SoundHeaderCard(audio: state.audio),
+                ),
+              ),
 
               // Posts Grid
               if (state.posts.isEmpty)
@@ -140,10 +161,19 @@ class _SoundPageState extends ConsumerState<SoundPage> {
                         }
 
                         final post = state.posts[index];
-                        return _SoundPostTile(
-                          post: post,
-                          onTap: () => context.router.push(
-                            StandalonePostRoute(postUri: post.uri.toString()),
+                        return ModeratedContent(
+                          subject: ModerationSubject.content(
+                            labels: post.labels ?? const [],
+                            authorLabels: post.author.labels ?? const [],
+                            subjectDid: post.author.did,
+                          ),
+                          context: ModerationContext.contentList,
+                          presentation: const ModerationPresentation.compact(),
+                          child: _SoundPostTile(
+                            post: post,
+                            onTap: () => context.router.push(
+                              StandalonePostRoute(postUri: post.uri.toString()),
+                            ),
                           ),
                         );
                       },
diff --git a/lib/src/features/sound/ui/widgets/audio_track_list_section.dart b/lib/src/features/sound/ui/widgets/audio_track_list_section.dart
index ce092385..bb995c47 100644
--- a/lib/src/features/sound/ui/widgets/audio_track_list_section.dart
+++ b/lib/src/features/sound/ui/widgets/audio_track_list_section.dart
@@ -5,6 +5,9 @@ import 'package:spark/src/core/design_system/components/atoms/buttons/interactiv
 import 'package:spark/src/core/design_system/tokens/colors.dart';
 import 'package:spark/src/core/design_system/tokens/typography.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/models.dart';
 import 'package:spark/src/features/sound/models/sound_audio_track.dart';
 import 'package:spark/src/features/sound/providers/sound_picker_search_provider.dart';
 import 'package:spark/src/features/sound/providers/sound_picker_search_state.dart';
@@ -68,12 +71,16 @@ class _AudioTrackListSectionState extends ConsumerState<AudioTrackListSection> {
   @override
   Widget build(BuildContext context) {
     final state = ref.watch(soundPickerSearchProvider);
-    final audioTracks = audioViewsToAudioTracks(state.audios);
+    final audioTracks = <({AudioView? audio, AudioTrack track})>[
+      for (final audio in state.audios)
+        if (audioViewToAudioTrack(audio) case final track?)
+          (audio: audio, track: track),
+    ];
     final selectedTrack = widget.selectedTrack;
     final tracks =
         selectedTrack != null &&
-            !audioTracks.any((track) => track.id == selectedTrack.id)
-        ? [selectedTrack, ...audioTracks]
+            !audioTracks.any((item) => item.track.id == selectedTrack.id)
+        ? [(audio: null, track: selectedTrack), ...audioTracks]
         : audioTracks;
 
     return Column(
@@ -122,7 +129,7 @@ class _AudioTrackListSectionState extends ConsumerState<AudioTrackListSection> {
   Widget _buildTrackList(
     BuildContext context,
     SoundPickerSearchState state,
-    List<AudioTrack> tracks,
+    List<({AudioView? audio, AudioTrack track})> tracks,
   ) {
     if (state.isLoading && tracks.isEmpty) {
       return const Center(child: CircularProgressIndicator());
@@ -155,8 +162,9 @@ class _AudioTrackListSectionState extends ConsumerState<AudioTrackListSection> {
           );
         }
 
-        final audioTrack = tracks[index];
-        return Padding(
+        final item = tracks[index];
+        final audioTrack = item.track;
+        final tile = Padding(
           padding: const EdgeInsets.only(bottom: 8),
           child: AudioTrackSelectionTile(
             audioTrack: audioTrack,
@@ -165,6 +173,18 @@ class _AudioTrackListSectionState extends ConsumerState<AudioTrackListSection> {
             onTap: () => widget.onTrackSelected(audioTrack),
           ),
         );
+        final audio = item.audio;
+        if (audio == null) return tile;
+        return ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: audio.labels ?? const [],
+            authorLabels: audio.author.labels ?? const [],
+            subjectDid: audio.author.did,
+          ),
+          context: ModerationContext.contentList,
+          presentation: const ModerationPresentation.compact(),
+          child: tile,
+        );
       },
     );
   }
diff --git a/lib/src/features/stories/providers/stories_by_author.dart b/lib/src/features/stories/providers/stories_by_author.dart
index 54f66d00..1b5ffd65 100644
--- a/lib/src/features/stories/providers/stories_by_author.dart
+++ b/lib/src/features/stories/providers/stories_by_author.dart
@@ -1,5 +1,5 @@
 import 'package:riverpod_annotation/riverpod_annotation.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/features/stories/providers/story_repository_provider.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 
@@ -7,7 +7,10 @@ part 'stories_by_author.g.dart';
 
 @riverpod
 FutureOr<
-  ({Map<ProfileViewBasic, List<StoryView>> storiesByAuthor, String? cursor})
+  ({
+    Map<ProfileViewBasic, List<ModeratedStoryView>> storiesByAuthor,
+    String? cursor,
+  })
 >
 storiesByAuthor(Ref ref, {int limit = 30, String? cursor}) async {
   final repository = ref.read(storyRepositoryProvider);
diff --git a/lib/src/features/stories/providers/story_manager_provider.dart b/lib/src/features/stories/providers/story_manager_provider.dart
index 1714db99..876232bb 100644
--- a/lib/src/features/stories/providers/story_manager_provider.dart
+++ b/lib/src/features/stories/providers/story_manager_provider.dart
@@ -2,7 +2,7 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:get_it/get_it.dart';
 import 'package:poptart/poptart.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/story_repository.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
@@ -23,12 +23,12 @@ class StoryManagerState {
     this.isLoading = false,
     this.error,
   });
-  final List<StoryView> stories; // hydrated story views
+  final List<ModeratedStoryView> stories;
   final bool isLoading;
   final String? error;
 
   StoryManagerState copyWith({
-    List<StoryView>? stories,
+    List<ModeratedStoryView>? stories,
     bool? isLoading,
     String? error,
   }) {
@@ -97,12 +97,12 @@ class StoryManager extends _$StoryManager {
     state = await AsyncValue.guard(_loadInitial);
   }
 
-  Future<void> deleteStory(StoryView story) async {
+  Future<void> deleteStory(ModeratedStoryView story) async {
     final current = state.value;
     if (current == null) return;
     try {
       // Optimistic update
-      final updatedList = List<StoryView>.from(current.stories)
+      final updatedList = List<ModeratedStoryView>.from(current.stories)
         ..removeWhere((s) => s.uri == story.uri);
       state = AsyncData(current.copyWith(stories: updatedList));
       await _repository.deleteStoryRecord(story.uri);
diff --git a/lib/src/features/stories/ui/pages/all_stories_page.dart b/lib/src/features/stories/ui/pages/all_stories_page.dart
index be8a289d..346697ef 100644
--- a/lib/src/features/stories/ui/pages/all_stories_page.dart
+++ b/lib/src/features/stories/ui/pages/all_stories_page.dart
@@ -2,7 +2,7 @@ import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/features/stories/ui/pages/author_stories_page.dart';
 
 @RoutePage()
@@ -14,7 +14,7 @@ class AllStoriesPage extends StatefulWidget {
     this.initialStoryIndex,
   });
 
-  final Map<ProfileViewBasic, List<StoryView>> storiesByAuthor;
+  final Map<ProfileViewBasic, List<ModeratedStoryView>> storiesByAuthor;
   final int initialAuthorIndex;
   final int? initialStoryIndex;
 
@@ -24,7 +24,8 @@ class AllStoriesPage extends StatefulWidget {
 
 class _AllStoriesPageState extends State<AllStoriesPage> {
   late final PageController _pageController;
-  late final List<MapEntry<ProfileViewBasic, List<StoryView>>> _authorsList;
+  late final List<MapEntry<ProfileViewBasic, List<ModeratedStoryView>>>
+  _authorsList;
   int _currentAuthorIndex = 0;
 
   @override
diff --git a/lib/src/features/stories/ui/pages/author_stories_page.dart b/lib/src/features/stories/ui/pages/author_stories_page.dart
index b42178bc..e083be6f 100644
--- a/lib/src/features/stories/ui/pages/author_stories_page.dart
+++ b/lib/src/features/stories/ui/pages/author_stories_page.dart
@@ -4,7 +4,8 @@ import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/core/design_system/components/atoms/user_avatar.dart';
 import 'package:spark/src/features/stories/ui/pages/story_page.dart';
@@ -21,7 +22,7 @@ class AuthorStoriesPage extends ConsumerStatefulWidget {
   });
 
   final ProfileViewBasic author;
-  final List<StoryView> stories;
+  final List<ModeratedStoryView> stories;
   final int initialStoryIndex;
 
   /// Called when the user attempts to go to a previous story but is already at
@@ -42,11 +43,13 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
   late final PageController _pageController;
   late final List<AnimationController> _progressControllers;
   late final List<bool> _storyLoadingStates;
+  late final List<bool?> _storyConcealedStates;
   int _currentStoryIndex = 0;
   double _dragOffset = 0;
   double _dragScale = 1;
   bool _isDragging = false;
   bool _isCurrentStoryLoading = true;
+  bool _isCurrentStoryConcealed = true;
 
   @override
   void initState() {
@@ -75,6 +78,7 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
       (_) => AnimationController(duration: _defaultStoryDuration, vsync: this),
     );
     _storyLoadingStates = List<bool>.filled(widget.stories.length, true);
+    _storyConcealedStates = List<bool?>.filled(widget.stories.length, null);
   }
 
   void _onStoryDurationChanged(int index, Duration duration) {
@@ -94,6 +98,7 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
   }
 
   void _startProgressForCurrentStory() {
+    if (_isCurrentStoryLoading || _isCurrentStoryConcealed) return;
     final storyIndex = _currentStoryIndex;
     final controller = _progressControllers[storyIndex];
     controller.forward().whenComplete(() {
@@ -112,11 +117,22 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
   void _resume() {
     final controller = _progressControllers[_currentStoryIndex];
     if (controller.status != AnimationStatus.completed &&
-        !_isCurrentStoryLoading) {
+        !_isCurrentStoryLoading &&
+        !_isCurrentStoryConcealed &&
+        !controller.isAnimating) {
       _startProgressForCurrentStory();
     }
   }
 
+  void _onStoryConcealChanged(int index, bool concealed) {
+    if (index < 0 || index >= _storyConcealedStates.length) return;
+    _storyConcealedStates[index] = concealed;
+    if (index != _currentStoryIndex) return;
+
+    _isCurrentStoryConcealed = concealed;
+    if (concealed) _pause();
+  }
+
   void _onStoryLoadingStateChanged(int index, bool isLoading) {
     if (index < 0 || index >= _storyLoadingStates.length) return;
     _storyLoadingStates[index] = isLoading;
@@ -132,7 +148,8 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
       } else {
         final controller = _progressControllers[_currentStoryIndex];
         if (controller.status != AnimationStatus.completed &&
-            !controller.isAnimating) {
+            !controller.isAnimating &&
+            !_isCurrentStoryConcealed) {
           _startProgressForCurrentStory();
         }
       }
@@ -236,7 +253,7 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
     });
   }
 
-  String _timeAgo(StoryView story) {
+  String _timeAgo(ModeratedStoryView story) {
     final now = DateTime.now();
     final diff = now.difference(story.indexedAt);
     if (diff.inDays > 0) return '${diff.inDays}d';
@@ -279,8 +296,11 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
                         setState(() {
                           _currentStoryIndex = index;
                           _isCurrentStoryLoading = _storyLoadingStates[index];
+                          _isCurrentStoryConcealed =
+                              _storyConcealedStates[index] != false;
                         });
-                        if (!_isCurrentStoryLoading) {
+                        if (!_isCurrentStoryLoading &&
+                            !_isCurrentStoryConcealed) {
                           _startProgressForCurrentStory();
                         }
                       }
@@ -289,12 +309,15 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
                       final story = widget.stories[index];
                       return StoryPage(
                         story: story,
+                        isActive: index == _currentStoryIndex,
                         onLoadingStateChanged: (isLoading) =>
                             _onStoryLoadingStateChanged(index, isLoading),
                         onStoryDurationChanged: (duration) =>
                             _onStoryDurationChanged(index, duration),
                         onPauseRequested: _pause,
                         onResumeRequested: _resume,
+                        onConcealChanged: (concealed) =>
+                            _onStoryConcealChanged(index, concealed),
                         onPrevious: _previousStory,
                         onNext: _nextStory,
                       );
@@ -353,9 +376,19 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
                               ),
                             );
                           },
-                          child: UserAvatar(
-                            imageUrl: widget.author.avatar?.toString() ?? '',
-                            size: 40,
+                          child: ModeratedProfileAvatar(
+                            labels:
+                                widget.author.labels ??
+                                widget
+                                    .stories[_currentStoryIndex]
+                                    .author
+                                    .labels ??
+                                const [],
+                            subjectDid: widget.author.did,
+                            child: UserAvatar(
+                              imageUrl: widget.author.avatar?.toString() ?? '',
+                              size: 40,
+                            ),
                           ),
                         ),
                         const SizedBox(width: 12),
diff --git a/lib/src/features/stories/ui/pages/story_manager_page.dart b/lib/src/features/stories/ui/pages/story_manager_page.dart
index fc0e1a5d..6a65904d 100644
--- a/lib/src/features/stories/ui/pages/story_manager_page.dart
+++ b/lib/src/features/stories/ui/pages/story_manager_page.dart
@@ -3,7 +3,6 @@ import 'package:cached_network_image/cached_network_image.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/stories/providers/story_auto_delete_provider.dart';
 import 'package:spark/src/features/stories/providers/story_manager_provider.dart';
diff --git a/lib/src/features/stories/ui/pages/story_page.dart b/lib/src/features/stories/ui/pages/story_page.dart
index 392d3022..66bea6cf 100644
--- a/lib/src/features/stories/ui/pages/story_page.dart
+++ b/lib/src/features/stories/ui/pages/story_page.dart
@@ -5,7 +5,10 @@ import 'package:cached_network_image/cached_network_image.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/widgets.dart' as flutter_widgets show Image;
 import 'package:flutter_riverpod/flutter_riverpod.dart';
-import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/network/atproto/data/models/record_models.dart';
 import 'package:spark/src/core/network/atproto/data/models/story_embed_models.dart';
 import 'package:spark/src/core/routing/app_router.dart';
@@ -14,20 +17,24 @@ import 'package:video_player/video_player.dart';
 class StoryPage extends ConsumerStatefulWidget {
   const StoryPage({
     required this.story,
+    required this.isActive,
     super.key,
     this.onLoadingStateChanged,
     this.onStoryDurationChanged,
     this.onPauseRequested,
     this.onResumeRequested,
+    this.onConcealChanged,
     this.onPrevious,
     this.onNext,
   });
 
-  final StoryView story;
+  final ModeratedStoryView story;
+  final bool isActive;
   final ValueChanged<bool>? onLoadingStateChanged;
   final ValueChanged<Duration>? onStoryDurationChanged;
   final VoidCallback? onPauseRequested;
   final VoidCallback? onResumeRequested;
+  final ValueChanged<bool>? onConcealChanged;
   final VoidCallback? onPrevious;
   final VoidCallback? onNext;
 
@@ -42,6 +49,7 @@ class _StoryPageState extends ConsumerState<StoryPage>
   bool _isVideoInitialized = false;
   bool _isImageLoaded = false;
   bool _isLoading = true;
+  bool? _moderationConcealed;
 
   @override
   void initState() {
@@ -62,6 +70,14 @@ class _StoryPageState extends ConsumerState<StoryPage>
   void didUpdateWidget(covariant StoryPage oldWidget) {
     super.didUpdateWidget(oldWidget);
 
+    if (oldWidget.isActive != widget.isActive) {
+      if (widget.isActive) {
+        _applyModerationPlaybackState();
+      } else {
+        _videoController?.pause();
+      }
+    }
+
     // If this page becomes active after being prebuilt, ensure the parent gets
     // the latest loading state immediately.
     if (oldWidget.onLoadingStateChanged != widget.onLoadingStateChanged &&
@@ -106,7 +122,9 @@ class _StoryPageState extends ConsumerState<StoryPage>
           await _videoController!.initialize();
           await _videoController!.setLooping(true);
           widget.onStoryDurationChanged?.call(_resolvedStoryDuration());
-          await _videoController!.play();
+          if (widget.isActive && _moderationConcealed == false) {
+            await _videoController!.play();
+          }
           if (mounted) {
             setState(() {
               _isVideoInitialized = true;
@@ -128,15 +146,15 @@ class _StoryPageState extends ConsumerState<StoryPage>
     }
   }
 
-  bool _isVideoStory(StoryView story) {
+  bool _isVideoStory(ModeratedStoryView story) {
     return story.isVideoStory;
   }
 
-  String _getVideoUrl(StoryView story) {
+  String _getVideoUrl(ModeratedStoryView story) {
     return story.videoUrl;
   }
 
-  String _getImageUrl(StoryView story) {
+  String _getImageUrl(ModeratedStoryView story) {
     final imageUrl = story.imageUrl;
     return imageUrl.isNotEmpty
         ? imageUrl
@@ -244,88 +262,108 @@ class _StoryPageState extends ConsumerState<StoryPage>
       );
     }
 
-    // Wrap the media in a Stack to overlay gradient shadows for readability.
-    return ClipRRect(
-      borderRadius: borderRadius,
-      child: LayoutBuilder(
-        builder: (context, constraints) {
-          final destinationRect = _resolveMediaRect(
-            containerSize: constraints.biggest,
-            sourceSize: sourceSize,
-          );
+    final selfLabels = widget.story.localRecord?.selfLabels ?? const [];
+    final labels = <Label>[
+      ...widget.story.moderationLabels,
+      for (final selfLabel in selfLabels)
+        Label(
+          src: widget.story.author.did,
+          uri: widget.story.uri.toString(),
+          val: selfLabel.val,
+          cts: widget.story.indexedAt,
+        ),
+    ];
 
-          return Stack(
-            fit: StackFit.expand,
-            children: [
-              mediaContent,
-              Positioned(
-                top: 80,
-                bottom: 0,
-                left: 0,
-                width: constraints.maxWidth * 0.3,
-                child: GestureDetector(
-                  behavior: HitTestBehavior.translucent,
-                  onTap: widget.onPrevious,
-                  child: const SizedBox.expand(),
+    return ModeratedContent(
+      subject: ModerationSubject.content(
+        labels: labels,
+        authorLabels: widget.story.author.labels ?? const [],
+        subjectDid: widget.story.author.did,
+      ),
+      context: ModerationContext.contentView,
+      onConcealChanged: _onModerationConcealChanged,
+      child: ClipRRect(
+        borderRadius: borderRadius,
+        child: LayoutBuilder(
+          builder: (context, constraints) {
+            final destinationRect = _resolveMediaRect(
+              containerSize: constraints.biggest,
+              sourceSize: sourceSize,
+            );
+
+            return Stack(
+              fit: StackFit.expand,
+              children: [
+                mediaContent,
+                Positioned(
+                  top: 80,
+                  bottom: 0,
+                  left: 0,
+                  width: constraints.maxWidth * 0.3,
+                  child: GestureDetector(
+                    behavior: HitTestBehavior.translucent,
+                    onTap: widget.onPrevious,
+                    child: const SizedBox.expand(),
+                  ),
                 ),
-              ),
-              Positioned(
-                top: 80,
-                bottom: 0,
-                right: 0,
-                width: constraints.maxWidth * 0.3,
-                child: GestureDetector(
-                  behavior: HitTestBehavior.translucent,
-                  onTap: widget.onNext,
-                  child: const SizedBox.expand(),
+                Positioned(
+                  top: 80,
+                  bottom: 0,
+                  right: 0,
+                  width: constraints.maxWidth * 0.3,
+                  child: GestureDetector(
+                    behavior: HitTestBehavior.translucent,
+                    onTap: widget.onNext,
+                    child: const SizedBox.expand(),
+                  ),
                 ),
-              ),
-              ..._buildMentionEmbeds(destinationRect),
-              // Top shadow overlay
-              Positioned(
-                left: 0,
-                right: 0,
-                top: 0,
-                child: IgnorePointer(
-                  child: Container(
-                    height: 120,
-                    decoration: BoxDecoration(
-                      gradient: LinearGradient(
-                        begin: Alignment.topCenter,
-                        end: Alignment.bottomCenter,
-                        colors: [
-                          Colors.black87.withAlpha(100),
-                          Colors.transparent,
-                        ],
+                ..._buildMentionEmbeds(destinationRect),
+                // Top shadow overlay
+                Positioned(
+                  left: 0,
+                  right: 0,
+                  top: 0,
+                  child: IgnorePointer(
+                    child: Container(
+                      height: 120,
+                      decoration: BoxDecoration(
+                        gradient: LinearGradient(
+                          begin: Alignment.topCenter,
+                          end: Alignment.bottomCenter,
+                          colors: [
+                            Colors.black87.withAlpha(100),
+                            Colors.transparent,
+                          ],
+                        ),
                       ),
                     ),
                   ),
                 ),
-              ),
-              // Bottom shadow overlay
-              Positioned(
-                left: 0,
-                right: 0,
-                bottom: 0,
-                child: IgnorePointer(
-                  child: Container(
-                    height: 120,
-                    decoration: BoxDecoration(
-                      gradient: LinearGradient(
-                        begin: Alignment.bottomCenter,
-                        end: Alignment.topCenter,
-                        colors: [
-                          Colors.black87.withAlpha(100),
-                          Colors.transparent,
-                        ],
+                // Bottom shadow overlay
+                Positioned(
+                  left: 0,
+                  right: 0,
+                  bottom: 0,
+                  child: IgnorePointer(
+                    child: Container(
+                      height: 120,
+                      decoration: BoxDecoration(
+                        gradient: LinearGradient(
+                          begin: Alignment.bottomCenter,
+                          end: Alignment.topCenter,
+                          colors: [
+                            Colors.black87.withAlpha(100),
+                            Colors.transparent,
+                          ],
+                        ),
                       ),
                     ),
                   ),
                 ),
-              ),
-            ],
-          );
-        },
+              ],
+            );
+          },
+        ),
       ),
     );
   }
@@ -407,4 +445,20 @@ class _StoryPageState extends ConsumerState<StoryPage>
     final frame = placement.frame;
     return frame.w > 0 && frame.h > 0;
   }
+
+  void _onModerationConcealChanged(bool concealed) {
+    _moderationConcealed = concealed;
+    widget.onConcealChanged?.call(concealed);
+    if (widget.isActive) _applyModerationPlaybackState();
+  }
+
+  void _applyModerationPlaybackState() {
+    if (_moderationConcealed != false) {
+      _videoController?.pause();
+      widget.onPauseRequested?.call();
+    } else {
+      _videoController?.play();
+      widget.onResumeRequested?.call();
+    }
+  }
 }
diff --git a/lib/src/features/stories/ui/widgets/stories_list.dart b/lib/src/features/stories/ui/widgets/stories_list.dart
index 842560fd..b5cc986c 100644
--- a/lib/src/features/stories/ui/widgets/stories_list.dart
+++ b/lib/src/features/stories/ui/widgets/stories_list.dart
@@ -4,6 +4,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spark/src/core/design_system/components/molecules/story_circle.dart';
 import 'package:spark/src/core/design_system/templates/explore_loading_skeletons.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/routing/app_router.dart';
 import 'package:spark/src/features/auth/providers/auth_providers.dart';
 import 'package:spark/src/features/posting/ui/pages/recording_page.dart';
@@ -103,20 +105,33 @@ class _StoriesListState extends ConsumerState<StoriesList> {
                   final authorEntry = authorsList[index - 1];
                   final author = authorEntry.key;
 
-                  return GestureDetector(
-                    onTap: () {
-                      context.router.push(
-                        AllStoriesRoute(
-                          storiesByAuthor: data.storiesByAuthor,
-                          initialAuthorIndex: index - 1,
+                  return ModeratedContent(
+                    subject: ModerationSubject.profile(
+                      labels: author.labels ?? const [],
+                      subjectDid: author.did,
+                    ),
+                    context: ModerationContext.profileList,
+                    presentation: const ModerationPresentation.compact(),
+                    child: GestureDetector(
+                      onTap: () {
+                        context.router.push(
+                          AllStoriesRoute(
+                            storiesByAuthor: data.storiesByAuthor,
+                            initialAuthorIndex: index - 1,
+                          ),
+                        );
+                      },
+                      child: Padding(
+                        padding: const EdgeInsets.only(right: 12),
+                        child: StoryCircle.story(
+                          userName: author.displayName ?? author.handle,
+                          imageUrl: author.avatar?.toString() ?? '',
+                          avatarBuilder: (avatar) => ModeratedProfileAvatar(
+                            labels: author.labels ?? const [],
+                            subjectDid: author.did,
+                            child: avatar,
+                          ),
                         ),
-                      );
-                    },
-                    child: Padding(
-                      padding: const EdgeInsets.only(right: 12),
-                      child: StoryCircle.story(
-                        userName: author.displayName ?? author.handle,
-                        imageUrl: author.avatar?.toString() ?? '',
                       ),
                     ),
                   );
diff --git a/lib/src/features/stories/utils/story_navigation.dart b/lib/src/features/stories/utils/story_navigation.dart
index 1b41901a..7801d7bf 100644
--- a/lib/src/features/stories/utils/story_navigation.dart
+++ b/lib/src/features/stories/utils/story_navigation.dart
@@ -35,6 +35,7 @@ Future<void> openStoriesForProfile(
       displayName: user.displayName,
       avatar: user.avatar,
       viewer: user.viewer,
+      labels: user.labels,
     );
 
     context.router.push(
diff --git a/pubspec.lock b/pubspec.lock
index 27199d9e..12a4317a 100644
--- a/pubspec.lock
+++ b/pubspec.lock
@@ -181,10 +181,10 @@ packages:
     dependency: "direct main"
     description:
       name: bluesky_poptart
-      sha256: "03d75389a9d7f7e49c92181bff53c779038fdf4c84b64cf39efbea6fc5263906"
+      sha256: "9b1278f11718d4a873bc7e8983a813f55f6e0ff5501db074fb8f1e82d43d247a"
       url: "https://pub.dev"
     source: hosted
-    version: "0.1.3"
+    version: "0.2.0"
   boolean_selector:
     dependency: transitive
     description:
@@ -1160,10 +1160,10 @@ packages:
     dependency: "direct main"
     description:
       name: ozone_poptart
-      sha256: c2abf0eb23b4f522927a87143723e067fda328a73e1f9cc81bbe2e8bfb41a50e
+      sha256: df6df201b8bb3a20e284e139b5b019295e87e2291b3ef6ca743716a5ffc7807b
       url: "https://pub.dev"
     source: hosted
-    version: "0.1.3"
+    version: "0.2.0"
   package_config:
     dependency: transitive
     description:
@@ -1637,10 +1637,10 @@ packages:
     dependency: "direct main"
     description:
       name: sprk_poptart
-      sha256: "49635009231c2a9bd2652502c9ceca5afa7bbfb8a7201ea68588a857306bb382"
+      sha256: ccc71f94d8ca626583f46ed84fe87b58dffd5919b80891b22c2e8d28d876ffb5
       url: "https://pub.dev"
     source: hosted
-    version: "0.1.3"
+    version: "0.2.0"
   sqflite:
     dependency: "direct main"
     description:
diff --git a/pubspec.yaml b/pubspec.yaml
index 51ebe0dc..7c7b1c80 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -18,12 +18,12 @@ dependencies:
   audioplayers: ^6.8.1
   auto_route: ^11.1.0
   better_player_plus: ^1.3.4
-  bluesky_poptart: ^0.1.3
-  ozone_poptart: ^0.1.3
+  bluesky_poptart: ^0.2.0
+  ozone_poptart: ^0.2.0
   plyr_poptart: ^0.1.2
   poptart: ^0.1.2
   poptart_lex: ^0.1.0
-  sprk_poptart: ^0.1.3
+  sprk_poptart: ^0.2.0
   cached_network_image: ^3.4.1
   camera: ^0.12.0+2
   collection: ^1.19.1
diff --git a/test/src/core/design_system/components/app_choice_group_test.dart b/test/src/core/design_system/components/app_choice_group_test.dart
new file mode 100644
index 00000000..c881fe22
--- /dev/null
+++ b/test/src/core/design_system/components/app_choice_group_test.dart
@@ -0,0 +1,129 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/interactive_pressable.dart';
+import 'package:spark/src/core/design_system/components/molecules/app_choice_group.dart';
+
+void main() {
+  testWidgets('renders equal-width choices and reports the selected value', (
+    tester,
+  ) async {
+    String? changedValue;
+
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Scaffold(
+          body: SizedBox(
+            width: 300,
+            child: AppChoiceGroup<String>(
+              value: 'warn',
+              options: const [
+                AppChoiceOption(value: 'off', label: 'Off'),
+                AppChoiceOption(value: 'warn', label: 'Warn'),
+                AppChoiceOption(value: 'hide', label: 'Hide'),
+              ],
+              onChanged: (value) => changedValue = value,
+            ),
+          ),
+        ),
+      ),
+    );
+
+    final choiceMaterials = find.descendant(
+      of: find.byType(AppChoiceGroup<String>),
+      matching: find.byType(Material),
+    );
+    expect(choiceMaterials, findsNWidgets(3));
+    final row = tester.widget<Row>(
+      find.descendant(
+        of: find.byType(AppChoiceGroup<String>),
+        matching: find.byType(Row),
+      ),
+    );
+    expect(row.spacing, 6);
+    expect(
+      tester.getSize(choiceMaterials.at(0)).width,
+      tester.getSize(choiceMaterials.at(1)).width,
+    );
+    expect(
+      tester.getSize(choiceMaterials.at(1)).width,
+      tester.getSize(choiceMaterials.at(2)).width,
+    );
+    expect(tester.widget<Material>(choiceMaterials.at(1)).elevation, 2);
+    expect(tester.widget<Material>(choiceMaterials.at(0)).elevation, 0);
+
+    await tester.tap(
+      find
+          .descendant(
+            of: find.byType(AppChoiceGroup<String>),
+            matching: find.byType(InteractivePressable),
+          )
+          .at(2),
+    );
+    await tester.pump();
+
+    expect(changedValue, 'hide');
+  });
+
+  testWidgets('exposes mutually-exclusive selection semantics', (tester) async {
+    final semanticsHandle = tester.ensureSemantics();
+
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Scaffold(
+          body: AppChoiceGroup<String>(
+            value: 'warn',
+            options: const [
+              AppChoiceOption(value: 'off', label: 'Off'),
+              AppChoiceOption(value: 'warn', label: 'Warn'),
+            ],
+            onChanged: (_) {},
+          ),
+        ),
+      ),
+    );
+
+    final warnSemantics = find.byWidgetPredicate(
+      (widget) => widget is Semantics && widget.properties.label == 'Warn',
+    );
+    final node = tester.getSemantics(warnSemantics);
+
+    expect(node.flagsCollection.isButton, isTrue);
+    expect(node.flagsCollection.isSelected.toBoolOrNull(), isTrue);
+    expect(node.flagsCollection.isInMutuallyExclusiveGroup, isTrue);
+
+    semanticsHandle.dispose();
+  });
+
+  testWidgets('does not report changes when disabled', (tester) async {
+    String? changedValue;
+
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Scaffold(
+          body: AppChoiceGroup<String>(
+            value: 'off',
+            enabled: false,
+            options: const [
+              AppChoiceOption(value: 'off', label: 'Off'),
+              AppChoiceOption(value: 'warn', label: 'Warn'),
+            ],
+            onChanged: (value) => changedValue = value,
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(
+      find
+          .descendant(
+            of: find.byType(AppChoiceGroup<String>),
+            matching: find.byType(InteractivePressable),
+          )
+          .at(1),
+    );
+    await tester.pump();
+
+    expect(changedValue, isNull);
+    expect(find.byType(InteractivePressable), findsNWidgets(2));
+  });
+}
diff --git a/test/src/core/design_system/components/app_surface_test.dart b/test/src/core/design_system/components/app_surface_test.dart
new file mode 100644
index 00000000..281a8387
--- /dev/null
+++ b/test/src/core/design_system/components/app_surface_test.dart
@@ -0,0 +1,35 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spark/src/core/design_system/components/atoms/surfaces/app_surface.dart';
+import 'package:spark/src/core/design_system/tokens/shadows.dart';
+
+void main() {
+  testWidgets('owns outlined and raised surface treatments', (tester) async {
+    await tester.pumpWidget(
+      const MaterialApp(
+        home: Scaffold(
+          body: Column(
+            children: [
+              AppSurface(child: Text('Outlined')),
+              AppSurface(
+                variant: AppSurfaceVariant.raised,
+                child: Text('Raised'),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+
+    final decorations = tester
+        .widgetList<DecoratedBox>(find.byType(DecoratedBox))
+        .map((widget) => widget.decoration)
+        .whereType<BoxDecoration>()
+        .where((decoration) => decoration.border != null)
+        .toList();
+
+    expect(decorations, hasLength(2));
+    expect(decorations[0].boxShadow, isNull);
+    expect(decorations[1].boxShadow, const [AppShadows.shadowXs]);
+  });
+}
diff --git a/test/src/core/design_system/components/profile_card_test.dart b/test/src/core/design_system/components/profile_card_test.dart
index 542b4364..31806fe6 100644
--- a/test/src/core/design_system/components/profile_card_test.dart
+++ b/test/src/core/design_system/components/profile_card_test.dart
@@ -1,8 +1,13 @@
+import 'package:fluentui_system_icons/fluentui_system_icons.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:spark/src/core/design_system/components/atoms/toggles/toggle_button.dart';
+import 'package:spark/src/core/design_system/components/molecules/profile_avatar.dart';
 import 'package:spark/src/core/design_system/components/molecules/profile_card.dart';
+import 'package:spark/src/core/design_system/templates/info_bar_template.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
 
 void main() {
   testWidgets('reports follow and unfollow through one state-change intent', (
@@ -61,6 +66,63 @@ void main() {
     expect(find.text('Follow'), findsNothing);
     expect(find.text('Unfollow'), findsNothing);
   });
+
+  testWidgets('avatar moderation leaves the add-story action outside', (
+    tester,
+  ) async {
+    var addRequests = 0;
+
+    await tester.pumpWidget(
+      ProviderScope(
+        child: _TestApp(
+          child: ProfileAvatar(
+            avatarUrl: null,
+            displayName: 'Alice',
+            showAddButton: true,
+            onAddTap: () => addRequests += 1,
+            avatarBuilder: (avatar) => ModeratedProfileAvatar(
+              labels: const [],
+              subjectDid: 'did:plc:alice',
+              child: avatar,
+            ),
+          ),
+        ),
+      ),
+    );
+
+    final addAction = find.byIcon(FluentIcons.add_24_filled);
+    expect(find.byType(ModeratedProfileAvatar), findsOneWidget);
+    expect(
+      find.ancestor(
+        of: addAction,
+        matching: find.byType(ModeratedProfileAvatar),
+      ),
+      findsNothing,
+    );
+
+    await tester.tap(addAction);
+    await tester.pump();
+    expect(addRequests, 1);
+  });
+
+  testWidgets('info bar forwards its avatar builder to the image seam', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _TestApp(
+        child: InfoBarTemplate(
+          displayName: 'Alice',
+          handle: 'alice.sprk.so',
+          avatarBuilder: (avatar) => KeyedSubtree(
+            key: const Key('moderated-info-bar-avatar'),
+            child: avatar,
+          ),
+        ),
+      ),
+    );
+
+    expect(find.byKey(const Key('moderated-info-bar-avatar')), findsOneWidget);
+  });
 }
 
 class _TestApp extends StatelessWidget {
diff --git a/test/src/core/moderation/moderated_content_test.dart b/test/src/core/moderation/moderated_content_test.dart
new file mode 100644
index 00000000..6434afa4
--- /dev/null
+++ b/test/src/core/moderation/moderated_content_test.dart
@@ -0,0 +1,581 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+
+void main() {
+  testWidgets('conceals labeled content until the engine is available', (
+    tester,
+  ) async {
+    final completer = Completer<ModerationEngine>();
+    var taps = 0;
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          moderationEngineProvider.overrideWith((ref) => completer.future),
+        ],
+        child: _materialApp(
+          ModeratedContent(
+            subject: ModerationSubject.content(
+              labels: [_label('sexual')],
+              subjectDid: null,
+            ),
+            context: ModerationContext.contentView,
+            child: GestureDetector(
+              key: const Key('pending-child'),
+              onTap: () => taps += 1,
+              child: const ColoredBox(
+                color: Colors.pink,
+                child: SizedBox.square(dimension: 100),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.pump();
+
+    await tester.tap(
+      find.byKey(const Key('pending-child')),
+      warnIfMissed: false,
+    );
+    await tester.pump();
+    expect(taps, 0);
+    expect(find.byType(CircularProgressIndicator), findsOneWidget);
+
+    completer.complete(_engine());
+    await tester.pumpAndSettle();
+    expect(find.byType(CircularProgressIndicator), findsNothing);
+  });
+
+  testWidgets('revealed compact content passes taps to its child', (
+    tester,
+  ) async {
+    var taps = 0;
+
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        Center(
+          child: ModeratedContent(
+            subject: ModerationSubject.content(
+              labels: [_label('sexual')],
+              subjectDid: null,
+            ),
+            context: ModerationContext.contentView,
+            presentation: const ModerationPresentation.compact(),
+            child: GestureDetector(
+              key: const Key('compact-child'),
+              onTap: () => taps += 1,
+              child: const ColoredBox(
+                color: Colors.pink,
+                child: SizedBox.square(dimension: 100),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byIcon(Icons.visibility_off_outlined));
+    await tester.pumpAndSettle();
+    await tester.tap(find.byKey(const Key('compact-child')));
+    await tester.pump();
+
+    expect(taps, 1);
+  });
+
+  testWidgets('compact content can blur inside its own frame', (tester) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        Center(
+          child: ModeratedContent(
+            subject: ModerationSubject.content(
+              labels: [_label('sexual')],
+              subjectDid: null,
+            ),
+            context: ModerationContext.contentView,
+            presentation: const ModerationPresentation.compact(
+              blurredChild: SizedBox.square(
+                key: Key('internally-blurred-child'),
+                dimension: 100,
+              ),
+            ),
+            child: const SizedBox.square(
+              key: Key('clear-child'),
+              dimension: 100,
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.byKey(const Key('internally-blurred-child')), findsOneWidget);
+    expect(find.byKey(const Key('clear-child')), findsNothing);
+    expect(find.byType(ImageFiltered), findsNothing);
+
+    await tester.tap(find.byIcon(Icons.visibility_off_outlined));
+    await tester.pumpAndSettle();
+
+    expect(find.byKey(const Key('internally-blurred-child')), findsNothing);
+    expect(find.byKey(const Key('clear-child')), findsOneWidget);
+  });
+
+  testWidgets('concealed compact content can forward taps without revealing', (
+    tester,
+  ) async {
+    var forwardedTaps = 0;
+
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        Center(
+          child: ModeratedContent(
+            subject: ModerationSubject.content(
+              labels: [_label('sexual')],
+              subjectDid: null,
+            ),
+            context: ModerationContext.contentList,
+            presentation: ModerationPresentation.compact(
+              onConcealedTap: () => forwardedTaps += 1,
+              blurredChild: const SizedBox.square(
+                key: Key('still-blurred-child'),
+                dimension: 100,
+              ),
+            ),
+            child: const SizedBox.square(
+              key: Key('clear-child'),
+              dimension: 100,
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byIcon(Icons.visibility_off_outlined));
+    await tester.pump();
+
+    expect(forwardedTaps, 1);
+    expect(find.byKey(const Key('still-blurred-child')), findsOneWidget);
+    expect(find.byKey(const Key('clear-child')), findsNothing);
+  });
+
+  testWidgets('warn content is concealed, revealable, and resets by label', (
+    tester,
+  ) async {
+    final engine = _engine();
+    var labels = [_label('sexual')];
+
+    await tester.pumpWidget(
+      _app(
+        engine,
+        StatefulBuilder(
+          builder: (context, setState) => Column(
+            children: [
+              Expanded(
+                child: ModeratedContent(
+                  subject: ModerationSubject.content(
+                    labels: labels,
+                    subjectDid: 'did:plc:author',
+                  ),
+                  context: ModerationContext.contentView,
+                  child: const ColoredBox(
+                    color: Colors.pink,
+                    child: SizedBox.expand(),
+                  ),
+                ),
+              ),
+              TextButton(
+                onPressed: () => setState(() {
+                  labels = [_label('sexual', source: 'did:plc:labeler')];
+                }),
+                child: const Text('change label'),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('Content warning'), findsOneWidget);
+    expect(find.text('Sexually Suggestive'), findsOneWidget);
+    expect(find.text('View content'), findsOneWidget);
+
+    await tester.tap(find.text('View content'));
+    await tester.pumpAndSettle();
+    expect(find.text('View content'), findsNothing);
+
+    await tester.tap(find.text('change label'));
+    await tester.pumpAndSettle();
+    expect(
+      tester
+          .widget<ModeratedContent>(find.byType(ModeratedContent))
+          .subject
+          .labels
+          .single
+          .src,
+      'did:plc:labeler',
+    );
+    final updatedUi = engine
+        .evaluate(
+          labels,
+          target: ModerationTarget.content,
+          subjectDid: 'did:plc:author',
+        )
+        .forContext(ModerationContext.contentView);
+    expect(updatedUi.blur, isTrue);
+    expect(updatedUi.noOverride, isFalse);
+    expect(find.text('Content warning'), findsOneWidget);
+    expect(find.text('View content'), findsOneWidget);
+  });
+
+  testWidgets('reissued labels require a fresh disclosure', (tester) async {
+    final firstCts = DateTime.utc(2026, 8, 8);
+    final secondCts = DateTime.utc(2026, 8, 9);
+    var labels = [_label('sexual', cid: 'cid-a', cts: firstCts)];
+
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        StatefulBuilder(
+          builder: (context, setState) => Column(
+            children: [
+              Expanded(
+                child: ModeratedContent(
+                  subject: ModerationSubject.content(
+                    labels: labels,
+                    subjectDid: 'did:plc:author',
+                  ),
+                  context: ModerationContext.contentView,
+                  child: const SizedBox.expand(),
+                ),
+              ),
+              TextButton(
+                onPressed: () => setState(() {
+                  labels = [_label('sexual', cid: 'cid-b', cts: firstCts)];
+                }),
+                child: const Text('new revision'),
+              ),
+              TextButton(
+                onPressed: () => setState(() => labels = []),
+                child: const Text('remove label'),
+              ),
+              TextButton(
+                onPressed: () => setState(() {
+                  labels = [_label('sexual', cid: 'cid-b', cts: secondCts)];
+                }),
+                child: const Text('reissue label'),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('View content'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('new revision'));
+    await tester.pumpAndSettle();
+    expect(find.text('View content'), findsOneWidget);
+
+    await tester.tap(find.text('View content'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('remove label'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('reissue label'));
+    await tester.pumpAndSettle();
+    expect(find.text('View content'), findsOneWidget);
+  });
+
+  testWidgets('profile avatars use avatar moderation behavior', (tester) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(adultContentEnabled: false),
+        ModeratedProfileAvatar(
+          labels: [
+            _label(
+              'porn',
+              source: 'did:plc:labeler',
+              uri: 'at://did:plc:author/app.bsky.actor.profile/self',
+            ),
+          ],
+          subjectDid: 'did:plc:author',
+          child: const SizedBox.square(
+            key: Key('profile-avatar'),
+            dimension: 80,
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.byType(ImageFiltered), findsOneWidget);
+    expect(find.byIcon(Icons.visibility_off_outlined), findsOneWidget);
+  });
+
+  testWidgets('built-in label details use app-localized guidance', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: [_label('gore', source: 'did:plc:labeler')],
+            subjectDid: 'did:plc:author',
+          ),
+          context: ModerationContext.contentView,
+          child: const SizedBox.expand(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Why am I seeing this?'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Gore'), findsWidgets);
+    expect(
+      find.text('Graphic depictions of severe injury, blood, or death.'),
+      findsOneWidget,
+    );
+  });
+
+  testWidgets('label details show the moderator handle instead of its DID', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(labelerHandles: const {'did:plc:labeler': 'labeler.test'}),
+        ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: [_label('gore', source: 'did:plc:labeler')],
+            subjectDid: 'did:plc:author',
+          ),
+          context: ModerationContext.contentView,
+          child: const SizedBox.expand(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Why am I seeing this?'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Applied by: @labeler.test'), findsOneWidget);
+    expect(find.textContaining('did:plc:labeler'), findsNothing);
+  });
+
+  testWidgets('does not offer an account appeal for a CID-less record label', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(currentUserDid: 'did:plc:author'),
+        ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: [_label('gore', source: 'did:plc:labeler')],
+            subjectDid: 'did:plc:author',
+          ),
+          context: ModerationContext.contentView,
+          child: const SizedBox.expand(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Why am I seeing this?'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Appeal label'), findsNothing);
+  });
+
+  testWidgets('offers an appeal for an account label without a CID', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(currentUserDid: 'did:plc:author'),
+        ModeratedContent(
+          subject: ModerationSubject.profile(
+            labels: [
+              _label('gore', source: 'did:plc:labeler', uri: 'did:plc:author'),
+            ],
+            subjectDid: 'did:plc:author',
+          ),
+          context: ModerationContext.contentView,
+          child: const SizedBox.expand(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Why am I seeing this?'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Appeal label'), findsOneWidget);
+  });
+
+  testWidgets('inform content stays visible with a moderation badge', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(
+          definitions: {
+            'did:plc:labeler': [
+              LabelValueDefinition(
+                identifier: 'context',
+                severity: LabelValueDefinitionSeverity.valueOf('inform')!,
+                blurs: LabelValueDefinitionBlurs.valueOf('none')!,
+                defaultSetting: LabelValueDefinitionDefaultSetting.valueOf(
+                  'warn',
+                ),
+                locales: const [],
+              ),
+            ],
+          },
+        ),
+        ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: [_label('context', source: 'did:plc:labeler')],
+            subjectDid: null,
+          ),
+          context: ModerationContext.contentView,
+          child: const SizedBox.expand(key: Key('inform-child')),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.byKey(const Key('inform-child')), findsOneWidget);
+    expect(find.byType(ActionChip), findsOneWidget);
+    expect(find.text('Content warning'), findsNothing);
+    expect(find.text('View content'), findsNothing);
+  });
+
+  testWidgets('imperative restriction cannot be revealed', (tester) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        ModeratedContent(
+          subject: ModerationSubject.content(
+            labels: [_label('!hide', source: 'did:plc:labeler')],
+            subjectDid: 'did:plc:author',
+          ),
+          context: ModerationContext.contentView,
+          child: const SizedBox.expand(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('View content'), findsNothing);
+    expect(find.text('This restriction cannot be overridden.'), findsOneWidget);
+  });
+
+  testWidgets('a revealed item is concealed when it becomes non-overridable', (
+    tester,
+  ) async {
+    var engine = _engine();
+    final container = ProviderContainer(
+      overrides: [moderationEngineProvider.overrideWith((ref) async => engine)],
+    );
+    addTearDown(container.dispose);
+
+    await tester.pumpWidget(
+      UncontrolledProviderScope(
+        container: container,
+        child: _materialApp(
+          ModeratedContent(
+            subject: ModerationSubject.content(
+              labels: [_label('sexual')],
+              subjectDid: 'did:plc:author',
+            ),
+            context: ModerationContext.contentView,
+            child: const SizedBox.expand(),
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('View content'));
+    await tester.pumpAndSettle();
+    expect(find.text('Content warning'), findsNothing);
+
+    engine = _engine(adultContentEnabled: false);
+    container.invalidate(moderationEngineProvider);
+    await tester.pumpAndSettle();
+
+    expect(find.text('Content warning'), findsOneWidget);
+    expect(find.text('View content'), findsNothing);
+    expect(find.text('This restriction cannot be overridden.'), findsOneWidget);
+  });
+}
+
+Widget _app(ModerationEngine engine, Widget child) {
+  return ProviderScope(
+    overrides: [moderationEngineProvider.overrideWith((ref) async => engine)],
+    child: _materialApp(child),
+  );
+}
+
+Widget _materialApp(Widget child) {
+  return MaterialApp(
+    localizationsDelegates: AppLocalizations.localizationsDelegates,
+    supportedLocales: AppLocalizations.supportedLocales,
+    home: Scaffold(body: child),
+  );
+}
+
+ModerationEngine _engine({
+  bool adultContentEnabled = true,
+  String? currentUserDid,
+  Map<String, Iterable<LabelValueDefinition>> definitions = const {},
+  Map<String, String> labelerHandles = const {},
+}) {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers({
+      'did:plc:author': const [],
+      'did:plc:labeler': const [],
+      ...definitions,
+    }),
+    preferences: ModerationPreferences(
+      labels: const [],
+      adultContentEnabled: adultContentEnabled,
+      authenticated: true,
+    ),
+    currentUserDid: currentUserDid,
+    labelerHandles: labelerHandles,
+  );
+}
+
+Label _label(
+  String value, {
+  String source = 'did:plc:author',
+  String uri = 'at://did:plc:author/so.sprk.feed.post/example',
+  String? cid,
+  DateTime? cts,
+}) {
+  return Label(
+    src: source,
+    uri: uri,
+    cid: cid,
+    val: value,
+    cts: cts ?? DateTime.utc(2026, 8, 8),
+  );
+}
diff --git a/test/src/core/moderation/moderation_definitions_test.dart b/test/src/core/moderation/moderation_definitions_test.dart
new file mode 100644
index 00000000..155182d7
--- /dev/null
+++ b/test/src/core/moderation/moderation_definitions_test.dart
@@ -0,0 +1,383 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+
+void main() {
+  group('ModerationLabelDefinitions', () {
+    test('resolves definitions by label source and value', () {
+      final definitions = ModerationLabelDefinitions.fromLabelers({
+        'did:plc:alpha': [_lexDefinition('topic', severity: 'alert')],
+        'did:plc:beta': [_lexDefinition('topic', severity: 'inform')],
+      });
+
+      expect(
+        definitions
+            .lookup(_label(src: 'did:plc:alpha', val: 'topic'))
+            ?.severity,
+        ModerationSeverity.alert,
+      );
+      expect(
+        definitions.lookup(_label(src: 'did:plc:beta', val: 'topic'))?.severity,
+        ModerationSeverity.inform,
+      );
+      expect(
+        definitions.lookup(_label(src: 'did:plc:other', val: 'topic')),
+        isNull,
+      );
+    });
+
+    test('falls back to global definitions', () {
+      final definitions = ModerationLabelDefinitions();
+
+      expect(
+        definitions
+            .lookup(_label(src: 'did:plc:any', val: 'sexual'))
+            ?.definedBy,
+        isNull,
+      );
+    });
+
+    test('imperative definitions cannot be replaced by a labeler', () {
+      final definitions = ModerationLabelDefinitions.fromLabelers({
+        'did:plc:labeler': [
+          _lexDefinition('!hide', severity: 'none', blurs: 'none'),
+        ],
+      });
+
+      final result = definitions.lookup(
+        _label(src: 'did:plc:labeler', val: '!hide'),
+      )!;
+      expect(result.definedBy, isNull);
+      expect(result.configurable, isFalse);
+      expect(result.noOverride, isTrue);
+    });
+
+    test(
+      'imperative definitions cannot be replaced by a global definition',
+      () {
+        final replacement = ModerationLabelDefinition(
+          identifier: '!hide',
+          severity: ModerationSeverity.none,
+          blurs: ModerationBlur.none,
+          defaultSetting: ModerationSetting.ignore,
+          configurable: true,
+          flags: const {},
+          locales: const [],
+          behaviors: const {},
+        );
+        final definitions = ModerationLabelDefinitions(
+          definitions: [replacement],
+        );
+
+        expect(definitions.global['!hide'], isNot(same(replacement)));
+        expect(definitions.global['!hide']?.configurable, isFalse);
+      },
+    );
+
+    test('includes current, legacy, and imperative global fallbacks', () {
+      final values = ModerationLabelDefinitions().global.keys;
+
+      expect(
+        values,
+        containsAll([
+          '!hide',
+          '!takedown',
+          '!warn',
+          '!no-promote',
+          '!no-unauthenticated',
+          'porn',
+          'sexual',
+          'nudity',
+          'graphic-media',
+          'gore',
+          'nsfl',
+          'dmca-violation',
+          'doxxing',
+        ]),
+      );
+    });
+
+    test('uses a labeler definition before a same-valued global default', () {
+      final definitions = ModerationLabelDefinitions.fromLabelers({
+        'did:plc:labeler': [
+          _lexDefinition('sexual', severity: 'inform', blurs: 'none'),
+        ],
+      });
+
+      final result = definitions.lookup(
+        _label(src: 'did:plc:labeler', val: 'sexual'),
+      )!;
+      expect(result.definedBy, 'did:plc:labeler');
+      expect(result.severity, ModerationSeverity.inform);
+      expect(result.blurs, ModerationBlur.none);
+    });
+  });
+
+  group('interpretLabelValueDefinition', () {
+    test('preserves metadata and derives protocol flags', () {
+      final result = interpretLabelValueDefinition(
+        _lexDefinition(
+          'custom-adult',
+          severity: 'inform',
+          blurs: 'none',
+          defaultSetting: 'hide',
+          adultOnly: true,
+          locales: const [
+            LabelValueDefinitionStrings(
+              lang: 'fr',
+              name: 'Nom',
+              description: 'Description',
+            ),
+          ],
+        ),
+        definedBy: 'did:plc:labeler',
+      );
+
+      expect(result.identifier, 'custom-adult');
+      expect(result.definedBy, 'did:plc:labeler');
+      expect(result.severity, ModerationSeverity.inform);
+      expect(result.blurs, ModerationBlur.none);
+      expect(result.defaultSetting, ModerationSetting.hide);
+      expect(result.configurable, isTrue);
+      expect(
+        result.flags,
+        containsAll([ModerationLabelFlag.adult, ModerationLabelFlag.noSelf]),
+      );
+      expect(result.locales.single.name, 'Nom');
+    });
+
+    test('defaults an absent or unknown setting to warn', () {
+      expect(
+        interpretLabelValueDefinition(
+          _lexDefinition('absent'),
+          definedBy: 'did:plc:labeler',
+        ).defaultSetting,
+        ModerationSetting.warn,
+      );
+      expect(
+        interpretLabelValueDefinition(
+          _lexDefinition('unknown', defaultSetting: 'surprise'),
+          definedBy: 'did:plc:labeler',
+        ).defaultSetting,
+        ModerationSetting.warn,
+      );
+    });
+
+    test('maps content blur behavior for each target', () {
+      final result = interpretLabelValueDefinition(
+        _lexDefinition('topic', severity: 'alert', blurs: 'content'),
+        definedBy: 'did:plc:labeler',
+      );
+
+      expect(
+        result.behaviorFor(
+          ModerationTarget.account,
+        )[ModerationContext.contentList],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.account,
+        )[ModerationContext.contentView],
+        ModerationAction.alert,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.profile,
+        )[ModerationContext.profileView],
+        ModerationAction.alert,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.content,
+        )[ModerationContext.contentList],
+        ModerationAction.blur,
+      );
+    });
+
+    test('adult content blur also blurs direct content views', () {
+      final result = interpretLabelValueDefinition(
+        _lexDefinition(
+          'adult',
+          severity: 'alert',
+          blurs: 'content',
+          adultOnly: true,
+        ),
+        definedBy: 'did:plc:labeler',
+      );
+
+      expect(
+        result.behaviorFor(
+          ModerationTarget.content,
+        )[ModerationContext.contentView],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.account,
+        )[ModerationContext.contentView],
+        ModerationAction.blur,
+      );
+    });
+
+    test('maps media blur behavior to media, avatars, and banners', () {
+      final result = interpretLabelValueDefinition(
+        _lexDefinition('topic', severity: 'inform', blurs: 'media'),
+        definedBy: 'did:plc:labeler',
+      );
+
+      expect(
+        result.behaviorFor(
+          ModerationTarget.content,
+        )[ModerationContext.contentMedia],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.content,
+        )[ModerationContext.contentView],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.account,
+        )[ModerationContext.contentView],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(ModerationTarget.profile)[ModerationContext.avatar],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(ModerationTarget.account)[ModerationContext.banner],
+        ModerationAction.blur,
+      );
+      expect(
+        result.behaviorFor(
+          ModerationTarget.profile,
+        )[ModerationContext.profileList],
+        ModerationAction.inform,
+      );
+    });
+
+    test('maps no-blur severity to alerts or information', () {
+      final alert = interpretLabelValueDefinition(
+        _lexDefinition('alert', severity: 'alert', blurs: 'none'),
+        definedBy: 'did:plc:labeler',
+      );
+      final inform = interpretLabelValueDefinition(
+        _lexDefinition('inform', severity: 'inform', blurs: 'none'),
+        definedBy: 'did:plc:labeler',
+      );
+
+      expect(
+        alert.behaviorFor(
+          ModerationTarget.content,
+        )[ModerationContext.contentView],
+        ModerationAction.alert,
+      );
+      expect(
+        inform.behaviorFor(
+          ModerationTarget.account,
+        )[ModerationContext.profileList],
+        ModerationAction.inform,
+      );
+    });
+  });
+
+  group('labeler-authored locale selection', () {
+    final definition = ModerationLabelDefinition(
+      identifier: 'topic',
+      definedBy: 'did:plc:labeler',
+      severity: ModerationSeverity.inform,
+      blurs: ModerationBlur.none,
+      defaultSetting: ModerationSetting.warn,
+      configurable: true,
+      flags: const {},
+      locales: const [
+        ModerationLabelStrings(
+          lang: 'en-US',
+          name: 'English',
+          description: 'English description',
+        ),
+        ModerationLabelStrings(
+          lang: 'fr',
+          name: 'Français',
+          description: 'Description française',
+        ),
+        ModerationLabelStrings(
+          lang: 'pt-BR',
+          name: 'Português',
+          description: 'Descrição',
+        ),
+      ],
+      behaviors: const {},
+    );
+
+    test('matches exact tags case-insensitively and accepts underscores', () {
+      expect(definition.stringsFor(['EN_us'])?.name, 'English');
+    });
+
+    test('truncates regional tags using lookup fallback', () {
+      expect(definition.stringsFor(['fr-CA'])?.name, 'Français');
+    });
+
+    test('matches a labeler regional variant by primary language', () {
+      expect(definition.stringsFor(['pt'])?.name, 'Português');
+    });
+
+    test('honors preferred locale order', () {
+      expect(definition.stringsFor(['de', 'fr'])?.name, 'Français');
+    });
+
+    test('falls back to labeler English then its first locale', () {
+      expect(definition.stringsFor(['de'])?.name, 'English');
+
+      final withoutEnglish = ModerationLabelDefinition(
+        identifier: 'topic',
+        severity: ModerationSeverity.none,
+        blurs: ModerationBlur.none,
+        defaultSetting: ModerationSetting.warn,
+        configurable: true,
+        flags: const {},
+        locales: const [
+          ModerationLabelStrings(lang: 'ja', name: '日本語', description: '説明'),
+        ],
+        behaviors: const {},
+      );
+      expect(withoutEnglish.stringsFor(['de'])?.name, '日本語');
+    });
+
+    test('returns null instead of inventing app-owned label strings', () {
+      final system = ModerationLabelDefinitions().global['!hide']!;
+      expect(system.stringsFor(['en']), isNull);
+    });
+  });
+}
+
+LabelValueDefinition _lexDefinition(
+  String identifier, {
+  String severity = 'none',
+  String blurs = 'none',
+  String? defaultSetting,
+  bool? adultOnly,
+  List<LabelValueDefinitionStrings> locales = const [],
+}) {
+  return LabelValueDefinition(
+    identifier: identifier,
+    severity: LabelValueDefinitionSeverity.valueOf(severity)!,
+    blurs: LabelValueDefinitionBlurs.valueOf(blurs)!,
+    defaultSetting: LabelValueDefinitionDefaultSetting.valueOf(defaultSetting),
+    adultOnly: adultOnly,
+    locales: locales,
+  );
+}
+
+Label _label({required String src, required String val}) {
+  return Label(
+    src: src,
+    uri: 'at://did:plc:subject/app.bsky.feed.post/1',
+    val: val,
+    cts: DateTime.utc(2026),
+  );
+}
diff --git a/test/src/core/moderation/moderation_engine_test.dart b/test/src/core/moderation/moderation_engine_test.dart
new file mode 100644
index 00000000..8176b712
--- /dev/null
+++ b/test/src/core/moderation/moderation_engine_test.dart
@@ -0,0 +1,773 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 8, 12);
+
+  group('ModerationEngine lifecycle', () {
+    test('ignores negated labels', () {
+      final decision = _engine().evaluate(
+        [_label(val: 'sexual', neg: true)],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes, isEmpty);
+    });
+
+    test('ignores expired labels including the exact expiry instant', () {
+      final decision = _engine().evaluate(
+        [
+          _label(val: 'sexual', exp: now.subtract(const Duration(seconds: 1))),
+          _label(val: 'sexual', exp: now),
+          _label(val: 'sexual', exp: now.add(const Duration(seconds: 1))),
+        ],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes, hasLength(1));
+      expect(
+        decision.causes.single.label.exp,
+        now.add(const Duration(seconds: 1)),
+      );
+    });
+
+    test('ignores unknown label values', () {
+      final decision = _engine().evaluate(
+        [_label(val: 'not-defined')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes, isEmpty);
+    });
+
+    test('ignores unsupported custom self-labels', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:author': [_definition('custom')],
+        },
+      );
+
+      final decision = engine.evaluate(
+        [_label(src: 'did:plc:author', val: 'custom')],
+        target: ModerationTarget.content,
+        subjectDid: 'did:plc:author',
+        now: now,
+      );
+
+      expect(decision.causes, isEmpty);
+    });
+
+    test('allows supported built-in self-labels', () {
+      final decision = _engine().evaluate(
+        [_label(src: 'did:plc:author', val: 'sexual')],
+        target: ModerationTarget.content,
+        subjectDid: 'did:plc:author',
+        now: now,
+      );
+
+      expect(decision.causes.single.definition.identifier, 'sexual');
+    });
+
+    test('ignores moderation-only built-in values when self-applied', () {
+      final decision = _engine().evaluate(
+        [_label(src: 'did:plc:author', val: 'dmca-violation')],
+        target: ModerationTarget.content,
+        subjectDid: 'did:plc:author',
+        now: now,
+      );
+
+      expect(decision.causes, isEmpty);
+    });
+
+    test('uses the configured labeler policy and metadata for self-labels', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:moderator': [
+            _definition(
+              'nudity',
+              blurs: 'media',
+              locales: const [
+                LabelValueDefinitionStrings(
+                  lang: 'en',
+                  name: 'Labeler Nudity',
+                  description: 'Labeler-authored description.',
+                ),
+              ],
+            ),
+          ],
+        },
+        labelPreferences: const [
+          ModerationLabelPreference(
+            value: 'nudity',
+            labelerDid: 'did:plc:moderator',
+            setting: ModerationSetting.hide,
+          ),
+        ],
+        selfLabelerDid: 'did:plc:moderator',
+      );
+
+      final decision = engine.evaluate(
+        [_label(src: 'did:plc:author', val: 'nudity')],
+        target: ModerationTarget.content,
+        subjectDid: 'did:plc:author',
+        preferredLocales: const ['en'],
+        now: now,
+      );
+
+      expect(decision.causes.single.setting, ModerationSetting.hide);
+      expect(decision.causes.single.definition.definedBy, 'did:plc:moderator');
+      expect(decision.causes.single.strings?.name, 'Labeler Nudity');
+      expect(decision.causes.single.sourceDid, 'did:plc:author');
+      expect(decision.forContext(ModerationContext.contentList).filter, isTrue);
+    });
+
+    test(
+      'keeps same-valued labels from different sources as distinct causes',
+      () {
+        final engine = _engine(
+          definitions: {
+            'did:plc:alpha': [_definition('topic')],
+            'did:plc:beta': [_definition('topic')],
+          },
+        );
+
+        final decision = engine.evaluate(
+          [
+            _label(src: 'did:plc:alpha', val: 'topic'),
+            _label(src: 'did:plc:beta', val: 'topic'),
+          ],
+          target: ModerationTarget.content,
+          now: now,
+        );
+
+        expect(decision.causes.map((cause) => cause.sourceDid), {
+          'did:plc:alpha',
+          'did:plc:beta',
+        });
+      },
+    );
+  });
+
+  group('imperative labels', () {
+    for (final value in ['!hide', '!takedown']) {
+      test('$value cannot be ignored and is non-overridable', () {
+        final engine = _engine(
+          labelPreferences: [
+            ModerationLabelPreference(
+              value: value,
+              labelerDid: 'did:plc:labeler',
+              setting: ModerationSetting.ignore,
+            ),
+          ],
+        );
+        final decision = engine.evaluate(
+          [_label(val: value)],
+          target: ModerationTarget.content,
+          now: now,
+        );
+
+        expect(decision.causes.single.setting, ModerationSetting.hide);
+        expect(
+          decision.forContext(ModerationContext.contentList).filter,
+          isTrue,
+        );
+        expect(decision.forContext(ModerationContext.contentView).blur, isTrue);
+        expect(
+          decision.forContext(ModerationContext.contentView).noOverride,
+          isTrue,
+        );
+      });
+    }
+
+    test('!no-promote excludes promotion without changing ordinary UI', () {
+      final decision = _engine().evaluate(
+        [_label(val: '!no-promote')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.excludeFromPromotion, isTrue);
+      for (final context in ModerationContext.values) {
+        final ui = decision.forContext(context);
+        expect(ui.filter, isFalse, reason: context.name);
+        expect(ui.blur, isFalse, reason: context.name);
+        expect(ui.alert, isFalse, reason: context.name);
+        expect(ui.inform, isFalse, reason: context.name);
+      }
+    });
+
+    test('!no-unauthenticated is ignored for signed-in viewers', () {
+      final decision = _engine(authenticated: true).evaluate(
+        [_label(val: '!no-unauthenticated')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes, isEmpty);
+    });
+
+    test('!no-unauthenticated hides from signed-out viewers', () {
+      final decision = _engine(authenticated: false).evaluate(
+        [_label(val: '!no-unauthenticated')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.hideFromUnauthenticated, isTrue);
+      expect(decision.forContext(ModerationContext.contentList).filter, isTrue);
+      expect(decision.forContext(ModerationContext.contentView).blur, isTrue);
+      expect(
+        decision.forContext(ModerationContext.contentView).noOverride,
+        isTrue,
+      );
+    });
+  });
+
+  group('Spark warn policy', () {
+    test('non-adult media hide still conceals a direct content view', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [
+            _definition('media-hide', blurs: 'media', defaultSetting: 'hide'),
+          ],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'media-hide')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.forContext(ModerationContext.contentList).filter, isTrue);
+      expect(decision.forContext(ModerationContext.contentView).blur, isTrue);
+      expect(decision.forContext(ModerationContext.contentMedia).blur, isTrue);
+    });
+
+    test('warn adds content blur while preserving an alert', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [
+            _definition('alert-only', severity: 'alert', blurs: 'none'),
+          ],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'alert-only')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      final ui = decision.forContext(ModerationContext.contentView);
+      expect(ui.blur, isTrue);
+      expect(ui.alert, isTrue);
+      expect(ui.inform, isFalse);
+      expect(
+        decision.causes.single.definition.severity,
+        ModerationSeverity.alert,
+      );
+    });
+
+    test('warn keeps information badge-only without explicit blur', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [
+            _definition('info-only', severity: 'inform', blurs: 'none'),
+          ],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'info-only')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      final ui = decision.forContext(ModerationContext.contentView);
+      expect(ui.blur, isFalse);
+      expect(ui.inform, isTrue);
+      expect(ui.alert, isFalse);
+      expect(decision.forContext(ModerationContext.contentList).blur, isFalse);
+      expect(decision.forContext(ModerationContext.contentMedia).blur, isFalse);
+      expect(
+        decision.causes.single.definition.severity,
+        ModerationSeverity.inform,
+      );
+    });
+
+    test('inform still applies an explicit media blur', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [
+            _definition('info-media', severity: 'inform', blurs: 'media'),
+          ],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'info-media')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.forContext(ModerationContext.contentView).blur, isTrue);
+      expect(decision.forContext(ModerationContext.contentMedia).blur, isTrue);
+    });
+
+    test('non-inform warn blurs every content context', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [_definition('topic')],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'topic')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      for (final context in [
+        ModerationContext.contentList,
+        ModerationContext.contentView,
+        ModerationContext.contentMedia,
+      ]) {
+        expect(decision.forContext(context).blur, isTrue, reason: context.name);
+      }
+      expect(decision.forContext(ModerationContext.profileView).blur, isFalse);
+    });
+
+    test('non-inform warn blurs every profile context', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [_definition('topic')],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'topic')],
+        target: ModerationTarget.profile,
+        now: now,
+      );
+
+      for (final context in [
+        ModerationContext.profileList,
+        ModerationContext.profileView,
+        ModerationContext.avatar,
+        ModerationContext.banner,
+        ModerationContext.displayName,
+      ]) {
+        expect(decision.forContext(context).blur, isTrue, reason: context.name);
+      }
+      expect(decision.forContext(ModerationContext.contentView).blur, isFalse);
+    });
+
+    test('non-inform warn on an account blurs every supported context', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [_definition('topic')],
+        },
+      );
+      final decision = engine.evaluate(
+        [_label(val: 'topic')],
+        target: ModerationTarget.account,
+        now: now,
+      );
+
+      for (final context in ModerationContext.values) {
+        expect(decision.forContext(context).blur, isTrue, reason: context.name);
+      }
+    });
+  });
+
+  group('decisions and contexts', () {
+    test('partitions profile-record labels from account labels', () {
+      final decision = _engine().evaluateProfileLabels(
+        [
+          _label(
+            val: 'doxxing',
+            uri: 'at://did:plc:subject/app.bsky.actor.profile/self',
+          ),
+          _label(val: 'doxxing', uri: 'did:plc:subject'),
+        ],
+        subjectDid: 'did:plc:subject',
+        now: now,
+      );
+
+      expect(decision.causes, hasLength(2));
+      expect(
+        decision.causes
+            .singleWhere(
+              (cause) =>
+                  cause.label.uri.endsWith('/app.bsky.actor.profile/self'),
+            )
+            .target,
+        ModerationTarget.profile,
+      );
+      expect(
+        decision.causes
+            .singleWhere((cause) => cause.label.uri == 'did:plc:subject')
+            .target,
+        ModerationTarget.account,
+      );
+    });
+
+    test('keeps Spark profile-record labels out of account content', () {
+      final decision = _engine().evaluateProfileLabels(
+        [
+          _label(
+            val: 'doxxing',
+            uri: 'at://did:plc:subject/so.sprk.actor.profile/self',
+          ),
+        ],
+        subjectDid: 'did:plc:subject',
+        now: now,
+      );
+
+      expect(decision.causes.single.target, ModerationTarget.profile);
+      expect(decision.forContext(ModerationContext.profileView).blur, isTrue);
+      expect(decision.forContext(ModerationContext.contentList).blur, isFalse);
+    });
+
+    test('keeps profile-record imperatives out of authored content', () {
+      for (final namespace in [
+        'app.bsky.actor.profile',
+        'so.sprk.actor.profile',
+      ]) {
+        for (final value in ['!hide', '!takedown', '!warn']) {
+          final decision = _engine().evaluateProfileLabels(
+            [_label(val: value, uri: 'at://did:plc:subject/$namespace/self')],
+            subjectDid: 'did:plc:subject',
+            now: now,
+          );
+
+          expect(decision.causes.single.target, ModerationTarget.profile);
+          expect(
+            decision.forContext(ModerationContext.profileView).blur,
+            isTrue,
+            reason: '$namespace $value profile',
+          );
+          for (final context in [
+            ModerationContext.contentList,
+            ModerationContext.contentView,
+            ModerationContext.contentMedia,
+          ]) {
+            final ui = decision.forContext(context);
+            expect(ui.filter, isFalse, reason: '$namespace $value $context');
+            expect(ui.blur, isFalse, reason: '$namespace $value $context');
+            expect(ui.alert, isFalse, reason: '$namespace $value $context');
+            expect(ui.inform, isFalse, reason: '$namespace $value $context');
+          }
+        }
+      }
+    });
+
+    test('classifies profile-record imperatives exactly once', () {
+      final decision = _engine(authenticated: false).evaluateProfileLabels(
+        [
+          _label(
+            val: '!no-unauthenticated',
+            uri: 'at://did:plc:subject/app.bsky.actor.profile/self',
+          ),
+        ],
+        subjectDid: 'did:plc:subject',
+        now: now,
+      );
+
+      expect(decision.causes, hasLength(1));
+      expect(decision.causes.single.target, ModerationTarget.account);
+      expect(decision.hideFromUnauthenticated, isTrue);
+      expect(decision.forContext(ModerationContext.contentView).blur, isTrue);
+    });
+
+    test(
+      'merges account, profile, and content decisions without losing targets',
+      () {
+        final engine = _engine(
+          definitions: {
+            'did:plc:labeler': [_definition('topic')],
+          },
+        );
+        final merged = ModerationDecision.merge([
+          engine.evaluate(
+            [_label(val: 'topic')],
+            target: ModerationTarget.account,
+            now: now,
+          ),
+          engine.evaluate(
+            [_label(val: 'topic')],
+            target: ModerationTarget.content,
+            now: now,
+          ),
+        ]);
+
+        expect(merged.causes.map((cause) => cause.target), [
+          ModerationTarget.account,
+          ModerationTarget.content,
+        ]);
+        expect(
+          merged.forContext(ModerationContext.contentView).blurs,
+          hasLength(2),
+        );
+      },
+    );
+
+    test('hide filters matching list contexts only', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [_definition('topic', defaultSetting: 'hide')],
+        },
+      );
+
+      final content = engine.evaluate(
+        [_label(val: 'topic')],
+        target: ModerationTarget.content,
+        now: now,
+      );
+      expect(content.forContext(ModerationContext.contentList).filter, isTrue);
+      expect(content.forContext(ModerationContext.profileList).filter, isFalse);
+
+      final profile = engine.evaluate(
+        [_label(val: 'topic')],
+        target: ModerationTarget.profile,
+        now: now,
+      );
+      expect(profile.forContext(ModerationContext.profileList).filter, isFalse);
+      expect(profile.forContext(ModerationContext.contentList).filter, isFalse);
+    });
+
+    test('does not filter the current user or lock away an override', () {
+      final decision = _engine(currentUserDid: 'did:plc:me').evaluate(
+        [_label(val: '!hide')],
+        target: ModerationTarget.account,
+        subjectDid: 'did:plc:me',
+        now: now,
+      );
+
+      expect(decision.isSubjectCurrentUser, isTrue);
+      expect(
+        decision.forContext(ModerationContext.profileList).filter,
+        isFalse,
+      );
+      expect(decision.forContext(ModerationContext.profileView).blur, isTrue);
+      expect(
+        decision.forContext(ModerationContext.profileView).noOverride,
+        isFalse,
+      );
+    });
+
+    test('adult-disabled content is forced hidden and non-overridable', () {
+      final decision =
+          _engine(
+            adultContentEnabled: false,
+            labelPreferences: const [
+              ModerationLabelPreference(
+                value: 'sexual',
+                setting: ModerationSetting.ignore,
+              ),
+            ],
+          ).evaluate(
+            [_label(val: 'sexual')],
+            target: ModerationTarget.content,
+            now: now,
+          );
+
+      expect(decision.causes.single.setting, ModerationSetting.hide);
+      expect(decision.causes.single.noOverride, isTrue);
+      expect(decision.forContext(ModerationContext.contentList).filter, isTrue);
+      expect(decision.forContext(ModerationContext.contentView).blur, isTrue);
+      expect(
+        decision.forContext(ModerationContext.contentView).noOverride,
+        isTrue,
+      );
+      expect(decision.forContext(ModerationContext.contentMedia).blur, isTrue);
+      expect(
+        decision.forContext(ModerationContext.contentMedia).noOverride,
+        isTrue,
+      );
+    });
+
+    test('source-specific ignore suppresses only that source', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:alpha': [_definition('topic')],
+          'did:plc:beta': [_definition('topic')],
+        },
+        labelPreferences: const [
+          ModerationLabelPreference(
+            value: 'topic',
+            labelerDid: 'did:plc:alpha',
+            setting: ModerationSetting.ignore,
+          ),
+          ModerationLabelPreference(
+            value: 'topic',
+            labelerDid: 'did:plc:beta',
+            setting: ModerationSetting.warn,
+          ),
+        ],
+      );
+      final decision = engine.evaluate(
+        [
+          _label(src: 'did:plc:alpha', val: 'topic'),
+          _label(src: 'did:plc:beta', val: 'topic'),
+        ],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes.single.sourceDid, 'did:plc:beta');
+    });
+
+    test('ignores labels from non-configured sources', () {
+      final engine = _engine(
+        configuredLabelerDids: const {'did:plc:configured'},
+      );
+      final decision = engine.evaluate(
+        [
+          _label(src: 'did:plc:removed', val: '!hide'),
+          _label(src: 'did:plc:removed', val: 'porn'),
+          _label(src: 'did:plc:configured', val: '!warn'),
+        ],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes, hasLength(1));
+      expect(decision.causes.single.sourceDid, 'did:plc:configured');
+      expect(decision.causes.single.definition.identifier, '!warn');
+    });
+
+    test('keeps supported self labels from non-configured authors', () {
+      final decision = _engine(configuredLabelerDids: const {}).evaluate(
+        [_label(src: 'did:plc:author', val: 'sexual')],
+        target: ModerationTarget.content,
+        subjectDid: 'did:plc:author',
+        now: now,
+      );
+
+      expect(decision.causes.single.sourceDid, 'did:plc:author');
+      expect(decision.causes.single.definition.identifier, 'sexual');
+    });
+
+    test('selects labeler-authored cause strings for the viewer locale', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [
+            _definition(
+              'topic',
+              locales: const [
+                LabelValueDefinitionStrings(
+                  lang: 'en',
+                  name: 'English',
+                  description: 'Description',
+                ),
+                LabelValueDefinitionStrings(
+                  lang: 'es',
+                  name: 'Español',
+                  description: 'Descripción',
+                ),
+              ],
+            ),
+          ],
+        },
+      );
+
+      final decision = engine.evaluate(
+        [_label(val: 'topic')],
+        target: ModerationTarget.content,
+        preferredLocales: const ['es-MX'],
+        now: now,
+      );
+
+      expect(decision.causes.single.strings?.name, 'Español');
+    });
+
+    test('orders non-overridable, hide, blur, and notice causes', () {
+      final engine = _engine(
+        definitions: {
+          'did:plc:labeler': [
+            _definition('hidden', defaultSetting: 'hide'),
+            _definition('media', blurs: 'media'),
+            _definition('notice', severity: 'alert'),
+          ],
+        },
+      );
+      final decision = engine.evaluate(
+        [
+          _label(val: 'notice'),
+          _label(val: 'media'),
+          _label(val: 'hidden'),
+          _label(val: '!hide'),
+        ],
+        target: ModerationTarget.content,
+        now: now,
+      );
+
+      expect(decision.causes.map((cause) => cause.definition.identifier), [
+        '!hide',
+        'hidden',
+        'media',
+        'notice',
+      ]);
+      expect(decision.causes.map((cause) => cause.priority), [1, 2, 5, 8]);
+    });
+  });
+}
+
+ModerationEngine _engine({
+  Map<String, Iterable<LabelValueDefinition>> definitions = const {},
+  List<ModerationLabelPreference> labelPreferences = const [],
+  bool adultContentEnabled = true,
+  bool authenticated = true,
+  String? currentUserDid,
+  String? selfLabelerDid,
+  Set<String> configuredLabelerDids = const {'did:plc:labeler'},
+}) {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers({
+      for (final did in configuredLabelerDids) did: const [],
+      ...definitions,
+    }),
+    preferences: ModerationPreferences(
+      labels: labelPreferences,
+      adultContentEnabled: adultContentEnabled,
+      authenticated: authenticated,
+    ),
+    currentUserDid: currentUserDid,
+    selfLabelerDid: selfLabelerDid,
+  );
+}
+
+LabelValueDefinition _definition(
+  String identifier, {
+  String severity = 'none',
+  String blurs = 'none',
+  String? defaultSetting,
+  bool? adultOnly,
+  List<LabelValueDefinitionStrings> locales = const [],
+}) {
+  return LabelValueDefinition(
+    identifier: identifier,
+    severity: LabelValueDefinitionSeverity.valueOf(severity)!,
+    blurs: LabelValueDefinitionBlurs.valueOf(blurs)!,
+    defaultSetting: LabelValueDefinitionDefaultSetting.valueOf(defaultSetting),
+    adultOnly: adultOnly,
+    locales: locales,
+  );
+}
+
+Label _label({
+  String src = 'did:plc:labeler',
+  required String val,
+  String uri = 'at://did:plc:subject/app.bsky.feed.post/1',
+  bool? neg,
+  DateTime? exp,
+}) {
+  return Label(
+    src: src,
+    uri: uri,
+    val: val,
+    neg: neg,
+    cts: DateTime.utc(2026),
+    exp: exp,
+  );
+}
diff --git a/test/src/core/moderation/moderation_label_events_test.dart b/test/src/core/moderation/moderation_label_events_test.dart
new file mode 100644
index 00000000..5246c2e9
--- /dev/null
+++ b/test/src/core/moderation/moderation_label_events_test.dart
@@ -0,0 +1,96 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation_label_events.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 20, 12);
+
+  Label label({
+    required String value,
+    required DateTime createdAt,
+    String source = 'did:plc:moderator',
+    String uri = 'at://did:plc:author/app.bsky.feed.post/record',
+    bool? negated,
+    DateTime? expiresAt,
+  }) {
+    return Label(
+      src: source,
+      uri: uri,
+      val: value,
+      neg: negated,
+      cts: createdAt,
+      exp: expiresAt,
+    );
+  }
+
+  group('mergeLatestLabelEvents', () {
+    test('reconciles each identity while preserving identity order', () {
+      final original = label(
+        value: 'sexual',
+        createdAt: now.subtract(const Duration(minutes: 3)),
+      );
+      final otherValue = label(
+        value: 'gore',
+        createdAt: now.subtract(const Duration(minutes: 2)),
+      );
+      final replacement = label(
+        value: 'sexual',
+        createdAt: now.subtract(const Duration(minutes: 1)),
+      );
+      final otherSource = label(
+        value: 'sexual',
+        source: 'did:plc:other-moderator',
+        createdAt: now,
+      );
+
+      final result = mergeLatestLabelEvents(
+        existing: [original, otherValue],
+        incoming: [replacement, otherSource],
+        now: now,
+      );
+
+      expect(result, [replacement, otherValue, otherSource]);
+    });
+
+    test('keeps an inactive event over an equal-time assertion', () {
+      final assertion = label(value: 'sexual', createdAt: now);
+      final negation = label(value: 'sexual', createdAt: now, negated: true);
+
+      expect(
+        mergeLatestLabelEvents(
+          existing: [assertion],
+          incoming: [negation],
+          now: now,
+        ),
+        [negation],
+      );
+      expect(
+        mergeLatestLabelEvents(
+          existing: [negation],
+          incoming: [assertion],
+          now: now,
+        ),
+        [negation],
+      );
+    });
+  });
+
+  group('label activity', () {
+    test('uses one negation and expiry boundary', () {
+      final active = label(
+        value: 'active',
+        createdAt: now,
+        expiresAt: now.add(const Duration(seconds: 1)),
+      );
+      final negated = label(value: 'negated', createdAt: now, negated: true);
+      final expired = label(value: 'expired', createdAt: now, expiresAt: now);
+
+      expect(isLabelActiveAt(active, now: now), isTrue);
+      expect(isLabelActiveAt(negated, now: now), isFalse);
+      expect(isLabelActiveAt(expired, now: now), isFalse);
+      expect(activeLabelsFromEvents([active, negated, expired], now: now), [
+        active,
+      ]);
+    });
+  });
+}
diff --git a/test/src/core/moderation/moderation_preferences_test.dart b/test/src/core/moderation/moderation_preferences_test.dart
new file mode 100644
index 00000000..0aebd8ed
--- /dev/null
+++ b/test/src/core/moderation/moderation_preferences_test.dart
@@ -0,0 +1,238 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+
+void main() {
+  group('ModerationPreferences', () {
+    final definition = _definition();
+
+    test('source-specific preference wins for an ordinary label', () {
+      final preferences = _preferences([
+        const ModerationLabelPreference(
+          value: 'topic',
+          setting: ModerationSetting.hide,
+        ),
+        const ModerationLabelPreference(
+          value: 'topic',
+          labelerDid: 'did:plc:alpha',
+          setting: ModerationSetting.warn,
+        ),
+      ]);
+
+      expect(
+        preferences.settingFor(_label(src: 'did:plc:alpha'), definition),
+        ModerationSetting.warn,
+      );
+    });
+
+    test('global adult preference overrides source-specific preference', () {
+      final preferences = _preferences([
+        const ModerationLabelPreference(
+          value: 'porn',
+          setting: ModerationSetting.hide,
+        ),
+        const ModerationLabelPreference(
+          value: 'porn',
+          labelerDid: 'did:plc:alpha',
+          setting: ModerationSetting.warn,
+        ),
+      ]);
+
+      expect(
+        preferences.settingFor(
+          _label(src: 'did:plc:alpha', val: 'porn'),
+          _definition(identifier: 'porn'),
+        ),
+        ModerationSetting.hide,
+      );
+    });
+
+    test('global preference applies to sources without an override', () {
+      final preferences = _preferences([
+        const ModerationLabelPreference(
+          value: 'topic',
+          setting: ModerationSetting.hide,
+        ),
+        const ModerationLabelPreference(
+          value: 'topic',
+          labelerDid: 'did:plc:alpha',
+          setting: ModerationSetting.warn,
+        ),
+      ]);
+
+      expect(
+        preferences.settingFor(_label(src: 'did:plc:beta'), definition),
+        ModerationSetting.hide,
+      );
+    });
+
+    test('same-valued labels from different sources remain independent', () {
+      final preferences = _preferences([
+        const ModerationLabelPreference(
+          value: 'topic',
+          labelerDid: 'did:plc:alpha',
+          setting: ModerationSetting.warn,
+        ),
+        const ModerationLabelPreference(
+          value: 'topic',
+          labelerDid: 'did:plc:beta',
+          setting: ModerationSetting.ignore,
+        ),
+      ]);
+
+      expect(
+        preferences.settingFor(_label(src: 'did:plc:alpha'), definition),
+        ModerationSetting.warn,
+      );
+      expect(
+        preferences.settingFor(_label(src: 'did:plc:beta'), definition),
+        ModerationSetting.ignore,
+      );
+    });
+
+    test('uses definition default when no preference exists', () {
+      expect(
+        _preferences([]).settingFor(_label(src: 'did:plc:alpha'), definition),
+        ModerationSetting.warn,
+      );
+    });
+
+    test('tracks definition default changes when no preference exists', () {
+      final preferences = _preferences([]);
+      final label = _label(src: 'did:plc:alpha');
+
+      expect(
+        preferences.settingFor(
+          label,
+          _definition(defaultSetting: ModerationSetting.hide),
+        ),
+        ModerationSetting.hide,
+      );
+      expect(
+        preferences.settingFor(
+          label,
+          _definition(defaultSetting: ModerationSetting.ignore),
+        ),
+        ModerationSetting.ignore,
+      );
+    });
+
+    test('non-configurable labels ignore user preferences', () {
+      final preferences = _preferences([
+        const ModerationLabelPreference(
+          value: '!hide',
+          setting: ModerationSetting.ignore,
+        ),
+        const ModerationLabelPreference(
+          value: '!hide',
+          labelerDid: 'did:plc:alpha',
+          setting: ModerationSetting.ignore,
+        ),
+      ]);
+      final imperative = ModerationLabelDefinitions().global['!hide']!;
+
+      expect(
+        preferences.settingFor(
+          _label(src: 'did:plc:alpha', val: '!hide'),
+          imperative,
+        ),
+        ModerationSetting.hide,
+      );
+    });
+
+    test('adult restriction forces hide before configured preferences', () {
+      final adult = ModerationLabelDefinitions().global['sexual']!;
+      final preference = const ModerationLabelPreference(
+        value: 'sexual',
+        labelerDid: 'did:plc:alpha',
+        setting: ModerationSetting.ignore,
+      );
+
+      expect(
+        _preferences(
+          [preference],
+          adultContentEnabled: false,
+        ).settingFor(_label(src: 'did:plc:alpha', val: 'sexual'), adult),
+        ModerationSetting.hide,
+      );
+      expect(
+        _preferences([
+          preference,
+        ]).settingFor(_label(src: 'did:plc:alpha', val: 'sexual'), adult),
+        ModerationSetting.ignore,
+      );
+    });
+
+    test('adapts generated content-label preferences', () {
+      final generated = [
+        contentLabelPreference(
+          labelerDid: null,
+          label: 'global',
+          visibility: 'hide',
+        ).contentLabelPref!,
+        contentLabelPreference(
+          labelerDid: 'did:plc:alpha',
+          label: 'specific',
+          visibility: 'warn',
+        ).contentLabelPref!,
+        contentLabelPreference(
+          labelerDid: 'did:plc:alpha',
+          label: 'ignored',
+          visibility: 'ignore',
+        ).contentLabelPref!,
+      ];
+
+      final preferences = ModerationPreferences.fromContentLabelPrefs(
+        generated,
+        adultContentEnabled: true,
+        authenticated: true,
+      );
+
+      expect(preferences.labels[0].setting, ModerationSetting.hide);
+      expect(preferences.labels[0].labelerDid, isNull);
+      expect(preferences.labels[1].setting, ModerationSetting.warn);
+      expect(preferences.labels[1].labelerDid, 'did:plc:alpha');
+      expect(preferences.labels[2].setting, ModerationSetting.ignore);
+      expect(preferences.adultContentEnabled, isTrue);
+      expect(preferences.authenticated, isTrue);
+    });
+  });
+}
+
+ModerationPreferences _preferences(
+  List<ModerationLabelPreference> labels, {
+  bool adultContentEnabled = true,
+}) {
+  return ModerationPreferences(
+    labels: labels,
+    adultContentEnabled: adultContentEnabled,
+    authenticated: true,
+  );
+}
+
+ModerationLabelDefinition _definition({
+  String identifier = 'topic',
+  ModerationSetting defaultSetting = ModerationSetting.warn,
+}) {
+  return ModerationLabelDefinition(
+    identifier: identifier,
+    definedBy: 'did:plc:alpha',
+    severity: ModerationSeverity.none,
+    blurs: ModerationBlur.none,
+    defaultSetting: defaultSetting,
+    configurable: true,
+    flags: const {},
+    locales: const [],
+    behaviors: const {},
+  );
+}
+
+Label _label({required String src, String val = 'topic'}) {
+  return Label(
+    src: src,
+    uri: 'at://did:plc:subject/app.bsky.feed.post/1',
+    val: val,
+    cts: DateTime.utc(2026),
+  );
+}
diff --git a/test/src/core/moderation/moderation_provider_test.dart b/test/src/core/moderation/moderation_provider_test.dart
new file mode 100644
index 00000000..a4864177
--- /dev/null
+++ b/test/src/core/moderation/moderation_provider_test.dart
@@ -0,0 +1,196 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/pref_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+void main() {
+  setUp(() async {
+    await GetIt.I.reset();
+  });
+
+  tearDown(() async {
+    await GetIt.I.reset();
+  });
+
+  test('definition fetch failures keep the engine unavailable', () async {
+    final error = StateError('policy unavailable');
+    GetIt.I
+      ..registerSingleton<PrefRepository>(_FakePrefRepository())
+      ..registerSingleton<SprkRepository>(
+        _FakeSprkRepository(_FailingLabelerRepository(error)),
+      )
+      ..registerSingleton<LogService>(LogService());
+    final container = ProviderContainer.test(
+      retry: (retryCount, error) => null,
+    );
+    addTearDown(container.dispose);
+
+    await expectLater(
+      container.read(moderationEngineProvider.future),
+      throwsA(same(error)),
+    );
+
+    expect(container.read(moderationEngineProvider).hasError, isTrue);
+  });
+
+  test('preserves labeler handles for moderation details', () async {
+    GetIt.I
+      ..registerSingleton<PrefRepository>(_FakePrefRepository())
+      ..registerSingleton<SprkRepository>(
+        _FakeSprkRepository(_SuccessfulLabelerRepository()),
+      )
+      ..registerSingleton<LogService>(LogService());
+    final container = ProviderContainer.test();
+    addTearDown(container.dispose);
+
+    final engine = await container.read(moderationEngineProvider.future);
+    final decision = engine.evaluate(
+      [
+        Label(
+          src: 'did:plc:moderator',
+          uri: 'at://did:plc:author/so.sprk.feed.post/example',
+          val: 'porn',
+          cts: DateTime.utc(2026),
+        ),
+      ],
+      target: ModerationTarget.content,
+      subjectDid: 'did:plc:author',
+    );
+
+    expect(decision.causes.single.sourceHandle, 'moderator.test');
+  });
+
+  test('only accepts labels from currently configured labelers', () async {
+    GetIt.I
+      ..registerSingleton<PrefRepository>(
+        _FakePrefRepository(
+          Preferences(
+            preferences: [
+              labelersPreference(const [
+                LabelerPrefItem(did: ' did:plc:selected#atproto_labeler '),
+              ]),
+            ],
+          ),
+        ),
+      )
+      ..registerSingleton<SprkRepository>(
+        _FakeSprkRepository(_SuccessfulLabelerRepository()),
+      )
+      ..registerSingleton<LogService>(LogService());
+    final container = ProviderContainer.test();
+    addTearDown(container.dispose);
+
+    final engine = await container.read(moderationEngineProvider.future);
+    final decision = engine.evaluate(
+      [
+        _label(src: 'did:plc:removed', value: '!hide'),
+        _label(src: 'did:plc:removed', value: 'porn'),
+        _label(src: 'did:plc:selected', value: '!warn'),
+        _label(src: 'did:plc:moderator', value: 'sexual'),
+      ],
+      target: ModerationTarget.content,
+      subjectDid: 'did:plc:author',
+    );
+
+    expect(decision.causes.map((cause) => cause.sourceDid).toSet(), {
+      'did:plc:selected',
+      'did:plc:moderator',
+    });
+  });
+}
+
+class _FakePrefRepository implements PrefRepository {
+  _FakePrefRepository([this.preferences = const Preferences(preferences: [])]);
+
+  final Preferences preferences;
+
+  @override
+  Future<Preferences> getPreferences() async => preferences;
+
+  @override
+  Future<void> putPreferences(Preferences preferences) async {}
+}
+
+Label _label({required String src, required String value}) => Label(
+  src: src,
+  uri: 'at://did:plc:author/so.sprk.feed.post/example',
+  val: value,
+  cts: DateTime.utc(2026),
+);
+
+class _FakeSprkRepository implements SprkRepository {
+  _FakeSprkRepository(this.labeler);
+
+  @override
+  final LabelerRepository labeler;
+
+  @override
+  final AuthRepository authRepository = _FakeAuthRepository();
+
+  @override
+  String get modDid => 'did:plc:moderator#atproto_labeler';
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {}
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FailingLabelerRepository implements LabelerRepository {
+  _FailingLabelerRepository(this.error);
+
+  final Object error;
+
+  @override
+  Future<LabelerViewDetailed> getServicesDetailed(List<String> dids) async {
+    throw error;
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _SuccessfulLabelerRepository implements LabelerRepository {
+  @override
+  Future<LabelerViewDetailed> getServicesDetailed(List<String> dids) async {
+    final did = dids.single;
+    return LabelerViewDetailed(
+      uri: AtUri.parse('at://$did/app.bsky.labeler.service/self'),
+      cid: 'cid',
+      creator: ProfileView(did: did, handle: 'moderator.test'),
+      policies: LabelerPolicies(
+        labelValues: const [LabelValue.knownValue(data: KnownLabelValue.porn)],
+      ),
+      indexedAt: DateTime.utc(2026),
+    );
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeAuthRepository implements AuthRepository {
+  @override
+  Future<void> initializationComplete = Future<void>.value();
+
+  @override
+  bool get isAuthenticated => true;
+
+  @override
+  String get did => 'did:plc:me';
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
diff --git a/test/src/core/network/atproto/data/repositories/actor_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/actor_repository_impl_test.dart
index 7879efd0..682006ce 100644
--- a/test/src/core/network/atproto/data/repositories/actor_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/actor_repository_impl_test.dart
@@ -24,6 +24,10 @@ void main() {
         request.headers['atproto-proxy'],
         'did:web:sprk.test#sprk_appview',
       );
+      expect(
+        request.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
       expect(profile.did, 'did:plc:alice');
     });
 
@@ -86,6 +90,10 @@ void main() {
         request.headers['atproto-proxy'],
         'did:web:sprk.test#sprk_appview',
       );
+      expect(
+        request.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
       expect(result.actors.single.did, 'did:plc:alice');
     });
 
diff --git a/test/src/core/network/atproto/data/repositories/feed_repository_requests_test.dart b/test/src/core/network/atproto/data/repositories/feed_repository_requests_test.dart
index 3ac114c3..60f7913f 100644
--- a/test/src/core/network/atproto/data/repositories/feed_repository_requests_test.dart
+++ b/test/src/core/network/atproto/data/repositories/feed_repository_requests_test.dart
@@ -98,40 +98,34 @@ void main() {
       },
     );
 
-    test(
-      'getFeedView selects Bluesky and omits Spark labeler headers',
-      () async {
-        final harness = RepositoryHarness(
-          getResponse: const <String, dynamic>{
-            'cursor': 'bsky-next',
-            'feed': <dynamic>[],
-          },
-        );
-        final feedUri = AtUri(
-          'at://did:plc:generator/app.bsky.feed.generator/bsky-feed',
-        );
+    test('getFeedView selects Bluesky and sends subscribed labelers', () async {
+      final harness = RepositoryHarness(
+        getResponse: const <String, dynamic>{
+          'cursor': 'bsky-next',
+          'feed': <dynamic>[],
+        },
+      );
+      final feedUri = AtUri(
+        'at://did:plc:generator/app.bsky.feed.generator/bsky-feed',
+      );
 
-        final result = await repository(harness).getFeedView(
-          feedUri,
-          limit: 6,
-          cursor: 'bsky-cursor',
-          labelerDids: const ['did:plc:labeler'],
-        );
+      final result = await repository(harness).getFeedView(
+        feedUri,
+        limit: 6,
+        cursor: 'bsky-cursor',
+        labelerDids: const ['did:plc:labeler'],
+      );
 
-        final request = harness.transport.singleRequest;
-        expect(request.uri.path, '/xrpc/app.bsky.feed.getFeed');
-        expect(request.uri.queryParameters['feed'], feedUri.toString());
-        expect(request.uri.queryParameters['limit'], '6');
-        expect(request.uri.queryParameters['cursor'], 'bsky-cursor');
-        expect(
-          request.headers['atproto-proxy'],
-          FakeSprkRepository.testBskyDid,
-        );
-        expect(request.headers, isNot(contains('atproto-accept-labelers')));
-        expect(result.cursor, 'bsky-next');
-        expect(result.feed, isEmpty);
-      },
-    );
+      final request = harness.transport.singleRequest;
+      expect(request.uri.path, '/xrpc/app.bsky.feed.getFeed');
+      expect(request.uri.queryParameters['feed'], feedUri.toString());
+      expect(request.uri.queryParameters['limit'], '6');
+      expect(request.uri.queryParameters['cursor'], 'bsky-cursor');
+      expect(request.headers['atproto-proxy'], FakeSprkRepository.testBskyDid);
+      expect(request.headers['atproto-accept-labelers'], 'did:plc:labeler');
+      expect(result.cursor, 'bsky-next');
+      expect(result.feed, isEmpty);
+    });
 
     test('getFeedView rejects unauthenticated requests before transport', () {
       final harness = RepositoryHarness(authenticated: false);
diff --git a/test/src/core/network/atproto/data/repositories/graph_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/graph_repository_impl_test.dart
index 9c557f75..dc6e6e51 100644
--- a/test/src/core/network/atproto/data/repositories/graph_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/graph_repository_impl_test.dart
@@ -35,6 +35,10 @@ void main() {
         request.headers['atproto-proxy'],
         'did:web:sprk.test#sprk_appview',
       );
+      expect(
+        request.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
       expect(output.cursor, 'next-page');
       expect(output.followers.single.did, 'did:plc:bob');
     });
diff --git a/test/src/core/network/atproto/data/repositories/labeler_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/labeler_repository_impl_test.dart
index 06faa773..2b50c22f 100644
--- a/test/src/core/network/atproto/data/repositories/labeler_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/labeler_repository_impl_test.dart
@@ -1,4 +1,6 @@
 import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart/poptart.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository_impl.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 
@@ -34,6 +36,10 @@ void main() {
           request.headers['atproto-proxy'],
           'did:web:sprk.test#sprk_appview',
         );
+        expect(
+          request.headers['atproto-accept-labelers'],
+          'did:web:mod.sprk.test',
+        );
         expect(service.creator.did, 'did:plc:labeler-one');
       },
     );
@@ -58,6 +64,195 @@ void main() {
       expect(service.policies.labelValues, isEmpty);
     });
 
+    test('queryLabels falls back to the configured labeler sources', () async {
+      final harness = RepositoryHarness(
+        getResponse: const <String, dynamic>{'labels': <dynamic>[]},
+      );
+      harness.sprk.configureLabelers(const ['did:plc:one', 'did:plc:two']);
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+      final uri = AtUri('at://did:plc:author/so.sprk.feed.post/post');
+
+      final result = await repository.queryLabels([uri]);
+
+      final request = harness.transport.singleRequest;
+      expect(request.uri.path, '/xrpc/com.atproto.label.queryLabels');
+      expect(request.uri.queryParametersAll['uriPatterns'], [uri.toString()]);
+      expect(request.uri.queryParametersAll['sources'], [
+        'did:plc:one',
+        'did:plc:two',
+      ]);
+      expect(request.headers['atproto-proxy'], harness.sprk.modDid);
+      expect(result.labels, isEmpty);
+    });
+
+    test('queryLabels preserves typed labels and signatures', () async {
+      final harness = RepositoryHarness(
+        getResponse: const <String, dynamic>{
+          'cursor': 'next-page',
+          'labels': [
+            {
+              r'$type': 'com.atproto.label.defs#label',
+              'src': 'did:plc:labeler',
+              'uri': 'at://did:plc:author/so.sprk.feed.post/post',
+              'val': 'sexual',
+              'cts': '2026-08-25T12:00:00.000Z',
+              'sig': {r'$bytes': 'AQI='},
+            },
+          ],
+        },
+      );
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+      final uri = AtUri('at://did:plc:author/so.sprk.feed.post/post');
+
+      final result = await repository.queryLabels([uri]);
+
+      expect(result.cursor, 'next-page');
+      expect(result.labels.single.src, 'did:plc:labeler');
+      expect(result.labels.single.sig, {r'$bytes': 'AQI='});
+    });
+
+    test('deduplicates concurrent detailed service lookups', () async {
+      final harness = RepositoryHarness();
+      harness.transport.enqueueGet({
+        'views': [_detailedLabeler],
+      });
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+
+      final services = await Future.wait([
+        repository.getServicesDetailed(['did:plc:labeler-one']),
+        repository.getServicesDetailed(['did:plc:labeler-one']),
+      ]);
+
+      expect(services, hasLength(2));
+      expect(harness.transport.requests, hasLength(1));
+    });
+
+    test('refreshes completed detailed service lookups', () async {
+      final harness = RepositoryHarness();
+      harness.transport
+        ..enqueueGet({
+          'views': [_detailedLabeler],
+        })
+        ..enqueueGet({
+          'views': [
+            {..._detailedLabeler, 'cid': 'refreshed-labeler-cid'},
+          ],
+        });
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+
+      final initial = await repository.getServicesDetailed([
+        'did:plc:labeler-one',
+      ]);
+      final refreshed = await repository.getServicesDetailed([
+        'did:plc:labeler-one',
+      ]);
+
+      expect(initial.cid, 'labeler-cid');
+      expect(refreshed.cid, 'refreshed-labeler-cid');
+      expect(harness.transport.requests, hasLength(2));
+    });
+
+    test('filters moderation services by report capabilities', () async {
+      final harness = RepositoryHarness();
+      harness.transport
+        ..enqueueGet({
+          'views': [
+            _detailedService('did:plc:labeler-one', subjectTypes: ['record']),
+          ],
+        })
+        ..enqueueGet({
+          'views': [
+            _detailedService('did:plc:accounts', subjectTypes: ['account']),
+          ],
+        });
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+
+      final services = await repository.getCompatibleModerationServices(
+        ['did:plc:accounts'],
+        const ModerationServiceQuery(
+          fallbackDid: 'did:plc:labeler-one',
+          subjectType: 'record',
+          reasonType: 'com.atproto.moderation.defs#reasonOther',
+        ),
+      );
+
+      expect(services.map((service) => service.did), ['did:plc:labeler-one']);
+      expect(harness.transport.requests, hasLength(2));
+    });
+
+    test(
+      'resolveIdentifier resolves handles directly through the PDS',
+      () async {
+        final harness = RepositoryHarness(
+          getResponse: const {'did': 'did:plc:resolved'},
+        );
+        final repository = LabelerRepositoryImpl(
+          harness.sprk,
+          logger: SparkLogger(),
+        );
+
+        final did = await repository.resolveIdentifier('@labeler.test');
+
+        final request = harness.transport.singleRequest;
+        expect(request.uri.path, '/xrpc/com.atproto.identity.resolveHandle');
+        expect(request.uri.queryParameters['handle'], 'labeler.test');
+        expect(request.headers, isNot(contains('atproto-proxy')));
+        expect(request.headers, isNot(contains('atproto-accept-labelers')));
+        expect(did, 'did:plc:resolved');
+      },
+    );
+
+    test('resolveIdentifier normalizes DIDs without transport', () async {
+      final harness = RepositoryHarness();
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+
+      expect(
+        await repository.resolveIdentifier(' did:plc:labeler#service '),
+        'did:plc:labeler',
+      );
+      expect(harness.transport.requests, isEmpty);
+    });
+
+    test('validateService rejects a mismatched returned service', () {
+      final harness = RepositoryHarness();
+      harness.transport.enqueueGet({
+        'views': [_detailedLabeler],
+      });
+      final repository = LabelerRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+
+      expect(
+        repository.validateService('did:plc:different'),
+        throwsA(
+          isA<Exception>().having(
+            (error) => error.toString(),
+            'message',
+            contains('does not match'),
+          ),
+        ),
+      );
+    });
+
     test('getServices rejects an empty server result', () {
       final harness = RepositoryHarness();
       harness.transport.enqueueGet({'views': <dynamic>[]});
@@ -141,3 +336,25 @@ const _detailedLabeler = <String, dynamic>{
   },
   'indexedAt': '2026-07-22T12:00:00.000Z',
 };
+
+Map<String, dynamic> _detailedService(
+  String did, {
+  required List<String> subjectTypes,
+}) {
+  return {
+    r'$type': 'so.sprk.labeler.defs#labelerViewDetailed',
+    'uri': 'at://$did/so.sprk.labeler.service/self',
+    'cid': 'labeler-cid',
+    'creator': {
+      r'$type': 'so.sprk.actor.defs#profileView',
+      'did': did,
+      'handle': '${did.split(':').last}.test',
+    },
+    'policies': {
+      r'$type': 'so.sprk.labeler.defs#labelerPolicies',
+      'labelValues': <dynamic>[],
+    },
+    'subjectTypes': subjectTypes,
+    'indexedAt': '2026-07-22T12:00:00.000Z',
+  };
+}
diff --git a/test/src/core/network/atproto/data/repositories/notification_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/notification_repository_impl_test.dart
index 2a2a4c4c..33a45444 100644
--- a/test/src/core/network/atproto/data/repositories/notification_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/notification_repository_impl_test.dart
@@ -30,6 +30,10 @@ void main() {
         'priority': ['true'],
         'reasons': ['like', 'reply'],
       });
+      expect(
+        harness.transport.singleRequest.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
     });
 
     test('getUnreadCount maps count and optional priority', () async {
diff --git a/test/src/core/network/atproto/data/repositories/pref_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/pref_repository_impl_test.dart
index eb975f9f..6216a1b7 100644
--- a/test/src/core/network/atproto/data/repositories/pref_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/pref_repository_impl_test.dart
@@ -33,6 +33,24 @@ void main() {
       },
     );
 
+    test('getPreferences decodes Spark adult-content preference', () async {
+      final harness = RepositoryHarness();
+      harness.transport.enqueueGet({
+        'preferences': [
+          {r'$type': 'so.sprk.actor.defs#adultContentPref', 'enabled': true},
+        ],
+      });
+      final repository = PrefRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+
+      final preferences = await repository.getPreferences();
+
+      expect(preferences.preferences.single.isAdultContentPref, isTrue);
+      expect(preferences.adultContentEnabled, isTrue);
+    });
+
     test('getPreferences rejects unauthenticated requests without I/O', () {
       final harness = RepositoryHarness(authenticated: false);
       final repository = PrefRepositoryImpl(
@@ -85,6 +103,26 @@ void main() {
       );
       expect((sent.single as Map<String, dynamic>)['items'], hasLength(1));
     });
+
+    test('putPreferences serializes Spark adult-content preference', () async {
+      final harness = RepositoryHarness();
+      harness.transport.enqueuePost(<String, dynamic>{});
+      final repository = PrefRepositoryImpl(
+        harness.sprk,
+        logger: SparkLogger(),
+      );
+      final preferences = Preferences(
+        preferences: [adultContentPreference(enabled: true)],
+      );
+
+      await repository.putPreferences(preferences);
+
+      final request = harness.transport.singleRequest;
+      final sent = request.jsonBody['preferences'] as List<dynamic>;
+      expect(sent, [
+        {r'$type': 'so.sprk.actor.defs#adultContentPref', 'enabled': true},
+      ]);
+    });
   });
 }
 
diff --git a/test/src/core/network/atproto/data/repositories/repository_test_support.dart b/test/src/core/network/atproto/data/repositories/repository_test_support.dart
index b3541e3b..a388fedd 100644
--- a/test/src/core/network/atproto/data/repositories/repository_test_support.dart
+++ b/test/src/core/network/atproto/data/repositories/repository_test_support.dart
@@ -4,6 +4,8 @@ import 'package:http/http.dart' as http;
 import 'package:poptart/poptart.dart';
 import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
 import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/repo_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 
@@ -15,6 +17,8 @@ class RepositoryHarness {
     String? did = 'did:plc:viewer',
     Map<String, dynamic>? getResponse,
     int getStatusCode = 200,
+    FeedRepository? feedRepository,
+    LabelerRepository? labelerRepository,
   }) : transport = TestTransport() {
     final atproto = oauth
         ? PoptartClient.fromOAuthSession(
@@ -44,7 +48,12 @@ class RepositoryHarness {
       atproto: atprotoInitialized ? atproto : null,
     );
     repo = FakeRepoRepository();
-    sprk = FakeSprkRepository(auth: auth, repo: repo);
+    sprk = FakeSprkRepository(
+      auth: auth,
+      repo: repo,
+      feed: feedRepository ?? const _UnavailableFeedRepository(),
+      labeler: labelerRepository ?? const _UnavailableLabelerRepository(),
+    );
     if (atprotoInitialized && getResponse != null) {
       transport.enqueueGet(getResponse, statusCode: getStatusCode);
     }
@@ -183,16 +192,28 @@ class FakeAuthRepository implements AuthRepository {
 }
 
 class FakeSprkRepository implements SprkRepository {
-  FakeSprkRepository({required this.auth, required this.repo});
+  FakeSprkRepository({
+    required this.auth,
+    required this.repo,
+    required this.feed,
+    required this.labeler,
+  });
 
   static const testSprkDid = 'did:web:sprk.test#sprk_appview';
   static const testBskyDid = 'did:web:bsky.test#bsky_appview';
 
   final FakeAuthRepository auth;
+  List<String> _labelerDids = ['did:web:mod.sprk.test'];
 
   @override
   final RepoRepository repo;
 
+  @override
+  final FeedRepository feed;
+
+  @override
+  final LabelerRepository labeler;
+
   @override
   AuthRepository get authRepository => auth;
 
@@ -208,6 +229,26 @@ class FakeSprkRepository implements SprkRepository {
   @override
   String get bskyModDid => 'did:web:mod.bsky.test';
 
+  @override
+  List<String> get labelerDids => List.unmodifiable(_labelerDids);
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {
+    _labelerDids = labelerDids.toSet().toList();
+  }
+
+  @override
+  Map<String, String> appViewHeaders(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  }) {
+    final accepted = labelerDids?.toList() ?? _labelerDids;
+    return {
+      'atproto-proxy': ?proxyDid,
+      if (accepted.isNotEmpty) 'atproto-accept-labelers': accepted.join(','),
+    };
+  }
+
   @override
   Future<T> executeWithRetry<T>(Future<T> Function() apiCall) => apiCall();
 
@@ -215,6 +256,20 @@ class FakeSprkRepository implements SprkRepository {
   dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
+class _UnavailableFeedRepository implements FeedRepository {
+  const _UnavailableFeedRepository();
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _UnavailableLabelerRepository implements LabelerRepository {
+  const _UnavailableLabelerRepository();
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
 class FakeRepoRepository implements RepoRepository {
   final List<CreateRecordCall> createCalls = [];
   final List<DeleteRecordCall> deleteCalls = [];
diff --git a/test/src/core/network/atproto/data/repositories/sound_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/sound_repository_impl_test.dart
index 1305e480..6c0065aa 100644
--- a/test/src/core/network/atproto/data/repositories/sound_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/sound_repository_impl_test.dart
@@ -56,6 +56,10 @@ void main() {
         'cursor': 'page',
       });
       expect(request.headers['atproto-proxy'], harness.sprk.sprkDid);
+      expect(
+        request.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
       expect(result.cursor, 'next');
     });
 
diff --git a/test/src/core/network/atproto/data/repositories/story_repository_impl_test.dart b/test/src/core/network/atproto/data/repositories/story_repository_impl_test.dart
index 63c7553d..3dde01c5 100644
--- a/test/src/core/network/atproto/data/repositories/story_repository_impl_test.dart
+++ b/test/src/core/network/atproto/data/repositories/story_repository_impl_test.dart
@@ -1,7 +1,11 @@
 import 'package:flutter_test/flutter_test.dart';
 import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/atproto/data/models/models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/story_repository_impl.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 
 import 'repository_test_support.dart';
 
@@ -26,6 +30,10 @@ void main() {
         'limit': '5',
         'cursor': 'page',
       });
+      expect(
+        harness.transport.singleRequest.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
     });
 
     test('getStoryViews maps an empty story list', () async {
@@ -41,8 +49,145 @@ void main() {
       expect(harness.transport.singleRequest.uri.queryParametersAll['uris'], [
         uri.toString(),
       ]);
+      expect(
+        harness.transport.singleRequest.headers['atproto-accept-labelers'],
+        'did:web:mod.sprk.test',
+      );
     });
 
+    test(
+      'getStoryViews enriches stories with queried moderation labels',
+      () async {
+        final story = StoryView(
+          uri: AtUri('at://did:plc:author/so.sprk.story.post/story'),
+          cid: 'story-cid',
+          author: const ProfileViewBasic(
+            did: 'did:plc:author',
+            handle: 'author.sprk.so',
+          ),
+          record: const <String, dynamic>{},
+          indexedAt: fixedNow,
+        );
+        final currentVersionLabel = Label(
+          src: 'did:plc:moderator',
+          uri: story.uri.toString(),
+          cid: story.cid,
+          val: 'sexual',
+          cts: fixedNow,
+        );
+        final oldVersionLabel = Label(
+          src: 'did:plc:moderator',
+          uri: story.uri.toString(),
+          cid: 'old-story-cid',
+          val: 'gore',
+          cts: fixedNow,
+        );
+        final unversionedLabel = Label(
+          src: 'did:plc:moderator',
+          uri: story.uri.toString(),
+          val: 'nudity',
+          cts: fixedNow,
+        );
+        final labeler = _LabelQueryRepository([
+          (
+            labels: [currentVersionLabel, oldVersionLabel, unversionedLabel],
+            cursor: null,
+          ),
+        ]);
+        final harness = RepositoryHarness(
+          getResponse: {
+            'stories': [story.toJson()],
+          },
+          labelerRepository: labeler,
+        );
+        final repository = StoryRepositoryImpl(harness.sprk);
+
+        final result = await repository.getStoryViews([story.uri]);
+
+        expect(result.single.moderationLabels, [
+          currentVersionLabel,
+          unversionedLabel,
+        ]);
+        expect(labeler.calls.single.uris, [story.uri]);
+        expect(labeler.calls.single.limit, 250);
+      },
+    );
+
+    test(
+      'getStoryViews reconciles paged negations and newer assertions',
+      () async {
+        final story = StoryView(
+          uri: AtUri('at://did:plc:author/so.sprk.story.post/story'),
+          cid: 'story-cid',
+          author: const ProfileViewBasic(
+            did: 'did:plc:author',
+            handle: 'author.sprk.so',
+          ),
+          record: const <String, dynamic>{},
+          indexedAt: fixedNow,
+        );
+        Label label(String value, Duration age, {bool? neg, String? cid}) =>
+            Label(
+              src: 'did:plc:moderator',
+              uri: story.uri.toString(),
+              cid: cid ?? story.cid,
+              val: value,
+              neg: neg,
+              cts: fixedNow.subtract(age),
+            );
+
+        final sexualAssertion = label('sexual', const Duration(minutes: 3));
+        final sexualNegation = label(
+          'sexual',
+          const Duration(minutes: 2),
+          neg: true,
+        );
+        final staleSexualAssertion = label(
+          'sexual',
+          const Duration(minutes: 4),
+        );
+        final goreAssertion = label('gore', const Duration(minutes: 3));
+        final goreNegation = label(
+          'gore',
+          const Duration(minutes: 2),
+          neg: true,
+        );
+        final reappliedGore = label('gore', const Duration(minutes: 1));
+        final oldVersionGore = label(
+          'gore',
+          Duration.zero,
+          cid: 'old-story-cid',
+        );
+        final labeler = _LabelQueryRepository([
+          (labels: [sexualAssertion, goreAssertion], cursor: 'negations'),
+          (labels: [sexualNegation, goreNegation], cursor: 'updates'),
+          (
+            labels: [staleSexualAssertion, reappliedGore, oldVersionGore],
+            cursor: null,
+          ),
+        ]);
+        final harness = RepositoryHarness(
+          getResponse: {
+            'stories': [story.toJson()],
+          },
+          labelerRepository: labeler,
+        );
+        final repository = StoryRepositoryImpl(
+          harness.sprk,
+          now: () => fixedNow,
+        );
+
+        final result = await repository.getStoryViews([story.uri]);
+
+        expect(result.single.moderationLabels, [reappliedGore]);
+        expect(labeler.calls.map((call) => call.cursor), [
+          null,
+          'negations',
+          'updates',
+        ]);
+      },
+    );
+
     test('listStoryRecords owns record paging parameters', () async {
       final harness = RepositoryHarness(
         getResponse: const {'records': <dynamic>[], 'cursor': 'next-page'},
@@ -115,3 +260,24 @@ void main() {
     });
   });
 }
+
+class _LabelQueryRepository implements LabelerRepository {
+  _LabelQueryRepository(this.pages);
+
+  final List<({List<Label> labels, String? cursor})> pages;
+  final List<({List<AtUri> uris, int? limit, String? cursor})> calls = [];
+
+  @override
+  Future<({List<Label> labels, String? cursor})> queryLabels(
+    List<AtUri> uris, {
+    List<String>? sources,
+    int? limit,
+    String? cursor,
+  }) async {
+    calls.add((uris: uris, limit: limit, cursor: cursor));
+    return pages.removeAt(0);
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
diff --git a/test/src/core/network/atproto/data/services/appview_labeler_headers_test.dart b/test/src/core/network/atproto/data/services/appview_labeler_headers_test.dart
new file mode 100644
index 00000000..d8b2d279
--- /dev/null
+++ b/test/src/core/network/atproto/data/services/appview_labeler_headers_test.dart
@@ -0,0 +1,43 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spark/src/core/network/atproto/data/services/appview_labeler_headers.dart';
+
+void main() {
+  group('AppViewLabelerHeaders', () {
+    test('keeps the required default and normalizes subscriptions', () {
+      final headers = AppViewLabelerHeaders(
+        defaultLabelerDid: 'did:plc:default#labeler',
+      )..configure([' did:plc:custom ', 'did:plc:default', 'did:plc:custom']);
+
+      expect(headers.labelerDids, ['did:plc:default', 'did:plc:custom']);
+      expect(headers.forAppView('did:web:appview.test'), {
+        'atproto-proxy': 'did:web:appview.test',
+        atprotoAcceptLabelersHeader: 'did:plc:default,did:plc:custom',
+      });
+    });
+
+    test('limits the accepted labelers to the protocol maximum', () {
+      final headers = AppViewLabelerHeaders(
+        defaultLabelerDid: 'did:plc:default',
+      )..configure([for (var index = 0; index < 30; index++) 'did:plc:$index']);
+
+      expect(headers.labelerDids, hasLength(AppViewLabelerHeaders.maxLabelers));
+      expect(headers.labelerDids.first, 'did:plc:default');
+      expect(headers.labelerDids.last, 'did:plc:18');
+    });
+
+    test('can override one request without mutating configured labelers', () {
+      final headers = AppViewLabelerHeaders(
+        defaultLabelerDid: 'did:plc:default',
+      )..configure(['did:plc:configured']);
+
+      expect(
+        headers.forAppView(
+          'did:web:appview.test',
+          labelerDids: ['did:plc:override'],
+        )[atprotoAcceptLabelersHeader],
+        'did:plc:default,did:plc:override',
+      );
+      expect(headers.labelerDids, ['did:plc:default', 'did:plc:configured']);
+    });
+  });
+}
diff --git a/test/src/features/settings/providers/preferences_provider_test.dart b/test/src/core/providers/preferences_provider_test.dart
similarity index 54%
rename from test/src/features/settings/providers/preferences_provider_test.dart
rename to test/src/core/providers/preferences_provider_test.dart
index bca6f901..54425fa8 100644
--- a/test/src/features/settings/providers/preferences_provider_test.dart
+++ b/test/src/core/providers/preferences_provider_test.dart
@@ -6,23 +6,27 @@ import 'package:get_it/get_it.dart';
 import 'package:poptart/poptart.dart';
 import 'package:spark/src/core/auth/data/models/login_result.dart';
 import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/pref_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
 
 void main() {
   late _FakeAuthRepository authRepository;
   late _FakePrefRepository prefRepository;
+  late _FakeSprkRepository sprkRepository;
 
   setUp(() async {
     await GetIt.I.reset();
     authRepository = _FakeAuthRepository();
     prefRepository = _FakePrefRepository();
+    sprkRepository = _FakeSprkRepository(authRepository);
     GetIt.I
       ..registerSingleton<PrefRepository>(prefRepository)
-      ..registerSingleton<SprkRepository>(_FakeSprkRepository(authRepository))
+      ..registerSingleton<SprkRepository>(sprkRepository)
       ..registerSingleton<LogService>(LogService());
   });
 
@@ -41,6 +45,7 @@ void main() {
 
     expect(preferences.preferences, isEmpty);
     expect(prefRepository.getCalls, 0);
+    expect(sprkRepository.labelerConfigurations, [<String>[]]);
   });
 
   test('loads preferences when authenticated', () async {
@@ -56,6 +61,9 @@ void main() {
       container.read(userPreferencesProvider.notifier).currentPreferences,
       expected,
     );
+    expect(sprkRepository.labelerConfigurations, [
+      ['did:plc:labeler'],
+    ]);
   });
 
   test('exposes an error when initial loading fails', () async {
@@ -87,10 +95,15 @@ void main() {
 
     expect(container.read(userPreferencesProvider).value, refreshed);
     expect(prefRepository.getCalls, 2);
+    expect(sprkRepository.labelerConfigurations, [
+      ['did:plc:labeler'],
+      ['did:plc:labeler'],
+    ]);
   });
 
-  test('refresh exposes and rethrows repository errors', () async {
-    prefRepository.getResult = _preferences('initial');
+  test('refresh rethrows errors without discarding committed data', () async {
+    final initial = _preferences('initial');
+    prefRepository.getResult = initial;
     final container = createContainer();
     await container.read(userPreferencesProvider.future);
     final notifier = container.read(userPreferencesProvider.notifier);
@@ -99,7 +112,8 @@ void main() {
 
     await expectLater(notifier.refresh(), throwsA(same(error)));
 
-    expect(container.read(userPreferencesProvider).error, same(error));
+    expect(container.read(userPreferencesProvider).requireValue, initial);
+    expect(notifier.currentPreferences, initial);
   });
 
   test('update persists and publishes preferences', () async {
@@ -109,13 +123,94 @@ void main() {
     final notifier = container.read(userPreferencesProvider.notifier);
     final updated = _preferences('updated');
 
-    await notifier.updatePreferences(updated);
+    final committed = await notifier.updatePreferences(updated);
 
+    expect(committed, updated);
     expect(prefRepository.putCalls, [updated]);
     expect(container.read(userPreferencesProvider).value, updated);
+    expect(sprkRepository.labelerConfigurations, [
+      ['did:plc:labeler'],
+      ['did:plc:labeler'],
+    ]);
+  });
+
+  test(
+    'adult content updates preserve other preferences and replace prior state',
+    () async {
+      final initial = Preferences(
+        preferences: [
+          ..._preferences('preserved').preferences,
+          adultContentPreference(enabled: false),
+        ],
+      );
+      prefRepository.getResult = initial;
+      final container = createContainer();
+      await container.read(userPreferencesProvider.future);
+      final notifier = container.read(userPreferencesProvider.notifier);
+
+      await notifier.setAdultContentEnabled(true);
+
+      final updated = container.read(userPreferencesProvider).value!;
+      expect(updated.adultContentEnabled, isTrue);
+      expect(updated.contentLabelPrefs?.single.label, 'preserved');
+      expect(
+        updated.preferences.where(
+          (preference) => preference.isAdultContentPref,
+        ),
+        hasLength(1),
+      );
+      expect(prefRepository.putCalls.single, updated);
+    },
+  );
+
+  test('global adult label update replaces every scoped copy', () async {
+    final initial = Preferences(
+      preferences: [
+        contentLabelPreference(
+          labelerDid: 'did:plc:one',
+          label: 'porn',
+          visibility: 'warn',
+        ),
+        contentLabelPreference(
+          labelerDid: 'did:plc:two',
+          label: 'porn',
+          visibility: 'ignore',
+        ),
+        contentLabelPreference(
+          labelerDid: 'did:plc:one',
+          label: 'sexual',
+          visibility: 'warn',
+        ),
+      ],
+    );
+    prefRepository.getResult = initial;
+    final container = createContainer();
+    await container.read(userPreferencesProvider.future);
+
+    await container
+        .read(userPreferencesProvider.notifier)
+        .setGlobalLabelPreference('porn', ModerationSetting.hide);
+
+    final prefs = container
+        .read(userPreferencesProvider)
+        .requireValue
+        .contentLabelPrefs!;
+    expect(
+      prefs.where((preference) => preference.label == 'porn'),
+      hasLength(1),
+    );
+    final porn = prefs.singleWhere((preference) => preference.label == 'porn');
+    expect(porn.labelerDid, isNull);
+    expect(porn.visibility.toJson(), 'hide');
+    expect(
+      prefs
+          .singleWhere((preference) => preference.label == 'sexual')
+          .labelerDid,
+      'did:plc:one',
+    );
   });
 
-  test('update exposes and rethrows repository errors', () async {
+  test('update rethrows errors without discarding committed data', () async {
     final initial = _preferences('initial');
     prefRepository.getResult = initial;
     final container = createContainer();
@@ -131,7 +226,8 @@ void main() {
     );
 
     expect(prefRepository.putCalls, [updated]);
-    expect(container.read(userPreferencesProvider).error, same(error));
+    expect(container.read(userPreferencesProvider).requireValue, initial);
+    expect(notifier.currentPreferences, initial);
   });
 
   test(
@@ -145,17 +241,99 @@ void main() {
       final notifier = container.read(userPreferencesProvider.notifier);
       Preferences? updaterInput;
 
-      await notifier.updatePreferencesWithFn((current) {
+      final committed = await notifier.updatePreferencesWithFn((current) {
         updaterInput = current;
         return updated;
       });
 
+      expect(committed, updated);
       expect(updaterInput, initial);
       expect(prefRepository.putCalls, [updated]);
       expect(container.read(userPreferencesProvider).value, updated);
     },
   );
 
+  test(
+    'serializes a rapid labeler setting against the latest document',
+    () async {
+      final initial = Preferences(
+        preferences: [
+          labelersPreference([LabelerPrefItem(did: 'did:plc:labeler')]),
+        ],
+      );
+      prefRepository.getResult = initial;
+      final firstWriteGate = Completer<void>();
+      prefRepository.putHandler = (call, preferences) async {
+        if (call == 1) await firstWriteGate.future;
+      };
+      final container = createContainer();
+      await container.read(userPreferencesProvider.future);
+      final notifier = container.read(userPreferencesProvider.notifier);
+
+      final adultUpdate = notifier.setAdultContentEnabled(true);
+      await pumpEventQueue();
+      final labelUpdate = container
+          .read(labelerSettingsControllerProvider)
+          .setLabelPreference(
+            'did:plc:labeler',
+            'custom',
+            ModerationSetting.hide,
+          );
+      await pumpEventQueue();
+
+      expect(prefRepository.putCalls, hasLength(1));
+      firstWriteGate.complete();
+      await Future.wait([adultUpdate, labelUpdate]);
+
+      expect(prefRepository.putCalls, hasLength(2));
+      final persisted = prefRepository.putCalls.last;
+      expect(persisted.adultContentEnabled, isTrue);
+      final labelPreference = persisted.contentLabelPrefs?.single;
+      expect(labelPreference?.labelerDid, 'did:plc:labeler');
+      expect(labelPreference?.label, 'custom');
+      expect(labelPreference?.visibility.toJson(), 'hide');
+    },
+  );
+
+  test('continues queued transformations after a failed write', () async {
+    final initial = _preferences('initial');
+    prefRepository.getResult = initial;
+    final firstWriteGate = Completer<void>();
+    final error = StateError('first write failed');
+    prefRepository.putHandler = (call, preferences) async {
+      if (call == 1) {
+        await firstWriteGate.future;
+        throw error;
+      }
+    };
+    final container = createContainer();
+    await container.read(userPreferencesProvider.future);
+    final notifier = container.read(userPreferencesProvider.notifier);
+
+    final failedUpdate = notifier.setAdultContentEnabled(true);
+    await pumpEventQueue();
+    final succeedingUpdate = notifier.setGlobalLabelPreference(
+      'porn',
+      ModerationSetting.warn,
+    );
+    firstWriteGate.complete();
+
+    await expectLater(failedUpdate, throwsA(same(error)));
+    await succeedingUpdate;
+
+    expect(prefRepository.putCalls, hasLength(2));
+    final persisted = prefRepository.putCalls.last;
+    expect(persisted.adultContentEnabled, isFalse);
+    expect(
+      persisted.contentLabelPrefs
+          ?.singleWhere((preference) => preference.label == 'porn')
+          .visibility
+          .toJson(),
+      'warn',
+    );
+    expect(container.read(userPreferencesProvider).requireValue, persisted);
+  });
+
   test('updatePreferencesWithFn rejects unloaded state', () async {
     final initialization = Completer<void>();
     authRepository.initializationComplete = initialization.future;
@@ -183,6 +361,7 @@ void main() {
 
 Preferences _preferences(String label) => Preferences(
   preferences: [
+    labelersPreference([LabelerPrefItem(did: 'did:plc:labeler')]),
     contentLabelPreference(
       labelerDid: 'did:plc:labeler',
       label: label,
@@ -195,6 +374,7 @@ class _FakePrefRepository implements PrefRepository {
   Preferences getResult = Preferences(preferences: []);
   Object? getError;
   Object? putError;
+  Future<void> Function(int call, Preferences preferences)? putHandler;
   int getCalls = 0;
   final List<Preferences> putCalls = [];
 
@@ -209,6 +389,7 @@ class _FakePrefRepository implements PrefRepository {
   @override
   Future<void> putPreferences(Preferences preferences) async {
     putCalls.add(preferences);
+    await putHandler?.call(putCalls.length, preferences);
     final error = putError;
     if (error != null) throw error;
   }
@@ -220,6 +401,22 @@ class _FakeSprkRepository implements SprkRepository {
   @override
   final AuthRepository authRepository;
 
+  final List<List<String>> labelerConfigurations = [];
+
+  @override
+  List<String> get labelerDids => const [];
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {
+    labelerConfigurations.add(labelerDids.toList(growable: false));
+  }
+
+  @override
+  Map<String, String> appViewHeaders(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  }) => const {};
+
   @override
   Future<T> executeWithRetry<T>(Future<T> Function() apiCall) => apiCall();
 
diff --git a/test/src/core/ui/widgets/report_dialog_test.dart b/test/src/core/ui/widgets/report_dialog_test.dart
new file mode 100644
index 00000000..4faaba9f
--- /dev/null
+++ b/test/src/core/ui/widgets/report_dialog_test.dart
@@ -0,0 +1,286 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/admin/defs.dart';
+import 'package:poptart_lex/com/atproto/moderation/create_report.dart';
+import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/app_button.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/ui/widgets/report_dialog.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+
+void main() {
+  setUp(() async {
+    await GetIt.I.reset();
+    GetIt.I
+      ..registerSingleton<LogService>(LogService())
+      ..registerSingleton<SprkRepository>(
+        _FakeSprkRepository(
+          _FakeLabelerRepository({
+            'did:plc:default': _service(
+              'did:plc:default',
+              'Default moderation',
+              subjectTypes: const ['record'],
+            ),
+            'did:plc:community': _service(
+              'did:plc:community',
+              'Community moderation',
+              subjectTypes: const ['record'],
+              subjectCollections: const ['so.sprk.feed.post'],
+            ),
+            'did:plc:accounts': _service(
+              'did:plc:accounts',
+              'Accounts only',
+              subjectTypes: const ['account'],
+            ),
+            'did:plc:bsky': _service(
+              'did:plc:bsky',
+              'Bluesky moderation',
+              subjectTypes: const ['account'],
+            ),
+          }),
+        ),
+      );
+  });
+
+  tearDown(() async => GetIt.I.reset());
+
+  testWidgets('offers only subscribed services compatible with the report', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      ProviderScope(
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(
+            body: ReportDialog(
+              subject: UModerationCreateReportSubject.repoStrongRef(
+                data: RepoStrongRef(
+                  uri: AtUri('at://did:plc:author/so.sprk.feed.post/example'),
+                  cid: 'example-cid',
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.text('Violence'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Animal Abuse'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Default moderation'), findsOneWidget);
+    await tester.tap(find.text('Default moderation'));
+    await tester.pumpAndSettle();
+    expect(find.text('Community moderation'), findsOneWidget);
+    expect(find.text('Accounts only'), findsNothing);
+    expect(find.text('Moderation service'), findsOneWidget);
+  });
+
+  testWidgets('uses the supplied fallback service for account reports', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      const ProviderScope(
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(
+            body: ReportDialog(
+              subject: UModerationCreateReportSubject.repoRef(
+                data: RepoRef(did: 'did:plc:account'),
+              ),
+              fallbackServiceDid: 'did:plc:bsky#atproto_labeler',
+            ),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.text('Violence'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Animal Abuse'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Bluesky moderation'), findsOneWidget);
+    expect(find.text('Moderation service'), findsOneWidget);
+  });
+
+  testWidgets('renders service discovery failures without an uncaught error', (
+    tester,
+  ) async {
+    await GetIt.I.unregister<SprkRepository>();
+    GetIt.I.registerSingleton<SprkRepository>(
+      _FakeSprkRepository(
+        _FakeLabelerRepository(
+          const {},
+          compatibilityError: StateError('discovery failed'),
+        ),
+      ),
+    );
+    await tester.pumpWidget(
+      ProviderScope(
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(
+            body: ReportDialog(
+              subject: UModerationCreateReportSubject.repoStrongRef(
+                data: RepoStrongRef(
+                  uri: AtUri('at://did:plc:author/so.sprk.feed.post/example'),
+                  cid: 'example-cid',
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.text('Violence'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Animal Abuse'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Could not load moderation services.'), findsOneWidget);
+  });
+
+  testWidgets('does not expose submission exceptions to the user', (
+    tester,
+  ) async {
+    await tester.binding.setSurfaceSize(const Size(800, 900));
+    addTearDown(() => tester.binding.setSurfaceSize(null));
+    await tester.pumpWidget(
+      ProviderScope(
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(
+            body: ReportDialog(
+              subject: UModerationCreateReportSubject.repoRef(
+                data: RepoRef(did: 'did:plc:account'),
+              ),
+              fallbackServiceDid: 'did:plc:bsky#atproto_labeler',
+              onSubmit: (_, _) async {
+                throw StateError('private transport detail');
+              },
+            ),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.text('Violence'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Animal Abuse'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(AppButton, 'Submit'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('An error occurred'), findsOneWidget);
+    expect(find.textContaining('private transport detail'), findsNothing);
+  });
+}
+
+class _FakeSprkRepository implements SprkRepository {
+  _FakeSprkRepository(this.labelerRepository);
+
+  final LabelerRepository labelerRepository;
+
+  @override
+  String get modDid => 'did:plc:default#atproto_labeler';
+
+  @override
+  String get bskyModDid => 'did:plc:bsky#atproto_labeler';
+
+  @override
+  List<String> get labelerDids => const [
+    'did:plc:default',
+    'did:plc:community',
+    'did:plc:accounts',
+  ];
+
+  @override
+  LabelerRepository get labeler => labelerRepository;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeLabelerRepository implements LabelerRepository {
+  const _FakeLabelerRepository(this.services, {this.compatibilityError});
+
+  final Map<String, LabelerViewDetailed> services;
+  final Object? compatibilityError;
+
+  @override
+  Future<List<CompatibleModerationService>> getCompatibleModerationServices(
+    Iterable<String> dids,
+    ModerationServiceQuery query,
+  ) async {
+    if (compatibilityError case final error?) throw error;
+    final candidates = <String>{query.fallbackDid, ...dids};
+    return [
+      for (final did in candidates)
+        if (services[did] case final service?)
+          if ((service.subjectTypes == null ||
+                  service.subjectTypes!.any(
+                    (type) => type.toJson() == query.subjectType,
+                  )) &&
+              (query.subjectCollection == null ||
+                  service.subjectCollections == null ||
+                  service.subjectCollections!.contains(
+                    query.subjectCollection,
+                  )))
+            CompatibleModerationService(
+              did: did,
+              displayName:
+                  service.creator.displayName ?? service.creator.handle,
+              isDefault: did == query.fallbackDid,
+            ),
+    ]..sort((left, right) => left.isDefault ? -1 : 1);
+  }
+
+  @override
+  Future<LabelerViewDetailed> getServicesDetailed(List<String> dids) async {
+    return services[dids.single] ??
+        (throw StateError('Unknown service ${dids.single}'));
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+LabelerViewDetailed _service(
+  String did,
+  String displayName, {
+  required List<String> subjectTypes,
+  List<String>? subjectCollections,
+}) {
+  return LabelerViewDetailed.fromJson({
+    r'$type': 'so.sprk.labeler.defs#labelerViewDetailed',
+    'uri': 'at://$did/so.sprk.labeler.service/self',
+    'cid': 'service-cid',
+    'creator': {
+      r'$type': 'so.sprk.actor.defs#profileView',
+      'did': did,
+      'handle': '${did.split(':').last}.test',
+      'displayName': displayName,
+    },
+    'policies': {
+      r'$type': 'so.sprk.labeler.defs#labelerPolicies',
+      'labelValues': <dynamic>[],
+    },
+    'indexedAt': '2026-08-08T12:00:00.000Z',
+    'subjectTypes': subjectTypes,
+    'subjectCollections': ?subjectCollections,
+  });
+}
diff --git a/test/src/core/utils/label_utils_test.dart b/test/src/core/utils/label_utils_test.dart
deleted file mode 100644
index c63113d4..00000000
--- a/test/src/core/utils/label_utils_test.dart
+++ /dev/null
@@ -1,247 +0,0 @@
-import 'package:flutter_test/flutter_test.dart';
-import 'package:poptart_lex/com/atproto/label/defs.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
-import 'package:spark/src/core/utils/label_utils.dart';
-
-void main() {
-  final indexedAt = DateTime.utc(2026, 1, 1);
-
-  group('LabelUtils', () {
-    group('getLabelPreferenceFromPrefs', () {
-      test('maps visibility to correct blurs/severity/setting/adultOnly', () {
-        final prefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:labeler',
-              label: 'porn',
-              visibility: 'warn',
-            ),
-            contentLabelPreference(
-              labelerDid: 'did:plc:labeler',
-              label: 'gore',
-              visibility: 'hide',
-            ),
-            contentLabelPreference(
-              labelerDid: 'did:plc:labeler',
-              label: 'nudity',
-              visibility: 'ignore',
-            ),
-          ],
-        );
-
-        final warn = LabelUtils.getLabelPreferenceFromPrefs(prefs, 'porn')!;
-        expect(warn.blurs, Blurs.media);
-        expect(warn.severity, Severity.alert);
-        expect(warn.setting, Setting.warn);
-        expect(warn.adultOnly, isTrue);
-
-        final hide = LabelUtils.getLabelPreferenceFromPrefs(prefs, 'gore')!;
-        expect(hide.blurs, Blurs.content);
-        expect(hide.severity, Severity.alert);
-        expect(hide.setting, Setting.hide);
-        expect(hide.adultOnly, isFalse);
-
-        final ignore = LabelUtils.getLabelPreferenceFromPrefs(prefs, 'nudity')!;
-        expect(ignore.blurs, Blurs.none);
-        expect(ignore.severity, Severity.none);
-        expect(ignore.setting, Setting.ignore);
-      });
-
-      test('returns null when label not found', () {
-        final prefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:labeler',
-              label: 'gore',
-              visibility: 'warn',
-            ),
-          ],
-        );
-        expect(
-          LabelUtils.getLabelPreferenceFromPrefs(prefs, 'unknown'),
-          isNull,
-        );
-      });
-
-      test('returns null when contentLabelPrefs is null', () {
-        final prefs = Preferences(preferences: []);
-        expect(LabelUtils.getLabelPreferenceFromPrefs(prefs, 'porn'), isNull);
-      });
-    });
-
-    group('shouldShowWarning', () {
-      test('returns true only when severity=alert and setting=warn', () {
-        final warnPrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'porn',
-              visibility: 'warn',
-            ),
-          ],
-        );
-        final hidePrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'porn',
-              visibility: 'hide',
-            ),
-          ],
-        );
-        final noMatchPrefs = Preferences(preferences: []);
-
-        final label = Label(
-          src: 'did:plc:l',
-          uri: 'at://test',
-          val: 'porn',
-          cts: indexedAt,
-        );
-
-        expect(LabelUtils.shouldShowWarning(warnPrefs, [label]), isTrue);
-        expect(LabelUtils.shouldShowWarning(hidePrefs, [label]), isFalse);
-        expect(LabelUtils.shouldShowWarning(noMatchPrefs, [label]), isFalse);
-        expect(LabelUtils.shouldShowWarning(warnPrefs, []), isFalse);
-      });
-    });
-
-    group('shouldBlurContent', () {
-      test('blurs on hide (content) and warn (media)', () {
-        final hidePrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'porn',
-              visibility: 'hide',
-            ),
-          ],
-        );
-        final warnPrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'sexual',
-              visibility: 'warn',
-            ),
-          ],
-        );
-        final ignorePrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'nudity',
-              visibility: 'ignore',
-            ),
-          ],
-        );
-
-        Label label(String val) =>
-            Label(src: 'did:plc:l', uri: 'at://test', val: val, cts: indexedAt);
-
-        expect(
-          LabelUtils.shouldBlurContent(hidePrefs, [label('porn')]),
-          isTrue,
-        );
-        expect(
-          LabelUtils.shouldBlurContent(warnPrefs, [label('sexual')]),
-          isTrue,
-        );
-        expect(
-          LabelUtils.shouldBlurContent(ignorePrefs, [label('nudity')]),
-          isFalse,
-        );
-      });
-    });
-
-    group('shouldHideContent', () {
-      test('hides when setting=hide or adultOnly=true', () {
-        final hidePrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'gore',
-              visibility: 'hide',
-            ),
-          ],
-        );
-        final warnAdultPrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'porn',
-              visibility: 'warn',
-            ),
-          ],
-        );
-        final warnNonAdultPrefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'gore',
-              visibility: 'warn',
-            ),
-          ],
-        );
-
-        Label label(String val) =>
-            Label(src: 'did:plc:l', uri: 'at://test', val: val, cts: indexedAt);
-
-        expect(
-          LabelUtils.shouldHideContent(hidePrefs, [label('gore')]),
-          isTrue,
-        );
-        expect(
-          LabelUtils.shouldHideContent(warnAdultPrefs, [label('porn')]),
-          isTrue,
-        );
-        expect(
-          LabelUtils.shouldHideContent(warnNonAdultPrefs, [label('gore')]),
-          isFalse,
-        );
-        expect(
-          LabelUtils.shouldHideContent(Preferences(preferences: []), []),
-          isFalse,
-        );
-      });
-    });
-
-    group('getWarningLabels', () {
-      test('returns only labels with severity=alert and setting=warn', () {
-        final prefs = Preferences(
-          preferences: [
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'gore',
-              visibility: 'warn',
-            ),
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'porn',
-              visibility: 'warn',
-            ),
-            contentLabelPreference(
-              labelerDid: 'did:plc:l',
-              label: 'nudity',
-              visibility: 'ignore',
-            ),
-          ],
-        );
-
-        final labels = ['gore', 'porn', 'nudity']
-            .map(
-              (v) => Label(
-                src: 'did:plc:l',
-                uri: 'at://test',
-                val: v,
-                cts: indexedAt,
-              ),
-            )
-            .toList();
-
-        final result = LabelUtils.getWarningLabels(prefs, labels);
-        expect(result, ['gore', 'porn']);
-      });
-    });
-  });
-}
diff --git a/test/src/features/feed/providers/feed_provider_test.dart b/test/src/features/feed/providers/feed_provider_test.dart
index 2e6d1041..c28edea0 100644
--- a/test/src/features/feed/providers/feed_provider_test.dart
+++ b/test/src/features/feed/providers/feed_provider_test.dart
@@ -5,8 +5,9 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:get_it/get_it.dart';
 import 'package:poptart/poptart.dart';
 import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
 import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
@@ -47,6 +48,9 @@ void main() {
           SettingsState(activeFeed: activeFeed ?? feed),
         ),
         feedSettingsGatewayProvider.overrideWithValue(settingsGateway),
+        moderationEngineProvider.overrideWith(
+          (ref) async => _moderationEngine(settingsGateway.hiddenLabels),
+        ),
       ],
     );
     addTearDown(container.dispose);
@@ -205,6 +209,157 @@ void main() {
     },
   );
 
+  test('author labels retain account and profile subject semantics', () async {
+    settingsGateway.hiddenLabels.add('blocked');
+    final profileLabeledPost = _post(
+      'profile-labeled',
+      authorLabels: [_authorLabel(profileRecord: true)],
+    );
+    final accountLabeledPost = _post(
+      'account-labeled',
+      authorLabels: [_authorLabel()],
+    );
+    feedRepository.enqueue(_page([profileLabeledPost, accountLabeledPost]));
+    final container = createContainer();
+    final notifier = readNotifier(container);
+
+    await notifier.loadAndUpdateFirstLoad();
+
+    expect(
+      container.read(feedProvider(feed)).loadedPosts.map((post) => post.uri),
+      [profileLabeledPost.uri],
+    );
+  });
+
+  test(
+    'a newer negation blocks stale data and yields to a newer assertion',
+    () async {
+      final original = _post(
+        'updated-label',
+        labels: [
+          Label(
+            ver: 1,
+            src: 'did:plc:moderator',
+            uri: 'at://did:plc:author/so.sprk.feed.post/updated-label',
+            val: 'sexual',
+            cts: _indexedAt,
+          ),
+        ],
+      );
+      final retracted = _post(
+        'updated-label',
+        labels: [
+          Label(
+            ver: 1,
+            src: 'did:plc:moderator',
+            uri: 'at://did:plc:author/so.sprk.feed.post/updated-label',
+            val: 'sexual',
+            neg: true,
+            cts: _indexedAt.add(const Duration(minutes: 1)),
+          ),
+        ],
+      );
+      final staleAssertion = original.copyWith(
+        labels: [original.labels!.single.copyWith(cts: _indexedAt)],
+      );
+      final reapplied = original.copyWith(
+        labels: [
+          original.labels!.single.copyWith(
+            cts: _indexedAt.add(const Duration(minutes: 2)),
+          ),
+        ],
+      );
+      feedRepository
+        ..enqueue(_page([original], cursor: 'next'))
+        ..enqueue(_page([retracted], cursor: 'after-retraction'))
+        ..enqueue(_page([staleAssertion], cursor: 'after-stale'))
+        ..enqueue(_page([reapplied]));
+      final container = createContainer();
+      final notifier = readNotifier(container);
+
+      await notifier.loadAndUpdateFirstLoad();
+      await notifier.scrollDown();
+      await notifier.scrollDown();
+
+      var state = container.read(feedProvider(feed));
+      expect(state.loadedPosts, hasLength(1));
+      expect(state.loadedPosts.single.labels, isEmpty);
+      expect(state.extraInfo[original.uri]!.postLabels.single.isNeg, isTrue);
+      expect(
+        state.extraInfo[original.uri]!.postLabels.single.cts,
+        _indexedAt.add(const Duration(minutes: 1)),
+      );
+
+      await notifier.scrollDown();
+
+      state = container.read(feedProvider(feed));
+      expect(state.loadedPosts.single.labels, [reapplied.labels!.single]);
+      expect(state.extraInfo[original.uri]!.postLabels, [
+        reapplied.labels!.single,
+      ]);
+    },
+  );
+
+  test('an all-hidden update removes the stale loaded post', () async {
+    settingsGateway.hiddenLabels.add('blocked');
+    final visible = _post('newly-hidden');
+    final hidden = _post('newly-hidden', label: 'blocked');
+    feedRepository
+      ..enqueue(_page([visible], cursor: 'next'))
+      ..enqueue(_page([hidden]));
+    final container = createContainer();
+    final notifier = readNotifier(container);
+
+    await notifier.loadAndUpdateFirstLoad();
+    expect(
+      container.read(feedProvider(feed)).loadedPosts.map((post) => post.uri),
+      [visible.uri],
+    );
+
+    await notifier.scrollDown();
+
+    final state = container.read(feedProvider(feed));
+    expect(state.loadedPosts, isEmpty);
+    expect(state.index, 0);
+    expect(state.extraInfo[visible.uri]!.postLabels.map((label) => label.val), [
+      'blocked',
+    ]);
+  });
+
+  test(
+    'expired assertions are cached as tombstones but not attached',
+    () async {
+      final post = _post(
+        'expired-label',
+        labels: [
+          Label(
+            ver: 1,
+            src: 'did:plc:moderator',
+            uri: 'at://did:plc:author/so.sprk.feed.post/expired-label',
+            val: 'sexual',
+            cts: _indexedAt,
+            exp: _indexedAt.add(const Duration(minutes: 1)),
+          ),
+        ],
+      );
+      final staleAssertion = post.copyWith(
+        labels: [post.labels!.single.copyWith(exp: null)],
+      );
+      feedRepository
+        ..enqueue(_page([post], cursor: 'next'))
+        ..enqueue(_page([staleAssertion]));
+      final container = createContainer();
+      final notifier = readNotifier(container);
+
+      await notifier.loadAndUpdateFirstLoad();
+      await notifier.scrollDown();
+
+      final state = container.read(feedProvider(feed));
+      expect(state.loadedPosts.single.labels, isEmpty);
+      expect(state.extraInfo[post.uri]!.postLabels, post.labels);
+    },
+  );
+
   test('an empty network page ends the feed', () async {
     feedRepository.enqueue(_page(const []));
     final container = createContainer();
@@ -289,27 +444,43 @@ Feed _feed(String id) => Feed(
   ),
 );
 
-PostView _post(String id, {String? label}) {
+PostView _post(
+  String id, {
+  String? label,
+  List<Label>? labels,
+  List<Label>? authorLabels,
+}) {
   final uri = AtUri.parse('at://did:plc:author/so.sprk.feed.post/$id');
   return PostView(
     uri: uri,
     cid: 'cid-$id',
-    author: _author,
+    author: _author.copyWith(labels: authorLabels),
     record: {r'$type': 'so.sprk.feed.post', 'text': id},
     indexedAt: _indexedAt,
-    labels: label == null
-        ? null
-        : [
-            Label(
-              src: 'did:plc:moderator',
-              uri: uri.toString(),
-              val: label,
-              cts: _indexedAt,
-            ),
-          ],
+    labels:
+        labels ??
+        (label == null
+            ? null
+            : [
+                Label(
+                  src: 'did:plc:moderator',
+                  uri: uri.toString(),
+                  val: label,
+                  cts: _indexedAt,
+                ),
+              ]),
   );
 }
 
+Label _authorLabel({bool profileRecord = false}) => Label(
+  src: 'did:plc:moderator',
+  uri: profileRecord
+      ? 'at://did:plc:author/app.bsky.actor.profile/self'
+      : 'did:plc:author',
+  val: 'blocked',
+  cts: _indexedAt,
+);
+
 FeedView _page(List<PostView> posts, {String? cursor}) {
   return FeedView(
     cursor: cursor,
@@ -376,18 +547,39 @@ class _FakeFeedSettingsGateway implements FeedSettingsGateway {
 
   @override
   Future<List<String>> getLabelers() async => const ['did:plc:moderator'];
+}
 
-  @override
-  Future<LabelPreference> getLabelPreference(String value) async {
-    return LabelPreference(
-      value: value,
-      blurs: Blurs.none,
-      severity: Severity.none,
-      defaultSetting: Setting.ignore,
-      setting: hiddenLabels.contains(value) ? Setting.hide : Setting.ignore,
-      adultOnly: false,
-    );
-  }
+ModerationEngine _moderationEngine(Iterable<String> hiddenLabels) {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions(
+      definitions: [
+        for (final value in hiddenLabels)
+          ModerationLabelDefinition(
+            identifier: value,
+            definedBy: 'did:plc:moderator',
+            severity: ModerationSeverity.alert,
+            blurs: ModerationBlur.content,
+            defaultSetting: ModerationSetting.hide,
+            configurable: true,
+            flags: const {ModerationLabelFlag.noSelf},
+            locales: const [],
+            behaviors: {
+              ModerationTarget.content: ModerationBehavior({
+                ModerationContext.contentList: ModerationAction.blur,
+              }),
+              ModerationTarget.account: ModerationBehavior({
+                ModerationContext.contentList: ModerationAction.blur,
+              }),
+            },
+          ),
+      ],
+    ),
+    preferences: ModerationPreferences(
+      labels: const [],
+      adultContentEnabled: true,
+      authenticated: true,
+    ),
+  );
 }
 
 class _FakeSprkRepository implements SprkRepository {
diff --git a/test/src/features/feed/providers/visible_pinned_feeds_provider_test.dart b/test/src/features/feed/providers/visible_pinned_feeds_provider_test.dart
new file mode 100644
index 00000000..138273e2
--- /dev/null
+++ b/test/src/features/feed/providers/visible_pinned_feeds_provider_test.dart
@@ -0,0 +1,165 @@
+import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/features/feed/providers/visible_pinned_feeds_provider.dart';
+import 'package:spark/src/features/settings/providers/settings_provider.dart';
+import 'package:spark/src/features/settings/providers/settings_state.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+void main() {
+  test('conceals labeled generators while moderation is pending', () {
+    final moderation = Completer<ModerationEngine>();
+    final timeline = _timeline();
+    final labeled = _feed('labeled', generatorLabels: [_label()]);
+    final unlabeled = _feed('unlabeled');
+    final container = ProviderContainer.test(
+      overrides: [
+        settingsProvider.overrideWithValue(
+          SettingsState(
+            activeFeed: timeline,
+            feeds: [timeline, labeled, unlabeled],
+          ),
+        ),
+        moderationEngineProvider.overrideWith((ref) => moderation.future),
+      ],
+    );
+    addTearDown(container.dispose);
+
+    final visiblePinnedFeeds = container.read(visiblePinnedFeedsProvider);
+
+    expect(visiblePinnedFeeds.effectiveActiveFeed, timeline);
+    expect(visiblePinnedFeeds.shouldPersistEffectiveActiveFeed, isFalse);
+    expect(visiblePinnedFeeds.feeds, [timeline, unlabeled]);
+  });
+
+  test('uses one ordered list with profile-aware creator moderation', () async {
+    final timeline = _timeline();
+    final accountLabeled = _feed(
+      'account-labeled',
+      creatorLabels: [_label(account: true)],
+    );
+    final profileLabeled = _feed('profile-labeled', creatorLabels: [_label()]);
+    final generatorLabeled = _feed(
+      'generator-labeled',
+      generatorLabels: [_label()],
+    );
+    final visible = _feed('visible');
+    final container = ProviderContainer.test(
+      overrides: [
+        settingsProvider.overrideWithValue(
+          SettingsState(
+            activeFeed: timeline,
+            feeds: [
+              timeline,
+              accountLabeled,
+              profileLabeled,
+              generatorLabeled,
+              visible,
+            ],
+          ),
+        ),
+        moderationEngineProvider.overrideWith((ref) async => _engine()),
+      ],
+    );
+    addTearDown(container.dispose);
+
+    await container.read(moderationEngineProvider.future);
+
+    final visiblePinnedFeeds = container.read(visiblePinnedFeedsProvider);
+
+    expect(visiblePinnedFeeds.effectiveActiveFeed, timeline);
+    expect(visiblePinnedFeeds.shouldPersistEffectiveActiveFeed, isFalse);
+    expect(visiblePinnedFeeds.feeds, [timeline, profileLabeled, visible]);
+  });
+}
+
+final _indexedAt = DateTime.utc(2026, 8, 11);
+
+Feed _timeline() => Feed(
+  type: 'timeline',
+  config: makeSavedFeed(
+    type: 'timeline',
+    value: 'following',
+    pinned: true,
+    id: 'timeline',
+  ),
+);
+
+Feed _feed(
+  String id, {
+  List<Label>? generatorLabels,
+  List<Label>? creatorLabels,
+}) {
+  final creator = ProfileView(
+    did: 'did:plc:creator',
+    handle: 'creator.sprk.so',
+    labels: creatorLabels,
+  );
+  return Feed(
+    type: 'feed',
+    config: makeSavedFeed(
+      type: 'feed',
+      value: 'at://did:plc:feed/so.sprk.feed.generator/$id',
+      pinned: true,
+      id: id,
+    ),
+    view: GeneratorView(
+      uri: AtUri('at://did:plc:feed/so.sprk.feed.generator/$id'),
+      cid: 'cid-$id',
+      did: 'did:plc:feed',
+      creator: creator,
+      displayName: id,
+      labels: generatorLabels,
+      indexedAt: _indexedAt,
+    ),
+  );
+}
+
+Label _label({bool account = false}) => Label(
+  src: 'did:plc:moderator',
+  uri: account
+      ? 'did:plc:creator'
+      : 'at://did:plc:creator/app.bsky.actor.profile/self',
+  val: 'blocked',
+  cts: _indexedAt,
+);
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions(
+    definitions: [
+      ModerationLabelDefinition(
+        identifier: 'blocked',
+        definedBy: 'did:plc:moderator',
+        severity: ModerationSeverity.alert,
+        blurs: ModerationBlur.content,
+        defaultSetting: ModerationSetting.hide,
+        configurable: true,
+        flags: const {ModerationLabelFlag.noSelf},
+        locales: const [],
+        behaviors: {
+          ModerationTarget.content: ModerationBehavior({
+            ModerationContext.contentList: ModerationAction.blur,
+          }),
+          ModerationTarget.account: ModerationBehavior({
+            ModerationContext.contentList: ModerationAction.blur,
+          }),
+          ModerationTarget.profile: ModerationBehavior({
+            ModerationContext.profileList: ModerationAction.blur,
+          }),
+        },
+      ),
+    ],
+  ),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);
diff --git a/test/src/features/feed/ui/pages/feeds_page_test.dart b/test/src/features/feed/ui/pages/feeds_page_test.dart
new file mode 100644
index 00000000..93388f70
--- /dev/null
+++ b/test/src/features/feed/ui/pages/feeds_page_test.dart
@@ -0,0 +1,262 @@
+import 'dart:async';
+import 'dart:collection';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/features/feed/providers/feed_provider.dart';
+import 'package:spark/src/features/feed/providers/feed_state.dart';
+import 'package:spark/src/features/feed/ui/pages/feeds_page.dart';
+import 'package:spark/src/features/settings/providers/settings_provider.dart';
+import 'package:spark/src/features/settings/providers/settings_state.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+void main() {
+  testWidgets('does not persist a fallback while feed moderation is pending', (
+    tester,
+  ) async {
+    final moderation = Completer<ModerationEngine>();
+    final timeline = _timeline();
+    final labeled = _feed('labeled');
+    final container = _container(
+      moderation: moderation,
+      timeline: timeline,
+      labeled: labeled,
+    );
+    addTearDown(container.dispose);
+
+    await _pumpFeedsPage(tester, container);
+
+    final settings = container.read(settingsProvider.notifier) as _FakeSettings;
+    expect(settings.selectedFeeds, isEmpty);
+    expect(container.read(settingsProvider).activeFeed, labeled);
+    expect(
+      (container.read(feedProvider(timeline).notifier) as _FakeFeedNotifier)
+          .loadCalls,
+      1,
+    );
+
+    moderation.complete(_engine(hideLabeledFeed: false));
+    await tester.pump();
+    await tester.pump();
+
+    expect(settings.selectedFeeds, isEmpty);
+    expect(container.read(settingsProvider).activeFeed, labeled);
+
+    await _disposeFeedsPage(tester);
+  });
+
+  testWidgets('persists a fallback after moderation hides the active feed', (
+    tester,
+  ) async {
+    final moderation = Completer<ModerationEngine>();
+    final timeline = _timeline();
+    final labeled = _feed('labeled');
+    final container = _container(
+      moderation: moderation,
+      timeline: timeline,
+      labeled: labeled,
+    );
+    addTearDown(container.dispose);
+
+    await _pumpFeedsPage(tester, container);
+
+    final settings = container.read(settingsProvider.notifier) as _FakeSettings;
+    expect(settings.selectedFeeds, isEmpty);
+
+    moderation.complete(_engine(hideLabeledFeed: true));
+    await tester.pump();
+    await tester.pump();
+
+    expect(settings.selectedFeeds, [timeline]);
+    expect(container.read(settingsProvider).activeFeed, timeline);
+
+    await _disposeFeedsPage(tester);
+  });
+
+  testWidgets(
+    'persists a non-moderation fallback while moderation is pending',
+    (tester) async {
+      final moderation = Completer<ModerationEngine>();
+      final timeline = _timeline();
+      final unpinned = _feed('unpinned', pinned: false);
+      final container = _container(
+        moderation: moderation,
+        timeline: timeline,
+        labeled: unpinned,
+      );
+      addTearDown(container.dispose);
+
+      await _pumpFeedsPage(tester, container);
+
+      final settings =
+          container.read(settingsProvider.notifier) as _FakeSettings;
+      expect(settings.selectedFeeds, [timeline]);
+      expect(container.read(settingsProvider).activeFeed, timeline);
+
+      await _disposeFeedsPage(tester);
+    },
+  );
+}
+
+ProviderContainer _container({
+  required Completer<ModerationEngine> moderation,
+  required Feed timeline,
+  required Feed labeled,
+}) {
+  return ProviderContainer.test(
+    overrides: [
+      settingsProvider.overrideWith(
+        () => _FakeSettings(
+          SettingsState(activeFeed: labeled, feeds: [timeline, labeled]),
+        ),
+      ),
+      moderationEngineProvider.overrideWith((ref) => moderation.future),
+      feedProvider.overrideWith2((feed) => _FakeFeedNotifier()),
+    ],
+  );
+}
+
+Future<void> _pumpFeedsPage(
+  WidgetTester tester,
+  ProviderContainer container,
+) async {
+  await tester.pumpWidget(
+    UncontrolledProviderScope(
+      container: container,
+      child: MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: const FeedsPage(),
+      ),
+    ),
+  );
+  await tester.pump();
+}
+
+Future<void> _disposeFeedsPage(WidgetTester tester) async {
+  await tester.pumpWidget(const SizedBox.shrink());
+  await tester.pump(const Duration(milliseconds: 1));
+}
+
+class _FakeSettings extends Settings {
+  _FakeSettings(this.initialState);
+
+  final SettingsState initialState;
+  final List<Feed> selectedFeeds = [];
+
+  @override
+  SettingsState build() => initialState;
+
+  @override
+  Future<void> setActiveFeed(Feed feed) async {
+    selectedFeeds.add(feed);
+    state = state.copyWith(activeFeed: feed);
+  }
+}
+
+class _FakeFeedNotifier extends FeedNotifier {
+  int loadCalls = 0;
+
+  @override
+  FeedState build(Feed feed) => FeedState(
+    active: false,
+    loadedPosts: const [],
+    index: 0,
+    isEndOfNetworkFeed: false,
+    cursor: null,
+    loadingFirstLoad: false,
+    error: false,
+    extraInfo: LinkedHashMap(),
+  );
+
+  @override
+  Future<void> loadAndUpdateFirstLoad() async {
+    loadCalls++;
+  }
+
+  @override
+  Future<void> setActive(bool active) async {
+    state = state.copyWith(active: active);
+  }
+}
+
+final _indexedAt = DateTime.utc(2026, 8, 14);
+
+Feed _timeline() => Feed(
+  type: 'timeline',
+  config: makeSavedFeed(
+    type: 'timeline',
+    value: 'following',
+    pinned: true,
+    id: 'timeline',
+  ),
+);
+
+Feed _feed(String id, {bool pinned = true}) {
+  final creator = ProfileView(
+    did: 'did:plc:creator',
+    handle: 'creator.sprk.so',
+  );
+  return Feed(
+    type: 'feed',
+    config: makeSavedFeed(
+      type: 'feed',
+      value: 'at://did:plc:feed/so.sprk.feed.generator/$id',
+      pinned: pinned,
+      id: id,
+    ),
+    view: GeneratorView(
+      uri: AtUri('at://did:plc:feed/so.sprk.feed.generator/$id'),
+      cid: 'cid-$id',
+      did: 'did:plc:feed',
+      creator: creator,
+      displayName: id,
+      labels: [
+        Label(
+          src: 'did:plc:moderator',
+          uri: 'at://did:plc:feed/so.sprk.feed.generator/$id',
+          val: 'blocked',
+          cts: _indexedAt,
+        ),
+      ],
+      indexedAt: _indexedAt,
+    ),
+  );
+}
+
+ModerationEngine _engine({required bool hideLabeledFeed}) => ModerationEngine(
+  definitions: ModerationLabelDefinitions(
+    definitions: [
+      ModerationLabelDefinition(
+        identifier: 'blocked',
+        definedBy: 'did:plc:moderator',
+        severity: ModerationSeverity.alert,
+        blurs: ModerationBlur.content,
+        defaultSetting: hideLabeledFeed
+            ? ModerationSetting.hide
+            : ModerationSetting.warn,
+        configurable: true,
+        flags: const {ModerationLabelFlag.noSelf},
+        locales: const [],
+        behaviors: {
+          ModerationTarget.content: ModerationBehavior({
+            ModerationContext.contentList: ModerationAction.blur,
+          }),
+        },
+      ),
+    ],
+  ),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);
diff --git a/test/src/features/feed/ui/pages/standalone_post_page_test.dart b/test/src/features/feed/ui/pages/standalone_post_page_test.dart
new file mode 100644
index 00000000..ed2c0bb3
--- /dev/null
+++ b/test/src/features/feed/ui/pages/standalone_post_page_test.dart
@@ -0,0 +1,203 @@
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/routing/app_router.dart';
+import 'package:spark/src/features/feed/ui/pages/standalone_post_page.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+const _postUri = 'at://did:plc:author/so.sprk.feed.post/root';
+const _replyUri = 'at://did:plc:reply/so.sprk.feed.reply/highlighted';
+
+void main() {
+  setUp(() async {
+    await GetIt.I.reset();
+  });
+
+  tearDown(() async {
+    await GetIt.I.reset();
+  });
+
+  testWidgets('waits for reveal before opening a highlighted reply', (
+    tester,
+  ) async {
+    final post = _post(
+      labels: [
+        Label(
+          src: 'did:plc:author',
+          uri: _postUri,
+          val: 'sexual',
+          cts: DateTime.utc(2026, 8, 26),
+        ),
+      ],
+    );
+    await _pumpPage(tester, post);
+
+    expect(find.text('Content warning'), findsOneWidget);
+    expect(find.text('Comments destination'), findsNothing);
+
+    await tester.tap(find.text('View content'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Comments destination'), findsOneWidget);
+  });
+
+  testWidgets('opens an unmoderated highlighted reply automatically', (
+    tester,
+  ) async {
+    await _pumpPage(tester, _post());
+
+    expect(find.text('Comments destination'), findsOneWidget);
+  });
+
+  testWidgets('comment bar waits for concealed content to be revealed', (
+    tester,
+  ) async {
+    final post = _post(
+      labels: [
+        Label(
+          src: 'did:plc:author',
+          uri: _postUri,
+          val: 'sexual',
+          cts: DateTime.utc(2026, 8, 26),
+        ),
+      ],
+    );
+    await _pumpPage(tester, post, highlightedReplyUri: null);
+
+    await tester.tap(find.text('Add comment...'));
+    await tester.pump();
+    expect(find.text('Comments destination'), findsNothing);
+
+    await tester.tap(find.text('View content'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Add comment...'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Comments destination'), findsOneWidget);
+  });
+}
+
+Future<void> _pumpPage(
+  WidgetTester tester,
+  PostView post, {
+  String? highlightedReplyUri = _replyUri,
+}) async {
+  final feedRepository = _FakeFeedRepository(post);
+  GetIt.I.registerSingleton<SprkRepository>(
+    _FakeSprkRepository(feedRepository),
+  );
+  GetIt.I.registerSingleton<AuthRepository>(_FakeAuthRepository());
+
+  final router = RootStackRouter.build(
+    routes: [
+      AutoRoute(
+        page: PageInfo.builder(
+          StandalonePostRoute.name,
+          builder: (context, data) => StandalonePostPage(
+            postUri: _postUri,
+            highlightedReplyUri: highlightedReplyUri,
+          ),
+        ),
+        path: '/',
+        initial: true,
+      ),
+      AutoRoute(
+        page: PageInfo.builder(
+          CommentsRoute.name,
+          builder: (context, data) =>
+              const Scaffold(body: Center(child: Text('Comments destination'))),
+        ),
+        path: '/comments',
+      ),
+    ],
+  );
+
+  await tester.pumpWidget(
+    ProviderScope(
+      overrides: [
+        moderationEngineProvider.overrideWith((ref) async => _engine()),
+      ],
+      child: MaterialApp.router(
+        routerConfig: router.config(),
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+      ),
+    ),
+  );
+  await tester.pumpAndSettle();
+}
+
+PostView _post({List<Label>? labels}) {
+  return PostView(
+    uri: AtUri.parse(_postUri),
+    cid: 'cid-root',
+    author: const ProfileViewBasic(
+      did: 'did:plc:author',
+      handle: 'author.sprk.so',
+    ),
+    record: const {r'$type': 'so.sprk.feed.post', 'text': 'root post'},
+    indexedAt: DateTime.utc(2026, 8, 26),
+    labels: labels,
+  );
+}
+
+ModerationEngine _engine() {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers({
+      'did:plc:author': const [],
+    }),
+    preferences: ModerationPreferences(
+      labels: const [],
+      adultContentEnabled: true,
+      authenticated: true,
+    ),
+  );
+}
+
+class _FakeSprkRepository implements SprkRepository {
+  const _FakeSprkRepository(this.feed);
+
+  @override
+  final FeedRepository feed;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeAuthRepository implements AuthRepository {
+  @override
+  String? get did => null;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeFeedRepository implements FeedRepository {
+  const _FakeFeedRepository(this.post);
+
+  final PostView post;
+
+  @override
+  Future<Thread> getThread(
+    AtUri uri, {
+    int depth = 2,
+    int parentHeight = 0,
+    bool bluesky = false,
+  }) async {
+    return ThreadViewPost(post: ThreadPost.post(post: post));
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
diff --git a/test/src/features/feed/ui/widgets/post_likes_sheet_test.dart b/test/src/features/feed/ui/widgets/post_likes_sheet_test.dart
new file mode 100644
index 00000000..58323212
--- /dev/null
+++ b/test/src/features/feed/ui/widgets/post_likes_sheet_test.dart
@@ -0,0 +1,129 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/features/feed/ui/widgets/post_likes_sheet.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+void main() {
+  setUp(() async {
+    await GetIt.I.reset();
+  });
+
+  tearDown(() async {
+    await GetIt.I.reset();
+  });
+
+  testWidgets('filters account-hidden actors from the likes list', (
+    tester,
+  ) async {
+    final repository = _FakeFeedRepository([
+      _like('visible'),
+      _like('hidden', hidden: true),
+    ]);
+    GetIt.I
+      ..registerSingleton<SprkRepository>(_FakeSprkRepository(repository))
+      ..registerSingleton<LogService>(LogService());
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          moderationEngineProvider.overrideWith((ref) async => _engine()),
+        ],
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Builder(
+            builder: (context) => Scaffold(
+              body: TextButton(
+                onPressed: () => showPostLikesSheet(
+                  context: context,
+                  uri: 'at://did:plc:author/so.sprk.feed.post/post',
+                ),
+                child: const Text('Show likes'),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.text('Show likes'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Visible'), findsOneWidget);
+    expect(find.text('Hidden'), findsNothing);
+  });
+}
+
+PostLike _like(String name, {bool hidden = false}) {
+  final did = 'did:plc:$name';
+  return PostLike(
+    indexedAt: DateTime.utc(2026, 8, 17),
+    createdAt: DateTime.utc(2026, 8, 17),
+    actor: ProfileView(
+      did: did,
+      handle: '$name.sprk.so',
+      displayName: name[0].toUpperCase() + name.substring(1),
+      labels: hidden
+          ? [
+              Label(
+                src: 'did:plc:moderator',
+                uri: did,
+                val: '!hide',
+                cts: DateTime.utc(2026, 8, 17),
+              ),
+            ]
+          : null,
+    ),
+  );
+}
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions.fromLabelers(const {
+    'did:plc:moderator': [],
+  }),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);
+
+class _FakeFeedRepository implements FeedRepository {
+  const _FakeFeedRepository(this.likes);
+
+  final List<PostLike> likes;
+
+  @override
+  Future<({List<PostLike> likes, String? cursor})> getLikes(
+    AtUri uri, {
+    String? cid,
+    int limit = 50,
+    String? cursor,
+  }) async => (likes: likes, cursor: null);
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeSprkRepository implements SprkRepository {
+  const _FakeSprkRepository(this.feedRepository);
+
+  final FeedRepository feedRepository;
+
+  @override
+  FeedRepository get feed => feedRepository;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
diff --git a/test/src/features/profile/ui/pages/profile_page_test.dart b/test/src/features/profile/ui/pages/profile_page_test.dart
new file mode 100644
index 00000000..a2b3d721
--- /dev/null
+++ b/test/src/features/profile/ui/pages/profile_page_test.dart
@@ -0,0 +1,158 @@
+import 'dart:async';
+
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/actor_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/routing/app_router.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/features/auth/providers/auth_providers.dart';
+import 'package:spark/src/features/profile/ui/pages/profile_page.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+const _profileDid = 'did:plc:profile';
+
+void main() {
+  setUp(() async {
+    await GetIt.I.reset();
+  });
+
+  tearDown(() async {
+    await GetIt.I.reset();
+  });
+
+  testWidgets('moderates the complete initial profile while loading', (
+    tester,
+  ) async {
+    final actorRepository = _PendingActorRepository();
+    GetIt.I
+      ..registerSingleton<AuthRepository>(_FakeAuthRepository())
+      ..registerSingleton<ActorRepository>(actorRepository)
+      ..registerSingleton<SprkRepository>(
+        const _FakeSprkRepository(_FakeFeedRepository()),
+      )
+      ..registerSingleton<LogService>(LogService());
+
+    final initialProfile = ProfileViewBasic(
+      did: _profileDid,
+      handle: 'hidden.sprk.so',
+      displayName: 'Hidden Person',
+      labels: [
+        Label(
+          src: 'did:plc:moderator',
+          uri: 'at://$_profileDid/so.sprk.actor.profile/self',
+          val: '!hide',
+          cts: DateTime.utc(2026, 8, 26),
+        ),
+      ],
+    );
+    final router = RootStackRouter.build(
+      routes: [
+        AutoRoute(
+          page: PageInfo.builder(
+            ProfileRoute.name,
+            builder: (context, data) =>
+                ProfilePage(did: _profileDid, initialProfile: initialProfile),
+          ),
+          path: '/',
+          initial: true,
+        ),
+      ],
+    );
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          currentDidProvider.overrideWith((ref) => null),
+          moderationEngineProvider.overrideWith((ref) async => _engine()),
+        ],
+        child: MaterialApp.router(
+          routerConfig: router.config(),
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+        ),
+      ),
+    );
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 100));
+
+    expect(find.text('Content warning'), findsOneWidget);
+    expect(find.text('This restriction cannot be overridden.'), findsOneWidget);
+    expect(find.text('View content'), findsNothing);
+  });
+}
+
+ModerationEngine _engine() {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers(const {
+      'did:plc:moderator': [],
+    }),
+    preferences: ModerationPreferences(
+      labels: const [],
+      adultContentEnabled: true,
+      authenticated: true,
+    ),
+  );
+}
+
+class _PendingActorRepository implements ActorRepository {
+  final Completer<ProfileViewDetailed> _profile =
+      Completer<ProfileViewDetailed>();
+
+  @override
+  Future<ProfileViewDetailed> getProfile(
+    String did, {
+    bool useBluesky = false,
+  }) => _profile.future;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeAuthRepository implements AuthRepository {
+  @override
+  String? get did => null;
+
+  @override
+  bool get isAuthenticated => false;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeSprkRepository implements SprkRepository {
+  const _FakeSprkRepository(this.feed);
+
+  @override
+  final FeedRepository feed;
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _FakeFeedRepository implements FeedRepository {
+  const _FakeFeedRepository();
+
+  @override
+  Future<({List<FeedViewPost> posts, String? cursor})> getAuthorFeed(
+    AtUri actorUri, {
+    int limit = 20,
+    String? cursor,
+    bool videosOnly = false,
+    bool bluesky = false,
+  }) async => (posts: <FeedViewPost>[], cursor: null);
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
diff --git a/test/src/features/search/data/repositories/post_search_repository_test.dart b/test/src/features/search/data/repositories/post_search_repository_test.dart
new file mode 100644
index 00000000..06e75bdd
--- /dev/null
+++ b/test/src/features/search/data/repositories/post_search_repository_test.dart
@@ -0,0 +1,41 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
+import 'package:spark/src/core/utils/logging/logger.dart';
+import 'package:spark/src/features/search/data/repositories/post_search_repository.dart';
+
+import '../../../../core/network/atproto/data/repositories/repository_test_support.dart';
+
+void main() {
+  test(
+    'Bluesky search uses its appview proxy and subscribed labelers',
+    () async {
+      final harness = RepositoryHarness(
+        getResponse: const {'posts': <dynamic>[], 'cursor': 'next'},
+      );
+      harness.sprk.configureLabelers(const ['did:plc:custom']);
+      final repository = PostSearchRepositoryImpl(
+        _UnusedFeedRepository(),
+        harness.sprk,
+        SparkLogger(),
+      );
+
+      final result = await repository.searchBsky('cats', cursor: 'page');
+
+      final request = harness.transport.singleRequest;
+      expect(request.uri.path, '/xrpc/app.bsky.feed.searchPosts');
+      expect(request.uri.queryParameters['q'], 'cats');
+      expect(request.uri.queryParameters['sort'], 'latest');
+      expect(request.uri.queryParameters['cursor'], 'page');
+      expect(request.headers['atproto-proxy'], FakeSprkRepository.testBskyDid);
+      expect(request.headers['atproto-accept-labelers'], 'did:plc:custom');
+      expect(result.posts, isEmpty);
+      expect(result.cursor, 'next');
+    },
+  );
+}
+
+class _UnusedFeedRepository implements FeedRepository {
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
diff --git a/test/src/features/search/providers/post_search_provider_test.dart b/test/src/features/search/providers/post_search_provider_test.dart
index 39ffea3e..73b4631b 100644
--- a/test/src/features/search/providers/post_search_provider_test.dart
+++ b/test/src/features/search/providers/post_search_provider_test.dart
@@ -6,8 +6,9 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:get_it/get_it.dart';
 import 'package:poptart/poptart.dart';
 import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/core/providers/debounce_scheduler.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/features/search/data/repositories/post_search_repository.dart';
@@ -46,6 +47,11 @@ void main() {
         sprk: (
           posts: [
             _post('hidden', label: 'blocked'),
+            _post(
+              'profile-labeled-author',
+              authorLabels: [_authorLabel(profileRecord: true)],
+            ),
+            _post('account-labeled-author', authorLabels: [_authorLabel()]),
             _post('spark'),
           ],
           cursor: null,
@@ -56,15 +62,35 @@ void main() {
     final scope = container(
       overrides: [
         postSearchRepositoryProvider.overrideWithValue(repository),
-        postSearchPreferencesProvider.overrideWithValue(
-          Preferences(
-            preferences: [
-              contentLabelPreference(
-                labelerDid: 'did:plc:mod',
-                label: 'blocked',
-                visibility: 'hide',
-              ),
-            ],
+        moderationEngineProvider.overrideWith(
+          (ref) async => ModerationEngine(
+            definitions: ModerationLabelDefinitions(
+              definitions: [
+                ModerationLabelDefinition(
+                  identifier: 'blocked',
+                  definedBy: 'did:plc:mod',
+                  severity: ModerationSeverity.alert,
+                  blurs: ModerationBlur.content,
+                  defaultSetting: ModerationSetting.hide,
+                  configurable: true,
+                  flags: const {ModerationLabelFlag.noSelf},
+                  locales: const [],
+                  behaviors: {
+                    ModerationTarget.content: ModerationBehavior({
+                      ModerationContext.contentList: ModerationAction.blur,
+                    }),
+                    ModerationTarget.account: ModerationBehavior({
+                      ModerationContext.contentList: ModerationAction.blur,
+                    }),
+                  },
+                ),
+              ],
+            ),
+            preferences: ModerationPreferences(
+              labels: const [],
+              adultContentEnabled: true,
+              authenticated: true,
+            ),
           ),
         ),
       ],
@@ -76,7 +102,11 @@ void main() {
 
     final state = scope.read(postSearchProvider);
     expect(state.query, 'clips');
-    expect(state.searchResults.map((post) => post.uri.rkey), ['spark', 'bsky']);
+    expect(state.searchResults.map((post) => post.uri.rkey), [
+      'profile-labeled-author',
+      'spark',
+      'bsky',
+    ]);
     expect(state.isLoading, isFalse);
     expect(state.sprkNextCursor, isNull);
     expect(state.bskyNextCursor, isNull);
@@ -112,6 +142,50 @@ void main() {
     );
   });
 
+  test(
+    'query change while moderation resolves cannot publish stale results',
+    () async {
+      final repository = _FakePostSearchRepository();
+      final secondResponse = Completer<InitialPostSearchResult>();
+      repository.initialResponses
+        ..add(() async => _initial([_post('first')]))
+        ..add(() => secondResponse.future);
+      final moderation = Completer<ModerationEngine>();
+      final scope = container(
+        overrides: [
+          postSearchRepositoryProvider.overrideWithValue(repository),
+          moderationEngineProvider.overrideWith((ref) => moderation.future),
+        ],
+      );
+      final subscription = scope.listen(
+        postSearchProvider,
+        (previous, next) {},
+      );
+      addTearDown(subscription.close);
+      final notifier = scope.read(postSearchProvider.notifier);
+
+      final firstRequest = notifier.submitQuery('first');
+      await pumpEventQueue();
+      final secondRequest = notifier.submitQuery('second');
+      await pumpEventQueue();
+
+      moderation.complete(_engine());
+      await firstRequest;
+
+      final pendingSecondState = scope.read(postSearchProvider);
+      expect(pendingSecondState.query, 'second');
+      expect(pendingSecondState.searchResults, isEmpty);
+      expect(pendingSecondState.isLoading, isTrue);
+
+      secondResponse.complete(_initial([_post('second')]));
+      await secondRequest;
+      expect(
+        scope.read(postSearchProvider).searchResults.single.uri.rkey,
+        'second',
+      );
+    },
+  );
+
   test(
     'pagination suppresses duplicates and stops after cursors end',
     () async {
@@ -153,6 +227,62 @@ void main() {
     },
   );
 
+  test(
+    'query change while paginated moderation resolves discards the page',
+    () async {
+      final repository = _FakePostSearchRepository();
+      repository.initialResponses.add(
+        () async => (
+          sprk: (
+            posts: List.generate(10, (i) => _post('initial-$i')),
+            cursor: 'next',
+          ),
+          bsky: (posts: const <PostView>[], cursor: null),
+        ),
+      );
+      final pageReturned = Completer<void>();
+      repository.sprkResponses.add(() {
+        pageReturned.complete();
+        return Future.value((posts: [_post('stale-page')], cursor: null));
+      });
+      final paginationModeration = Completer<ModerationEngine>();
+      var moderationBuilds = 0;
+      final scope = container(
+        overrides: [
+          postSearchRepositoryProvider.overrideWithValue(repository),
+          moderationEngineProvider.overrideWith((ref) {
+            moderationBuilds++;
+            return moderationBuilds == 1
+                ? Future.value(_engine())
+                : paginationModeration.future;
+          }),
+        ],
+      );
+      final subscription = scope.listen(
+        postSearchProvider,
+        (previous, next) {},
+      );
+      addTearDown(subscription.close);
+      final notifier = scope.read(postSearchProvider.notifier);
+      await notifier.submitQuery('first');
+
+      scope.invalidate(moderationEngineProvider);
+      final loadMore = notifier.loadMorePosts();
+      await pageReturned.future;
+      await pumpEventQueue();
+
+      notifier.updateQuery('second');
+      paginationModeration.complete(_engine());
+      await loadMore;
+
+      final state = scope.read(postSearchProvider);
+      expect(state.query, 'second');
+      expect(state.searchResults, isEmpty);
+      expect(state.sprkNextCursor, isNull);
+      expect(state.isLoading, isTrue);
+    },
+  );
+
   test('current errors clear loading and empty query resets state', () async {
     final repository = _FakePostSearchRepository();
     repository.initialResponses.add(() async => throw StateError('offline'));
@@ -204,12 +334,12 @@ final _postAuthor = ProfileViewBasic(
 );
 final _indexedAt = DateTime.utc(2026, 7, 1);
 
-PostView _post(String id, {String? label}) {
+PostView _post(String id, {String? label, List<Label>? authorLabels}) {
   final uri = AtUri('at://did:plc:author/so.sprk.feed.post/$id');
   return PostView(
     uri: uri,
     cid: 'cid-$id',
-    author: _postAuthor,
+    author: _postAuthor.copyWith(labels: authorLabels),
     record: {r'$type': 'so.sprk.feed.post', 'text': id},
     indexedAt: _indexedAt,
     labels: label == null
@@ -225,5 +355,25 @@ PostView _post(String id, {String? label}) {
   );
 }
 
+Label _authorLabel({bool profileRecord = false}) => Label(
+  src: 'did:plc:mod',
+  uri: profileRecord
+      ? 'at://did:plc:author/app.bsky.actor.profile/self'
+      : 'did:plc:author',
+  val: 'blocked',
+  cts: _indexedAt,
+);
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions.fromLabelers(const {
+    'did:plc:mod': [],
+  }),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);
+
 InitialPostSearchResult _initial(List<PostView> posts) =>
     (sprk: (posts: posts, cursor: null), bsky: (posts: const [], cursor: null));
diff --git a/test/src/features/search/providers/suggested_feeds_provider_test.dart b/test/src/features/search/providers/suggested_feeds_provider_test.dart
index 1559adc1..a40a6841 100644
--- a/test/src/features/search/providers/suggested_feeds_provider_test.dart
+++ b/test/src/features/search/providers/suggested_feeds_provider_test.dart
@@ -1,7 +1,12 @@
+import 'dart:async';
+
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:get_it/get_it.dart';
 import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
@@ -74,6 +79,67 @@ void main() {
     await scope.read(suggestedFeedsProvider.notifier).refresh();
     expect(scope.read(suggestedFeedsProvider).hasError, isTrue);
   });
+
+  test('waits for moderation before exposing suggested feeds', () async {
+    final promoted = _generator('promoted');
+    final excluded = _generator('excluded', labels: [_label('!no-promote')]);
+    feedRepository.suggestedResponses.add(() async => [promoted, excluded]);
+    final engineCompleter = Completer<ModerationEngine>();
+    final scope = ProviderContainer.test(
+      overrides: [
+        moderationEngineProvider.overrideWith((ref) => engineCompleter.future),
+      ],
+    );
+    addTearDown(scope.dispose);
+    final subscription = scope.listen(
+      promotableSuggestedFeedsProvider,
+      (previous, next) {},
+    );
+    addTearDown(subscription.close);
+
+    await scope.read(suggestedFeedsProvider.future);
+    expect(scope.read(promotableSuggestedFeedsProvider).isLoading, isTrue);
+
+    engineCompleter.complete(_engine());
+    await scope.read(moderationEngineProvider.future);
+
+    expect(scope.read(promotableSuggestedFeedsProvider).requireValue, [
+      promoted,
+    ]);
+  });
+
+  test('exposes moderation errors instead of unfiltered feeds', () async {
+    final moderationError = StateError('moderation failed');
+    feedRepository.suggestedResponses.add(
+      () async => [
+        _generator('excluded', labels: [_label('!no-promote')]),
+      ],
+    );
+    final scope = ProviderContainer.test(
+      retry: (retryCount, error) => null,
+      overrides: [
+        moderationEngineProvider.overrideWith(
+          (ref) => Future<ModerationEngine>.error(moderationError),
+        ),
+      ],
+    );
+    addTearDown(scope.dispose);
+    final subscription = scope.listen(
+      promotableSuggestedFeedsProvider,
+      (previous, next) {},
+    );
+    addTearDown(subscription.close);
+
+    await scope.read(suggestedFeedsProvider.future);
+    await expectLater(
+      scope.read(moderationEngineProvider.future),
+      throwsA(same(moderationError)),
+    );
+
+    final result = scope.read(promotableSuggestedFeedsProvider);
+    expect(result.hasError, isTrue);
+    expect(result.error, same(moderationError));
+  });
 }
 
 class _FakeFeedRepository implements FeedRepository {
@@ -107,11 +173,30 @@ ProfileView _profile(String id) =>
 
 final _indexedAt = DateTime.utc(2026, 7, 1);
 
-GeneratorView _generator(String id) => GeneratorView(
+GeneratorView _generator(String id, {List<Label>? labels}) => GeneratorView(
   uri: AtUri('at://did:plc:feed/so.sprk.feed.generator/$id'),
   cid: 'cid-$id',
   did: 'did:plc:feed',
   creator: _profile('creator'),
   displayName: id,
+  labels: labels,
   indexedAt: _indexedAt,
 );
+
+Label _label(String value) => Label(
+  src: 'did:plc:moderator',
+  uri: 'at://did:plc:feed/so.sprk.feed.generator/excluded',
+  val: value,
+  cts: _indexedAt,
+);
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions.fromLabelers(const {
+    'did:plc:moderator': [],
+  }),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);
diff --git a/test/src/features/settings/providers/labeler_settings_controller_test.dart b/test/src/features/settings/providers/labeler_settings_controller_test.dart
new file mode 100644
index 00000000..9e9b107f
--- /dev/null
+++ b/test/src/features/settings/providers/labeler_settings_controller_test.dart
@@ -0,0 +1,223 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
+import 'package:sprk_poptart/so/sprk/labeler/defs/labeler_view_detailed.dart';
+
+void main() {
+  late _PreferencesController preferencesController;
+  late _FakeLabelerRepository labelerRepository;
+  late ProviderContainer container;
+
+  setUp(() async {
+    await GetIt.I.reset();
+    preferencesController = _PreferencesController();
+    labelerRepository = _FakeLabelerRepository();
+    GetIt.I
+      ..registerSingleton<SprkRepository>(
+        _FakeSprkRepository(labelerRepository),
+      )
+      ..registerSingleton<LogService>(LogService());
+    container = ProviderContainer.test(
+      overrides: [
+        userPreferencesProvider.overrideWith(
+          () => _FakeUserPreferences(preferencesController),
+        ),
+      ],
+      retry: (retryCount, error) => null,
+    );
+  });
+
+  tearDown(() async {
+    container.dispose();
+    await GetIt.I.reset();
+  });
+
+  group('label policy defaults', () {
+    test(
+      'startup labeler lookup does not persist definition defaults',
+      () async {
+        preferencesController.current = _preferencesWithLabelers([
+          'did:plc:mod',
+          'did:plc:custom',
+        ]);
+        final controller = container.read(labelerSettingsControllerProvider);
+
+        final labelers = await controller.getLabelers();
+        await pumpEventQueue();
+
+        expect(labelers, ['did:plc:mod', 'did:plc:custom']);
+        expect(preferencesController.writes, isEmpty);
+        expect(labelerRepository.detailedServiceCalls, isEmpty);
+      },
+    );
+
+    test('adding a labeler persists only the subscription', () async {
+      preferencesController.current = _preferencesWithLabelers(['did:plc:mod']);
+      final controller = container.read(labelerSettingsControllerProvider);
+
+      await controller.addLabeler('@labeler.test');
+
+      expect(preferencesController.writes, hasLength(1));
+      expect(preferencesController.current.labelers?.map((item) => item.did), [
+        'did:plc:mod',
+        'did:plc:resolved',
+      ]);
+      expect(preferencesController.current.contentLabelPrefs, isNull);
+      expect(labelerRepository.detailedServiceCalls, isEmpty);
+    });
+
+    test('syncing labelers does not persist definition defaults', () async {
+      preferencesController.current = _preferencesWithLabelers([
+        'did:plc:mod',
+        'did:plc:custom',
+      ]);
+      final controller = container.read(labelerSettingsControllerProvider);
+
+      await controller.syncLabelers();
+
+      expect(preferencesController.refreshCalls, 1);
+      expect(preferencesController.writes, isEmpty);
+      expect(labelerRepository.detailedServiceCalls, isEmpty);
+    });
+
+    test(
+      'sync validates concurrently and persists one final subscription list',
+      () async {
+        preferencesController.current = _preferencesWithLabelers([
+          'did:plc:available',
+          'did:plc:unavailable',
+        ]);
+        labelerRepository.unavailableDids.add('did:plc:unavailable');
+        final controller = container.read(labelerSettingsControllerProvider);
+
+        await controller.syncLabelers();
+
+        expect(
+          labelerRepository.validationCalls,
+          unorderedEquals(['did:plc:available', 'did:plc:unavailable']),
+        );
+        expect(labelerRepository.maxConcurrentValidations, 2);
+        expect(preferencesController.writes, hasLength(1));
+        expect(
+          preferencesController.current.labelers?.map((item) => item.did),
+          ['did:plc:mod', 'did:plc:available'],
+        );
+      },
+    );
+  });
+}
+
+Preferences _preferencesWithLabelers(List<String> dids) => Preferences(
+  preferences: [
+    labelersPreference([for (final did in dids) LabelerPrefItem(did: did)]),
+  ],
+);
+
+class _PreferencesController {
+  Preferences current = Preferences(preferences: []);
+  int refreshCalls = 0;
+  final List<Preferences> writes = [];
+}
+
+class _FakeUserPreferences extends UserPreferences {
+  _FakeUserPreferences(this.controller);
+
+  final _PreferencesController controller;
+
+  @override
+  Future<Preferences> build() async => controller.current;
+
+  @override
+  Future<void> refresh() async {
+    controller.refreshCalls++;
+    state = AsyncValue.data(controller.current);
+  }
+
+  @override
+  Future<Preferences> updatePreferences(Preferences preferences) async {
+    controller.writes.add(preferences);
+    controller.current = preferences;
+    state = AsyncValue.data(preferences);
+    return preferences;
+  }
+
+  @override
+  Future<Preferences> updatePreferencesWithFn(
+    Preferences Function(Preferences current) updater,
+  ) async {
+    final current = controller.current;
+    final updated = updater(current);
+    if (identical(updated, current)) return current;
+    return updatePreferences(updated);
+  }
+}
+
+class _FakeSprkRepository implements SprkRepository {
+  _FakeSprkRepository(this.labeler);
+
+  @override
+  final LabelerRepository labeler;
+
+  List<String> _labelerDids = ['did:plc:mod'];
+
+  @override
+  List<String> get labelerDids => List.unmodifiable(_labelerDids);
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {
+    _labelerDids = {'did:plc:mod', ...labelerDids}.take(20).toList();
+  }
+
+  @override
+  String get modDid => 'did:plc:mod#spark-labeler';
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
+
+class _FakeLabelerRepository implements LabelerRepository {
+  final List<List<String>> detailedServiceCalls = [];
+  final Set<String> unavailableDids = {};
+  final List<String> validationCalls = [];
+  int activeValidations = 0;
+  int maxConcurrentValidations = 0;
+
+  @override
+  Future<String> resolveIdentifier(String identifier) async {
+    return identifier == '@labeler.test' ? 'did:plc:resolved' : identifier;
+  }
+
+  @override
+  Future<void> validateService(String did) async {
+    validationCalls.add(did);
+    activeValidations++;
+    if (activeValidations > maxConcurrentValidations) {
+      maxConcurrentValidations = activeValidations;
+    }
+    try {
+      await Future<void>.delayed(const Duration(milliseconds: 1));
+      if (unavailableDids.contains(did)) {
+        throw const LabelerServiceUnavailableException('Unavailable labeler');
+      }
+    } finally {
+      activeValidations--;
+    }
+  }
+
+  @override
+  Future<LabelerViewDetailed> getServicesDetailed(List<String> dids) async {
+    detailedServiceCalls.add(List.of(dids));
+    throw UnsupportedError('Detailed label policies must not be fetched');
+  }
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
diff --git a/test/src/features/settings/providers/settings_provider_test.dart b/test/src/features/settings/providers/settings_provider_test.dart
index 69148513..f4099c2e 100644
--- a/test/src/features/settings/providers/settings_provider_test.dart
+++ b/test/src/features/settings/providers/settings_provider_test.dart
@@ -7,19 +7,22 @@ import 'package:poptart/poptart.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spark/src/core/auth/data/models/login_result.dart';
 import 'package:spark/src/core/auth/data/repositories/auth_repository.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
-import 'package:spark/src/core/network/atproto/data/models/models.dart';
 import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/feed_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/core/storage/preferences/storage_manager.dart';
 import 'package:spark/src/core/utils/logging/log_service.dart';
-import 'package:spark/src/features/settings/providers/preferences_provider.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/providers/labeler_settings_controller.dart';
 import 'package:spark/src/features/settings/providers/settings_provider.dart';
 
 void main() {
   late _FakeAuthRepository authRepository;
   late _FakeFeedRepository feedRepository;
+  late _FakeSprkRepository sprkRepository;
   late _PreferencesController preferencesController;
 
   setUpAll(() async {
@@ -32,11 +35,10 @@ void main() {
     await StorageManager.instance.preferences.clear();
     authRepository = _FakeAuthRepository();
     feedRepository = _FakeFeedRepository();
+    sprkRepository = _FakeSprkRepository(authRepository, feedRepository);
     preferencesController = _PreferencesController();
     GetIt.I
-      ..registerSingleton<SprkRepository>(
-        _FakeSprkRepository(authRepository, feedRepository),
-      )
+      ..registerSingleton<SprkRepository>(sprkRepository)
       ..registerSingleton<StorageManager>(StorageManager.instance)
       ..registerSingleton<LogService>(LogService());
   });
@@ -48,7 +50,7 @@ void main() {
   ProviderContainer createContainer() => ProviderContainer.test(
     overrides: [
       userPreferencesProvider.overrideWith(
-        () => _FakeUserPreferences(preferencesController),
+        () => _FakeUserPreferences(preferencesController, sprkRepository),
       ),
     ],
     retry: (retryCount, error) => null,
@@ -329,140 +331,232 @@ void main() {
   });
 
   group('labeler preferences', () {
-    test('maps stored visibility into label policy state', () async {
+    test('labeler-specific update changes only the matching policy', () async {
       preferencesController.current = Preferences(
         preferences: [
           savedFeedsPreference([_savedFeed('following')]),
           contentLabelPreference(
-            labelerDid: 'did:plc:labeler',
-            label: 'nsfl',
+            labelerDid: 'did:plc:a',
+            label: 'custom',
             visibility: 'warn',
           ),
+          contentLabelPreference(
+            labelerDid: 'did:plc:b',
+            label: 'custom',
+            visibility: 'ignore',
+          ),
         ],
       );
       final container = createContainer();
-      final notifier = await loadSettings(container);
+      await loadSettings(container);
+      final labelers = container.read(labelerSettingsControllerProvider);
 
-      final preference = await notifier.getLabelPreference('nsfl');
+      await labelers.setLabelPreference(
+        'did:plc:a',
+        'custom',
+        ModerationSetting.hide,
+      );
 
-      expect(preference.setting, Setting.warn);
-      expect(preference.blurs, Blurs.media);
-      expect(preference.severity, Severity.alert);
-      expect(preference.adultOnly, isTrue);
+      final written = preferencesController.writes.single.contentLabelPrefs!;
+      expect(
+        written
+            .firstWhere((pref) => pref.labelerDid == 'did:plc:a')
+            .visibility
+            .toJson(),
+        'hide',
+      );
+      expect(
+        written
+            .firstWhere((pref) => pref.labelerDid == 'did:plc:b')
+            .visibility
+            .toJson(),
+        'ignore',
+      );
     });
 
     test(
-      'setLabelPreference updates the target and preserves others',
+      'adds and removes labelers but protects the default labeler',
       () async {
         preferencesController.current = Preferences(
           preferences: [
             savedFeedsPreference([_savedFeed('following')]),
+            labelersPreference([LabelerPrefItem(did: 'did:plc:mod')]),
             contentLabelPreference(
-              labelerDid: 'did:plc:labeler',
-              label: 'gore',
+              labelerDid: 'did:plc:other',
+              label: 'custom',
               visibility: 'warn',
             ),
-            contentLabelPreference(
-              labelerDid: 'did:plc:labeler',
-              label: 'nudity',
-              visibility: 'ignore',
-            ),
           ],
         );
         final container = createContainer();
-        final notifier = await loadSettings(container);
-
-        await notifier.setLabelPreference(
-          'gore',
-          Blurs.content,
-          Severity.alert,
-          false,
-          Setting.hide,
+        await loadSettings(container);
+        final labelers = container.read(labelerSettingsControllerProvider);
+
+        await labelers.addLabeler('did:plc:other');
+        expect(
+          preferencesController.current.labelers?.map((item) => item.did),
+          ['did:plc:mod', 'did:plc:other'],
         );
 
-        final written = preferencesController.writes.single.contentLabelPrefs!;
+        await labelers.removeLabeler('did:plc:other');
         expect(
-          written.firstWhere((pref) => pref.label == 'gore').visibilityValue,
-          'hide',
+          preferencesController.current.labelers?.map((item) => item.did),
+          ['did:plc:mod'],
         );
         expect(
-          written.firstWhere((pref) => pref.label == 'nudity').visibilityValue,
-          'ignore',
+          preferencesController.current.contentLabelPrefs?.where(
+                (pref) => pref.labelerDid == 'did:plc:other',
+              ) ??
+              const [],
+          isEmpty,
+        );
+        await expectLater(
+          labelers.removeLabeler('did:plc:mod'),
+          throwsA(isA<Exception>()),
         );
+        expect(preferencesController.writes, hasLength(2));
       },
     );
 
-    test('labeler-specific update changes only the matching policy', () async {
+    test('resolves and validates a handle before persisting it', () async {
+      preferencesController.current = Preferences(
+        preferences: [
+          savedFeedsPreference([_savedFeed('following')]),
+          labelersPreference([LabelerPrefItem(did: 'did:plc:mod')]),
+        ],
+      );
+      final container = createContainer();
+      await loadSettings(container);
+      final labelers = container.read(labelerSettingsControllerProvider);
+
+      await labelers.addLabeler('@labeler.test');
+
+      expect(preferencesController.current.labelers?.map((item) => item.did), [
+        'did:plc:mod',
+        'did:plc:resolved',
+      ]);
+      expect(sprkRepository.labelerDids, ['did:plc:mod', 'did:plc:resolved']);
+    });
+
+    test('does not persist a service that fails validation', () async {
+      preferencesController.current = Preferences(
+        preferences: [
+          savedFeedsPreference([_savedFeed('following')]),
+          labelersPreference([LabelerPrefItem(did: 'did:plc:mod')]),
+        ],
+      );
+      sprkRepository._labelerRepository.invalidDids.add('did:plc:invalid');
+      final container = createContainer();
+      await loadSettings(container);
+      final labelers = container.read(labelerSettingsControllerProvider);
+
+      await expectLater(
+        labelers.addLabeler('did:plc:invalid'),
+        throwsA(isA<Exception>()),
+      );
+
+      expect(preferencesController.writes, isEmpty);
+      expect(preferencesController.current.labelers?.map((item) => item.did), [
+        'did:plc:mod',
+      ]);
+    });
+
+    test('enforces the 20-labeler subscription limit', () async {
+      preferencesController.current = Preferences(
+        preferences: [
+          savedFeedsPreference([_savedFeed('following')]),
+          labelersPreference([
+            LabelerPrefItem(did: 'did:plc:mod'),
+            for (var index = 1; index < 20; index++)
+              LabelerPrefItem(did: 'did:plc:$index'),
+          ]),
+        ],
+      );
+      final container = createContainer();
+      await loadSettings(container);
+      final labelers = container.read(labelerSettingsControllerProvider);
+
+      await expectLater(
+        labelers.addLabeler('did:plc:overflow'),
+        throwsA(isA<StateError>()),
+      );
+
+      expect(preferencesController.writes, isEmpty);
+      expect(preferencesController.current.labelers, hasLength(20));
+    });
+
+    test('sync removes unavailable labelers and their preferences', () async {
       preferencesController.current = Preferences(
         preferences: [
           savedFeedsPreference([_savedFeed('following')]),
+          labelersPreference([
+            LabelerPrefItem(did: 'did:plc:mod'),
+            LabelerPrefItem(did: 'did:plc:unavailable'),
+          ]),
           contentLabelPreference(
-            labelerDid: 'did:plc:a',
+            labelerDid: 'did:plc:unavailable',
             label: 'custom',
             visibility: 'warn',
           ),
-          contentLabelPreference(
-            labelerDid: 'did:plc:b',
-            label: 'custom',
-            visibility: 'ignore',
-          ),
         ],
       );
+      sprkRepository._labelerRepository.invalidDids.add('did:plc:unavailable');
       final container = createContainer();
-      final notifier = await loadSettings(container);
+      await loadSettings(container);
+      final labelers = container.read(labelerSettingsControllerProvider);
 
-      await notifier.setLabelPreferenceForLabeler(
-        'did:plc:a',
-        'custom',
-        Blurs.content,
-        Severity.alert,
-        false,
-        Setting.hide,
-      );
+      await labelers.syncLabelers();
 
-      final written = preferencesController.writes.single.contentLabelPrefs!;
-      expect(
-        written
-            .firstWhere((pref) => pref.labelerDid == 'did:plc:a')
-            .visibilityValue,
-        'hide',
-      );
+      expect(preferencesController.current.labelers?.map((item) => item.did), [
+        'did:plc:mod',
+      ]);
       expect(
-        written
-            .firstWhere((pref) => pref.labelerDid == 'did:plc:b')
-            .visibilityValue,
-        'ignore',
+        preferencesController.current.contentLabelPrefs?.where(
+              (pref) => pref.labelerDid == 'did:plc:unavailable',
+            ) ??
+            const [],
+        isEmpty,
       );
+      expect(sprkRepository.labelerDids, ['did:plc:mod']);
     });
 
     test(
-      'adds and removes labelers but protects the default labeler',
+      'sync caps persisted labelers with the required default first',
       () async {
         preferencesController.current = Preferences(
           preferences: [
             savedFeedsPreference([_savedFeed('following')]),
-            labelersPreference([LabelerPrefItem(did: 'did:plc:mod')]),
+            labelersPreference([
+              for (var index = 0; index < 20; index++)
+                LabelerPrefItem(did: 'did:plc:$index'),
+            ]),
+            contentLabelPreference(
+              labelerDid: 'did:plc:19',
+              label: 'custom',
+              visibility: 'warn',
+            ),
           ],
         );
         final container = createContainer();
-        final notifier = await loadSettings(container);
+        await loadSettings(container);
+        final labelers = container.read(labelerSettingsControllerProvider);
 
-        await notifier.addLabeler('did:plc:other');
-        expect(
-          preferencesController.current.labelers?.map((item) => item.did),
-          ['did:plc:mod', 'did:plc:other'],
-        );
+        await labelers.syncLabelers();
 
-        await notifier.removeLabeler('did:plc:other');
+        final persisted = preferencesController.current;
+        expect(persisted.labelers, hasLength(20));
+        expect(persisted.labelers?.first.did, 'did:plc:mod');
         expect(
-          preferencesController.current.labelers?.map((item) => item.did),
-          ['did:plc:mod'],
+          persisted.labelers?.map((labeler) => labeler.did),
+          sprkRepository.labelerDids,
         );
-        await expectLater(
-          notifier.removeLabeler('did:plc:mod'),
-          throwsA(isA<Exception>()),
+        expect(
+          persisted.contentLabelPrefs?.where(
+                (preference) => preference.labelerDid == 'did:plc:19',
+              ) ??
+              const [],
+          isEmpty,
         );
-        expect(preferencesController.writes, hasLength(2));
       },
     );
   });
@@ -493,36 +587,53 @@ class _PreferencesController {
 }
 
 class _FakeUserPreferences extends UserPreferences {
-  _FakeUserPreferences(this.controller);
+  _FakeUserPreferences(this.controller, this.repository);
 
   final _PreferencesController controller;
+  final SprkRepository repository;
 
   @override
-  Future<Preferences> build() async => controller.current;
+  Future<Preferences> build() async => _configureLabelers(controller.current);
 
   @override
   Future<void> refresh() async {
     controller.refreshCalls++;
     final error = controller.refreshError;
     if (error != null) {
-      state = AsyncValue.error(error, StackTrace.current);
       throw error;
     }
     final refreshed = controller.refreshResult ?? controller.current;
     controller.current = refreshed;
-    state = AsyncValue.data(refreshed);
+    state = AsyncValue.data(_configureLabelers(refreshed));
   }
 
   @override
-  Future<void> updatePreferences(Preferences preferences) async {
+  Future<Preferences> updatePreferences(Preferences preferences) async {
     controller.writes.add(preferences);
     final error = controller.updateError;
     if (error != null) {
-      state = AsyncValue.error(error, StackTrace.current);
       throw error;
     }
     controller.current = preferences;
-    state = AsyncValue.data(preferences);
+    state = AsyncValue.data(_configureLabelers(preferences));
+    return preferences;
+  }
+
+  @override
+  Future<Preferences> updatePreferencesWithFn(
+    Preferences Function(Preferences current) updater,
+  ) async {
+    final current = controller.current;
+    final updated = updater(current);
+    if (identical(updated, current)) return current;
+    return updatePreferences(updated);
+  }
+
+  Preferences _configureLabelers(Preferences preferences) {
+    repository.configureLabelers(
+      preferences.labelers?.map((labeler) => labeler.did) ?? const [],
+    );
+    return preferences;
   }
 }
 
@@ -548,12 +659,38 @@ class _FakeFeedRepository implements FeedRepository {
 class _FakeSprkRepository implements SprkRepository {
   _FakeSprkRepository(this.authRepository, this.feed);
 
+  final _FakeLabelerRepository _labelerRepository = _FakeLabelerRepository();
+  List<String> _labelerDids = ['did:plc:mod'];
+
   @override
   final AuthRepository authRepository;
 
   @override
   final FeedRepository feed;
 
+  @override
+  LabelerRepository get labeler => _labelerRepository;
+
+  @override
+  List<String> get labelerDids => List.unmodifiable(_labelerDids);
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {
+    _labelerDids = {'did:plc:mod', ...labelerDids}.take(20).toList();
+  }
+
+  @override
+  Map<String, String> appViewHeaders(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  }) {
+    final accepted = labelerDids?.toList() ?? _labelerDids;
+    return {
+      'atproto-proxy': ?proxyDid,
+      if (accepted.isNotEmpty) 'atproto-accept-labelers': accepted.join(','),
+    };
+  }
+
   @override
   String get modDid => 'did:plc:mod#spark-labeler';
 
@@ -568,6 +705,28 @@ class _FakeSprkRepository implements SprkRepository {
       throw UnsupportedError('${invocation.memberName} is not used');
 }
 
+class _FakeLabelerRepository implements LabelerRepository {
+  final Set<String> invalidDids = {};
+
+  @override
+  Future<String> resolveIdentifier(String identifier) async {
+    final normalized = identifier.trim().replaceFirst(RegExp(r'^@'), '');
+    if (normalized == 'labeler.test') return 'did:plc:resolved';
+    return normalized;
+  }
+
+  @override
+  Future<void> validateService(String did) async {
+    if (invalidDids.contains(did)) {
+      throw const LabelerServiceUnavailableException('Not a labeler');
+    }
+  }
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
+
 class _FakeAuthRepository implements AuthRepository {
   @override
   Future<void> initializationComplete = Future<void>.value();
diff --git a/test/src/features/settings/ui/pages/labeler_label_settings_page_test.dart b/test/src/features/settings/ui/pages/labeler_label_settings_page_test.dart
new file mode 100644
index 00000000..c07170c2
--- /dev/null
+++ b/test/src/features/settings/ui/pages/labeler_label_settings_page_test.dart
@@ -0,0 +1,293 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/interactive_pressable.dart';
+import 'package:spark/src/core/design_system/components/molecules/app_choice_group.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/actor_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/labeler_repository.dart';
+import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/ui/pages/labeler_label_settings_page.dart';
+import 'package:spark/src/features/settings/ui/widgets/label_setting_tile.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+void main() {
+  const labelerDid = 'did:plc:labeler';
+
+  setUp(() async {
+    await GetIt.I.reset();
+    GetIt.I
+      ..registerSingleton<ActorRepository>(_FakeActorRepository())
+      ..registerSingleton<SprkRepository>(
+        _FakeSprkRepository(_service(labelerDid)),
+      )
+      ..registerSingleton<LogService>(LogService());
+  });
+
+  tearDown(() async {
+    await GetIt.I.reset();
+  });
+
+  testWidgets('uses built-in policy when a labeler omits definitions', (
+    tester,
+  ) async {
+    await _pumpPage(tester, labelerDid);
+
+    expect(find.text('Adult Content'), findsOneWidget);
+    expect(find.text('Explicit sexual images.'), findsOneWidget);
+    expect(find.text('Configured in Moderation settings.'), findsOneWidget);
+    expect(find.byType(LabelSettingTile), findsOneWidget);
+    for (final action in ['Off', 'Warn', 'Hide']) {
+      expect(find.text(action), findsOneWidget);
+    }
+    expect(find.text('Show'), findsNothing);
+    final actions = tester.widget<AppChoiceGroup<ModerationSetting>>(
+      find.byType(AppChoiceGroup<ModerationSetting>),
+    );
+    expect(actions.enabled, isFalse);
+  });
+
+  testWidgets('uses Badge for a labeler-defined inform label', (tester) async {
+    await GetIt.I.unregister<SprkRepository>();
+    GetIt.I.registerSingleton<SprkRepository>(
+      _FakeSprkRepository(_informService(labelerDid)),
+    );
+
+    await _pumpPage(tester, labelerDid);
+
+    expect(find.text('context'), findsOneWidget);
+    for (final action in ['Off', 'Badge', 'Hide']) {
+      expect(find.text(action), findsOneWidget);
+    }
+    expect(find.text('Warn'), findsNothing);
+  });
+
+  testWidgets('does not update state after disposal while loading', (
+    tester,
+  ) async {
+    final profiles = Completer<List<ProfileViewDetailed>>();
+    await GetIt.I.unregister<ActorRepository>();
+    GetIt.I.registerSingleton<ActorRepository>(
+      _PendingActorRepository(profiles.future),
+    );
+
+    await tester.pumpWidget(_page(labelerDid));
+    await tester.pump();
+    await tester.pumpWidget(const SizedBox.shrink());
+
+    profiles.complete(const []);
+    await tester.pump();
+
+    expect(tester.takeException(), isNull);
+  });
+
+  testWidgets('disables every label control while a save is pending', (
+    tester,
+  ) async {
+    await GetIt.I.unregister<SprkRepository>();
+    GetIt.I.registerSingleton<SprkRepository>(
+      _FakeSprkRepository(_customService(labelerDid)),
+    );
+    final preferences = _PendingPreferences();
+
+    await tester.pumpWidget(_page(labelerDid, preferences: preferences));
+    await tester.pumpAndSettle();
+
+    final firstControl = find.byKey(const Key('labeler-label-topic-one'));
+    await tester.tap(
+      find
+          .descendant(
+            of: firstControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .last,
+    );
+    final secondControl = find.byKey(const Key('labeler-label-topic-two'));
+    await tester.tap(
+      find
+          .descendant(
+            of: secondControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .last,
+    );
+    expect(preferences.updateCount, 1);
+
+    await tester.pump();
+
+    expect(preferences.updateCount, 1);
+    expect(
+      tester
+          .widgetList<AppChoiceGroup<ModerationSetting>>(
+            find.byType(AppChoiceGroup<ModerationSetting>),
+          )
+          .every((group) => !group.enabled),
+      isTrue,
+    );
+
+    await tester.tap(
+      find
+          .descendant(
+            of: secondControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .last,
+    );
+    expect(preferences.updateCount, 1);
+
+    await tester.pumpWidget(const SizedBox.shrink());
+    preferences.save.complete();
+    await tester.pump();
+
+    expect(tester.takeException(), isNull);
+  });
+}
+
+Future<void> _pumpPage(WidgetTester tester, String labelerDid) async {
+  await tester.pumpWidget(_page(labelerDid));
+  await tester.pumpAndSettle();
+}
+
+Widget _page(String labelerDid, {UserPreferences? preferences}) =>
+    ProviderScope(
+      overrides: [
+        userPreferencesProvider.overrideWith(
+          preferences == null ? _FakePreferences.new : () => preferences,
+        ),
+      ],
+      child: MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: LabelerLabelSettingsPage(did: labelerDid),
+      ),
+    );
+
+LabelerViewDetailed _service(String did) => LabelerViewDetailed(
+  uri: AtUri.parse('at://$did/app.bsky.labeler.service/self'),
+  cid: 'cid',
+  creator: ProfileView(did: did, handle: 'labeler.test'),
+  policies: LabelerPolicies(
+    labelValues: const [LabelValue.knownValue(data: KnownLabelValue.porn)],
+  ),
+  indexedAt: DateTime.utc(2026),
+);
+
+LabelerViewDetailed _informService(String did) => LabelerViewDetailed(
+  uri: AtUri.parse('at://$did/app.bsky.labeler.service/self'),
+  cid: 'cid',
+  creator: ProfileView(did: did, handle: 'labeler.test'),
+  policies: LabelerPolicies(
+    labelValues: const [LabelValue.unknown(data: 'context')],
+    labelValueDefinitions: [
+      LabelValueDefinition(
+        identifier: 'context',
+        severity: LabelValueDefinitionSeverity.valueOf('inform')!,
+        blurs: LabelValueDefinitionBlurs.valueOf('none')!,
+        locales: const [],
+      ),
+    ],
+  ),
+  indexedAt: DateTime.utc(2026),
+);
+
+LabelerViewDetailed _customService(String did) => LabelerViewDetailed(
+  uri: AtUri.parse('at://$did/app.bsky.labeler.service/self'),
+  cid: 'cid',
+  creator: ProfileView(did: did, handle: 'labeler.test'),
+  policies: LabelerPolicies(
+    labelValues: const [
+      LabelValue.unknown(data: 'topic-one'),
+      LabelValue.unknown(data: 'topic-two'),
+    ],
+  ),
+  indexedAt: DateTime.utc(2026),
+);
+
+class _FakeActorRepository implements ActorRepository {
+  @override
+  Future<List<ProfileViewDetailed>> getProfiles(
+    List<String> dids, {
+    bool useBluesky = false,
+  }) async => const [];
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
+
+class _PendingActorRepository implements ActorRepository {
+  const _PendingActorRepository(this.profiles);
+
+  final Future<List<ProfileViewDetailed>> profiles;
+
+  @override
+  Future<List<ProfileViewDetailed>> getProfiles(
+    List<String> dids, {
+    bool useBluesky = false,
+  }) => profiles;
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
+
+class _FakeSprkRepository implements SprkRepository {
+  _FakeSprkRepository(this.service);
+
+  final LabelerViewDetailed service;
+
+  @override
+  String get modDid => 'did:plc:mod#spark-labeler';
+
+  @override
+  LabelerRepository get labeler => _FakeLabelerRepository(service);
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
+
+class _FakeLabelerRepository implements LabelerRepository {
+  const _FakeLabelerRepository(this.service);
+
+  final LabelerViewDetailed service;
+
+  @override
+  Future<LabelerViewDetailed> getServicesDetailed(List<String> dids) async =>
+      service;
+
+  @override
+  Never noSuchMethod(Invocation invocation) =>
+      throw UnsupportedError('${invocation.memberName} is not used');
+}
+
+class _FakePreferences extends UserPreferences {
+  @override
+  Future<Preferences> build() async => Preferences(preferences: []);
+}
+
+class _PendingPreferences extends _FakePreferences {
+  final save = Completer<void>();
+  int updateCount = 0;
+  Preferences current = Preferences(preferences: []);
+
+  @override
+  Future<Preferences> updatePreferencesWithFn(
+    Preferences Function(Preferences current) updater,
+  ) async {
+    updateCount++;
+    current = updater(current);
+    await save.future;
+    return current;
+  }
+}
diff --git a/test/src/features/settings/ui/pages/moderation_page_test.dart b/test/src/features/settings/ui/pages/moderation_page_test.dart
new file mode 100644
index 00000000..1f4f0e15
--- /dev/null
+++ b/test/src/features/settings/ui/pages/moderation_page_test.dart
@@ -0,0 +1,255 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/interactive_pressable.dart';
+import 'package:spark/src/core/design_system/components/molecules/app_choice_group.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/network/atproto/data/models/pref_models.dart';
+import 'package:spark/src/core/utils/logging/log_service.dart';
+import 'package:spark/src/core/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/ui/pages/moderation_page.dart';
+import 'package:spark/src/features/settings/ui/widgets/label_setting_tile.dart';
+
+void main() {
+  setUp(() async {
+    await GetIt.I.reset();
+    GetIt.I.registerSingleton<LogService>(LogService());
+  });
+
+  tearDown(() async {
+    await GetIt.I.reset();
+  });
+
+  testWidgets('shows adult content and labeling controls', (tester) async {
+    await _pumpPage(tester, _UserPreferences.new);
+
+    expect(find.text('Moderation'), findsOneWidget);
+    expect(find.text('Show adult content'), findsOneWidget);
+    expect(find.text('Labelers'), findsOneWidget);
+  });
+
+  testWidgets('adult content update failures show localized feedback', (
+    tester,
+  ) async {
+    await _pumpPage(tester, _FailingUserPreferences.new);
+
+    await tester.tap(find.text('Show adult content'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('An error occurred'), findsOneWidget);
+    expect(
+      tester.widget<SwitchListTile>(find.byType(SwitchListTile)).onChanged,
+      isNotNull,
+    );
+    expect(tester.takeException(), isNull);
+  });
+
+  testWidgets('shows built-in global adult filters without loading labelers', (
+    tester,
+  ) async {
+    final preferences = _AdultPreferences();
+    await _pumpPage(tester, () => preferences);
+
+    expect(find.text('Content filters'), findsNothing);
+    expect(find.byType(CircularProgressIndicator), findsNothing);
+    final adultSettingsGroup = find.byKey(
+      const Key('adult-content-settings-group'),
+    );
+    expect(
+      find.descendant(
+        of: adultSettingsGroup,
+        matching: find.byType(SwitchListTile),
+      ),
+      findsOneWidget,
+    );
+    expect(
+      find.descendant(
+        of: adultSettingsGroup,
+        matching: find.byType(LabelSettingTile),
+      ),
+      findsNWidgets(4),
+    );
+
+    final sexualControl = find.byKey(const Key('global-label-sexual'));
+    final sexualActions = tester.widget<AppChoiceGroup<ModerationSetting>>(
+      find.descendant(
+        of: sexualControl,
+        matching: find.byType(AppChoiceGroup<ModerationSetting>),
+      ),
+    );
+    expect(sexualActions.options, hasLength(3));
+    expect(sexualActions.value, ModerationSetting.hide);
+
+    final pornControl = find.byKey(const Key('global-label-porn'));
+    expect(tester.widget(pornControl), isA<LabelSettingTile>());
+    await tester.tap(
+      find
+          .descendant(
+            of: pornControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .first,
+    );
+    await tester.pump();
+
+    expect(preferences.lastLabel, 'porn');
+    expect(preferences.lastSetting, ModerationSetting.ignore);
+
+    for (final strings in {
+      'Adult Content': 'Explicit sexual images.',
+      'Sexually Suggestive': 'Does not include nudity.',
+      'Graphic Media': 'Explicit or potentially disturbing media.',
+      'Non-sexual Nudity': 'For example, artistic nudes.',
+    }.entries) {
+      await tester.scrollUntilVisible(
+        find.text(strings.key),
+        200,
+        scrollable: find.byType(Scrollable).first,
+      );
+      expect(find.text(strings.key), findsOneWidget);
+      expect(find.text(strings.value), findsOneWidget);
+    }
+  });
+
+  testWidgets('disables all moderation controls while a save is pending', (
+    tester,
+  ) async {
+    final preferences = _PendingAdultPreferences();
+    await _pumpPage(tester, () => preferences);
+
+    final pornControl = find.byKey(const Key('global-label-porn'));
+    await tester.tap(
+      find
+          .descendant(
+            of: pornControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .first,
+    );
+    final sexualControl = find.byKey(const Key('global-label-sexual'));
+    await tester.tap(
+      find
+          .descendant(
+            of: sexualControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .last,
+    );
+    expect(preferences.updateCount, 1);
+
+    await tester.pump();
+
+    expect(preferences.updateCount, 1);
+    expect(
+      tester
+          .widgetList<AppChoiceGroup<ModerationSetting>>(
+            find.byType(AppChoiceGroup<ModerationSetting>),
+          )
+          .every((group) => !group.enabled),
+      isTrue,
+    );
+    expect(
+      tester.widget<SwitchListTile>(find.byType(SwitchListTile)).onChanged,
+      isNull,
+    );
+
+    await tester.tap(
+      find
+          .descendant(
+            of: sexualControl,
+            matching: find.byType(InteractivePressable),
+          )
+          .last,
+    );
+    expect(preferences.updateCount, 1);
+
+    preferences.save.complete();
+    await tester.pumpAndSettle();
+
+    expect(
+      tester
+          .widgetList<AppChoiceGroup<ModerationSetting>>(
+            find.byType(AppChoiceGroup<ModerationSetting>),
+          )
+          .every((group) => group.enabled),
+      isTrue,
+    );
+  });
+}
+
+Future<void> _pumpPage(
+  WidgetTester tester,
+  UserPreferences Function() createPreferences,
+) async {
+  await tester.pumpWidget(
+    ProviderScope(
+      overrides: [userPreferencesProvider.overrideWith(createPreferences)],
+      child: MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: const ModerationPage(),
+      ),
+    ),
+  );
+  await tester.pumpAndSettle();
+}
+
+class _UserPreferences extends UserPreferences {
+  @override
+  Future<Preferences> build() async => Preferences(preferences: []);
+}
+
+class _FailingUserPreferences extends _UserPreferences {
+  @override
+  Future<void> setAdultContentEnabled(bool enabled) async {
+    throw StateError('update failed');
+  }
+}
+
+class _AdultPreferences extends UserPreferences {
+  String? lastLabel;
+  ModerationSetting? lastSetting;
+
+  @override
+  Future<Preferences> build() async => Preferences(
+    preferences: [
+      adultContentPreference(enabled: true),
+      contentLabelPreference(
+        labelerDid: null,
+        label: 'sexual',
+        visibility: 'hide',
+      ),
+    ],
+  );
+
+  @override
+  Future<void> setGlobalLabelPreference(
+    String label,
+    ModerationSetting setting,
+  ) async {
+    lastLabel = label;
+    lastSetting = setting;
+  }
+}
+
+class _PendingAdultPreferences extends UserPreferences {
+  final save = Completer<void>();
+  int updateCount = 0;
+
+  @override
+  Future<Preferences> build() async =>
+      Preferences(preferences: [adultContentPreference(enabled: true)]);
+
+  @override
+  Future<void> setGlobalLabelPreference(
+    String label,
+    ModerationSetting setting,
+  ) async {
+    updateCount++;
+    await save.future;
+  }
+}
diff --git a/test/src/features/settings/ui/pages/settings_page_test.dart b/test/src/features/settings/ui/pages/settings_page_test.dart
new file mode 100644
index 00000000..1daf1955
--- /dev/null
+++ b/test/src/features/settings/ui/pages/settings_page_test.dart
@@ -0,0 +1,23 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/features/settings/ui/pages/settings_page.dart';
+
+void main() {
+  testWidgets('groups moderation controls under a dedicated destination', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: const SettingsPage(),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('Moderation'), findsOneWidget);
+    expect(find.text('Show adult content'), findsNothing);
+    expect(find.text('Labelers'), findsNothing);
+  });
+}
diff --git a/test/src/features/settings/ui/widgets/label_setting_tile_test.dart b/test/src/features/settings/ui/widgets/label_setting_tile_test.dart
index 4f6d6dae..d23b9696 100644
--- a/test/src/features/settings/ui/widgets/label_setting_tile_test.dart
+++ b/test/src/features/settings/ui/widgets/label_setting_tile_test.dart
@@ -1,43 +1,123 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:spark/src/core/network/atproto/data/models/labeler_models.dart';
+import 'package:spark/src/core/design_system/components/atoms/buttons/interactive_pressable.dart';
+import 'package:spark/src/core/design_system/components/atoms/surfaces/app_surface.dart';
+import 'package:spark/src/core/design_system/components/molecules/app_choice_group.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
 import 'package:spark/src/features/settings/ui/widgets/label_setting_tile.dart';
 
 void main() {
-  testWidgets('selecting a moderation action reports the label and setting', (
+  testWidgets('uses the app surface and choice-group design primitives', (
     tester,
   ) async {
-    String? updatedLabel;
-    Setting? updatedSetting;
+    ModerationSetting? updatedSetting;
 
     await tester.pumpWidget(
       MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
         home: Scaffold(
           body: LabelSettingTile(
             label: 'graphic-media',
             labelName: 'Graphic media',
-            showSeverity: false,
-            preference: LabelPreference(
-              value: 'graphic-media',
-              blurs: Blurs.media,
-              severity: Severity.alert,
-              defaultSetting: Setting.warn,
-              setting: Setting.warn,
-              adultOnly: false,
-            ),
-            onPreferenceUpdate: (label, {blurs, setting, severity}) async {
-              updatedLabel = label;
-              updatedSetting = setting;
-            },
+            labelDescription: 'Potentially disturbing media.',
+            controlContext: LabelSettingTileContext.label,
+            setting: ModerationSetting.warn,
+            onChanged: (setting) => updatedSetting = setting,
           ),
         ),
       ),
     );
 
-    await tester.tap(find.widgetWithText(ElevatedButton, 'HIDE'));
+    final surface = tester.widget<AppSurface>(find.byType(AppSurface));
+    expect(
+      surface.margin,
+      const EdgeInsets.symmetric(horizontal: 16, vertical: 6),
+    );
+    expect(
+      surface.padding,
+      const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
+    );
+    final choiceGroup = tester.widget<AppChoiceGroup<ModerationSetting>>(
+      find.byType(AppChoiceGroup<ModerationSetting>),
+    );
+    expect(choiceGroup.options, hasLength(3));
+    expect(find.byType(Card), findsNothing);
+    expect(find.byType(ElevatedButton), findsNothing);
+    for (final action in ['Off', 'Warn', 'Hide']) {
+      expect(find.text(action), findsOneWidget);
+    }
+
+    await tester.tap(
+      find
+          .descendant(
+            of: find.byType(AppChoiceGroup<ModerationSetting>),
+            matching: find.byType(InteractivePressable),
+          )
+          .at(2),
+    );
+    await tester.pump();
+
+    expect(updatedSetting, ModerationSetting.hide);
+  });
+
+  testWidgets('falls back to the label identifier when no name is available', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: Scaffold(
+          body: LabelSettingTile(
+            label: 'custom-topic',
+            controlContext: LabelSettingTileContext.adultContentFilter,
+            setting: ModerationSetting.warn,
+            onChanged: (_) {},
+          ),
+        ),
+      ),
+    );
+
+    expect(find.text('custom-topic'), findsOneWidget);
+    expect(find.text('Show'), findsOneWidget);
+    expect(find.text('Off'), findsNothing);
+  });
+
+  testWidgets('inform labels use Badge for the warn setting', (tester) async {
+    ModerationSetting? updatedSetting;
+
+    await tester.pumpWidget(
+      MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: Scaffold(
+          body: LabelSettingTile(
+            label: 'context',
+            controlContext: LabelSettingTileContext.informLabel,
+            setting: ModerationSetting.ignore,
+            onChanged: (setting) => updatedSetting = setting,
+          ),
+        ),
+      ),
+    );
+
+    expect(find.text('Off'), findsOneWidget);
+    expect(find.text('Badge'), findsOneWidget);
+    expect(find.text('Hide'), findsOneWidget);
+    expect(find.text('Warn'), findsNothing);
+
+    await tester.tap(
+      find
+          .descendant(
+            of: find.byType(AppChoiceGroup<ModerationSetting>),
+            matching: find.byType(InteractivePressable),
+          )
+          .at(1),
+    );
     await tester.pump();
 
-    expect((updatedLabel, updatedSetting), ('graphic-media', Setting.hide));
-    expect(find.text('Severity Level'), findsNothing);
+    expect(updatedSetting, ModerationSetting.warn);
   });
 }
diff --git a/test/src/features/sound/ui/widgets/audio_selection_bottom_sheet_test.dart b/test/src/features/sound/ui/widgets/audio_selection_bottom_sheet_test.dart
index 1704e8ee..6120601b 100644
--- a/test/src/features/sound/ui/widgets/audio_selection_bottom_sheet_test.dart
+++ b/test/src/features/sound/ui/widgets/audio_selection_bottom_sheet_test.dart
@@ -3,17 +3,46 @@ import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
 import 'package:pro_image_editor/pro_image_editor.dart';
 import 'package:spark/src/core/design_system/components/atoms/buttons/app_button.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/models.dart';
 import 'package:spark/src/features/sound/controllers/audio_audition_controller.dart';
 import 'package:spark/src/features/sound/controllers/audio_audition_playback.dart';
 import 'package:spark/src/features/sound/ui/widgets/audio_selection_bottom_sheet.dart';
 import 'package:spark/src/features/sound/providers/sound_picker_search_provider.dart';
 import 'package:spark/src/features/sound/providers/sound_picker_search_state.dart';
 import 'package:spark/src/features/sound/ui/widgets/audio_track_list_section.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
 
 void main() {
+  testWidgets('hidden sounds are not selectable', (tester) async {
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          soundPickerSearchProvider.overrideWithValue(
+            SoundPickerSearchState(audios: [_audio(hidden: true)]),
+          ),
+          moderationEngineProvider.overrideWith((ref) async => _engine()),
+        ],
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(body: AudioTrackListSection(onTrackSelected: (_) {})),
+        ),
+      ),
+    );
+    await tester.pump();
+    await tester.pump();
+
+    expect(find.byType(AudioTrackSelectionTile), findsNothing);
+    expect(find.text('Hidden sound'), findsNothing);
+  });
+
   testWidgets('cancel while opening does not present a stale picker', (
     tester,
   ) async {
@@ -314,6 +343,44 @@ AudioTrack _track(String id) {
   );
 }
 
+AudioView _audio({required bool hidden}) {
+  final uri = AtUri('at://did:plc:author/so.sprk.sound.audio/hidden');
+  return AudioView(
+    uri: uri,
+    cid: 'audio-cid',
+    author: const ProfileViewBasic(
+      did: 'did:plc:author',
+      handle: 'author.sprk.so',
+    ),
+    record: const <String, dynamic>{},
+    title: 'Hidden sound',
+    coverArt: 'https://example.com/cover.jpg',
+    indexedAt: DateTime.utc(2026, 8, 17),
+    audio: 'https://example.com/audio.mp3',
+    labels: hidden
+        ? [
+            Label(
+              src: 'did:plc:moderator',
+              uri: uri.toString(),
+              val: '!hide',
+              cts: DateTime.utc(2026, 8, 17),
+            ),
+          ]
+        : null,
+  );
+}
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions.fromLabelers(const {
+    'did:plc:moderator': [],
+  }),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);
+
 final _span = TrimDurationSpan(
   start: Duration.zero,
   end: const Duration(seconds: 10),
diff --git a/test/src/features/stories/providers/stories_by_author_test.dart b/test/src/features/stories/providers/stories_by_author_test.dart
index f91b8bb1..5ca21f5d 100644
--- a/test/src/features/stories/providers/stories_by_author_test.dart
+++ b/test/src/features/stories/providers/stories_by_author_test.dart
@@ -3,6 +3,7 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:poptart/poptart.dart';
 import 'package:spark/src/core/network/atproto/atproto.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/features/stories/providers/stories_by_author.dart';
 import 'package:spark/src/features/stories/providers/story_repository_provider.dart';
 import 'package:sprk_poptart/so/sprk/actor/defs.dart';
@@ -39,13 +40,15 @@ void main() {
   });
 }
 
-StoryView _story(String id, {required ProfileViewBasic author}) {
-  return StoryView(
-    uri: AtUri('at://did:plc:me/so.sprk.story.post/$id'),
-    cid: 'cid-$id',
-    author: author,
-    record: const {},
-    indexedAt: DateTime.utc(2026, 7, 22, 10),
+ModeratedStoryView _story(String id, {required ProfileViewBasic author}) {
+  return ModeratedStoryView(
+    story: StoryView(
+      uri: AtUri('at://did:plc:me/so.sprk.story.post/$id'),
+      cid: 'cid-$id',
+      author: author,
+      record: const {},
+      indexedAt: DateTime.utc(2026, 7, 22, 10),
+    ),
   );
 }
 
@@ -53,7 +56,7 @@ class _FakeStoryTimelineRepository implements StoryRepository {
   _FakeStoryTimelineRepository({required this.timelineResult});
 
   final ({
-    Map<ProfileViewBasic, List<StoryView>> storiesByAuthor,
+    Map<ProfileViewBasic, List<ModeratedStoryView>> storiesByAuthor,
     String? cursor,
   })
   timelineResult;
@@ -61,7 +64,10 @@ class _FakeStoryTimelineRepository implements StoryRepository {
 
   @override
   Future<
-    ({String? cursor, Map<ProfileViewBasic, List<StoryView>> storiesByAuthor})
+    ({
+      String? cursor,
+      Map<ProfileViewBasic, List<ModeratedStoryView>> storiesByAuthor,
+    })
   >
   getStoriesTimeline({int limit = 30, String? cursor}) async {
     timelineCalls.add((limit: limit, cursor: cursor));
diff --git a/test/src/features/stories/providers/story_manager_provider_test.dart b/test/src/features/stories/providers/story_manager_provider_test.dart
index c9bc1c46..f40639f7 100644
--- a/test/src/features/stories/providers/story_manager_provider_test.dart
+++ b/test/src/features/stories/providers/story_manager_provider_test.dart
@@ -6,6 +6,7 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:poptart/poptart.dart';
 import 'package:spark/src/core/network/atproto/atproto.dart';
 import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 import 'package:spark/src/features/auth/providers/auth_providers.dart';
 import 'package:spark/src/features/stories/providers/story_auto_delete_provider.dart';
@@ -237,13 +238,15 @@ ProviderContainer _managerContainer({
   return container;
 }
 
-StoryView _story(String id, {required int hour}) {
-  return StoryView(
-    uri: AtUri('at://did:plc:me/so.sprk.story.post/$id'),
-    cid: 'cid-$id',
-    author: ProfileViewBasic(did: 'did:plc:me', handle: 'me.sprk.so'),
-    record: const {},
-    indexedAt: DateTime.utc(2026, 7, 22, hour),
+ModeratedStoryView _story(String id, {required int hour}) {
+  return ModeratedStoryView(
+    story: StoryView(
+      uri: AtUri('at://did:plc:me/so.sprk.story.post/$id'),
+      cid: 'cid-$id',
+      author: ProfileViewBasic(did: 'did:plc:me', handle: 'me.sprk.so'),
+      record: const {},
+      indexedAt: DateTime.utc(2026, 7, 22, hour),
+    ),
   );
 }
 
@@ -251,7 +254,7 @@ class _FakeStoryRepository implements StoryRepository {
   Future<StoryRecordPage> Function({required String did, String? cursor})?
   recordPageLoader;
   Future<void> Function(AtUri uri)? deleteRecord;
-  List<StoryView> storyViews = [];
+  List<ModeratedStoryView> storyViews = [];
   final List<List<AtUri>> storyViewCalls = [];
 
   @override
@@ -268,9 +271,9 @@ class _FakeStoryRepository implements StoryRepository {
   }
 
   @override
-  Future<List<StoryView>> getStoryViews(List<AtUri> storyUris) async {
+  Future<List<ModeratedStoryView>> getStoryViews(List<AtUri> storyUris) async {
     storyViewCalls.add(List<AtUri>.of(storyUris));
-    return List<StoryView>.of(storyViews);
+    return List<ModeratedStoryView>.of(storyViews);
   }
 
   @override
diff --git a/test/src/features/stories/ui/pages/story_page_test.dart b/test/src/features/stories/ui/pages/story_page_test.dart
new file mode 100644
index 00000000..9888c18a
--- /dev/null
+++ b/test/src/features/stories/ui/pages/story_page_test.dart
@@ -0,0 +1,219 @@
+import 'dart:convert';
+import 'dart:typed_data';
+import 'dart:ui' as ui;
+
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/core/moderation/moderated_content.dart';
+import 'package:spark/src/core/moderation/moderation.dart';
+import 'package:spark/src/core/moderation/moderation_provider.dart';
+import 'package:spark/src/core/network/atproto/data/models/feed_models.dart';
+import 'package:spark/src/core/network/atproto/data/models/moderated_story_view.dart';
+import 'package:spark/src/features/stories/ui/pages/author_stories_page.dart';
+import 'package:spark/src/features/stories/ui/pages/story_page.dart';
+import 'package:sprk_poptart/so/sprk/actor/defs.dart';
+
+void main() {
+  testWidgets('inactive neighbor cannot resume a concealed active story', (
+    tester,
+  ) async {
+    var pauseRequests = 0;
+    var resumeRequests = 0;
+    final callbacks = (
+      pause: () => pauseRequests += 1,
+      resume: () => resumeRequests += 1,
+    );
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          moderationEngineProvider.overrideWith((ref) async => _engine()),
+        ],
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Stack(
+            children: [
+              StoryPage(
+                story: _story('active', authorLabeled: true),
+                isActive: true,
+                onPauseRequested: callbacks.pause,
+                onResumeRequested: callbacks.resume,
+              ),
+              Offstage(
+                child: StoryPage(
+                  story: _story('neighbor'),
+                  isActive: false,
+                  onPauseRequested: callbacks.pause,
+                  onResumeRequested: callbacks.resume,
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+    await tester.pump();
+    await tester.pump();
+    await tester.pump();
+
+    expect(pauseRequests, greaterThan(0));
+    expect(resumeRequests, 0);
+  });
+
+  testWidgets('service-issued story labels conceal story media', (
+    tester,
+  ) async {
+    var pauseRequests = 0;
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          moderationEngineProvider.overrideWith((ref) async => _engine()),
+        ],
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: StoryPage(
+            story: _story('service-labeled', storyLabeled: true),
+            isActive: true,
+            onPauseRequested: () => pauseRequests += 1,
+          ),
+        ),
+      ),
+    );
+    await tester.pump();
+    await tester.pump();
+
+    expect(pauseRequests, greaterThan(0));
+  });
+
+  testWidgets('concealed story stays paused after its media finishes loading', (
+    tester,
+  ) async {
+    const avatarUrl = 'https://example.com/cached-avatar.png';
+    await tester.runAsync(() => _cacheImage(avatarUrl));
+    final story = _story(
+      'concealed-load',
+      authorLabeled: true,
+      avatar: avatarUrl,
+    );
+    var nextAuthorRequests = 0;
+
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          moderationEngineProvider.overrideWith((ref) async => _engine()),
+        ],
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: AuthorStoriesPage(
+            author: story.author,
+            stories: [story],
+            onNextAuthor: () => nextAuthorRequests += 1,
+          ),
+        ),
+      ),
+    );
+    await tester.pump();
+    await tester.pump();
+    await tester.pump();
+    expect(find.byType(ModeratedProfileAvatar), findsOneWidget);
+    expect(find.byType(CircularProgressIndicator), findsNothing);
+    await tester.pump(const Duration(seconds: 6));
+
+    expect(nextAuthorRequests, 0);
+    expect(
+      tester
+          .widget<LinearProgressIndicator>(find.byType(LinearProgressIndicator))
+          .value,
+      0,
+    );
+  });
+}
+
+Future<void> _cacheImage(String url) async {
+  final bytes = Uint8List.fromList(
+    base64Decode(
+      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk'
+      '+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+    ),
+  );
+  final codec = await ui.instantiateImageCodec(bytes);
+  final frame = await codec.getNextFrame();
+  final provider = CachedNetworkImageProvider(url);
+  final key = await provider.obtainKey(ImageConfiguration.empty);
+  PaintingBinding.instance.imageCache.putIfAbsent(
+    key,
+    () => OneFrameImageStreamCompleter(
+      Future.value(ImageInfo(image: frame.image.clone())),
+    ),
+  );
+  addTearDown(() {
+    PaintingBinding.instance.imageCache
+      ..clear()
+      ..clearLiveImages();
+    codec.dispose();
+    frame.image.dispose();
+  });
+}
+
+ModeratedStoryView _story(
+  String id, {
+  bool authorLabeled = false,
+  bool storyLabeled = false,
+  String avatar = 'https://example.com/avatar.jpg',
+}) {
+  final author = ProfileViewBasic(
+    did: 'did:plc:author',
+    handle: 'author.sprk.so',
+    avatar: avatar,
+    labels: authorLabeled
+        ? [
+            Label(
+              src: 'did:plc:moderator',
+              uri: 'did:plc:author',
+              val: 'sexual',
+              cts: DateTime.utc(2026, 8, 12),
+            ),
+          ]
+        : null,
+  );
+  final story = StoryView(
+    uri: AtUri('at://did:plc:author/so.sprk.story.post/$id'),
+    cid: 'cid-$id',
+    author: author,
+    record: const {},
+    indexedAt: DateTime.utc(2026, 8, 12),
+  );
+  return ModeratedStoryView(
+    story: story,
+    moderationLabels: storyLabeled
+        ? [
+            Label(
+              src: 'did:plc:moderator',
+              uri: story.uri.toString(),
+              val: 'sexual',
+              cts: DateTime.utc(2026, 8, 12),
+            ),
+          ]
+        : const [],
+  );
+}
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions.fromLabelers(const {
+    'did:plc:moderator': [],
+  }),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);