feat(cache): add explicit inputs config for cache fingerprinting (#104)

## Summary
- Add `inputs` field to task configuration for explicit cache fingerprinting
- Support glob patterns, auto-inference from fspy, negative patterns, and mixed mode
- Expand trailing `/` in globs to `/**` (e.g., `"src/"` → `"src/**"`)
- Bare directory names (e.g., `"src"` without `/`) match nothing — only files are fingerprinted
- Remove `fstat` interception in fspy (fd was already tracked via `open`)
- Skip duplicate files across overlapping glob patterns via entry API

### Input modes
- Explicit globs: `inputs: ["src/**/*.ts"]`
- Auto-inference: `inputs: [{ "auto": true }]`
- Negative patterns: `inputs: ["src/**", "!**/*.test.ts"]`
- Directory shorthand: `inputs: ["src/"]` (expands to `"src/**"`)
- Mixed: `inputs: ["package.json", { "auto": true }, "!dist/**"]`
- Empty (no file tracking): `inputs: []`

## Test plan
- [x] Plan snapshot: `inputs-trailing-slash` verifies `src/` → `src/**` and `!dist/` → `dist/**`
- [x] E2E: all input combinations (positive, negative, auto, mixed, empty)
- [x] E2E: `folder-slash-input` — cache miss on direct and nested file changes, hit on outside
- [x] E2E: `folder-input` — bare directory name fingerprints nothing
- [x] E2E: glob meta chars in package paths (`packages/[lib]`)
- [x] E2E: cross-package `..` globs in subpackages
- [x] Unit tests: overlapping globs deduplicate, negative exclusions, sibling packages

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: branchseer

Cargo.lock

@@ -100,6 +100,7 @@ impl SpyImpl {
         )
         .map_err(|err| SpawnError::Injection(err.into()))?;
         command.set_exec(exec);
+        command.env("FSPY", "1");
 
         let mut tokio_command = command.into_tokio_command();
 

crates/fspy/src/unix/mod.rs

@@ -73,8 +73,9 @@ impl SpyImpl {
     }
 
     #[expect(clippy::unused_async, reason = "async signature required by SpyImpl trait")]
-    pub(crate) async fn spawn(&self, command: Command) -> Result<TrackedChild, SpawnError> {
+    pub(crate) async fn spawn(&self, mut command: Command) -> Result<TrackedChild, SpawnError> {
         let ansi_dll_path_with_nul = Arc::clone(&self.ansi_dll_path_with_nul);
+        command.env("FSPY", "1");
         let mut command = command.into_tokio_command();
 
         command.creation_flags(CREATE_SUSPENDED);

crates/fspy/src/windows/mod.rs

@@ -2,10 +2,7 @@ use fspy_shared::ipc::AccessMode;
 use libc::{c_char, c_int, stat as stat_struct};
 
 use crate::{
-    client::{
-        convert::{Fd, PathAt},
-        handle_open,
-    },
+    client::{convert::PathAt, handle_open},
     macros::intercept,
 };
 
@@ -30,16 +27,6 @@ unsafe extern "C" fn lstat(path: *const c_char, buf: *mut stat_struct) -> c_int
     unsafe { lstat::original()(path, buf) }
 }
 
-intercept!(fstat(64): unsafe extern "C" fn(fd: c_int, buf: *mut stat_struct) -> c_int);
-unsafe extern "C" fn fstat(fd: c_int, buf: *mut stat_struct) -> c_int {
-    // SAFETY: fd is a valid file descriptor provided by the caller of the interposed function
-    unsafe {
-        handle_open(Fd(fd), AccessMode::READ);
-    }
-    // SAFETY: calling the original libc fstat() with the same arguments forwarded from the interposed function
-    unsafe { fstat::original()(fd, buf) }
-}
-
 intercept!(fstatat(64): unsafe extern "C" fn(dirfd: c_int, pathname: *const c_char, buf: *mut stat_struct, flags: c_int) -> c_int);
 unsafe extern "C" fn fstatat(
     dirfd: c_int,

crates/fspy_preload_unix/src/interceptions/stat.rs

@@ -9,6 +9,7 @@ rust-version.workspace = true
 
 [dependencies]
 thiserror = { workspace = true }
+vite_path = { workspace = true }
 wax = { workspace = true }
 
 [dev-dependencies]

crates/vite_glob/Cargo.toml

@@ -2,4 +2,8 @@
 pub enum Error {
     #[error(transparent)]
     WaxBuild(#[from] wax::BuildError),
+    #[error(transparent)]
+    Walk(#[from] wax::walk::WalkError),
+    #[error(transparent)]
+    InvalidPathData(#[from] vite_path::relative::InvalidPathDataError),
 }

crates/vite_glob/src/error.rs

@@ -9,6 +9,7 @@ rust-version.workspace = true
 [dependencies]
 bincode = { workspace = true }
 diff-struct = { workspace = true }
+path-clean = { workspace = true }
 ref-cast = { workspace = true }
 serde = { workspace = true, features = ["derive", "rc"] }
 thiserror = { workspace = true }

crates/vite_path/Cargo.toml

@@ -200,6 +200,24 @@ impl AbsolutePath {
     pub fn ends_with<P: AsRef<Path>>(&self, path: P) -> bool {
         self.0.ends_with(path.as_ref())
     }
+
+    /// Lexically normalizes the path by resolving `.` and `..` components
+    /// without accessing the filesystem.
+    ///
+    /// **Symlink limitation**: Because this is purely lexical, it can produce
+    /// incorrect results when symlinks are involved. For example, if
+    /// `/a/link` is a symlink to `/x/y`, then cleaning `/a/link/../c`
+    /// yields `/a/c` instead of the correct `/x/c`. Use
+    /// [`std::fs::canonicalize`] when you need symlink-correct resolution.
+    #[must_use]
+    pub fn clean(&self) -> AbsolutePathBuf {
+        use path_clean::PathClean as _;
+
+        let cleaned = self.0.clean();
+        // SAFETY: Lexical cleaning of an absolute path preserves absoluteness —
+        // it only removes `.`/`..` components and redundant separators.
+        unsafe { AbsolutePathBuf::assume_absolute(cleaned) }
+    }
 }
 
 /// An Error returned from [`AbsolutePath::strip_prefix`] if the stripped path is not a valid `RelativePath`

crates/vite_path/src/absolute/mod.rs

@@ -62,6 +62,28 @@ impl RelativePath {
         relative_path_buf
     }
 
+    /// Lexically normalizes the path by resolving `..` components without
+    /// accessing the filesystem. (`.` components are already stripped by
+    /// [`RelativePathBuf::new`].)
+    ///
+    /// **Symlink limitation**: Because this is purely lexical, it can produce
+    /// incorrect results when symlinks are involved. For example, if
+    /// `a/link` is a symlink to `x/y`, then cleaning `a/link/../c`
+    /// yields `a/c` instead of the correct `x/c`. Use
+    /// [`std::fs::canonicalize`] when you need symlink-correct resolution.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the cleaned path is no longer a valid relative path, which
+    /// should never happen in practice.
+    #[must_use]
+    pub fn clean(&self) -> RelativePathBuf {
+        use path_clean::PathClean as _;
+
+        let cleaned = self.as_path().clean();
+        RelativePathBuf::new(cleaned).expect("cleaning a relative path preserves relativity")
+    }
+
     /// Returns a path that, when joined onto `base`, yields `self`.
     ///
     /// If `base` is not a prefix of `self`, returns [`None`].

crates/vite_path/src/relative.rs

@@ -33,13 +33,16 @@ thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "io-std", "io-util", "macros", "sync"] }
 tracing = { workspace = true }
 twox-hash = { workspace = true }
-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_workspace = { workspace = true }
+wax = { workspace = true }
+
+[dev-dependencies]
+tempfile = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = { workspace = true }