feat: copyright moderation improvements (#480)

* fix: sync copyright flag resolution from labeler to portal

when an admin marks a track as "false positive" in the moderation UI,
the flag now correctly clears from the user's portal. previously the
backend's copyright_scans table was never updated, leaving stale flags.

the fix uses an idempotent approach - the backend now queries the
labeler for the source of truth rather than requiring a sync/backfill:

moderation service:
- add POST /admin/active-labels endpoint
- returns which URIs have active (non-negated) copyright-violation labels

backend:
- add get_active_copyright_labels() to query the labeler
- update get_copyright_info() to check labeler for pending flags
- lazily update resolution field when labeler confirms resolution
- skip labeler call for already-resolved scans (optimization)

behavior:
- existing resolved flags immediately take effect (no backfill needed)
- fails closed: if labeler unreachable, flags remain visible (safe default)
- lazy DB update reduces future labeler calls for same track

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

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

* feat: add copyright attestation checkbox to upload flow

users must now confirm they have distribution rights before uploading.
includes educational copy about "publicly available ≠ licensed" to reduce
good-faith mistakes (per tigers blood incident retrospective).

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

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

---------

Co-authored-by: Claude <[e-mail]>

backend/src/backend/_internal/moderation.py

···
         logger.warning("failed to emit copyright label for %s: %s", uri, e)
 
 
+async def get_active_copyright_labels(uris: list[str]) -> set[str]:
+    """check which URIs have active (non-negated) copyright-violation labels.
+
+    queries the moderation service's labeler to determine which tracks are
+    still actively flagged. this is the source of truth for flag status.
+
+    args:
+        uris: list of AT URIs to check
+
+    returns:
+        set of URIs that are still actively flagged
+
+    note:
+        fails closed (returns all URIs as active) if moderation service is unreachable
+        to avoid accidentally hiding real violations.
+    """
+    if not uris:
+        return set()
+
+    if not settings.moderation.enabled:
+        logger.debug("moderation disabled, treating all as active")
+        return set(uris)
+
+    if not settings.moderation.auth_token:
+        logger.warning("MODERATION_AUTH_TOKEN not set, treating all as active")
+        return set(uris)
+
+    try:
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(settings.moderation.timeout_seconds)
+        ) as client:
+            response = await client.post(
+                f"{settings.moderation.labeler_url}/admin/active-labels",
+                json={"uris": uris},
+                headers={"X-Moderation-Key": settings.moderation.auth_token},
+            )
+            response.raise_for_status()
+            data = response.json()
+            active = set(data.get("active_uris", []))
+            logfire.debug(
+                "checked active copyright labels",
+                total_uris=len(uris),
+                active_count=len(active),
+            )
+            return active
+    except Exception as e:
+        # fail closed: if we can't confirm resolution, treat as active
+        logger.warning("failed to check active labels, treating all as active: %s", e)
+        return set(uris)
+
+
 async def _store_scan_error(track_id: int, error: str) -> None:
     """store a scan error as a clear result.
 

backend/src/backend/utilities/aggregations.py

···
 """aggregation utilities for efficient batch counting."""
 
+import logging
 from collections import Counter
 from dataclasses import dataclass
+from datetime import UTC, datetime
 from typing import Any
 
-from sqlalchemy import select
+from sqlalchemy import select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.sql import func
 
-from backend.models import CopyrightScan, Tag, TrackComment, TrackLike, TrackTag
+from backend.models import CopyrightScan, Tag, Track, TrackComment, TrackLike, TrackTag
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
···
 ) -> dict[int, CopyrightInfo]:
     """get copyright scan info for multiple tracks in a single query.
 
+    checks the moderation service's labeler for the true resolution status.
+    if a track was resolved (negation label exists), treats it as not flagged
+    and lazily updates the backend's resolution field.
+
     args:
         db: database session
         track_ids: list of track IDs to get info for
···
     if not track_ids:
         return {}
 
-    stmt = select(
-        CopyrightScan.track_id, CopyrightScan.is_flagged, CopyrightScan.matches
-    ).where(CopyrightScan.track_id.in_(track_ids))
+    # get scans with track AT URIs for labeler lookup
+    stmt = (
+        select(
+            CopyrightScan.id,
+            CopyrightScan.track_id,
+            CopyrightScan.is_flagged,
+            CopyrightScan.matches,
+            CopyrightScan.resolution,
+            Track.atproto_record_uri,
+        )
+        .join(Track, CopyrightScan.track_id == Track.id)
+        .where(CopyrightScan.track_id.in_(track_ids))
+    )
 
     result = await db.execute(stmt)
     rows = result.all()
 
