feat(cache): consume runner-aware tool reports for cache decisions

Step 6 of docs/runner-task-ipc/plan.md.

- Apply `ignoreInputs` to filter inferred fspy reads (directory-aware)
- Apply `ignoreOutputs` to filter auto-detected writes (overlap check + archive)
- Short-circuit cache update on `disableCache()` via new
  `CacheNotUpdatedReason::ToolRequested`
- Embed `tracked: true` envs in `PostRunFingerprint.tracked_envs`; validate
  on lookup by comparing against the current parent env
- Recorder env_map sources from `std::env::vars_os()` so tools can resolve
  envs the user never declared
- Bump cache schema to 13

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: wan9chi

Cargo.lock

@@ -179,6 +179,11 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
                     let desc = format_input_change_str(*kind, path.as_str());
                     return Some(vite_str::format!("○ cache miss: {desc}, executing"));
                 }
+                FingerprintMismatch::TrackedEnvChanged { name, .. } => {
+                    return Some(vite_str::format!(
+                        "○ cache miss: tracked env '{name}' changed, executing"
+                    ));
+                }
             };
             Some(vite_str::format!("○ cache miss: {reason}, executing"))
         }

crates/vite_task/src/session/cache/display.rs

@@ -158,6 +158,12 @@ pub enum FingerprintMismatch {
         kind: InputChangeKind,
         path: RelativePathBuf,
     },
+    /// A tool-tracked env var changed between runs.
+    TrackedEnvChanged {
+        name: Str,
+        old: Option<Str>,
+        new: Option<Str>,
+    },
 }
 
 impl Display for FingerprintMismatch {
@@ -175,6 +181,18 @@ impl Display for FingerprintMismatch {
             Self::InputChanged { kind, path } => {
                 write!(f, "{}", display::format_input_change_str(*kind, path.as_str()))
             }
+            Self::TrackedEnvChanged { name, old, new } => {
+                write!(f, "tracked env {name}: ")?;
+                match old {
+                    Some(value) => write!(f, "{:?}", value.as_str())?,
+                    None => write!(f, "(unset)")?,
+                }
+                write!(f, " → ")?;
+                match new {
+                    Some(value) => write!(f, "{:?}", value.as_str()),
+                    None => write!(f, "(unset)"),
+                }
+            }
         }
     }
 }
@@ -215,16 +233,16 @@ impl ExecutionCache {
                         "CREATE TABLE task_fingerprints (key BLOB PRIMARY KEY, value BLOB);",
                         (),
                     )?;
-                    conn.execute("PRAGMA user_version = 12", ())?;
+                    conn.execute("PRAGMA user_version = 13", ())?;
                 }
-                1..=11 => {
+                1..=12 => {
                     // old internal db version. reset
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, true)?;
                     conn.execute("VACUUM", ())?;
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, false)?;
                 }
-                12 => break, // current version
-                13.. => {
+                13 => break, // current version
+                14.. => {
                     return Err(anyhow::anyhow!("Unrecognized database version: {user_version}"));
                 }
             }
@@ -262,11 +280,20 @@ impl ExecutionCache {
                 return Ok(Err(CacheMiss::FingerprintMismatch(mismatch)));
             }
 
