Fix hanging thread issue by replacing parallel file discovery with sequential

- Replace ignore crate's build_parallel().run() with sequential builder.build()
- The parallel walker doesn't guarantee thread completion before returning
- Sequential discovery followed by parallel processing with rayon is more reliable
- Eliminates the hanging thread issue that prevented app termination
- Maintains performance through parallel file processing

Author: cursoragent

crates/scanner-core/src/lib.rs

@@ -803,57 +803,43 @@ impl<'a> Scanner<'a> {
             builder.threads(n.get());
         }
 
-        let out: Arc<Mutex<Vec<PathBuf>>> = Arc::new(Mutex::new(Vec::with_capacity(4096)));
-        let out_ref = out.clone();
-
-        builder.build_parallel().run(|| {
-            let out = out_ref.clone();
-            Box::new(move |res| {
-                let entry = match res {
-                    Ok(e) => e,
-                    Err(_) => return ignore::WalkState::Continue,
-                };
+        // Use sequential walker to collect all paths (this guarantees completion)
+        let mut discovered_paths = Vec::new();
+        
+        for result in builder.build() {
+            let entry = match result {
+                Ok(e) => e,
+                Err(_) => continue,
+            };
 
-                if let Some(ft) = entry.file_type() {
-                    if !ft.is_file() {
-                        return ignore::WalkState::Continue;
-                    }
-                } else if let Ok(md) = entry.metadata() {
-                    if !md.is_file() {
-                        return ignore::WalkState::Continue;
-                    }
-                } else {
-                    return ignore::WalkState::Continue;
+            if let Some(ft) = entry.file_type() {
+                if !ft.is_file() {
+                    continue;
                 }
-
-                let path = entry.into_path();
-                if !path_allowed(&path) {
-                    return ignore::WalkState::Continue;
+            } else if let Ok(md) = entry.metadata() {
+                if !md.is_file() {
+                    continue;
                 }
+            } else {
+                continue;
+            }
 
-                if let Ok(md) = fs::metadata(&path) {
-                    if (md.len() as usize) > self.config.max_file_size {
-                        return ignore::WalkState::Continue;
-                    }
-                } else {
-                    return ignore::WalkState::Continue;
-                }
+            let path = entry.into_path();
+            if !path_allowed(&path) {
+                continue;
+            }
 
-                if let Ok(mut guard) = out.lock() {
-                    guard.push(path);
+            if let Ok(md) = fs::metadata(&path) {
+                if (md.len() as usize) > self.config.max_file_size {
+                    continue;
                 }
+            } else {
+                continue;
+            }
 
-                ignore::WalkState::Continue
-            })
-        });
+            discovered_paths.push(path);
+        }
 
-        let drained: Vec<PathBuf> = {
-            match out.lock() {
-                Ok(mut guard) => guard.drain(..).collect(),
-                Err(_) => Vec::new(),
-            }
-        };
-        discovered_paths.extend(drained);
         discovered_paths
     }