feat(cache): disable fspy when auto inference is off

- Add FSPY=1 env var to tracked processes in fspy crate (unix + windows)
  to indicate when file tracking is active
- Split SpawnTrackResult into separate Vec<StdOutput> and TrackedPathAccesses
  to decouple output capturing from file access tracking
- Only enable fspy when input_config.includes_auto is true
- When inference is disabled (explicit globs only), spawn without fspy
  overhead while still capturing outputs for cache replay
- Add e2e tests verifying FSPY env is set/unset based on config

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: branchseer

crates/fspy/src/unix/mod.rs

@@ -100,6 +100,7 @@ impl SpyImpl {
         )
         .map_err(|err| SpawnError::Injection(err.into()))?;
         command.set_exec(exec);
+        command.env("FSPY", "1");
 
         let mut tokio_command = command.into_tokio_command();
 

crates/fspy/src/windows/mod.rs

@@ -73,8 +73,9 @@ impl SpyImpl {
     }
 
     #[expect(clippy::unused_async, reason = "async signature required by SpyImpl trait")]
-    pub(crate) async fn spawn(&self, command: Command) -> Result<TrackedChild, SpawnError> {
+    pub(crate) async fn spawn(&self, mut command: Command) -> Result<TrackedChild, SpawnError> {
         let ansi_dll_path_with_nul = Arc::clone(&self.ansi_dll_path_with_nul);
+        command.env("FSPY", "1");
         let mut command = command.into_tokio_command();
 
         command.creation_flags(CREATE_SUSPENDED);

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

@@ -29,7 +29,8 @@ use super::{
         StdioSuggestion,
     },
 };
-use crate::{Session, session::execute::spawn::SpawnTrackResult};
+use crate::Session;
+use self::spawn::TrackedPathAccesses;
 
 /// Outcome of a spawned execution.
 ///
@@ -309,8 +310,19 @@ pub async fn execute_spawn(
     }
 
     // 5. Piped mode: execute spawn with tracking, streaming output to writers.
-    let mut track_result_with_cache_metadata_and_inputs =
-        cache_metadata.map(|cache_metadata| (SpawnTrackResult::default(), cache_metadata, globbed_inputs));
+    //    - std_outputs: always captured when caching is enabled (for cache replay)
+    //    - path_accesses: only tracked when includes_auto is true (fspy inference)
+    let (mut std_outputs, mut path_accesses, cache_metadata_and_inputs) =
+        if let Some(cache_metadata) = cache_metadata {
+            let path_accesses = if cache_metadata.input_config.includes_auto {
+                Some(TrackedPathAccesses::default())
+            } else {
+                None // Skip fspy when inference is disabled
+            };
+            (Some(Vec::new()), path_accesses, Some((cache_metadata, globbed_inputs)))
+        } else {
+            (None, None, None)
+        };
 
     #[expect(
         clippy::large_futures,
@@ -321,7 +333,8 @@ pub async fn execute_spawn(
         cache_base_path,
         &mut stdio_config.stdout_writer,
         &mut stdio_config.stderr_writer,
-        track_result_with_cache_metadata_and_inputs.as_mut().map(|(track_result, _, _)| track_result),
+        std_outputs.as_mut(),
+        path_accesses.as_mut(),
     )
     .await
     {
@@ -341,20 +354,25 @@ pub async fn execute_spawn(
     // 6. Update cache if successful and determine cache update status.
     //    Errors during cache update are terminal (reported through finish).
     let (cache_update_status, cache_error) =
-        if let Some((track_result, cache_metadata, globbed_inputs)) =
-            track_result_with_cache_metadata_and_inputs
-        {
+        if let Some((cache_metadata, globbed_inputs)) = cache_metadata_and_inputs {
             if result.exit_status.success() {
+                // path_reads is empty when inference is disabled (path_accesses is None)
+                let empty_path_reads = Default::default();
+                let path_reads = path_accesses
+                    .as_ref()
+                    .map(|pa| &pa.path_reads)
+                    .unwrap_or(&empty_path_reads);
+
                 // Execution succeeded — attempt to create fingerprint and update cache
                 match PostRunFingerprint::create(
-                    &track_result.path_reads,
+                    path_reads,
                     cache_base_path,
                     &cache_metadata.input_config,
                 ) {
                     Ok(post_run_fingerprint) => {
                         let new_cache_value = CommandCacheValue {
                             post_run_fingerprint,
-                            std_outputs: track_result.std_outputs.clone().into(),
+                            std_outputs: std_outputs.unwrap_or_default().into(),
                             duration: result.duration,
                         };
                         match cache

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

@@ -43,27 +43,25 @@ pub struct SpawnResult {
     pub duration: Duration,
 }
 
-/// Tracking result from a spawned process for caching
+/// Tracked file accesses from fspy.
+/// Only populated when fspy tracking is enabled (includes_auto is true).
 #[derive(Default, Debug)]
-pub struct SpawnTrackResult {
-    /// captured stdout/stderr
-    pub std_outputs: Vec<StdOutput>,
-
+pub struct TrackedPathAccesses {
     /// Tracked path reads
     pub path_reads: HashMap<RelativePathBuf, PathRead>,
 
     /// Tracked path writes
     pub path_writes: FxHashSet<RelativePathBuf>,
 }
 
-/// Spawn a command with file system tracking via fspy, using piped stdio.
+/// Spawn a command with optional file system tracking via fspy, using piped stdio.
 ///
-/// Returns the execution result including captured outputs, exit status,
-/// and tracked file accesses.
+/// Returns the execution result including exit status and duration.
 ///
 /// - stdin is always `/dev/null` (piped mode is for non-interactive execution).
 /// - `stdout_writer`/`stderr_writer` receive the child's stdout/stderr output in real-time.
-/// - `track_result` if provided, will be populated with captured outputs and path accesses for caching. If `None`, tracking is disabled.
+/// - `std_outputs` if provided, will be populated with captured outputs for cache replay.
+/// - `path_accesses` if provided, fspy will be used to track file accesses. If `None`, fspy is disabled.
 #[tracing::instrument(level = "debug", skip_all)]
 #[expect(clippy::future_not_send, reason = "uses !Send dyn AsyncWrite writers internally")]
 #[expect(
@@ -75,15 +73,17 @@ pub async fn spawn_with_tracking(
     workspace_root: &AbsolutePath,
     stdout_writer: &mut (dyn AsyncWrite + Unpin),
     stderr_writer: &mut (dyn AsyncWrite + Unpin),
-    track_result: Option<&mut SpawnTrackResult>,
+    std_outputs: Option<&mut Vec<StdOutput>>,
+    path_accesses: Option<&mut TrackedPathAccesses>,
 ) -> anyhow::Result<SpawnResult> {
-    /// The tracking state of the spawned process
-    enum TrackingState<'a> {
-        /// Tacking is enabled, with the tracked child and result reference
-        Enabled(fspy::TrackedChild, &'a mut SpawnTrackResult),
-
-        /// Tracking is disabled, with the tokio child process
-        Disabled(tokio::process::Child),
+    /// The tracking state of the spawned process.
+    /// Determined by whether path_accesses is Some (fspy enabled) or None (fspy disabled).
+    enum TrackingState {
+        /// fspy tracking is enabled
+        FspyEnabled(fspy::TrackedChild),
+
+        /// fspy tracking is disabled, using plain tokio process
+        FspyDisabled(tokio::process::Child),
     }
 
     let mut cmd = fspy::Command::new(spawn_command.program_path.as_path());
@@ -92,27 +92,25 @@ pub async fn spawn_with_tracking(
     cmd.current_dir(&*spawn_command.cwd);
     cmd.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
 
-    let mut tracking_state = if let Some(track_result) = track_result {
-        // track_result is Some. Spawn with tracking enabled
-        TrackingState::Enabled(cmd.spawn().await?, track_result)
+    let mut tracking_state = if path_accesses.is_some() {
+        // path_accesses is Some, spawn with fspy tracking enabled
+        TrackingState::FspyEnabled(cmd.spawn().await?)
     } else {
-        // Spawn without tracking
-        TrackingState::Disabled(cmd.into_tokio_command().spawn()?)
+        // path_accesses is None, spawn without fspy
+        TrackingState::FspyDisabled(cmd.into_tokio_command().spawn()?)
     };
 
     let mut child_stdout = match &mut tracking_state {
-        TrackingState::Enabled(tracked_child, _) => tracked_child.stdout.take().unwrap(),
-        TrackingState::Disabled(tokio_child) => tokio_child.stdout.take().unwrap(),
+        TrackingState::FspyEnabled(tracked_child) => tracked_child.stdout.take().unwrap(),
+        TrackingState::FspyDisabled(tokio_child) => tokio_child.stdout.take().unwrap(),
     };
     let mut child_stderr = match &mut tracking_state {
-        TrackingState::Enabled(tracked_child, _) => tracked_child.stderr.take().unwrap(),
-        TrackingState::Disabled(tokio_child) => tokio_child.stderr.take().unwrap(),
+        TrackingState::FspyEnabled(tracked_child) => tracked_child.stderr.take().unwrap(),
+        TrackingState::FspyDisabled(tokio_child) => tokio_child.stderr.take().unwrap(),
     };
 
-    let mut outputs = match &mut tracking_state {
-        TrackingState::Enabled(_, track_result) => Some(&mut track_result.std_outputs),
-        TrackingState::Disabled(_) => None,
-    };
+    // Output capturing is independent of fspy tracking
+    let mut outputs = std_outputs;
     let mut stdout_buf = [0u8; 8192];
     let mut stderr_buf = [0u8; 8192];
     let mut stdout_done = false;
@@ -169,22 +167,20 @@ pub async fn spawn_with_tracking(
         }
     }
 
-    let (termination, track_result) = match tracking_state {
-        TrackingState::Enabled(tracked_child, track_result) => {
-            (tracked_child.wait_handle.await?, track_result)
-        }
-        TrackingState::Disabled(mut tokio_child) => {
-            return Ok(SpawnResult {
-                exit_status: tokio_child.wait().await?,
-                duration: start.elapsed(),
-            });
+    let termination = match tracking_state {
+        TrackingState::FspyEnabled(tracked_child) => Some(tracked_child.wait_handle.await?),
+        TrackingState::FspyDisabled(mut tokio_child) => {
+            let exit_status = tokio_child.wait().await?;
+            return Ok(SpawnResult { exit_status, duration: start.elapsed() });
         }
     };
     let duration = start.elapsed();
 
-    // Process path accesses
-    let path_reads = &mut track_result.path_reads;
-    let path_writes = &mut track_result.path_writes;
+    // Process path accesses from fspy (only when fspy was enabled)
+    let termination = termination.expect("fspy enabled but no termination");
+    let path_accesses = path_accesses.expect("fspy enabled but no path_accesses");
+    let path_reads = &mut path_accesses.path_reads;
+    let path_writes = &mut path_accesses.path_writes;
 
     for access in termination.path_accesses.iter() {
         let relative_path = access.path.strip_path_prefix(workspace_root, |strip_result| {

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-cache-test/snapshots.toml

@@ -179,7 +179,24 @@ steps = [
   # Initial run
   "vite run empty-inputs",
   # Change the command
-  "json-edit vite.config.json \"_.tasks['empty-inputs'].command = 'print-file src/utils.ts'\"",
+  "json-edit vite-task.json \"_.tasks['empty-inputs'].command = 'print-file src/utils.ts'\"",
   # Cache miss: command changed
   "vite run empty-inputs",
 ]
+
+# 7. FSPY environment variable
+# - FSPY=1 is set when fspy is enabled (includes_auto is true)
+# - FSPY is NOT set when fspy is disabled (explicit globs only)
+[[e2e]]
+name = "fspy env - set when auto inference enabled"
+steps = [
+  # Run task with auto inference - should see FSPY=1
+  "vite run check-fspy-env-with-auto",
+]
+
+[[e2e]]
+name = "fspy env - not set when auto inference disabled"
+steps = [
+  # Run task without auto inference - should see (undefined)
+  "vite run check-fspy-env-without-auto",
+]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-cache-test/snapshots/fspy env - not set when auto inference disabled.snap

@@ -0,0 +1,22 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+input_file: crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-cache-test
+---
+> vite run check-fspy-env-without-auto
+$ print-env FSPY
+(undefined)
+
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    Vite+ Task Runner • Execution Summary
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Statistics:   1 tasks • 0 cache hits • 1 cache misses 
+Performance:  0% cache hit rate
+
+Task Details:
+────────────────────────────────────────────────
+  [1] inputs-cache-test#check-fspy-env-without-auto: $ print-env FSPY ✓
+      → Cache miss: no previous cache entry found
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-cache-test/snapshots/fspy env - set when auto inference enabled.snap

@@ -0,0 +1,22 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+input_file: crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-cache-test
+---
+> vite run check-fspy-env-with-auto
+$ print-env FSPY
+1
+
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    Vite+ Task Runner • Execution Summary
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Statistics:   1 tasks • 0 cache hits • 1 cache misses 
+Performance:  0% cache hit rate
+
+Task Details:
+────────────────────────────────────────────────
+  [1] inputs-cache-test#check-fspy-env-with-auto: $ print-env FSPY ✓
+      → Cache miss: no previous cache entry found
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-cache-test/vite-task.json

@@ -34,6 +34,16 @@
       "command": "print-file src/main.ts",
       "inputs": [],
       "cache": true
+    },
+    "check-fspy-env-with-auto": {
+      "command": "print-env FSPY",
+      "inputs": [{ "auto": true }],
+      "cache": true
+    },
+    "check-fspy-env-without-auto": {
+      "command": "print-env FSPY",
+      "inputs": ["src/**/*.ts"],
+      "cache": true
     }
   }
 }