revert: remove cache directory exclusion from fspy tracking

The cache directory should not be special-cased in fspy. Instead, tests that
run tools like oxlint should include a .gitignore with 'node_modules' to
prevent the tool from traversing the cache directory — matching the setup
of real projects.

Author: branchseer

crates/vite_task/src/session/execute/mod.rs

@@ -5,7 +5,7 @@ use std::{process::Stdio, sync::Arc};
 
 use futures_util::FutureExt;
 use tokio::io::AsyncWriteExt as _;
-use vite_path::{AbsolutePath, RelativePath};
+use vite_path::AbsolutePath;
 use vite_task_plan::{
     ExecutionGraph, ExecutionItemDisplay, ExecutionItemKind, LeafExecutionKind, SpawnCommand,
     SpawnExecution,
@@ -56,11 +56,6 @@ struct ExecutionContext<'a> {
     /// Base path for resolving relative paths in cache entries.
     /// Typically the workspace root.
     cache_base_path: &'a Arc<AbsolutePath>,
-    /// Cache directory path relative to the workspace root.
-    /// Used to exclude cache directory accesses from fspy tracking (the cache
-    /// directory is infrastructure, not a task input).
-    /// `None` when the cache directory is outside the workspace (custom `VITE_CACHE_PATH`).
-    cache_dir_relative: Option<&'a RelativePath>,
 }
 
 impl ExecutionContext<'_> {
@@ -157,14 +152,9 @@ impl ExecutionContext<'_> {
                     clippy::large_futures,
                     reason = "spawn execution with cache management creates large futures"
                 )]
-                let _ = execute_spawn(
-                    leaf_reporter,
-                    spawn_execution,
-                    self.cache,
-                    self.cache_base_path,
-                    self.cache_dir_relative,
-                )
-                .await;
+                let _ =
+                    execute_spawn(leaf_reporter, spawn_execution, self.cache, self.cache_base_path)
+                        .await;
             }
         }
     }
@@ -194,7 +184,6 @@ pub async fn execute_spawn(
     spawn_execution: &SpawnExecution,
     cache: &ExecutionCache,
     cache_base_path: &Arc<AbsolutePath>,
-    cache_dir_relative: Option<&RelativePath>,
 ) -> SpawnOutcome {
     let cache_metadata = spawn_execution.cache_metadata.as_ref();
 
@@ -304,7 +293,6 @@ pub async fn execute_spawn(
         &mut stdio_config.stdout_writer,
         &mut stdio_config.stderr_writer,
         track_result_with_cache_metadata.as_mut().map(|(track_result, _)| track_result),
-        cache_dir_relative,
     )
     .await
     {
@@ -430,7 +418,6 @@ impl Session<'_> {
             reporter: &mut *reporter,
             cache,
             cache_base_path: &self.workspace_path,
-            cache_dir_relative: self.cache_dir_relative.as_deref(),
         };
 
         // Execute the graph. Leaf-level errors are reported through the reporter

crates/vite_task/src/session/execute/spawn.rs

@@ -11,7 +11,7 @@ use fspy::AccessMode;
 use rustc_hash::FxHashSet;
 use serde::Serialize;
 use tokio::io::{AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _};
-use vite_path::{AbsolutePath, RelativePath, RelativePathBuf};
+use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_task_plan::SpawnCommand;
 
 use crate::collections::HashMap;
@@ -75,7 +75,6 @@ pub async fn spawn_with_tracking(
     stdout_writer: &mut (dyn AsyncWrite + Unpin),
     stderr_writer: &mut (dyn AsyncWrite + Unpin),
     track_result: Option<&mut SpawnTrackResult>,
-    cache_dir_relative: Option<&RelativePath>,
 ) -> anyhow::Result<SpawnResult> {
     /// The tracking state of the spawned process
     enum TrackingState<'a> {
@@ -207,16 +206,6 @@ pub async fn spawn_with_tracking(
             continue;
         }
 
-        // Skip cache directory accesses — the cache directory is infrastructure
-        // (SQLite DB, last-summary.json), not a task input. Tools like oxlint may
-        // traverse node_modules/ and read files in the cache directory, which would
-        // otherwise cause spurious cache misses when those files change between runs.
-        if let Some(cache_dir) = cache_dir_relative
-            && relative_path.as_path().strip_prefix(cache_dir).is_ok()
-        {
-            continue;
-        }
-
         if access.mode.contains(AccessMode::READ) {
             path_reads.entry(relative_path.clone()).or_insert(PathRead { read_dir_entries: false });
         }

crates/vite_task/src/session/mod.rs

@@ -15,7 +15,7 @@ use reporter::{
     summary::{LastRunSummary, ReadSummaryError, format_full_summary},
 };
 use rustc_hash::FxHashMap;
-use vite_path::{AbsolutePath, AbsolutePathBuf, RelativePathBuf};
+use vite_path::{AbsolutePath, AbsolutePathBuf};
 use vite_select::SelectItem;
 use vite_str::Str;
 use vite_task_graph::{
@@ -141,11 +141,6 @@ pub struct Session<'a> {
     /// processes (e.g., parallel `vp lib` commands) start simultaneously.
     cache: OnceCell<ExecutionCache>,
     cache_path: AbsolutePathBuf,
-    /// Cache directory path relative to the workspace root.
-    /// Used to exclude cache directory accesses from fspy tracking (the cache
-    /// directory is infrastructure, not a task input).
-    /// `None` when the cache directory is outside the workspace (custom `VITE_CACHE_PATH`).
-    cache_dir_relative: Option<RelativePathBuf>,
 }
 
 fn get_cache_path_of_workspace(workspace_root: &AbsolutePath) -> AbsolutePathBuf {
@@ -203,12 +198,6 @@ impl<'a> Session<'a> {
         let (workspace_root, _) = find_workspace_root(&cwd)?;
         let cache_path = get_cache_path_of_workspace(&workspace_root.path);
 
-        // Compute the cache directory path relative to the workspace root.
-        // Used to exclude cache directory accesses from fspy tracking.
-        // `None` if the cache path is outside the workspace (custom VITE_CACHE_PATH)
-        // or if stripping the prefix fails.
-        let cache_dir_relative = cache_path.strip_prefix(&workspace_root.path).ok().flatten();
-
         // Prepend workspace's node_modules/.bin to PATH
         let workspace_node_modules_bin = workspace_root.path.join("node_modules").join(".bin");
         prepend_path_env(&mut envs, &workspace_node_modules_bin)?;
@@ -225,7 +214,6 @@ impl<'a> Session<'a> {
             plan_request_parser: PlanRequestParser { command_handler: callbacks.command_handler },
             cache: OnceCell::new(),
             cache_path,
-            cache_dir_relative,
         })
     }
 
@@ -557,7 +545,6 @@ impl<'a> Session<'a> {
             &spawn_execution,
             cache,
             &self.workspace_path,
-            self.cache_dir_relative.as_deref(),
         )
         .await
         {