feat: improve task runner summary with compact one-liners (#171)

## Summary

Replace the verbose full execution summary with compact one-liners for
normal runs, with `--verbose` flag for full summary and `--last-details`
to view the last run's saved summary from a JSON file.

### Behavior

| Command | Behavior |
|---|---|
| `vp run task` | Run task, **compact** summary |
| `vp run -v task` | Run task, **full** summary |
| `vp run --last-details` | Read saved JSON, display full summary |

### Compact summary rules

- Single task + not cache hit → no summary at all
- Single task + cache hit → `[vp run] cache hit, {duration} saved.`
- Multi-task → `[vp run] {hits}/{total} cache hit ({rate}%), {duration}
saved. (Run 'vp run --verbose' for full details)`

### Key design decisions

- **Structured data, not formatted strings**: all display formatting
happens at render time from `LastRunSummary`
- **Enums for invalid states**: `--last-details` is exclusive at the
type level via `Command::RunLastDetails` variant
- **Single rendering path**: always generate `LastRunSummary`, then
render compact or full from it
- **Atomic writes**: `last-summary.json` written to `.tmp` then
`fs::rename`
- **Write callback**: reporter decoupled from file paths via `Box<dyn
FnOnce(&LastRunSummary)>`
- **Direct TaskSummary construction**: leaf reporter builds
`TaskSummary` in `finish()` instead of collecting intermediate
`ExecutionInfo`

### Snapshot proof

Includes a commit adding `--verbose` to all e2e tests followed by its
revert, proving the full summary output is correct and unchanged. The
e2e tests exercise the compact summary path by default.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

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,23 +30,43 @@ 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", short = 'v', long)]
+    pub verbose: bool,
 }
 
-/// Arguments for the `run` subcommand.
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Public CLI types (clap-parsed)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/// Arguments for the `run` subcommand as parsed by clap.
+///
+/// Contains the `--last-details` flag which is resolved into a separate
+/// `ResolvedCommand::RunLastDetails` variant internally.
 #[derive(Debug, clap::Args)]
 pub struct RunCommand {
     /// `packageName#taskName` or `taskName`. If omitted, lists all available tasks.
-    pub task_specifier: Option<TaskSpecifier>,
+    pub(crate) task_specifier: Option<TaskSpecifier>,
 
     #[clap(flatten)]
-    pub flags: RunFlags,
+    pub(crate) flags: RunFlags,
 
     /// Additional arguments to pass to the tasks
     #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
-    pub additional_args: Vec<Str>,
+    pub(crate) additional_args: Vec<Str>,
+
+    /// Display the detailed summary of the last run.
+    #[clap(long, exclusive = true)]
+    pub(crate) last_details: bool,
 }
 
-/// vite task CLI subcommands
+/// vite task CLI subcommands as parsed by clap.
+///
+/// vite task CLI subcommands as parsed by clap.
+///
+/// Pass directly to `Session::main` or `HandledCommand::ViteTaskCommand`.
+/// The `--last-details` flag on the `run` subcommand is resolved internally.
 #[derive(Debug, Parser)]
 pub enum Command {
     /// Run tasks
@@ -57,6 +78,68 @@ pub enum Command {
     },
 }
 
+impl Command {
+    /// Resolve the clap-parsed command into the dispatched [`ResolvedCommand`] enum.
+    ///
+    /// When `--last-details` is set on the `run` subcommand, this produces
+    /// [`ResolvedCommand::RunLastDetails`] instead of [`ResolvedCommand::Run`],
+    /// making the exclusivity enforced at the type level.
+    #[must_use]
+    pub(crate) fn into_resolved(self) -> ResolvedCommand {
+        match self {
+            Self::Run(run) if run.last_details => ResolvedCommand::RunLastDetails,
+            Self::Run(run) => ResolvedCommand::Run(run.into_resolved()),
+            Self::Cache { subcmd } => ResolvedCommand::Cache { subcmd },
+        }
+    }
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Internal resolved types (used for dispatch — `--last-details` is a separate variant)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/// Resolved CLI command for internal dispatch.
+///
+/// Unlike [`Command`], this enum makes `--last-details` a separate variant
+/// ([`ResolvedCommand::RunLastDetails`]) so that it is exclusive at the type level —
+/// there is no way to combine it with task execution fields.
+#[derive(Debug)]
+pub enum ResolvedCommand {
+    /// Run tasks with the given parameters.
+    Run(ResolvedRunCommand),
+    /// Display the saved detailed summary of the last run (`--last-details`).
+    RunLastDetails,
+    /// Manage the task cache.
+    Cache { subcmd: CacheSubcommand },
+}
+
+/// Resolved arguments for executing tasks.
+///
+/// Does not contain `last_details` — that case is represented by
+/// [`ResolvedCommand::RunLastDetails`] instead.
+#[derive(Debug)]
+pub struct ResolvedRunCommand {
+    /// `packageName#taskName` or `taskName`. If omitted, lists all available tasks.
+    pub task_specifier: Option<TaskSpecifier>,
+
+    pub flags: RunFlags,
+
+    /// Additional arguments to pass to the tasks.
+    pub additional_args: Vec<Str>,
+}
+
+impl RunCommand {
+    /// Convert to the resolved run command, stripping the `last_details` flag.
+    #[must_use]
+    pub(crate) fn into_resolved(self) -> ResolvedRunCommand {
+        ResolvedRunCommand {
+            task_specifier: self.task_specifier,
+            flags: self.flags,
+            additional_args: self.additional_args,
+        }
+    }
+}
+
 #[derive(thiserror::Error, Debug)]
 pub enum CLITaskQueryError {
     #[error("no task specifier provided")]
@@ -69,7 +152,7 @@ pub enum CLITaskQueryError {
     PackageNameSpecifiedWithRecursive { package_name: Str, task_name: Str },
 }
 
-impl RunCommand {
+impl ResolvedRunCommand {
     /// Convert to `QueryPlanRequest`, or return an error if invalid.
     ///
     /// # Errors
@@ -82,7 +165,7 @@ 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;
 

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};
+use crate::session::event::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> {
@@ -180,105 +216,6 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
             };
             Some(vite_str::format!("✗ cache miss: {reason}, executing"))
         }
-        CacheStatus::Disabled(reason) => {
-            // Show inline message for disabled cache
-            let message = match reason {
-                CacheDisabledReason::InProcessExecution => "cache disabled: built-in command",
-                CacheDisabledReason::NoCacheMetadata => "cache disabled: no cache config",
-            };
-            Some(vite_str::format!("⊘ {message}"))
-        }
-    }
-}
-
-/// 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}")
-        }
+        CacheStatus::Disabled(_) => Some(Str::from("⊘ cache disabled")),
     }
 }

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;