Git browser: per-file Modified in snapshots

- Snapshot listings (`.git/branches/main/src/`, `.git/commits/<sha>/`, etc.) now show each entry's last-touched commit date instead of the snapshot's commit date.
- New `git/snapshot_dates.rs` module: walks commits backwards from the snapshot, diffs each against its first parent, and attributes the committer time to any pending top-level entry the diff touches. Stops when every entry is dated, after 1000 commits, or when the rev-walk runs out.
- Initial commits short-circuit (every entry gets the initial commit's date).
- Subdirs get the date of the most recent commit that touched any file underneath.
- Process-global FIFO cache (50 keys), content-addressable so it never invalidates.
- Bench: 100 entries × 5000 commits cold p95=21 ms (budget 200 ms), warm p95=2 µs cache hit. New ignored bench at 50k commits stays inside the 500 ms budget.
- Tests: per-file dates on three-files / dir / cache-hit / cap-fallback / initial-commit fixtures.
- Falls back to the snapshot date when the cap fires so the cell never reads as blank.

Author: vdavid

apps/desktop/src-tauri/src/file_system/git/CLAUDE.md

@@ -27,7 +27,8 @@ three new error variants (`ShallowBoundary`, `MissingObject`,
 | `stash.rs` | `list_stashes(repo_root)`, `resolve_stash_commit(handle, n)` – shells out to `git stash list -z` and `git rev-parse stash@{n}` (gix has no public stash API). `list_stashes` doesn't take a `RepoHandle` because the shell-out only needs `repo_root` for `git -C` |
 | `worktrees.rs` | `list_worktrees` – gix `Repository::worktrees()`. Each entry sets `redirect_to_path` to the worktree's working dir |
 | `submodules.rs` | `list_submodules` – gix `Repository::submodules()`. Each entry sets `redirect_to_path` to `<repo_root>/<rel-path>` |
-| `tree.rs` | `list_tree`, `get_tree_entry`, `lookup_blob_id`, `read_blob` – gix tree walks. Permissions reflect `EntryKind::BlobExecutable` so cross-volume copy preserves the executable bit |
+| `tree.rs` | `list_tree`, `get_tree_entry`, `lookup_blob_id`, `read_blob` – gix tree walks. Permissions reflect `EntryKind::BlobExecutable` so cross-volume copy preserves the executable bit. `list_tree` calls `snapshot_dates::decode_per_file_dates` for per-file Modified dates, falling back to the snapshot date |
+| `snapshot_dates.rs` | `decode_per_file_dates(commit, dir_path)` walks commits backwards from `commit`, diffs each against its first parent, and attributes the committer time to any pending top-level entry the diff touches. Capped at `MAX_COMMITS_PER_WALK` (1000). FIFO-bounded process-global cache keyed on `(commit_id, dir_path)` — cache is content-addressable so it never goes stale |
 | `read_blob.rs` | `GitBlobReadStream` – owns the full `Vec<u8>` and yields 256 KB chunks. See *Honest blob streaming* below |
 | `status.rs` | `list_status(repo, dir)` runs a full-repo `git status --porcelain=v2 -z` once per `.git/index` mtime, caches the result in a process-global `RwLock<HashMap<RepoRoot, CachedStatus>>`, and slices it by `dir`. The watcher invalidates the snapshot whenever `.git/*` changes. Parses porcelain v2 in `parse_porcelain_v2`. |
 | `watcher.rs` | `GitWatcherRegistry` – per-repo notify-rs debouncer. `subscribe(app, root)` returns the current `RepoInfo` synchronously and emits `git-state-changed` on relevant `.git/*` mutations. 200 ms debounce. M2: also calls `notify_directory_changed(.., FullRefresh)` for any cached `.git/{branches,tags}/` listings on the local volume |
@@ -134,8 +135,8 @@ Every virtual entry carries a real `modified_at` and most carry a `display_size`
 | `stash/<n>/` | stash creation date | `on main` (parsed from stash subject) | 0 |
 | `worktrees/<name>` (redirect) | worktree HEAD date | `on feature-x` or short SHA | 0 |
 | `submodules/<name>` (redirect) | pinned commit date | short SHA | 0 |
-| inside snapshots — files | snapshot commit date | None (blob bytes) | blob bytes |
-| inside snapshots — subdirs | snapshot commit date | None (recursive bytes) | recursive blob bytes |
+| inside snapshots — files | most recent commit that touched the file (fallback: snapshot commit date) | None (blob bytes) | blob bytes |
+| inside snapshots — subdirs | most recent commit that touched any file underneath (fallback: snapshot commit date) | None (recursive bytes) | recursive blob bytes |
 
 Cross-category Size sort is meaningless (ahead-count vs files-changed vs item count); that's an honest tradeoff — each cell is self-explaining via `display_size_tooltip` (also used as the aria-label).
 
@@ -146,6 +147,9 @@ The frontend reads `display_size` / `display_size_tooltip` from `FileEntry`; the
 
 ## Decisions
 
+**Decision (M4 follow-up)**: Per-file Modified dates inside snapshot listings via walk-once batching
+**Why**: The snapshot date ("when this commit landed") is the same value for every file inside a `branches/main/`, `commits/<sha>/`, etc. listing — semantically correct as a "frozen point in time", but useless as a "when did I last work on this?" hint. We now run a single rev-walk per `(commit_id, dir_path)` listing: from the snapshot commit backwards by commit time, first-parent only, diffing each commit against its first parent (gix's `Tree::changes()::for_each_to_obtain_tree`). Each `Change.location` is matched against the directory's top-level entries; the first-seen commit's committer time wins. The walk stops early when every entry is dated, after `MAX_COMMITS_PER_WALK` (1000), or when the rev-walk exits. Initial commits short-circuit. Cache is process-global, FIFO-bounded at 50 keys, content-addressable so it never invalidates. Bench: 100 entries × 5000 commits cold p95=21 ms (budget 200 ms), warm p95=2 µs. 50k-commit fixture sits inside the 500 ms budget too. Entries that don't surface within the cap fall back to the snapshot date so the cell never reads as blank.
+
 **Decision (M4 follow-up)**: Cache `list_status` results keyed by `.git/index` mtime
 **Why**: Status used to walk the worktree on every `listing-complete` (every nav,
 every diff). On a 50k-file repo that's ~75 ms per nav. We now run one full-repo

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

@@ -215,6 +215,116 @@ fn bench_list_branches_with_ahead_behind() {
     let _ = std::fs::remove_dir_all(&dir);
 }
 
+// ── Per-file Modified dates inside snapshots ────────────────────────
+
+/// Builds a deep-history fixture: `commits` commits, each touching one
+/// file in a 100-entry top-level dir. Used to bench the per-file date
+/// walk-once batching at "Cmdr-scale" (5000 commits) and "monorepo-scale"
+/// (50k commits).
+fn build_deep_history_fixture(commits: usize, top_level_files: usize, name: &str) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!("cmdr_bench_per_file_dates_{}_{}", name, std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    run(&dir, &["init", "-q", "-b", "main"]);
+    run(&dir, &["config", "user.name", "Bench"]);
+    run(&dir, &["config", "user.email", "bench@cmdr.local"]);
+    // Seed `top_level_files` files in one commit so the listing has
+    // something to walk over.
+    for f in 0..top_level_files {
+        std::fs::write(dir.join(format!("f{:04}.txt", f)), b"seed\n").unwrap();
+    }
+    run(&dir, &["add", "."]);
+    run(&dir, &["commit", "-q", "-m", "seed"]);
+    // Then `commits-1` follow-up commits. Each touches a single file in a
+    // round-robin pattern so each top-level file gets its date set fairly
+    // recently.
+    for n in 1..commits {
+        let f = n % top_level_files;
+        std::fs::write(dir.join(format!("f{:04}.txt", f)), format!("change {}\n", n).as_bytes()).unwrap();
+        run(&dir, &["add", "."]);
+        run(&dir, &["commit", "-q", "-m", &format!("c{}", n)]);
+    }
+    dir
+}
+
+#[test]
+#[ignore = "Slow: builds a 5000-commit fixture; opt-in via `cargo test -- --ignored`"]
+fn bench_per_file_dates_5k_commits_under_budget() {
+    use super::path::Cat;
+    use super::snapshot_dates;
+    use super::virtual_listing;
+    let dir = build_deep_history_fixture(5_000, 100, "5k");
+    let (handle, _) = discover_repo(&dir).expect("discover");
+    let commit = virtual_listing::resolve_ref_commit(&handle, Cat::Branches, "main").expect("resolve main");
+
+    // Cold: clear cache before each run.
+    let mut cold = Vec::with_capacity(RUNS);
+    for _ in 0..RUNS {
+        snapshot_dates::clear_cache();
+        let start = Instant::now();
+        let dates = snapshot_dates::decode_per_file_dates(&handle, commit, "").expect("dates");
+        cold.push(start.elapsed().as_micros());
+        assert_eq!(dates.len(), 100, "every top-level entry dated");
+    }
+    let cold_p95 = percentile(cold.clone(), 95.0);
+    let cold_p50 = percentile(cold.clone(), 50.0);
+    eprintln!(
+        "per_file_dates 100 entries / 5k commits (cold): p50={}ms p95={}ms (budget 200 ms)",
+        cold_p50 / 1000,
+        cold_p95 / 1000
+    );
+    assert!(cold_p95 / 1000 <= 200, "p95 over 200 ms budget: {}ms", cold_p95 / 1000);
+
+    // Warm: cache hit.
+    snapshot_dates::clear_cache();
+    let _ = snapshot_dates::decode_per_file_dates(&handle, commit, "").expect("warmup");
+    let mut warm = Vec::with_capacity(RUNS);
+    for _ in 0..RUNS {
+        let start = Instant::now();
+        let _ = snapshot_dates::decode_per_file_dates(&handle, commit, "").expect("dates");
+        warm.push(start.elapsed().as_micros());
+    }
+    let warm_p95 = percentile(warm.clone(), 95.0);
+    let warm_p50 = percentile(warm.clone(), 50.0);
+    eprintln!(
+        "per_file_dates (warm, cache hit): p50={}µs p95={}µs",
+        warm_p50, warm_p95
+    );
+    assert!(warm_p95 <= 5_000, "warm p95 over 5 ms: {}µs", warm_p95);
+
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+#[ignore = "Very slow: builds a 50k-commit fixture; opt-in via `cargo test -- --ignored`"]
+fn bench_per_file_dates_50k_commits_under_budget() {
+    use super::path::Cat;
+    use super::snapshot_dates;
+    use super::virtual_listing;
+    let dir = build_deep_history_fixture(50_000, 100, "50k");
+    let (handle, _) = discover_repo(&dir).expect("discover");
+    let commit = virtual_listing::resolve_ref_commit(&handle, Cat::Branches, "main").expect("resolve main");
+
+    let mut cold = Vec::with_capacity(RUNS);
+    for _ in 0..RUNS {
+        snapshot_dates::clear_cache();
+        let start = Instant::now();
+        let _ = snapshot_dates::decode_per_file_dates(&handle, commit, "").expect("dates");
+        cold.push(start.elapsed().as_micros());
+    }
+    let cold_p95 = percentile(cold.clone(), 95.0);
+    let cold_p50 = percentile(cold.clone(), 50.0);
+    eprintln!(
+        "per_file_dates 100 entries / 50k commits (cold, capped at {} commits walked): p50={}ms p95={}ms (budget 500 ms)",
+        snapshot_dates::MAX_COMMITS_PER_WALK,
+        cold_p50 / 1000,
+        cold_p95 / 1000
+    );
+    assert!(cold_p95 / 1000 <= 500, "p95 over 500 ms budget: {}ms", cold_p95 / 1000);
+
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
 #[test]
 #[ignore = "Slow: builds a 200-commit fixture; opt-in via `cargo test -- --ignored`"]
 fn bench_list_commits_files_changed() {

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

@@ -42,6 +42,7 @@ pub mod log;
 pub mod path;
 pub mod read_blob;
 pub mod repo;
+pub mod snapshot_dates;
 pub mod stash;
 pub mod status;
 pub mod submodules;
@@ -59,6 +60,8 @@ mod m3_tests;
 #[cfg(test)]
 mod m4_tests;
 #[cfg(test)]
+mod snapshot_dates_tests;
+#[cfg(test)]
 mod tests;
 
 #[allow(