fix(api): rescore release decks at read time

GET .../releases returned the stored score column, frozen at
search time. Policy tuning never reached an existing deck. Recompute
from parsed/size/seeders against the current policy and re-sort by
bucket then score; the stored column stays for the daemon's grab-time
winner pick.

Closes #114

crates/arr-api/src/movies.rs

@@ -1,3 +1,6 @@
+use arr_core::policy::Candidate;
+use arr_core::score::score;
+use arr_core::{ParsedRelease, Policy};
 use axum::extract::{Path, Query, State};
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
@@ -503,12 +506,58 @@ pub async fn releases(
     Path(id): Path<i64>,
 ) -> Result<Json<Vec<Release>>, ApiError> {
     load_movie(&state, id).await?;
-    let releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN movie_releases mr ON mr.release_id = r.id WHERE mr.movie_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id)
+    let mut releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN movie_releases mr ON mr.release_id = r.id WHERE mr.movie_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id)
     .fetch_all(pool(&state)?)
     .await?;
+    let policy = state
+        .database()
+        .ok_or(ApiError::Unavailable)?
+        .movie_policy(id)
+        .await
+        .map_err(|error| ApiError::Database(error.to_string()))?
+        .ok_or(ApiError::NotFound)?
+        .policy;
+    rescore(&mut releases, &policy)?;
     Ok(Json(releases))
 }
 
+/// Recompute each release's score against the current policy and re-sort
+/// (`DESIGN.md` §5.5). The stored `score` column is grab-time truth for the
+/// daemon's winner pick; the deck the user sees must reflect policy tuning
+/// made since the release was last searched, not whatever was true then.
+///
+/// Score magnitudes stay far below `f64`'s 52-bit mantissa (they are sums of
+/// policy weights in the thousands), so the `i64` -> `f64` cast into the
+/// column's storage type is exact.
+#[allow(clippy::cast_precision_loss)]
+pub(crate) fn rescore(releases: &mut [Release], policy: &Policy) -> Result<(), ApiError> {
+    let mut totals = Vec::with_capacity(releases.len());
+    for release in releases.iter() {
+        let parsed: ParsedRelease = serde_json::from_value(release.parsed.clone())
+            .map_err(|error| ApiError::Database(error.to_string()))?;
+        let seeders = u32::try_from(release.seeders.unwrap_or(0)).unwrap_or(u32::MAX);
+        let size = u64::try_from(release.size).unwrap_or(0);
+        totals.push(score(policy, Candidate::PreGrab(&parsed), size, seeders).total);
+    }
+    let mut indices: Vec<usize> = (0..releases.len()).collect();
+    indices.sort_by_key(|&i| (bucket(releases[i].verdict.as_deref()), -totals[i]));
+
+    for (release, &total) in releases.iter_mut().zip(&totals) {
+        release.score = Some(total as f64);
+    }
+    let sorted: Vec<Release> = indices.into_iter().map(|i| releases[i].clone()).collect();
+    releases.clone_from_slice(&sorted);
+    Ok(())
+}
+
+fn bucket(verdict: Option<&str>) -> u8 {
+    match verdict {
+        Some("eligible") => 0,
+        Some("waived") => 1,
+        _ => 2,
+    }
+}
+
 #[utoipa::path(
     get, path = "/api/movies/{movie_id}/files", tag = "movies",
     params(("movie_id" = i64, Path, description = "Movie row id")),
@@ -956,6 +1005,71 @@ mod tests {
         );
     }
 
+    /// #114: a deck must score against the current policy, not whatever the
+    /// score was when the release was last searched — tuning must reach what
+    /// the user sees without a re-search.
+    #[tokio::test]
+    async fn the_deck_rescores_against_the_current_policy_not_the_stored_score() {
+        let (_dir, state, base) = application().await;
+        let movie = add_movie(&base, 693_134, 1).await;
+        let movie_id = movie["id"].as_i64().expect("id");
+        let pool = state.database().expect("database").pool();
+
+        let name = "Dune Part Two 2024 1080p BluRay x264-GROUP";
+        let parsed = arr_parse::parse(name);
+        let size_bytes: u64 = 20 * (1 << 30);
+        let seeders: u32 = 50;
+        let size: i64 = i64::try_from(size_bytes).expect("size fits i64");
+
+        let release_id = sqlx::query(
+            "INSERT INTO releases (indexer_id, guid, name, size, seeders, download_url, parsed, score, verdict)
+             VALUES (7, 'guid', ?, ?, ?, 'url', ?, -12345, 'eligible')",
+        )
+        .bind(name)
+        .bind(size)
+        .bind(i64::from(seeders))
+        .bind(serde_json::to_string(&parsed).expect("parsed json"))
+        .execute(pool)
+        .await
+        .expect("release")
+        .last_insert_rowid();
+        sqlx::query("INSERT INTO movie_releases (movie_id, release_id) VALUES (?, ?)")
+            .bind(movie_id)
+            .bind(release_id)
+            .execute(pool)
+            .await
+            .expect("association");
+
+        let policy = state
+            .database()
+            .expect("database")
+            .movie_policy(movie_id)
+            .await
+            .expect("policy")
+            .expect("movie has a policy")
+            .policy;
+        let expected = arr_core::score::score(
+            &policy,
+            arr_core::policy::Candidate::PreGrab(&parsed),
+            size_bytes,
+            seeders,
+        )
+        .total;
+        #[allow(clippy::cast_precision_loss)]
+        let expected = expected as f64;
+
+        let releases: Vec<serde_json::Value> =
+            reqwest::get(format!("{base}/api/movies/{movie_id}/releases"))
+                .await
+                .expect("releases")
+                .json()
+                .await
+                .expect("release json");
+
+        assert_ne!(releases[0]["score"].as_f64(), Some(-12345.0));
+        assert_eq!(releases[0]["score"].as_f64(), Some(expected));
+    }
+
     #[tokio::test]
     async fn a_full_action_queue_returns_service_unavailable() {
         let (_dir, state, base) = application().await;

crates/arr-api/src/series.rs

@@ -29,7 +29,7 @@ use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
 use serde::{Deserialize, Serialize};
 use utoipa::{IntoParams, ToSchema};
 
-use crate::movies::{pool, Accepted, ApiError, ErrorBody, Release};
+use crate::movies::{pool, rescore, Accepted, ApiError, ErrorBody, Release};
 use crate::owners::Owner;
 use crate::state::{AppState, EpisodeCommand};
 
@@ -844,9 +844,18 @@ pub async fn episode_releases(
     Path(id): Path<i64>,
 ) -> Result<Json<Vec<Release>>, ApiError> {
     load_episode(&state, id).await?;
-    let releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN episode_releases er ON er.release_id = r.id WHERE er.episode_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id)
+    let mut releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN episode_releases er ON er.release_id = r.id WHERE er.episode_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id)
         .fetch_all(pool(&state)?)
         .await?;
+    let policy = state
+        .database()
+        .ok_or(ApiError::Unavailable)?
+        .episode_policy(id)
+        .await
+        .map_err(|error| ApiError::Database(error.to_string()))?
+        .ok_or(ApiError::EpisodeNotFound)?
+        .policy;
+    rescore(&mut releases, &policy)?;
     Ok(Json(releases))
 }