refactor: rename ParsedCommand to Command and make resolved types internal

- Rename `ParsedCommand` → `Command` and `ParsedRunCommand` → `RunCommand` as the public API types
- Rename old `Command` → `ResolvedCommand` and old `RunCommand` → `ResolvedRunCommand` as crate-internal types
- `Session::main` and `HandledCommand::ViteTaskCommand` now accept `Command` directly (no `.into_command()` needed)
- Fix summary message: `--verbose` → `--last-details`

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

Author: branchseer

crates/vite_task/src/cli/mod.rs

@@ -37,78 +37,74 @@ pub struct RunFlags {
 }
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// Clap-parsed types (used only at the parsing boundary)
+// 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
-/// [`Command::RunLastDetails`] variant via [`ParsedCommand::into_command`].
+/// [`ResolvedCommand::RunLastDetails`] variant via [`Command::into_resolved`].
 #[derive(Debug, clap::Args)]
-pub struct ParsedRunCommand {
+pub struct RunCommand {
     /// `packageName#taskName` or `taskName`. If omitted, lists all available tasks.
-    task_specifier: Option<TaskSpecifier>,
+    pub(crate) task_specifier: Option<TaskSpecifier>,
 
     #[clap(flatten)]
-    flags: RunFlags,
+    pub(crate) flags: RunFlags,
 
     /// Additional arguments to pass to the tasks
     #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
-    additional_args: Vec<Str>,
+    pub(crate) additional_args: Vec<Str>,
 
     /// Display the detailed summary of the last run.
     #[clap(long, exclusive = true)]
-    last_details: bool,
+    pub(crate) last_details: bool,
 }
 
 /// vite task CLI subcommands as parsed by clap.
 ///
-/// Use [`ParsedCommand::into_command`] to resolve into the dispatched [`Command`]
-/// enum, which makes `--last-details` exclusive at the type level.
+/// Pass directly to [`Session::main`] or [`HandledCommand::ViteTaskCommand`].
+/// The `--last-details` flag on the `run` subcommand is resolved internally.
 #[derive(Debug, Parser)]
-pub enum ParsedCommand {
+pub enum Command {
     /// Run tasks
-    Run(ParsedRunCommand),
+    Run(RunCommand),
     /// Manage the task cache
     Cache {
         #[clap(subcommand)]
         subcmd: CacheSubcommand,
     },
 }
 
-impl ParsedCommand {
-    /// Resolve the clap-parsed command into the dispatched [`Command`] enum.
+impl Command {
+    /// Resolve the clap-parsed command into the dispatched [`ResolvedCommand`] enum.
     ///
     /// When `--last-details` is set on the `run` subcommand, this produces
-    /// [`Command::RunLastDetails`] instead of [`Command::Run`], making the
-    /// exclusivity enforced at the type level.
+    /// [`ResolvedCommand::RunLastDetails`] instead of [`ResolvedCommand::Run`],
+    /// making the exclusivity enforced at the type level.
     #[must_use]
-    pub fn into_command(self) -> Command {
+    pub(crate) fn into_resolved(self) -> ResolvedCommand {
         match self {
-            Self::Run(run) if run.last_details => Command::RunLastDetails,
-            Self::Run(run) => Command::Run(RunCommand {
-                task_specifier: run.task_specifier,
-                flags: run.flags,
-                additional_args: run.additional_args,
-            }),
-            Self::Cache { subcmd } => Command::Cache { subcmd },
+            Self::Run(run) if run.last_details => ResolvedCommand::RunLastDetails,
+            Self::Run(run) => ResolvedCommand::Run(run.into_resolved()),
+            Self::Cache { subcmd } => ResolvedCommand::Cache { subcmd },
         }
     }
 }
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// Resolved types (used for dispatch — `--last-details` is a separate variant)
+// Internal resolved types (used for dispatch — `--last-details` is a separate variant)
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-/// Resolved CLI command for dispatch.
+/// Resolved CLI command for internal dispatch.
 ///
-/// Unlike [`ParsedCommand`], this enum makes `--last-details` a separate variant
-/// ([`Command::RunLastDetails`]) so that it is exclusive at the type level —
+/// 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 Command {
+pub enum ResolvedCommand {
     /// Run tasks with the given parameters.
-    Run(RunCommand),
+    Run(ResolvedRunCommand),
     /// Display the saved detailed summary of the last run (`--last-details`).
     RunLastDetails,
     /// Manage the task cache.
@@ -118,9 +114,9 @@ pub enum Command {
 /// Resolved arguments for executing tasks.
 ///
 /// Does not contain `last_details` — that case is represented by
-/// [`Command::RunLastDetails`] instead.
+/// [`ResolvedCommand::RunLastDetails`] instead.
 #[derive(Debug)]
-pub struct RunCommand {
+pub struct ResolvedRunCommand {
     /// `packageName#taskName` or `taskName`. If omitted, lists all available tasks.
     pub task_specifier: Option<TaskSpecifier>,
 
@@ -130,6 +126,18 @@ pub struct RunCommand {
     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")]
@@ -142,7 +150,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

crates/vite_task/src/lib.rs

@@ -4,7 +4,7 @@ mod maybe_str;
 pub mod session;
 
 // Public exports for vite_task_bin
-pub use cli::{CacheSubcommand, Command, ParsedCommand, RunCommand, RunFlags};
+pub use cli::{CacheSubcommand, Command, RunCommand, RunFlags};
 pub use session::{CommandHandler, ExitStatus, HandledCommand, Session, SessionCallbacks};
 pub use vite_task_graph::{
     config::{

crates/vite_task/src/session/mod.rs

@@ -29,7 +29,7 @@ use vite_task_plan::{
 };
 use vite_workspace::{WorkspaceRoot, find_workspace_root};
 
-use crate::cli::{CacheSubcommand, Command, RunCommand, RunFlags};
+use crate::cli::{CacheSubcommand, Command, ResolvedCommand, RunCommand, RunFlags};
 
 #[derive(Debug)]
 enum LazyTaskGraph<'a> {
@@ -100,13 +100,13 @@ impl vite_task_plan::PlanRequestParser for PlanRequestParser<'_> {
     ) -> anyhow::Result<Option<PlanRequest>> {
         match self.command_handler.handle_command(command).await? {
             HandledCommand::Synthesized(synthetic) => Ok(Some(PlanRequest::Synthetic(synthetic))),
-            HandledCommand::ViteTaskCommand(cli_command) => match cli_command {
-                Command::Cache { .. } | Command::RunLastDetails => {
+            HandledCommand::ViteTaskCommand(cli_command) => match cli_command.into_resolved() {
+                ResolvedCommand::Cache { .. } | ResolvedCommand::RunLastDetails => {
                     Ok(Some(PlanRequest::Synthetic(
                         command.to_synthetic_plan_request(UserCacheConfig::disabled()),
                     )))
                 }
-                Command::Run(run_command) => {
+                ResolvedCommand::Run(run_command) => {
                     match run_command.into_query_plan_request(&command.cwd) {
                         Ok(query_plan_request) => Ok(Some(PlanRequest::Query(query_plan_request))),
                         Err(crate::cli::CLITaskQueryError::MissingTaskSpecifier) => {
@@ -227,10 +227,10 @@ impl<'a> Session<'a> {
         reason = "session is single-threaded, futures do not need to be Send"
     )]
     pub async fn main(mut self, command: Command) -> anyhow::Result<ExitStatus> {
-        match command {
-            Command::Cache { ref subcmd } => self.handle_cache_command(subcmd),
-            Command::RunLastDetails => self.show_last_run_details(),
-            Command::Run(run_command) => {
+        match command.into_resolved() {
+            ResolvedCommand::Cache { ref subcmd } => self.handle_cache_command(subcmd),
+            ResolvedCommand::RunLastDetails => self.show_last_run_details(),
+            ResolvedCommand::Run(run_command) => {
                 let cwd = Arc::clone(&self.cwd);
                 let is_interactive =
                     std::io::stdin().is_terminal() && std::io::stdout().is_terminal();
@@ -241,7 +241,7 @@ impl<'a> Session<'a> {
                 let flags = run_command.flags;
                 let additional_args = run_command.additional_args.clone();
 
-                match self.plan_from_cli_run(cwd, run_command).await {
+                match self.plan_from_cli_run_resolved(cwd, run_command).await {
                     Ok(ref graph) if graph.node_count() == 0 => {
                         // No tasks matched the query — show task selector / "did you mean"
                         self.handle_no_task(
@@ -399,8 +399,12 @@ impl<'a> Session<'a> {
         let selected_label = &select_items[selected_index].label;
         let task_specifier = TaskSpecifier::parse_raw(selected_label);
         let show_details = flags.verbose;
-        let run_command =
-            RunCommand { task_specifier: Some(task_specifier), flags, additional_args };
+        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?;
@@ -579,6 +583,19 @@ impl<'a> Session<'a> {
         &mut self,
         cwd: Arc<AbsolutePath>,
         command: RunCommand,
+    ) -> Result<ExecutionGraph, vite_task_plan::Error> {
+        self.plan_from_cli_run_resolved(cwd, command.into_resolved()).await
+    }
+
+    /// Internal: plans execution from a resolved run command.
+    #[expect(
+        clippy::future_not_send,
+        reason = "session is single-threaded, futures do not need to be Send"
+    )]
+    async fn plan_from_cli_run_resolved(
+        &mut self,
+        cwd: Arc<AbsolutePath>,
+        command: crate::cli::ResolvedRunCommand,
     ) -> Result<ExecutionGraph, vite_task_plan::Error> {
         let query_plan_request = match command.into_query_plan_request(&cwd) {
             Ok(query_plan_request) => query_plan_request,

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

@@ -709,7 +709,7 @@ pub fn format_compact_summary(summary: &LastRunSummary) -> Vec<u8> {
         let _ = write!(
             buf,
             ". {}",
-            "(Run `vp run --verbose` for full details)".style(Style::new().bright_black()),
+            "(Run `vp run --last-details` for full details)".style(Style::new().bright_black()),
         );
         let _ = writeln!(buf);
     }

crates/vite_task_bin/src/lib.rs

@@ -10,8 +10,8 @@ use rustc_hash::FxHashMap;
 use vite_path::AbsolutePath;
 use vite_str::Str;
 use vite_task::{
-    EnabledCacheConfig, HandledCommand, ParsedCommand, ScriptCommand, SessionCallbacks,
-    UserCacheConfig, get_path_env, plan_request::SyntheticPlanRequest,
+    Command, EnabledCacheConfig, HandledCommand, ScriptCommand, SessionCallbacks, UserCacheConfig,
+    get_path_env, plan_request::SyntheticPlanRequest,
 };
 
 #[derive(Debug, Default)]
@@ -85,7 +85,7 @@ pub enum Args {
         value: Str,
     },
     #[command(flatten)]
-    Task(ParsedCommand),
+    Task(Command),
 }
 
 #[async_trait::async_trait(?Send)]
@@ -130,7 +130,7 @@ impl vite_task::CommandHandler for CommandHandler {
                     envs: Arc::new(envs),
                 }))
             }
-            Args::Task(parsed) => Ok(HandledCommand::ViteTaskCommand(parsed.into_command())),
+            Args::Task(parsed) => Ok(HandledCommand::ViteTaskCommand(parsed)),
         }
     }
 }

crates/vite_task_bin/src/main.rs

@@ -21,7 +21,7 @@ async fn run() -> anyhow::Result<ExitStatus> {
     let mut owned_callbacks = OwnedSessionCallbacks::default();
     let session = Session::init(owned_callbacks.as_callbacks())?;
     match args {
-        Args::Task(parsed) => session.main(parsed.into_command()).await,
+        Args::Task(parsed) => session.main(parsed).await,
         args => {
             // If env FOO is set, run `print-env FOO` via Session::exec before proceeding.
             // In vite-plus, Session::exec is used for auto-install.

crates/vite_task_bin/tests/e2e_snapshots/fixtures/cache-miss-command-change/snapshots/cache miss command change.snap

@@ -10,7 +10,7 @@ $ print bar
 bar
 
 ---
-[vp run] 0/2 cache hit (0%). (Run `vp run --verbose` for full details)
+[vp run] 0/2 cache hit (0%). (Run `vp run --last-details` for full details)
 > json-edit package.json '_.scripts.task = "print baz && print bar"' # change first subtask
 
 > vp run task # first: cache miss, second: cache hit
@@ -21,7 +21,7 @@ $ print bar ✓ cache hit, replaying
 bar
 
 ---
-[vp run] 1/2 cache hit (50%), <duration> saved. (Run `vp run --verbose` for full details)
+[vp run] 1/2 cache hit (50%), <duration> saved. (Run `vp run --last-details` for full details)
 > json-edit package.json '_.scripts.task = "print bar"' # remove first subtask
 
 > vp run task # cache hit

crates/vite_task_bin/tests/e2e_snapshots/fixtures/exit-codes/snapshots/multiple task failures returns exit code 1.snap

@@ -8,4 +8,4 @@ expression: e2e_outputs
 ~/packages/pkg-b$ node -e "process.exit(7)"
 
 ---
-[vp run] 0/2 cache hit (0%), 2 failed. (Run `vp run --verbose` for full details)
+[vp run] 0/2 cache hit (0%), 2 failed. (Run `vp run --last-details` for full details)

crates/vite_task_bin/tests/e2e_snapshots/fixtures/stdin-inheritance/snapshots/multiple tasks get null stdin.snap

@@ -8,4 +8,4 @@ expression: e2e_outputs
 $ read-stdin ⊘ cache disabled: no cache config
 
 ---
-[vp run] 0/2 cache hit (0%). (Run `vp run --verbose` for full details)
+[vp run] 0/2 cache hit (0%). (Run `vp run --last-details` for full details)

crates/vite_task_bin/tests/e2e_snapshots/fixtures/stdio-detection/snapshots/multiple tasks, cache disabled.snap

@@ -14,4 +14,4 @@ stdout:not-tty
 stderr:not-tty
 
 ---
-[vp run] 0/2 cache hit (0%). (Run `vp run --verbose` for full details)
+[vp run] 0/2 cache hit (0%). (Run `vp run --last-details` for full details)