fix: normalize AuDD scores + add filter to admin UI (#413)

* fix: normalize AuDD scores + add filter to admin UI

- normalize scores from integer (0-100) to float (0.0-1.0) when storing
context, fixing the 0% display issue for potential matches
- add filter controls to admin UI: pending (default), resolved, all
- preserve current filter when resolving flags or refreshing
- add unit test for score normalization

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

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

* fix: show match count instead of misleading 0% scores

AuDD doesn't return confidence scores when using accurate_offsets mode
(which we use for timecode data). All scores were 0, showing as "0% match".

Changed to show "{N} matches" badge instead, which is accurate and useful.

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

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

---------

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

moderation/src/admin.rs

···
 //! Uses htmx for interactivity with server-rendered HTML.
 
 use axum::{
-    extract::State,
+    extract::{Query, State},
     http::header::CONTENT_TYPE,
     response::{IntoResponse, Response},
     Json,
···
     pub tracks: Vec<FlaggedTrack>,
 }
 
+/// Query parameters for listing flags.
+#[derive(Debug, Deserialize, Default)]
+pub struct ListFlagsQuery {
+    /// Filter: "pending" (default), "resolved", or "all"
+    #[serde(default = "default_filter")]
+    pub filter: String,
+}
+
+fn default_filter() -> String {
+    "pending".to_string()
+}
+
 /// Request to resolve (negate) a flag.
 #[derive(Debug, Deserialize)]
 pub struct ResolveRequest {
···
 /// List all flagged tracks - returns JSON for API, HTML for htmx.
 pub async fn list_flagged(
     State(state): State<AppState>,
+    Query(query): Query<ListFlagsQuery>,
 ) -> Result<Json<ListFlaggedResponse>, AppError> {
     let db = state.db.as_ref().ok_or(AppError::LabelerNotConfigured)?;
-    let tracks = db.get_pending_flags().await?;
+    let all_tracks = db.get_pending_flags().await?;
+    let tracks = filter_tracks(all_tracks, &query.filter);
     Ok(Json(ListFlaggedResponse { tracks }))
 }
 
 /// Render flags as HTML partial for htmx.
-pub async fn list_flagged_html(State(state): State<AppState>) -> Result<Response, AppError> {
+pub async fn list_flagged_html(
+    State(state): State<AppState>,
+    Query(query): Query<ListFlagsQuery>,
+) -> Result<Response, AppError> {
     let db = state.db.as_ref().ok_or(AppError::LabelerNotConfigured)?;
-    let tracks = db.get_pending_flags().await?;
+    let all_tracks = db.get_pending_flags().await?;
+    let tracks = filter_tracks(all_tracks, &query.filter);
 
-    let html = render_flags_list(&tracks);
+    let html = render_flags_list(&tracks, &query.filter);
 
     Ok(([(CONTENT_TYPE, "text/html; charset=utf-8")], html).into_response())
+}
+
+/// Filter tracks based on filter parameter.
+fn filter_tracks(tracks: Vec<FlaggedTrack>, filter: &str) -> Vec<FlaggedTrack> {
+    match filter {
+        "resolved" => tracks.into_iter().filter(|t| t.resolved).collect(),
+        "all" => tracks,
+        _ => tracks.into_iter().filter(|t| !t.resolved).collect(), // "pending" is default
+    }
 }
 
 /// Resolve (negate) a copyright flag, marking it as a false positive.
···
     Ok(([(CONTENT_TYPE, "text/html; charset=utf-8")], html).into_response())
 }
 
-/// Render the flags list as HTML.
-fn render_flags_list(tracks: &[FlaggedTrack]) -> String {
+/// Render the flags list as HTML with filter controls.
+fn render_flags_list(tracks: &[FlaggedTrack], current_filter: &str) -> String {
+    let pending_active = if current_filter == "pending" { " active" } else { "" };
+    let resolved_active = if current_filter == "resolved" { " active" } else { "" };
+    let all_active = if current_filter == "all" { " active" } else { "" };
+
+    let filter_buttons = format!(
+        "<div class=\"filter-row\">\
+            <span class=\"filter-label\">show:</span>\
+            <button type=\"button\" class=\"filter-btn{}\" hx-get=\"/admin/flags-html?filter=pending\" hx-target=\"#flags-list\">pending</button>\
+            <button type=\"button\" class=\"filter-btn{}\" hx-get=\"/admin/flags-html?filter=resolved\" hx-target=\"#flags-list\">resolved</button>\
+            <button type=\"button\" class=\"filter-btn{}\" hx-get=\"/admin/flags-html?filter=all\" hx-target=\"#flags-list\">all</button>\
+        </div>",
+        pending_active,
+        resolved_active,
+        all_active,
+    );
+
     if tracks.is_empty() {
-        return r#"<div class="empty">no flagged tracks</div>"#.to_string();
+        let empty_msg = match current_filter {
+            "pending" => "no pending flags",
+            "resolved" => "no resolved flags",
+            _ => "no flagged tracks",
+        };
+        return format!(
+            "{}<div class=\"empty\">{}</div>",
+            filter_buttons, empty_msg
+        );
     }
 
     let cards: Vec<String> = tracks.iter().map(render_flag_card).collect();
-    cards.join("\n")
+    format!("{}\n{}", filter_buttons, cards.join("\n"))
 }
 
 /// Extract namespace from AT URI (e.g., "fm.plyr.dev" from "at://did:plc:xxx/fm.plyr.dev.track/yyy")
···
         })
         .unwrap_or_default();
 
-    let score_badge = ctx
-        .and_then(|c| c.highest_score)
-        .filter(|&s| s > 0.0)
-        .map(|s| {
+    // Show match count instead of score (AuDD doesn't provide scores in accurate_offsets mode)
+    let match_count_badge = ctx
+        .and_then(|c| c.matches.as_ref())
+        .filter(|m| !m.is_empty())
+        .map(|matches| {
             format!(
-                r#"<span class="badge score">{}% match</span>"#,
-                (s * 100.0) as i32
+                r#"<span class="badge matches">{} matches</span>"#,
+                matches.len()
             )
         })
         .unwrap_or_default();
···
                 .map(|m| {
                     format!(
                         r#"<div class="match-item">
-                            <span><span class="title">{}</span> <span class="artist">by {}</span></span>
-                            <span class="score">{}%</span>
+                            <span class="title">{}</span> <span class="artist">by {}</span>
                         </div>"#,
                         html_escape(&m.title),
                         html_escape(&m.artist),
-                        (m.score * 100.0) as i32
                     )
                 })
                 .collect();
···
         track_info,
         html_escape(&track.uri),
         env_badge,
-        score_badge,
+        match_count_badge,
         status_badge,
         matches_html,
         action_button

moderation/src/handlers.rs

···
     "copyright-violation".to_string()
 }
 
+/// Normalize a score from integer (0-100) to float (0.0-1.0) range.
+/// AuDD returns scores as integers like 85 meaning 85%.
+fn normalize_score(score: f64) -> f64 {
+    if score > 1.0 {
+        score / 100.0
+    } else {
+        score
+    }
+}
+
 #[derive(Debug, Serialize)]
 pub struct EmitLabelResponse {
     pub seq: i64,
···
             track_title: ctx.track_title,
             artist_handle: ctx.artist_handle,
             artist_did: ctx.artist_did,
-            highest_score: ctx.highest_score,
-            matches: ctx.matches,
+            highest_score: ctx.highest_score.map(normalize_score),
+            matches: ctx.matches.map(|matches| {
+                matches
+                    .into_iter()
+                    .map(|mut m| {
+                        m.score = normalize_score(m.score);
+                        m
+                    })
+                    .collect()
+            }),
             resolution_reason: None,
             resolution_notes: None,
         };
···
 
     Ok(Json(EmitLabelResponse { seq, label }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_score() {
+        // Integer scores (0-100) should be converted to 0.0-1.0
+        assert!((normalize_score(85.0) - 0.85).abs() < 0.001);
+        assert!((normalize_score(100.0) - 1.0).abs() < 0.001);
+        assert!((normalize_score(50.0) - 0.5).abs() < 0.001);
+
+        // Scores already in 0.0-1.0 range should stay unchanged
+        assert!((normalize_score(0.85) - 0.85).abs() < 0.001);
+        assert!((normalize_score(1.0) - 1.0).abs() < 0.001);
+        assert!((normalize_score(0.5) - 0.5).abs() < 0.001);
+        assert!((normalize_score(0.0) - 0.0).abs() < 0.001);
+    }
+}

moderation/static/admin.css

···
     margin-bottom: 20px;
 }
 
+/* filter controls */
+.filter-row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 16px;
+    padding-bottom: 16px;
+    border-bottom: 1px solid var(--border-subtle);
+}
+
+.filter-label {
+    color: var(--text-tertiary);
+    font-size: 0.85rem;
+    margin-right: 4px;
+}
+
+.filter-btn {
+    font-family: inherit;
+    font-size: 0.8rem;
+    padding: 6px 12px;
+    border-radius: 4px;
+    border: 1px solid var(--border-default);
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: all 0.15s ease;
+}
+
+.filter-btn:hover {
+    background: var(--bg-hover);
+    border-color: var(--border-emphasis);
+    color: var(--text-primary);
+}
+
+.filter-btn.active {
+    background: var(--accent);
+    color: var(--bg-primary);
+    border-color: var(--accent);
+}
+
 .header-row h2 {
     margin: 0;
     font-size: 1.1rem;
···
     color: var(--success);
 }
 
-.badge.score {
-    background: rgba(239, 68, 68, 0.15);
-    color: var(--error);
+.badge.matches {
+    background: rgba(251, 191, 36, 0.15);
+    color: #fbbf24;
 }
 
 .badge.env {
···
 
 .match-item .artist {
     color: var(--text-tertiary);
-}
-
-.match-item .score {
-    color: var(--error);
-    font-weight: 500;
 }
 
 /* actions */

moderation/static/admin.html

···
     <div id="main-content" style="display: none;">
         <div class="header-row">
             <h2>flagged tracks</h2>
-            <button class="btn btn-secondary"
-                    hx-get="/admin/flags-html"
-                    hx-target="#flags-list"
-                    hx-indicator="#refresh-indicator">
-                <span id="refresh-indicator" class="htmx-indicator">...</span>
+            <button class="btn btn-secondary" onclick="refreshFlagsList()">
                 refresh
             </button>
         </div>
 
         <div id="flags-list" class="flags-list"
-             hx-get="/admin/flags-html"
-             hx-trigger="load, flagsUpdated from:body"
+             hx-get="/admin/flags-html?filter=pending"
+             hx-trigger="load"
              hx-indicator="#loading">
             <div id="loading" class="loading htmx-indicator">loading...</div>
         </div>

moderation/static/admin.js

···
 // Set up auth header listener first (before any htmx requests)
 let currentToken = null;
+let currentFilter = 'pending'; // track current filter state
 
 document.body.addEventListener('htmx:configRequest', function(evt) {
     if (currentToken) {
         evt.detail.headers['X-Moderation-Key'] = currentToken;
+    }
+});
+
+// Track filter changes via htmx
+document.body.addEventListener('htmx:afterRequest', function(evt) {
+    const url = evt.detail.pathInfo?.requestPath || '';
+    const match = url.match(/filter=(\w+)/);
+    if (match) {
+        currentFilter = match[1];
     }
 });
 
···
     })
     .then(response => {
         if (response.ok) {
-            // Trigger refresh of flags list
-            htmx.trigger('#flags-list', 'flagsUpdated');
             return response.text();
         }
         throw new Error('Failed to resolve');
···
         if (match) {
             showToast(match[0], 'success');
         }
+        // Refresh flags list with current filter
+        refreshFlagsList();
     })
     .catch(err => {
         showToast('failed to resolve: ' + err.message, 'error');
         cancelResolve(btn);
     });
+}
+
+// Refresh flags list preserving current filter
+function refreshFlagsList() {
+    htmx.ajax('GET', `/admin/flags-html?filter=${currentFilter}`, '#flags-list');
 }
 
 // Cancel: restore original button