+    # separate flagged scans that need labeler check vs already resolved
+    needs_labeler_check: list[
+        tuple[int, int, str, list]
+    ] = []  # scan_id, track_id, uri, matches
     copyright_info: dict[int, CopyrightInfo] = {}
-    for track_id, is_flagged, matches in rows:
-        primary_match = _extract_primary_match(matches) if is_flagged else None
-        copyright_info[track_id] = CopyrightInfo(
-            is_flagged=is_flagged,
-            primary_match=primary_match,
-        )
+
+    for scan_id, track_id, is_flagged, matches, resolution, uri in rows:
+        if not is_flagged or resolution is not None:
+            # not flagged or already resolved - no need to check labeler
+            copyright_info[track_id] = CopyrightInfo(
+                is_flagged=False if resolution else is_flagged,
+                primary_match=_extract_primary_match(matches)
+                if is_flagged and not resolution
+                else None,
+            )
+        elif uri:
+            # flagged with no resolution - need to check labeler
+            needs_labeler_check.append((scan_id, track_id, uri, matches))
+        else:
+            # flagged but no AT URI - can't check labeler, treat as flagged
+            copyright_info[track_id] = CopyrightInfo(
+                is_flagged=True,
+                primary_match=_extract_primary_match(matches),
+            )
+
+    # check labeler for tracks that need it
+    if needs_labeler_check:
+        from backend._internal.moderation import get_active_copyright_labels
+
+        uris = [uri for _, _, uri, _ in needs_labeler_check]
+        active_uris = await get_active_copyright_labels(uris)
+
+        # process results and lazily update DB for resolved tracks
+        resolved_scan_ids: list[int] = []
+        for scan_id, track_id, uri, matches in needs_labeler_check:
+            if uri in active_uris:
+                # still actively flagged
+                copyright_info[track_id] = CopyrightInfo(
+                    is_flagged=True,
+                    primary_match=_extract_primary_match(matches),
+                )
+            else:
+                # resolved in labeler - treat as not flagged
+                copyright_info[track_id] = CopyrightInfo(
+                    is_flagged=False,
+                    primary_match=None,
+                )
+                resolved_scan_ids.append(scan_id)
+
+        # lazily update resolution for newly discovered resolved scans
+        if resolved_scan_ids:
+            try:
+                await db.execute(
+                    update(CopyrightScan)
+                    .where(CopyrightScan.id.in_(resolved_scan_ids))
+                    .values(resolution="dismissed", reviewed_at=datetime.now(UTC))
+                )
+                await db.commit()
+                logger.info(
+                    "lazily updated %d copyright scans as dismissed",
+                    len(resolved_scan_ids),
+                )
+            except Exception as e:
+                logger.warning("failed to lazily update copyright resolutions: %s", e)
+                await db.rollback()
 
     return copyright_info
 

backend/tests/test_moderation.py

···
 from backend._internal.moderation import (
     _call_moderation_service,
     _store_scan_result,
+    get_active_copyright_labels,
     scan_track_for_copyright,
 )
 from backend.models import Artist, CopyrightScan, Track
···
 
     assert scan.is_flagged is True
     assert scan.highest_score == 85
