feat: improve cache miss messages with specific input change kinds

Unify GlobbedInput and PostRunFingerprint mismatch variants into a
single InputChanged { kind, path } with Added/Removed/ContentModified
discrimination. Messages now show '{path} modified', '{file} added in
{dir}', or '{file} removed from {dir}' instead of generic 'content of
input changed'.

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

# Conflicts:
#	crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-negative-glob-subpackage/snapshots/dotdot auto negative - miss on non-excluded sibling inferred file.snap

Author: branchseer

crates/vite_task/src/session/cache/display.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use vite_str::Str;
 use vite_task_plan::cache_metadata::SpawnFingerprint;
 
-use super::{CacheMiss, FingerprintMismatch};
+use super::{CacheMiss, FingerprintMismatch, InputChangeKind, split_path};
 use crate::session::event::CacheStatus;
 
 /// Describes a single atomic change between two spawn fingerprints.
@@ -174,24 +174,28 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
                     }
                 }
                 FingerprintMismatch::InputConfig => "inputs configuration changed",
-                FingerprintMismatch::GlobbedInput { path } => {
-                    return Some(vite_str::format!(
-                        "✗ cache miss: content of input '{path}' changed, executing"
-                    ));
-                }
-                FingerprintMismatch::PostRunFingerprint(diff) => {
-                    use crate::session::execute::fingerprint::PostRunFingerprintMismatch;
-                    match diff {
-                        PostRunFingerprintMismatch::InputContentChanged { path } => {
-                            return Some(vite_str::format!(
-                                "✗ cache miss: content of input '{path}' changed, executing"
-                            ));
-                        }
-                    }
+                FingerprintMismatch::InputChanged { kind, path } => {
+                    let desc = format_input_change_str(*kind, path.as_str());
+                    return Some(vite_str::format!("✗ cache miss: {desc}, executing"));
                 }
             };
             Some(vite_str::format!("✗ cache miss: {reason}, executing"))
         }
         CacheStatus::Disabled(_) => Some(Str::from("⊘ cache disabled")),
     }
 }
+
+/// Format an input change as a [`Str`] for inline display.
+pub fn format_input_change_str(kind: InputChangeKind, path: &str) -> Str {
+    match kind {
+        InputChangeKind::ContentModified => vite_str::format!("'{path}' modified"),
+        InputChangeKind::Added => {
+            let (dir, filename) = split_path(path);
+            vite_str::format!("'{filename}' added in {dir}")
+        }
+        InputChangeKind::Removed => {
+            let (dir, filename) = split_path(path);
+            vite_str::format!("'{filename}' removed from {dir}")
+        }
+    }
+}

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

