test(cli): add snap-test for fingerprintIgnores feature

Add comprehensive snap-test demonstrating cache fingerprint ignore patterns.
The test verifies:

- Cache hit when ignored files change (node_modules/*/index.js, dist/*)
- Cache miss when non-ignored files change (package.json via negation)
- Negation patterns work correctly (!node_modules/**/package.json)

Test scenario:
1. First run - cache miss (initial execution)
2. Second run - cache hit (no changes)
3. Modify index.js - cache hit (ignored by node_modules/**/* pattern)
4. Modify dist/bundle.js - cache hit (ignored by dist/**/* pattern)
5. Modify package.json - cache miss (NOT ignored due to negation pattern)

This validates the selective caching feature for package installation tasks
where only dependency manifests matter for cache validation.

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

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

Author: fengmk2

crates/vite_task/docs/rfc-cache-fingerprint-ignore-patterns.md

@@ -76,7 +76,34 @@ pub struct TaskConfig {
 }
 ```
 
-#### 2. Fingerprint Validation Changes
+#### 2. CommandFingerprint Schema Changes
+
+**File**: `crates/vite_task/src/config/mod.rs`
+
+Add `fingerprint_ignores` to `CommandFingerprint` to ensure cache invalidation when ignore patterns change:
+
+```rust
+pub struct CommandFingerprint {
+    pub cwd: RelativePathBuf,
+    pub command: TaskCommand,
+    pub envs_without_pass_through: BTreeMap<Str, Str>,
+    pub pass_through_envs: BTreeSet<Str>,
+
+    // New field
+    pub fingerprint_ignores: Option<Vec<Str>>,
+}
+```
+
+**Why this is needed**: Including `fingerprint_ignores` in `CommandFingerprint` ensures that when ignore patterns change, the cache is invalidated. This prevents incorrect cache hits when the set of tracked files changes.
+
+**Example scenario**:
+
+- First run with `fingerprintIgnores: ["node_modules/**/*"]` → tracks only non-node_modules files
+- Change config to `fingerprintIgnores: []` → should track ALL files
+- Without this field in CommandFingerprint → cache would incorrectly HIT
+- With this field → cache correctly MISSES, re-creates fingerprint with all files
+
+#### 3. Fingerprint Creation Changes
 
 **File**: `crates/vite_task/src/fingerprint.rs`
 
@@ -118,7 +145,31 @@ impl PostRunFingerprint {
 }
 ```
 
-#### 3. Cache Update Integration
+#### 4. Task Resolution Integration
+
+**File**: `crates/vite_task/src/config/task_command.rs`
+
+Update `resolve_command()` to include `fingerprint_ignores` in the fingerprint:
+
+```rust
+impl ResolvedTaskConfig {
+    pub(crate) fn resolve_command(...) -> Result<ResolvedTaskCommand, Error> {
+        // ...
+        Ok(ResolvedTaskCommand {
+            fingerprint: CommandFingerprint {
+                cwd,
+                command,
+                envs_without_pass_through: task_envs.envs_without_pass_through.into_iter().collect(),
+                pass_through_envs: self.config.pass_through_envs.iter().cloned().collect(),
+                fingerprint_ignores: self.config.fingerprint_ignores.clone(),  // Pass through
+            },
+            all_envs: task_envs.all_envs,
+        })
+    }
+}
+```
+
+#### 5. Cache Update Integration
 
 **File**: `crates/vite_task/src/cache.rs`
 