+
+
+# tests for get_active_copyright_labels
+
+
+async def test_get_active_copyright_labels_empty_list() -> None:
+    """test that empty URI list returns empty set."""
+    result = await get_active_copyright_labels([])
+    assert result == set()
+
+
+async def test_get_active_copyright_labels_disabled() -> None:
+    """test that disabled moderation returns all URIs as active (fail closed)."""
+    uris = ["at://did:plc:test/fm.plyr.track/1", "at://did:plc:test/fm.plyr.track/2"]
+
+    with patch("backend._internal.moderation.settings") as mock_settings:
+        mock_settings.moderation.enabled = False
+
+        result = await get_active_copyright_labels(uris)
+
+    assert result == set(uris)
+
+
+async def test_get_active_copyright_labels_no_auth_token() -> None:
+    """test that missing auth token returns all URIs as active (fail closed)."""
+    uris = ["at://did:plc:test/fm.plyr.track/1"]
+
+    with patch("backend._internal.moderation.settings") as mock_settings:
+        mock_settings.moderation.enabled = True
+        mock_settings.moderation.auth_token = ""
+
+        result = await get_active_copyright_labels(uris)
+
+    assert result == set(uris)
+
+
+async def test_get_active_copyright_labels_success() -> None:
+    """test successful call to labeler returns active URIs."""
+    uris = [
+        "at://did:plc:test/fm.plyr.track/1",
+        "at://did:plc:test/fm.plyr.track/2",
+        "at://did:plc:test/fm.plyr.track/3",
+    ]
+
+    mock_response = Mock()
+    mock_response.json.return_value = {
+        "active_uris": ["at://did:plc:test/fm.plyr.track/1"]  # only one is active
+    }
+    mock_response.raise_for_status.return_value = None
+
+    with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
+        mock_post.return_value = mock_response
+
+        with patch("backend._internal.moderation.settings") as mock_settings:
+            mock_settings.moderation.enabled = True
+            mock_settings.moderation.auth_token = "test-token"
+            mock_settings.moderation.labeler_url = "https://labeler.example.com"
+            mock_settings.moderation.timeout_seconds = 10
+
+            result = await get_active_copyright_labels(uris)
+
+    # only the active URI should be in the result
+    assert result == {"at://did:plc:test/fm.plyr.track/1"}
+
+    # verify correct endpoint was called
+    call_kwargs = mock_post.call_args
+    assert "/admin/active-labels" in str(call_kwargs)
+    assert call_kwargs.kwargs["json"] == {"uris": uris}
+
+
+async def test_get_active_copyright_labels_service_error() -> None:
+    """test that service errors return all URIs as active (fail closed)."""
+    uris = ["at://did:plc:test/fm.plyr.track/1", "at://did:plc:test/fm.plyr.track/2"]
+
+    with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
+        mock_post.side_effect = httpx.ConnectError("connection failed")
+
+        with patch("backend._internal.moderation.settings") as mock_settings:
+            mock_settings.moderation.enabled = True
+            mock_settings.moderation.auth_token = "test-token"
+            mock_settings.moderation.labeler_url = "https://labeler.example.com"
+            mock_settings.moderation.timeout_seconds = 10
+
+            result = await get_active_copyright_labels(uris)
+
+    # should fail closed - all URIs treated as active
+    assert result == set(uris)

backend/tests/utilities/test_aggregations.py

···
 """tests for aggregation utilities."""
 
+from unittest.mock import AsyncMock, patch
+
 import pytest
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from backend.models import Artist, Track, TrackLike
-from backend.utilities.aggregations import get_like_counts
+from backend.models import Artist, CopyrightScan, Track, TrackLike
+from backend.utilities.aggregations import get_copyright_info, get_like_counts
 
 
 @pytest.fixture
···
     """test getting like count for a single track."""
     counts = await get_like_counts(db_session, [test_tracks[0].id])
     assert counts[test_tracks[0].id] == 2