@@ -7,18 +7,18 @@ use std::{collections::BTreeMap, fmt::Display, fs::File, io::Write, sync::Arc, t
 use bincode::{Decode, Encode, decode_from_slice, encode_to_vec};
 // Re-export display functions for convenience
 pub use display::format_cache_status_inline;
-pub use display::{SpawnFingerprintChange, detect_spawn_fingerprint_changes, format_spawn_change};
+pub use display::{
+    SpawnFingerprintChange, detect_spawn_fingerprint_changes, format_input_change_str,
+    format_spawn_change,
+};
 use rusqlite::{Connection, OptionalExtension as _, config::DbConfig};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_task_graph::config::ResolvedInputConfig;
 use vite_task_plan::cache_metadata::{CacheMetadata, ExecutionCacheKey, SpawnFingerprint};
 
-use super::execute::{
-    fingerprint::{PostRunFingerprint, PostRunFingerprintMismatch},
-    spawn::StdOutput,
-};
+use super::execute::{fingerprint::PostRunFingerprint, spawn::StdOutput};
 
 /// Cache lookup key identifying a task's execution configuration.
 ///
@@ -83,6 +83,16 @@ pub enum CacheMiss {
     FingerprintMismatch(FingerprintMismatch),
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum InputChangeKind {
+    /// File content changed but path is the same
+    ContentModified,
+    /// New file or folder added
+    Added,
+    /// Existing file or folder removed
+    Removed,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub enum FingerprintMismatch {
     /// Found a previous cache entry key for the same task, but the spawn fingerprint differs.
@@ -95,10 +105,11 @@ pub enum FingerprintMismatch {
     },
     /// Found a previous cache entry key for the same task, but `input_config` differs.
     InputConfig,
-    /// Found the cache entry with the same spawn fingerprint, but an explicit globbed input changed
-    GlobbedInput { path: RelativePathBuf },
-    /// Found the cache entry with the same spawn fingerprint, but the post-run fingerprint mismatches
-    PostRunFingerprint(PostRunFingerprintMismatch),
+
+    InputChanged {
+        kind: InputChangeKind,
+        path: RelativePathBuf,
+    },
 }
 
 impl Display for FingerprintMismatch {
@@ -110,14 +121,22 @@ impl Display for FingerprintMismatch {
             Self::InputConfig => {
                 write!(f, "inputs configuration changed")
             }
-            Self::GlobbedInput { path } => {
-                write!(f, "content of input '{path}' changed")
+            Self::InputChanged { kind, path } => {
+                write!(f, "{}", display::format_input_change_str(*kind, path.as_str()))
             }
-            Self::PostRunFingerprint(diff) => Display::fmt(diff, f),
         }
     }
 }
 
+/// Split a relative path into `(parent_dir, filename)`.
+/// Returns `("workspace root", path)` if there is no parent directory.
+pub fn split_path(path: &str) -> (&str, &str) {
+    match path.rsplit_once('/') {
+        Some((parent, filename)) => (parent, filename),
+        None => ("workspace root", path),
+    }
+}
+
 impl ExecutionCache {
     #[tracing::instrument(level = "debug", skip_all)]
     pub fn load_from_path(path: &AbsolutePath) -> anyhow::Result<Self> {
@@ -197,11 +216,9 @@ impl ExecutionCache {
             }
 
             // Validate post-run fingerprint (inferred inputs from fspy)
-            if let Some(post_run_fingerprint_mismatch) =
-                cache_value.post_run_fingerprint.validate(workspace_root)?
-            {
+            if let Some((kind, path)) = cache_value.post_run_fingerprint.validate(workspace_root)? {
                 return Ok(Err(CacheMiss::FingerprintMismatch(
-                    FingerprintMismatch::PostRunFingerprint(post_run_fingerprint_mismatch),
+                    FingerprintMismatch::InputChanged { kind, path },
                 )));
             }
             // Associate the execution key to the cache entry key if not already,
@@ -264,22 +281,40 @@ fn detect_globbed_input_change(
     loop {
         match (s, c) {
             (None, None) => return None,
-            (Some((path, _)), None) | (None, Some((path, _))) => {
-                return Some(FingerprintMismatch::GlobbedInput { path: path.clone() });
+            (Some((sp, _)), None) => {
+                return Some(FingerprintMismatch::InputChanged {
+                    kind: InputChangeKind::Removed,
+                    path: sp.clone(),
+                });
+            }
+            (None, Some((cp, _))) => {
+                return Some(FingerprintMismatch::InputChanged {
+                    kind: InputChangeKind::Added,
+                    path: cp.clone(),
+                });
             }
             (Some((sp, sh)), Some((cp, ch))) => match sp.cmp(cp) {
                 std::cmp::Ordering::Equal => {
                     if sh != ch {
-                        return Some(FingerprintMismatch::GlobbedInput { path: sp.clone() });
+                        return Some(FingerprintMismatch::InputChanged {
+                            kind: InputChangeKind::ContentModified,
+                            path: sp.clone(),
+                        });
                     }
                     s = stored_iter.next();
                     c = current_iter.next();
                 }
                 std::cmp::Ordering::Less => {
-                    return Some(FingerprintMismatch::GlobbedInput { path: sp.clone() });
+                    return Some(FingerprintMismatch::InputChanged {
+                        kind: InputChangeKind::Removed,
+                        path: sp.clone(),
+                    });
                 }
                 std::cmp::Ordering::Greater => {
-                    return Some(FingerprintMismatch::GlobbedInput { path: cp.clone() });
+                    return Some(FingerprintMismatch::InputChanged {
+                        kind: InputChangeKind::Added,
+                        path: cp.clone(),
+                    });
                 }
             },
         }

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

@@ -17,7 +17,7 @@ use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
 
 use super::spawn::PathRead;
-use crate::collections::HashMap;
+use crate::{collections::HashMap, session::cache::InputChangeKind};
 
 /// Post-run fingerprint capturing file state after execution.
 /// Used to validate whether cached outputs are still valid.
@@ -50,22 +50,6 @@ pub enum DirEntryKind {
     Symlink,
 }
 
-/// Describes why the post-run fingerprint validation failed
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub enum PostRunFingerprintMismatch {
-    InputContentChanged { path: RelativePathBuf },
-}
-
-impl std::fmt::Display for PostRunFingerprintMismatch {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::InputContentChanged { path } => {
-                write!(f, "{path} content changed")
-            }
-        }
-    }
-}
-
 impl PostRunFingerprint {
     /// Creates a new fingerprint from path accesses after task execution.
     ///
@@ -94,12 +78,12 @@ impl PostRunFingerprint {
     }
 
     /// Validates the fingerprint against current filesystem state.
-    /// Returns `Some(mismatch)` if validation fails, `None` if valid.
+    /// Returns `Some((kind, path))` if an input changed, `None` if all valid.
     #[tracing::instrument(level = "debug", skip_all, name = "validate_post_run_fingerprint")]
     pub fn validate(
         &self,
         base_dir: &AbsolutePath,
-    ) -> anyhow::Result<Option<PostRunFingerprintMismatch>> {
+    ) -> anyhow::Result<Option<(InputChangeKind, RelativePathBuf)>> {
         let input_mismatch = self.inferred_inputs.par_iter().find_map_any(
             |(input_relative_path, path_fingerprint)| {
                 let input_full_path = Arc::<AbsolutePath>::from(base_dir.join(input_relative_path));
@@ -113,16 +97,74 @@ impl PostRunFingerprint {
                 if path_fingerprint == &current_path_fingerprint {
                     None
                 } else {
-                    Some(Ok(PostRunFingerprintMismatch::InputContentChanged {
-                        path: input_relative_path.clone(),
-                    }))
+                    let (kind, entry_name) =
+                        determine_change_kind(path_fingerprint, &current_path_fingerprint);
+                    let path = if let Some(name) = entry_name {
+                        // For folder changes, build `dir/entry` path
+                        let entry = match RelativePathBuf::new(name.as_str()) {
+                            Ok(p) => p,
+                            Err(e) => return Some(Err(e.into())),
+                        };
+                        input_relative_path.as_relative_path().join(entry)
+                    } else {
+                        input_relative_path.clone()
+                    };
+                    Some(Ok((kind, path)))
                 }
             },
         );
         input_mismatch.transpose()
     }
 }
 
+/// Determine the kind of change between two differing path fingerprints.
+/// Caller guarantees `stored != current`.
+///
+/// Returns `(kind, entry_name)` where `entry_name` is `Some` for folder changes
+/// when a specific added/removed entry can be identified.
+fn determine_change_kind<'a>(
+    stored: &'a PathFingerprint,
+    current: &'a PathFingerprint,
+) -> (InputChangeKind, Option<&'a Str>) {
+    match (stored, current) {
+        (PathFingerprint::NotFound, _) => (InputChangeKind::Added, None),
+        (_, PathFingerprint::NotFound) => (InputChangeKind::Removed, None),
+        (PathFingerprint::FileContentHash(_), PathFingerprint::FileContentHash(_)) => {
+            (InputChangeKind::ContentModified, None)
+        }
+        (PathFingerprint::Folder(old), PathFingerprint::Folder(new)) => {
+            determine_folder_change_kind(old.as_ref(), new.as_ref())
+        }
+        // Type changed (file ↔ folder)
+        _ => (InputChangeKind::Added, None),
+    }
+}
+
+/// Determine whether a folder change is an addition or removal by comparing entries.
+/// Returns the specific entry name that was added or removed, if identifiable.
+fn determine_folder_change_kind<'a>(
+    old: Option<&'a HashMap<Str, DirEntryKind>>,
+    new: Option<&'a HashMap<Str, DirEntryKind>>,
+) -> (InputChangeKind, Option<&'a Str>) {
+    match (old, new) {
+        (Some(old_entries), Some(new_entries)) => {
+            for key in old_entries.keys() {
+                if !new_entries.contains_key(key) {
+                    return (InputChangeKind::Removed, Some(key));
+                }
+            }
+            for key in new_entries.keys() {
+                if !old_entries.contains_key(key) {
+                    return (InputChangeKind::Added, Some(key));
+                }
+            }
+            // Same keys but different entry kinds — default to Added
+            (InputChangeKind::Added, None)
+        }
+        _ => (InputChangeKind::Added, None),
+    }
+}
+
 /// Hash file content using `xxHash3_64`
 fn hash_content(mut stream: impl Read) -> io::Result<u64> {
     let mut hasher = twox_hash::XxHash3_64::default();

crates/vite_task/src/session/reporter/summary.rs

@@ -17,8 +17,8 @@ use vite_str::Str;
 use super::{CACHE_MISS_STYLE, COMMAND_STYLE, ColorizeExt};
 use crate::session::{
     cache::{
-        CacheMiss, FingerprintMismatch, SpawnFingerprintChange, detect_spawn_fingerprint_changes,
-        format_spawn_change,
+        CacheMiss, FingerprintMismatch, InputChangeKind, SpawnFingerprintChange,
+        detect_spawn_fingerprint_changes, format_input_change_str, format_spawn_change,
     },
     event::{CacheDisabledReason, CacheErrorKind, CacheStatus, ExecutionError},
 };
@@ -114,8 +114,8 @@ pub enum SavedCacheMissReason {
     SpawnFingerprintChanged(Vec<SpawnFingerprintChange>),
     /// Task configuration changed (`input_config` or `glob_base`).
     ConfigChanged,
-    /// Content of an input file changed.
-    InputContentChanged { path: Str },
+    /// An input file or folder changed.
+    InputChanged { kind: InputChangeKind, path: Str },
 }
 
 /// An execution error, serializable for persistence.
@@ -241,16 +241,8 @@ impl SavedCacheMissReason {
                     Self::SpawnFingerprintChanged(detect_spawn_fingerprint_changes(old, new))
                 }
                 FingerprintMismatch::InputConfig => Self::ConfigChanged,
-                FingerprintMismatch::GlobbedInput { path } => {
-                    Self::InputContentChanged { path: Str::from(path.as_str()) }
-                }
-                FingerprintMismatch::PostRunFingerprint(diff) => {
-                    use crate::session::execute::fingerprint::PostRunFingerprintMismatch;
-                    match diff {
-                        PostRunFingerprintMismatch::InputContentChanged { path } => {
-                            Self::InputContentChanged { path: Str::from(path.as_str()) }
-                        }
-                    }
+                FingerprintMismatch::InputChanged { kind, path } => {
+                    Self::InputChanged { kind: *kind, path: Str::from(path.as_str()) }
                 }
             },
         }
@@ -434,8 +426,9 @@ impl TaskResult {
                     SavedCacheMissReason::ConfigChanged => {
                         Str::from("→ Cache miss: inputs configuration changed")
                     }
-                    SavedCacheMissReason::InputContentChanged { path } => {
-                        vite_str::format!("→ Cache miss: content of input '{path}' changed")
+                    SavedCacheMissReason::InputChanged { kind, path } => {
+                        let desc = format_input_change_str(*kind, path.as_str());
+                        vite_str::format!("→ Cache miss: {desc}")
                     }
                 },
             },

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-different-cwd/snapshots/builtin different cwd.snap

@@ -46,7 +46,7 @@ Finished in <duration> on 2 files with 90 rules using <n> threads.
 > echo 'console.log(1);' > folder2/a.js # modify folder2
 
 > cd folder1 && vp run lint # cache hit
-$ vp lint ✗ cache miss: content of input 'folder2/a.js' changed, executing
+$ vp lint ✗ cache miss: 'folder2/a.js' modified, executing
 
   ! eslint-plugin-unicorn(no-empty-file): Empty files are not allowed.
    ,-[folder1/a.js:1:1]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/cache-miss-reasons/extra.txt

@@ -0,0 +1 @@
+extra content