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/templates/chat_list_page_template.dart b/lib/src/core/design_system/templates/chat_list_page_template.dart
index 8faf9a03..b5a03b0b 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
@@ -34,6 +34,7 @@ class ChatListPageTemplate extends StatelessWidget {
     this.loadingItemCount = 8,
     this.onAddTap,
     this.onRefresh,
+    this.itemWrapper,
   });
 
   const ChatListPageTemplate.loading({
@@ -42,6 +43,7 @@ class ChatListPageTemplate extends StatelessWidget {
     this.loadingItemCount = 8,
     this.onAddTap,
     this.onRefresh,
+    this.itemWrapper,
   }) : items = const [],
        onItemTap = _noopItemTap,
        loading = true;
@@ -53,6 +55,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 +90,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;
+                      },
                     ),
                   ),
           ),
diff --git a/lib/src/core/design_system/templates/image_review_page_template.dart b/lib/src/core/design_system/templates/image_review_page_template.dart
index a5de199f..fd9a8bd1 100644
--- a/lib/src/core/design_system/templates/image_review_page_template.dart
+++ b/lib/src/core/design_system/templates/image_review_page_template.dart
@@ -46,6 +46,7 @@ class ImageReviewPageTemplate extends StatelessWidget {
     this.mentionController,
     this.onMentionsChanged,
     this.showCrossPostWarning = false,
+    this.contentWarningSection,
     this.backgroundColor,
     this.isOverLimit = false,
   });
@@ -70,6 +71,7 @@ class ImageReviewPageTemplate extends StatelessWidget {
   final bool crossPostValue;
   final ValueChanged<bool> onCrossPostChanged;
   final bool showCrossPostWarning;
+  final Widget? contentWarningSection;
   final String? selectedSoundTitle;
   final String? selectedSoundSubtitle;
   final VoidCallback? onAddSound;
@@ -148,6 +150,10 @@ class ImageReviewPageTemplate extends StatelessWidget {
                         onMentionsChanged: onMentionsChanged,
                         maxChars: descriptionMaxChars,
                       ),
+                      if (contentWarningSection != null) ...[
+                        const SizedBox(height: 20),
+                        contentWarningSection!,
+                      ],
                       const SizedBox(height: 20),
                       _CrossPostSection(
                         value: crossPostValue,
diff --git a/lib/src/core/design_system/templates/video_review_page_template.dart b/lib/src/core/design_system/templates/video_review_page_template.dart
index f66f3ddb..153e50b6 100644
--- a/lib/src/core/design_system/templates/video_review_page_template.dart
+++ b/lib/src/core/design_system/templates/video_review_page_template.dart
@@ -37,6 +37,7 @@ class VideoReviewPageTemplate extends StatelessWidget {
     this.uploadIndeterminate = false,
     this.hasUploadError = false,
     this.onUploadRetry,
+    this.contentWarningSection,
     super.key,
   });
 
@@ -63,6 +64,7 @@ class VideoReviewPageTemplate extends StatelessWidget {
   final bool uploadIndeterminate;
   final bool hasUploadError;
   final VoidCallback? onUploadRetry;
+  final Widget? contentWarningSection;
 
   @override
   Widget build(BuildContext context) {
@@ -116,6 +118,10 @@ class VideoReviewPageTemplate extends StatelessWidget {
                         onMentionsChanged: onMentionsChanged,
                         maxChars: descriptionMaxChars,
                       ),
+                      if (contentWarningSection != null) ...[
+                        const SizedBox(height: 20),
+                        contentWarningSection!,
+                      ],
                       if (showCrossPost) ...[
                         const SizedBox(height: 20),
                         _CrossPostSection(
diff --git a/lib/src/core/l10n/app_localizations.dart b/lib/src/core/l10n/app_localizations.dart
index d29b8bf6..073cd88e 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,234 @@ abstract class AppLocalizations {
     int count,
   );
 
+  /// Heading for author-applied media content warnings
+  ///
+  /// In en, this message translates to:
+  /// **'Content warnings'**
+  String get labelContentWarnings;
+
+  /// Explanation shown above author self-label controls
+  ///
+  /// In en, this message translates to:
+  /// **'Add any warnings that apply to the media you are posting.'**
+  String get messageContentWarningsDescription;
+
+  /// Heading for mutually exclusive adult-content warnings
+  ///
+  /// In en, this message translates to:
+  /// **'Adult Content'**
+  String get labelAdultContent;
+
+  /// 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..b1f969d7 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,129 @@ class AppLocalizationsEn extends AppLocalizations {
     return 'Followed by $firstName, $secondName, and $_temp0';
   }
 
+  @override
+  String get labelContentWarnings => 'Content warnings';
+
+  @override
+  String get messageContentWarningsDescription =>
+      'Add any warnings that apply to the media you are posting.';
+
+  @override
+  String get labelAdultContent => 'Adult Content';
+
+  @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..9aeff253 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,159 @@
     }
   },
 
+  "labelContentWarnings": "Content warnings",
+  "@labelContentWarnings": {
+    "description": "Heading for author-applied media content warnings"
+  },
+  "messageContentWarningsDescription": "Add any warnings that apply to the media you are posting.",
+  "@messageContentWarningsDescription": {
+    "description": "Explanation shown above author self-label controls"
+  },
+  "labelAdultContent": "Adult Content",
+  "@labelAdultContent": {
+    "description": "Heading for mutually exclusive adult-content warnings"
+  },
+  "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/moderated_content.dart b/lib/src/core/moderation/moderated_content.dart
new file mode 100644
index 00000000..7751dd5b
--- /dev/null
+++ b/lib/src/core/moderation/moderated_content.dart
@@ -0,0 +1,528 @@
+import 'dart:ui';
+
+import 'package:flutter/material.dart';
+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/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/repositories/sprk_repository.dart';
+
+/// Applies the same moderation decision and reveal rules to every surface.
+class ModeratedContent extends ConsumerStatefulWidget {
+  const ModeratedContent({
+    required this.labels,
+    required this.target,
+    required this.context,
+    required this.child,
+    super.key,
+    this.subjectDid,
+    this.authorLabels = const [],
+    this.compact = false,
+    this.blurredChild,
+    this.onConcealedTap,
+    this.filterReplacement = const SizedBox.shrink(),
+    this.onConcealChanged,
+  });
+
+  final List<Label> labels;
+  final ModerationTarget target;
+  final ModerationContext context;
+  final String? subjectDid;
+  final List<Label> authorLabels;
+  final Widget child;
+  final bool compact;
+  final Widget? blurredChild;
+  final VoidCallback? onConcealedTap;
+  final Widget filterReplacement;
+  final ValueChanged<bool>? onConcealChanged;
+
+  @override
+  ConsumerState<ModeratedContent> createState() => _ModeratedContentState();
+}
+
+class _ModeratedContentState extends ConsumerState<ModeratedContent> {
+  String? _revealedKey;
+  bool? _lastConcealed;
+
+  @override
+  Widget build(BuildContext context) {
+    if (widget.labels.isEmpty && widget.authorLabels.isEmpty) {
+      _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 = ModerationDecision.merge([
+      if (widget.target == ModerationTarget.account)
+        engine.evaluateProfileLabels(
+          widget.labels,
+          subjectDid: widget.subjectDid,
+          preferredLocales: [locale],
+        )
+      else
+        engine.evaluate(
+          widget.labels,
+          target: widget.target,
+          subjectDid: widget.subjectDid,
+          preferredLocales: [locale],
+        ),
+      if (widget.authorLabels.isNotEmpty)
+        engine.evaluateProfileLabels(
+          widget.authorLabels,
+          subjectDid: widget.subjectDid,
+          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.subjectDid,
+      widget.context.name,
+      _signature([...widget.labels, ...widget.authorLabels]),
+    ].join('|');
+    final shouldConceal =
+        ui.blur && (ui.noOverride || _revealedKey != disclosureKey);
+    _notifyConcealed(shouldConceal);
+
+    if (widget.compact) {
+      return Stack(
+        fit: StackFit.passthrough,
+        children: [
+          if (shouldConceal)
+            widget.blurredChild ??
+                ImageFiltered(
+                  imageFilter: ImageFilter.blur(sigmaX: 18, sigmaY: 18),
+                  child: widget.child,
+                )
+          else
+            widget.child,
+          if (shouldConceal)
+            Positioned.fill(
+              child: Material(
+                color: Colors.black.withValues(alpha: 0.38),
+                child: InkWell(
+                  onTap:
+                      widget.onConcealedTap ??
+                      (ui.noOverride
+                          ? () => _showDetails(decision, causes)
+                          : () => setState(() => _revealedKey = disclosureKey)),
+                  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(decision, causes),
+              ),
+            ),
+        ],
+      );
+    }
+
+    return Stack(
+      fit: StackFit.passthrough,
+      children: [
+        if (shouldConceal)
+          IgnorePointer(
+            child:
+                widget.blurredChild ??
+                ImageFiltered(
+                  imageFilter: ImageFilter.blur(sigmaX: 40, sigmaY: 40),
+                  child: widget.child,
+                ),
+          )
+        else
+          widget.child,
+        if (shouldConceal)
+          Positioned.fill(
+            child: _ModerationCover(
+              causes: causes,
+              noOverride: ui.noOverride,
+              onReveal: ui.noOverride
+                  ? null
+                  : () => setState(() => _revealedKey = disclosureKey),
+              onDetails: () => _showDetails(decision, causes),
+            ),
+          )
+        else if (ui.alert || ui.inform)
+          Positioned(
+            left: 12,
+            top: 12,
+            child: _ModerationNotice(
+              causes: causes,
+              onTap: () => _showDetails(decision, causes),
+            ),
+          ),
+      ],
+    );
+  }
+
+  Future<void> _showDetails(
+    ModerationDecision decision,
+    List<ModerationCause> causes,
+  ) async {
+    await showModalBottomSheet<void>(
+      context: context,
+      showDragHandle: true,
+      isScrollControlled: true,
+      builder: (context) => _ModerationDetails(
+        causes: causes,
+        mayAppeal: decision.isSubjectCurrentUser,
+      ),
+    );
+  }
+
+  void _notifyConcealed(bool concealed) {
+    if (_lastConcealed == concealed) return;
+    _lastConcealed = concealed;
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (mounted) widget.onConcealChanged?.call(concealed);
+    });
+  }
+}
+
+class _ModerationPending extends StatelessWidget {
+  const _ModerationPending({
+    required this.hasError,
+    required this.onRetry,
+    required this.child,
+  });
+
+  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,
+    );
+  }
+}
+
+class _ModerationDetails extends StatefulWidget {
+  const _ModerationDetails({required this.causes, required this.mayAppeal});
+
+  final List<ModerationCause> causes;
+  final bool mayAppeal;
+
+  @override
+  State<_ModerationDetails> createState() => _ModerationDetailsState();
+}
+
+class _ModerationDetailsState extends State<_ModerationDetails> {
+  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)
+            Builder(
+              builder: (context) {
+                final strings = cause.localizedStrings(l10n);
+                return Card(
+                  child: Padding(
+                    padding: const EdgeInsets.all(16),
+                    child: Column(
+                      crossAxisAlignment: CrossAxisAlignment.start,
+                      children: [
+                        Text(
+                          strings?.name ?? l10n.moderationContentNotice,
+                          style: Theme.of(context).textTheme.titleMedium,
+                        ),
+                        if (strings?.description case final description?) ...[
+                          const SizedBox(height: 6),
+                          Text(description),
+                        ],
+                        const SizedBox(height: 8),
+                        SelectableText(
+                          '${l10n.moderationAppliedBy}: ${cause.sourceDid}',
+                        ),
+                        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 &&
+                            cause.sourceDid != _labelSubjectDid(cause.label) &&
+                            cause.sourceDid.startsWith('did:')) ...[
+                          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 {
+      final subject = _reportSubject(cause.label);
+      await GetIt.I<SprkRepository>().repo.createReport(
+        input: ModerationCreateReportInput(
+          subject: subject,
+          reasonType: const ReasonType.knownValue(
+            data: KnownReasonType.comAtprotoModerationDefsReasonAppeal,
+          ),
+          reason: l10n.moderationAppealReason,
+        ),
+        serviceDid: cause.sourceDid,
+      );
+      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);
+    }
+  }
+}
+
+UModerationCreateReportSubject _reportSubject(Label label) {
+  AtUri? uri;
+  try {
+    uri = AtUri.parse(label.uri);
+  } catch (_) {
+    uri = null;
+  }
+  if (uri != null && label.cid != null && label.cid!.isNotEmpty) {
+    return UModerationCreateReportSubject.repoStrongRef(
+      data: RepoStrongRef(uri: uri, cid: label.cid!),
+    );
+  }
+  final did = uri?.hostname ?? label.uri;
+  return UModerationCreateReportSubject.repoRef(data: RepoRef(did: did));
+}
+
+String _labelSubjectDid(Label label) {
+  try {
+    return AtUri.parse(label.uri).hostname;
+  } catch (_) {
+    return label.uri;
+  }
+}
+
+String _signature(List<Label> labels) => labels
+    .map(
+      (label) =>
+          '${label.src}|${label.uri}|${label.val}|${label.neg}|${label.exp}',
+    )
+    .join(';;');
diff --git a/lib/src/core/moderation/moderation.dart b/lib/src/core/moderation/moderation.dart
new file mode 100644
index 00000000..d87b0773
--- /dev/null
+++ b/lib/src/core/moderation/moderation.dart
@@ -0,0 +1,4 @@
+export 'moderation_definitions.dart';
+export 'moderation_engine.dart';
+export 'moderation_label_localizations.dart';
+export 'moderation_models.dart';
diff --git a/lib/src/core/moderation/moderation_definitions.dart b/lib/src/core/moderation/moderation_definitions.dart
new file mode 100644
index 00000000..1b0b485d
--- /dev/null
+++ b/lib/src/core/moderation/moderation_definitions.dart
@@ -0,0 +1,338 @@
+import 'dart:collection';
+
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+import 'package:spark/src/core/moderation/moderation_models.dart';
+
+final class ModerationLabelDefinitions {
+  ModerationLabelDefinitions({
+    Iterable<ModerationLabelDefinition> definitions = const [],
+    bool includeBuiltIns = true,
+  }) {
+    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,
+        }),
+    });
+  }
+
+  factory ModerationLabelDefinitions.fromLabelers(
+    Map<String, Iterable<LabelValueDefinition>> definitionsByLabeler, {
+    bool includeBuiltIns = true,
+  }) {
+    return ModerationLabelDefinitions(
+      includeBuiltIns: includeBuiltIns,
+      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;
+
+  Map<String, ModerationLabelDefinition> get global => _global;
+
+  Map<String, Map<String, ModerationLabelDefinition>> get bySource => _bySource;
+
+  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.
+    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 allBlurred = ModerationBehavior({
+    ModerationContext.profileList: ModerationAction.blur,
+    ModerationContext.profileView: ModerationAction.blur,
+    ModerationContext.avatar: ModerationAction.blur,
+    ModerationContext.banner: ModerationAction.blur,
+    ModerationContext.displayName: ModerationAction.blur,
+    ModerationContext.contentList: ModerationAction.blur,
+    ModerationContext.contentView: ModerationAction.blur,
+    ModerationContext.contentMedia: ModerationAction.blur,
+  });
+  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: allBlurred,
+      ModerationTarget.profile: allBlurred,
+      ModerationTarget.content: allBlurred,
+    },
+  );
+}
+
+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_engine.dart b/lib/src/core/moderation/moderation_engine.dart
new file mode 100644
index 00000000..e02213cb
--- /dev/null
+++ b/lib/src/core/moderation/moderation_engine.dart
@@ -0,0 +1,248 @@
+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_models.dart';
+
+final class ModerationEngine {
+  const ModerationEngine({
+    required this.definitions,
+    required this.preferences,
+    this.currentUserDid,
+    this.selfLabelerDid,
+  });
+
+  final ModerationLabelDefinitions definitions;
+  final ModerationPreferences preferences;
+  final String? currentUserDid;
+  final String? selfLabelerDid;
+
+  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 (label.neg ?? false) continue;
+      if (label.exp?.toUtc().isAfter(evaluationTime) == false) continue;
+
+      final isSelfLabel = subjectDid != null && label.src == subjectDid;
+      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),
+        ),
+      );
+    }
+
+    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);
+    return ModerationDecision.merge([
+      evaluate(
+        items.where(_isAccountLabel),
+        target: ModerationTarget.account,
+        subjectDid: subjectDid,
+        preferredLocales: preferredLocales,
+        now: now,
+      ),
+      evaluate(
+        items.where(_isProfileRecordLabel),
+        target: ModerationTarget.profile,
+        subjectDid: subjectDid,
+        preferredLocales: preferredLocales,
+        now: now,
+      ),
+    ]);
+  }
+}
+
+bool _isProfileRecordLabel(Label label) {
+  return label.uri.endsWith('/app.bsky.actor.profile/self');
+}
+
+bool _isAccountLabel(Label label) {
+  return !_isProfileRecordLabel(label) || label.val == '!no-unauthenticated';
+}
+
+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 || target == ModerationTarget.profile,
+    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_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..cfdae6b6
--- /dev/null
+++ b/lib/src/core/moderation/moderation_models.dart
@@ -0,0 +1,271 @@
+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,
+  });
+
+  final Label label;
+  final ModerationLabelDefinition definition;
+  final ModerationTarget target;
+  final ModerationSetting setting;
+  final ModerationBehavior behavior;
+  final bool noOverride;
+  final int priority;
+  final ModerationLabelStrings? strings;
+
+  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_provider.dart b/lib/src/core/moderation/moderation_provider.dart
new file mode 100644
index 00000000..e3070d00
--- /dev/null
+++ b/lib/src/core/moderation/moderation_provider.dart
@@ -0,0 +1,50 @@
+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/utils/logging/log_service.dart';
+import 'package:spark/src/features/settings/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 = <String>{
+    repository.modDid.split('#').first,
+    ...?preferences.labelers?.map((labeler) => labeler.did),
+  };
+
+  final definitions = <String, Iterable<LabelValueDefinition>>{};
+  await Future.wait(
+    labelerDids.map((did) async {
+      try {
+        final service = await repository.labeler.getServicesDetailed([did]);
+        definitions[did] = service.policies.labelValueDefinitions ?? const [];
+      } 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: repository.modDid.split('#').first,
+  );
+});
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/models/feed_models.dart b/lib/src/core/network/atproto/data/models/feed_models.dart
index ef484b36..ee71c6aa 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
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..4c0c3acc 100644
--- a/lib/src/core/network/atproto/data/models/pref_models.dart
+++ b/lib/src/core/network/atproto/data/models/pref_models.dart
@@ -74,7 +74,27 @@ Preference contentLabelPreference({
   );
 }
 