+
+
+# tests for get_copyright_info
+
+
[e-mail]
+async def flagged_track(db_session: AsyncSession) -> Track:
+    """create a track with a copyright flag."""
+    artist = Artist(
+        did="did:plc:flagged",
+        handle="flagged.bsky.social",
+        display_name="Flagged Artist",
+    )
+    db_session.add(artist)
+    await db_session.flush()
+
+    track = Track(
+        title="Flagged Track",
+        artist_did=artist.did,
+        file_id="flagged_file",
+        file_type="mp3",
+        atproto_record_uri="at://did:plc:flagged/fm.plyr.track/abc123",
+    )
+    db_session.add(track)
+    await db_session.commit()
+    await db_session.refresh(track)
+
+    # add copyright scan with flag
+    scan = CopyrightScan(
+        track_id=track.id,
+        is_flagged=True,
+        highest_score=90,
+        matches=[{"title": "Copyrighted Song", "artist": "Famous Artist", "score": 90}],
+    )
+    db_session.add(scan)
+    await db_session.commit()
+
+    return track
+
+
+async def test_get_copyright_info_already_resolved(
+    db_session: AsyncSession, flagged_track: Track
+) -> None:
+    """test that already resolved scans are treated as not flagged."""
+    # update scan to have resolution set
+    scan = await db_session.scalar(
+        select(CopyrightScan).where(CopyrightScan.track_id == flagged_track.id)
+    )
+    assert scan is not None
+    scan.resolution = "dismissed"
+    await db_session.commit()
+
+    # should NOT call labeler since resolution is already set
+    with patch(
+        "backend._internal.moderation.get_active_copyright_labels",
+        new_callable=AsyncMock,
+    ) as mock_labeler:
+        result = await get_copyright_info(db_session, [flagged_track.id])
+
+        # labeler should not be called for already-resolved scans
+        mock_labeler.assert_not_called()
+
+    # track should show as not flagged
+    assert flagged_track.id in result
+    assert result[flagged_track.id].is_flagged is False
+
+
+async def test_get_copyright_info_checks_labeler_for_pending(
+    db_session: AsyncSession, flagged_track: Track
+) -> None:
+    """test that pending flagged scans query the labeler."""
+    # mock labeler returning this URI as active (still flagged)
+    with patch(
+        "backend._internal.moderation.get_active_copyright_labels",
+        new_callable=AsyncMock,
+    ) as mock_labeler:
+        mock_labeler.return_value = {flagged_track.atproto_record_uri}
+
+        result = await get_copyright_info(db_session, [flagged_track.id])
+
+        # labeler should be called
+        mock_labeler.assert_called_once()
+        call_args = mock_labeler.call_args[0][0]
+        assert flagged_track.atproto_record_uri in call_args
+
+    # track should still show as flagged
+    assert flagged_track.id in result
+    assert result[flagged_track.id].is_flagged is True
+    assert result[flagged_track.id].primary_match == "Copyrighted Song by Famous Artist"
+
+
+async def test_get_copyright_info_resolved_in_labeler(
+    db_session: AsyncSession, flagged_track: Track
+) -> None:
+    """test that labeler resolution clears the flag and updates DB."""
+    # mock labeler returning empty set (all resolved)
+    with patch(
+        "backend._internal.moderation.get_active_copyright_labels",
+        new_callable=AsyncMock,
+    ) as mock_labeler:
+        mock_labeler.return_value = set()  # not active = resolved
+
+        result = await get_copyright_info(db_session, [flagged_track.id])
+
+    # track should show as not flagged
+    assert flagged_track.id in result
+    assert result[flagged_track.id].is_flagged is False
+
+    # verify lazy update: resolution should be set in DB
+    scan = await db_session.scalar(
+        select(CopyrightScan).where(CopyrightScan.track_id == flagged_track.id)
+    )
+    assert scan is not None
+    assert scan.resolution == "dismissed"
+    assert scan.reviewed_at is not None
+
+
+async def test_get_copyright_info_empty_list(db_session: AsyncSession) -> None:
+    """test that empty track list returns empty dict."""
+    result = await get_copyright_info(db_session, [])
+    assert result == {}
+
+
+async def test_get_copyright_info_no_scan(
+    db_session: AsyncSession, test_tracks: list[Track]
+) -> None:
+    """test that tracks without copyright scans are not included."""
+    # test_tracks fixture doesn't create copyright scans
+    track_ids = [track.id for track in test_tracks]
+
+    with patch(
+        "backend._internal.moderation.get_active_copyright_labels",
+        new_callable=AsyncMock,
+    ) as mock_labeler:
+        result = await get_copyright_info(db_session, track_ids)
+
+        # labeler should not be called since no flagged tracks
+        mock_labeler.assert_not_called()
+
+    # no tracks should be in result since none have scans
+    assert result == {}

frontend/src/routes/upload/+page.svelte

···
 <script lang="ts">
