feat: replace verbose execution summary with compact one-liners

Add --details flag for full summary and --last-details to view saved
summary from last run. Normal runs now show a compact one-liner instead
of the full summary table:

- Single task + no cache hit: no summary
- Single task + cache hit: '[vp run] cache hit, {duration} saved.'
- Multi-task: '[vp run] {hits}/{total} cache hit ({rate}%)'

Summary data is persisted as structured JSON (last-summary.json) in the
cache directory using atomic writes. Both live and --last-details
rendering share the same code path through LastRunSummary.

The TaskResult enum encodes cache status and execution outcome together,
making invalid states unrepresentable (e.g. CacheHit+exit_code,
InProcess+error).

Also fixes a pre-existing flaky test in e2e-lint-cache where oxlint
scanned node_modules, causing fspy to fingerprint the cache directory.

Author: branchseer

crates/vite_task/src/cli/mod.rs

@@ -17,6 +17,7 @@ pub enum CacheSubcommand {
 /// Extracted as a separate struct so they can be cheaply `Copy`-ed
 /// before `RunCommand` is consumed.
 #[derive(Debug, Clone, Copy, clap::Args)]
+#[expect(clippy::struct_excessive_bools, reason = "CLI flags are naturally boolean")]
 pub struct RunFlags {
     /// Run tasks found in all packages in the workspace, in topological order based on package dependencies.
     #[clap(default_value = "false", short, long)]
@@ -29,6 +30,10 @@ pub struct RunFlags {
     /// Do not run dependencies specified in `dependsOn` fields.
     #[clap(default_value = "false", long)]
     pub ignore_depends_on: bool,
+
+    /// Show full detailed summary after execution.
+    #[clap(default_value = "false", long)]
+    pub details: bool,
 }
 
 /// Arguments for the `run` subcommand.
@@ -43,6 +48,10 @@ pub struct RunCommand {
     /// Additional arguments to pass to the tasks
     #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
     pub additional_args: Vec<Str>,
+
+    /// Display the detailed summary of the last run.
+    #[clap(long, exclusive = true)]
+    pub last_details: bool,
 }
 
 /// vite task CLI subcommands
@@ -82,8 +91,9 @@ impl RunCommand {
     ) -> Result<QueryPlanRequest, CLITaskQueryError> {
         let Self {
             task_specifier,
-            flags: RunFlags { recursive, transitive, ignore_depends_on },
+            flags: RunFlags { recursive, transitive, ignore_depends_on, .. },
             additional_args,
+            ..
         } = self;
 
         let task_specifier = task_specifier.ok_or(CLITaskQueryError::MissingTaskSpecifier)?;

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

@@ -4,14 +4,18 @@
 //! Coloring is handled by the reporter to respect `NO_COLOR` environment variable.
 
 use rustc_hash::FxHashSet;
+use serde::{Deserialize, Serialize};
 use vite_str::Str;
 use vite_task_plan::cache_metadata::SpawnFingerprint;
 
 use super::{CacheMiss, FingerprintMismatch};
 use crate::session::event::{CacheDisabledReason, CacheStatus};
 
-/// Describes a single atomic change between two spawn fingerprints
-enum SpawnFingerprintChange {
+/// Describes a single atomic change between two spawn fingerprints.
+///
+/// Used both for live cache status display and for persisted summary data.
+#[derive(Serialize, Deserialize)]
+pub enum SpawnFingerprintChange {
     // Environment variable changes
     /// Environment variable added
     EnvAdded { key: Str, value: Str },
@@ -43,8 +47,40 @@ enum SpawnFingerprintChange {
     FingerprintIgnoreRemoved { pattern: Str },
 }
 
-/// Compare two spawn fingerprints and return all changes
-fn detect_spawn_fingerprint_changes(
+/// Format a single spawn fingerprint change as human-readable text.
+///
+/// Used by both the live cache status display and the persisted summary rendering.
+pub fn format_spawn_change(change: &SpawnFingerprintChange) -> Str {
+    match change {
+        SpawnFingerprintChange::EnvAdded { key, value } => {
+            vite_str::format!("env {key}={value} added")
+        }
+        SpawnFingerprintChange::EnvRemoved { key, value } => {
+            vite_str::format!("env {key}={value} removed")
+        }
+        SpawnFingerprintChange::EnvValueChanged { key, old_value, new_value } => {
+            vite_str::format!("env {key} value changed from '{old_value}' to '{new_value}'")
+        }
+        SpawnFingerprintChange::PassThroughEnvAdded { name } => {
+            vite_str::format!("pass-through env '{name}' added")
+        }
+        SpawnFingerprintChange::PassThroughEnvRemoved { name } => {
+            vite_str::format!("pass-through env '{name}' removed")
+        }
+        SpawnFingerprintChange::ProgramChanged => Str::from("program changed"),
+        SpawnFingerprintChange::ArgsChanged => Str::from("args changed"),
+        SpawnFingerprintChange::CwdChanged => Str::from("working directory changed"),
+        SpawnFingerprintChange::FingerprintIgnoreAdded { pattern } => {
+            vite_str::format!("fingerprint ignore '{pattern}' added")
+        }
+        SpawnFingerprintChange::FingerprintIgnoreRemoved { pattern } => {
+            vite_str::format!("fingerprint ignore '{pattern}' removed")
+        }
+    }
+}
+
+/// Compare two spawn fingerprints and return all changes.
+pub fn detect_spawn_fingerprint_changes(
     old: &SpawnFingerprint,
     new: &SpawnFingerprint,
 ) -> Vec<SpawnFingerprintChange> {
@@ -190,95 +226,3 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
         }
     }
 }
-
-/// Format cache status for summary display (post-execution).
-///
-/// Returns a formatted string showing detailed cache information.
-/// - Cache Hit: Shows saved time
-/// - Cache Miss (NotFound): Indicates first-time execution
-/// - Cache Miss (with mismatch): Shows specific reason with details
-/// - Cache Disabled: Shows user-friendly reason message
-///
-/// Note: Returns plain text without styling. The reporter applies colors.
-pub fn format_cache_status_summary(cache_status: &CacheStatus) -> Str {
-    match cache_status {
-        CacheStatus::Hit { replayed_duration } => {
-            // Show saved time for cache hits
-            vite_str::format!("→ Cache hit - output replayed - {replayed_duration:.2?} saved")
-        }
-        CacheStatus::Miss(CacheMiss::NotFound) => {
-            // First time running this task - no previous cache entry
-            Str::from("→ Cache miss: no previous cache entry found")
-        }
-        CacheStatus::Miss(CacheMiss::FingerprintMismatch(mismatch)) => {
-            // Show specific reason why cache was invalidated
-            match mismatch {
-                FingerprintMismatch::SpawnFingerprintMismatch { old, new } => {
-                    let changes = detect_spawn_fingerprint_changes(old, new);
-                    let formatted: Vec<Str> = changes
-                        .iter()
-                        .map(|c| match c {
-                            SpawnFingerprintChange::EnvAdded { key, value } => {
-                                vite_str::format!("env {key}={value} added")
-                            }
-                            SpawnFingerprintChange::EnvRemoved { key, value } => {
-                                vite_str::format!("env {key}={value} removed")
-                            }
-                            SpawnFingerprintChange::EnvValueChanged {
-                                key,
-                                old_value,
-                                new_value,
-                            } => {
-                                vite_str::format!(
-                                    "env {key} value changed from '{old_value}' to '{new_value}'"
-                                )
-                            }
-                            SpawnFingerprintChange::PassThroughEnvAdded { name } => {
-                                vite_str::format!("pass-through env '{name}' added")
-                            }
-                            SpawnFingerprintChange::PassThroughEnvRemoved { name } => {
-                                vite_str::format!("pass-through env '{name}' removed")
-                            }
-                            SpawnFingerprintChange::ProgramChanged => Str::from("program changed"),
-                            SpawnFingerprintChange::ArgsChanged => Str::from("args changed"),
-                            SpawnFingerprintChange::CwdChanged => {
-                                Str::from("working directory changed")
-                            }
-                            SpawnFingerprintChange::FingerprintIgnoreAdded { pattern } => {
-                                vite_str::format!("fingerprint ignore '{pattern}' added")
-                            }
-                            SpawnFingerprintChange::FingerprintIgnoreRemoved { pattern } => {
-                                vite_str::format!("fingerprint ignore '{pattern}' removed")
-                            }
-                        })
-                        .collect();
-
-                    if formatted.is_empty() {
-                        Str::from("→ Cache miss: configuration changed")
-                    } else {
-                        let joined =
-                            formatted.iter().map(Str::as_str).collect::<Vec<_>>().join("; ");
-                        vite_str::format!("→ Cache miss: {joined}")
-                    }
-                }
-                FingerprintMismatch::PostRunFingerprintMismatch(diff) => {
-                    // Post-run mismatch has specific path information
-                    use crate::session::execute::fingerprint::PostRunFingerprintMismatch;
-                    match diff {
-                        PostRunFingerprintMismatch::InputContentChanged { path } => {
-                            vite_str::format!("→ Cache miss: content of input '{path}' changed")
-                        }
-                    }
-                }
-            }
-        }
-        CacheStatus::Disabled(reason) => {
-            // Display user-friendly message for each disabled reason
-            let message = match reason {
-                CacheDisabledReason::InProcessExecution => "Cache disabled for built-in command",
-                CacheDisabledReason::NoCacheMetadata => "Cache disabled in task configuration",
-            };
-            vite_str::format!("→ {message}")
-        }
-    }
-}

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

@@ -6,7 +6,8 @@ use std::{fmt::Display, fs::File, io::Write, sync::Arc, time::Duration};
 
 use bincode::{Decode, Encode, decode_from_slice, encode_to_vec};
 // Re-export display functions for convenience
-pub use display::{format_cache_status_inline, format_cache_status_summary};
+pub use display::format_cache_status_inline;
+pub use display::{SpawnFingerprintChange, detect_spawn_fingerprint_changes, format_spawn_change};
 use rusqlite::{Connection, OptionalExtension as _, config::DbConfig};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;

crates/vite_task/src/session/mod.rs

@@ -10,7 +10,10 @@ use cache::ExecutionCache;
 pub use cache::{CacheMiss, FingerprintMismatch};
 use once_cell::sync::OnceCell;
 pub use reporter::ExitStatus;
-use reporter::LabeledReporterBuilder;
+use reporter::{
+    LabeledReporterBuilder,
+    summary::{LastRunSummary, ReadSummaryError, format_full_summary},
+};
 use rustc_hash::FxHashMap;
 use vite_path::{AbsolutePath, AbsolutePathBuf};
 use vite_select::SelectItem;
@@ -225,12 +228,18 @@ impl<'a> Session<'a> {
         match command {
             Command::Cache { ref subcmd } => self.handle_cache_command(subcmd),
             Command::Run(run_command) => {
+                // --last-details: display saved summary and exit (exclusive flag)
+                if run_command.last_details {
+                    return self.show_last_run_details();
+                }
+
                 let cwd = Arc::clone(&self.cwd);
                 let is_interactive =
                     std::io::stdin().is_terminal() && std::io::stdout().is_terminal();
 
                 // Save task name and flags before consuming run_command
                 let task_name = run_command.task_specifier.as_ref().map(|s| s.task_name.clone());
+                let show_details = run_command.flags.details;
                 let flags = run_command.flags;
                 let additional_args = run_command.additional_args.clone();
 
@@ -249,6 +258,8 @@ impl<'a> Session<'a> {
                         let builder = LabeledReporterBuilder::new(
                             self.workspace_path(),
                             Box::new(tokio::io::stdout()),
+                            show_details,
+                            Some(self.summary_file_path()),
                         );
                         Ok(self
                             .execute_graph(graph, Box::new(builder))
@@ -389,13 +400,22 @@ impl<'a> Session<'a> {
         // Interactive: run the selected task
         let selected_label = &select_items[selected_index].label;
         let task_specifier = TaskSpecifier::parse_raw(selected_label);
-        let run_command =
-            RunCommand { task_specifier: Some(task_specifier), flags, additional_args };
+        let show_details = flags.details;
+        let run_command = RunCommand {
+            task_specifier: Some(task_specifier),
+            flags,
+            additional_args,
+            last_details: false,
+        };
 
         let cwd = Arc::clone(&self.cwd);
         let graph = self.plan_from_cli_run(cwd, run_command).await?;
-        let builder =
-            LabeledReporterBuilder::new(self.workspace_path(), Box::new(tokio::io::stdout()));
+        let builder = LabeledReporterBuilder::new(
+            self.workspace_path(),
+            Box::new(tokio::io::stdout()),
+            show_details,
+            Some(self.summary_file_path()),
+        );
         Ok(self.execute_graph(graph, Box::new(builder)).await.err().unwrap_or(ExitStatus::SUCCESS))
     }
 
@@ -414,6 +434,44 @@ impl<'a> Session<'a> {
         Arc::clone(&self.workspace_path)
     }
 
+    /// Path to the `last-summary.json` file inside the cache directory.
+    fn summary_file_path(&self) -> AbsolutePathBuf {
+        self.cache_path.join("last-summary.json")
+    }
+
+    /// Display the saved summary from the last run (`--last-details`).
+    #[expect(
+        clippy::print_stderr,
+        reason = "--last-details error messages are user-facing diagnostics, not debug output"
+    )]
+    fn show_last_run_details(&self) -> anyhow::Result<ExitStatus> {
+        let path = self.summary_file_path();
+        match LastRunSummary::read_from_path(&path) {
+            Ok(Some(summary)) => {
+                let buf = format_full_summary(&summary);
+                {
+                    use std::io::Write;
+                    let mut stdout = std::io::stdout().lock();
+                    let _ = stdout.write_all(&buf);
+                    let _ = stdout.flush();
+                }
+                Ok(ExitStatus(summary.exit_code))
+            }
+            Ok(None) => {
+                eprintln!("No previous run summary found. Run a task first to generate a summary.");
+                Ok(ExitStatus::FAILURE)
+            }
+            Err(ReadSummaryError::IncompatibleVersion) => {
+                eprintln!(
+                    "Summary data was saved by a different version of vite-task and cannot be read. \
+                     Run a task to generate a new summary."
+                );
+                Ok(ExitStatus::FAILURE)
+            }
+            Err(ReadSummaryError::Io(err)) => Err(err.into()),
+        }
+    }
+
     pub const fn task_graph(&self) -> Option<&TaskGraph> {
         match &self.lazy_task_graph {
             LazyTaskGraph::Initialized(graph) => Some(graph.task_graph()),