+/// Stores Spark's adult-content preference in the forward-compatible
+/// preference union until sprk_poptart exposes the typed variant.
+Preference adultContentPreference({required bool enabled}) =>
+    Preference.unknown(
+      data: {
+        r'$type': 'so.sprk.actor.defs#adultContentPref',
+        'enabled': enabled,
+      },
+    );
+
 extension PreferencesConvenience on Preferences {
+  bool get adultContentEnabled {
+    for (final preference in preferences) {
+      final data = preference.unknown;
+      if (data?[r'$type'] == 'so.sprk.actor.defs#adultContentPref') {
+        return data?['enabled'] == true;
+      }
+    }
+    return false;
+  }
+
   List<ContentLabelPref>? get contentLabelPrefs {
     final prefs = preferences
         .map((preference) => preference.contentLabelPref)
@@ -153,7 +173,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..619f961a 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
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..f26511cf 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
@@ -87,12 +87,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 +211,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 +232,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(
@@ -331,7 +323,7 @@ class FeedRepositoryImpl implements FeedRepository {
                   )
                 : null,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
         final output = result.data;
         final outputJson = output.toJson();
@@ -391,6 +383,7 @@ class FeedRepositoryImpl implements FeedRepository {
                       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);
@@ -1460,7 +1459,7 @@ class FeedRepositoryImpl implements FeedRepository {
             limit: 100,
             cursor: cursor,
           ),
-          headers: {'atproto-proxy': _client.sprkDid},
+          headers: _client.appViewHeaders(_client.sprkDid),
         );
 
         final pageItems =
@@ -1508,9 +1507,9 @@ class FeedRepositoryImpl implements FeedRepository {
 
       // Use modDid from repository as fallback if no sources provided
       final defaultLabelerDid = _client.modDid.split('#').first;
-      final labelers = sources?.isNotEmpty ?? true
-          ? sources!
-          : [defaultLabelerDid];
+      final labelers = sources != null && sources.isNotEmpty
+          ? sources
+          : _client.labelerDids;
 
       final parameters = label_query_labels.LabelQueryLabelsInput(
         uriPatterns: uris.map((uri) => uri.toString()).toList(),
@@ -1575,7 +1574,7 @@ class FeedRepositoryImpl implements FeedRepository {
           sort: sprk_search_posts.FeedSearchPostsSort.valueOf(sort),
           cursor: cursor,
         ),
-        headers: {'atproto-proxy': _client.sprkDid},
+        headers: _client.appViewHeaders(_client.sprkDid),
       );
 
       final output = response.data;
@@ -1621,7 +1620,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 +1663,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 +1732,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..e446d94c 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,22 @@
 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;
+}
+
 /// 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);
 }
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..9dc84e41 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,6 @@
 import 'package:poptart/poptart.dart';
+import 'package:poptart_lex/com/atproto/identity/resolve_handle.dart'
+    as identity_resolve_handle;
 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';
@@ -17,6 +19,49 @@ class LabelerRepositoryImpl extends LabelerRepository {
   final SprkRepository _client;
   final SparkLogger _logger;
 
+  @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<LabelerView> getServices(List<String> dids) async {
     _logger.d('Getting labeler services for DIDs: $dids');
@@ -38,18 +83,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;
@@ -77,18 +126,22 @@ 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;
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..41e3dbc5 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;
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..15d2fde6 100644
--- a/lib/src/core/network/atproto/data/repositories/repo_repository.dart
+++ b/lib/src/core/network/atproto/data/repositories/repo_repository.dart
@@ -79,5 +79,6 @@ abstract class RepoRepository {
   Future<bool> createReport({
     required ModerationCreateReportInput input,
     dynamic service,
+    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..c9e9c9f8 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
@@ -262,6 +262,7 @@ class RepoRepositoryImpl implements RepoRepository {
   Future<bool> createReport({
     required ModerationCreateReportInput input,
     dynamic service,
+    String? serviceDid,
   }) async {
     _logger.i('Creating moderation report for reason: ${input.reasonType}');
 
@@ -291,22 +292,23 @@ class RepoRepositoryImpl implements RepoRepository {
       } 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',
-        );
+        final isBskyPost =
+            subjectData is RepoStrongRef &&
+            subjectData.uri.collection.toString().startsWith('app.bsky');
+        final fallbackServiceDid = isBskyPost
+            ? _client.bskyModDid
+            : _client.modDid;
+        final modServiceDid =
+            serviceDid ??
+            await _resolveCompatibleModerationService(
+              input,
+              fallbackDid: fallbackServiceDid,
+            );
+        _logger.d('Routing report to moderation service: $modServiceDid');
 
-        final headers = {'atproto-proxy': modServiceDid};
+        final headers = {
+          'atproto-proxy': _moderationProxyDid(modServiceDid),
+        };
 
         try {
           final response = await atproto.call(
@@ -332,4 +334,52 @@ class RepoRepositoryImpl implements RepoRepository {
       }
     });
   }
+
+  Future<String> _resolveCompatibleModerationService(
+    ModerationCreateReportInput input, {
+    required String fallbackDid,
+  }) async {
+    final subject = input.subject.data;
+    final subjectType = subject is RepoStrongRef ? 'record' : 'account';
+    final collection = subject is RepoStrongRef
+        ? subject.uri.collection.toString()
+        : null;
+    final reasonType = input.reasonType.toJson();
+    final candidates = <String>{
+      fallbackDid.split('#').first,
+      ..._client.labelerDids,
+    };
+
+    for (final did in candidates) {
+      try {
+        final service = await _client.labeler.getServicesDetailed([did]);
+        final subjectTypes = service.subjectTypes?.map((type) => type.toJson());
+        if (subjectTypes != null && !subjectTypes.contains(subjectType)) {
+          continue;
+        }
+        final collections = service.subjectCollections;
+        if (collection != null &&
+            collections != null &&
+            !collections.contains(collection)) {
+          continue;
+        }
+        final reasons = service.reasonTypes?.map((reason) => reason.toJson());
+        if (reasons != null && !reasons.contains(reasonType)) {
+          continue;
+        }
+        return did;
+      } catch (error, stackTrace) {
+        _logger.w(
+          'Could not inspect moderation service $did',
+          error: error,
+          stackTrace: stackTrace,
+        );
+      }
+    }
+    return fallbackDid;
+  }
+
+  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_impl.dart b/lib/src/core/network/atproto/data/repositories/story_repository_impl.dart
index b596f648..0709d423 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
@@ -96,7 +96,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();
@@ -174,7 +174,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();
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..9f170061
--- /dev/null
+++ b/lib/src/core/network/atproto/data/services/appview_labeler_headers.dart
@@ -0,0 +1,65 @@
+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 = [_normalizeDid(defaultLabelerDid)];
+
+  static const int maxLabelers = 20;
+
+  final String _defaultLabelerDid;
+  List<String> _labelerDids;
+
+  List<String> get labelerDids => List.unmodifiable(_labelerDids);
+
+  void configure(Iterable<String> labelerDids) {
+    final normalized = <String>{_defaultLabelerDid};
+    for (final did in labelerDids) {
+      final value = _normalizeDid(did);
+      if (value.isNotEmpty) {
+        normalized.add(value);
+      }
+      if (normalized.length == maxLabelers) {
+        break;
+      }
+    }
+    _labelerDids = normalized.toList(growable: false);
+  }
+
+  Map<String, String> forAppView(
+    String? proxyDid, {
+    Iterable<String>? labelerDids,
+  }) {
+    final accepted = labelerDids == null
+        ? _labelerDids
+        : _normalizedWithDefault(labelerDids);
+    final headers = <String, String>{
+      if (accepted.isNotEmpty) atprotoAcceptLabelersHeader: accepted.join(','),
+    };
+    if (proxyDid != null) {
+      headers['atproto-proxy'] = proxyDid;
+    }
+    return headers;
+  }
+
+  List<String> _normalizedWithDefault(Iterable<String> labelerDids) {
+    final normalized = <String>{_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/routing/app_router.dart b/lib/src/core/routing/app_router.dart
index b31c34ff..373c1350 100644
--- a/lib/src/core/routing/app_router.dart
+++ b/lib/src/core/routing/app_router.dart
@@ -109,6 +109,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..6d6ccdd9 100644
--- a/lib/src/core/ui/widgets/report_dialog.dart
+++ b/lib/src/core/ui/widgets/report_dialog.dart
@@ -1,3 +1,6 @@
+import 'dart:async';
+
+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/moderation/defs.dart';
 import 'package:poptart/poptart.dart';
@@ -13,10 +16,11 @@ import 'package:spark/src/core/utils/logging/log_service.dart';
 import 'package:spark/src/core/utils/logging/logger.dart';
 
 typedef ReportSubmitCallback =
-    void Function(
+    Future<void> Function(
       UModerationCreateReportSubject subject,
       ReasonType reasonType,
       String? reason,
+      String serviceDid,
     );
 
 enum ReportCategory {
@@ -49,13 +53,20 @@ class ReportReason {
 
 class ReportDialog extends ConsumerStatefulWidget {
   const ReportDialog({
-    required this.postUri,
-    required this.postCid,
+    this.postUri,
+    this.postCid,
+    this.accountDid,
+    this.fallbackServiceDid,
     super.key,
     this.onSubmit,
-  });
-  final String postUri;
-  final String postCid;
+  }) : assert(
+         accountDid != null || (postUri != null && postCid != null),
+         'Provide either an account DID or both a record URI and CID.',
+       );
+  final String? postUri;
+  final String? postCid;
+  final String? accountDid;
+  final String? fallbackServiceDid;
 
   /// Callback for report submission. Uses [ReasonType] directly to support
   /// known & unknown reason types.
@@ -75,6 +86,8 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
       TextEditingController();
   bool _isSubmitting = false;
   String? _errorMessage;
+  Future<List<_ModerationServiceOption>>? _compatibleServicesFuture;
+  String? _selectedServiceDid;
 
   // Map categories to their reasons
   static final Map<ReportCategory, List<ReportReason>> _categoryReasons = {
@@ -353,27 +366,122 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
   }
 
   void _selectReason(ReportReason reason) {
+    final servicesFuture = _loadCompatibleServices(reason);
     setState(() {
       _selectedReason = reason;
+      _compatibleServicesFuture = servicesFuture;
+      _selectedServiceDid = null;
     });
+    unawaited(
+      servicesFuture.then((services) {
+        if (!mounted || _selectedReason != reason || services.isEmpty) return;
+        setState(() {
+          _selectedServiceDid = services.first.did;
+        });
+      }),
+    );
   }
 
   void _goBack() {
     setState(() {
       _selectedCategory = null;
       _selectedReason = null;
+      _compatibleServicesFuture = null;
+      _selectedServiceDid = null;
     });
   }
 
-  Future<void> _submitReport() async {
-    if (_selectedReason == null) return;
-
-    final subject = UModerationCreateReportSubject.repoStrongRef(
+  UModerationCreateReportSubject _buildSubject() {
+    final accountDid = widget.accountDid;
+    if (accountDid != null) {
+      return UModerationCreateReportSubject.repoRef(
+        data: RepoRef(did: accountDid),
+      );
+    }
+    return UModerationCreateReportSubject.repoStrongRef(
       data: RepoStrongRef(
-        cid: widget.postCid,
-        uri: AtUri.parse(widget.postUri),
+        cid: widget.postCid!,
+        uri: AtUri.parse(widget.postUri!),
       ),
     );
+  }
+
+  ReasonType _reasonTypeFor(ReportReason reason) {
+    return reason.knownType != null
+        ? ReasonType.knownValue(data: reason.knownType!)
+        : ReasonType.unknown(data: reason.value);
+  }
+
+  Future<List<_ModerationServiceOption>> _loadCompatibleServices(
+    ReportReason reason,
+  ) async {
+    final repository = GetIt.instance<SprkRepository>();
+    final subject = _buildSubject().data;
+    final isRecord = subject is RepoStrongRef;
+    final collection = isRecord ? subject.uri.collection.toString() : null;
+    final fallbackProxyDid =
+        widget.fallbackServiceDid ??
+        (isRecord && collection!.startsWith('app.bsky')
+            ? repository.bskyModDid
+            : repository.modDid);
+    final fallbackDid = fallbackProxyDid.split('#').first;
+    final candidates = <String>{fallbackDid, ...repository.labelerDids};
+    final reasonType = _reasonTypeFor(reason).toJson();
+    final services = <_ModerationServiceOption>[];
+
+    for (final did in candidates) {
+      try {
+        final service = await repository.labeler.getServicesDetailed([did]);
+        final subjectTypes = service.subjectTypes?.map((type) => type.toJson());
+        if (subjectTypes != null &&
+            !subjectTypes.contains(isRecord ? 'record' : 'account')) {
+          continue;
+        }
+        if (collection != null &&
+            service.subjectCollections != null &&
+            !service.subjectCollections!.contains(collection)) {
+          continue;
+        }
+        final reasonTypes = service.reasonTypes?.map((type) => type.toJson());
+        if (reasonTypes != null && !reasonTypes.contains(reasonType)) {
+          continue;
+        }
+        services.add(
+          _ModerationServiceOption(
+            did: did,
+            displayName: service.creator.displayName ?? service.creator.handle,
+            isDefault: did == fallbackDid,
+          ),
+        );
+      } catch (error, stackTrace) {
+        _logger.w(
+          'Unable to inspect report capabilities for $did',
+          error: error,
+          stackTrace: stackTrace,
+        );
+        if (did == fallbackDid) {
+          services.add(
+            _ModerationServiceOption(
+              did: did,
+              displayName: did,
+              isDefault: true,
+            ),
+          );
+        }
+      }
+    }
+
+    services.sort((left, right) {
+      if (left.isDefault != right.isDefault) return left.isDefault ? -1 : 1;
+      return left.displayName.compareTo(right.displayName);
+    });
+    return services;
+  }
+
+  Future<void> _submitReport() async {
+    if (_selectedReason == null || _selectedServiceDid == null) return;
+
+    final subject = _buildSubject();
     final reason = _additionalInfoController.text.isNotEmpty
         ? _additionalInfoController.text
         : null;
@@ -386,13 +494,15 @@ 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);
+      final reasonType = _reasonTypeFor(_selectedReason!);
 
       if (widget.onSubmit != null) {
-        // Use the callback if provided - now passing ReasonType directly
-        widget.onSubmit!(subject, reasonType, reason);
+        await widget.onSubmit!(
+          subject,
+          reasonType,
+          reason,
+          _selectedServiceDid!,
+        );
         if (mounted) {
           context.router.maybePop();
         }
@@ -407,6 +517,7 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
             reasonType: reasonType,
             reason: reason,
           ),
+          serviceDid: _selectedServiceDid,
         );
 
         if (success && mounted) {
@@ -477,79 +588,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<List<_ModerationServiceOption>>(
+                  future: _compatibleServicesFuture,
+                  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 ?? 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,
@@ -566,6 +727,18 @@ class _ReportDialogState extends ConsumerState<ReportDialog> {
   }
 }
 
+class _ModerationServiceOption {
+  const _ModerationServiceOption({
+    required this.did,
+    required this.displayName,
+    required this.isDefault,
+  });
+
+  final String did;
+  final String displayName;
+  final bool isDefault;
+}
+
 class _CategoryTile extends StatelessWidget {
   const _CategoryTile({
     required this.category,
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..6051672f 100644
--- a/lib/src/features/comments/ui/widgets/comment_item.dart
+++ b/lib/src/features/comments/ui/widgets/comment_item.dart
@@ -7,6 +7,8 @@ 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';
@@ -37,21 +39,28 @@ 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(
+      labels: post.labels ?? const [],
+      authorLabels: post.author.labels ?? const [],
+      target: ModerationTarget.content,
+      context: ModerationContext.contentList,
+      subjectDid: post.author.did,
+      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),
+        ],
+      ),
     );
   }
 }
@@ -100,7 +109,7 @@ class _CommentBodyState extends ConsumerState<CommentBody> {
       builder: (context) => ReportDialog(
         postUri: commentState.thread.post.uri.toString(),
         postCid: commentState.thread.post.cid,
-        onSubmit: (subject, reasonType, reason) async {
+        onSubmit: (subject, reasonType, reason, serviceDid) async {
           try {
             await sprkRepository.repo.createReport(
               input: ModerationCreateReportInput(
@@ -108,6 +117,7 @@ class _CommentBodyState extends ConsumerState<CommentBody> {
                 reasonType: reasonType,
                 reason: reason,
               ),
+              serviceDid: serviceDid,
             );
           } catch (e) {
             _logger.e('Error creating report', error: e);
diff --git a/lib/src/features/feed/providers/feed_provider.dart b/lib/src/features/feed/providers/feed_provider.dart
index ee3dea27..c2487c83 100644
--- a/lib/src/features/feed/providers/feed_provider.dart
+++ b/lib/src/features/feed/providers/feed_provider.dart
@@ -6,7 +6,8 @@ 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';
@@ -19,8 +20,6 @@ part 'feed_provider.g.dart';
 
 abstract interface class FeedSettingsGateway {
   Future<List<String>> getLabelers();
-
-  Future<LabelPreference> getLabelPreference(String value);
 }
 
 class _RiverpodFeedSettingsGateway implements FeedSettingsGateway {
@@ -44,11 +43,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 +209,63 @@ 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;
+        final activeLabels = <Label>[
+          ...?extraInfo[post.uri]?.postLabels.where(
+            (label) => label.exp?.toUtc().isAfter(now) ?? true,
+          ),
+        ];
+        for (final incoming in incomingLabels) {
+          final existingIndex = activeLabels.indexWhere(
+            (label) =>
+                label.src == incoming.src &&
+                label.uri == incoming.uri &&
+                label.val == incoming.val,
+          );
+          final isExpired = incoming.exp?.toUtc().isAfter(now) == false;
+          if (incoming.isNeg || isExpired) {
+            if (existingIndex != -1 &&
+                _labelIsAtLeastAsNew(incoming, activeLabels[existingIndex])) {
+              activeLabels.removeAt(existingIndex);
             }
-          } else {
-            // if the new label is not in the existing labels, add it
-            return (postLabels: [...existingLabels, newLabel]);
+            continue;
+          }
+          if (existingIndex == -1) {
+            activeLabels.add(incoming);
+          } else if (_labelIsAtLeastAsNew(
+            incoming,
+            activeLabels[existingIndex],
+          )) {
+            activeLabels[existingIndex] = incoming;
           }
-        }, ifAbsent: () => (postLabels: [newLabel]));
+        }
+        extraInfo[post.uri] = (postLabels: activeLabels);
+        postsWithMergedLabels.add(post.copyWith(labels: activeLabels));
       }
 
       final filteredPosts = await _filterHiddenPosts(
@@ -289,29 +281,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(
@@ -561,22 +558,29 @@ 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;
-      }
+  Future<bool> _shouldHidePost(PostView post, List<Label> postLabels) async {
+    try {
+      final engine = await ref.read(moderationEngineProvider.future);
+      final decision = ModerationDecision.merge([
+        engine.evaluate(
+          postLabels,
+          target: ModerationTarget.content,
+          subjectDid: post.author.did,
+        ),
+        engine.evaluateProfileLabels(
+          post.author.labels ?? const [],
+          subjectDid: post.author.did,
+        ),
+      ]);
+      return decision.forContext(ModerationContext.contentList).filter;
+    } catch (error, stackTrace) {
+      _logger.w(
+        'Could not evaluate moderation for ${post.uri}',
+        error: error,
+        stackTrace: stackTrace,
+      );
+      return false;
     }
-    return false;
   }
 
   /// Filters based on label preferences, removing posts that should be hidden
@@ -590,7 +594,7 @@ class FeedNotifier extends _$FeedNotifier {
       final postExtraInfo = extraInfo[post.uri];
       if (postExtraInfo != null) {
         final shouldHide = await _shouldHidePost(
-          post.uri,
+          post,
           postExtraInfo.postLabels,
         );
         if (!shouldHide) {
@@ -604,3 +608,12 @@ class FeedNotifier extends _$FeedNotifier {
     return filteredPosts;
   }
 }
+
+bool _labelIsAtLeastAsNew(Label candidate, Label existing) {
+  final candidateVersion = candidate.ver;
+  final existingVersion = existing.ver;
+  if (candidateVersion != null || existingVersion != null) {
+    return (candidateVersion ?? 0) >= (existingVersion ?? 0);
+  }
+  return !candidate.cts.toUtc().isBefore(existing.cts.toUtc());
+}
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..dfb10d6f
--- /dev/null
+++ b/lib/src/features/feed/providers/visible_pinned_feeds_provider.dart
@@ -0,0 +1,50 @@
+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';
+
+final visiblePinnedFeedsProvider = Provider<List<Feed>>((ref) {
+  final settings = ref.watch(settingsProvider);
+  final engine = ref.watch(moderationEngineProvider).asData?.value;
+
+  return settings.feeds
+      .where((feed) {
+        if (!feed.config.pinned) return false;
+
+        final generator = feed.view;
+        if (generator == null) return true;
+
+        final hasLabels =
+            (generator.labels?.isNotEmpty ?? false) ||
+            (generator.creator.labels?.isNotEmpty ?? false);
+        if (!hasLabels) return true;
+        if (engine == null) return false;
+
+        return !feedGeneratorModerationDecision(
+          engine,
+          generator,
+        ).forContext(ModerationContext.contentList).filter;
+      })
+      .toList(growable: false);
+});
+
+ModerationDecision feedGeneratorModerationDecision(
+  ModerationEngine engine,
+  GeneratorView generator, {
+  Iterable<String> preferredLocales = const [],
+}) {
+  return ModerationDecision.merge([
+    engine.evaluate(
+      generator.labels ?? const [],
+      target: ModerationTarget.content,
+      subjectDid: generator.creator.did,
+      preferredLocales: preferredLocales,
+    ),
+    engine.evaluateProfileLabels(
+      generator.creator.labels ?? const [],
+      subjectDid: generator.creator.did,
+      preferredLocales: preferredLocales,
+    ),
+  ]);
+}
diff --git a/lib/src/features/feed/ui/pages/feeds_page.dart b/lib/src/features/feed/ui/pages/feeds_page.dart
index b69cb334..4043a9ac 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() {
@@ -98,9 +102,13 @@ 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 feeds = ref.watch(visiblePinnedFeedsProvider);
+    var activeFeed = settings.activeFeed;
+    if (feeds.isNotEmpty &&
+        !feeds.any((feed) => feed.config.id == activeFeed.config.id)) {
+      activeFeed = feeds.first;
+      _scheduleActiveFeed(activeFeed);
+    }
 
     // Check if we need to initialize or update the page controller
     final needsInitialization = !_isInitialized;
@@ -179,4 +187,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..45357d29 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 = false;
   bool _hasOpenedHighlightedReply = false;
   String? _activePostUri;
   ProviderSubscription<int>? _anchorUpdateSubscription;
@@ -72,7 +69,6 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
       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);
@@ -217,7 +179,7 @@ class _StandalonePostPageState extends ConsumerState<StandalonePostPage> {
               Positioned.fill(
                 child: postData!.videoUrl.isNotEmpty
                     ? MediaPlaybackGate(
-                        isActive: true,
+                        isActive: !_moderationConcealed,
                         builder: (context, shouldPlay) {
                           return PostVideoPlayer(
                             key: _videoPlayerKey,
@@ -247,20 +209,20 @@ 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()),
+            labels: postData.labels ?? const [],
+            authorLabels: postData.author.labels ?? const [],
+            target: ModerationTarget.content,
+            context: ModerationContext.contentView,
+            subjectDid: postData.author.did,
+            onConcealChanged: (concealed) {
+              if (mounted && _moderationConcealed != concealed) {
+                setState(() => _moderationConcealed = concealed);
+              }
+            },
+            child: mainContent,
+          );
         } else if (snapshot.hasError) {
           content = Center(
             child: Column(
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..fb7b8ca8 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'
@@ -151,18 +154,28 @@ class _FeedsBarState extends ConsumerState<FeedsBar> {
   Widget build(BuildContext context) {
     final l10n = AppLocalizations.of(context);
     final settings = ref.watch(settingsProvider);
+    final visiblePinnedFeeds = ref.watch(visiblePinnedFeedsProvider);
+    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 = feedGeneratorModerationDecision(
+          engine,
+          generator,
+          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,
@@ -174,20 +187,22 @@ class _FeedsBarState extends ConsumerState<FeedsBar> {
       selectedTagId: settings.activeFeed.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) {
           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..607bc283 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,20 @@ 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()),
+            labels: labels,
+            authorLabels: currentPost.author.labels ?? const [],
+            target: ModerationTarget.content,
+            context: ModerationContext.contentList,
+            subjectDid: currentPost.author.did,
+            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/post_overlay.dart b/lib/src/features/feed/ui/widgets/post/post_overlay.dart
index 9750e303..fb37d97c 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,13 @@ 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/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 +56,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,12 +112,27 @@ 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:
diff --git a/lib/src/features/messages/ui/pages/messages_page.dart b/lib/src/features/messages/ui/pages/messages_page.dart
index 1b222661..98bfd62d 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';
@@ -84,6 +86,16 @@ class _MessagesPageState extends ConsumerState<MessagesPage> {
           },
           onAddTap: _openNewChat,
           onRefresh: refreshAndInvalidate,
+          itemWrapper: (context, index, child) {
+            final profile = data.conversations[index].$1;
+            return ModeratedContent(
+              labels: profile.labels ?? const [],
+              target: ModerationTarget.account,
+              context: ModerationContext.profileList,
+              subjectDid: profile.did,
+              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..ceb87eae 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,22 @@ 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(
+          labels: actor.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.profileList,
+          subjectDid: actor.did,
+          child: 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),
+            ),
           ),
         );
       },
diff --git a/lib/src/features/messages/ui/widgets/messages_list.dart b/lib/src/features/messages/ui/widgets/messages_list.dart
index 4ce95862..7b6f73b9 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,28 @@ 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(
+          labels: post.labels ?? const [],
+          authorLabels: post.author.labels ?? const [],
+          target: ModerationTarget.content,
+          context: ModerationContext.contentList,
+          subjectDid: post.author.did,
+          compact: true,
+          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..d1c7c806 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,18 @@ class _NotificationItemState extends ConsumerState<NotificationItem> {
 
       return SizedBox(
         width: 40,
-        child: UserAvatar(
-          imageUrl: avatarUrl,
-          username: username,
-          size: 32,
-          backgroundColor: getAvatarColor(handleHash),
+        child: ModeratedContent(
+          labels: author.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.avatar,
+          subjectDid: author.did,
+          compact: true,
+          child: UserAvatar(
+            imageUrl: avatarUrl,
+            username: username,
+            size: 32,
+            backgroundColor: getAvatarColor(handleHash),
+          ),
         ),
       );
     }
@@ -429,11 +438,18 @@ class _NotificationItemState extends ConsumerState<NotificationItem> {
 
             return Positioned(
               left: index * overlapStep,
-              child: UserAvatar(
-                imageUrl: avatarUrl,
-                username: username,
-                size: avatarSize,
-                backgroundColor: getAvatarColor(handleHash),
+              child: ModeratedContent(
+                labels: author.labels ?? const [],
+                target: ModerationTarget.account,
+                context: ModerationContext.avatar,
+                subjectDid: author.did,
+                compact: true,
+                child: UserAvatar(
+                  imageUrl: avatarUrl,
+                  username: username,
+                  size: avatarSize,
+                  backgroundColor: getAvatarColor(handleHash),
+                ),
               ),
             );
           }),
@@ -489,132 +505,139 @@ 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(
+      labels: notification.labels ?? const [],
+      authorLabels: notification.author.labels ?? const [],
+      target: ModerationTarget.content,
+      context: ModerationContext.contentList,
+      subjectDid: primaryAuthor.did,
+      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/models/content_warning_selection.dart b/lib/src/features/posting/models/content_warning_selection.dart
new file mode 100644
index 00000000..c9c13233
--- /dev/null
+++ b/lib/src/features/posting/models/content_warning_selection.dart
@@ -0,0 +1,28 @@
+import 'package:poptart_lex/com/atproto/label/defs.dart';
+
+enum AdultContentWarning { sexual, nudity, porn }
+
+class ContentWarningSelection {
+  const ContentWarningSelection({this.adult, this.graphicMedia = false});
+
+  final AdultContentWarning? adult;
+  final bool graphicMedia;
+
+  ContentWarningSelection copyWith({
+    AdultContentWarning? adult,
+    bool clearAdult = false,
+    bool? graphicMedia,
+  }) {
+    return ContentWarningSelection(
+      adult: clearAdult ? null : adult ?? this.adult,
+      graphicMedia: graphicMedia ?? this.graphicMedia,
+    );
+  }
+
+  List<SelfLabel> get selfLabels => [
+    if (adult case final value?) SelfLabel(val: value.name),
+    if (graphicMedia) const SelfLabel(val: 'graphic-media'),
+  ];
+
+  List<String> get values => selfLabels.map((label) => label.val).toList();
+}
diff --git a/lib/src/features/posting/providers/video_upload_provider.dart b/lib/src/features/posting/providers/video_upload_provider.dart
index 1825240b..98066631 100644
--- a/lib/src/features/posting/providers/video_upload_provider.dart
+++ b/lib/src/features/posting/providers/video_upload_provider.dart
@@ -1,6 +1,7 @@
 import 'package:poptart/poptart.dart';
 import 'package:bluesky_poptart/app/bsky/richtext/facet.dart';
 import 'package:poptart_lex/com/atproto/repo/strong_ref.dart';
+import 'package:poptart_lex/com/atproto/label/defs.dart';
 import 'package:get_it/get_it.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 import 'package:spark/src/core/network/atproto/atproto.dart';
@@ -52,6 +53,7 @@ Future<RepoStrongRef?> postVideo(
   bool crosspostToBsky = false,
   RepoStrongRef? soundRef,
   List<Facet> facets = const [],
+  List<String> selfLabelValues = const [],
 }) async {
   final logger = GetIt.I<LogService>().getLogger('Posting Video');
   try {
@@ -64,6 +66,9 @@ Future<RepoStrongRef?> postVideo(
       crosspostToBsky: crosspostToBsky,
       soundRef: soundRef,
       facets: facets,
+      selfLabels: selfLabelValues
+          .map((value) => SelfLabel(val: value))
+          .toList(),
     );
   } catch (error, stackTrace) {
     logger.e('Error posting video', error: error, stackTrace: stackTrace);
@@ -81,6 +86,7 @@ Future<RepoStrongRef?> postProcessedVideo({
   RepoStrongRef? soundRef,
   List<Facet> facets = const [],
   List<StoryEmbed> storyEmbeds = const [],
+  List<SelfLabel>? selfLabels,
 }) async {
   final logger = GetIt.I<LogService>().getLogger('Post Processed Video')
     ..d(
@@ -117,6 +123,7 @@ Future<RepoStrongRef?> postProcessedVideo({
           Media.video(video: videoBlob, aspectRatio: aspectRatio),
           soundRef: effectiveSoundRef,
           embeds: storyEmbeds,
+          selfLabels: selfLabels,
         );
         logger.i('Story posted: ${res.uri}');
         return res;
@@ -135,6 +142,7 @@ Future<RepoStrongRef?> postProcessedVideo({
       crosspostToBsky: crosspostToBsky,
       soundRef: effectiveSoundRef,
       facets: facets,
+      selfLabels: selfLabels,
     );
     logger.i('Video flow complete (storyMode=false) success=${res != null}');
     return res;
@@ -161,6 +169,7 @@ Future<RepoStrongRef?> processAndPostVideo(
   RepoStrongRef? soundRef,
   List<Facet> facets = const [],
   List<StoryEmbed> storyEmbeds = const [],
+  List<String> selfLabelValues = const [],
 }) async {
   final logger = GetIt.I<LogService>().getLogger('Process/Post Video')
     ..d(
@@ -183,6 +192,7 @@ Future<RepoStrongRef?> processAndPostVideo(
     soundRef: soundRef,
     facets: facets,
     storyEmbeds: storyEmbeds,
+    selfLabels: selfLabelValues.map((value) => SelfLabel(val: value)).toList(),
   );
 }
 
@@ -195,6 +205,7 @@ Future<RepoStrongRef?> _postVideoRecord({
   required bool crosspostToBsky,
   required RepoStrongRef? soundRef,
   required List<Facet> facets,
+  required List<SelfLabel>? selfLabels,
 }) async {
   logger.d(
     'Posting video (size=${blob.size}, crosspost=$crosspostToBsky, '
@@ -209,6 +220,7 @@ Future<RepoStrongRef?> _postVideoRecord({
     media: Media.video(video: blob, alt: altText, aspectRatio: aspectRatio),
     createdAt: DateTime.now().toUtc(),
     sound: soundRef,
+    selfLabels: selfLabels,
   );
 
   final result = await GetIt.I<SprkRepository>().repo.createRecord(
@@ -226,6 +238,7 @@ Future<RepoStrongRef?> _postVideoRecord({
         altText,
         result.uri.rkey,
         facets,
+        selfLabels,
       );
       finalResult = await GetIt.I<SprkRepository>().repo.editRecordJson(
         uri: result.uri,
@@ -241,25 +254,13 @@ 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,
   String altText,
   String rkey,
   List<Facet> sparkFacets,
+  List<SelfLabel>? selfLabels,
 ) async {
   final logger = GetIt.I<LogService>().getLogger('Crosspost Video')
     ..d('Crossposting video to Bluesky');
@@ -324,6 +325,8 @@ Future<RepoStrongRef> _crosspostVideoToBlueSkyRecord(
       'alt': altText,
     },
     'createdAt': DateTime.now().toUtc().toIso8601String(),
+    if (selfLabels != null && selfLabels.isNotEmpty)
+      'labels': SelfLabels(values: selfLabels).toJson(),
   };
 
   final result = await sprkRepository.repo.createRecord(
diff --git a/lib/src/features/posting/ui/pages/image_review_page.dart b/lib/src/features/posting/ui/pages/image_review_page.dart
index c99d17bc..e3676f03 100644
--- a/lib/src/features/posting/ui/pages/image_review_page.dart
+++ b/lib/src/features/posting/ui/pages/image_review_page.dart
@@ -15,8 +15,10 @@ import 'package:spark/src/core/ui/widgets/alt_text_editor_dialog.dart';
 import 'package:spark/src/features/auth/providers/auth_providers.dart';
 import 'package:spark/src/features/media_editor/canvas/ui/pages/post_image_editor_page.dart';
 import 'package:spark/src/features/posting/models/mention_controller.dart';
+import 'package:spark/src/features/posting/models/content_warning_selection.dart';
 import 'package:spark/src/features/posting/providers/post_story.dart';
 import 'package:spark/src/features/posting/ui/widgets/image_sound_selection_sheet.dart';
+import 'package:spark/src/features/posting/ui/widgets/content_warning_selector.dart';
 import 'package:spark/src/features/profile/providers/profile_feed_provider.dart';
 import 'package:spark/src/features/sound/models/sound_audio_track.dart';
 
@@ -44,6 +46,7 @@ class _ImageReviewPageState extends ConsumerState<ImageReviewPage> {
   final Map<String, String> _altTexts = {};
   bool _crosspostToBsky = false;
   AudioTrack? _selectedSoundTrack;
+  ContentWarningSelection _contentWarnings = const ContentWarningSelection();
   late final FeedRepository _feedRepository;
 
   Future<void> showImageEditor(BuildContext context, XFile imageFile) async {
@@ -147,6 +150,7 @@ class _ImageReviewPageState extends ConsumerState<ImageReviewPage> {
         final firstImage = uploadedImage.first;
         final storyProvider = postStoryProvider(
           Media.image(image: firstImage.image, alt: firstImage.alt),
+          selfLabels: _contentWarnings.selfLabels,
         );
         final asyncResult = await ref.read(storyProvider.future);
         if (asyncResult == null) {
@@ -162,6 +166,7 @@ class _ImageReviewPageState extends ConsumerState<ImageReviewPage> {
           crosspostToBsky: crosspostEnabled,
           facets: facets,
           soundRef: decodeSoundTrackStrongRef(_selectedSoundTrack?.id),
+          selfLabels: _contentWarnings.selfLabels,
         );
       }
       return result;
@@ -213,6 +218,10 @@ class _ImageReviewPageState extends ConsumerState<ImageReviewPage> {
         // Mentions are automatically tracked in the controller
       },
       descriptionMaxChars: AppConstants.postDescriptionMaxChars,
+      contentWarningSection: ContentWarningSelector(
+        value: _contentWarnings,
+        onChanged: (value) => setState(() => _contentWarnings = value),
+      ),
       crossPostValue: _crosspostToBsky,
       onCrossPostChanged: (v) => setState(() => _crosspostToBsky = v),
       showCrossPostWarning: showCrossPostWarning,
diff --git a/lib/src/features/posting/ui/pages/story_post_page.dart b/lib/src/features/posting/ui/pages/story_post_page.dart
index 3c78d91f..049aa1f9 100644
--- a/lib/src/features/posting/ui/pages/story_post_page.dart
+++ b/lib/src/features/posting/ui/pages/story_post_page.dart
@@ -11,6 +11,8 @@ import 'package:spark/src/core/utils/error_messages.dart';
 import 'package:spark/src/core/l10n/app_localizations.dart';
 import 'package:spark/src/features/posting/providers/post_story.dart';
 import 'package:spark/src/features/posting/providers/video_upload_provider.dart';
+import 'package:spark/src/features/posting/models/content_warning_selection.dart';
+import 'package:spark/src/features/posting/ui/widgets/content_warning_selector.dart';
 
 /// Page that handles posting a story directly without a review UI.
 ///
@@ -42,6 +44,7 @@ class _StoryPostPageState extends ConsumerState<StoryPostPage> {
   bool _isPosting = false;
   String _statusMessage = 'Preparing...';
   String? _error;
+  ContentWarningSelection _contentWarnings = const ContentWarningSelection();
 
   @override
   void initState() {
@@ -54,6 +57,14 @@ class _StoryPostPageState extends ConsumerState<StoryPostPage> {
   Future<void> _postStory() async {
     if (_isPosting) return;
 
+    final selection = await showContentWarningDialog(context);
+    if (!mounted) return;
+    if (selection == null) {
+      context.router.maybePop(false);
+      return;
+    }
+    _contentWarnings = selection;
+
     setState(() {
       _isPosting = true;
       _error = null;
@@ -104,6 +115,7 @@ class _StoryPostPageState extends ConsumerState<StoryPostPage> {
       postStoryProvider(
         Media.image(image: uploadedImage.image, alt: uploadedImage.alt),
         embeds: widget.embeds,
+        selfLabels: _contentWarnings.selfLabels,
       ).future,
     );
 
@@ -123,6 +135,7 @@ class _StoryPostPageState extends ConsumerState<StoryPostPage> {
         storyMode: true,
         soundRef: widget.soundRef,
         storyEmbeds: widget.embeds,
+        selfLabelValues: _contentWarnings.values,
       ).future,
     );
 
diff --git a/lib/src/features/posting/ui/pages/video_review_page.dart b/lib/src/features/posting/ui/pages/video_review_page.dart
index 274dc21b..b8e492fc 100644
--- a/lib/src/features/posting/ui/pages/video_review_page.dart
+++ b/lib/src/features/posting/ui/pages/video_review_page.dart
@@ -17,7 +17,9 @@ import 'package:spark/src/core/ui/widgets/alt_text_editor_dialog.dart';
 import 'package:spark/src/core/utils/error_messages.dart';
 import 'package:spark/src/features/auth/providers/auth_providers.dart';
 import 'package:spark/src/features/posting/models/mention_controller.dart';
+import 'package:spark/src/features/posting/models/content_warning_selection.dart';
 import 'package:spark/src/features/posting/providers/video_upload_provider.dart';
+import 'package:spark/src/features/posting/ui/widgets/content_warning_selector.dart';
 import 'package:spark/src/features/profile/providers/profile_feed_provider.dart';
 import 'package:video_player/video_player.dart';
 
@@ -50,6 +52,7 @@ class _VideoReviewPageState extends ConsumerState<VideoReviewPage> {
   bool _isPosting = false;
   String _videoAltText = '';
   bool _crosspostToBsky = false;
+  ContentWarningSelection _contentWarnings = const ContentWarningSelection();
   late XFile _video;
   late final FeedRepository _feedRepository;
   VideoPlayerController? _player;
@@ -276,6 +279,7 @@ class _VideoReviewPageState extends ConsumerState<VideoReviewPage> {
         soundRef: widget.soundRef,
         crosspostToBsky: !widget.storyMode && _crosspostToBsky,
         facets: facets,
+        selfLabels: _contentWarnings.selfLabels,
       );
 
       if (!mounted) return;
@@ -378,6 +382,10 @@ class _VideoReviewPageState extends ConsumerState<VideoReviewPage> {
         // Mentions are automatically tracked in the controller
       },
       descriptionMaxChars: AppConstants.postDescriptionMaxChars,
+      contentWarningSection: ContentWarningSelector(
+        value: _contentWarnings,
+        onChanged: (value) => setState(() => _contentWarnings = value),
+      ),
       showCrossPost: !widget.storyMode,
       crossPostValue: _crosspostToBsky,
       onCrossPostChanged: (v) => setState(() => _crosspostToBsky = v),
diff --git a/lib/src/features/posting/ui/widgets/content_warning_selector.dart b/lib/src/features/posting/ui/widgets/content_warning_selector.dart
new file mode 100644
index 00000000..f6941e42
--- /dev/null
+++ b/lib/src/features/posting/ui/widgets/content_warning_selector.dart
@@ -0,0 +1,140 @@
+import 'package:flutter/material.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/moderation.dart';
+import 'package:spark/src/features/posting/models/content_warning_selection.dart';
+
+const _contentWarningValues = ['sexual', 'nudity', 'porn', 'graphic-media'];
+
+Future<ContentWarningSelection?> showContentWarningDialog(
+  BuildContext context,
+) {
+  var selection = const ContentWarningSelection();
+  return showDialog<ContentWarningSelection>(
+    context: context,
+    builder: (context) => StatefulBuilder(
+      builder: (context, setDialogState) {
+        final l10n = AppLocalizations.of(context);
+        return AlertDialog(
+          title: Text(l10n.labelContentWarnings),
+          content: SingleChildScrollView(
+            child: ContentWarningSelector(
+              value: selection,
+              onChanged: (value) => setDialogState(() => selection = value),
+            ),
+          ),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.pop(context),
+              child: Text(l10n.buttonCancel),
+            ),
+            FilledButton(
+              onPressed: () => Navigator.pop(context, selection),
+              child: Text(l10n.buttonPost),
+            ),
+          ],
+        );
+      },
+    ),
+  );
+}
+
+class ContentWarningSelector extends StatelessWidget {
+  const ContentWarningSelector({
+    required this.value,
+    required this.onChanged,
+    super.key,
+  });
+
+  final ContentWarningSelection value;
+  final ValueChanged<ContentWarningSelection> onChanged;
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context);
+    final colorScheme = Theme.of(context).colorScheme;
+    final strings = {
+      for (final value in _contentWarningValues)
+        value: builtInLabelDefinitionsByValue[value]!.localizedStrings(l10n)!,
+    };
+
+    return Semantics(
+      container: true,
+      label: l10n.labelContentWarnings,
+      child: Container(
+        width: double.infinity,
+        padding: const EdgeInsets.all(16),
+        decoration: ShapeDecoration(
+          color: colorScheme.surfaceContainerHighest.withValues(alpha: 0.45),
+          shape: RoundedSuperellipseBorder(
+            borderRadius: BorderRadius.circular(AppShapes.squircleRadius),
+            side: BorderSide(color: colorScheme.outlineVariant),
+          ),
+        ),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text(
+              l10n.labelContentWarnings,
+              style: AppTypography.textMediumBold.copyWith(
+                color: colorScheme.onSurface,
+              ),
+            ),
+            const SizedBox(height: 4),
+            Text(
+              l10n.messageContentWarningsDescription,
+              style: AppTypography.textSmallMedium.copyWith(
+                color: colorScheme.onSurfaceVariant,
+              ),
+            ),
+            const SizedBox(height: 12),
+            Text(l10n.labelAdultContent, style: AppTypography.textSmallBold),
+            const SizedBox(height: 8),
+            Wrap(
+              spacing: 8,
+              runSpacing: 8,
+              children: [
+                for (final adult in AdultContentWarning.values)
+                  ChoiceChip(
+                    key: Key('content-warning-${adult.name}'),
+                    label: Text(strings[adult.name]!.name),
+                    selected: value.adult == adult,
+                    onSelected: (selected) => onChanged(
+                      value.copyWith(adult: adult, clearAdult: !selected),
+                    ),
+                  ),
+              ],
+            ),
+            if (value.adult case final adult?) ...[
+              const SizedBox(height: 8),
+              Text(
+                strings[adult.name]!.description,
+                style: AppTypography.textSmallMedium.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
+              ),
+            ],
+            const SizedBox(height: 16),
+            FilterChip(
+              key: const Key('content-warning-graphic-media'),
+              label: Text(strings['graphic-media']!.name),
+              selected: value.graphicMedia,
+              onSelected: (selected) =>
+                  onChanged(value.copyWith(graphicMedia: selected)),
+            ),
+            if (value.graphicMedia) ...[
+              const SizedBox(height: 8),
+              Text(
+                strings['graphic-media']!.description,
+                style: AppTypography.textSmallMedium.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
+              ),
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+}
diff --git a/lib/src/features/posting/utils/story_direct_post.dart b/lib/src/features/posting/utils/story_direct_post.dart
index 56bf0f67..e9e27e5b 100644
--- a/lib/src/features/posting/utils/story_direct_post.dart
+++ b/lib/src/features/posting/utils/story_direct_post.dart
@@ -9,6 +9,7 @@ import 'package:spark/src/core/network/atproto/data/models/models.dart';
 import 'package:spark/src/core/network/atproto/data/repositories/sprk_repository.dart';
 import 'package:spark/src/features/posting/providers/post_story.dart';
 import 'package:spark/src/features/posting/providers/video_upload_provider.dart';
+import 'package:spark/src/features/posting/ui/widgets/content_warning_selector.dart';
 
 /// Utility for posting stories directly without a review page.
 class StoryDirectPost {
@@ -24,6 +25,9 @@ class StoryDirectPost {
     XFile imageFile, {
     List<StoryEmbed> embeds = const [],
   }) async {
+    final contentWarnings = await showContentWarningDialog(context);
+    if (contentWarnings == null || !context.mounted) return null;
+
     // Show loading overlay
     final navigator = Navigator.of(context);
 
@@ -55,6 +59,7 @@ class StoryDirectPost {
         postStoryProvider(
           Media.image(image: uploadedImage.image, alt: uploadedImage.alt),
           embeds: embeds,
+          selfLabels: contentWarnings.selfLabels,
         ).future,
       );
 
@@ -88,6 +93,9 @@ class StoryDirectPost {
     RepoStrongRef? soundRef,
     List<StoryEmbed> embeds = const [],
   }) async {
+    final contentWarnings = await showContentWarningDialog(context);
+    if (contentWarnings == null || !context.mounted) return null;
+
     // Show loading overlay
     final navigator = Navigator.of(context);
 
@@ -107,6 +115,7 @@ class StoryDirectPost {
           storyMode: true,
           soundRef: soundRef,
           storyEmbeds: embeds,
+          selfLabelValues: contentWarnings.values,
         ).future,
       );
 
diff --git a/lib/src/features/profile/providers/profile_provider.dart b/lib/src/features/profile/providers/profile_provider.dart
index 33f3fb43..8e855166 100644
--- a/lib/src/features/profile/providers/profile_provider.dart
+++ b/lib/src/features/profile/providers/profile_provider.dart
@@ -292,6 +292,7 @@ class ProfileNotifier extends _$ProfileNotifier {
     required String did,
     required ReasonType reasonType,
     String? reason,
+    String? serviceDid,
   }) async {
     if (!authRepository.isAuthenticated) {
       logger.w('Cannot create report, user not authenticated');
@@ -313,6 +314,7 @@ class ProfileNotifier extends _$ProfileNotifier {
           reasonType: reasonType,
           reason: reason,
         ),
+        serviceDid: serviceDid,
       );
       logger.i('Report created successfully for $did');
       return result;
diff --git a/lib/src/features/profile/ui/pages/profile_page.dart b/lib/src/features/profile/ui/pages/profile_page.dart
index 03bbd82c..5778808a 100644
--- a/lib/src/features/profile/ui/pages/profile_page.dart
+++ b/lib/src/features/profile/ui/pages/profile_page.dart
@@ -17,6 +17,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 +59,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 +257,209 @@ 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),
-          ),
-          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();
+        return ModeratedContent(
+          labels: profile.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.profileView,
+          subjectDid: profile.did,
+          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(),
+            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 {
-                          await notifier.createReport(
-                            did: profile.did,
-                            reasonType: reasonType,
-                            reason: reason,
-                          );
-                        } catch (e) {
-                          _logger.e('Error creating report', error: e);
-                        }
-                      },
-                    ),
-                  ),
-                  onBlock: () async {
-                    final wasBlocked = isBlocking(profile.viewer);
-
-                    // Show confirmation dialog
-                    final confirmed = await showDialog<bool>(
+                    onReport: () => showDialog<void>(
                       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),
+                      useRootNavigator: false,
+                      builder: (dContext) => ReportDialog(
+                        accountDid: profile.did,
+                        fallbackServiceDid: widget.bsky
+                            ? _sprkRepository.bskyModDid
+                            : _sprkRepository.modDid,
+                        onSubmit:
+                            (subject, reasonType, reason, serviceDid) async {
+                              try {
+                                await notifier.createReport(
+                                  did: profile.did,
+                                  reasonType: reasonType,
+                                  reason: 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,
                             ),
-                            TextButton(
-                              onPressed: () => Navigator.of(context).pop(true),
-                              style: TextButton.styleFrom(
-                                foregroundColor: wasBlocked ? null : Colors.red,
+                            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: () {
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..7063089e 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,34 @@ 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(
+          labels: user.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.profileList,
+          subjectDid: user.did,
+          child: 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,
-                  handle: user.handle,
-                  displayName: user.displayName,
-                  avatar: user.avatar,
+                  initialProfile: ProfileViewBasic(
+                    did: user.did,
+                    handle: user.handle,
+                    displayName: user.displayName,
+                    avatar: user.avatar,
+                  ),
                 ),
               ),
             ),
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..99f8d26f 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,20 @@ 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()),
+          labels: post.labels ?? const [],
+          authorLabels: post.author.labels ?? const [],
+          target: ModerationTarget.content,
+          context: ModerationContext.contentList,
+          subjectDid: post.author.did,
+          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..835283e6 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,55 @@ 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(
+        labels: postView.labels ?? const [],
+        authorLabels: postView.author.labels ?? const [],
+        target: ModerationTarget.content,
+        context: ModerationContext.contentList,
+        subjectDid: postView.author.did,
+        compact: true,
+        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(
+      labels: postView.labels ?? const [],
+      authorLabels: postView.author.labels ?? const [],
+      target: ModerationTarget.content,
+      context: ModerationContext.contentList,
+      subjectDid: postView.author.did,
+      compact: true,
+      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..08dcb37a 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,49 @@ 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(
+          labels: user.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.profileList,
+          subjectDid: user.did,
+          child: 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,
-                  handle: user.handle,
-                  displayName: user.displayName,
-                  avatar: user.avatar,
+                  initialProfile: ProfileViewBasic(
+                    did: user.did,
+                    handle: user.handle,
+                    displayName: user.displayName,
+                    avatar: user.avatar,
+                  ),
                 ),
               ),
             ),
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..592718c0 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,25 @@ 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.FeedSearchPostsSort.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..27f4b352 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 {
@@ -122,8 +116,8 @@ class PostSearch extends _$PostSearch {
         return;
       }
 
-      final filteredSprkPosts = _filterHiddenPosts(response.sprk.posts);
-      final filteredBskyPosts = _filterHiddenPosts(response.bsky.posts);
+      final filteredSprkPosts = await _filterHiddenPosts(response.sprk.posts);
+      final filteredBskyPosts = await _filterHiddenPosts(response.bsky.posts);
 
       final combinedPosts = [...filteredSprkPosts, ...filteredBskyPosts];
 
@@ -196,7 +190,7 @@ class PostSearch extends _$PostSearch {
         return;
       }
 
-      final filteredPosts = _filterHiddenPosts(response.posts);
+      final filteredPosts = await _filterHiddenPosts(response.posts);
       state = state.copyWith(
         searchResults: [...state.searchResults, ...filteredPosts],
         sprkNextCursor: response.cursor,
@@ -221,7 +215,7 @@ class PostSearch extends _$PostSearch {
       }
 
       final initialCount = state.searchResults.length;
-      final filteredBskyPosts = _filterHiddenPosts(response.posts);
+      final filteredBskyPosts = await _filterHiddenPosts(response.posts);
       state = state.copyWith(
         searchResults: [...state.searchResults, ...filteredBskyPosts],
         bskyNextCursor: response.cursor,
@@ -236,19 +230,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
-    }
-
-    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 = ModerationDecision.merge([
+          engine.evaluate(
+            post.labels ?? const [],
+            target: ModerationTarget.content,
+            subjectDid: post.author.did,
+          ),
+          engine.evaluateProfileLabels(
+            post.author.labels ?? const [],
+            subjectDid: post.author.did,
+          ),
+        ]);
+        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/ui/pages/post_results.dart b/lib/src/features/search/ui/pages/post_results.dart
index 6146dca8..7b035fc6 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,24 @@ 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(
+                labels: post.labels ?? const [],
+                authorLabels: post.author.labels ?? const [],
+                target: ModerationTarget.content,
+                context: ModerationContext.contentList,
+                subjectDid: post.author.did,
+                compact: true,
+                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..acfeb25c 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,21 @@ 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(
+          labels: actor.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.profileList,
+          subjectDid: actor.did,
+          child: ListTile(
+            onTap: () => onSuggestionSelected(actor),
+            contentPadding: const EdgeInsets.symmetric(vertical: 4),
+            leading: 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..19bd4706 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,57 @@ 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(
+          labels: actor.labels ?? const [],
+          target: ModerationTarget.account,
+          context: ModerationContext.profileList,
+          subjectDid: actor.did,
+          child: 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,
-                      handle: actor.handle,
-                      displayName: actor.displayName,
-                      avatar: actor.avatar,
+                      initialProfile: ProfileViewBasic(
+                        did: actor.did,
+                        handle: actor.handle,
+                        displayName: actor.displayName,
+                        avatar: actor.avatar,
+                      ),
                     ),
-                  ),
-                );
-              }
-            },
+                  );
+                }
+              },
+            ),
           ),
         );
       },
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..b3371d83 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';
@@ -99,65 +101,74 @@ 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(
+                  labels: generatorView.labels ?? const [],
+                  authorLabels: generatorView.creator.labels ?? const [],
+                  target: ModerationTarget.content,
+                  context: ModerationContext.contentList,
+                  subjectDid: generatorView.creator.did,
+                  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/preferences_provider.dart b/lib/src/features/settings/providers/preferences_provider.dart
index 2006f3a4..f213b920 100644
--- a/lib/src/features/settings/providers/preferences_provider.dart
+++ b/lib/src/features/settings/providers/preferences_provider.dart
@@ -1,5 +1,6 @@
 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';
@@ -89,4 +90,45 @@ class UserPreferences extends _$UserPreferences {
     final updated = updater(current);
     await updatePreferences(updated);
   }
+
+  Future<void> setAdultContentEnabled(bool enabled) async {
+    await updatePreferencesWithFn((current) {
+      final retained = current.preferences.where((preference) {
+        final data = preference.unknown;
+        return data?[r'$type'] != 'so.sprk.actor.defs#adultContentPref';
+      });
+      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,
+          ),
+        ],
+      );
+    });
+  }
 }
diff --git a/lib/src/features/settings/providers/settings_provider.dart b/lib/src/features/settings/providers/settings_provider.dart
index d1479be5..b1105544 100644
--- a/lib/src/features/settings/providers/settings_provider.dart
+++ b/lib/src/features/settings/providers/settings_provider.dart
@@ -1,20 +1,20 @@
-import 'package:poptart/poptart.dart';
 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/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/pref_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/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/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';
 
@@ -96,6 +96,7 @@ class Settings extends _$Settings {
     await ref
         .read(userPreferencesProvider.notifier)
         .updatePreferences(preferences);
+    _configureLabelerHeaders(preferences);
   }
 
   Future<Preferences> _getCurrentPreferencesForFeedUpdate() async {
@@ -246,6 +247,7 @@ class Settings extends _$Settings {
 
       // Get preferences from the provider (waits for it to load if needed)
       final preferences = await _getPreferences();
+      _configureLabelerHeaders(preferences);
       final savedFeeds = _getSavedFeedsFromPreferences(preferences);
 
       // If there are no feeds, set default preferences
@@ -255,11 +257,29 @@ class Settings extends _$Settings {
           final defaultPrefs = DefaultPreferences.defaultPreferences(
             modServiceDid: modServiceDid,
           );
-          await _updatePreferences(defaultPrefs);
+          final mergedDefaults = Preferences(
+            preferences: [
+              ...preferences.preferences.where(
+                (preference) => !preference.isSavedFeedsPref,
+              ),
+              ...defaultPrefs.preferences.where((preference) {
+                if (preference.isSavedFeedsPref) return true;
+                if (preference.isLabelersPref) {
+                  return preferences.labelers == null;
+                }
+                if (preference.isContentLabelPref) {
+                  return preferences.contentLabelPrefs == null;
+                }
+                return false;
+              }),
+            ],
+          );
+          await _updatePreferences(mergedDefaults);
 
           // Get updated preferences from provider
           final updatedPreferences =
-              ref.read(userPreferencesProvider).asData?.value ?? defaultPrefs;
+              ref.read(userPreferencesProvider).asData?.value ?? mergedDefaults;
+          _configureLabelerHeaders(updatedPreferences);
           final updatedSavedFeeds = _getSavedFeedsFromPreferences(
             updatedPreferences,
           );
@@ -563,11 +583,13 @@ class Settings extends _$Settings {
         logger.d('Default mod service labeler not found, adding it');
         labelers = [modServiceDid, ...labelers];
 
+        sprkRepository.configureLabelers(labelers);
+        labelers = sprkRepository.labelerDids;
+
         // Update preferences to include default labeler
-        final updatedLabelers = <LabelerPrefItem>[
-          LabelerPrefItem(did: modServiceDid),
-          ...(preferences.labelers ?? []),
-        ];
+        final updatedLabelers = labelers
+            .map((did) => LabelerPrefItem(did: did))
+            .toList();
         final updatedPreferencesList =
             preferences.preferences
                 .where((pref) => !pref.isLabelersPref)
@@ -583,6 +605,9 @@ class Settings extends _$Settings {
       labelers = [modServiceDid, ...labelers];
     }
 
+    sprkRepository.configureLabelers(labelers);
+    labelers = sprkRepository.labelerDids;
+
     // Ensure all labelers' label values are set as preferences
     // Do this asynchronously to avoid blocking
     Future.microtask(() => _ensureAllLabelersPoliciesSet(labelers));
@@ -603,8 +628,9 @@ class Settings extends _$Settings {
 
     for (final did in uncheckedLabelers) {
       try {
-        await _fetchLabelerPoliciesAndSetDefaults(did);
-        _labelerPoliciesChecked.add(did);
+        if (await _fetchLabelerPoliciesAndSetDefaults(did)) {
+          _labelerPoliciesChecked.add(did);
+        }
       } catch (e) {
         logger.w('Error ensuring label values for labeler $did: $e');
       }
@@ -612,9 +638,10 @@ class Settings extends _$Settings {
   }
 
   /// Adds a labeler to the user's subscribed labelers list
-  Future<void> addLabeler(String did) async {
+  Future<void> addLabeler(String identifier) async {
     try {
-      logger.d('Adding labeler: $did');
+      logger.d('Adding labeler: $identifier');
+      final did = await sprkRepository.labeler.resolveIdentifier(identifier);
       final preferences = await _getPreferences();
       final currentLabelers = preferences.labelers ?? [];
 
@@ -624,6 +651,15 @@ class Settings extends _$Settings {
         return;
       }
 
+      if (currentLabelers.length >= AppViewLabelerHeaders.maxLabelers) {
+        throw StateError(
+          'Cannot subscribe to more than '
+          '${AppViewLabelerHeaders.maxLabelers} labelers',
+        );
+      }
+
+      await sprkRepository.labeler.validateService(did);
+
       // Create updated preferences with new labeler
       final updatedLabelers = [...currentLabelers, LabelerPrefItem(did: did)];
       final updatedPreferencesList =
@@ -636,8 +672,9 @@ class Settings extends _$Settings {
       logger.d('Labeler added successfully: $did');
 
       // Fetch and set default label preferences for this labeler
-      await _fetchLabelerPoliciesAndSetDefaults(did);
-      _labelerPoliciesChecked.add(did);
+      if (await _fetchLabelerPoliciesAndSetDefaults(did)) {
+        _labelerPoliciesChecked.add(did);
+      }
     } catch (e) {
       logger.e('Error adding labeler: $e');
       rethrow;
@@ -666,13 +703,16 @@ class Settings extends _$Settings {
           .toList();
 
       // Create updated preferences
-      final updatedPreferencesList =
-          preferences.preferences.where((pref) => !pref.isLabelersPref).toList()
-            ..add(labelersPreference(updatedLabelers));
+      final updatedPreferencesList = preferences.preferences.where((pref) {
+        if (pref.isLabelersPref) return false;
+        final contentLabelPref = pref.contentLabelPref;
+        return contentLabelPref?.labelerDid != did;
+      }).toList()..add(labelersPreference(updatedLabelers));
 
       await _updatePreferences(
         Preferences(preferences: updatedPreferencesList),
       );
+      _labelerPoliciesChecked.remove(did);
       logger.d('Labeler removed successfully: $did');
     } catch (e) {
       logger.e('Error removing labeler: $e');
@@ -690,8 +730,8 @@ class Settings extends _$Settings {
       // Refresh preferences from server first
       await ref.read(userPreferencesProvider.notifier).refresh();
 
-      final preferences = await _getPreferences();
-      final labelers =
+      var preferences = await _getPreferences();
+      var labelers =
           preferences.labelers?.map((labeler) => labeler.did).toList() ?? [];
 
       // Ensure default mod service labeler is present
@@ -699,18 +739,42 @@ class Settings extends _$Settings {
       _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),
-        );
+      }
+
+      sprkRepository.configureLabelers(labelers);
+      final normalizedLabelers = sprkRepository.labelerDids;
+      if (!_sameLabelers(labelers, normalizedLabelers) ||
+          !_sameLabelers(
+            preferences.labelers?.map((labeler) => labeler.did) ?? const [],
+            normalizedLabelers,
+          )) {
+        preferences = _withLabelers(preferences, normalizedLabelers);
+        await _updatePreferences(preferences);
+      }
+      labelers = normalizedLabelers.toList();
+
+      final availableLabelers = <String>[];
+      final unavailableLabelers = <String>{};
+      for (final did in labelers) {
+        if (did == modServiceDid) {
+          availableLabelers.add(did);
+          continue;
+        }
+        try {
+          await sprkRepository.labeler.validateService(did);
+          availableLabelers.add(did);
+        } on LabelerServiceUnavailableException catch (e) {
+          logger.w('Removing unavailable labeler $did: $e');
+          unavailableLabelers.add(did);
+        }
+      }
+
+      if (unavailableLabelers.isNotEmpty) {
+        preferences = _withLabelers(preferences, availableLabelers);
+        await _updatePreferences(preferences);
+        labelers
+          ..clear()
+          ..addAll(availableLabelers);
       }
 
       logger.d(
@@ -720,6 +784,8 @@ class Settings extends _$Settings {
       // Ensure all labelers' label values are set as preferences
       await _ensureAllLabelersPoliciesSet(labelers);
 
+      sprkRepository.configureLabelers(labelers);
+
       logger.d('Labelers synced successfully');
     } catch (e) {
       logger.e('Error syncing labelers: $e');
@@ -727,68 +793,8 @@ class Settings extends _$Settings {
     }
   }
 
-  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(
+  Future<Map<String, Setting>> getLabelSettingsForLabeler(
     String labelerDid,
   ) async {
     final preferences = await _getPreferences();
@@ -799,43 +805,28 @@ class Settings extends _$Settings {
       final contentLabelPref = pref.contentLabelPref;
       if (contentLabelPref != null &&
           contentLabelPref.labelerDid == labelerDid) {
-        contentLabelPrefsMap[contentLabelPref.label] =
-            contentLabelPref.visibilityValue;
+        contentLabelPrefsMap[contentLabelPref.label] = contentLabelPref
+            .visibility
+            .toJson();
       }
     }
 
     // Also check contentLabelPrefs property
-    final contentLabelPrefsFromProperty = preferences.contentLabelPrefs ?? [];
+    final contentLabelPrefsFromProperty =
+        preferences.contentLabelPrefs ?? const <ContentLabelPref>[];
     for (final pref in contentLabelPrefsFromProperty) {
       final prefLabelerDid = pref.labelerDid;
       final prefLabel = pref.label;
-      final prefVisibility = pref.visibilityValue;
+      final prefVisibility = pref.visibility.toJson();
       if (prefLabelerDid == labelerDid &&
           !contentLabelPrefsMap.containsKey(prefLabel)) {
         contentLabelPrefsMap[prefLabel] = prefVisibility;
       }
     }
 
-    final result = <String, LabelPreference>{};
+    final result = <String, Setting>{};
     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),
-      );
+      result[entry.key] = _visibilityToSetting(entry.value);
     }
     return result;
   }
@@ -844,9 +835,6 @@ class Settings extends _$Settings {
   Future<void> setLabelPreferenceForLabeler(
     String labelerDid,
     String value,
-    Blurs blurs,
-    Severity severity,
-    bool adultOnly,
     Setting setting,
   ) async {
     final preferences = await _getPreferences();
@@ -933,78 +921,16 @@ class Settings extends _$Settings {
     }
   }
 
-  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 {
+  Future<bool> _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 service = await sprkRepository.labeler.getServicesDetailed([did]);
+      final policiesJson = service.policies.toJson();
 
       final labelValuesJson = policiesJson['labelValues'] as List<dynamic>?;
       if (labelValuesJson == null || labelValuesJson.isEmpty) {
-        return;
+        return true;
       }
 
       final labelValues = labelValuesJson.map((v) => v as String).toList();
@@ -1029,7 +955,7 @@ class Settings extends _$Settings {
           .where((pref) => pref.isContentLabelPref)
           .toList();
       final existingContentPrefsFromProperty =
-          preferences.contentLabelPrefs ?? [];
+          preferences.contentLabelPrefs ?? const <ContentLabelPref>[];
 
       // Build a map of existing preferences by labelerDid:label
       final existingPrefsMap =
@@ -1038,20 +964,21 @@ class Settings extends _$Settings {
         final contentLabelPref = pref.contentLabelPref;
         if (contentLabelPref != null) {
           existingPrefsMap['${contentLabelPref.labelerDid}:'
-                  '${contentLabelPref.label}'] =
-              contentLabelPref.visibilityValue;
+              '${contentLabelPref.label}'] = contentLabelPref.visibility
+              .toJson();
         }
       }
       for (final pref in existingContentPrefsFromProperty) {
         final key = '${pref.labelerDid}:${pref.label}';
         if (!existingPrefsMap.containsKey(key)) {
-          existingPrefsMap[key] = pref.visibilityValue;
+          existingPrefsMap[key] = pref.visibility.toJson();
         }
       }
 
       final preferencesToAdd = <Preference>[];
 
       for (final labelValue in labelValues) {
+        if (globalAdultContentLabelValues.contains(labelValue)) continue;
         final key = '$did:$labelValue';
         final hasExistingPref = existingPrefsMap.containsKey(key);
 
@@ -1086,9 +1013,47 @@ class Settings extends _$Settings {
           Preferences(preferences: updatedPreferencesList),
         );
       }
+      return true;
     } catch (e) {
       logger.e('Error fetching labeler policies for $did: $e');
+      return false;
+    }
+  }
+
+  void _configureLabelerHeaders(Preferences preferences) {
+    sprkRepository.configureLabelers(
+      preferences.labelers?.map((labeler) => labeler.did) ?? const [],
+    );
+  }
+
+  Preferences _withLabelers(
+    Preferences preferences,
+    Iterable<String> labelers,
+  ) {
+    final normalizedLabelers = labelers.toList(growable: false);
+    final subscribed = normalizedLabelers.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 normalizedLabelers) 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;
   }
 
   /// Determines default visibility setting for a label value
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..71b31b2d 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,21 @@
-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:poptart_lex/com/atproto/label/defs.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/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/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/features/settings/providers/preferences_provider.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 {
@@ -35,7 +36,7 @@ class _LabelerLabelSettingsPageState
 
   ProfileViewDetailed? _labelerProfile;
   Map<String, LabelPreference> _labelPreferences = {};
-  Map<String, Map<String, dynamic>> _labelDefinitions = {};
+  Map<String, ModerationLabelDefinition> _labelDefinitions = {};
   bool _isLoading = true;
   String? _errorMessage;
 
@@ -75,94 +76,70 @@ class _LabelerLabelSettingsPageState
         _logger.w('Could not fetch labeler profile: $e');
       }
 
-      // 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 service = await _sprkRepository.labeler.getServicesDetailed([
+        widget.did,
+      ]);
+      final policiesJson = service.policies.toJson();
       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();
+      final labelValues = labelValuesJson.cast<String>();
 
-      // 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;
-          }
-        }
-      }
+      final definitions = ModerationLabelDefinitions.fromLabelers({
+        widget.did:
+            service.policies.labelValueDefinitions ??
+            const <LabelValueDefinition>[],
+      });
+      final labelDefinitionMap = <String, ModerationLabelDefinition>{
+        for (final labelValue in labelValues)
+          labelValue:
+              ?definitions.bySource[widget.did]?[labelValue] ??
+              definitions.global[labelValue],
+      };
 
       // Get existing preferences for this labeler
       final settings = ref.read(settingsProvider.notifier);
-      final existingPrefs = await settings.getLabelPreferencesForLabeler(
+      final existingSettings = await settings.getLabelSettingsForLabeler(
         widget.did,
       );
+      final globalSettings = <String, Setting>{
+        for (final preference
+            in (await ref.read(
+                  userPreferencesProvider.future,
+                )).contentLabelPrefs ??
+                const <ContentLabelPref>[])
+          if (preference.labelerDid == null)
+            preference.label: _visibilityToSetting(
+              preference.visibility.toJson(),
+            ),
+      };
       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 definition = labelDefinitionMap[labelValue];
+        final defaultSetting = definition == null
+            ? _visibilityToSetting(_getDefaultVisibilityForLabel(labelValue))
+            : Setting.fromValue(definition.defaultSetting.name);
+        final savedSetting = globalAdultContentLabelValues.contains(labelValue)
+            ? globalSettings[labelValue] ??
+                  existingSettings[labelValue] ??
+                  defaultSetting
+            : existingSettings[labelValue] ?? defaultSetting;
+        preferences[labelValue] = LabelPreference(
+          value: labelValue,
+          blurs: definition == null
+              ? _visibilityToBlurs(_getDefaultVisibilityForLabel(labelValue))
+              : Blurs.fromValue(definition.blurs.name),
+          severity: definition == null
+              ? _visibilityToSeverity(_getDefaultVisibilityForLabel(labelValue))
+              : Severity.fromValue(definition.severity.name),
+          defaultSetting: defaultSetting,
+          setting: savedSetting,
+          adultOnly: definition?.adultOnly ?? false,
+        );
       }
 
       setState(() {
@@ -241,40 +218,21 @@ class _LabelerLabelSettingsPageState
     }
   }
 
-  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 {
+  Future<void> _updateLabelPreference(String label, {Setting? setting}) async {
     try {
       final currentPref = _labelPreferences[label];
       if (currentPref != null) {
         final newSetting = setting ?? currentPref.setting;
-        final newBlurs = blurs ?? currentPref.blurs;
-        final newSeverity = severity ?? currentPref.severity;
 
         final settings = ref.read(settingsProvider.notifier);
         await settings.setLabelPreferenceForLabeler(
           widget.did,
           label,
-          newBlurs,
-          newSeverity,
-          currentPref.adultOnly,
           newSetting,
         );
 
         setState(() {
-          _labelPreferences[label] = currentPref.copyWith(
-            setting: newSetting,
-            blurs: newBlurs,
-            severity: newSeverity,
-          );
+          _labelPreferences[label] = currentPref.copyWith(setting: newSetting);
         });
       }
     } catch (e) {
@@ -287,6 +245,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(
@@ -502,28 +463,35 @@ class _LabelerLabelSettingsPageState
                   .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(
                       label: entry.key,
-                      preference: entry.value,
-                      onPreferenceUpdate: _updateLabelPreference,
-                      labelName: labelName,
-                      labelDescription: labelDescription,
-                      showSeverity: false,
+                      controlContext: entry.value.severity == Severity.inform
+                          ? LabelSettingTileContext.informLabel
+                          : LabelSettingTileContext.label,
+                      setting: ModerationSetting.values.byName(
+                        entry.value.setting.name,
+                      ),
+                      onChanged: (setting) => _updateLabelPreference(
+                        entry.key,
+                        setting: Setting.values.byName(setting.name),
+                      ),
+                      labelName: strings?.name,
+                      labelDescription: strings?.description,
+                      disabledMessage: configuredGlobally
+                          ? l10n.moderationConfiguredGlobally
+                          : null,
+                      enabled:
+                          !configuredGlobally &&
+                          (!entry.value.adultOnly || 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..e1406589 100644
--- a/lib/src/features/settings/ui/pages/labeler_management_page.dart
+++ b/lib/src/features/settings/ui/pages/labeler_management_page.dart
@@ -142,26 +142,18 @@ 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 settings.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();
     }
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..a3a0a8f9
--- /dev/null
+++ b/lib/src/features/settings/ui/pages/moderation_page.dart
@@ -0,0 +1,195 @@
+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/features/settings/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'];
+
+  Future<void> _setAdultContentEnabled(bool enabled) async {
+    final l10n = AppLocalizations.of(context);
+    final logger = GetIt.instance<LogService>().getLogger('ModerationPage');
+
+    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)));
+    }
+  }
+
+  Future<void> _setGlobalLabelPreference(
+    String label,
+    ModerationSetting setting,
+  ) async {
+    final l10n = AppLocalizations.of(context);
+    final logger = GetIt.instance<LogService>().getLogger('ModerationPage');
+
+    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)));
+    }
+  }
+
+  @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
+                        ? 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,
+                            ),
+                            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..341a8dcc 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,16 @@ class SettingsFeedCard extends ConsumerWidget {
           ? (liked) => _setLiked(context, ref, liked: liked)
           : null,
     );
+    final generator = _generator;
+    if (generator == null) return card;
+    return ModeratedContent(
+      labels: generator.labels ?? const [],
+      authorLabels: generator.creator.labels ?? const [],
+      target: ModerationTarget.content,
+      context: ModerationContext.contentList,
+      subjectDid: generator.creator.did,
+      child: card,
+    );
   }
 }
 
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..9692b9a6 100644
--- a/lib/src/features/stories/ui/pages/author_stories_page.dart
+++ b/lib/src/features/stories/ui/pages/author_stories_page.dart
@@ -289,6 +289,7 @@ class _AuthorStoriesPageState extends ConsumerState<AuthorStoriesPage>
                       final story = widget.stories[index];
                       return StoryPage(
                         story: story,
+                        isActive: index == _currentStoryIndex,
                         onLoadingStateChanged: (isLoading) =>
                             _onStoryLoadingStateChanged(index, isLoading),
                         onStoryDurationChanged: (duration) =>
diff --git a/lib/src/features/stories/ui/pages/story_page.dart b/lib/src/features/stories/ui/pages/story_page.dart
index 392d3022..dea862cd 100644
--- a/lib/src/features/stories/ui/pages/story_page.dart
+++ b/lib/src/features/stories/ui/pages/story_page.dart
@@ -5,6 +5,9 @@ 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: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/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';
@@ -14,6 +17,7 @@ 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,
@@ -24,6 +28,7 @@ class StoryPage extends ConsumerStatefulWidget {
   });
 
   final StoryView story;
+  final bool isActive;
   final ValueChanged<bool>? onLoadingStateChanged;
   final ValueChanged<Duration>? onStoryDurationChanged;
   final VoidCallback? onPauseRequested;
@@ -42,6 +47,7 @@ class _StoryPageState extends ConsumerState<StoryPage>
   bool _isVideoInitialized = false;
   bool _isImageLoaded = false;
   bool _isLoading = true;
+  bool? _moderationConcealed;
 
   @override
   void initState() {
@@ -62,6 +68,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 +120,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;
@@ -244,88 +260,107 @@ 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,
-          );
-
-          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(),
+    final selfLabels = widget.story.localRecord?.selfLabels ?? const [];
+    final labels = [
+      for (final selfLabel in selfLabels)
+        Label(
+          src: widget.story.author.did,
+          uri: widget.story.uri.toString(),
+          val: selfLabel.val,
+          cts: widget.story.indexedAt,
+        ),
+    ];
+
+    // Story labels are stored on the record rather than StoryView itself.
+    return ModeratedContent(
+      labels: labels,
+      authorLabels: widget.story.author.labels ?? const [],
+      target: ModerationTarget.content,
+      context: ModerationContext.contentView,
+      subjectDid: widget.story.author.did,
+      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 +442,19 @@ class _StoryPageState extends ConsumerState<StoryPage>
     final frame = placement.frame;
     return frame.w > 0 && frame.h > 0;
   }
+
+  void _onModerationConcealChanged(bool concealed) {
+    _moderationConcealed = 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..183cdae2 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,27 @@ 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(
+                    labels: author.labels ?? const [],
+                    target: ModerationTarget.account,
+                    context: ModerationContext.profileList,
+                    subjectDid: author.did,
+                    compact: true,
+                    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() ?? '',
                         ),
-                      );
-                    },
-                    child: Padding(
-                      padding: const EdgeInsets.only(right: 12),
-                      child: StoryCircle.story(
-                        userName: author.displayName ?? author.handle,
-                        imageUrl: author.avatar?.toString() ?? '',
                       ),
                     ),
                   );
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/moderation/moderated_content_test.dart b/test/src/core/moderation/moderated_content_test.dart
new file mode 100644
index 00000000..9b559ff2
--- /dev/null
+++ b/test/src/core/moderation/moderated_content_test.dart
@@ -0,0 +1,389 @@
+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(
+            labels: [_label('sexual')],
+            target: ModerationTarget.content,
+            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(
+            labels: [_label('sexual')],
+            target: ModerationTarget.content,
+            context: ModerationContext.contentView,
+            compact: true,
+            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(
+            labels: [_label('sexual')],
+            target: ModerationTarget.content,
+            context: ModerationContext.contentView,
+            compact: true,
+            blurredChild: const 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(
+            labels: [_label('sexual')],
+            target: ModerationTarget.content,
+            context: ModerationContext.contentList,
+            compact: true,
+            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(
+                  labels: labels,
+                  target: ModerationTarget.content,
+                  context: ModerationContext.contentView,
+                  subjectDid: 'did:plc:author',
+                  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))
+          .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('built-in label details use app-localized guidance', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      _app(
+        _engine(),
+        ModeratedContent(
+          labels: [_label('gore')],
+          target: ModerationTarget.content,
+          context: ModerationContext.contentView,
+          subjectDid: 'did:plc:author',
+          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('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(
+          labels: [_label('context', source: 'did:plc:labeler')],
+          target: ModerationTarget.content,
+          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(
+          labels: [_label('!hide', source: 'did:plc:labeler')],
+          target: ModerationTarget.content,
+          context: ModerationContext.contentView,
+          subjectDid: 'did:plc:author',
+          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(
+            labels: [_label('sexual')],
+            target: ModerationTarget.content,
+            context: ModerationContext.contentView,
+            subjectDid: 'did:plc:author',
+            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,
+  Map<String, Iterable<LabelValueDefinition>> definitions = const {},
+}) {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers(definitions),
+    preferences: ModerationPreferences(
+      labels: const [],
+      adultContentEnabled: adultContentEnabled,
+      authenticated: true,
+    ),
+  );
+}
+
+Label _label(String value, {String source = 'did:plc:author'}) {
+  return Label(
+    src: source,
+    uri: 'at://did:plc:author/so.sprk.feed.post/example',
+    val: value,
+    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..02bdefea
--- /dev/null
+++ b/test/src/core/moderation/moderation_engine_test.dart
@@ -0,0 +1,659 @@
+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('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(
+      '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, isTrue);
+      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('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,
+}) {
+  return ModerationEngine(
+    definitions: ModerationLabelDefinitions.fromLabelers(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_preferences_test.dart b/test/src/core/moderation/moderation_preferences_test.dart
new file mode 100644
index 00000000..1b515d90
--- /dev/null
+++ b/test/src/core/moderation/moderation_preferences_test.dart
@@ -0,0 +1,215 @@
+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('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'}) {
+  return ModerationLabelDefinition(
+    identifier: identifier,
+    definedBy: 'did:plc:alpha',
+    severity: ModerationSeverity.none,
+    blurs: ModerationBlur.none,
+    defaultSetting: ModerationSetting.warn,
+    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..fbe4af93
--- /dev/null
+++ b/test/src/core/moderation/moderation_provider_test.dart
@@ -0,0 +1,94 @@
+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/auth/data/repositories/auth_repository.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';
+
+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);
+  });
+}
+
+class _FakePrefRepository implements PrefRepository {
+  @override
+  Future<Preferences> getPreferences() async => Preferences(preferences: []);
+
+  @override
+  Future<void> putPreferences(Preferences preferences) async {}
+}
+
+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
+  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 _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..3ce8c26c 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);
@@ -181,6 +175,29 @@ void main() {
         '/xrpc/so.sprk.feed.getFeed',
       );
     });
+
+    test(
+      'getLabels falls back to configured labelers when sources are null',
+      () async {
+        final harness = RepositoryHarness(
+          getResponse: const <String, dynamic>{'labels': <dynamic>[]},
+        );
+        harness.sprk.configureLabelers(const ['did:plc:one', 'did:plc:two']);
+        final uri = AtUri('at://did:plc:author/so.sprk.feed.post/post');
+
+        final result = await repository(harness).getLabels([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);
+      },
+    );
   });
 }
 
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..9427d87e 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
@@ -34,6 +34,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 +62,64 @@ void main() {
       expect(service.policies.labelValues, isEmpty);
     });
 
+    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>[]});
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..005a65f4 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
@@ -85,6 +85,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..6dfce3a9 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
@@ -189,6 +189,7 @@ class FakeSprkRepository implements SprkRepository {
   static const testBskyDid = 'did:web:bsky.test#bsky_appview';
 
   final FakeAuthRepository auth;
+  List<String> _labelerDids = ['did:web:mod.sprk.test'];
 
   @override
   final RepoRepository repo;
@@ -208,6 +209,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();
 
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..63260632 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
@@ -26,6 +26,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,6 +45,10 @@ 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('listStoryRecords owns record paging parameters', () async {
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/core/ui/widgets/report_dialog_test.dart b/test/src/core/ui/widgets/report_dialog_test.dart
new file mode 100644
index 00000000..43a2f8e6
--- /dev/null
+++ b/test/src/core/ui/widgets/report_dialog_test.dart
@@ -0,0 +1,171 @@
+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/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(
+      const ProviderScope(
+        child: MaterialApp(
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(
+            body: ReportDialog(
+              postUri: 'at://did:plc:author/so.sprk.feed.post/example',
+              postCid: '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(
+              accountDid: '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);
+  });
+}
+
+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);
+
+  final Map<String, LabelerViewDetailed> services;
+
+  @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..2d2cce07 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,120 @@ 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 clears a cached label without duplicating the post',
+    () async {
+      final original = _post(
+        'updated-label',
+        labels: [
+          Label(
+            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(
+            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)),
+          ),
+        ],
+      );
+      feedRepository
+        ..enqueue(_page([original], cursor: 'next'))
+        ..enqueue(_page([retracted]));
+      final container = createContainer();
+      final notifier = readNotifier(container);
+
+      await notifier.loadAndUpdateFirstLoad();
+      await notifier.scrollDown();
+
+      final state = container.read(feedProvider(feed));
+      expect(state.loadedPosts, hasLength(1));
+      expect(state.loadedPosts.single.labels, isEmpty);
+      expect(state.extraInfo[original.uri]!.postLabels, isEmpty);
+    },
+  );
+
+  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 not cached or attached to posts', () async {
+    final post = _post(
+      'expired-label',
+      labels: [
+        Label(
+          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)),
+        ),
+      ],
+    );
+    feedRepository.enqueue(_page([post]));
+    final container = createContainer();
+    final notifier = readNotifier(container);
+
+    await notifier.loadAndUpdateFirstLoad();
+
+    final state = container.read(feedProvider(feed));
+    expect(state.loadedPosts.single.labels, isEmpty);
+    expect(state.extraInfo[post.uri]!.postLabels, isEmpty);
+  });
+
   test('an empty network page ends the feed', () async {
     feedRepository.enqueue(_page(const []));
     final container = createContainer();
@@ -289,27 +407,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 +510,38 @@ 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,
+            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..b0290b31
--- /dev/null
+++ b/test/src/features/feed/providers/visible_pinned_feeds_provider_test.dart
@@ -0,0 +1,160 @@
+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);
+
+    expect(container.read(visiblePinnedFeedsProvider), [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);
+
+    expect(container.read(visiblePinnedFeedsProvider), [
+      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',
+        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/posting/providers/video_upload_provider_test.dart b/test/src/features/posting/providers/video_upload_provider_test.dart
index f0ba5c2d..40d72cbd 100644
--- a/test/src/features/posting/providers/video_upload_provider_test.dart
+++ b/test/src/features/posting/providers/video_upload_provider_test.dart
@@ -82,12 +82,14 @@ void main() {
         uploadResult: upload,
         storyMode: true,
         storyEmbeds: [embed],
+        selfLabels: const [SelfLabel(val: 'nudity')],
       );
 
       expect(result, storyRepository.result);
       expect(soundRepository.createdBlobs, [upload.audioBlob]);
       expect(storyRepository.soundRef, createdSound);
       expect(storyRepository.embeds, [embed]);
+      expect(storyRepository.selfLabels, const [SelfLabel(val: 'nudity')]);
       expect(storyRepository.media, isA<MediaVideo>());
       expect((storyRepository.media! as MediaVideo).video, upload.videoBlob);
       expect(repoRepository.createCalls, isEmpty);
@@ -120,6 +122,10 @@ void main() {
       altText: 'a short clip',
       aspectRatio: const MediaAspectRatio(width: 9, height: 16),
       soundRef: sound,
+      selfLabels: const [
+        SelfLabel(val: 'sexual'),
+        SelfLabel(val: 'graphic-media'),
+      ],
     );
 
     expect(result, repoRepository.sparkResult);
@@ -134,6 +140,10 @@ void main() {
       'height': 16,
     });
     expect(call.record['sound'], sound.toJson());
+    expect(call.record['labels']['values'], [
+      {r'$type': 'com.atproto.label.defs#selfLabel', 'val': 'sexual'},
+      {r'$type': 'com.atproto.label.defs#selfLabel', 'val': 'graphic-media'},
+    ]);
     expect(repoRepository.editCalls, isEmpty);
   });
 
@@ -146,6 +156,7 @@ void main() {
         uploadResult: upload,
         description: 'crosspost me',
         crosspostToBsky: true,
+        selfLabels: const [SelfLabel(val: 'porn')],
       );
 
       expect(result, repoRepository.editedResult);
@@ -154,6 +165,9 @@ void main() {
         'app.bsky.feed.post',
       ]);
       expect(repoRepository.createCalls.last.rkey, 'spark-rkey');
+      expect(repoRepository.createCalls.last.record['labels']['values'], [
+        {r'$type': 'com.atproto.label.defs#selfLabel', 'val': 'porn'},
+      ]);
       expect(repoRepository.editCalls, hasLength(1));
       expect(
         repoRepository.editCalls.single.uri,
@@ -233,6 +247,7 @@ class _FakeStoryRepository implements StoryRepository {
   Media? media;
   RepoStrongRef? soundRef;
   List<StoryEmbed>? embeds;
+  List<SelfLabel>? selfLabels;
 
   @override
   Future<RepoStrongRef> postStory(
@@ -245,6 +260,7 @@ class _FakeStoryRepository implements StoryRepository {
     this.media = media;
     this.soundRef = soundRef;
     this.embeds = embeds;
+    this.selfLabels = selfLabels;
     return result;
   }
 
diff --git a/test/src/features/posting/ui/widgets/content_warning_selector_test.dart b/test/src/features/posting/ui/widgets/content_warning_selector_test.dart
new file mode 100644
index 00000000..e7dbe98d
--- /dev/null
+++ b/test/src/features/posting/ui/widgets/content_warning_selector_test.dart
@@ -0,0 +1,74 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spark/src/core/l10n/app_localizations.dart';
+import 'package:spark/src/features/posting/models/content_warning_selection.dart';
+import 'package:spark/src/features/posting/ui/widgets/content_warning_selector.dart';
+
+void main() {
+  testWidgets('adult warning is exclusive and graphic media is independent', (
+    tester,
+  ) async {
+    final key = GlobalKey<_HostState>();
+    await tester.pumpWidget(_app(_Host(key: key)));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byKey(const Key('content-warning-sexual')));
+    await tester.pump();
+    await tester.tap(find.byKey(const Key('content-warning-graphic-media')));
+    await tester.pump();
+
+    expect(key.currentState!.selection.values, ['sexual', 'graphic-media']);
+
+    await tester.tap(find.byKey(const Key('content-warning-nudity')));
+    await tester.pump();
+
+    expect(key.currentState!.selection.values, ['nudity', 'graphic-media']);
+    expect(find.text('For example, artistic nudes.'), findsOneWidget);
+  });
+
+  testWidgets('selected adult warning can be cleared', (tester) async {
+    final key = GlobalKey<_HostState>();
+    await tester.pumpWidget(_app(_Host(key: key)));
+    await tester.pumpAndSettle();
+
+    final suggestive = find.byKey(const Key('content-warning-sexual'));
+    await tester.tap(suggestive);
+    await tester.pump();
+    await tester.tap(suggestive);
+    await tester.pump();
+
+    expect(key.currentState!.selection.values, isEmpty);
+  });
+}
+
+Widget _app(Widget child) {
+  return ProviderScope(
+    child: MaterialApp(
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      home: Scaffold(body: child),
+    ),
+  );
+}
+
+class _Host extends StatefulWidget {
+  const _Host({super.key});
+
+  @override
+  State<_Host> createState() => _HostState();
+}
+
+class _HostState extends State<_Host> {
+  ContentWarningSelection selection = const ContentWarningSelection();
+
+  @override
+  Widget build(BuildContext context) {
+    return SingleChildScrollView(
+      child: ContentWarningSelector(
+        value: selection,
+        onChanged: (value) => setState(() => selection = value),
+      ),
+    );
+  }
+}
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..d6dda09c 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,34 @@ 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',
+                  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 +101,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);
@@ -204,12 +233,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 +254,14 @@ 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,
+);
+
 InitialPostSearchResult _initial(List<PostView> posts) =>
     (sprk: (posts: posts, cursor: null), bsky: (posts: const [], cursor: null));
diff --git a/test/src/features/settings/providers/preferences_provider_test.dart b/test/src/features/settings/providers/preferences_provider_test.dart
index bca6f901..1efd9dee 100644
--- a/test/src/features/settings/providers/preferences_provider_test.dart
+++ b/test/src/features/settings/providers/preferences_provider_test.dart
@@ -6,6 +6,7 @@ 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';
@@ -115,6 +116,84 @@ void main() {
     expect(container.read(userPreferencesProvider).value, updated);
   });
 
+  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.unknown?[r'$type'] ==
+              'so.sprk.actor.defs#adultContentPref',
+        ),
+        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 {
     final initial = _preferences('initial');
     prefRepository.getResult = initial;
@@ -220,6 +299,18 @@ class _FakeSprkRepository implements SprkRepository {
   @override
   final AuthRepository authRepository;
 
+  @override
+  List<String> get labelerDids => const [];
+
+  @override
+  void configureLabelers(Iterable<String> labelerDids) {}
+
+  @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/features/settings/providers/settings_provider_test.dart b/test/src/features/settings/providers/settings_provider_test.dart
index 69148513..75be2423 100644
--- a/test/src/features/settings/providers/settings_provider_test.dart
+++ b/test/src/features/settings/providers/settings_provider_test.dart
@@ -11,6 +11,7 @@ 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';
@@ -20,6 +21,7 @@ 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 +34,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());
   });
@@ -329,140 +330,225 @@ 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);
 
-      final preference = await notifier.getLabelPreference('nsfl');
+      await notifier.setLabelPreferenceForLabeler(
+        'did:plc:a',
+        'custom',
+        Setting.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 notifier.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 notifier.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(
+          notifier.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();
+      final notifier = await loadSettings(container);
+
+      await notifier.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();
+      final notifier = await loadSettings(container);
+
+      await expectLater(
+        notifier.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();
+      final notifier = await loadSettings(container);
+
+      await expectLater(
+        notifier.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 notifier.setLabelPreferenceForLabeler(
-        'did:plc:a',
-        'custom',
-        Blurs.content,
-        Severity.alert,
-        false,
-        Setting.hide,
-      );
+      await notifier.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 notifier.addLabeler('did:plc:other');
-        expect(
-          preferencesController.current.labelers?.map((item) => item.did),
-          ['did:plc:mod', 'did:plc:other'],
-        );
+        await notifier.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));
       },
     );
   });
@@ -548,12 +634,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 +680,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..7f003b5a
--- /dev/null
+++ b/test/src/features/settings/ui/pages/labeler_label_settings_page_test.dart
@@ -0,0 +1,186 @@
+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/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/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/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/features/settings/providers/preferences_provider.dart';
+import 'package:spark/src/features/settings/providers/settings_provider.dart';
+import 'package:spark/src/features/settings/providers/settings_state.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);
+  });
+}
+
+Future<void> _pumpPage(WidgetTester tester, String labelerDid) async {
+  await tester.pumpWidget(
+    ProviderScope(
+      overrides: [
+        settingsProvider.overrideWith(_FakeSettings.new),
+        userPreferencesProvider.overrideWith(_FakePreferences.new),
+      ],
+      child: MaterialApp(
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: LabelerLabelSettingsPage(did: labelerDid),
+      ),
+    ),
+  );
+  await tester.pumpAndSettle();
+}
+
+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),
+);
+
+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 _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 _FakeSettings extends Settings {
+  @override
+  SettingsState build() => SettingsState(
+    activeFeed: Feed(
+      type: 'timeline',
+      config: makeSavedFeed(
+        id: 'following',
+        type: 'timeline',
+        value: 'following',
+        pinned: true,
+      ),
+    ),
+  );
+
+  @override
+  Future<Map<String, Setting>> getLabelSettingsForLabeler(
+    String labelerDid,
+  ) async => const {};
+}
+
+class _FakePreferences extends UserPreferences {
+  @override
+  Future<Preferences> build() async => Preferences(preferences: []);
+}
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..51a3baf3
--- /dev/null
+++ b/test/src/features/settings/ui/pages/moderation_page_test.dart
@@ -0,0 +1,166 @@
+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/features/settings/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.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);
+    }
+  });
+}
+
+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;
+  }
+}
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/stories/ui/pages/story_page_test.dart b/test/src/features/stories/ui/pages/story_page_test.dart
new file mode 100644
index 00000000..dbc350d6
--- /dev/null
+++ b/test/src/features/stories/ui/pages/story_page_test.dart
@@ -0,0 +1,94 @@
+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/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', labeled: 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);
+  });
+}
+
+StoryView _story(String id, {bool labeled = false}) {
+  final author = ProfileViewBasic(
+    did: 'did:plc:author',
+    handle: 'author.sprk.so',
+    avatar: 'https://example.com/avatar.jpg',
+    labels: labeled
+        ? [
+            Label(
+              src: 'did:plc:moderator',
+              uri: 'did:plc:author',
+              val: 'sexual',
+              cts: DateTime.utc(2026, 8, 12),
+            ),
+          ]
+        : null,
+  );
+  return 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),
+  );
+}
+
+ModerationEngine _engine() => ModerationEngine(
+  definitions: ModerationLabelDefinitions(),
+  preferences: ModerationPreferences(
+    labels: const [],
+    adultContentEnabled: true,
+    authenticated: true,
+  ),
+);