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::InjectionError(err.into()))?;
         command.set_exec(exec);
+        command.env("FSPY", "1");
 
         let mut tokio_command = command.into_tokio_command();
 

crates/fspy/src/windows/mod.rs

@@ -71,8 +71,9 @@ impl SpyImpl {
         Ok(Self { ansi_dll_path_with_nul: ansi_dll_path_with_nul.into() })
     }
 
-    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

@@ -25,7 +25,7 @@ use super::{
     },
     reporter::{ExitStatus, Reporter},
 };
-use crate::{Session, session::execute::spawn::SpawnTrackResult};
+use crate::{Session, session::execute::spawn::TrackedPathAccesses};
 
 /// Internal error type used to abort execution when errors occur.
 /// This error is swallowed in Session::execute and never exposed externally.
@@ -261,11 +261,18 @@ impl ExecutionContext<'_> {
 
         // 4. Execute spawn (cache miss or disabled)
         //    Track file system access if caching is enabled (for future cache updates)
-        let mut track_result_with_cache_metadata_and_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 {
-                Some((SpawnTrackResult::default(), cache_metadata, globbed_inputs))
+                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, None)
             };
 
         // Execute command with tracking, emitting output events in real-time
@@ -284,9 +291,8 @@ impl ExecutionContext<'_> {
                     },
                 });
             },
-            track_result_with_cache_metadata_and_inputs
-                .as_mut()
-                .map(|(track_result, _, _)| track_result),
+            std_outputs.as_mut(),
+            path_accesses.as_mut(),
         )
         .await
         {
@@ -303,20 +309,24 @@ impl ExecutionContext<'_> {
         };
 
         // 5. Update cache if successful
-        //    Only update cache if: (a) tracking was enabled, and (b) execution succeeded
-        if let Some((track_result, cache_metadata, globbed_inputs)) =
-            track_result_with_cache_metadata_and_inputs
+        //    Only update cache if: (a) caching was enabled, and (b) execution succeeded
+        if let Some((cache_metadata, globbed_inputs)) = cache_metadata_and_inputs
             && 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);
+
             match PostRunFingerprint::create(
-                &track_result.path_reads,
+                path_reads,
                 &*self.cache_base_path,
                 &cache_metadata.input_config,
             ) {
                 Ok(post_run_fingerprint) => {
                     let 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,
                     };
                     if let Err(err) = self

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

@@ -47,31 +47,30 @@ 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: HashMap<RelativePathBuf, PathWrite>,
 }
 
-/// Spawn a command with file system tracking via fspy.
+/// Spawn a command with optional file system tracking via fspy.
 ///
-/// Returns the execution result including captured outputs, exit status,
-/// and tracked file accesses.
+/// Returns the execution result including exit status and duration.
 ///
 /// - `on_output` is called in real-time as stdout/stderr data arrives.
-/// - `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.
 pub async fn spawn_with_tracking<F>(
     spawn_command: &SpawnCommand,
     workspace_root: &AbsolutePath,
     mut on_output: F,
-    track_result: Option<&mut SpawnTrackResult>,
+    std_outputs: Option<&mut Vec<StdOutput>>,
+    path_accesses: Option<&mut TrackedPathAccesses>,
 ) -> anyhow::Result<SpawnResult>
 where
     F: FnMut(OutputKind, BString),
@@ -82,36 +81,35 @@ where
     cmd.current_dir(&*spawn_command.cwd);
     cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
 
-    /// 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),
+    /// 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),
 
-        /// Tracking is disabled, with the tokio child process
-        Disabled(tokio::process::Child),
+        /// fspy tracking is disabled, using plain tokio process
+        FspyDisabled(tokio::process::Child),
     }
 
-    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;
@@ -156,22 +154,20 @@ where
         }
     }
 
-    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

@@ -183,3 +183,20 @@ steps = [
   # 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.config.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
     }
   }
 }