-            // Validate post-run fingerprint (inferred inputs from fspy)
-            if let Some((kind, path)) = cache_value.post_run_fingerprint.validate(workspace_root)? {
-                return Ok(Err(CacheMiss::FingerprintMismatch(
-                    FingerprintMismatch::InputChanged { kind, path },
-                )));
+            // Validate post-run fingerprint (inferred inputs + tracked envs)
+            if let Some(mismatch) = cache_value.post_run_fingerprint.validate(workspace_root)? {
+                let fingerprint_mismatch = match mismatch {
+                    crate::session::execute::fingerprint::PostRunMismatch::InputChanged {
+                        kind,
+                        path,
+                    } => FingerprintMismatch::InputChanged { kind, path },
+                    crate::session::execute::fingerprint::PostRunMismatch::TrackedEnvChanged {
+                        name,
+                        old,
+                        new,
+                    } => FingerprintMismatch::TrackedEnvChanged { name, old, new },
+                };
+                return Ok(Err(CacheMiss::FingerprintMismatch(fingerprint_mismatch)));
             }
             // Associate the execution key to the cache entry key if not already,
             // so that next time we can find it and report what changed

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

@@ -84,6 +84,9 @@ pub enum CacheNotUpdatedReason {
     /// inputs/outputs on the next hit. Carries the underlying error for
     /// user-facing reporting.
     IpcServerError(IpcServerError),
+    /// A runner-aware tool explicitly requested that this run not be cached
+    /// (e.g. vite dev-server, a watch task).
+    ToolRequested,
 }
 
 #[derive(Debug)]

crates/vite_task/src/session/event.rs

@@ -26,6 +26,20 @@ pub struct PostRunFingerprint {
     /// Paths inferred from fspy during execution with their content fingerprints.
     /// Only populated when `input_config.includes_auto` is true.
     pub inferred_inputs: HashMap<RelativePathBuf, PathFingerprint>,
+
+    /// Env vars observed via runner-aware IPC with `tracked: true`. Key is the
+    /// env name; value is the env value at execution time (or `None` if unset).
+    /// Validated at cache lookup by comparing against the current parent env.
+    pub tracked_envs: BTreeMap<Str, Option<Str>>,
+}
+
+/// A mismatch between the stored post-run fingerprint and the current state.
+#[derive(Debug, Clone)]
+pub enum PostRunMismatch {
+    /// An inferred input file or directory changed.
+    InputChanged { kind: InputChangeKind, path: RelativePathBuf },
+    /// A tool-tracked env var changed value (or was added/removed).
+    TrackedEnvChanged { name: Str, old: Option<Str>, new: Option<Str> },
 }
 
 /// Fingerprint for a single path (file or directory)
@@ -64,11 +78,13 @@ impl PostRunFingerprint {
     /// * `inferred_path_reads` - Map of paths that were read during execution (from fspy)
     /// * `base_dir` - Workspace root for resolving relative paths
     /// * `globbed_inputs` - Prerun glob fingerprint; paths here are skipped
+    /// * `tracked_envs` - Tool-requested env vars (name → value), validated on lookup
     #[tracing::instrument(level = "debug", skip_all, name = "create_post_run_fingerprint")]
     pub fn create(
         inferred_path_reads: &HashMap<RelativePathBuf, PathRead>,
         base_dir: &AbsolutePath,
         globbed_inputs: &BTreeMap<RelativePathBuf, u64>,
+        tracked_envs: BTreeMap<Str, Option<Str>>,
     ) -> anyhow::Result<Self> {
         let inferred_inputs = inferred_path_reads
             .par_iter()
@@ -80,16 +96,16 @@ impl PostRunFingerprint {
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
 
-        Ok(Self { inferred_inputs })
+        Ok(Self { inferred_inputs, tracked_envs })
     }
 
-    /// Validates the fingerprint against current filesystem state.
-    /// Returns `Some((kind, path))` if an input changed, `None` if all valid.
+    /// Validates the fingerprint against current filesystem and env state.
+    /// Returns `Some(mismatch)` on the first divergence, `None` if all valid.
     #[tracing::instrument(level = "debug", skip_all, name = "validate_post_run_fingerprint")]
     pub fn validate(
         &self,
         base_dir: &AbsolutePath,
-    ) -> anyhow::Result<Option<(InputChangeKind, RelativePathBuf)>> {
+    ) -> anyhow::Result<Option<PostRunMismatch>> {
         let input_mismatch = self.inferred_inputs.par_iter().find_map_any(
             |(input_relative_path, path_fingerprint)| {
                 let input_full_path = Arc::<AbsolutePath>::from(base_dir.join(input_relative_path));
@@ -115,11 +131,27 @@ impl PostRunFingerprint {
                     } else {
                         input_relative_path.clone()
                     };
-                    Some(Ok((kind, path)))
+                    Some(Ok(PostRunMismatch::InputChanged { kind, path }))
                 }
             },
         );
-        input_mismatch.transpose()
+        if let Some(result) = input_mismatch {
+            return result.map(Some);
+        }
+
+        // Validate tracked envs against the current parent env.
+        for (name, stored_value) in &self.tracked_envs {
+            let current_value =
+                std::env::var_os(name.as_str()).and_then(|v| v.to_str().map(Str::from));
+            if current_value.as_ref() != stored_value.as_ref() {
+                return Ok(Some(PostRunMismatch::TrackedEnvChanged {
+                    name: name.clone(),
+                    old: stored_value.clone(),
+                    new: current_value,
+                }));
+            }
+        }
+        Ok(None)
     }
 }