fix(vfs): skip CAS round-trip for reads on reused-staging opens

The prior commit installed sparse_write on the can_reuse_staging path
to enable range_upload at flush time. That regressed reads: a writable
handle that hadn't written anything yet would still call
fill_sparse_holes, which downloaded CAS bytes for the whole read region
even though the staging file already held the full original content.

Add a `staging_holds_full_original` flag to SparseWriteState, set via
`new_with_full_staging` on the reused-staging path only. When true,
fill_sparse_holes short-circuits — staging is the source of truth for
non-dirty bytes, and track_write keeps that invariant on subsequent
writes. Fresh sparse opens (where staging is an actual hole) leave the
flag false and continue to fill from CAS.

Author: XciD

src/virtual_fs/inode.rs

@@ -173,6 +173,15 @@ pub struct SparseWriteState {
     pub effective_original_size: u64,
     /// Sorted, non-overlapping dirty byte ranges (start, end), in current-file coordinates.
     pub dirty_ranges: Vec<(u64, u64)>,
+    /// When true, the on-disk staging file holds the full original content in
+    /// [0, effective_original_size) — set for opens that reuse a current
+    /// staging cache (no fresh sparse hole was created). Reads can serve
+    /// directly from staging without consulting CAS; `fill_sparse_holes`
+    /// short-circuits to a no-op. Stays valid for the lifetime of the open
+    /// because dirty writes overlay onto the existing bytes (track_write
+    /// updates both staging and the dirty range list) and the snapshot hash
+    /// is pinned once dirty is set.
+    pub staging_holds_full_original: bool,
 }
 
 impl SparseWriteState {
@@ -182,6 +191,16 @@ impl SparseWriteState {
             original_size,
             effective_original_size: original_size,
             dirty_ranges: Vec::new(),
+            staging_holds_full_original: false,
+        }
+    }
+
+    /// Variant of `new` for reused-staging opens: the staging file already
+    /// holds the full original content, so reads bypass CAS.
+    pub fn new_with_full_staging(original_hash: String, original_size: u64) -> Self {
+        Self {
+            staging_holds_full_original: true,
+            ..Self::new(original_hash, original_size)
         }
     }
 
@@ -2697,6 +2716,32 @@ mod tests {
         assert_eq!(table.lookup_child(ROOT_INODE, "a.txt").map(|e| e.inode), Some(a2));
     }
 
+    // ── SparseWriteState constructors ───────────────────────────────
+
+    #[test]
+    fn sparse_new_defaults_to_empty_holes() {
+        let sw = SparseWriteState::new("h".into(), 100);
+        assert!(
+            !sw.staging_holds_full_original,
+            "fresh sparse open: staging is a hole, must consult CAS on reads"
+        );
+        assert_eq!(sw.original_size, 100);
+        assert_eq!(sw.effective_original_size, 100);
+        assert!(sw.dirty_ranges.is_empty());
+    }
+
+    #[test]
+    fn sparse_new_with_full_staging_marks_flag() {
+        let sw = SparseWriteState::new_with_full_staging("h".into(), 100);
+        assert!(
+            sw.staging_holds_full_original,
+            "reused-staging open: fill_sparse_holes must short-circuit"
+        );
+        assert_eq!(sw.original_size, 100);
+        assert_eq!(sw.effective_original_size, 100);
+        assert!(sw.dirty_ranges.is_empty());
+    }
+
     // ── SparseWriteState::track_write ───────────────────────────────
 
     //  0    10   20   30

src/virtual_fs/mod.rs

@@ -1787,14 +1787,23 @@ impl VirtualFs {
             } else if will_install_sparse && entry.sparse_write.is_none() {
                 // Install sparse tracking against the snapshot hash. Covers two
                 // cases under the same drift guard:
-                //  * created_sparse_staging: staging is a hole sized to snapshot;
-                //    reads fill from CAS via `fill_sparse_holes`.
-                //  * reused staging: on-disk file matches the snapshot hash
-                //    fully (staging_is_current path); reads serve from staging
-                //    and fill_sparse_holes is a no-op for non-dirty regions.
+                //  * fresh sparse staging (can_reuse_staging=false): staging is
+                //    a hole sized to snapshot; reads must fill from CAS via
+                //    `fill_sparse_holes`.
+                //  * reused staging (can_reuse_staging=true with staging_is_current
+                //    snapshotted true): on-disk file already holds the full
+                //    original content for the snapshot hash. Mark it via
+                //    `new_with_full_staging` so `fill_sparse_holes` is a no-op
+                //    and reads serve directly from staging without an extra
+                //    CAS round-trip.
                 // Once set_dirty has fired, poll skips this inode so the snapshot
                 // remains valid for the lifetime of the open.
-                entry.sparse_write = Some(Arc::new(inode::SparseWriteState::new(xet_hash.to_string(), size)));
+                let sw = if can_reuse_staging {
+                    inode::SparseWriteState::new_with_full_staging(xet_hash.to_string(), size)
+                } else {
+                    inode::SparseWriteState::new(xet_hash.to_string(), size)
+                };
+                entry.sparse_write = Some(Arc::new(sw));
             }
         }
 
@@ -2132,6 +2141,15 @@ impl VirtualFs {
             return Ok(());
         }
 
+        // Reused-staging open: the on-disk file holds the full original content
+        // for the snapshot hash, so reads outside dirty ranges are already served
+        // correctly by the prior pread. Skip CAS to avoid an unnecessary round-
+        // trip — track_write keeps overlaying user bytes onto staging, so the
+        // invariant still holds for dirty regions too.
+        if sparse_write_state.staging_holds_full_original {
+            return Ok(());
+        }
+
         // Skip the CAS download if the read region is fully covered by dirty ranges
         // (the staging file already has the right data, no sparse holes to fill).
         let ranges = &sparse_write_state.dirty_ranges;