feat(cache): runner-aware auto output tracking + ignore consumption

Completes runner-aware caching on top of the IPC infra:

- ignoreInput/ignoreOutput land across the whole IPC surface: protocol
  verbs, sync client (with cwd-resolution and Windows path
  canonicalization), napi addon methods, and server-side recording with
  absolute-path validation.
- `output: None` resolves to auto inference again, so fspy-written files
  are archived and restored on a cache hit (auto output restoration).
- The reported ignores are applied: vite excludes its out dir and
  write-then-read temp files from the input fingerprint and read-write
  overlap check, so `vite build` caches and restores `dist/` without
  manual `!`-glob exclusions.
- Adds the real-vite e2e coverage, which needs this full client surface:
  ignoreInput keeps the cache valid, ignoreOutput allows a read-write
  overlap, vite build caches/restores its outputs and re-runs on tracked
  env changes, and vite dev disables caching end-to-end.

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

Author: wan9chi

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- **Changed** Cached tasks without an `output` config now automatically archive the files the task writes and restore them on cache hits (`output: []` disables restoration). Runner-aware tools can exclude internal paths via `ignoreInput`/`ignoreOutput`, so `vite build` caches and restores `dist/` with zero manual cache config ([#431](https://github.com/voidzero-dev/vite-task/pull/431))
 - **Added** Runner-aware `getEnvs` match sets can now participate in task cache fingerprints, so changing, adding, or removing a matching env var invalidates the cache.
 - **Added** Runner-aware `getEnvs` calls now return env values served by the runner for matching env glob patterns.
 - **Added** Runner-aware `getEnv` reads can now participate in task cache fingerprints, so changing a tool-served env value invalidates the cache and names the env var in the miss message.

Cargo.lock

@@ -3,6 +3,7 @@
 
 use std::{collections::BTreeMap, sync::Arc, time::Duration};
 
+use rustc_hash::FxHashSet;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
 use vite_task_plan::cache_metadata::CacheMetadata;
@@ -27,6 +28,9 @@ use crate::{
 /// value is only ever `Some` when tracking happened (see [`observe_fspy`]).
 struct TrackingOutcome {
     path_reads: HashMap<RelativePathBuf, PathRead>,
+    /// All paths the task wrote to. Consumed by `collect_and_archive_outputs`
+    /// when `output_config.includes_auto` is set.
+    path_writes: FxHashSet<RelativePathBuf>,
     /// First path that was both read and written during execution, if any.
     /// A non-empty value means caching this task is unsound.
     read_write_overlap: Option<RelativePathBuf>,
@@ -64,6 +68,15 @@ pub(super) async fn update_cache(
         return (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::ToolRequested), None);
     }
 
+    // Tool-reported paths to exclude from auto-tracking. Absolute paths
+    // are normalized to workspace-relative; anything outside is dropped.
+    let ignored_input_rels: FxHashSet<RelativePathBuf> = reports
+        .map(|r| normalize_ignored_paths(&r.ignored_inputs, workspace_root))
+        .unwrap_or_default();
+    let ignored_output_rels: FxHashSet<RelativePathBuf> = reports
+        .map(|r| normalize_ignored_paths(&r.ignored_outputs, workspace_root))
+        .unwrap_or_default();
+
     if cancelled {
         // Cancelled (Ctrl-C or sibling failure) — result is untrustworthy.
         return (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::Cancelled), None);
@@ -74,7 +87,14 @@ pub(super) async fn update_cache(
         return (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus), None);
     }
 
-    let fspy_outcome = observe_fspy(outcome, input_negative_globs, workspace_root);
+    let fspy_outcome = observe_fspy(
+        outcome,
+        metadata,
+        input_negative_globs,
+        &ignored_input_rels,
+        &ignored_output_rels,
+        workspace_root,
+    );
 
     if let Some(TrackingOutcome { read_write_overlap: Some(path), .. }) = &fspy_outcome {
         // fspy-inferred read-write overlap: the task wrote to a file it also
@@ -124,7 +144,15 @@ pub(super) async fn update_cache(
         }
     };
 
-    let output_archive = match collect_and_archive_outputs(metadata, workspace_root, cache_dir) {
+    // Collect output files and create archive. Tool-reported `ignoreOutput`
+    // paths are excluded from archiving too.
+    let output_archive = match collect_and_archive_outputs(
+        metadata,
+        fspy_outcome.as_ref(),
+        &ignored_output_rels,
+        workspace_root,
+        cache_dir,
+    ) {
         Ok(archive) => archive,
         Err(err) => {
             return (
@@ -151,32 +179,142 @@ pub(super) async fn update_cache(
 }
 
 /// Summarize the run's fspy observations. `Some` iff tracking was both
-/// requested (`input_negative_globs.is_some()`) and compiled in (`cfg(fspy)`). On a
+/// requested (`tracking.is_some()`) and compiled in (`cfg(fspy)`). On a
 /// `cfg(not(fspy))` build this is always `None`, and [`update_cache`]
 /// short-circuits to `FspyUnsupported` when tracking was needed.
+///
+/// `path_reads` is gated on `input_config.includes_auto`, filtered by
+/// user-configured input negatives, and by tool-reported `ignoreInput`
+/// paths. `path_writes` is NOT filtered here — output negatives and
+/// `ignoreOutput` are applied later inside `collect_and_archive_outputs`.
+/// Keeping the two sides separate avoids `input: ["!dist/**"]` accidentally
+/// dropping writes to `dist/**`, which would break archive restoration.
 fn observe_fspy(
     outcome: &ChildOutcome,
+    metadata: &CacheMetadata,
     input_negative_globs: Option<&[wax::Glob<'static>]>,
+    ignored_input_rels: &FxHashSet<RelativePathBuf>,
+    ignored_output_rels: &FxHashSet<RelativePathBuf>,
     workspace_root: &AbsolutePath,
 ) -> Option<TrackingOutcome> {
     #[cfg(fspy)]
     {
+        use wax::Program as _;
+
         use super::tracked_accesses::TrackedPathAccesses;
 
-        outcome.path_accesses.as_ref().zip(input_negative_globs).map(|(raw, negatives)| {
-            let tracked = TrackedPathAccesses::from_raw(raw, workspace_root, negatives);
-            let read_write_overlap =
-                tracked.path_reads.keys().find(|p| tracked.path_writes.contains(*p)).cloned();
-            TrackingOutcome { path_reads: tracked.path_reads, read_write_overlap }
+        outcome.path_accesses.as_ref().map(|raw| {
+            let tracked = TrackedPathAccesses::from_raw(raw, workspace_root);
+            let path_reads: HashMap<RelativePathBuf, PathRead> =
+                if metadata.input_config.includes_auto
+                    && let Some(negatives) = input_negative_globs
+                {
+                    tracked
+                        .path_reads
+                        .iter()
+                        .filter(|(path, _)| {
+                            !negatives.iter().any(|neg| neg.is_match(path.as_str()))
+                                && !is_ignored(path, ignored_input_rels)
+                        })
+                        .map(|(path, read)| (path.clone(), *read))
+                        .collect()
+                } else {
+                    HashMap::default()
+                };
+            let read_write_overlap = path_reads
+                .keys()
+                .find(|p| tracked.path_writes.contains(*p) && !is_ignored(p, ignored_output_rels))
+                .cloned();
+            TrackingOutcome { path_reads, path_writes: tracked.path_writes, read_write_overlap }
         })
     }
     #[cfg(not(fspy))]
     {
-        let _ = (outcome, input_negative_globs, workspace_root);
+        let _ = (
+            outcome,
+            metadata,
+            input_negative_globs,
+            ignored_input_rels,
+            ignored_output_rels,
+            workspace_root,
+        );
         None
     }
 }
 
+/// Normalize tool-reported absolute paths to workspace-relative. Paths outside
+/// the workspace are dropped — they can't contribute to inputs or outputs.
+fn normalize_ignored_paths(
+    paths: &FxHashSet<Arc<AbsolutePath>>,
+    workspace_root: &AbsolutePath,
+) -> FxHashSet<RelativePathBuf> {
+    // On Windows, `workspace_root` may carry a `\\?\` extended-path prefix
+    // (it does when the runner derived it from `std::fs::canonicalize`)
+    // while a tool's `current_dir()`-based ignoreInput/ignoreOutput path
+    // doesn't. `Path::strip_prefix` is a byte-exact comparison so the
+    // prefix mismatch silently drops every tool-reported path. Pre-build
+    // an alternate workspace root with the `\\?\` / `\\.\` / `\??\`
+    // prefix dropped and try it as a fallback. `fspy_shared::NativePath::
+    // strip_path_prefix` does the inverse (strips `\\?\` from incoming
+    // fspy paths) so each side stays agnostic to how the other side
+    // canonicalised.
+    #[cfg(windows)]
+    let workspace_root_stripped: Option<vite_path::AbsolutePathBuf> =
+        windows_strip_verbatim_prefix(workspace_root.as_path().as_os_str());
+
+    paths
+        .iter()
+        .filter_map(|p| {
+            if let Some(rel) = p.strip_prefix(workspace_root).ok().flatten() {
+                return Some(rel);
+            }
+            #[cfg(windows)]
+            if let Some(alt_root) = workspace_root_stripped.as_ref() {
+                if let Some(rel) = p.strip_prefix(alt_root).ok().flatten() {
+                    return Some(rel);
+                }
+            }
+            None
+        })
+        .collect()
+}
+
+/// Build an alternate workspace-root path by dropping a `\\?\`, `\\.\`,
+/// or `\??\` prefix if present. Returns `None` when the input is already
+/// in plain `C:\...` form (no fallback needed). Mirrors
+/// `fspy_shared::NativePath::strip_path_prefix`'s helper so the inputs of
+/// `strip_prefix` can match across `current_dir`-derived and
+/// `canonicalize`-derived paths.
+#[cfg(windows)]
+#[expect(
+    clippy::disallowed_types,
+    reason = "OsStr-level prefix matching for Windows extended-path normalization"
+)]
+fn windows_strip_verbatim_prefix(p: &std::ffi::OsStr) -> Option<vite_path::AbsolutePathBuf> {
+    use std::os::windows::ffi::{OsStrExt, OsStringExt};
+    let wide: Vec<u16> = p.encode_wide().collect();
+    for prefix in [r"\\?\", r"\\.\", r"\??\"] {
+        let prefix_wide: Vec<u16> = prefix.encode_utf16().collect();
+        if wide.starts_with(prefix_wide.as_slice()) {
+            let stripped = std::ffi::OsString::from_wide(&wide[prefix_wide.len()..]);
+            return vite_path::AbsolutePathBuf::new(std::path::PathBuf::from(stripped));
+        }
+    }
+    None
+}
+
+/// Whether `path` is covered by any `ignored` entry. An ignored entry matches
+/// itself (exact file) and everything under it (directory subtree).
+fn is_ignored(path: &RelativePathBuf, ignored: &FxHashSet<RelativePathBuf>) -> bool {
+    if ignored.is_empty() {
+        return false;
+    }
+    if ignored.contains(path) {
+        return true;
+    }
+    ignored.iter().any(|ig| path.strip_prefix(ig).is_some())
+}
+
 /// Select tool-reported env records to embed in the post-run fingerprint.
 /// Only `tracked: true` records are included, and names that the user already
 /// declared as fingerprinted are skipped.
@@ -220,36 +358,70 @@ fn collect_tracked_env_globs(reports: &Reports) -> BTreeMap<Str, BTreeMap<Str, S
         .collect()
 }
 
-/// Collect output files matching the configured globs and create a tar.zst
-/// archive in the cache directory.
+/// Collect output files and create a tar.zst archive in the cache directory.
+///
+/// Output files are determined by:
+/// - fspy-tracked writes (when `output_config.includes_auto` is true)
+/// - Positive output globs (always, if configured)
+/// - Filtered by negative output globs
+/// - Filtered by tool-reported `ignoreOutput` paths (auto writes only)
 ///
-/// Returns `Some(archive_filename)` if files were archived, `None` if the
-/// output config has no positive globs or no files matched.
+/// Returns `Some(archive_filename)` if files were archived, `None` if no output files.
 fn collect_and_archive_outputs(
     cache_metadata: &CacheMetadata,
+    tracking: Option<&TrackingOutcome>,
+    ignored_output_rels: &FxHashSet<RelativePathBuf>,
     workspace_root: &AbsolutePath,
     cache_dir: &AbsolutePath,
 ) -> anyhow::Result<Option<Str>> {
+    use wax::Program as _;
+
     let output_config = &cache_metadata.output_config;
 
-    if output_config.positive_globs.is_empty() {
-        return Ok(None);
+    // Collect output files from auto-detection (fspy writes), excluding
+    // anything the tool reported via `ignoreOutput`.
+    let mut output_files: FxHashSet<RelativePathBuf> = FxHashSet::default();
+
+    if output_config.includes_auto
+        && let Some(t) = tracking
+    {
+        output_files
+            .extend(t.path_writes.iter().filter(|p| !is_ignored(p, ignored_output_rels)).cloned());
     }
 
-    let output_files = glob::collect_glob_paths(
-        workspace_root,
-        &output_config.positive_globs,
-        &output_config.negative_globs,
-    )?;
+    // Collect output files from positive globs
+    if !output_config.positive_globs.is_empty() {
+        let glob_paths = glob::collect_glob_paths(
+            workspace_root,
+            &output_config.positive_globs,
+            &output_config.negative_globs,
+        )?;
+        output_files.extend(glob_paths);
+    }
+
+    // Apply negative globs to auto-detected files
+    if output_config.includes_auto && !output_config.negative_globs.is_empty() {
+        let negatives: Vec<wax::Glob<'static>> = output_config
+            .negative_globs
+            .iter()
+            .map(|p| Ok(wax::Glob::new(p.as_str())?.into_owned()))
+            .collect::<anyhow::Result<_>>()?;
+        output_files.retain(|path| !negatives.iter().any(|neg| neg.is_match(path.as_str())));
+    }
 
     if output_files.is_empty() {
         return Ok(None);
     }
 
+    // Sort for deterministic archive content
+    let mut sorted_files: Vec<RelativePathBuf> = output_files.into_iter().collect();
+    sorted_files.sort();
+
+    // Create archive with UUID filename
     let archive_name: Str = vite_str::format!("{}.tar.zst", uuid::Uuid::new_v4());
     let archive_path = cache_dir.join(archive_name.as_str());
 
-    archive::create_output_archive(workspace_root, &output_files, &archive_path)?;
+    archive::create_output_archive(workspace_root, &sorted_files, &archive_path)?;
 
     Ok(Some(archive_name))
 }

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

@@ -90,9 +90,9 @@ struct CacheState<'a> {
     /// always present (possibly empty) once we reach the cache-update phase.
     std_outputs: Vec<StdOutput>,
     /// Runner-aware tracking for cached tasks: an IPC server is always
-    /// available, and fspy path tracing is attached only when auto input
-    /// inference needs it. Parts are borrowed in place during the wait/join;
-    /// the struct is never moved out.
+    /// available, and fspy path tracing is attached only when auto input or
+    /// output inference needs it. Parts are borrowed in place during the
+    /// wait/join; the struct is never moved out.
     tracking: Tracking,
 }
 
@@ -101,7 +101,7 @@ struct CacheState<'a> {
 type IpcDriver = LocalBoxFuture<'static, Result<Recorder, vite_task_server::Error>>;
 
 /// fspy path-tracking state, present only when a cached task needs automatic
-/// input inference.
+/// input or output inference.
 struct FspyTracking {
     input_negative_globs: Vec<wax::Glob<'static>>,
 }
@@ -166,7 +166,7 @@ impl<'a> ExecutionMode<'a> {
             });
         };
 
-        let fspy = if metadata.input_config.includes_auto {
+        let fspy = if metadata.input_config.includes_auto || metadata.output_config.includes_auto {
             // Resolve input negative globs for fspy path filtering (already
             // workspace-root-relative).
             let negatives = metadata
@@ -181,9 +181,11 @@ impl<'a> ExecutionMode<'a> {
             None
         };
 
-        // Bind runner IPC for every cached task. The merged cache-control API
-        // (`disableCache`) must work even when a task uses explicit inputs and
-        // therefore does not need fspy auto-input inference.
+        // Bind runner IPC for every cached task. `disableCache` and
+        // runner-served envs must work even when a task has explicit inputs
+        // and does not need fspy auto-input/output inference. Env requests
+        // resolve against the spawn's full env context, not the filtered child
+        // `all_envs`.
         let (ipc_envs, ServerHandle { driver, stop_accepting }) =
             serve(Recorder::new(Arc::clone(envs))).map_err(ExecutionError::IpcServerBind)?;
         let tracking =