Tests: Trim two tests that crossed the 8 s nextest cap

Both tests passed in isolation but timed out when `./scripts/check.sh` ran them under its full parallel-check contention. The 8 s cap is intentional (see `.config/nextest.toml`); the policy is to refactor the workload, not to bump it. Confirmed by three back-to-back green runs after the change.
- `file_system::volume::in_memory_test::test_concurrent_reads`: 10 tasks × 100 iters (~1 M `RwLock<HashMap>` ops + entry materialisations) → 10 × 25 iters (250 interleavings, still plenty of pressure to surface a race). Was 2.0 s in isolation; trimmed to ~1.25 s, comfortably under cap.
- `file_system::git::m3_tests::commits_listing_cancellation_polls_atomic_flag`: `build_simple_repo(20)` (≈31 `git` shell-outs) → `build_simple_repo(5)`. With the cancel flag pre-set, even 5 commits is enough to prove the walk got cut short (`entries.len() < 5`). The fixture build dominated; the listing call itself is microseconds.
- Also included: an `oxfmt` reflow of the CLAUDE.md selection note that landed in the previous commit (auto-fixed by check.sh).

Author: vdavid

apps/desktop/src-tauri/src/file_system/git/m3_tests.rs

@@ -129,7 +129,14 @@ fn commits_caps_listing_at_max() {
 #[test]
 fn commits_listing_cancellation_polls_atomic_flag() {
     use std::sync::atomic::Ordering;
-    let dir = build_simple_repo(20);
+    // 5 commits is enough to prove the walk got cut short: with the flag
+    // pre-set, even one returned entry would still be `< 5`. The earlier
+    // shape used 20 commits, which made the `build_simple_repo` shell-out
+    // chain (~31 `git` calls) the dominant cost and pushed the test to
+    // ~5 s warm / >8 s under `check.sh` parallel-check load (timing
+    // confirmed in three back-to-back runs). The 8 s cap is intentional
+    // (see `.config/nextest.toml`); trim the fixture instead.
+    let dir = build_simple_repo(5);
     let (handle, root) = discover_repo(&dir).unwrap();
 
     // Pre-set the cancel flag so the walk bails after 0 commits.
@@ -138,8 +145,8 @@ fn commits_listing_cancellation_polls_atomic_flag() {
     git_log::cancel_flag().store(false, Ordering::Relaxed);
 
     assert!(
-        entries.len() < 20,
-        "cancellation should stop the walk before all 20 commits arrive"
+        entries.len() < 5,
+        "cancellation should stop the walk before all 5 commits arrive"
     );
     cleanup(&dir);
 }

apps/desktop/src-tauri/src/file_system/volume/in_memory_test.rs

@@ -335,14 +335,20 @@ async fn test_rename_nonexistent_source() {
 async fn test_concurrent_reads() {
     use std::sync::Arc;
 
+    // 10 concurrent tasks × 25 iterations each = 250 interleaved reads. The
+    // earlier shape (100 iters, ~1 M entry materialisations across threads)
+    // passed in ~2 s in isolation but timed out at 8 s under `check.sh`'s
+    // parallel-check load — per `.config/nextest.toml` we trim the workload
+    // rather than bump the cap. Concurrency races surface at much smaller
+    // scale than this; 250 interleavings is plenty of pressure on the
+    // `RwLock<HashMap>`.
     let volume = Arc::new(InMemoryVolume::with_file_count("Test", 1000));
     let mut handles = vec![];
 
-    // Spawn 10 tasks doing concurrent reads
     for _ in 0..10 {
         let vol = Arc::clone(&volume);
         handles.push(tokio::spawn(async move {
-            for _ in 0..100 {
+            for _ in 0..25 {
                 let _ = vol.list_directory(Path::new(""), None).await;
                 let _ = vol.exists(Path::new("/file_000001.txt")).await;
                 let _ = vol.get_metadata(Path::new("/file_000010.txt")).await;