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

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

- `output: None` resolves to auto inference again, so fspy-written files
  are archived and restored on a cache hit (auto output restoration).
- `ignoreInput`/`ignoreOutput` reported over IPC are now 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.
- Re-adds the e2e coverage: ignoreInput keeps the cache valid,
  ignoreOutput allows a read-write overlap, and vite build caches and
  restores its outputs 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 env tracking: tools can ask the runner for env values via `getEnv`/`getEnvs`, and the served values (and glob match-sets) become part of the cache fingerprint, so changing them invalidates the cache with the env var named in the miss message ([#430](https://github.com/voidzero-dev/vite-task/pull/430))
 - **Added** Runner-aware tools can now opt the current task run out of caching through the new IPC channel; Vite dev server integration uses this automatically ([#441](https://github.com/voidzero-dev/vite-task/pull/441))
 - **Fixed** Prefix environment assignments like `PATH=... command` now affect executable lookup during task planning, so tools provided only by the prefixed `PATH` can be resolved correctly ([#440](https://github.com/voidzero-dev/vite-task/pull/440))

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

@@ -67,13 +67,14 @@ pub(super) async fn update_cache(
         return (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::ToolRequested), None);
     }
 
-    // `ignoreInput`/`ignoreOutput` are accepted over IPC but not yet
-    // applied — runner-aware output tracking (which consumes them) lands
-    // in a follow-up. Treat the reported ignore sets as empty so they
-    // have no effect on input/output inference or the read-write overlap
-    // check.
-    let ignored_input_rels: FxHashSet<RelativePathBuf> = FxHashSet::default();
-    let ignored_output_rels: FxHashSet<RelativePathBuf> = FxHashSet::default();
+    // 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.
@@ -240,6 +241,67 @@ fn observe_fspy(
     }
 }
 
+/// 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 {

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

@@ -89,10 +89,10 @@ struct CacheState<'a> {
     /// Captured stdout/stderr for cache replay. Written in place during drain;
     /// always present (possibly empty) once we reach the cache-update phase.
     std_outputs: Vec<StdOutput>,
-    /// `Some` iff auto-input tracking is on (`includes_auto` + successful
-    /// IPC bind). Bundles fspy's input negative globs with the per-task IPC
-    /// server that runner-aware tools talk to. Parts are borrowed in place
-    /// during the wait/join; the struct is never moved out.
+    /// `Some` iff auto-input or auto-output tracking is on (`includes_auto` +
+    /// successful IPC bind). Bundles fspy's input negative globs with the
+    /// per-task IPC server that runner-aware tools talk to. Parts are borrowed
+    /// in place during the wait/join; the struct is never moved out.
     tracking: Option<Tracking>,
 }
 
@@ -160,7 +160,9 @@ impl<'a> ExecutionMode<'a> {
             });
         };
 
-        let tracking = if metadata.input_config.includes_auto {
+        let tracking = 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

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input_cache_test/snapshots/fspy_env___not_set_when_auto_inference_disabled.md

@@ -6,5 +6,5 @@ When auto-inference is disabled (explicit globs only), the task process should n
 
 ```
 $ vtt print-env FSPY
-(undefined)
+1
 ```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots.toml

@@ -1,3 +1,61 @@
+[[e2e]]
+name = "ignore_input_keeps_cache_valid"
+comment = """
+Exercises `ignoreInput` through `@voidzero-dev/vite-task-client`.
+The runner treats `cache_like/` as non-input, so mutations to it between
+runs do not invalidate the cache.
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "ignore-input",
+  ], comment = "populate the cache" },
+  { argv = [
+    "vtt",
+    "write-file",
+    "cache_like/other.txt",
+    "after",
+  ], comment = "mutate the ignored directory — would invalidate if tracked" },
+  { argv = [
+    "vt",
+    "run",
+    "ignore-input",
+  ], comment = "cache hit: cache_like/ was ignored via ignoreInput" },
+]
+
+[[e2e]]
+name = "ignore_output_allows_read_write_overlap"
+comment = """
+Exercises `ignoreOutput`. The task reads and writes `sidecar/tmp.txt`;
+without the ignore the runner's read-write overlap check would refuse to
+cache the run ("read and wrote 'sidecar/tmp.txt'").
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "ignore-output",
+  ], comment = "first run populates the cache" },
+  { argv = [
+    "vtt",
+    "rm",
+    "dist/out.txt",
+  ], comment = "remove the real output so the cache-hit restore is observable" },
+  { argv = [
+    "vt",
+    "run",
+    "ignore-output",
+  ], comment = "cache hit: sidecar/ writes were ignored" },
+  { argv = [
+    "vtt",
+    "print-file",
+    "dist/out.txt",
+  ], comment = "restored from the cache archive" },
+]
+
 [[e2e]]
 name = "disable_cache_forces_reexecution"
 comment = """

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/ignore_input_keeps_cache_valid.md

@@ -0,0 +1,31 @@
+# ignore_input_keeps_cache_valid
+
+Exercises `ignoreInput` through `@voidzero-dev/vite-task-client`.
+The runner treats `cache_like/` as non-input, so mutations to it between
+runs do not invalidate the cache.
+
+## `vt run ignore-input`
+
+populate the cache
+
+```
+$ node scripts/ignore_input.mjs
+```
+
+## `vtt write-file cache_like/other.txt after`
+
+mutate the ignored directory — would invalidate if tracked
+
+```
+```
+
+## `vt run ignore-input`
+
+cache hit: cache_like/ was ignored via ignoreInput
+
+```
+$ node scripts/ignore_input.mjs ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/ignore_output_allows_read_write_overlap.md

@@ -0,0 +1,39 @@
+# ignore_output_allows_read_write_overlap
+
+Exercises `ignoreOutput`. The task reads and writes `sidecar/tmp.txt`;
+without the ignore the runner's read-write overlap check would refuse to
+cache the run ("read and wrote 'sidecar/tmp.txt'").
+
+## `vt run ignore-output`
+
+first run populates the cache
+
+```
+$ node scripts/ignore_output.mjs
+```
+
+## `vtt rm dist/out.txt`
+
+remove the real output so the cache-hit restore is observable
+
+```
+```
+
+## `vt run ignore-output`
+
+cache hit: sidecar/ writes were ignored
+
+```
+$ node scripts/ignore_output.mjs ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```
+
+## `vtt print-file dist/out.txt`
+
+restored from the cache archive
+
+```
+ok
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_build_cache/snapshots.toml

@@ -1,3 +1,39 @@
+[[e2e]]
+name = "vite_build_caches_and_restores_outputs"
+comment = """
+`vt run --cache build` must produce a cache hit on the second run without any manual input/output configuration. Vite reports `ignoreInput(outDir)` + `ignoreInput/Output(cacheDir)` via `@voidzero-dev/vite-task-client`, so fspy-detected reads of `dist/` and writes to `node_modules/.vite/` don't poison the cache.
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "--cache",
+    "build",
+  ], comment = "first run: cache miss, emits dist/" },
+  { argv = [
+    "vtt",
+    "stat-file",
+    "dist/assets/main.js",
+  ], comment = "existence check — content would drift across Vite versions" },
+  { argv = [
+    "vtt",
+    "rm",
+    "dist/assets/main.js",
+  ], comment = "remove the artefact so the cache-hit restore is observable" },
+  { argv = [
+    "vt",
+    "run",
+    "--cache",
+    "build",
+  ], comment = "cache hit: outputs restored without manual config" },
+  { argv = [
+    "vtt",
+    "stat-file",
+    "dist/assets/main.js",
+  ], comment = "restored from the cache archive" },
+]
+
 [[e2e]]
 name = "vite_prefix_env_change_invalidates_cache"
 comment = """

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_build_cache/snapshots/vite_build_caches_and_restores_outputs.md

@@ -0,0 +1,45 @@
+# vite_build_caches_and_restores_outputs
+
+`vt run --cache build` must produce a cache hit on the second run without any manual input/output configuration. Vite reports `ignoreInput(outDir)` + `ignoreInput/Output(cacheDir)` via `@voidzero-dev/vite-task-client`, so fspy-detected reads of `dist/` and writes to `node_modules/.vite/` don't poison the cache.
+
+## `vt run --cache build`
+
+first run: cache miss, emits dist/
+
+```
+$ vite build
+```
+
+## `vtt stat-file dist/assets/main.js`
+
+existence check — content would drift across Vite versions
+
+```
+dist/assets/main.js: exists
+```
+
+## `vtt rm dist/assets/main.js`
+
+remove the artefact so the cache-hit restore is observable
+
+```
+```
+
+## `vt run --cache build`
+
+cache hit: outputs restored without manual config
+
+```
+$ vite build ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```
+
+## `vtt stat-file dist/assets/main.js`
+
+restored from the cache archive
+
+```
+dist/assets/main.js: exists
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_build_cache/vite-task.json

@@ -5,15 +5,6 @@
       // No `"env": [...]` — vite's patched `loadEnv` asks the runner for
       // every `VITE_*` env via `getEnvs`, so the glob + match-set are
       // fingerprinted automatically.
-      //
-      // Auto output tracking (which lets vite `ignoreInput`/`ignoreOutput` the
-      // out dir and the dirs it writes-then-reads) is not implemented yet, so
-      // excluding them from auto input inference keeps `vite build` cacheable:
-      // it stops fspy's reads of the build's own outputs (`dist/`) and vite's
-      // write-then-read config-timestamp temp files (`node_modules/.vite-temp/`)
-      // from being treated as inputs, which would otherwise trip the read-write
-      // overlap check.
-      "input": ["!dist/**", "!node_modules/.vite-temp/**", { "auto": true }],
       "cache": true
     }
   }