-	import { onMount } from 'svelte';
-	import { goto } from '$app/navigation';
-	import Header from '$lib/components/Header.svelte';
-	import HandleSearch from '$lib/components/HandleSearch.svelte';
-	import AlbumSelect from '$lib/components/AlbumSelect.svelte';
-	import WaveLoading from '$lib/components/WaveLoading.svelte';
-	import TagInput from '$lib/components/TagInput.svelte';
-	import type { FeaturedArtist, AlbumSummary } from '$lib/types';
-	import { API_URL, getServerConfig } from '$lib/config';
-	import { uploader } from '$lib/uploader.svelte';
-	import { toast } from '$lib/toast.svelte';
-	import { auth } from '$lib/auth.svelte';
+	import { onMount } from "svelte";
+	import { goto } from "$app/navigation";
+	import Header from "$lib/components/Header.svelte";
+	import HandleSearch from "$lib/components/HandleSearch.svelte";
+	import AlbumSelect from "$lib/components/AlbumSelect.svelte";
+	import WaveLoading from "$lib/components/WaveLoading.svelte";
+	import TagInput from "$lib/components/TagInput.svelte";
+	import type { FeaturedArtist, AlbumSummary } from "$lib/types";
+	import { API_URL, getServerConfig } from "$lib/config";
+	import { uploader } from "$lib/uploader.svelte";
+	import { toast } from "$lib/toast.svelte";
+	import { auth } from "$lib/auth.svelte";
 
 	// browser-compatible audio formats only
-	const ACCEPTED_AUDIO_EXTENSIONS = ['.mp3', '.wav', '.m4a'];
-	const ACCEPTED_AUDIO_MIME_TYPES = ['audio/mpeg', 'audio/wav', 'audio/mp4'];
-	const FILE_INPUT_ACCEPT = [...ACCEPTED_AUDIO_EXTENSIONS, ...ACCEPTED_AUDIO_MIME_TYPES].join(',');
+	const ACCEPTED_AUDIO_EXTENSIONS = [".mp3", ".wav", ".m4a"];
+	const ACCEPTED_AUDIO_MIME_TYPES = ["audio/mpeg", "audio/wav", "audio/mp4"];
+	const FILE_INPUT_ACCEPT = [
+		...ACCEPTED_AUDIO_EXTENSIONS,
+		...ACCEPTED_AUDIO_MIME_TYPES,
+	].join(",");
 
 	function isSupportedAudioFile(name: string): boolean {
-		const dotIndex = name.lastIndexOf('.');
+		const dotIndex = name.lastIndexOf(".");
 		if (dotIndex === -1) return false;
 		const ext = name.slice(dotIndex).toLowerCase();
 		return ACCEPTED_AUDIO_EXTENSIONS.includes(ext);
···
 	let loading = $state(true);
 
 	// upload form fields
-	let title = $state('');
-	let albumTitle = $state('');
+	let title = $state("");
+	let albumTitle = $state("");
 	let file = $state<File | null>(null);
 	let imageFile = $state<File | null>(null);
 	let featuredArtists = $state<FeaturedArtist[]>([]);
 	let uploadTags = $state<string[]>([]);
 	let hasUnresolvedFeaturesInput = $state(false);
+	let attestedRights = $state(false);
 
 	// albums for selection
 	let albums = $state<AlbumSummary[]>([]);
···
 	onMount(async () => {
 		// wait for auth to finish loading
 		while (auth.loading) {
-			await new Promise(resolve => setTimeout(resolve, 50));
+			await new Promise((resolve) => setTimeout(resolve, 50));
 		}
 
 		if (!auth.isAuthenticated) {
-			goto('/login');
+			goto("/login");
 			return;
 		}
 
···
 	async function loadMyAlbums() {
 		if (!auth.user) return;
 		try {
-			const response = await fetch(`${API_URL}/albums/${auth.user.handle}`);
+			const response = await fetch(
+				`${API_URL}/albums/${auth.user.handle}`,
+			);
 			if (response.ok) {
 				const data = await response.json();
 				albums = data.albums;
 			}
 		} catch (_e) {
-			console.error('failed to load albums:', _e);
+			console.error("failed to load albums:", _e);
 		}
 	}
 
···
 		const tagsToUpload = [...uploadTags];
 
 		const clearForm = () => {
-			title = '';
-			albumTitle = '';
+			title = "";
+			albumTitle = "";
 			file = null;
 			imageFile = null;
 			featuredArtists = [];
 			uploadTags = [];
+			attestedRights = false;
 
-			const fileInput = document.getElementById('file-input') as HTMLInputElement;
-			if (fileInput) fileInput.value = '';
-			const imageInput = document.getElementById('image-input') as HTMLInputElement;
-			if (imageInput) imageInput.value = '';
+			const fileInput = document.getElementById(
+				"file-input",
+			) as HTMLInputElement;
+			if (fileInput) fileInput.value = "";
+			const imageInput = document.getElementById(
+				"image-input",
+			) as HTMLInputElement;
+			if (imageInput) imageInput.value = "";
 		};
 
 		uploader.upload(
···
 				onSuccess: () => {
 					clearForm();
 				},
-				onError: () => {}
-			}
+				onError: () => {},
+			},
 		);
 	}
 
