feat(runner-execute-refactor): refactor execute module for runner-aware IPC

Reshape `vite_task::session::execute` (and the supporting modules:
`spawn`, `fingerprint`, `cache`, `tracked_accesses`, `event`, and the
summary reporter) to accommodate a per-task IPC server. The server
itself is a placeholder on this branch: instead of actually calling
`vite_task_server::serve(...)`, we construct an empty `Recorder`
whose driver future resolves immediately with no traffic, and bind
a `StopAccepting::noop()`. The downstream plumbing — async-join of
the child with the server, `Reports` flowing into post-run
fingerprinting and into the cache update — is fully in place but
sees only the empty `Reports`, so behaviour is byte-for-byte
identical to today's runner.

The follow-up wires up the real `serve(...)`, embeds the napi
addon, and injects `VP_RUN_NODE_CLIENT_PATH` into the child. That
PR's `serve(Recorder::new(env_map))` is the only call that changes
from "future::ready(Ok(recorder))" to the real bind.

Adds `StopAccepting::noop()` to `vite_task_server` for the same
placeholder use case; it's a tiny helper that's also useful for
tests that need a value of the type without running a server.

Also folds in the unrelated-but-blocking output-config refactor
(`output: Option<UserInputsConfig>` instead of
`Option<Vec<UserOutputEntry>>`) — both sides now route through
`ResolvedGlobConfig::from_user_config`. The 80-odd plan-snapshot
updates are mechanical consequences of that type change.

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

Author: wan9chi

Cargo.lock

@@ -44,11 +44,13 @@ tokio-util = { workspace = true }
 tracing = { workspace = true }
 twox-hash = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
+vite_glob = { workspace = true }
 vite_path = { workspace = true }
 vite_select = { workspace = true }
 vite_str = { workspace = true }
 vite_task_graph = { workspace = true }
 vite_task_plan = { workspace = true }
+vite_task_server = { workspace = true }
 vite_workspace = { workspace = true }
 wax = { workspace = true }
 zstd = { workspace = true }

crates/vite_task/Cargo.toml

@@ -92,7 +92,7 @@ The cache entry key uniquely identifies a command execution context:
 ```rust
 pub struct CacheEntryKey {
     pub spawn_fingerprint: SpawnFingerprint,
-    pub input_config: ResolvedInputConfig,
+    pub input_config: ResolvedGlobConfig,
 }
 ```
 
@@ -303,7 +303,7 @@ Cache entries are serialized using `bincode` for efficient storage.
 │  ──────────────────────                                      │
 │    CacheEntryKey {                                           │
 │        spawn_fingerprint: SpawnFingerprint { ... },          │
-│        input_config: ResolvedInputConfig { ... },            │
+│        input_config: ResolvedGlobConfig { ... },            │
 │    }                                                         │
 │    ExecutionCacheKey::UserTask {                              │
 │        task_name: "build",                                   │

crates/vite_task/docs/task-cache.md

@@ -179,6 +179,16 @@ 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"
+                    ));
+                }
+                FingerprintMismatch::TrackedEnvGlobChanged { pattern, .. } => {
+                    return Some(vite_str::format!(
+                        "○ cache miss: tracked env glob '{pattern}' changed, executing"
+                    ));
+                }
             };
             Some(vite_str::format!("○ cache miss: {reason}, executing"))
         }

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

@@ -158,6 +158,17 @@ pub enum FingerprintMismatch {
         kind: InputChangeKind,
         path: RelativePathBuf,
     },
+    /// A tool-tracked env var changed between runs.
+    TrackedEnvChanged {
+        name: Str,
+        old: Option<Str>,
+        new: Option<Str>,
+    },
+    /// A tool-tracked env glob's match-set changed between runs.
+    TrackedEnvGlobChanged {
+        pattern: Str,
+        diff: crate::session::execute::fingerprint::EnvGlobDiff,
+    },
 }
 
 impl Display for FingerprintMismatch {
@@ -175,6 +186,42 @@ 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)"),
+                }
+            }
+            Self::TrackedEnvGlobChanged { pattern, diff } => {
+                write!(f, "tracked env glob {:?}:", pattern.as_str())?;
+                let mut first = true;
+                for (name, value) in &diff.added {
+                    write!(f, "{} +{}={:?}", if first { "" } else { "," }, name, value.as_str())?;
+                    first = false;
+                }
+                for (name, value) in &diff.removed {
+                    write!(f, "{} -{}={:?}", if first { "" } else { "," }, name, value.as_str())?;
+                    first = false;
+                }
+                for (name, (old, new)) in &diff.changed {
+                    write!(
+                        f,
+                        "{} {}: {:?} → {:?}",
+                        if first { "" } else { "," },
+                        name,
+                        old.as_str(),
+                        new.as_str()
+                    )?;
+                    first = false;
+                }
+                Ok(())
+            }
         }
     }
 }
@@ -266,11 +313,24 @@ 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 },
+                    crate::session::execute::fingerprint::PostRunMismatch::TrackedEnvGlobChanged {
+                        pattern,
+                        diff,
+                    } => FingerprintMismatch::TrackedEnvGlobChanged { pattern, diff },
+                };
+                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

@@ -1,6 +1,7 @@
 use std::{process::ExitStatus, time::Duration};
 
 use vite_path::RelativePathBuf;
+use vite_task_server::Error as IpcServerError;
 
 use super::cache::CacheMiss;
 