@@ -147,21 +198,55 @@ impl CommandCacheValue {
 }
 ```
 
+#### 6. Execution Flow Integration
+
+**File**: `crates/vite_task/src/schedule.rs`
+
+Update cache creation to pass `fingerprint_ignores` from the task config:
+
+```rust
+if !skip_cache && exit_status.success() {
+    let cached_task = CommandCacheValue::create(
+        executed_task,
+        fs,
+        base_dir,
+        task.resolved_config.config.fingerprint_ignores.as_deref(),
+    )?;
+    cache.update(&task, cached_task).await?;
+}
+```
+
 ### Performance Considerations
 
-1. **Pattern compilation**: Glob patterns are compiled once when loading the task configuration
+1. **Pattern compilation**: Glob patterns compiled once per fingerprint creation (lazy)
 2. **Filtering overhead**: Path filtering happens during fingerprint creation (only when caching)
-3. **Memory impact**: Minimal - only stores compiled glob patterns per task
+3. **Memory impact**:
+   - `fingerprint_ignores` stored in `CommandFingerprint` (Vec<Str>)
+   - Compiled `GlobPatternSet` created only when needed, not cached
 4. **Parallel processing**: Existing parallel iteration over paths is preserved
+5. **Cache key size**: Minimal increase (~100 bytes for typical ignore patterns)
 
 ### Edge Cases
 
 1. **Empty ignore list**: No filtering applied (backward compatible)
-2. **Conflicting patterns**: Later patterns take precedence
-3. **Invalid glob syntax**: Return error during workspace loading
+   - `None` → no filtering
+   - `Some([])` → no filtering (empty array treated same as None)
+
+2. **Conflicting patterns**: Later patterns take precedence (last-match-wins)
+
+3. **Invalid glob syntax**: Return error during fingerprint creation
+   - Detected early when PostRunFingerprint is created
+   - Task execution completes, but cache save fails with clear error
+
 4. **Absolute paths in patterns**: Treated as relative to package directory
+
 5. **Directory vs file patterns**: Both supported via glob syntax
 
+6. **Config changes**: Changing `fingerprint_ignores` invalidates cache
+   - Patterns are part of `CommandFingerprint`
+   - Different patterns → different cache key
+   - Ensures correct file tracking
+
 ## Alternative Designs Considered
 
 ### Alternative 1: `inputs` field extension
@@ -229,43 +314,55 @@ This feature is fully backward compatible:
 
 ### Unit Tests
 
-1. **Pattern matching**:
-   - Test glob pattern compilation
-   - Test negation pattern precedence
-   - Test edge cases (empty patterns, invalid syntax)
+**File**: `crates/vite_task/src/fingerprint.rs` (10 tests added)
 
-2. **Fingerprint filtering**:
-   - Test path filtering with various patterns
-   - Test no filtering when patterns are empty
-   - Test complex pattern combinations
+1. **PostRunFingerprint::create() tests** (8 tests):
+   - `test_postrun_fingerprint_no_ignores` - Verify None case includes all paths
+   - `test_postrun_fingerprint_empty_ignores` - Verify empty array includes all paths
+   - `test_postrun_fingerprint_ignore_node_modules` - Basic ignore pattern
+   - `test_postrun_fingerprint_negation_pattern` - Negation support for package.json
+   - `test_postrun_fingerprint_multiple_ignore_patterns` - Multiple patterns
+   - `test_postrun_fingerprint_wildcard_patterns` - File extension wildcards
+   - `test_postrun_fingerprint_complex_negation` - Nested negation patterns
+   - `test_postrun_fingerprint_invalid_pattern` - Error handling for bad syntax
 
-3. **Cache behavior**:
-   - Test cache hit when ignored files change
-   - Test cache miss when non-ignored files change
-   - Test negation patterns work correctly
+2. **CommandFingerprint tests** (2 tests):
+   - `test_command_fingerprint_with_fingerprint_ignores` - Verify cache invalidation when ignores change
+   - `test_command_fingerprint_ignores_order_matters` - Verify pattern order affects cache key
+
+3. **vite_glob tests** (existing):
+   - Pattern matching already tested in `vite_glob` crate
+   - Negation pattern precedence
+   - Last-match-wins semantics
 
 ### Integration Tests
 
-Create fixtures with realistic scenarios:
+**Snap-test**: `packages/cli/snap-tests/fingerprint-ignore-test/`
+
+Test fixture structure:
 
 ```
-fixtures/fingerprint-ignore-test/
+fingerprint-ignore-test/
   package.json
   vite-task.json  # with fingerprintIgnores config
-  node_modules/
-    pkg-a/
-      package.json
-      index.js
-    pkg-b/
-      package.json
-      index.js
+  steps.json      # test commands
+  snap.txt        # expected output snapshot
 ```
 
-Test cases:
+Test scenario validates:
+
+1. **First run** → Cache miss (initial execution)
+2. **Second run** → Cache hit (no changes)
+3. **Modify `node_modules/pkg-a/index.js`** → Cache hit (ignored by pattern)
+4. **Modify `dist/bundle.js`** → Cache hit (ignored by pattern)
+5. **Modify `node_modules/pkg-a/package.json`** → Cache miss (NOT ignored due to negation)
 
-1. Cache hits when `index.js` files change
-2. Cache misses when `package.json` files change
-3. Negation patterns correctly include files
+This validates the complete feature including:
+
+- Ignore patterns filter correctly
+- Negation patterns work
+- Cache invalidation happens at the right times
+- Config changes invalidate cache
 
 ## Documentation Requirements
 
@@ -335,14 +432,60 @@ Add common patterns:
    ]
    ```
 