···
 		if (target.files && target.files[0]) {
 			const selected = target.files[0];
 			if (!isSupportedAudioFile(selected.name)) {
-				toast.error(`unsupported file type. supported: ${ACCEPTED_AUDIO_EXTENSIONS.join(', ')}`);
-				target.value = '';
+				toast.error(
+					`unsupported file type. supported: ${ACCEPTED_AUDIO_EXTENSIONS.join(", ")}`,
+				);
+				target.value = "";
 				file = null;
 				return;
 			}
···
 				const config = await getServerConfig();
 				const sizeMB = selected.size / (1024 * 1024);
 				if (sizeMB > config.max_upload_size_mb) {
-					toast.error(`audio file too large (${sizeMB.toFixed(1)}MB). max: ${config.max_upload_size_mb}MB`);
-					target.value = '';
+					toast.error(
+						`audio file too large (${sizeMB.toFixed(1)}MB). max: ${config.max_upload_size_mb}MB`,
+					);
+					target.value = "";
 					file = null;
 					return;
 				}
 			} catch (_e) {
-				console.error('failed to validate file size:', _e);
+				console.error("failed to validate file size:", _e);
 			}
 
 			file = selected;
···
 				const config = await getServerConfig();
 				const sizeMB = selected.size / (1024 * 1024);
 				if (sizeMB > config.max_image_size_mb) {
-					toast.error(`image too large (${sizeMB.toFixed(1)}MB). max: ${config.max_image_size_mb}MB`);
-					target.value = '';
+					toast.error(
+						`image too large (${sizeMB.toFixed(1)}MB). max: ${config.max_image_size_mb}MB`,
+					);
+					target.value = "";
 					imageFile = null;
 					return;
 				}
 			} catch (_e) {
-				console.error('failed to validate image size:', _e);
+				console.error("failed to validate image size:", _e);
 			}
 
 			imageFile = selected;
···
 
 	async function logout() {
 		await auth.logout();
-		window.location.href = '/';
+		window.location.href = "/";
 	}
 </script>
 
···
 		<WaveLoading size="lg" message="loading..." />
 	</div>
 {:else}
-	<Header user={auth.user} isAuthenticated={auth.isAuthenticated} onLogout={logout} />
+	<Header
+		user={auth.user}
+		isAuthenticated={auth.isAuthenticated}
+		onLogout={logout}
+	/>
 	<main>
 		<div class="section-header">
 			<h2>upload track</h2>
···
 
 			<div class="form-group">
 				<label for="album">album (optional)</label>
-				<AlbumSelect
-					{albums}
-					bind:value={albumTitle}
-				/>
+				<AlbumSelect {albums} bind:value={albumTitle} />
 			</div>
 
 			<div class="form-group">
···
 				<HandleSearch
 					bind:selected={featuredArtists}
 					bind:hasUnresolvedInput={hasUnresolvedFeaturesInput}
-					onAdd={(artist) => { featuredArtists = [...featuredArtists, artist]; }}
-					onRemove={(did) => { featuredArtists = featuredArtists.filter(a => a.did !== did); }}
+					onAdd={(artist) => {
+						featuredArtists = [...featuredArtists, artist];
+					}}
+					onRemove={(did) => {
+						featuredArtists = featuredArtists.filter(
+							(a) => a.did !== did,
+						);
+					}}
 				/>
 			</div>
 
···
 				<label for="upload-tags">tags (optional)</label>
 				<TagInput
 					tags={uploadTags}
-					onAdd={(tag) => { uploadTags = [...uploadTags, tag]; }}
-					onRemove={(tag) => { uploadTags = uploadTags.filter(t => t !== tag); }}
+					onAdd={(tag) => {
+						uploadTags = [...uploadTags, tag];
+					}}
+					onRemove={(tag) => {
+						uploadTags = uploadTags.filter((t) => t !== tag);
+					}}
 					placeholder="type to search tags..."
 				/>
 			</div>
