feat: show "not cached" message when task modifies its input

Surface the read-write overlap detection in both compact and full
summaries so users understand why their task wasn't cached.

Compact: "app#build not cached because it modified its input."
Full:    "→ Not cached: read and wrote 'src/data.txt'"

Thread CacheUpdateStatus through the reporter so InputModified
(with the overlapping path) reaches SpawnOutcome::Success and
the summary rendering.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: branchseer

crates/vite_task/src/session/event.rs

@@ -1,5 +1,7 @@
 use std::{process::ExitStatus, time::Duration};
 
+use vite_path::RelativePathBuf;
+
 use super::cache::CacheMiss;
 
 /// The cache operation that failed.
@@ -59,7 +61,10 @@ pub enum CacheNotUpdatedReason {
     NonZeroExitStatus,
     /// Task modified files it read during execution (read-write overlap detected by fspy).
     /// Caching such tasks is unsound because the prerun input hashes become stale.
-    InputModified,
+    InputModified {
+        /// First path that was both read and written during execution.
+        path: RelativePathBuf,
+    },
 }
 
 #[derive(Debug)]
@@ -69,13 +74,7 @@ pub enum CacheUpdateStatus {
     /// Cache was not updated (with reason).
     /// The reason is part of the `LeafExecutionReporter` trait contract — reporters
     /// can use it for detailed logging, even if current implementations don't.
-    NotUpdated(
-        #[expect(
-            dead_code,
-            reason = "part of LeafExecutionReporter trait contract; reporters may use for detailed logging"
-        )]
-        CacheNotUpdatedReason,
-    ),
+    NotUpdated(CacheNotUpdatedReason),
 }
 
 #[derive(Debug)]

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

