fix(watcher): return original tracks on filter_removed_tracks error

Change filter_removed_tracks to return the original Vec alongside the
DbError so callers can fall back to unfiltered insertion. Previously the
function consumed the vec via into_iter(), making it unavailable on
error, causing the watcher to drop all new tracks instead of proceeding
unfiltered.

Refs: TASK-292, roborev job #29

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pythoninthegrass

backlog/tasks/task-292 - Fix-watcher-error-path-dropping-new-tracks-instead-of-proceeding-unfiltered.md

@@ -1,9 +1,10 @@
 ---
 id: TASK-292
 title: Fix watcher error path dropping new tracks instead of proceeding unfiltered
-status: To Do
+status: In Progress
 assignee: []
 created_date: '2026-02-26 00:10'
+updated_date: '2026-02-26 16:05'
 labels:
   - bug
   - roborev

crates/mt-tauri/src/db/removed.rs

@@ -6,7 +6,9 @@
 use rusqlite::{Connection, params};
 use std::collections::HashSet;
 
-use crate::db::DbResult;
+use crate::db::{DbError, DbResult};
+
+type TrackVec = Vec<(String, crate::db::TrackMetadata)>;
 
 /// Record a track removal by filepath and optional content hash.
 /// Uses INSERT OR REPLACE so re-removing the same filepath just updates the timestamp.
@@ -93,12 +95,21 @@ pub(crate) fn clear_all_removals(conn: &Connection) -> DbResult<usize> {
 /// Filter a list of `(filepath, TrackMetadata)` pairs, removing any that match
 /// previously-removed filepaths or content hashes. Returns the filtered vec and
 /// the number of tracks that were skipped.
+///
+/// On DB errors, the original `tracks` vec is returned alongside the error so
+/// the caller can fall back to unfiltered insertion.
 pub(crate) fn filter_removed_tracks(
     conn: &Connection,
-    tracks: Vec<(String, crate::db::TrackMetadata)>,
-) -> DbResult<(Vec<(String, crate::db::TrackMetadata)>, usize)> {
-    let removed_paths = get_removed_filepaths(conn)?;
-    let removed_hashes = get_removed_content_hashes(conn)?;
+    tracks: TrackVec,
+) -> Result<(TrackVec, usize), (DbError, TrackVec)> {
+    let removed_paths = match get_removed_filepaths(conn) {
+        Ok(v) => v,
+        Err(e) => return Err((e, tracks)),
+    };
+    let removed_hashes = match get_removed_content_hashes(conn) {
+        Ok(v) => v,
+        Err(e) => return Err((e, tracks)),
+    };
 
     if removed_paths.is_empty() && removed_hashes.is_empty() {
         return Ok((tracks, 0));
@@ -456,4 +467,26 @@ mod tests {
         let info = get_track_removal_info_bulk(&conn, &[]).unwrap();
         assert!(info.is_empty());
     }
+
+    #[test]
+    fn test_filter_removed_tracks_returns_tracks_on_error() {
+        use crate::db::TrackMetadata;
+
+        // Use a closed connection to force a DB error.
+        let conn = setup_test_db();
+        conn.execute_batch("DROP TABLE removed_tracks").unwrap();
+
+        let tracks = vec![
+            ("/music/a.mp3".to_string(), TrackMetadata::default()),
+            ("/music/b.mp3".to_string(), TrackMetadata::default()),
+        ];
+
+        let result = filter_removed_tracks(&conn, tracks);
+        assert!(result.is_err());
+
+        let (_, returned_tracks) = result.unwrap_err();
+        assert_eq!(returned_tracks.len(), 2);
+        assert_eq!(returned_tracks[0].0, "/music/a.mp3");
+        assert_eq!(returned_tracks[1].0, "/music/b.mp3");
+    }
 }

crates/mt-tauri/src/scanner/commands.rs

@@ -261,8 +261,8 @@ pub(crate) async fn scan_paths_to_library(
     // Filter out tracks that the user has previously removed from the library.
     let truly_new = {
         let conn = db.conn().map_err(|e| e.to_string())?;
-        let (filtered, skipped) =
-            removed::filter_removed_tracks(&conn, truly_new).map_err(|e| e.to_string())?;
+        let (filtered, skipped) = removed::filter_removed_tracks(&conn, truly_new)
+            .map_err(|(e, _tracks)| e.to_string())?;
         if skipped > 0 {
             info!(skipped, "Skipped previously removed tracks during scan");
         }

crates/mt-tauri/src/watcher.rs

@@ -635,11 +635,9 @@ impl WatcherManager {
                     }
                     filtered
                 }
-                Err(e) => {
+                Err((e, unfiltered)) => {
                     error!(folder_id, error = %e, "Failed to filter removed tracks, proceeding unfiltered");
-                    // filter_removed_tracks consumed truly_new but failed before
-                    // filtering; tracks on disk will be picked up on next scan cycle.
-                    vec![]
+                    unfiltered
                 }
             },
             Err(e) => {