From 87496f11308fb1e3147bb6405a0aa1bdcab3c836 Mon Sep 17 00:00:00 2001
From: RCD <90105158+Finesssee@users.noreply.github.com>
Date: Tue, 29 Sep 2026 20:15:00 +0700
Subject: [PATCH 1/4] Port upstream 0.65.0: scan claude-swap session homes in
 the Claude cost scan

---
 rust/src/cost_scanner.rs                   |  72 ++++---
 rust/src/cost_scanner/claude_roots.rs      | 219 +++++++++++++++++++++
 rust/src/cost_scanner/tests.rs             |   3 +
 rust/src/cost_scanner/tests/claude_swap.rs |  45 +++++
 4 files changed, 307 insertions(+), 32 deletions(-)
 create mode 100644 rust/src/cost_scanner/claude_roots.rs
 create mode 100644 rust/src/cost_scanner/tests/claude_swap.rs

diff --git a/rust/src/cost_scanner.rs b/rust/src/cost_scanner.rs
index 55444c6a74..b7db328e5b 100755
--- a/rust/src/cost_scanner.rs
+++ b/rust/src/cost_scanner.rs
@@ -35,6 +35,7 @@ use crate::providers::claude::quota_history::{
 use crate::providers::opencodego::local as opencodego_local;
 use crate::settings::Settings;
 mod claude_pricing;
+mod claude_roots;
 mod claude_usage;
 mod codex;
 mod read_receipt;
@@ -584,7 +585,7 @@ impl CostScanner {
         cancel: Option<&AtomicBool>,
         include_pi_sessions: bool,
     ) -> CostSummary {
-        let projects_dir = self.get_claude_projects_dir();
+        let roots = self.claude_projects_roots();
         let mut summary = CostSummary::default();
         let today = Utc::now().date_naive();
         let start_date = today - Duration::days(self.days as i64);
@@ -596,7 +597,7 @@ impl CostScanner {
         // Walk through projects directory, de-duplicating usage records
         // that appear across multiple files.
         let mut claude_scan = ClaudeFileScanResult::default();
-        if projects_dir.exists() {
+        if !roots.is_empty() {
             let mut seen = HashSet::new();
             let mut pricing = ClaudeScanPricingResolver::default();
             let traversal_read_failures = {
@@ -623,7 +624,7 @@ impl CostScanner {
                     }
                     claude_scan.absorb(file_result);
                 };
-                self.walk_claude_files(&projects_dir, &cutoff, cancel, &mut handle_file)
+                self.walk_claude_roots(&roots, &cutoff, cancel, &mut handle_file)
             };
             claude_scan.read_failures = claude_scan
                 .read_failures
@@ -649,7 +650,7 @@ impl CostScanner {
         // than turning a partial zero into a known zero.
         finalize_claude_summary(
             &mut summary,
-            projects_dir.exists(),
+            !roots.is_empty(),
             claude_scan,
             is_cancelled(cancel),
         );
@@ -663,7 +664,7 @@ impl CostScanner {
         &self,
         cancel: Option<&AtomicBool>,
     ) -> ClaudeChartSnapshot {
-        let projects_dir = self.get_claude_projects_dir();
+        let roots = self.claude_projects_roots();
         let today = Local::now().date_naive();
         let cutoff = Utc::now() - Duration::days(self.days as i64);
         let mut summary = CostSummary {
@@ -683,11 +684,11 @@ impl CostScanner {
 
         let mut quota_records = Vec::new();
         let mut scan_result = ClaudeFileScanResult::default();
-        if projects_dir.exists() {
+        if !roots.is_empty() {
             let mut seen = HashSet::new();
             let mut pricing = ClaudeScanPricingResolver::default();
             let traversal_read_failures =
-                self.walk_claude_files(&projects_dir, &cutoff, cancel, &mut |path| {
+                self.walk_claude_roots(&roots, &cutoff, cancel, &mut |path| {
                     let mut file_has_usage = false;
                     let mut aggregation_complete = true;
                     let mut file_result = scan_claude_file_with_pricing(
@@ -735,10 +736,10 @@ impl CostScanner {
             &mut HashSet::new(),
         );
 
-        let complete = projects_dir.exists() && !is_cancelled(cancel) && scan_result.is_complete();
+        let complete = !roots.is_empty() && !is_cancelled(cancel) && scan_result.is_complete();
         finalize_claude_summary(
             &mut summary,
-            projects_dir.exists(),
+            !roots.is_empty(),
             scan_result,
             is_cancelled(cancel),
         );
@@ -804,23 +805,30 @@ impl CostScanner {
         }
     }
 
-    fn get_claude_projects_dir(&self) -> PathBuf {
-        if let Ok(claude_config) = std::env::var("CLAUDE_CONFIG_DIR") {
-            let trimmed = claude_config.trim();
-            if !trimmed.is_empty() {
-                return PathBuf::from(trimmed).join("projects");
-            }
-        }
-
-        // Try ~/.claude/projects first
-        let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
-        let claude_dir = home.join(".claude").join("projects");
-        if claude_dir.exists() {
-            return claude_dir;
-        }
+    /// Existing Claude transcript roots: the profile root plus claude-swap
+    /// session homes, de-duplicated by resolved path.
+    fn claude_projects_roots(&self) -> Vec<PathBuf> {
+        claude_roots::claude_projects_roots(
+            std::env::var("CLAUDE_CONFIG_DIR").ok().as_deref(),
+            dirs::home_dir().as_deref(),
+        )
+    }
 
-        // Fallback to ~/.config/claude/projects
-        home.join(".config").join("claude").join("projects")
+    /// Walk every root with one caller-owned `seen` set behind `on_file`, so a
+    /// row copied between homes is counted once. Returns read failures.
+    fn walk_claude_roots<F>(
+        &self,
+        roots: &[PathBuf],
+        cutoff: &DateTime<Utc>,
+        cancel: Option<&AtomicBool>,
+        on_file: &mut F,
+    ) -> u32
+    where
+        F: FnMut(&Path),
+    {
+        roots.iter().fold(0u32, |failures, root| {
+            failures.saturating_add(self.walk_claude_files(root, cutoff, cancel, on_file))
+        })
     }
 
     fn walk_claude_files<F>(
@@ -1204,7 +1212,7 @@ pub fn has_cost_usage_sources() -> bool {
         .get_codex_sessions_dirs()
         .iter()
         .any(|dir| dir.exists())
-        || scanner.get_claude_projects_dir().exists()
+        || !scanner.claude_projects_roots().is_empty()
         || crate::pi_session_cost::pi_compatible_session_roots(dirs::home_dir())
             .iter()
             .any(|dir| dir.exists())
@@ -1267,8 +1275,8 @@ pub fn get_daily_cost_history(provider: &str, days: u32) -> Vec<(String, Option<
         "claude" => {
             // Real per-day breakdown: walk the project logs once,
             // de-duplicating records across files.
-            let projects_dir = scanner.get_claude_projects_dir();
-            if projects_dir.exists() {
+            let roots = scanner.claude_projects_roots();
+            if !roots.is_empty() {
                 let cutoff = Utc::now() - Duration::days(days as i64);
                 let mut seen = HashSet::new();
                 let mut pricing = ClaudeScanPricingResolver::default();
@@ -1298,7 +1306,7 @@ pub fn get_daily_cost_history(provider: &str, days: u32) -> Vec<(String, Option<
                         }
                         claude_scan.absorb(file_result);
                     };
-                    scanner.walk_claude_files(&projects_dir, &cutoff, None, &mut handle_file)
+                    scanner.walk_claude_roots(&roots, &cutoff, None, &mut handle_file)
                 };
                 claude_scan.read_failures = claude_scan
                     .read_failures
@@ -1389,8 +1397,8 @@ pub fn get_daily_token_history(provider: &str, days: u32) -> (Vec<(String, u64)>
             // Per-day token breakdown from the same de-duplicated record walk
             // as the cost chart. Only a complete valid walk establishes
             // authoritative coverage of the requested history window.
-            let projects_dir = scanner.get_claude_projects_dir();
-            if projects_dir.exists() {
+            let roots = scanner.claude_projects_roots();
+            if !roots.is_empty() {
                 let cutoff = Utc::now() - Duration::days(days as i64);
                 let mut seen = HashSet::new();
                 let mut pricing = ClaudeScanPricingResolver::default();
@@ -1406,7 +1414,7 @@ pub fn get_daily_token_history(provider: &str, days: u32) -> (Vec<(String, u64)>
                         );
                         claude_scan.absorb(file_result);
                     };
-                    scanner.walk_claude_files(&projects_dir, &cutoff, None, &mut handle_file)
+                    scanner.walk_claude_roots(&roots, &cutoff, None, &mut handle_file)
                 };
                 claude_scan.read_failures = claude_scan
                     .read_failures
diff --git a/rust/src/cost_scanner/claude_roots.rs b/rust/src/cost_scanner/claude_roots.rs
new file mode 100644
index 0000000000..b127044d78
--- /dev/null
+++ b/rust/src/cost_scanner/claude_roots.rs
@@ -0,0 +1,219 @@
+//! Claude transcript roots for the local cost scan.
+//!
+//! The Claude profile root (`CLAUDE_CONFIG_DIR` or `~/.claude`) is always
+//! scanned. claude-swap (`cswap run`) additionally keeps one Claude profile per
+//! session home below `~/.claude-swap-backup/sessions/<N>-<label>/projects`,
+//! which Claude Code writes to when a swapped session is active. Those homes
+//! are added so the aggregate totals include them (upstream 0.65.0,
+//! `ClaudeConfigPaths.costProjectsRoots`). Only transcript directories are
+//! read; claude-swap credentials and private metadata are never touched.
+//!
+//! claude-swap uses the legacy `~/.claude-swap-backup` root on Windows and
+//! macOS. The XDG data root applies to Linux/WSL only and is not needed here.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const SWAP_SESSIONS_DIR: [&str; 2] = [".claude-swap-backup", "sessions"];
+
+/// Existing Claude transcript roots, de-duplicated by resolved path.
+///
+/// `config_dir` is the raw `CLAUDE_CONFIG_DIR` value: one literal directory,
+/// with empty meaning "unset". A root that does not exist is omitted, so an
+/// empty result means there is no Claude history to scan.
+pub(super) fn claude_projects_roots(config_dir: Option<&str>, home: Option<&Path>) -> Vec<PathBuf> {
+    let mut candidates = vec![base_projects_dir(config_dir, home)];
+    if let Some(home) = home {
+        candidates.extend(swap_projects_roots(home));
+    }
+
+    let mut seen = Vec::new();
+    let mut roots = Vec::new();
+    for root in candidates {
+        if !root.exists() {
+            continue;
+        }
+        // Shared-history symlinks or junctions resolve to the same directory
+        // as the profile they point at; scan that directory once.
+        let resolved = fs::canonicalize(&root).unwrap_or_else(|_| root.clone());
+        if !seen.contains(&resolved) {
+            seen.push(resolved);
+            roots.push(root);
+        }
+    }
+    roots
+}
+
+fn base_projects_dir(config_dir: Option<&str>, home: Option<&Path>) -> PathBuf {
+    if let Some(trimmed) = config_dir.map(str::trim).filter(|dir| !dir.is_empty()) {
+        return PathBuf::from(trimmed).join("projects");
+    }
+
+    let home = home.unwrap_or_else(|| Path::new("."));
+    let claude_dir = home.join(".claude").join("projects");
+    if claude_dir.exists() {
+        return claude_dir;
+    }
+    home.join(".config").join("claude").join("projects")
+}
+
+/// `<home>/.claude-swap-backup/sessions/<N>-<label>/projects` directories,
+/// sorted by path. Only immediate children of `sessions` qualify; `<N>` must
+/// be a positive integer and `projects` must be a directory (a dangling shared
+/// history link is skipped without affecting the other homes).
+fn swap_projects_roots(home: &Path) -> Vec<PathBuf> {
+    let sessions = SWAP_SESSIONS_DIR
+        .iter()
+        .fold(home.to_path_buf(), |path, part| path.join(part));
+    let Ok(entries) = fs::read_dir(&sessions) else {
+        return Vec::new();
+    };
+    let mut slots: Vec<PathBuf> = entries
+        .filter_map(Result::ok)
+        .filter(|entry| is_swap_slot_name(&entry.file_name().to_string_lossy()))
+        .map(|entry| entry.path())
+        .collect();
+    slots.sort();
+    slots
+        .into_iter()
+        .map(|slot| slot.join("projects"))
+        .filter(|projects| projects.is_dir())
+        .collect()
+}
+
+fn is_swap_slot_name(name: &str) -> bool {
+    if name.starts_with('.') {
+        return false;
+    }
+    name.split_once('-')
+        .and_then(|(number, _label)| number.parse::<i64>().ok())
+        .is_some_and(|number| number > 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_projects(root: &Path) -> PathBuf {
+        let projects = root.join("projects");
+        fs::create_dir_all(&projects).unwrap();
+        projects
+    }
+
+    fn swap_home(home: &Path, slot: &str) -> PathBuf {
+        make_projects(&home.join(".claude-swap-backup").join("sessions").join(slot))
+    }
+
+    #[test]
+    fn slot_names_need_a_positive_integer_and_a_dash() {
+        for accepted in ["1-first", "12-a-b", "3-", "+5-plus"] {
+            assert!(is_swap_slot_name(accepted), "{accepted}");
+        }
+        for rejected in [
+            "0-foo",
+            "-1-foo",
+            "unrelated",
+            "abc-1",
+            "7",
+            "",
+            ".1-hidden",
+            " 1-x",
+        ] {
+            assert!(!is_swap_slot_name(rejected), "{rejected}");
+        }
+    }
+
+    #[test]
+    fn swap_homes_are_added_after_the_profile_root_sorted_by_path() {
+        let home = tempfile::tempdir().unwrap();
+        let base = make_projects(&home.path().join(".claude"));
+        let second = swap_home(home.path(), "2-second");
+        let first = swap_home(home.path(), "1-first");
+        swap_home(home.path(), "unrelated");
+        swap_home(home.path(), "0-zero");
+
+        let roots = claude_projects_roots(None, Some(home.path()));
+        assert_eq!(roots, vec![base, first, second]);
+    }
+
+    #[test]
+    fn literal_config_dir_stays_beside_swap_homes() {
+        let home = tempfile::tempdir().unwrap();
+        let configured = tempfile::tempdir().unwrap();
+        let configured_projects = make_projects(configured.path());
+        make_projects(&home.path().join(".claude"));
+        let swap = swap_home(home.path(), "2-second");
+
+        let roots = claude_projects_roots(configured.path().to_str(), Some(home.path()));
+        assert_eq!(roots, vec![configured_projects, swap]);
+    }
+
+    #[test]
+    fn empty_config_dir_falls_back_to_the_default_root() {
+        let home = tempfile::tempdir().unwrap();
+        let default = make_projects(&home.path().join(".config").join("claude"));
+        assert_eq!(
+            claude_projects_roots(Some("  "), Some(home.path())),
+            vec![default]
+        );
+    }
+
+    #[test]
+    fn missing_profile_root_does_not_stop_swap_homes() {
+        let home = tempfile::tempdir().unwrap();
+        let swap = swap_home(home.path(), "1-first");
+        // A slot without a projects directory and a file named like a slot.
+        fs::create_dir_all(
+            home.path()
+                .join(".claude-swap-backup")
+                .join("sessions")
+                .join("2-empty"),
+        )
+        .unwrap();
+        fs::write(
+            home.path()
+                .join(".claude-swap-backup")
+                .join("sessions")
+                .join("3-file"),
+            b"x",
+        )
+        .unwrap();
+
+        assert_eq!(claude_projects_roots(None, Some(home.path())), vec![swap]);
+        assert!(claude_projects_roots(None, Some(&home.path().join("nowhere"))).is_empty());
+    }
+
+    #[test]
+    fn a_profile_root_matching_a_swap_home_by_resolved_path_is_listed_once() {
+        let home = tempfile::tempdir().unwrap();
+        let sessions = home.path().join(".claude-swap-backup").join("sessions");
+        let first = swap_home(home.path(), "1-first");
+        let respelled = sessions.join("..").join("sessions").join("1-first");
+
+        let roots = claude_projects_roots(respelled.to_str(), Some(home.path()));
+        assert_eq!(roots.len(), 1);
+        assert_eq!(
+            fs::canonicalize(&roots[0]).unwrap(),
+            fs::canonicalize(first).unwrap()
+        );
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn shared_history_symlink_is_scanned_once() {
+        let home = tempfile::tempdir().unwrap();
+        let first = swap_home(home.path(), "1-first");
+        let shared = home
+            .path()
+            .join(".claude-swap-backup")
+            .join("sessions")
+            .join("3-shared");
+        fs::create_dir_all(&shared).unwrap();
+        // Creating a symlink needs a privilege on Windows; skip without it.
+        if std::os::windows::fs::symlink_dir(&first, shared.join("projects")).is_err() {
+            return;
+        }
+
+        assert_eq!(claude_projects_roots(None, Some(home.path())), vec![first]);
+    }
+}
diff --git a/rust/src/cost_scanner/tests.rs b/rust/src/cost_scanner/tests.rs
index 69f0c8dffa..7b1a5c6abf 100644
--- a/rust/src/cost_scanner/tests.rs
+++ b/rust/src/cost_scanner/tests.rs
@@ -3341,6 +3341,9 @@ fn incomplete_or_buffered_empty_codex_fragment_is_not_marked_complete() {
     assert!(buffered_cache.codex_pending_paths.contains(&buffered_key));
 }
 
+#[cfg(test)]
+#[path = "tests/claude_swap.rs"]
+mod claude_swap;
 #[cfg(test)]
 #[path = "tests/copied_prefix.rs"]
 mod copied_prefix;
diff --git a/rust/src/cost_scanner/tests/claude_swap.rs b/rust/src/cost_scanner/tests/claude_swap.rs
new file mode 100644
index 0000000000..23cd0e8778
--- /dev/null
+++ b/rust/src/cost_scanner/tests/claude_swap.rs
@@ -0,0 +1,45 @@
+use super::*;
+
+fn write_project(projects: PathBuf, rows: &[String]) -> PathBuf {
+    let project = projects.join("project");
+    std::fs::create_dir_all(&project).unwrap();
+    std::fs::write(project.join("session.jsonl"), rows.join("\n") + "\n").unwrap();
+    projects
+}
+
+#[test]
+fn claude_swap_homes_are_scanned_once_beside_a_literal_config_dir() {
+    let home = tempfile::tempdir().unwrap();
+    let configured = tempfile::tempdir().unwrap();
+    let timestamp = Utc::now().to_rfc3339();
+    let row = |id: &str| claude_transcript_line(&timestamp, "requestId", id, id);
+    let sessions = home.path().join(".claude-swap-backup").join("sessions");
+    let configured_projects = write_project(configured.path().join("projects"), &[row("literal")]);
+    let first = write_project(sessions.join("1-first").join("projects"), &[row("first")]);
+    // The second home carries a copy of the first home's row.
+    let second = write_project(
+        sessions.join("2-second").join("projects"),
+        &[row("first"), row("second")],
+    );
+    write_project(sessions.join("0-ignored").join("projects"), &[row("decoy")]);
+
+    let roots = claude_roots::claude_projects_roots(configured.path().to_str(), Some(home.path()));
+    assert_eq!(roots, vec![configured_projects, first, second]);
+
+    // A dangling profile directory only costs one read failure.
+    let mut scan_roots = roots;
+    scan_roots.push(home.path().join("missing").join("projects"));
+    let scanner = CostScanner::new(1);
+    let cutoff = Utc::now() - Duration::days(1);
+    let mut seen = HashSet::new();
+    let mut pricing = ClaudeScanPricingResolver::default();
+    let mut counted = 0usize;
+    let read_failures = scanner.walk_claude_roots(&scan_roots, &cutoff, None, &mut |path| {
+        counted +=
+            scan_claude_file_with_pricing(path, &cutoff, &mut seen, None, &mut pricing, |_| {})
+                .counted;
+    });
+
+    assert_eq!(read_failures, 1);
+    assert_eq!(counted, 3, "literal + first + second; the copy counts once");
+}

From 8da64f9d2522fb1a308e26cb5149ab4f2f72d59a Mon Sep 17 00:00:00 2001
From: RCD <90105158+Finesssee@users.noreply.github.com>
Date: Wed, 30 Sep 2026 21:01:13 +0700
Subject: [PATCH 2/4] Address thermo review

---
 rust/src/cost_scanner.rs                   |  31 ++--
 rust/src/cost_scanner/claude_roots.rs      | 173 +++++++++++++++------
 rust/src/cost_scanner/tests/claude_swap.rs |   7 +-
 3 files changed, 151 insertions(+), 60 deletions(-)

diff --git a/rust/src/cost_scanner.rs b/rust/src/cost_scanner.rs
index b7db328e5b..c83e2d8957 100755
--- a/rust/src/cost_scanner.rs
+++ b/rust/src/cost_scanner.rs
@@ -597,7 +597,7 @@ impl CostScanner {
         // Walk through projects directory, de-duplicating usage records
         // that appear across multiple files.
         let mut claude_scan = ClaudeFileScanResult::default();
-        if !roots.is_empty() {
+        if !roots.paths.is_empty() {
             let mut seen = HashSet::new();
             let mut pricing = ClaudeScanPricingResolver::default();
             let traversal_read_failures = {
@@ -624,10 +624,11 @@ impl CostScanner {
                     }
                     claude_scan.absorb(file_result);
                 };
-                self.walk_claude_roots(&roots, &cutoff, cancel, &mut handle_file)
+                self.walk_claude_roots(&roots.paths, &cutoff, cancel, &mut handle_file)
             };
             claude_scan.read_failures = claude_scan
                 .read_failures
+                .saturating_add(roots.read_failures)
                 .saturating_add(traversal_read_failures);
         }
 
@@ -650,7 +651,7 @@ impl CostScanner {
         // than turning a partial zero into a known zero.
         finalize_claude_summary(
             &mut summary,
-            !roots.is_empty(),
+            !roots.paths.is_empty(),
             claude_scan,
             is_cancelled(cancel),
         );
@@ -684,11 +685,11 @@ impl CostScanner {
 
         let mut quota_records = Vec::new();
         let mut scan_result = ClaudeFileScanResult::default();
-        if !roots.is_empty() {
+        if !roots.paths.is_empty() {
             let mut seen = HashSet::new();
             let mut pricing = ClaudeScanPricingResolver::default();
             let traversal_read_failures =
-                self.walk_claude_roots(&roots, &cutoff, cancel, &mut |path| {
+                self.walk_claude_roots(&roots.paths, &cutoff, cancel, &mut |path| {
                     let mut file_has_usage = false;
                     let mut aggregation_complete = true;
                     let mut file_result = scan_claude_file_with_pricing(
@@ -725,6 +726,7 @@ impl CostScanner {
                 });
             scan_result.read_failures = scan_result
                 .read_failures
+                .saturating_add(roots.read_failures)
                 .saturating_add(traversal_read_failures);
         }
 
@@ -736,10 +738,11 @@ impl CostScanner {
             &mut HashSet::new(),
         );
 
-        let complete = !roots.is_empty() && !is_cancelled(cancel) && scan_result.is_complete();
+        let complete =
+            !roots.paths.is_empty() && !is_cancelled(cancel) && scan_result.is_complete();
         finalize_claude_summary(
             &mut summary,
-            !roots.is_empty(),
+            !roots.paths.is_empty(),
             scan_result,
             is_cancelled(cancel),
         );
@@ -807,7 +810,7 @@ impl CostScanner {
 
     /// Existing Claude transcript roots: the profile root plus claude-swap
     /// session homes, de-duplicated by resolved path.
-    fn claude_projects_roots(&self) -> Vec<PathBuf> {
+    fn claude_projects_roots(&self) -> claude_roots::ClaudeProjectsRoots {
         claude_roots::claude_projects_roots(
             std::env::var("CLAUDE_CONFIG_DIR").ok().as_deref(),
             dirs::home_dir().as_deref(),
@@ -1212,7 +1215,7 @@ pub fn has_cost_usage_sources() -> bool {
         .get_codex_sessions_dirs()
         .iter()
         .any(|dir| dir.exists())
-        || !scanner.claude_projects_roots().is_empty()
+        || scanner.claude_projects_roots().has_possible_roots()
         || crate::pi_session_cost::pi_compatible_session_roots(dirs::home_dir())
             .iter()
             .any(|dir| dir.exists())
@@ -1276,7 +1279,7 @@ pub fn get_daily_cost_history(provider: &str, days: u32) -> Vec<(String, Option<
             // Real per-day breakdown: walk the project logs once,
             // de-duplicating records across files.
             let roots = scanner.claude_projects_roots();
-            if !roots.is_empty() {
+            if !roots.paths.is_empty() {
                 let cutoff = Utc::now() - Duration::days(days as i64);
                 let mut seen = HashSet::new();
                 let mut pricing = ClaudeScanPricingResolver::default();
@@ -1306,10 +1309,11 @@ pub fn get_daily_cost_history(provider: &str, days: u32) -> Vec<(String, Option<
                         }
                         claude_scan.absorb(file_result);
                     };
-                    scanner.walk_claude_roots(&roots, &cutoff, None, &mut handle_file)
+                    scanner.walk_claude_roots(&roots.paths, &cutoff, None, &mut handle_file)
                 };
                 claude_scan.read_failures = claude_scan
                     .read_failures
+                    .saturating_add(roots.read_failures)
                     .saturating_add(traversal_read_failures);
                 if claude_scan.is_complete() {
                     zero_fill_uninitialized_claude_daily_costs(
@@ -1398,7 +1402,7 @@ pub fn get_daily_token_history(provider: &str, days: u32) -> (Vec<(String, u64)>
             // as the cost chart. Only a complete valid walk establishes
             // authoritative coverage of the requested history window.
             let roots = scanner.claude_projects_roots();
-            if !roots.is_empty() {
+            if !roots.paths.is_empty() {
                 let cutoff = Utc::now() - Duration::days(days as i64);
                 let mut seen = HashSet::new();
                 let mut pricing = ClaudeScanPricingResolver::default();
@@ -1414,10 +1418,11 @@ pub fn get_daily_token_history(provider: &str, days: u32) -> (Vec<(String, u64)>
                         );
                         claude_scan.absorb(file_result);
                     };
-                    scanner.walk_claude_roots(&roots, &cutoff, None, &mut handle_file)
+                    scanner.walk_claude_roots(&roots.paths, &cutoff, None, &mut handle_file)
                 };
                 claude_scan.read_failures = claude_scan
                     .read_failures
+                    .saturating_add(roots.read_failures)
                     .saturating_add(traversal_read_failures);
                 mark_claude_daily_token_coverage(&mut covered_days, &daily_tokens, claude_scan);
             }
diff --git a/rust/src/cost_scanner/claude_roots.rs b/rust/src/cost_scanner/claude_roots.rs
index b127044d78..c1b983bfa5 100644
--- a/rust/src/cost_scanner/claude_roots.rs
+++ b/rust/src/cost_scanner/claude_roots.rs
@@ -11,37 +11,68 @@
 //! claude-swap uses the legacy `~/.claude-swap-backup` root on Windows and
 //! macOS. The XDG data root applies to Linux/WSL only and is not needed here.
 
+use std::collections::HashSet;
 use std::fs;
 use std::path::{Path, PathBuf};
 
-const SWAP_SESSIONS_DIR: [&str; 2] = [".claude-swap-backup", "sessions"];
+#[derive(Debug, Default)]
+pub(super) struct ClaudeProjectsRoots {
+    pub(super) paths: Vec<PathBuf>,
+    pub(super) read_failures: u32,
+}
+
+impl ClaudeProjectsRoots {
+    pub(super) fn has_possible_roots(&self) -> bool {
+        !self.paths.is_empty() || self.read_failures > 0
+    }
+}
 
 /// Existing Claude transcript roots, de-duplicated by resolved path.
 ///
 /// `config_dir` is the raw `CLAUDE_CONFIG_DIR` value: one literal directory,
-/// with empty meaning "unset". A root that does not exist is omitted, so an
-/// empty result means there is no Claude history to scan.
-pub(super) fn claude_projects_roots(config_dir: Option<&str>, home: Option<&Path>) -> Vec<PathBuf> {
-    let mut candidates = vec![base_projects_dir(config_dir, home)];
+/// with empty meaning "unset". A root that does not exist is omitted; failures
+/// that prevent discovering existing roots are retained for scan coverage.
+pub(super) fn claude_projects_roots(
+    config_dir: Option<&str>,
+    home: Option<&Path>,
+) -> ClaudeProjectsRoots {
+    let mut result = ClaudeProjectsRoots {
+        paths: vec![base_projects_dir(config_dir, home)],
+        ..ClaudeProjectsRoots::default()
+    };
     if let Some(home) = home {
-        candidates.extend(swap_projects_roots(home));
+        let swaps = swap_projects_roots(home);
+        result.paths.extend(swaps.paths);
+        result.read_failures = result.read_failures.saturating_add(swaps.read_failures);
     }
 
-    let mut seen = Vec::new();
-    let mut roots = Vec::new();
-    for root in candidates {
-        if !root.exists() {
-            continue;
+    let mut seen = HashSet::new();
+    let mut paths = Vec::new();
+    for root in result.paths.drain(..) {
+        match fs::metadata(&root) {
+            Ok(_) => {}
+            Err(error) if is_missing_path(&error) => continue,
+            Err(_) => {
+                result.read_failures = result.read_failures.saturating_add(1);
+                continue;
+            }
         }
+
         // Shared-history symlinks or junctions resolve to the same directory
         // as the profile they point at; scan that directory once.
-        let resolved = fs::canonicalize(&root).unwrap_or_else(|_| root.clone());
-        if !seen.contains(&resolved) {
-            seen.push(resolved);
-            roots.push(root);
+        let resolved = match fs::canonicalize(&root) {
+            Ok(resolved) => resolved,
+            Err(_) => {
+                result.read_failures = result.read_failures.saturating_add(1);
+                root.clone()
+            }
+        };
+        if seen.insert(resolved) {
+            paths.push(root);
         }
     }
-    roots
+    result.paths = paths;
+    result
 }
 
 fn base_projects_dir(config_dir: Option<&str>, home: Option<&Path>) -> PathBuf {
@@ -60,25 +91,54 @@ fn base_projects_dir(config_dir: Option<&str>, home: Option<&Path>) -> PathBuf {
 /// `<home>/.claude-swap-backup/sessions/<N>-<label>/projects` directories,
 /// sorted by path. Only immediate children of `sessions` qualify; `<N>` must
 /// be a positive integer and `projects` must be a directory (a dangling shared
-/// history link is skipped without affecting the other homes).
-fn swap_projects_roots(home: &Path) -> Vec<PathBuf> {
-    let sessions = SWAP_SESSIONS_DIR
-        .iter()
-        .fold(home.to_path_buf(), |path, part| path.join(part));
-    let Ok(entries) = fs::read_dir(&sessions) else {
-        return Vec::new();
+/// history link is skipped without affecting the other homes). Discovery
+/// failures are retained so callers do not report incomplete history as a
+/// complete zero.
+fn swap_projects_roots(home: &Path) -> ClaudeProjectsRoots {
+    let sessions = home.join(".claude-swap-backup").join("sessions");
+    let entries = match fs::read_dir(&sessions) {
+        Ok(entries) => entries,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+            return ClaudeProjectsRoots::default();
+        }
+        Err(_) => {
+            return ClaudeProjectsRoots {
+                read_failures: 1,
+                ..ClaudeProjectsRoots::default()
+            };
+        }
     };
-    let mut slots: Vec<PathBuf> = entries
-        .filter_map(Result::ok)
-        .filter(|entry| is_swap_slot_name(&entry.file_name().to_string_lossy()))
-        .map(|entry| entry.path())
-        .collect();
-    slots.sort();
-    slots
-        .into_iter()
-        .map(|slot| slot.join("projects"))
-        .filter(|projects| projects.is_dir())
-        .collect()
+
+    let mut result = ClaudeProjectsRoots::default();
+    for entry in entries {
+        let entry = match entry {
+            Ok(entry) => entry,
+            Err(_) => {
+                result.read_failures = result.read_failures.saturating_add(1);
+                continue;
+            }
+        };
+        if !is_swap_slot_name(&entry.file_name().to_string_lossy()) {
+            continue;
+        }
+        let projects = entry.path().join("projects");
+        match fs::metadata(&projects) {
+            Ok(metadata) if metadata.is_dir() => result.paths.push(projects),
+            Ok(_) => {}
+            Err(error) if is_missing_path(&error) => {}
+            Err(_) => result.read_failures = result.read_failures.saturating_add(1),
+        }
+    }
+
+    result.paths.sort();
+    result
+}
+
+fn is_missing_path(error: &std::io::Error) -> bool {
+    matches!(
+        error.kind(),
+        std::io::ErrorKind::NotFound | std::io::ErrorKind::NotADirectory
+    )
 }
 
 fn is_swap_slot_name(name: &str) -> bool {
@@ -86,7 +146,8 @@ fn is_swap_slot_name(name: &str) -> bool {
         return false;
     }
     name.split_once('-')
-        .and_then(|(number, _label)| number.parse::<i64>().ok())
+        .and_then(|(number, label)| (!label.is_empty()).then_some(number))
+        .and_then(|number| number.parse::<i64>().ok())
         .is_some_and(|number| number > 0)
 }
 
@@ -106,7 +167,7 @@ mod tests {
 
     #[test]
     fn slot_names_need_a_positive_integer_and_a_dash() {
-        for accepted in ["1-first", "12-a-b", "3-", "+5-plus"] {
+        for accepted in ["1-first", "12-a-b", "+5-plus"] {
             assert!(is_swap_slot_name(accepted), "{accepted}");
         }
         for rejected in [
@@ -115,6 +176,7 @@ mod tests {
             "unrelated",
             "abc-1",
             "7",
+            "3-",
             "",
             ".1-hidden",
             " 1-x",
@@ -133,7 +195,7 @@ mod tests {
         swap_home(home.path(), "0-zero");
 
         let roots = claude_projects_roots(None, Some(home.path()));
-        assert_eq!(roots, vec![base, first, second]);
+        assert_eq!(roots.paths, vec![base, first, second]);
     }
 
     #[test]
@@ -145,7 +207,7 @@ mod tests {
         let swap = swap_home(home.path(), "2-second");
 
         let roots = claude_projects_roots(configured.path().to_str(), Some(home.path()));
-        assert_eq!(roots, vec![configured_projects, swap]);
+        assert_eq!(roots.paths, vec![configured_projects, swap]);
     }
 
     #[test]
@@ -153,7 +215,7 @@ mod tests {
         let home = tempfile::tempdir().unwrap();
         let default = make_projects(&home.path().join(".config").join("claude"));
         assert_eq!(
-            claude_projects_roots(Some("  "), Some(home.path())),
+            claude_projects_roots(Some("  "), Some(home.path())).paths,
             vec![default]
         );
     }
@@ -179,8 +241,15 @@ mod tests {
         )
         .unwrap();
 
-        assert_eq!(claude_projects_roots(None, Some(home.path())), vec![swap]);
-        assert!(claude_projects_roots(None, Some(&home.path().join("nowhere"))).is_empty());
+        assert_eq!(
+            claude_projects_roots(None, Some(home.path())).paths,
+            vec![swap]
+        );
+        assert!(
+            claude_projects_roots(None, Some(&home.path().join("nowhere")))
+                .paths
+                .is_empty()
+        );
     }
 
     #[test]
@@ -191,9 +260,9 @@ mod tests {
         let respelled = sessions.join("..").join("sessions").join("1-first");
 
         let roots = claude_projects_roots(respelled.to_str(), Some(home.path()));
-        assert_eq!(roots.len(), 1);
+        assert_eq!(roots.paths.len(), 1);
         assert_eq!(
-            fs::canonicalize(&roots[0]).unwrap(),
+            fs::canonicalize(&roots.paths[0]).unwrap(),
             fs::canonicalize(first).unwrap()
         );
     }
@@ -214,6 +283,22 @@ mod tests {
             return;
         }
 
-        assert_eq!(claude_projects_roots(None, Some(home.path())), vec![first]);
+        assert_eq!(
+            claude_projects_roots(None, Some(home.path())).paths,
+            vec![first]
+        );
+    }
+
+    #[test]
+    fn session_enumeration_errors_are_reported() {
+        let home = tempfile::tempdir().unwrap();
+        let backup = home.path().join(".claude-swap-backup");
+        fs::create_dir_all(&backup).unwrap();
+        fs::write(backup.join("sessions"), b"not a directory").unwrap();
+
+        let roots = claude_projects_roots(None, Some(home.path()));
+        assert!(roots.paths.is_empty());
+        assert_eq!(roots.read_failures, 1);
+        assert!(roots.has_possible_roots());
     }
 }
diff --git a/rust/src/cost_scanner/tests/claude_swap.rs b/rust/src/cost_scanner/tests/claude_swap.rs
index 23cd0e8778..3ab26169d5 100644
--- a/rust/src/cost_scanner/tests/claude_swap.rs
+++ b/rust/src/cost_scanner/tests/claude_swap.rs
@@ -24,10 +24,11 @@ fn claude_swap_homes_are_scanned_once_beside_a_literal_config_dir() {
     write_project(sessions.join("0-ignored").join("projects"), &[row("decoy")]);
 
     let roots = claude_roots::claude_projects_roots(configured.path().to_str(), Some(home.path()));
-    assert_eq!(roots, vec![configured_projects, first, second]);
+    assert_eq!(roots.paths, vec![configured_projects, first, second]);
+    assert_eq!(roots.read_failures, 0);
 
-    // A dangling profile directory only costs one read failure.
-    let mut scan_roots = roots;
+    // A root that disappears before traversal is recorded as a read failure.
+    let mut scan_roots = roots.paths;
     scan_roots.push(home.path().join("missing").join("projects"));
     let scanner = CostScanner::new(1);
     let cutoff = Utc::now() - Duration::days(1);

From 610da6c45f6c2ec07f79983c0a6e90e3a628c4ed Mon Sep 17 00:00:00 2001
From: RCD <90105158+Finesssee@users.noreply.github.com>
Date: Thu, 1 Oct 2026 04:01:20 +0700
Subject: [PATCH 3/4] Match upstream claude-swap slot names and translate the
 swap cost tests

Accept an empty label after the slot number (upstream splits with
omittingEmptySubsequences: false), translate both
CostUsageScannerClaudeSwapTests cases with their token and cost
assertions and the two-minute rescan, and cover shared-history
de-duplication through a junction, which needs no symlink privilege.
---
 rust/src/cost_scanner/claude_roots.rs      |  56 +++++++--
 rust/src/cost_scanner/tests/claude_swap.rs | 128 +++++++++++++++++----
 2 files changed, 153 insertions(+), 31 deletions(-)

diff --git a/rust/src/cost_scanner/claude_roots.rs b/rust/src/cost_scanner/claude_roots.rs
index c1b983bfa5..6e8cbd50cf 100644
--- a/rust/src/cost_scanner/claude_roots.rs
+++ b/rust/src/cost_scanner/claude_roots.rs
@@ -29,9 +29,11 @@ impl ClaudeProjectsRoots {
 
 /// Existing Claude transcript roots, de-duplicated by resolved path.
 ///
-/// `config_dir` is the raw `CLAUDE_CONFIG_DIR` value: one literal directory,
-/// with empty meaning "unset". A root that does not exist is omitted; failures
-/// that prevent discovering existing roots are retained for scan coverage.
+/// `config_dir` is the raw `CLAUDE_CONFIG_DIR` value: one literal directory
+/// (never split on separators), with a blank value meaning "unset". A root
+/// that does not exist is omitted, which scans the same rows as upstream's
+/// empty missing root; failures that prevent discovering existing roots are
+/// retained for scan coverage.
 pub(super) fn claude_projects_roots(
     config_dir: Option<&str>,
     home: Option<&Path>,
@@ -141,13 +143,15 @@ fn is_missing_path(error: &std::io::Error) -> bool {
     )
 }
 
+/// `<N>-<label>` with `<N>` a positive integer. The label may be empty, as in
+/// upstream's `split(separator: "-", maxSplits: 1, omittingEmptySubsequences:
+/// false)` check; hidden entries are skipped like `.skipsHiddenFiles`.
 fn is_swap_slot_name(name: &str) -> bool {
     if name.starts_with('.') {
         return false;
     }
     name.split_once('-')
-        .and_then(|(number, label)| (!label.is_empty()).then_some(number))
-        .and_then(|number| number.parse::<i64>().ok())
+        .and_then(|(number, _label)| number.parse::<i64>().ok())
         .is_some_and(|number| number > 0)
 }
 
@@ -167,7 +171,7 @@ mod tests {
 
     #[test]
     fn slot_names_need_a_positive_integer_and_a_dash() {
-        for accepted in ["1-first", "12-a-b", "+5-plus"] {
+        for accepted in ["1-first", "12-a-b", "+5-plus", "3-"] {
             assert!(is_swap_slot_name(accepted), "{accepted}");
         }
         for rejected in [
@@ -176,10 +180,10 @@ mod tests {
             "unrelated",
             "abc-1",
             "7",
-            "3-",
             "",
             ".1-hidden",
             " 1-x",
+            "99999999999999999999-overflow",
         ] {
             assert!(!is_swap_slot_name(rejected), "{rejected}");
         }
@@ -289,6 +293,44 @@ mod tests {
         );
     }
 
+    /// Junctions need no symlink privilege, so this covers the resolved-path
+    /// de-duplication of a shared-history link on every Windows host.
+    #[cfg(windows)]
+    #[test]
+    fn shared_history_junction_is_scanned_once() {
+        use std::os::windows::process::CommandExt;
+        let home = tempfile::tempdir().unwrap();
+        let first = swap_home(home.path(), "1-first");
+        let second = swap_home(home.path(), "2-second");
+        let shared = home
+            .path()
+            .join(".claude-swap-backup")
+            .join("sessions")
+            .join("3-shared");
+        fs::create_dir_all(&shared).unwrap();
+        let output = std::process::Command::new("powershell.exe")
+            .args([
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                "New-Item -ItemType Junction -Path $env:CODEXBAR_TEST_LINK -Target $env:CODEXBAR_TEST_TARGET | Out-Null",
+            ])
+            .env("CODEXBAR_TEST_LINK", shared.join("projects"))
+            .env("CODEXBAR_TEST_TARGET", &first)
+            .creation_flags(0x0800_0000)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "Failed to create the shared-history junction fixture."
+        );
+        assert!(shared.join("projects").is_dir());
+
+        let roots = claude_projects_roots(None, Some(home.path()));
+        assert_eq!(roots.paths, vec![first, second]);
+        assert_eq!(roots.read_failures, 0);
+    }
+
     #[test]
     fn session_enumeration_errors_are_reported() {
         let home = tempfile::tempdir().unwrap();
diff --git a/rust/src/cost_scanner/tests/claude_swap.rs b/rust/src/cost_scanner/tests/claude_swap.rs
index 3ab26169d5..502aa3fc81 100644
--- a/rust/src/cost_scanner/tests/claude_swap.rs
+++ b/rust/src/cost_scanner/tests/claude_swap.rs
@@ -1,3 +1,5 @@
+//! Upstream 0.65.0 `CostUsageScannerClaudeSwapTests`, translated.
+
 use super::*;
 
 fn write_project(projects: PathBuf, rows: &[String]) -> PathBuf {
@@ -7,40 +9,118 @@ fn write_project(projects: PathBuf, rows: &[String]) -> PathBuf {
     projects
 }
 
+/// Upstream `row(env:day:id:input:)`: one priced Sonnet 4.5 request.
+fn swap_row(timestamp: &str, id: &str, input: u64) -> String {
+    format!(
+        r#"{{"type":"assistant","timestamp":"{timestamp}","requestId":"request-{id}","message":{{"id":"{id}","model":"claude-sonnet-4-5-20250929","usage":{{"input_tokens":{input},"output_tokens":10}}}}}}"#
+    )
+}
+
+/// Aggregate `roots` the way the summary scan does: one `seen` set across
+/// every root, so a row copied between homes is counted once.
+fn scan_roots(roots: &[PathBuf]) -> (CostSummary, u32) {
+    let scanner = CostScanner::new(1);
+    let cutoff = Utc::now() - Duration::days(1);
+    let mut seen = HashSet::new();
+    let mut pricing = ClaudeScanPricingResolver::default();
+    let mut summary = CostSummary::default();
+    let read_failures = scanner.walk_claude_roots(roots, &cutoff, None, &mut |path| {
+        let result =
+            scan_claude_file_with_pricing(path, &cutoff, &mut seen, None, &mut pricing, |row| {
+                assert!(add_claude_record_to_summary(&mut summary, row));
+            });
+        assert!(result.is_complete(), "{result:?}");
+    });
+    (summary, read_failures)
+}
+
 #[test]
-fn claude_swap_homes_are_scanned_once_beside_a_literal_config_dir() {
+fn two_swap_homes_contribute_once_across_copied_and_shared_history() {
     let home = tempfile::tempdir().unwrap();
-    let configured = tempfile::tempdir().unwrap();
     let timestamp = Utc::now().to_rfc3339();
-    let row = |id: &str| claude_transcript_line(&timestamp, "requestId", id, id);
     let sessions = home.path().join(".claude-swap-backup").join("sessions");
-    let configured_projects = write_project(configured.path().join("projects"), &[row("literal")]);
-    let first = write_project(sessions.join("1-first").join("projects"), &[row("first")]);
+    let first = write_project(
+        sessions.join("1-first").join("projects"),
+        &[swap_row(&timestamp, "first", 100)],
+    );
     // The second home carries a copy of the first home's row.
     let second = write_project(
         sessions.join("2-second").join("projects"),
-        &[row("first"), row("second")],
+        &[
+            swap_row(&timestamp, "first", 100),
+            swap_row(&timestamp, "second", 200),
+        ],
     );
-    write_project(sessions.join("0-ignored").join("projects"), &[row("decoy")]);
+    for decoy in ["unrelated", "0-zero"] {
+        write_project(
+            sessions.join(decoy).join("projects"),
+            &[swap_row(&timestamp, decoy, 999)],
+        );
+    }
+    // Shared history resolves to the first home; a dangling link is skipped.
+    // Creating either link needs the symlink privilege on Windows, and the
+    // expected roots are the same with or without them.
+    #[cfg(windows)]
+    {
+        for (slot, target) in [
+            ("3-shared", first.clone()),
+            ("4-missing", home.path().join("gone")),
+        ] {
+            std::fs::create_dir_all(sessions.join(slot)).unwrap();
+            let _ = std::os::windows::fs::symlink_dir(target, sessions.join(slot).join("projects"));
+        }
+    }
 
-    let roots = claude_roots::claude_projects_roots(configured.path().to_str(), Some(home.path()));
-    assert_eq!(roots.paths, vec![configured_projects, first, second]);
+    let roots = claude_roots::claude_projects_roots(None, Some(home.path()));
+    assert_eq!(roots.paths, vec![first, second]);
     assert_eq!(roots.read_failures, 0);
+    // Swap homes alone count as a token-cost source.
+    assert!(roots.has_possible_roots());
 
-    // A root that disappears before traversal is recorded as a read failure.
-    let mut scan_roots = roots.paths;
-    scan_roots.push(home.path().join("missing").join("projects"));
-    let scanner = CostScanner::new(1);
-    let cutoff = Utc::now() - Duration::days(1);
-    let mut seen = HashSet::new();
-    let mut pricing = ClaudeScanPricingResolver::default();
-    let mut counted = 0usize;
-    let read_failures = scanner.walk_claude_roots(&scan_roots, &cutoff, None, &mut |path| {
-        counted +=
-            scan_claude_file_with_pricing(path, &cutoff, &mut seen, None, &mut pricing, |_| {})
-                .counted;
-    });
+    // Upstream rescans two minutes later; totals must not drift on a rerun.
+    for _ in 0..2 {
+        let (summary, read_failures) = scan_roots(&roots.paths);
+        assert_eq!(read_failures, 0);
+        assert_eq!(summary.input_tokens + summary.output_tokens, 320);
+        assert_eq!(summary.cached_tokens, 0);
+        assert!(
+            (summary.total_cost_usd - 0.0012).abs() < 1e-9,
+            "{}",
+            summary.total_cost_usd
+        );
+        assert!(summary.unknown_models.is_empty());
+    }
+}
+
+#[test]
+fn literal_configured_home_remains_included_beside_discovered_swap_homes() {
+    let home = tempfile::tempdir().unwrap();
+    let timestamp = Utc::now().to_rfc3339();
+    // A literal value with a comma and a space is one directory, not a list.
+    let configured = home.path().join("custom, home");
+    let configured_projects = write_project(
+        configured.join("projects"),
+        &[swap_row(&timestamp, "literal", 100)],
+    );
+    let swap = write_project(
+        home.path()
+            .join(".claude-swap-backup")
+            .join("sessions")
+            .join("2-second")
+            .join("projects"),
+        &[swap_row(&timestamp, "second", 200)],
+    );
 
-    assert_eq!(read_failures, 1);
-    assert_eq!(counted, 3, "literal + first + second; the copy counts once");
+    let roots = claude_roots::claude_projects_roots(configured.to_str(), Some(home.path()));
+    assert_eq!(roots.paths, vec![configured_projects, swap]);
+    assert_eq!(roots.read_failures, 0);
+
+    let (summary, read_failures) = scan_roots(&roots.paths);
+    assert_eq!(read_failures, 0);
+    assert_eq!(summary.input_tokens + summary.output_tokens, 320);
+
+    // A root that disappears before traversal is recorded as a read failure.
+    let mut scan_paths = roots.paths;
+    scan_paths.push(home.path().join("missing").join("projects"));
+    assert_eq!(scan_roots(&scan_paths).1, 1);
 }

From 2808b1bf6241415da1d3f6e2c2635bc3f88e75e9 Mon Sep 17 00:00:00 2001
From: RCD <90105158+Finesssee@users.noreply.github.com>
Date: Thu, 1 Oct 2026 04:07:12 +0700
Subject: [PATCH 4/4] Drop the optional symlink fixture results explicitly

---
 rust/src/cost_scanner/tests/claude_swap.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rust/src/cost_scanner/tests/claude_swap.rs b/rust/src/cost_scanner/tests/claude_swap.rs
index 502aa3fc81..94c7a53e3c 100644
--- a/rust/src/cost_scanner/tests/claude_swap.rs
+++ b/rust/src/cost_scanner/tests/claude_swap.rs
@@ -67,7 +67,10 @@ fn two_swap_homes_contribute_once_across_copied_and_shared_history() {
             ("4-missing", home.path().join("gone")),
         ] {
             std::fs::create_dir_all(sessions.join(slot)).unwrap();
-            let _ = std::os::windows::fs::symlink_dir(target, sessions.join(slot).join("projects"));
+            drop(std::os::windows::fs::symlink_dir(
+                target,
+                sessions.join(slot).join("projects"),
+            ));
         }
     }