sweep/2026-09-22: 3-cycle maintenance sweep

.gitignore

@@ -2,3 +2,5 @@
 /dist
 .superpowers/
 .DS_Store
+.omc/
+.wrangler/

src/cleanup.rs

@@ -72,11 +72,6 @@ pub fn classify(path: &Path) -> Option<(&'static str, &'static str)> {
             "Docker Desktop Data",
             "Docker images, volumes, build cache. Prefer `docker system prune -a` for finer-grained cleanup.",
         ),
-        (
-            "Library/Containers/com.apple.iCloud.iCloudDrive",
-            "iCloud Drive evictable cache",
-            "Local cache of iCloud-stored files. Files reload from iCloud on next access.",
-        ),
         (
             ".cargo/registry",
             "Cargo registry cache",
@@ -89,7 +84,9 @@ pub fn classify(path: &Path) -> Option<(&'static str, &'static str)> {
         ),
     ];
     for &(suffix, label, desc) in SUFFIX_RULES {
-        if s.ends_with(suffix) {
+        // Require a path-component boundary: either the path IS the suffix or
+        // it ends with /<suffix>, preventing "MyLibrary/Caches" matching "Library/Caches".
+        if s == suffix || s.ends_with(&format!("/{suffix}")) {
             return Some((label, desc));
         }
     }
@@ -111,17 +108,17 @@ pub fn classify(path: &Path) -> Option<(&'static str, &'static str)> {
             )),
             ".gradle" => Some((
                 "Gradle caches",
-                "Gradle redownloads dependencies on next build.",
+                "Gradle redownloads dependencies on next build. Warning: gradle.properties (which may hold credentials) will also be deleted.",
             )),
             ".m2" => Some((
                 "Maven local repo",
-                "Maven local artifacts cache; rebuilt on next dependency resolve.",
+                "Maven cache — settings.xml (credentials) will also be deleted.",
             )),
             "DerivedData" => Some((
                 "DerivedData (loose)",
                 "Xcode build artifacts found outside the standard location.",
             )),
-            "target" => Some((
+            "target" if path.parent().map(|p| p.join("Cargo.toml").exists()).unwrap_or(false) => Some((
                 "Rust target/",
                 "`cargo build` recreates these. Often the largest single dir on a Rust dev machine.",
             )),
@@ -137,10 +134,6 @@ pub fn classify(path: &Path) -> Option<(&'static str, &'static str)> {
                 ".cache directories",
                 "App- and tool-specific caches. Generally regenerable.",
             )),
-            ".Trash" | ".Trashes" => Some((
-                "Trash",
-                "Files in the macOS Trash. Empty when you're sure you don't need them.",
-            )),
             _ => None,
         };
     }