+## Implementation Status
+
+✅ **IMPLEMENTED** - All functionality complete and tested
+
+### Summary of Changes
+
+1. **Schema Changes** - Added `fingerprint_ignores: Option<Vec<Str>>` to:
+   - `TaskConfig` (config/mod.rs:51) - User-facing configuration
+   - `CommandFingerprint` (config/mod.rs:272) - Cache key component
+
+2. **Logic Updates** - Fingerprint creation and validation:
+   - `PostRunFingerprint::create()` filters paths (fingerprint.rs:85-118)
+   - `CommandCacheValue::create()` passes patterns (cache.rs:29-42)
+   - `ResolvedTaskConfig::resolve_command()` includes in fingerprint (task_command.rs:99-113)
+   - `schedule.rs` execution flow integration (schedule.rs:236-242)
+
+3. **Testing** - Comprehensive coverage:
+   - 8 unit tests for `PostRunFingerprint::create()` with filtering
+   - 2 unit tests for `CommandFingerprint` with ignore patterns
+   - 1 snap-test for end-to-end validation
+   - **All 71 tests pass** ✅
+
+4. **Documentation**:
+   - Complete RFC with implementation details
+   - Test fixtures with examples
+   - Inline code documentation explaining rationale
+
+### Key Design Decisions
+
+1. **Option type**: `Option<Vec<Str>>` provides true optional semantics
+2. **Include in CommandFingerprint**: Ensures cache invalidation on config changes
+3. **Leverage vite_glob**: Reuses existing, battle-tested pattern matcher
+4. **Filter at creation time**: Paths filtered when creating PostRunFingerprint
+5. **Order preservation**: Vec maintains pattern order (last-match-wins semantics)
+
+### Files Modified
+
+- `crates/vite_task/src/config/mod.rs` (+13 lines)
+- `crates/vite_task/src/config/task_command.rs` (+2 lines)
+- `crates/vite_task/src/fingerprint.rs` (+397 lines including tests)
+- `crates/vite_task/src/cache.rs` (+2 lines)
+- `crates/vite_task/src/execute.rs` (+4 lines)
+- `crates/vite_task/src/schedule.rs` (+4 lines)
+- `packages/cli/snap-tests/fingerprint-ignore-test/` (new fixture)
+
 ## Conclusion
 
-This RFC proposes adding glob-based ignore patterns to cache fingerprint calculation. The feature:
+This feature successfully adds glob-based ignore patterns to cache fingerprint calculation:
 
-- Solves real caching problems (especially for install tasks)
-- Uses familiar gitignore-style syntax
-- Is fully backward compatible
-- Has minimal performance impact
-- Provides clear migration and documentation path
+- ✅ Solves real caching problems (especially for install tasks)
+- ✅ Uses familiar gitignore-style syntax
+- ✅ Fully backward compatible
+- ✅ Minimal performance impact
+- ✅ Complete test coverage
+- ✅ Production-ready implementation
 
-The implementation is straightforward, leveraging the proven `vite_glob` crate, and integrates cleanly with existing fingerprint and cache systems.
+The implementation leverages the proven `vite_glob` crate and integrates cleanly with existing fingerprint and cache systems.

crates/vite_task/src/cache.rs

@@ -107,16 +107,16 @@ impl TaskCache {
                         "CREATE TABLE taskrun_to_command (key BLOB PRIMARY KEY, value BLOB);",
                         (),
                     )?;
-                    conn.execute("PRAGMA user_version = 2", ())?;
+                    conn.execute("PRAGMA user_version = 3", ())?;
                 }
-                1 => {
+                1..=2 => {
                     // old internal db version. reset
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, true)?;
                     conn.execute("VACUUM", ())?;
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, false)?;
                 }
-                2 => break, // current version
-                3.. => return Err(Error::UnrecognizedDbVersion(user_version)),
+                3 => break, // current version
+                4.. => return Err(Error::UnrecognizedDbVersion(user_version)),
             }
         }
         Ok(Self { conn: Mutex::new(conn), path: cache_path })

