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 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))

Cargo.lock

@@ -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/cache_update.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/src/session/execute/mod.rs

@@ -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/input_cache_test/snapshots/fspy_env___not_set_when_auto_inference_disabled.md

@@ -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.toml

@@ -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_input_keeps_cache_valid.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/ipc_client_test/snapshots/ignore_output_allows_read_write_overlap.md

@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <head>
+    <title>vp-run-vite-cache</title>
+  </head>
+  <body>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_build_cache/index.html

@@ -0,0 +1,5 @@
+{
+  "name": "vite-build-cache-fixture",
+  "private": true,
+  "type": "module"
+}