feat: add reason selection for false positive resolution in moderation UI (#408)

* feat: add reason selection for false positive resolution in moderation UI

when marking a copyright flag as a false positive, admins must now select
a reason from preset options:
- original_artist: artist uploaded their own distributed music
- licensed: has licensing/permission rights
- fingerprint_noise: matcher produced false match
- cover_version: legal cover or remix
- other: free text in notes

the reason is stored in label_context table (resolution_reason, resolution_notes)
for audit purposes. the ATProto negation label stays minimal per protocol spec.

resolved flags now display the reason instead of just "resolved".

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

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

* rm random file

---------

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

moderation/src/admin.rs

···
     pub uri: String,
     #[serde(default = "default_val")]
     pub val: String,
+    /// Reason for marking as false positive.
+    pub reason: Option<String>,
+    /// Additional notes about the resolution.
+    pub notes: Option<String>,
 }
 
 fn default_val() -> String {
···
     Json(request): Json<ResolveRequest>,
 ) -> Result<Json<ResolveResponse>, AppError> {
     let db = state.db.as_ref().ok_or(AppError::LabelerNotConfigured)?;
-    let signer = state.signer.as_ref().ok_or(AppError::LabelerNotConfigured)?;
+    let signer = state
+        .signer
+        .as_ref()
+        .ok_or(AppError::LabelerNotConfigured)?;
 
     tracing::info!(uri = %request.uri, val = %request.val, "resolving flag (creating negation)");
 
···
     axum::Form(request): axum::Form<ResolveRequest>,
 ) -> Result<Response, AppError> {
     let db = state.db.as_ref().ok_or(AppError::LabelerNotConfigured)?;
-    let signer = state.signer.as_ref().ok_or(AppError::LabelerNotConfigured)?;
+    let signer = state
+        .signer
+        .as_ref()
+        .ok_or(AppError::LabelerNotConfigured)?;
+
+    // Parse the reason
+    let reason = request
+        .reason
+        .as_deref()
+        .and_then(crate::db::ResolutionReason::from_str);
 
-    tracing::info!(uri = %request.uri, val = %request.val, "resolving flag via htmx");
+    tracing::info!(
+        uri = %request.uri,
+        val = %request.val,
+        reason = ?reason,
+        notes = ?request.notes,
+        "resolving flag via htmx"
+    );
 
     // Create a negation label
     let label = crate::labels::Label::new(signer.did(), &request.uri, &request.val).negated();
···
 
     let seq = db.store_label(&label).await?;
 
+    // Store resolution reason in context
+    if let Some(r) = reason {
+        db.store_resolution(&request.uri, r, request.notes.as_deref())
+            .await?;
+    }
+
     // Broadcast to subscribers
     if let Some(tx) = &state.label_tx {
         let _ = tx.send((seq, label));
     }
 
     // Return success toast + trigger refresh
+    let reason_label = reason.map(|r| r.label()).unwrap_or("unknown");
     let html = format!(
-        r#"<div id="toast" class="toast success" hx-swap-oob="true">resolved (seq: {})</div>"#,
-        seq
+        r#"<div id="toast" class="toast success" hx-swap-oob="true">resolved: {} (seq: {})</div>"#,
+        reason_label, seq
     );
 
     Ok((
-        [
-            (CONTENT_TYPE, "text/html; charset=utf-8"),
-        ],
-        [(axum::http::header::HeaderName::from_static("hx-trigger"), "flagsUpdated")],
+        [(CONTENT_TYPE, "text/html; charset=utf-8")],
+        [(
+            axum::http::header::HeaderName::from_static("hx-trigger"),
+            "flagsUpdated",
+        )],
         html,
     )
         .into_response())
···
         artist_did: request.context.artist_did,
         highest_score: request.context.highest_score,
         matches: request.context.matches,
+        resolution_reason: None,
+        resolution_notes: None,
     };
 
     db.store_context(&request.uri, &label_ctx).await?;