@@ -43,6 +44,13 @@ pub enum ExecutionError {
     /// Creating the post-run fingerprint failed after successful execution.
     #[error("Failed to create post-run fingerprint")]
     PostRunFingerprint(#[source] anyhow::Error),
+
+    /// The runner-aware IPC server failed to bind for this task. Reported
+    /// instead of silently degrading so that `{ auto: true }` inputs stay
+    /// observable end-to-end.
+    #[expect(dead_code, reason = "placeholder; constructed once the real `serve()` lands")]
+    #[error("Failed to start runner IPC server")]
+    IpcServerBind(#[source] std::io::Error),
 }
 
 #[derive(Debug, Clone)]
@@ -76,6 +84,14 @@ pub enum CacheNotUpdatedReason {
     /// (its `input` config includes auto-inference). Task ran but cannot
     /// be cached without tracked path accesses.
     FspyUnsupported,
+    /// The runner's IPC server failed during execution, so the collected
+    /// reports may be incomplete. Caching such a run would risk stale
+    /// 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

@@ -31,6 +31,53 @@ 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 `getEnv` 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>>,
+
+    /// Glob-pattern env queries (`getEnvs`) made with `tracked: true`.
+    /// Outer key is the glob pattern, inner map is the match-set at
+    /// execution time (name → value). Validated at cache lookup by
+    /// re-matching against the current parent env and comparing the
+    /// resulting set.
+    pub tracked_env_globs: BTreeMap<Str, BTreeMap<Str, Str>>,
+}
+
+/// A mismatch between the stored post-run fingerprint and the current state.
+#[expect(
+    clippy::enum_variant_names,
+    reason = "all three variants describe different kinds of post-run changes; \
+              dropping the `Changed` suffix on any one of them would be misleading"
+)]
+#[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> },
+    /// A tool-tracked env glob's match-set changed between runs. The glob
+    /// still matches the same pattern, but added/removed/mutated entries.
+    TrackedEnvGlobChanged { pattern: Str, diff: EnvGlobDiff },
+}
+
+/// Per-pattern diff between stored and current match-set. Each map is a
+/// subset of the symmetric difference keyed by env name. `changed` holds
+/// names present in both with differing values; `added` / `removed` are
+/// exclusive to one side.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct EnvGlobDiff {
+    pub added: BTreeMap<Str, Str>,
+    pub removed: BTreeMap<Str, Str>,
+    pub changed: BTreeMap<Str, (Str, Str)>,
+}
+
+impl EnvGlobDiff {
+    fn is_empty(&self) -> bool {
+        self.added.is_empty() && self.removed.is_empty() && self.changed.is_empty()
+    }
 }
 
 /// Fingerprint for a single path (file or directory)
@@ -69,11 +116,15 @@ 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
+    /// * `tracked_env_globs` - Tool-requested env globs (pattern → matches), 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>>,
+        tracked_env_globs: BTreeMap<Str, BTreeMap<Str, Str>>,
     ) -> anyhow::Result<Self> {
         let inferred_inputs = inferred_path_reads
             .par_iter()
@@ -85,16 +136,13 @@ impl PostRunFingerprint {
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
 
-        Ok(Self { inferred_inputs })
+        Ok(Self { inferred_inputs, tracked_envs, tracked_env_globs })
     }
 
-    /// 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)>> {
+    pub fn validate(&self, base_dir: &AbsolutePath) -> 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));
@@ -120,12 +168,83 @@ 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,
+                }));
+            }
+        }
+
+        // Validate tracked env globs: re-enumerate parent env for each
+        // pattern and diff against the stored match-set.
+        for (pattern, stored_matches) in &self.tracked_env_globs {
+            let current_matches = match_env_glob(pattern.as_str())?;
+            let diff = diff_env_glob(stored_matches, &current_matches);
+            if !diff.is_empty() {
+                return Ok(Some(PostRunMismatch::TrackedEnvGlobChanged {
+                    pattern: pattern.clone(),
+                    diff,
+                }));
+            }
+        }
+
+        Ok(None)
+    }
+}
+
+/// Build the current match-set for `pattern` by enumerating
+/// `std::env::vars_os()` and keeping UTF-8 names whose representation matches
+/// the glob. Mirrors the server-side match (see
+/// `vite_task_server::Recorder::get_envs`).
+fn match_env_glob(pattern: &str) -> anyhow::Result<BTreeMap<Str, Str>> {
+    let set = vite_glob::GlobPatternSet::new(std::iter::once(pattern))?;
+    Ok(std::env::vars_os()
+        .filter_map(|(name, value)| {
+            let name_str = name.to_str()?.to_owned();
+            let value_str = value.to_str()?.to_owned();
+            if set.is_match(&name_str) {
+                Some((Str::from(name_str.as_str()), Str::from(value_str.as_str())))
+            } else {
+                None
+            }
+        })
+        .collect())
+}
+
+/// Compute the diff of two match-sets for the same glob pattern.
+fn diff_env_glob(stored: &BTreeMap<Str, Str>, current: &BTreeMap<Str, Str>) -> EnvGlobDiff {
+    let mut diff = EnvGlobDiff::default();
+    for (name, stored_value) in stored {
+        match current.get(name) {
+            None => {
+                diff.removed.insert(name.clone(), stored_value.clone());
+            }
+            Some(current_value) if current_value != stored_value => {
+                diff.changed.insert(name.clone(), (stored_value.clone(), current_value.clone()));
+            }
+            Some(_) => {}
+        }
+    }
+    for (name, current_value) in current {
+        if !stored.contains_key(name) {
+            diff.added.insert(name.clone(), current_value.clone());
+        }
     }
+    diff
 }
 
 /// Determine the kind of change between two differing path fingerprints.