···
 				/>
 				<p class="format-hint">supported: mp3, wav, m4a</p>
 				{#if file}
-					<p class="file-info">{file.name} ({(file.size / 1024 / 1024).toFixed(2)} MB)</p>
+					<p class="file-info">
+						{file.name} ({(file.size / 1024 / 1024).toFixed(2)} MB)
+					</p>
 				{/if}
 			</div>
 
···
 				/>
 				<p class="format-hint">supported: jpg, png, webp, gif</p>
 				{#if imageFile}
-					<p class="file-info">{imageFile.name} ({(imageFile.size / 1024 / 1024).toFixed(2)} MB)</p>
+					<p class="file-info">
+						{imageFile.name} ({(
+							imageFile.size /
+							1024 /
+							1024
+						).toFixed(2)} MB)
+					</p>
 				{/if}
 			</div>
 
-			<button type="submit" disabled={!file || hasUnresolvedFeaturesInput} class="upload-btn" title={hasUnresolvedFeaturesInput ? "please select or clear featured artist" : ""}>
+			<div class="form-group attestation">
+				<label class="checkbox-label">
+					<input
+						type="checkbox"
+						bind:checked={attestedRights}
+						required
+					/>
+					<span class="checkbox-text">
+						I have the right to distribute this content, I am not
+						knowingly infringing on copyright or otherwise stealing
+						from artists.
+					</span>
+				</label>
+				<p class="attestation-note">
+					Content appearing on other platforms (YouTube, SoundCloud,
+					Internet Archive, etc.) does not mean it's licensed for
+					redistribution. You should own the rights or have explicit
+					permission, or the content may be removed to keep plyr.fm in
+					compliance. For any questions or concerns, please DM
+					<a
+						href="https://bsky.app/profile/zzstoatzz.io"
+						target="_blank"
+						rel="noopener">@zzstoatzz.io</a
+					> :) have a nice day!
+				</p>
+			</div>
+
+			<button
+				type="submit"
+				disabled={!file ||
+					hasUnresolvedFeaturesInput ||
+					!attestedRights}
+				class="upload-btn"
+				title={hasUnresolvedFeaturesInput
+					? "please select or clear featured artist"
+					: !attestedRights
+						? "please confirm you have distribution rights"
+						: ""}
+			>
 				<span>upload track</span>
 			</button>
 		</form>
···
 	main {
 		max-width: 800px;
 		margin: 0 auto;
-		padding: 0 1rem calc(var(--player-height, 120px) + 2rem + env(safe-area-inset-bottom, 0px));
+		padding: 0 1rem
+			calc(
+				var(--player-height, 120px) + 2rem +
+					env(safe-area-inset-bottom, 0px)
+			);
 	}
 
 	.section-header {
···
 		font-size: 0.9rem;
 	}
 
-	input[type='text'] {
+	input[type="text"] {
 		width: 100%;
 		padding: 0.75rem;
 		background: var(--bg-primary);
···
 		transition: all 0.2s;
 	}
 
-	input[type='text']:focus {
+	input[type="text"]:focus {
 		outline: none;
 		border-color: var(--accent);
 	}
 
-	input[type='file'] {
+	input[type="file"] {
 		width: 100%;
 		padding: 0.75rem;
 		background: var(--bg-primary);
···
 	button:hover:not(:disabled) {
 		background: var(--accent-hover);
 		transform: translateY(-1px);
-		box-shadow: 0 4px 12px color-mix(in srgb, var(--accent) 30%, transparent);
+		box-shadow: 0 4px 12px
+			color-mix(in srgb, var(--accent) 30%, transparent);
 	}
 
 	button:disabled {
···
 		gap: 0.5rem;
 	}
 
+	.attestation {
+		background: var(--bg-primary);
+		padding: 1rem;
+		border-radius: 4px;
+		border: 1px solid var(--border-default);
+	}
+
+	.checkbox-label {
+		display: flex;
+		align-items: flex-start;
+		gap: 0.75rem;
+		cursor: pointer;
+		margin-bottom: 0;
+	}
+
+	.checkbox-label input[type="checkbox"] {
+		width: 1.25rem;
+		height: 1.25rem;
+		margin-top: 0.1rem;
+		flex-shrink: 0;
+		accent-color: var(--accent);
+		cursor: pointer;
+	}
+
+	.checkbox-text {
+		font-size: 0.95rem;
+		color: var(--text-primary);
+		line-height: 1.4;
+	}
+
+	.attestation-note {
+		margin-top: 0.75rem;
+		margin-left: 2rem;
+		font-size: 0.8rem;
+		color: var(--text-tertiary);
+		line-height: 1.4;
+	}
+
+	.attestation-note a {
+		color: var(--accent);
+		text-decoration: none;
+	}
+
+	.attestation-note a:hover {
+		text-decoration: underline;
+	}
+
 	@media (max-width: 768px) {
 		main {
-			padding: 0 0.75rem calc(var(--player-height, 120px) + 1.5rem + env(safe-area-inset-bottom, 0px));
+			padding: 0 0.75rem
+				calc(
+					var(--player-height, 120px) + 1.5rem +
+						env(safe-area-inset-bottom, 0px)
+				);
 		}
 
 		form {

moderation/src/admin.rs

···
     pub message: String,
 }
 
+/// Request to check which URIs have active labels.
+#[derive(Debug, Deserialize)]
+pub struct ActiveLabelsRequest {
+    pub uris: Vec<String>,
+}
+
+/// Response with active (non-negated) URIs.
+#[derive(Debug, Serialize)]
+pub struct ActiveLabelsResponse {
+    pub active_uris: Vec<String>,
+}
+
 /// List all flagged tracks - returns JSON for API, HTML for htmx.
 pub async fn list_flagged(
     State(state): State<AppState>,
···
         html,
     )
         .into_response())
+}
+
+/// Get which URIs have active (non-negated) copyright-violation labels.
+///
+/// Used by the backend to determine which tracks are still flagged.
+pub async fn get_active_labels(
+    State(state): State<AppState>,
+    Json(request): Json<ActiveLabelsRequest>,
+) -> Result<Json<ActiveLabelsResponse>, AppError> {
+    let db = state.db.as_ref().ok_or(AppError::LabelerNotConfigured)?;
+
+    tracing::debug!(uri_count = request.uris.len(), "checking active labels");
+
+    let active_uris = db.get_active_labels(&request.uris).await?;
+
+    tracing::debug!(
+        active_count = active_uris.len(),
+        "returning active labels"
+    );
+
+    Ok(Json(ActiveLabelsResponse { active_uris }))
 }
 
 /// Store context for a label (for backfill without re-emitting labels).

moderation/src/db.rs

···
             .map(|s| s.unwrap_or(0))
     }
 
+    /// Get URIs that have active (non-negated) copyright-violation labels.
+    ///
+    /// For each URI, checks if there's a negation label. Returns only those
+    /// that are still actively flagged.
+    pub async fn get_active_labels(&self, uris: &[String]) -> Result<Vec<String>, sqlx::Error> {
+        if uris.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Get all negated URIs from our input set
+        let negated_uris: std::collections::HashSet<String> = sqlx::query_scalar::<_, String>(
+            r#"
+            SELECT DISTINCT uri
+            FROM labels
+            WHERE val = 'copyright-violation' AND neg = true AND uri = ANY($1)
+            "#,
+        )
+        .bind(uris)
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .collect();
+
+        // Get URIs that have a positive label and are not negated
+        let active_uris: Vec<String> = sqlx::query_scalar::<_, String>(
+            r#"
+            SELECT DISTINCT uri
+            FROM labels
+            WHERE val = 'copyright-violation' AND neg = false AND uri = ANY($1)
+            "#,
+        )
+        .bind(uris)
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .filter(|uri| !negated_uris.contains(uri))
+        .collect();
+
+        Ok(active_uris)
+    }
+
     /// Get all copyright-violation labels with their resolution status and context.
     ///
     /// A label is resolved if there's a negation label for the same uri+val.

moderation/src/main.rs

···
         .route("/admin/resolve", post(admin::resolve_flag))
         .route("/admin/resolve-htmx", post(admin::resolve_flag_htmx))
         .route("/admin/context", post(admin::store_context))
+        .route("/admin/active-labels", post(admin::get_active_labels))
         // Static files (CSS, JS for admin UI)
         .nest_service("/static", ServeDir::new("static"))
         // ATProto XRPC endpoints (public)