@@ -157,6 +150,48 @@ pub fn find_candidates(tree: &FileTree, root: NodeId) -> Vec<CleanupCandidate> {
     candidates
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn cargo_target_with_cargo_toml_is_classified() {
+        let dir = std::env::temp_dir().join("mac_dir_stat_test_cargo");
+        fs::create_dir_all(&dir).unwrap();
+        fs::write(dir.join("Cargo.toml"), "[package]").unwrap();
+        let target = dir.join("target");
+        let (cat, _) = classify(&target).expect("should classify");
+        assert_eq!(cat, "Rust target/");
+        fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn target_without_cargo_toml_is_not_classified() {
+        let dir = std::env::temp_dir().join("mac_dir_stat_test_notcargo");
+        fs::create_dir_all(&dir).unwrap();
+        // No Cargo.toml in parent
+        let target = dir.join("target");
+        assert!(classify(&target).is_none(), "should not classify without Cargo.toml");
+        fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn library_caches_is_classified() {
+        let path = std::path::Path::new("/Users/someone/Library/Caches");
+        let (cat, _) = classify(path).expect("should classify");
+        assert_eq!(cat, "Application Caches");
+    }
+
+    #[test]
+    fn gradle_description_warns_about_credentials() {
+        let path = std::path::Path::new("/Users/someone/.gradle");
+        let (_, desc) = classify(path).expect("should classify");
+        assert!(desc.contains("credentials") || desc.contains("gradle.properties"),
+            "description should warn about credentials");
+    }
+}
+
 fn walk(tree: &FileTree, id: NodeId, out: &mut Vec<CleanupCandidate>) {
     if !tree.is_alive(id) {
         return;

src/flywheel.rs

@@ -72,11 +72,12 @@ pub fn telemetry_opted_out() -> bool {
     ) {
         return true;
     }
+    // Absent file = opted out; only "enabled" written by explicit opt-in counts.
     state_dir()
         .map(|d| d.join("telemetry.txt"))
         .and_then(|p| std::fs::read_to_string(p).ok())
-        .map(|s| s.trim() == "disabled")
-        .unwrap_or(false)
+        .map(|s| s.trim() != "enabled")
+        .unwrap_or(true)
 }
 
 /// Persist the user's telemetry choice so it survives restarts.
@@ -85,10 +86,12 @@ pub fn set_telemetry_opt_out(opted_out: bool) {
     if std::fs::create_dir_all(&dir).is_err() {
         return;
     }
-    let _ = std::fs::write(
+    if let Err(e) = std::fs::write(
         dir.join("telemetry.txt"),
         if opted_out { "disabled" } else { "enabled" },
-    );
+    ) {
+        eprintln!("mac-dir-stat: failed to persist telemetry choice: {e}");
+    }
 }
 
 /// 16 random bytes from `/dev/urandom`, or a time-seeded fallback.
@@ -385,6 +388,14 @@ mod tests {
         assert!(!fw.is_enabled());
     }
 
+    #[test]
+    fn no_telemetry_env_var_opts_out() {
+        // Safe: no other test touches MACDIRSTAT_NO_TELEMETRY.
+        std::env::set_var("MACDIRSTAT_NO_TELEMETRY", "1");
+        assert!(telemetry_opted_out(), "MACDIRSTAT_NO_TELEMETRY=1 should opt out");
+        std::env::remove_var("MACDIRSTAT_NO_TELEMETRY");
+    }
+
     #[test]
     fn taxonomy_matches_ts_client() {
         assert!(TAXONOMY.contains(&"conversion"));

src/platform/trash.rs

@@ -5,19 +5,18 @@ pub fn move_to_trash(path: &Path) -> Result<(), String> {
     trash::delete(path).map_err(|e| format!("Failed to move to trash: {}", e))
 }
 
-/// Empties the user's Trash via Finder. We've already shown our own
-/// confirmation, so we use `without warning` to skip Finder's.
+/// Empties the user's Trash via Finder in a background thread so the UI
+/// frame is not blocked while Finder moves files.
 pub fn empty_trash() -> Result<(), String> {
-    let status = Command::new("osascript")
+    Command::new("osascript")
         .args([
             "-e",
             "tell application \"Finder\" to empty trash without warning",
         ])
-        .status()
-        .map_err(|e| format!("osascript failed to start: {}", e))?;
-    if status.success() {
-        Ok(())
-    } else {
-        Err(format!("osascript exited with status {}", status))
-    }
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .spawn()
+        .map(|_| ())
+        .map_err(|e| format!("osascript failed to start: {}", e))
 }

src/scanner/tree.rs

@@ -13,9 +13,6 @@ pub struct StrRef {
     len: u32,
 }
 
-impl StrRef {
-    pub const EMPTY: StrRef = StrRef { offset: 0, len: 0 };
-}
 
 /// Bump arena holding raw bytes for all node names + extensions.
 /// One contiguous `Vec<u8>` instead of millions of small heap allocs.
@@ -86,10 +83,6 @@ impl Node {
         matches!(self.kind, NodeKind::Directory { .. })
     }
 
-    pub fn is_file(&self) -> bool {
-        matches!(self.kind, NodeKind::File { .. })
-    }
-
     pub fn children(&self) -> &[NodeId] {
         match &self.kind {
             NodeKind::Directory { children, .. } => children,
@@ -221,14 +214,17 @@ impl FileTree {
         id
     }
 
-    pub fn node_count(&self) -> usize {
-        self.nodes.iter().filter(|n| n.alive).count()
-    }
-
-    /// Aggregate a directory's `size`, `file_count` and `subdir_count` from its
+    /// Recompute a directory's `size`, `file_count` and `subdir_count` from its
     /// direct children. Requires the children's own counts to already be
     /// correct (true in a bottom-up reverse pass and after grafting).
-    fn aggregate_dir(&self, id: NodeId) -> (u64, u64, u64) {
+    fn aggregate_dir(&mut self, id: NodeId) {
+        let (size, files, dirs) = self.child_totals(id);
+        self.nodes[id].size = size;
+        self.nodes[id].file_count = files;
+        self.nodes[id].subdir_count = dirs;
+    }
+
+    fn child_totals(&self, id: NodeId) -> (u64, u64, u64) {
         let mut size = 0u64;
         let mut files = 0u64;
         let mut dirs = 0u64;
@@ -257,10 +253,7 @@ impl FileTree {
             if !self.nodes[i].alive || !self.nodes[i].is_dir() {
                 continue;
             }
-            let (size, files, dirs) = self.aggregate_dir(i);
-            self.nodes[i].size = size;
-            self.nodes[i].file_count = files;
-            self.nodes[i].subdir_count = dirs;
+            self.aggregate_dir(i);
         }
     }
 
@@ -293,16 +286,17 @@ impl FileTree {
             current = self.nodes[pid].parent;
         }
 
-        self.mark_dead_recursive(id);
+        self.mark_descendants_dead(id);
     }
 
-    fn mark_dead_recursive(&mut self, id: NodeId) {
-        if let NodeKind::Directory { ref children, .. } = self.nodes[id].kind {
-            let child_ids: Vec<NodeId> = children.clone();
-            for child in child_ids {
-                self.nodes[child].alive = false;
-                self.mark_dead_recursive(child);
-            }
+    /// Marks every descendant of `id` dead. The node itself is untouched and
+    /// children lists are left intact. Iterative — directory trees can be
+    /// deeper than the stack tolerates.
+    fn mark_descendants_dead(&mut self, id: NodeId) {
+        let mut stack: Vec<NodeId> = self.nodes[id].children().to_vec();
+        while let Some(child) = stack.pop() {
+            self.nodes[child].alive = false;
+            stack.extend_from_slice(self.nodes[child].children());
         }
     }
 
@@ -368,52 +362,31 @@ impl FileTree {
         }
     }
 
-    pub fn collect_files(&self, root: NodeId) -> Vec<NodeId> {
-        let mut files = vec![];
-        self.collect_files_recursive(root, &mut files);
-        files
+    pub fn is_alive(&self, id: NodeId) -> bool {
+        if id >= self.nodes.len() {
+            return false;
+        }
+        self.nodes[id].alive
     }
 
-    fn collect_files_recursive(&self, id: NodeId, files: &mut Vec<NodeId>) {
-        let node = &self.nodes[id];
-        if !node.alive {
-            return;
+    /// The directory a node belongs to: the node itself when it's a directory,
+    /// otherwise its parent. `None` for dead or out-of-range ids.
+    pub fn dir_of(&self, id: NodeId) -> Option<NodeId> {
+        if !self.is_alive(id) {
+            return None;
         }
-        match &node.kind {
-            NodeKind::File { .. } => files.push(id),
-            NodeKind::Directory { children, .. } => {
-                for &child in children {
-                    self.collect_files_recursive(child, files);
-                }
-            }
+        if self.nodes[id].is_dir() {
+            Some(id)
+        } else {
+            self.nodes[id].parent
         }
     }
 
-    pub fn children_sorted(&self, id: NodeId) -> Vec<NodeId> {
-        let mut children: Vec<NodeId> = self.node(id).children().to_vec();
-        children.retain(|&c| self.nodes[c].alive);
-        children.sort_by(|&a, &b| self.nodes[b].size.cmp(&self.nodes[a].size));
-        children
-    }
-
-    pub fn is_alive(&self, id: NodeId) -> bool {
-        self.nodes[id].alive
-    }
-
     /// Marks all descendants of `target` as dead and empties its children
     /// list. The node itself stays. Used as the first step of grafting a
     /// freshly-scanned subtree onto an existing tree.
     pub fn clear_descendants(&mut self, target: NodeId) {
-        let mut stack: Vec<NodeId> = Vec::new();
-        if let NodeKind::Directory { children, .. } = &self.nodes[target].kind {
-            stack.extend_from_slice(children);
-        }
-        while let Some(id) = stack.pop() {
-            self.nodes[id].alive = false;
-            if let NodeKind::Directory { children, .. } = &self.nodes[id].kind {
-                stack.extend_from_slice(children);
-            }
-        }
+        self.mark_descendants_dead(target);
         if let NodeKind::Directory { children, .. } = &mut self.nodes[target].kind {
             children.clear();
         }
@@ -425,11 +398,11 @@ impl FileTree {
     pub fn recompute_sizes_upward(&mut self, target: NodeId) {
         let mut current = Some(target);
         while let Some(id) = current {
+            if !self.nodes[id].alive {
+                break;
+            }
             if self.nodes[id].is_dir() {
-                let (size, files, dirs) = self.aggregate_dir(id);
-                self.nodes[id].size = size;
-                self.nodes[id].file_count = files;
-                self.nodes[id].subdir_count = dirs;
+                self.aggregate_dir(id);
             }
             current = self.nodes[id].parent;
         }
@@ -467,15 +440,14 @@ impl FileTree {
                     let ext_owned: Option<String> = extension.map(|r| {
                         String::from_utf8_lossy(source.strings.get(r)).into_owned()
                     });
-                    let new_id = self.add_file(
+                    self.add_file(
                         dst_parent,
                         &name_bytes,
                         src_node.size,
                         ext_owned.as_deref(),
                         src_node.modified,
                         depth,
                     );
-                    let _ = new_id;
                 }
                 NodeKind::Directory { children, .. } => {
                     let new_id = self.add_dir(
@@ -496,10 +468,7 @@ impl FileTree {
         // than their parents), then propagate target + ancestors upward.
         for i in (first_new..self.nodes.len()).rev() {
             if self.nodes[i].is_dir() {
-                let (size, files, dirs) = self.aggregate_dir(i);
-                self.nodes[i].size = size;
-                self.nodes[i].file_count = files;
-                self.nodes[i].subdir_count = dirs;
+                self.aggregate_dir(i);
             }
         }
 

src/scanner/walk.rs

@@ -97,7 +97,7 @@ fn build_skip_paths() -> Vec<PathBuf> {
 
 fn is_photos_library(path: &Path) -> bool {
     path.extension()
-        .map_or(false, |e| e == "photoslibrary" || e == "photolibrary")
+        .is_some_and(|e| e == "photoslibrary" || e == "photolibrary")
 }
 
 fn should_skip(path: &Path, scan_root: &Path, skip_paths: &[PathBuf]) -> bool {