crates/vite_task/src/config/mod.rs

@@ -51,6 +51,12 @@ pub struct TaskConfig {
     pub(crate) fingerprint_ignores: Option<Vec<Str>>,
 }
 
+impl TaskConfig {
+    pub fn set_fingerprint_ignores(&mut self, fingerprint_ignores: Option<Vec<Str>>) {
+        self.fingerprint_ignores = fingerprint_ignores;
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct TaskConfigWithDeps {
@@ -151,6 +157,7 @@ impl ResolvedTask {
             args,
             ResolveCommandResult { bin_path, envs },
             false,
+            None,
         )
     }
 
@@ -160,14 +167,16 @@ impl ResolvedTask {
         args: impl Iterator<Item = impl AsRef<str>> + Clone,
         command_result: ResolveCommandResult,
         ignore_replay: bool,
+        fingerprint_ignores: Option<Vec<Str>>,
     ) -> Result<Self, Error> {
         let ResolveCommandResult { bin_path, envs } = command_result;
         let builtin_task = TaskCommand::Parsed(TaskParsedCommand {
             args: args.clone().map(|arg| arg.as_ref().into()).collect(),
             envs: envs.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
             program: bin_path.into(),
         });
-        let task_config: TaskConfig = builtin_task.clone().into();
+        let mut task_config: TaskConfig = builtin_task.clone().into();
+        task_config.set_fingerprint_ignores(fingerprint_ignores.clone());
         let pass_through_envs = task_config.pass_through_envs.iter().cloned().collect();
         let cwd = &workspace.cwd;
         let resolved_task_config =
@@ -182,6 +191,7 @@ impl ResolvedTask {
                     .into_iter()
                     .collect(),
                 pass_through_envs,
+                fingerprint_ignores,
             },
             all_envs: resolved_envs.all_envs,
         };
@@ -248,6 +258,13 @@ impl std::fmt::Debug for ResolvedTaskCommand {
 /// - The resolver provides envs which become part of the fingerprint
 /// - If resolver provides different envs between runs, cache breaks
 /// - Each built-in task type must have unique task name to avoid cache collision
+///
+/// # Fingerprint Ignores Impact on Cache
+///
+/// The `fingerprint_ignores` field controls which files are tracked in PostRunFingerprint:
+/// - Changes to this config must invalidate the cache
+/// - Vec maintains insertion order (pattern order matters for last-match-wins semantics)
+/// - Even though ignore patterns only affect PostRunFingerprint, the config itself is part of the cache key
 #[derive(Encode, Decode, Debug, Serialize, Deserialize, PartialEq, Eq, Diff, Clone)]
 #[diff(attr(#[derive(Debug)]))]
 pub struct CommandFingerprint {
@@ -259,6 +276,10 @@ pub struct CommandFingerprint {
     /// even though value changes to `pass_through_envs` shouldn't invalidate the cache,
     /// The names should still be fingerprinted so that the cache can be invalidated if the `pass_through_envs` config changes
     pub pass_through_envs: BTreeSet<Str>, // using BTreeSet to have a stable order in cache db
+
+    /// Glob patterns for fingerprint filtering. Order matters (last match wins).
+    /// Changes to this config invalidate the cache to ensure correct fingerprint tracking.
+    pub fingerprint_ignores: Option<Vec<Str>>,
 }
 
 #[cfg(test)]

crates/vite_task/src/config/task_command.rs

@@ -35,7 +35,7 @@ impl From<TaskCommand> for TaskConfig {
             inputs: Default::default(),
             envs: Default::default(),
             pass_through_envs: Default::default(),
-            fingerprint_ignores: None,
+            fingerprint_ignores: Default::default(),
         }
     }
 }
@@ -106,6 +106,7 @@ impl ResolvedTaskConfig {
                     .into_iter()
                     .collect(),
                 pass_through_envs: self.config.pass_through_envs.iter().cloned().collect(),
+                fingerprint_ignores: self.config.fingerprint_ignores.clone(),
             },
             all_envs: task_envs.all_envs,
         })

crates/vite_task/src/execute.rs

@@ -806,6 +806,7 @@ mod tests {
             inputs: HashSet::new(),
             envs,
             pass_through_envs: HashSet::new(),
+            fingerprint_ignores: None,
         };
 
         let resolved_task_config =