feat: send DM notifications when tracks are copyright flagged

- add send_copyright_notification() to NotificationService
- DM both the artist (uploader) and admin when a track is flagged
- add notified_at field to CopyrightScan model to track notification status
- artist message explains the flag and invites dispute
- admin message includes match details and track link

related to #702

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

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

backend/alembic/versions/2026_01_02_140513_15472c0b3bb4_add_notified_at_to_copyright_scans.py

···
+"""add notified_at to copyright_scans
+
+Revision ID: 15472c0b3bb4
+Revises: 9ee155c078ed
+Create Date: 2026-01-02 14:05:13.306570
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "15472c0b3bb4"
+down_revision: str | Sequence[str] | None = "9ee155c078ed"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.add_column(
+        "copyright_scans",
+        sa.Column("notified_at", sa.DateTime(timezone=True), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    op.drop_column("copyright_scans", "notified_at")

backend/src/backend/_internal/moderation.py

···
 """moderation service integration for copyright scanning."""
 
 import logging
+from datetime import UTC, datetime
 from typing import Any
 
 import logfire
+from sqlalchemy import select
+from sqlalchemy.orm import joinedload
 
 from backend._internal.moderation_client import get_moderation_client
+from backend._internal.notifications import notification_service
 from backend.config import settings
-from backend.models import CopyrightScan
+from backend.models import CopyrightScan, Track
 from backend.utilities.database import db_session
 
 logger = logging.getLogger(__name__)
···
             match_count=len(scan.matches),
         )
 
-        # auto-label emission removed - see https://github.com/zzstoatzz/plyr.fm/issues/702
-        # labels will be emitted after user notification + grace period (future work)
+        # send notification if flagged (see #702)
+        if result.is_flagged:
+            track = await db.scalar(
+                select(Track)
+                .options(joinedload(Track.artist))
+                .where(Track.id == track_id)
+            )
+            if track and track.artist:
+                notified = await notification_service.send_copyright_notification(
+                    track_id=track_id,
+                    track_title=track.title,
+                    artist_did=track.artist_did,
+                    artist_handle=track.artist.handle,
+                    highest_score=scan.highest_score,
+                    matches=scan.matches,
+                )
+                if notified:
+                    scan.notified_at = datetime.now(UTC)
+                    await db.commit()
 
 
 async def _emit_copyright_label(

backend/src/backend/_internal/notifications.py

···
             self.dm_client = None
             self.recipient_did = None
 
+    async def _send_dm_to_did(self, recipient_did: str, message_text: str) -> bool:
+        """send a DM to a specific DID.
+
+        returns True if sent successfully, False otherwise.
+        """
+        if not self.dm_client:
+            logger.warning("dm client not authenticated, skipping notification")
+            return False
+
+        try:
+            dm = self.dm_client.chat.bsky.convo
+
+            convo_response = await dm.get_convo_for_members(
+                models.ChatBskyConvoGetConvoForMembers.Params(members=[recipient_did])
+            )
+
+            if not convo_response.convo or not convo_response.convo.id:
+                raise ValueError("failed to get conversation ID")
+
+            await dm.send_message(
+                models.ChatBskyConvoSendMessage.Data(
+                    convo_id=convo_response.convo.id,
+                    message=models.ChatBskyConvoDefs.MessageInput(text=message_text),
+                )
+            )
+            return True
+
+        except Exception:
+            logger.exception(f"error sending DM to {recipient_did}")
+            return False
+
+    async def send_copyright_notification(
+        self,
+        track_id: int,
+        track_title: str,
+        artist_did: str,
+        artist_handle: str,
+        highest_score: int,
+        matches: list[dict],
+    ) -> bool:
+        """send notification about a copyright flag to both artist and admin.
+
+        returns True if at least one notification was sent successfully.
+        """
+        if not self.dm_client:
+            logger.warning("dm client not authenticated, skipping notification")
+            return False
+
+        # format match info
+        match_count = len(matches)
+        primary_match = None
+        if matches:
+            m = matches[0]
+            primary_match = (
+                f"{m.get('title', 'Unknown')} by {m.get('artist', 'Unknown')}"
+            )
+
+        # build track URL if available
+        track_url = None
+        frontend_url = settings.frontend.url
+        if frontend_url and "localhost" not in frontend_url:
+            track_url = f"{frontend_url}/track/{track_id}"
+
+        # message for the artist (uploader)
+        artist_message = (
+            f"⚠️ copyright notice for your track on {settings.app.name}\n\n"
+            f"track: '{track_title}'\n"
+            f"match confidence: {highest_score}%\n"
+        )
+        if primary_match:
+            artist_message += f"potential match: {primary_match}\n"
+        artist_message += (
+            "\nif you believe this is an error, please reply to this message. "
+            "otherwise, the track may be removed after review."
+        )
+
+        # message for admin
+        admin_message = (
+            f"🚨 copyright flag on {settings.app.name}\n\n"
+            f"track: '{track_title}'\n"
+            f"artist: @{artist_handle}\n"
+            f"score: {highest_score}%\n"
+            f"matches: {match_count}\n"
+        )
+        if primary_match:
+            admin_message += f"primary: {primary_match}\n"
+        if track_url:
+            admin_message += f"\n{track_url}"
+
+        # send to both
+        artist_sent = await self._send_dm_to_did(artist_did, artist_message)
+        admin_sent = False
+        if self.recipient_did:
+            admin_sent = await self._send_dm_to_did(self.recipient_did, admin_message)
+
+        if artist_sent:
+            logger.info(f"sent copyright notification to artist {artist_handle}")
+        if admin_sent:
+            logger.info(f"sent copyright notification to admin for track {track_id}")
+
+        return artist_sent or admin_sent
+
     async def send_image_flag_notification(
         self,
         image_id: str,

backend/src/backend/models/copyright_scan.py

···
         server_default="{}",
     )
 
+    # notification tracking
+    notified_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True),
+        nullable=True,
+        default=None,
+    )
+
     __table_args__ = (
         Index("idx_copyright_scans_flagged", "is_flagged"),
         Index("idx_copyright_scans_scanned_at", "scanned_at"),