Retry failed fetcher rows during updates

crates/osu_fetcher/README.md

@@ -70,7 +70,7 @@ editing the file.
 | `download` | Runs a bounded greedy worker pool. Each idle worker claims the next `pending wanted` row in `set_id` order and cycles mirrors per-set. See **Failure modes** below for the resilience guarantees. |
 | `status` | Prints `wanted / pending / in_progress / success / failed / missing` counts. |
 | `verify` | Walks `--archives-dir`, validates every `.osz`. With `--fix`, marks corrupt rows back to pending. |
-| `retry` | Resets every `failed` and `missing` row back to `pending` so the next download run will retry. |
+| `retry` | Resets `failed` rows back to `pending` so the next download run will retry. Pass `--include-missing` to also retry rows that every mirror reported absent. |
 
 ## Global flags
 
@@ -174,10 +174,9 @@ State machine (per `set_id`):
                                   (every mirror returned 404)
 ```
 
-`retry` flips `{failed, missing}` back to `pending`. `requeue_in_progress`
-fires at the start of every `download` run (and also on `enumerate`'s
-startup as a safety net) to recover orphaned claims from a crashed prior
-run.
+`retry` flips `failed` back to `pending`. `retry --include-missing` also
+resets `missing`. `requeue_in_progress` fires at the start of every
+`download` run to recover orphaned claims from a crashed prior run.
 
 ## Failure modes
 
@@ -234,7 +233,8 @@ touch disk.
   `failed` to `missing` (so you can distinguish "transient" from "no mirror
   has this anymore").
 - 5xx / network: pool advances. The row counts a regular `failed` and gets
-  `attempts` incremented. Run `retry` later to reset.
+  `attempts` incremented. The update wrapper runs `retry` before download, so
+  the next normal update tries it again.
 - 429: same as 5xx for outcome — but the per-mirror rate limiter holds the
   next call back automatically, so you don't need to babysit it.
 - Final failure logs include the full attempted mirror chain, for example
@@ -382,10 +382,10 @@ Coverage:
 - **Long runs**: tail the lockfile path printed by `download begin` to see
   the active PID. Ctrl-C is responsive even mid-flight.
 - **Disk full**: workers fail individual sets, the run continues. Free
-  space and run `retry` to drain the failed bucket.
+  space and rerun the update wrapper to drain the failed bucket.
 - **Permanently missing maps** (DMCA / mapper deletions on every mirror):
-  they accumulate in `missing`. Tolerated; not retried by `download` until
-  you `retry` them explicitly.
+  they accumulate in `missing`. Tolerated; not retried by normal updates
+  unless you run `retry --include-missing` or set `RETRY_MISSING=1`.
 - **Rate-limit tuning**: if a mirror op asks you to slow down, lower
   `--<name>-rpm`. The update wrapper passes `480` rpm by default for every
   fetcher target.

crates/osu_fetcher/src/main.rs

@@ -158,7 +158,7 @@ enum Cmd {
     /// Validate every `.osz` in archives_dir; report corrupt files.
     Verify(VerifyArgs),
 
-    /// Reset failed/missing rows back to pending so the next download retries them.
+    /// Reset failed rows back to pending so the next download retries them.
     Retry(RetryArgs),
 
     /// Walk every mirror's search surface and cross-verify candidates.
@@ -262,7 +262,11 @@ struct VerifyArgs {
 }
 
 #[derive(clap::Args, Debug)]
-struct RetryArgs {}
+struct RetryArgs {
+    /// Also retry rows that every mirror reported absent.
+    #[arg(long)]
+    include_missing: bool,
+}
 
 #[derive(clap::Args, Debug)]
 struct DiscoverArgs {
@@ -342,7 +346,7 @@ async fn main() -> Result<()> {
 
     match &cli.cmd {
         Cmd::Status => cmd_status(state),
-        Cmd::Retry(_) => cmd_retry(state),
+        Cmd::Retry(args) => cmd_retry(state, args),
         Cmd::Verify(args) => {
             cmd_verify(state, &cli.archives_dir, args, progress_enabled(&cli)).await
         }
@@ -416,9 +420,13 @@ fn cmd_status(state: Arc<StateDb>) -> Result<()> {
     Ok(())
 }
 
-fn cmd_retry(state: Arc<StateDb>) -> Result<()> {
-    let n = state.reset_failed_to_pending()?;
-    println!("reset {n} failed/missing rows back to pending");
+fn cmd_retry(state: Arc<StateDb>, args: &RetryArgs) -> Result<()> {
+    let n = state.reset_failed_to_pending(args.include_missing)?;
+    if args.include_missing {
+        println!("reset {n} failed/missing rows back to pending");
+    } else {
+        println!("reset {n} failed rows back to pending");
+    }
     Ok(())
 }
 

crates/osu_fetcher/src/state.rs

@@ -43,8 +43,8 @@ pub const SCHEMA_VERSION: i64 = 2;
 /// `pending` rows are eligible for download workers. `in_progress` is held
 /// only while a worker is actively fetching; on startup, any leftover
 /// `in_progress` is reset to `pending` so a crashed worker doesn't strand its
-/// claim. Terminal states (`success`, `failed`, `missing`) require explicit
-/// user action (e.g. `retry`) to re-enter the queue.
+/// claim. Failed rows are retried by the update wrapper; missing rows require
+/// explicit user action because every mirror already agreed they were absent.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum DownloadStatus {
     Pending,
@@ -448,15 +448,20 @@ impl StateDb {
         Ok(())
     }
 
-    /// Reset terminal failed/missing rows back to pending so the next
-    /// `download` run will retry them. Returns the count moved.
-    pub fn reset_failed_to_pending(&self) -> Result<u64> {
+    /// Reset failed rows back to pending so the next `download` run retries
+    /// them. Returns the count moved.
+    pub fn reset_failed_to_pending(&self, include_missing: bool) -> Result<u64> {
         let conn = self.lock();
-        let n = conn.execute(
+        let predicate = if include_missing {
+            "download_status IN ('failed', 'missing')"
+        } else {
+            "download_status = 'failed'"
+        };
+        let sql = format!(
             "UPDATE sets SET download_status = 'pending', last_error = NULL
-             WHERE download_status IN ('failed', 'missing')",
-            [],
-        )?;
+             WHERE {predicate}"
+        );
+        let n = conn.execute(&sql, [])?;
         Ok(n as u64)
     }
 
@@ -915,6 +920,73 @@ mod tests {
         assert_eq!(counts.pending, 0);
     }
 
+    #[test]
+    fn retry_resets_failed_without_requeueing_missing_by_default() {
+        let db = StateDb::open_memory().unwrap();
+        db.upsert_wanted(&WantedRow {
+            set_id: 1,
+            ranked_status: RankedStatus::Ranked,
+            artist: None,
+            title: None,
+            creator: None,
+            api_last_updated: Some("2026-01-01T00:00:00Z"),
+        })
+        .unwrap();
+        db.upsert_wanted(&WantedRow {
+            set_id: 2,
+            ranked_status: RankedStatus::Ranked,
+            artist: None,
+            title: None,
+            creator: None,
+            api_last_updated: Some("2026-01-01T00:00:00Z"),
+        })
+        .unwrap();
+
+        db.finish_failed(&DownloadFailure {
+            set_id: 1,
+            mirror: "m",
+            error: "transient",
+        })
+        .unwrap();
+        db.finish_missing(&DownloadFailure {
+            set_id: 2,
+            mirror: "m",
+            error: "absent",
+        })
+        .unwrap();
+
+        assert_eq!(db.reset_failed_to_pending(false).unwrap(), 1);
+        let counts = db.status_counts().unwrap();
+        assert_eq!(counts.pending, 1);
+        assert_eq!(counts.failed, 0);
+        assert_eq!(counts.missing, 1);
+    }
+
+    #[test]
+    fn retry_can_include_missing_when_requested() {
+        let db = StateDb::open_memory().unwrap();
+        db.upsert_wanted(&WantedRow {
+            set_id: 1,
+            ranked_status: RankedStatus::Ranked,
+            artist: None,
+            title: None,
+            creator: None,
+            api_last_updated: Some("2026-01-01T00:00:00Z"),
+        })
+        .unwrap();
+        db.finish_missing(&DownloadFailure {
+            set_id: 1,
+            mirror: "m",
+            error: "absent",
+        })
+        .unwrap();
+
+        assert_eq!(db.reset_failed_to_pending(true).unwrap(), 1);
+        let counts = db.status_counts().unwrap();
+        assert_eq!(counts.pending, 1);
+        assert_eq!(counts.missing, 0);
+    }
+
     #[test]
     fn claim_next_pending_returns_lowest_id() {
         let db = StateDb::open_memory().unwrap();

docs/PIPELINE_RUNBOOK.md

@@ -68,6 +68,8 @@ DISCOVER=1             # run mirror discovery; slower, useful periodically
 RANKED_FRONT_PAGES=10  # widen the ranked-desc front scan
 CLEAN_INPUT=0          # keep incoming_osz after success
 DOWNLOAD_CONCURRENCY=8 # number of greedy download workers
+RETRY_FAILED=1         # retry previously failed acquisitions before download; default is on
+RETRY_MISSING=0        # also retry known-missing rows; default is off
 COMPACT=1              # compact all_revisions after ingest; default is on
 COMPACT_TARGET_ROWS=1000000 # target rows per compacted all_revisions file
 COMPACT_WORKERS=4      # parallel table compaction workers
@@ -242,6 +244,9 @@ PY
 
 If fetch/download is interrupted, rerun `scripts/update_maps_v1.sh`. The
 fetcher state DB requeues stale `in_progress` rows on the next download run.
+The update wrapper also retries previously failed acquisitions by default.
+Rows that all mirrors reported absent are left alone unless you set
+`RETRY_MISSING=1`.
 
 If ingest is interrupted, rerun the same script with a fresh `BATCH_ID`.
 Committed archives are skipped by SHA-256. An incomplete chunk has no

scripts/update_maps_v1.sh

@@ -24,6 +24,8 @@ MODE="${MODE:-0}"
 RANKED_FRONT_PAGES="${RANKED_FRONT_PAGES:-5}"
 DOWNLOAD_CONCURRENCY="${DOWNLOAD_CONCURRENCY:-16}"
 DOWNLOAD_LIMIT="${DOWNLOAD_LIMIT:-}"
+RETRY_FAILED="${RETRY_FAILED:-1}"
+RETRY_MISSING="${RETRY_MISSING:-0}"
 NDJSON_PARSE_WORKERS="${NDJSON_PARSE_WORKERS:-1}"
 NDJSON_PARSE_CHUNK_MB="${NDJSON_PARSE_CHUNK_MB:-8}"
 COMPACT="${COMPACT:-1}"
@@ -93,6 +95,8 @@ echo "upload=${UPLOAD}"
 echo "fetcher_progress=${FETCHER_PROGRESS}"
 echo "fetcher_rpm=${FETCHER_RPM}"
 echo "discover_search_rpm=${DISCOVER_SEARCH_RPM}"
+echo "retry_failed=${RETRY_FAILED}"
+echo "retry_missing=${RETRY_MISSING}"
 echo "compact=${COMPACT}"
 echo "compact_target_rows=${COMPACT_TARGET_ROWS}"
 echo "compact_batch_size=${COMPACT_BATCH_SIZE}"
@@ -205,8 +209,12 @@ if [ "$FETCH" = "1" ]; then
     "$FETCHER" "${fetcher_args[@]}" discover "${discover_args[@]}"
   fi
 
-  if [ "${RETRY_FAILED:-0}" = "1" ]; then
-    "$FETCHER" "${fetcher_args[@]}" retry
+  if [ "$RETRY_FAILED" = "1" ]; then
+    retry_args=()
+    if [ "$RETRY_MISSING" = "1" ]; then
+      retry_args+=(--include-missing)
+    fi
+    "$FETCHER" "${fetcher_args[@]}" retry "${retry_args[@]}"
   fi
 
   "$FETCHER" "${fetcher_args[@]}" status