@@ -403,11 +403,16 @@ pub async fn execute_spawn(
             // A task that writes to a glob-matched file without reading it causes
             // perpetual cache misses (glob detects the hash change) but not a
             // correctness bug, so we don't handle that case here.
-            if path_accesses
+            if let Some(path) = path_accesses
                 .as_ref()
-                .is_some_and(|pa| pa.path_reads.keys().any(|p| pa.path_writes.contains(p)))
+                .and_then(|pa| pa.path_reads.keys().find(|p| pa.path_writes.contains(*p)))
             {
-                (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::InputModified), None)
+                (
+                    CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::InputModified {
+                        path: path.clone(),
+                    }),
+                    None,
+                )
             } else {
                 // path_reads is empty when inference is disabled (path_accesses is None)
                 let empty_path_reads = HashMap::default();

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

@@ -251,7 +251,7 @@ impl LeafExecutionReporter for LabeledLeafReporter {
     async fn finish(
         self: Box<Self>,
         status: Option<StdExitStatus>,
-        _cache_update_status: CacheUpdateStatus,
+        cache_update_status: CacheUpdateStatus,
         error: Option<ExecutionError>,
     ) {
         // Convert error before consuming it (need the original for display formatting).
@@ -276,7 +276,12 @@ impl LeafExecutionReporter for LabeledLeafReporter {
                 task_name: display.task_display.task_name.clone(),
                 command: display.command.clone(),
                 cwd: cwd_relative,
-                result: TaskResult::from_execution(&cache_status, status, saved_error.as_ref()),
+                result: TaskResult::from_execution(
+                    &cache_status,
+                    status,
+                    saved_error.as_ref(),
+                    &cache_update_status,
+                ),
             };
 
             shared.borrow_mut().tasks.push(task_summary);

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

@@ -20,7 +20,10 @@ use crate::session::{
         CacheMiss, FingerprintMismatch, InputChangeKind, SpawnFingerprintChange,
         detect_spawn_fingerprint_changes, format_input_change_str, format_spawn_change,
     },
-    event::{CacheDisabledReason, CacheErrorKind, CacheStatus, ExecutionError},
+    event::{
+        CacheDisabledReason, CacheErrorKind, CacheNotUpdatedReason, CacheStatus, CacheUpdateStatus,
+        ExecutionError,
+    },
 };
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -94,7 +97,12 @@ pub enum SpawnOutcome {
     /// Process exited successfully (exit code 0).
     /// May have a post-execution infrastructure error (cache update or fingerprint failed).
     /// These only run after exit 0, so this field only exists on the success path.
-    Success { infra_error: Option<SavedExecutionError> },
+    Success {
+        infra_error: Option<SavedExecutionError>,
+        /// First path that was both read and written, causing cache to be skipped.
+        /// Only set when fspy detected a read-write overlap.
+        input_modified_path: Option<Str>,
+    },
 
     /// Process exited with non-zero status.
     /// [`NonZeroI32`] enforces that exit code 0 is unrepresentable here.
@@ -147,6 +155,8 @@ struct SummaryStats {
     cache_disabled: usize,
     failed: usize,
     total_saved: Duration,
+    /// Display names of tasks that were not cached due to read-write overlap.
+    input_modified_task_names: Vec<Str>,
 }
 
 impl SummaryStats {
@@ -158,6 +168,7 @@ impl SummaryStats {
             cache_disabled: 0,
             failed: 0,
             total_saved: Duration::ZERO,
+            input_modified_task_names: Vec::new(),
         };
 
         for task in tasks {
@@ -175,10 +186,13 @@ impl SummaryStats {
                         SpawnedCacheStatus::Disabled => stats.cache_disabled += 1,
                     }
                     match outcome {
-                        SpawnOutcome::Success { infra_error: Some(_) }
+                        SpawnOutcome::Success { infra_error: Some(_), .. }
                         | SpawnOutcome::Failed { .. }
                         | SpawnOutcome::SpawnError(_) => stats.failed += 1,
-                        SpawnOutcome::Success { infra_error: None } => {}
+                        SpawnOutcome::Success { input_modified_path: Some(_), .. } => {
+                            stats.input_modified_task_names.push(task.format_task_display());
+                        }
+                        SpawnOutcome::Success { .. } => {}
                     }
                 }
             }
@@ -255,25 +269,42 @@ impl TaskResult {
     /// `cache_status`: the cache status determined at `start()` time.
     /// `exit_status`: the process exit status, or `None` for cache hit / in-process.
     /// `saved_error`: an optional pre-converted execution error.
+    /// `cache_update_status`: the post-execution cache update result.
     pub fn from_execution(
         cache_status: &CacheStatus,
         exit_status: Option<std::process::ExitStatus>,
         saved_error: Option<&SavedExecutionError>,
+        cache_update_status: &CacheUpdateStatus,
     ) -> Self {
+        let input_modified_path = match cache_update_status {
+            CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::InputModified { path }) => {
+                Some(Str::from(path.as_str()))
+            }
+            _ => None,
+        };
+
         match cache_status {
             CacheStatus::Hit { replayed_duration } => {
                 Self::CacheHit { saved_duration_ms: duration_to_ms(*replayed_duration) }
             }
             CacheStatus::Disabled(CacheDisabledReason::InProcessExecution) => Self::InProcess,
             CacheStatus::Disabled(CacheDisabledReason::NoCacheMetadata) => Self::Spawned {
                 cache_status: SpawnedCacheStatus::Disabled,
-                outcome: spawn_outcome_from_execution(exit_status, saved_error),
+                outcome: spawn_outcome_from_execution(
+                    exit_status,
+                    saved_error,
+                    input_modified_path,
+                ),
             },
             CacheStatus::Miss(cache_miss) => Self::Spawned {
                 cache_status: SpawnedCacheStatus::Miss(SavedCacheMissReason::from_cache_miss(
                     cache_miss,
                 )),
-                outcome: spawn_outcome_from_execution(exit_status, saved_error),
+                outcome: spawn_outcome_from_execution(
+                    exit_status,
+                    saved_error,
+                    input_modified_path,
+                ),
             },
         }
     }
@@ -283,13 +314,14 @@ impl TaskResult {
 fn spawn_outcome_from_execution(
     exit_status: Option<std::process::ExitStatus>,
     saved_error: Option<&SavedExecutionError>,
+    input_modified_path: Option<Str>,
 ) -> SpawnOutcome {
     match (exit_status, saved_error) {
         // Spawn error — process never ran
         (None, Some(err)) => SpawnOutcome::SpawnError(err.clone()),
         // Process exited successfully, possible infra error
         (Some(status), _) if status.success() => {
-            SpawnOutcome::Success { infra_error: saved_error.cloned() }
+            SpawnOutcome::Success { infra_error: saved_error.cloned(), input_modified_path }
         }
         // Process exited with non-zero code
         (Some(status), _) => {
@@ -304,7 +336,7 @@ fn spawn_outcome_from_execution(
         // No exit status, no error — this is the cache hit / in-process path,
         // handled by TaskResult::CacheHit / InProcess before reaching here.
         // If we somehow get here, treat as success.
-        (None, None) => SpawnOutcome::Success { infra_error: None },
+        (None, None) => SpawnOutcome::Success { infra_error: None, input_modified_path: None },
     }
 }
 
@@ -415,6 +447,15 @@ impl TaskResult {
     /// - "→ Cache miss: no previous cache entry found"
     /// - "→ Cache disabled in task configuration"
     fn format_cache_detail(&self) -> Str {
+        // Check for input modification first — it overrides the cache miss reason
+        if let Self::Spawned {
+            outcome: SpawnOutcome::Success { input_modified_path: Some(path), .. },
+            ..
+        } = self
+        {
+            return vite_str::format!("→ Not cached: read and wrote '{path}'");
+        }
+
         match self {
             Self::CacheHit { saved_duration_ms } => {
                 let d = Duration::from_millis(*saved_duration_ms);
@@ -467,7 +508,7 @@ impl TaskResult {
         match self {
             Self::CacheHit { .. } | Self::InProcess => None,
             Self::Spawned { outcome, .. } => match outcome {
-                SpawnOutcome::Success { infra_error } => infra_error.as_ref(),
+                SpawnOutcome::Success { infra_error, .. } => infra_error.as_ref(),
                 SpawnOutcome::Failed { .. } => None,
                 SpawnOutcome::SpawnError(err) => Some(err),
             },
@@ -671,8 +712,8 @@ pub fn format_compact_summary(summary: &LastRunSummary, program_name: &str) -> V
 
     let is_single_task = summary.tasks.len() == 1;
 
-    // Single task + not cache hit → no summary
-    if is_single_task && stats.cache_hits == 0 {
+    // Single task + not cache hit + no input modification → no summary
+    if is_single_task && stats.cache_hits == 0 && stats.input_modified_task_names.is_empty() {
         return Vec::new();
     }
 
@@ -682,16 +723,18 @@ pub fn format_compact_summary(summary: &LastRunSummary, program_name: &str) -> V
     let _ = writeln!(buf, "{}", "---".style(Style::new().bright_black()));
 
     let run_label = vite_str::format!("{program_name} run:");
-    if is_single_task {
-        // Single task cache hit
+    let mut show_last_details_hint = true;
+    if is_single_task && stats.cache_hits > 0 {
+        // Single task cache hit — no need for --last-details hint
         let formatted_total_saved = format_summary_duration(stats.total_saved);
-        let _ = writeln!(
+        let _ = write!(
             buf,
             "{} cache hit, {} saved.",
             run_label.as_str().style(Style::new().blue().bold()),
             formatted_total_saved.style(Style::new().green().bold()),
         );
-    } else {
+        show_last_details_hint = false;
+    } else if !is_single_task {
         // Multi-task
         let total = stats.total;
         let hits = stats.cache_hits;
@@ -727,12 +770,42 @@ pub fn format_compact_summary(summary: &LastRunSummary, program_name: &str) -> V
             let _ = write!(buf, ", {} failed", n.style(Style::new().red()));
         }
 
+        let _ = write!(buf, ".");
+    } else {
+        // Single task, no cache hit — only shown when input_modified is non-empty
+        let _ = write!(buf, "{}", run_label.as_str().style(Style::new().blue().bold()));
+    }
+
+    // Inline input-modified notice before the --last-details hint
+    if !stats.input_modified_task_names.is_empty() {
+        format_input_modified_notice(&mut buf, &stats.input_modified_task_names);
+    }
+
+    if show_last_details_hint {
         let last_details_cmd = vite_str::format!("`{program_name} run --last-details`");
-        let _ = write!(buf, ". {}", "(Run ".style(Style::new().bright_black()));
+        let _ = write!(buf, " {}", "(Run ".style(Style::new().bright_black()));
         let _ = write!(buf, "{}", last_details_cmd.as_str().style(COMMAND_STYLE));
         let _ = write!(buf, "{}", " for full details)".style(Style::new().bright_black()));
-        let _ = writeln!(buf);
     }
+    let _ = writeln!(buf);
 
     buf
 }
+
+/// Write the "not cached because it modified its input" notice inline.
+fn format_input_modified_notice(buf: &mut Vec<u8>, task_names: &[Str]) {
+    let _ = write!(buf, " ");
+
+    let first = &task_names[0];
+    let _ = write!(buf, "{}", first.as_str().style(Style::new().bold()));
+    let remaining = task_names.len() - 1;
+    if remaining > 0 {
+        let _ = write!(buf, " (and {remaining} more)");
+    }
+
+    if task_names.len() == 1 {
+        let _ = write!(buf, " not cached because it modified its input.");
+    } else {
+        let _ = write!(buf, " not cached because they modified their inputs.");
+    }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/packages/normal-pkg/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@test/normal-pkg",
+  "scripts": {
+    "task": "print hello"
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/packages/rw-pkg/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@test/rw-pkg",
+  "scripts": {
+    "task": "replace-file-content src/data.txt original modified"
+  },
+  "dependencies": {
+    "@test/normal-pkg": "workspace:*"
+  }
+}

…input-read-write-not-cached/src/data.txt …-not-cached/packages/rw-pkg/src/data.txtcrates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/src/data.txt renamed to crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/packages/rw-pkg/src/data.txt crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/src/data.txt renamed to crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/packages/rw-pkg/src/data.txt

@@ -0,0 +1,2 @@
+packages:
+  - packages/*

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/pnpm-workspace.yaml

@@ -1,12 +1,19 @@
-# Test that tasks modifying their own inputs (read-write overlap) are not cached.
+# Tests that tasks modifying their own inputs (read-write overlap) are not cached.
 # replace-file-content reads then writes the same file — fspy detects both.
-# Without this behavior, the second run would be a cache hit.
 
+# Single rw-task: compact summary shows "not cached because it modified its input"
 [[e2e]]
-name = "read-write task is not cached"
-steps = [
-  # First run - executes, but cache NOT stored (read-write overlap detected)
-  "vt run rw-task",
-  # Second run - still miss (no cache was stored on first run)
-  "vt run rw-task",
-]
+name = "single read-write task shows not cached message"
+cwd = "packages/rw-pkg"
+steps = ["vt run task", "vt run task"]
+
+# Multi-task (recursive): compact summary shows stats + InputModified notice
+[[e2e]]
+name = "multi task with read-write shows not cached in summary"
+steps = ["vt run -r task", "vt run -r task"]
+
+# Verbose: full summary shows the overlapping path
+[[e2e]]
+name = "verbose read-write task shows path in full summary"
+cwd = "packages/rw-pkg"
+steps = ["vt run -v task"]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input-read-write-not-cached/snapshots.toml

@@ -0,0 +1,20 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+---
+> vt run -r task
+~/packages/normal-pkg$ print hello
+hello
+
+~/packages/rw-pkg$ replace-file-content src/data.txt original modified
+
+---
+vt run: 0/2 cache hit (0%). @test/rw-pkg#task not cached because it modified its input. (Run `vt run --last-details` for full details)
+> vt run -r task
+~/packages/normal-pkg$ print hello ✓ cache hit, replaying
+hello
+
+~/packages/rw-pkg$ replace-file-content src/data.txt original modified
+
+---
+vt run: 1/2 cache hit (50%), <duration> saved. @test/rw-pkg#task not cached because it modified its input. (Run `vt run --last-details` for full details)