feat(cache): honor runner ignored inputs

Co-authored-by: GPT-5 Codex <codex@openai.com>

Author: wan9chi

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- **Added** Runner-aware tools can now call `ignoreInput(path)` to exclude non-semantic reads from auto-inferred task cache inputs.
 - **Changed** Tracked environment values in task cache fingerprints are now stored only as SHA-256 digests, and env-related cache miss details report names without values.
 - **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 ([#450](https://github.com/voidzero-dev/vite-task/pull/450)).
 - **Added** Runner-aware `getEnvs` calls now return env values served by the runner for matching env glob patterns ([#449](https://github.com/voidzero-dev/vite-task/pull/449)).

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, EnvValueHash};
@@ -67,6 +68,12 @@ pub(super) async fn update_cache(
         return (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::ToolRequested), None);
     }
 
+    // Tool-reported paths to exclude from auto input 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();
+
     if cancelled {
         // Cancelled (Ctrl-C or sibling failure) — result is untrustworthy.
         return (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::Cancelled), None);
@@ -77,7 +84,8 @@ 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, input_negative_globs, &ignored_input_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
@@ -167,6 +175,7 @@ pub(super) async fn update_cache(
 fn observe_fspy(
     outcome: &ChildOutcome,
     input_negative_globs: Option<&[wax::Glob<'static>]>,
+    ignored_input_rels: &FxHashSet<RelativePathBuf>,
     workspace_root: &AbsolutePath,
 ) -> Option<TrackingOutcome> {
     #[cfg(fspy)]
@@ -175,14 +184,19 @@ fn observe_fspy(
 
         outcome.path_accesses.as_ref().zip(input_negative_globs).map(|(raw, negatives)| {
             let tracked = TrackedPathAccesses::from_raw(raw, workspace_root, negatives);
+            let path_reads: HashMap<RelativePathBuf, PathRead> = tracked
+                .path_reads
+                .into_iter()
+                .filter(|(path, _)| !is_ignored(path, ignored_input_rels))
+                .collect();
             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 }
+                path_reads.keys().find(|p| tracked.path_writes.contains(*p)).cloned();
+            TrackingOutcome { path_reads, read_write_overlap }
         })
     }
     #[cfg(not(fspy))]
     {
-        let _ = (outcome, input_negative_globs, workspace_root);
+        let _ = (outcome, input_negative_globs, ignored_input_rels, workspace_root);
         None
     }
 }
@@ -201,6 +215,52 @@ fn collect_tracked_reports(
         .map(Option::unwrap_or_default)
 }
 
+/// Normalize tool-reported absolute paths to cleaned workspace-relative paths.
+/// Paths outside the workspace are dropped — they can't contribute to inputs.
+fn normalize_ignored_paths(
+    paths: &FxHashSet<Arc<AbsolutePath>>,
+    workspace_root: &AbsolutePath,
+) -> FxHashSet<RelativePathBuf> {
+    paths
+        .iter()
+        .filter_map(|p| p.strip_path_prefix(workspace_root).ok().flatten()?.clean().ok())
+        .collect()
+}
+
+/// 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;
+    }
+    ignored.contains(path) || ignored.iter().any(|ig| path.strip_prefix(ig).is_some())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use rustc_hash::FxHashSet;
+    use vite_path::{AbsolutePath, RelativePathBuf};
+
+    use super::normalize_ignored_paths;
+
+    #[test]
+    fn normalize_ignored_paths_cleans_relative_components() {
+        let workspace_root =
+            AbsolutePath::new(if cfg!(windows) { r"C:\repo" } else { "/repo" }).unwrap();
+        let ignored =
+            workspace_root.join(if cfg!(windows) { r"pkg\..\cache" } else { "pkg/../cache" });
+        let mut ignored_paths = FxHashSet::default();
+        ignored_paths.insert(Arc::<AbsolutePath>::from(ignored));
+
+        let normalized = normalize_ignored_paths(&ignored_paths, &workspace_root);
+
+        let expected = RelativePathBuf::new("cache").unwrap();
+        assert!(normalized.contains(&expected));
+    }
+}
+
 /// Select tool-reported env records to embed in the post-run fingerprint.
 /// Names that the user already declared as fingerprinted are skipped because
 /// their values are already in the spawn fingerprint.

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

@@ -0,0 +1,10 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { ignoreInput } from '@voidzero-dev/vite-task-client';
+
+mkdirSync('cache_like', { recursive: true });
+mkdirSync('dist', { recursive: true });
+
+ignoreInput('cache_like');
+
+const value = readFileSync('cache_like/input.txt', 'utf8').trim();
+writeFileSync('dist/out.txt', value + '\n');

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/ignore_input.mjs

@@ -1,3 +1,34 @@
+[[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 under it between runs do not invalidate the cache.
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vtt",
+    "write-file",
+    "cache_like/input.txt",
+    "before",
+  ], comment = "seed the file the task will read and ignore" },
+  { argv = [
+    "vt",
+    "run",
+    "ignore-input",
+  ], comment = "populate the cache" },
+  { argv = [
+    "vtt",
+    "write-file",
+    "cache_like/input.txt",
+    "after",
+  ], comment = "mutate the ignored input — would invalidate if tracked" },
+  { argv = [
+    "vt",
+    "run",
+    "ignore-input",
+  ], comment = "cache hit: cache_like/ was ignored via ignoreInput" },
+]
+
 [[e2e]]
 name = "disable_cache_forces_reexecution"
 comment = """

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

@@ -0,0 +1,36 @@
+# ignore_input_keeps_cache_valid
+
+Exercises `ignoreInput` through `@voidzero-dev/vite-task-client`. The runner treats `cache_like/` as non-input, so mutations under it between runs do not invalidate the cache.
+
+## `vtt write-file cache_like/input.txt before`
+
+seed the file the task will read and ignore
+
+```
+```
+
+## `vt run ignore-input`
+
+populate the cache
+
+```
+$ node scripts/ignore_input.mjs
+```
+
+## `vtt write-file cache_like/input.txt after`
+
+mutate the ignored input — 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

@@ -1,5 +1,9 @@
 {
   "tasks": {
+    "ignore-input": {
+      "command": "node scripts/ignore_input.mjs",
+      "cache": true
+    },
     "disable-cache": {
       "command": "node scripts/disable_cache.mjs",
       "cache": true

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

@@ -9,6 +9,7 @@ rust-version.workspace = true
 [dependencies]
 native_str = { workspace = true }
 rustc-hash = { workspace = true }
+vite_path = { workspace = true }
 vite_task_ipc_shared = { workspace = true }
 wincode = { workspace = true, features = ["derive"] }
 

crates/vite_task_client/Cargo.toml

@@ -7,6 +7,7 @@ use std::{
 
 use native_str::NativeStr;
 use rustc_hash::FxHashMap;
+use vite_path::{self, AbsolutePath};
 use vite_task_ipc_shared::{GetEnvResponse, GetEnvsResponse, IPC_ENV_NAME, Request};
 use wincode::{SchemaRead, config::DefaultConfig};
 
@@ -46,13 +47,28 @@ impl Client {
         Self { stream: RefCell::new(stream), scratch: RefCell::new(Vec::new()) }
     }
 
+    /// `path` can be a file or a directory; for a directory, all files inside
+    /// it are ignored. Relative paths are resolved against the current working
+    /// directory before being sent to the runner.
+    ///
     /// Fire-and-forget: the call returns once the request is flushed to the
     /// kernel pipe buffer; the runner processes it during its drain phase
     /// after this process exits. See the `Request` type in the IPC protocol
     /// crate for why this is safe.
     ///
     /// # Errors
     ///
+    /// Returns an error if the request fails to send, or if a relative `path`
+    /// cannot be resolved against the current working directory.
+    pub fn ignore_input(&self, path: &OsStr) -> io::Result<()> {
+        let ns = resolve_path(path)?;
+        self.send(&Request::IgnoreInput(&ns))
+    }
+
+    /// Fire-and-forget — see [`Self::ignore_input`].
+    ///
+    /// # Errors
+    ///
     /// Returns an error if the request fails to send.
     pub fn disable_cache(&self) -> io::Result<()> {
         self.send(&Request::DisableCache)
@@ -129,6 +145,44 @@ impl Client {
     }
 }
 
+#[expect(
+    clippy::disallowed_types,
+    reason = "std::path::PathBuf is needed to round-trip through std::fs::canonicalize on Windows below"
+)]
+fn resolve_path(path: &OsStr) -> io::Result<Box<NativeStr>> {
+    let absolute: std::path::PathBuf = if let Some(abs) = AbsolutePath::new(path) {
+        abs.as_path().to_path_buf()
+    } else {
+        let mut buf = vite_path::current_dir()?;
+        buf.push(path);
+        buf.as_path().to_path_buf()
+    };
+
+    // On Windows, canonicalize so the path uses the exact on-disk casing and
+    // resolves substitute drives / junctions the same way fspy-reported paths
+    // do. Strip the `\\?\` namespace prefix for local drive paths because
+    // fspy strips it on the runner side too; keep `\\?\UNC\` unchanged.
+    #[cfg(windows)]
+    let absolute = std::fs::canonicalize(&absolute).map_or(absolute, |canonical| {
+        use std::{
+            ffi::OsString,
+            os::windows::ffi::{OsStrExt, OsStringExt},
+        };
+        let wide: Vec<u16> = canonical.as_os_str().encode_wide().collect();
+        let unc_prefix: Vec<u16> = r"\\?\UNC\".encode_utf16().collect();
+        let nt_prefix: Vec<u16> = r"\\?\".encode_utf16().collect();
+        if wide.starts_with(&unc_prefix) {
+            canonical
+        } else if let Some(rest) = wide.strip_prefix(nt_prefix.as_slice()) {
+            std::path::PathBuf::from(OsString::from_wide(rest))
+        } else {
+            canonical
+        }
+    });
+
+    Ok(Box::<NativeStr>::from(absolute.as_os_str()))
+}
+
 #[cfg(unix)]
 fn connect(name: &OsStr) -> io::Result<Stream> {
     std::os::unix::net::UnixStream::connect(name)

crates/vite_task_client/src/lib.rs

@@ -74,11 +74,11 @@ pub struct RunnerClient {
 
 #[napi]
 impl RunnerClient {
-    /// No-op for now: the runner cannot apply ignore reports yet. Becomes a
-    /// real request once auto output tracking can consume them.
     #[napi]
-    pub fn ignore_input(&self, _path: String) -> Result<()> {
-        Ok(())
+    pub fn ignore_input(&self, path: String) -> Result<()> {
+        self.client
+            .ignore_input(OsStr::new(&path))
+            .map_err(|err| err_string(vite_str::format!("{err}")))
     }
 
     /// No-op for now — see [`Self::ignore_input`].