···
 /// Render a single flag card as HTML.
 fn render_flag_card(track: &FlaggedTrack) -> String {
     let ctx = track.context.as_ref();
-    let has_context = ctx.map_or(false, |c| c.track_title.is_some() || c.artist_handle.is_some());
+    let has_context = ctx.is_some_and(|c| c.track_title.is_some() || c.artist_handle.is_some());
 
     let track_info = if has_context {
         let c = ctx.unwrap();
···
     let score_badge = ctx
         .and_then(|c| c.highest_score)
         .filter(|&s| s > 0.0)
-        .map(|s| format!(r#"<span class="badge score">{}% match</span>"#, (s * 100.0) as i32))
+        .map(|s| {
+            format!(
+                r#"<span class="badge score">{}% match</span>"#,
+                (s * 100.0) as i32
+            )
+        })
         .unwrap_or_default();
 
     let status_badge = if track.resolved {
···
         .unwrap_or_default();
 
     let action_button = if track.resolved {
-        r#"<button class="btn btn-secondary" disabled>resolved</button>"#.to_string()
+        // Show the resolution reason if available
+        let reason_text = ctx
+            .and_then(|c| c.resolution_reason.as_ref())
+            .map(|r| r.label())
+            .unwrap_or("resolved");
+        let notes_text = ctx
+            .and_then(|c| c.resolution_notes.as_ref())
+            .map(|n| format!(r#" title="{}""#, html_escape(n)))
+            .unwrap_or_default();
+        format!(
+            r#"<span class="resolution-reason"{}>{}</span>"#,
+            notes_text, reason_text
+        )
     } else {
         format!(
-            r#"<form hx-post="/admin/resolve-htmx" hx-swap="none" style="display:inline">
-                <input type="hidden" name="uri" value="{}">
-                <input type="hidden" name="val" value="{}">
-                <button type="submit" class="btn btn-warning">mark false positive</button>
-            </form>"#,
+            r#"<div class="resolve-dropdown">
+                <button type="button" class="btn btn-warning dropdown-toggle" onclick="toggleDropdown(this)">
+                    mark false positive
+                </button>
+                <div class="dropdown-menu">
+                    <form hx-post="/admin/resolve-htmx" hx-swap="none">
+                        <input type="hidden" name="uri" value="{}">
+                        <input type="hidden" name="val" value="{}">
+                        <button type="submit" name="reason" value="original_artist" class="dropdown-item">
+                            original artist
+                            <span class="item-desc">artist uploaded their own work</span>
+                        </button>
+                        <button type="submit" name="reason" value="licensed" class="dropdown-item">
+                            licensed
+                            <span class="item-desc">has rights/permission</span>
+                        </button>
+                        <button type="submit" name="reason" value="fingerprint_noise" class="dropdown-item">
+                            fingerprint noise
+                            <span class="item-desc">matcher false positive</span>
+                        </button>
+                        <button type="submit" name="reason" value="cover_version" class="dropdown-item">
+                            cover/remix
+                            <span class="item-desc">legal derivative work</span>
+                        </button>
+                        <button type="submit" name="reason" value="other" class="dropdown-item">
+                            other
+                            <span class="item-desc">see notes</span>
+                        </button>
+                    </form>
+                </div>
+            </div>"#,
             html_escape(&track.uri),
             html_escape(&track.val)
         )

moderation/src/audd.rs

···
 
     info!(
         match_count = matches.len(),
-        highest_score,
-        is_flagged,
-        "scan complete"
+        highest_score, is_flagged, "scan complete"
     );
 
     Ok(Json(ScanResponse {

moderation/src/db.rs

···
     Option<String>,
     Option<f64>,
     Option<serde_json::Value>,
+    Option<String>,
+    Option<String>,
 );
 
 /// Type alias for flagged track row from database query.
···
     Option<String>,
     Option<f64>,
     Option<serde_json::Value>,
+    Option<String>,
+    Option<String>,
 );
 
 /// Copyright match info stored alongside labels.
···
     pub score: f64,
 }
 
+/// Reason for resolving a false positive.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ResolutionReason {
+    /// Artist uploaded their own distributed music
+    OriginalArtist,
+    /// Artist has licensing/permission for the content
+    Licensed,
+    /// Fingerprint matcher produced a false match
+    FingerprintNoise,
+    /// Legal cover version or remix
+    CoverVersion,
+    /// Other reason (see resolution_notes)
+    Other,
+}
+
+impl ResolutionReason {
+    /// Human-readable label for the reason.
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::OriginalArtist => "original artist",
+            Self::Licensed => "licensed",
+            Self::FingerprintNoise => "fingerprint noise",
+            Self::CoverVersion => "cover/remix",
+            Self::Other => "other",
+        }
+    }
+
+    /// Parse from string.
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "original_artist" => Some(Self::OriginalArtist),
+            "licensed" => Some(Self::Licensed),
+            "fingerprint_noise" => Some(Self::FingerprintNoise),
+            "cover_version" => Some(Self::CoverVersion),
+            "other" => Some(Self::Other),
+            _ => None,
+        }
+    }
+}
+
 /// Context stored alongside a label for display in admin UI.
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct LabelContext {
···
     pub artist_did: Option<String>,
     pub highest_score: Option<f64>,
     pub matches: Option<Vec<CopyrightMatch>>,
+    /// Why the flag was resolved as false positive (set on resolution).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resolution_reason: Option<ResolutionReason>,
+    /// Additional notes about the resolution.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resolution_notes: Option<String>,
 }
 
 /// Database connection pool and operations.
···
             .execute(&self.pool)
             .await?;
 
+        // Add resolution columns (migration-safe: only adds if missing)
+        sqlx::query("ALTER TABLE label_context ADD COLUMN IF NOT EXISTS resolution_reason TEXT")
+            .execute(&self.pool)
+            .await?;
+        sqlx::query("ALTER TABLE label_context ADD COLUMN IF NOT EXISTS resolution_notes TEXT")
+            .execute(&self.pool)
+            .await?;
+
         Ok(())
     }
 
     /// Store or update label context for a URI.
-    pub async fn store_context(&self, uri: &str, context: &LabelContext) -> Result<(), sqlx::Error> {
+    pub async fn store_context(
+        &self,
+        uri: &str,
+        context: &LabelContext,
+    ) -> Result<(), sqlx::Error> {
         let matches_json = context
             .matches
             .as_ref()
             .map(|m| serde_json::to_value(m).unwrap_or_default());
+        let reason_str = context
+            .resolution_reason
+            .map(|r| format!("{:?}", r).to_lowercase());
 
         sqlx::query(
             r#"
-            INSERT INTO label_context (uri, track_title, artist_handle, artist_did, highest_score, matches)
-            VALUES ($1, $2, $3, $4, $5, $6)
+            INSERT INTO label_context (uri, track_title, artist_handle, artist_did, highest_score, matches, resolution_reason, resolution_notes)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
             ON CONFLICT (uri) DO UPDATE SET
-                track_title = EXCLUDED.track_title,
-                artist_handle = EXCLUDED.artist_handle,
-                artist_did = EXCLUDED.artist_did,
-                highest_score = EXCLUDED.highest_score,
-                matches = EXCLUDED.matches
+                track_title = COALESCE(EXCLUDED.track_title, label_context.track_title),
+                artist_handle = COALESCE(EXCLUDED.artist_handle, label_context.artist_handle),
+                artist_did = COALESCE(EXCLUDED.artist_did, label_context.artist_did),
+                highest_score = COALESCE(EXCLUDED.highest_score, label_context.highest_score),
+                matches = COALESCE(EXCLUDED.matches, label_context.matches),
+                resolution_reason = COALESCE(EXCLUDED.resolution_reason, label_context.resolution_reason),
+                resolution_notes = COALESCE(EXCLUDED.resolution_notes, label_context.resolution_notes)
             "#,
         )
         .bind(uri)
···
         .bind(&context.artist_did)
         .bind(context.highest_score)
         .bind(matches_json)
+        .bind(reason_str)
+        .bind(&context.resolution_notes)
+        .execute(&self.pool)
+        .await?;
+
+        Ok(())
+    }
+
+    /// Store resolution reason for a URI (without overwriting other context).
+    pub async fn store_resolution(
+        &self,
+        uri: &str,
+        reason: ResolutionReason,
+        notes: Option<&str>,
+    ) -> Result<(), sqlx::Error> {
+        let reason_str = format!("{:?}", reason).to_lowercase();
+        sqlx::query(
+            r#"
+            INSERT INTO label_context (uri, resolution_reason, resolution_notes)
+            VALUES ($1, $2, $3)
+            ON CONFLICT (uri) DO UPDATE SET
+                resolution_reason = EXCLUDED.resolution_reason,
+                resolution_notes = EXCLUDED.resolution_notes
+            "#,
+        )
+        .bind(uri)
+        .bind(reason_str)
+        .bind(notes)
         .execute(&self.pool)
         .await?;
 
···
     pub async fn get_context(&self, uri: &str) -> Result<Option<LabelContext>, sqlx::Error> {
         let row: Option<ContextRow> = sqlx::query_as(
                 r#"
-                SELECT track_title, artist_handle, artist_did, highest_score, matches
+                SELECT track_title, artist_handle, artist_did, highest_score, matches, resolution_reason, resolution_notes
                 FROM label_context
                 WHERE uri = $1
                 "#,
···
             .fetch_optional(&self.pool)
             .await?;
 
-        Ok(row.map(|(track_title, artist_handle, artist_did, highest_score, matches)| {
-            LabelContext {
+        Ok(row.map(
+            |(
                 track_title,
                 artist_handle,
                 artist_did,
                 highest_score,
-                matches: matches.and_then(|v| serde_json::from_value(v).ok()),
-            }
-        }))
+                matches,
+                resolution_reason,
+                resolution_notes,
+            )| {
+                LabelContext {
+                    track_title,
+                    artist_handle,
+                    artist_did,
+                    highest_score,
+                    matches: matches.and_then(|v| serde_json::from_value(v).ok()),
+                    resolution_reason: resolution_reason
+                        .and_then(|s| ResolutionReason::from_str(&s)),
+                    resolution_notes,
+                }
+            },
+        ))
     }
 
     /// Store a signed label and return its sequence number.
     pub async fn store_label(&self, label: &Label) -> Result<i64, sqlx::Error> {
         let sig = label.sig.as_ref().map(|b| b.to_vec()).unwrap_or_default();
-        let cts: DateTime<Utc> = label
-            .cts
-            .parse()
-            .unwrap_or_else(|_| Utc::now());
+        let cts: DateTime<Utc> = label.cts.parse().unwrap_or_else(|_| Utc::now());
         let exp: Option<DateTime<Utc>> = label.exp.as_ref().and_then(|e| e.parse().ok());
 
         let row = sqlx::query_scalar::<_, i64>(
···
     }
 
     /// Get labels since a sequence number (for subscribeLabels).
-    pub async fn get_labels_since(&self, cursor: i64, limit: i64) -> Result<Vec<LabelRow>, sqlx::Error> {
+    pub async fn get_labels_since(
+        &self,
+        cursor: i64,
+        limit: i64,
+    ) -> Result<Vec<LabelRow>, sqlx::Error> {
         sqlx::query_as::<_, LabelRow>(
             r#"
             SELECT seq, src, uri, cid, val, neg, cts, exp, sig
···
     pub async fn get_pending_flags(&self) -> Result<Vec<FlaggedTrack>, sqlx::Error> {
         // Get all copyright-violation labels with context via LEFT JOIN
         let rows: Vec<FlaggedRow> = sqlx::query_as(
-                r#"
+            r#"
                 SELECT l.seq, l.uri, l.val, l.cts,
-                       c.track_title, c.artist_handle, c.artist_did, c.highest_score, c.matches
+                       c.track_title, c.artist_handle, c.artist_did, c.highest_score, c.matches,
+                       c.resolution_reason, c.resolution_notes
                 FROM labels l
                 LEFT JOIN label_context c ON l.uri = c.uri
                 WHERE l.val = 'copyright-violation' AND l.neg = false
                 ORDER BY l.seq DESC
                 "#,
-            )
-            .fetch_all(&self.pool)
-            .await?;
+        )
+        .fetch_all(&self.pool)
+        .await?;
 
         // Get all negation labels
         let negated_uris: std::collections::HashSet<String> = sqlx::query_scalar::<_, String>(
···
 
         let tracks = rows
             .into_iter()
-            .map(|(seq, uri, val, cts, track_title, artist_handle, artist_did, highest_score, matches)| {
-                let context = if track_title.is_some() || artist_handle.is_some() {
-                    Some(LabelContext {
-                        track_title,
-                        artist_handle,
-                        artist_did,
-                        highest_score,
-                        matches: matches.and_then(|v| serde_json::from_value(v).ok()),
-                    })
-                } else {
-                    None
-                };
-
-                FlaggedTrack {
+            .map(
+                |(
                     seq,
-                    uri: uri.clone(),
+                    uri,
                     val,
-                    created_at: cts.format("%Y-%m-%d %H:%M:%S").to_string(),
-                    resolved: negated_uris.contains(&uri),
-                    context,
-                }
-            })
+                    cts,
+                    track_title,
+                    artist_handle,
+                    artist_did,
+                    highest_score,
+                    matches,
+                    resolution_reason,
+                    resolution_notes,
+                )| {
+                    let context = if track_title.is_some()
+                        || artist_handle.is_some()
+                        || resolution_reason.is_some()
+                    {
+                        Some(LabelContext {
+                            track_title,
+                            artist_handle,
+                            artist_did,
+                            highest_score,
+                            matches: matches.and_then(|v| serde_json::from_value(v).ok()),
+                            resolution_reason: resolution_reason
+                                .and_then(|s| ResolutionReason::from_str(&s)),
+                            resolution_notes,
+                        })
+                    } else {
+                        None
+                    };
+
+                    FlaggedTrack {
+                        seq,
+                        uri: uri.clone(),
+                        val,
+                        created_at: cts.format("%Y-%m-%d %H:%M:%S").to_string(),
+                        resolved: negated_uris.contains(&uri),
+                        context,
+                    }
+                },
+            )
             .collect();
 
         Ok(tracks)
···
             val: self.val.clone(),
             neg: if self.neg { Some(true) } else { None },
             cts: self.cts.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
-            exp: self.exp.map(|e| e.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string()),
+            exp: self
+                .exp
+                .map(|e| e.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string()),
             sig: Some(bytes::Bytes::from(self.sig.clone())),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_resolution_reason_from_str() {
+        assert_eq!(
+            ResolutionReason::from_str("original_artist"),
+            Some(ResolutionReason::OriginalArtist)
+        );
+        assert_eq!(
+            ResolutionReason::from_str("licensed"),
+            Some(ResolutionReason::Licensed)
+        );
+        assert_eq!(
+            ResolutionReason::from_str("fingerprint_noise"),
+            Some(ResolutionReason::FingerprintNoise)
+        );
+        assert_eq!(
+            ResolutionReason::from_str("cover_version"),
+            Some(ResolutionReason::CoverVersion)
+        );
+        assert_eq!(
+            ResolutionReason::from_str("other"),
+            Some(ResolutionReason::Other)
+        );
+        assert_eq!(ResolutionReason::from_str("invalid"), None);
+    }
+
+    #[test]
+    fn test_resolution_reason_labels() {
+        assert_eq!(ResolutionReason::OriginalArtist.label(), "original artist");
+        assert_eq!(ResolutionReason::Licensed.label(), "licensed");
+        assert_eq!(
+            ResolutionReason::FingerprintNoise.label(),
+            "fingerprint noise"
+        );
+        assert_eq!(ResolutionReason::CoverVersion.label(), "cover/remix");
+        assert_eq!(ResolutionReason::Other.label(), "other");
+    }
+
+    #[test]
+    fn test_label_context_default() {
+        let ctx = LabelContext::default();
+        assert!(ctx.track_title.is_none());
+        assert!(ctx.resolution_reason.is_none());
+        assert!(ctx.resolution_notes.is_none());
+    }
+}

moderation/src/handlers.rs

···
     Json(request): Json<EmitLabelRequest>,
 ) -> Result<Json<EmitLabelResponse>, AppError> {
     let db = state.db.as_ref().ok_or(AppError::LabelerNotConfigured)?;
-    let signer = state.signer.as_ref().ok_or(AppError::LabelerNotConfigured)?;
+    let signer = state
+        .signer
+        .as_ref()
+        .ok_or(AppError::LabelerNotConfigured)?;
 
     info!(uri = %request.uri, val = %request.val, neg = request.neg, "emitting label");
 
···
             artist_did: ctx.artist_did,
             highest_score: ctx.highest_score,
             matches: ctx.matches,
+            resolution_reason: None,
+            resolution_notes: None,
         };
         if let Err(e) = db.store_context(&request.uri, &label_ctx).await {
             // Log but don't fail - context is supplementary

moderation/src/main.rs

···
 
 mod admin;
 mod audd;
+mod auth;
 mod config;
 mod db;
 mod handlers;
 mod labels;
-mod auth;
 mod state;
 mod xrpc;
 
···
         // Static files (CSS, JS for admin UI)
         .nest_service("/static", ServeDir::new("static"))
         // ATProto XRPC endpoints (public)
-        .route("/xrpc/com.atproto.label.queryLabels", get(xrpc::query_labels))
+        .route(
+            "/xrpc/com.atproto.label.queryLabels",
+            get(xrpc::query_labels),
+        )
         .route(
             "/xrpc/com.atproto.label.subscribeLabels",
             get(xrpc::subscribe_labels),

moderation/static/admin.css

···
     border-top: 1px solid var(--border-subtle);
 }
 
+/* resolution reason display */
+.resolution-reason {
+    color: var(--success);
+    font-size: 0.85rem;
+    font-weight: 500;
+    cursor: help;
+}
+
+/* dropdown for reason selection */
+.resolve-dropdown {
+    position: relative;
+    display: inline-block;
+}
+
+.dropdown-toggle::after {
+    content: ' ▼';
+    font-size: 0.7em;
+}
+
+.dropdown-menu {
+    display: none;
+    position: absolute;
+    right: 0;
+    bottom: 100%;
+    margin-bottom: 4px;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-default);
+    border-radius: 8px;
+    min-width: 220px;
+    z-index: 100;
+    box-shadow: 0 -4px 20px rgba(0, 0, 0, 0.4);
+    overflow: hidden;
+}
+
+.resolve-dropdown.open .dropdown-menu {
+    display: block;
+}
+
+.dropdown-item {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    padding: 12px 16px;
+    background: transparent;
+    border: none;
+    border-bottom: 1px solid var(--border-subtle);
+    color: var(--text-primary);
+    font-family: inherit;
+    font-size: 0.85rem;
+    text-align: left;
+    cursor: pointer;
+    transition: background 0.1s ease;
+}
+
+.dropdown-item:last-child {
+    border-bottom: none;
+}
+
+.dropdown-item:hover {
+    background: var(--bg-hover);
+}
+
+.dropdown-item .item-desc {
+    color: var(--text-muted);
+    font-size: 0.75rem;
+    margin-top: 2px;
+}
+
 /* states */
 .empty, .loading {
     color: var(--text-muted);

moderation/static/admin.js

···
     toast.style.display = 'block';
     setTimeout(() => { toast.style.display = 'none'; }, 3000);
 }
+
+// Dropdown toggle for reason selection
+function toggleDropdown(btn) {
+    const dropdown = btn.closest('.resolve-dropdown');
+    const wasOpen = dropdown.classList.contains('open');
+
+    // Close all dropdowns first
+    document.querySelectorAll('.resolve-dropdown.open').forEach(d => d.classList.remove('open'));
+
+    // Toggle this one
+    if (!wasOpen) {
+        dropdown.classList.add('open');
+    }
+}
+
+// Close dropdowns when clicking outside
+document.addEventListener('click', function(evt) {
+    if (!evt.target.closest('.resolve-dropdown')) {
+        document.querySelectorAll('.resolve-dropdown.open').forEach(d => d.classList.remove('open'));
+    }
+});
+
+// Close dropdowns after form submission
+document.body.addEventListener('htmx:afterRequest', function(evt) {
+    document.querySelectorAll('.resolve-dropdown.open').forEach(d => d.classList.remove('open'));
+});

podcast_script.txt

···
-Host: Welcome to the plyr.fm update for early December 2025. Just shipped some major copyright moderation infrastructure this past week.
-
-Cohost: Yeah, this is a big one. We integrated an ATProto labeler service into the Rust-based moderation system. Think of it like a referee for the music sharing platform - when copyright violations get detected, proper labels get emitted that other ATProto apps can subscribe to.
-
-Host: The key piece is the admin UI that went live at the end of November. It's built with htmx for server-rendered interactivity, no JavaScript bloat. Admins can review copyright flags, see what tracks got matched against the AuDD fingerprinting API, and mark false positives with a single button click.
-
-Cohost: And those false positive resolutions emit negation labels, which is a nice touch. The system already reviewed 25 flagged tracks - found 8 actual violations, 11 false positives from fingerprint noise, and 6 cases where artists uploaded their own distributed music.
-
-Host: There's also some UX polish worth mentioning. The artist portal now shows a copyright flag indicator on flagged tracks with a tooltip showing the primary match. So artists can see immediately if something got flagged and why.
-
-Cohost: Late November also brought platform stats to the homepage - total plays, tracks, and artists displayed right in the header. Small detail, but it gives visitors an immediate sense of activity.
-
-Host: The Media Session API integration is pretty slick too. Your plyr.fm tracks now show up in CarPlay, lock screens, and system control centers with full metadata and artwork. Play, pause, skip - all works from the system UI.
-
-Cohost: And timed comments shipped. You can drop a comment at a specific timestamp in a track, and clicking that timestamp seeks right to that moment. Makes discussing specific parts of a song much more natural.
-
-Host: There's also developer token functionality with independent OAuth grants. Each token gets its own OAuth flow, separate from your browser session. So you can script uploads or deletions without worrying about your browser logout invalidating the token.
-
-Cohost: Looking back, the project started in November 2025, so we're about a month in. The copyright moderation system was the big push this past week, but earlier in November there was work on export reliability, oEmbed support for embeds, and a lot of mobile UI polish.
-
-Host: The oEmbed endpoint lets plyr.fm tracks embed properly in Leaflet.pub and other services. Before that, you'd just see a basic HTML5 audio element instead of the custom player.
-
-Cohost: Database-backed jobs fixed export failures on large files. Used to hit out-of-memory errors on 90-minute WAV files, but now exports stream to disk with constant memory usage.
-
-Host: That's the snapshot for early December. Copyright moderation infrastructure is live, platform stats are visible, and timed comments let people discuss specific moments in tracks.