feat: add --cache/--no-cache CLI flags and move cache resolution to plan stage

Move global cache config resolution from task graph load time to plan
time, enabling CLI overrides and proper nested vp run support.

Key changes:
- Add TaskSource enum to distinguish TaskConfig vs PackageJsonScript
- Store ResolvedGlobalCacheConfig on IndexedTaskGraph without applying
  the global kill switch at graph load time
- Add CacheOverride enum (None/ForceEnabled/ForceDisabled) to PlanOptions
- Add --cache and --no-cache flags to RunFlags with conflicts_with
- Compute final ResolvedGlobalCacheConfig in PlanContext by combining
  graph config with CLI override
- Apply effective_cache_config per task at plan time using TaskSource
- Nested vp run --cache/--no-cache overrides parent's resolved config

https://claude.ai/code/session_01AYbt3E5j8Adk9NB7Sprkah

Author: claude

crates/vite_task/src/cli/mod.rs

@@ -4,7 +4,7 @@ use clap::Parser;
 use vite_path::AbsolutePath;
 use vite_str::Str;
 use vite_task_graph::{TaskSpecifier, query::TaskQuery};
-use vite_task_plan::plan_request::{PlanOptions, QueryPlanRequest};
+use vite_task_plan::plan_request::{CacheOverride, PlanOptions, QueryPlanRequest};
 use vite_workspace::package_filter::{PackageQueryArgs, PackageQueryError};
 
 #[derive(Debug, Clone, clap::Subcommand)]
@@ -15,6 +15,7 @@ pub enum CacheSubcommand {
 
 /// Flags that control how a `run` command selects tasks.
 #[derive(Debug, Clone, PartialEq, Eq, clap::Args)]
+#[expect(clippy::struct_excessive_bools, reason = "CLI flags are naturally boolean")]
 pub struct RunFlags {
     #[clap(flatten)]
     pub package_query: PackageQueryArgs,
@@ -26,6 +27,27 @@ pub struct RunFlags {
     /// Show full detailed summary after execution.
     #[clap(default_value = "false", short = 'v', long)]
     pub verbose: bool,
+
+    /// Force caching on for all tasks and scripts.
+    #[clap(long, conflicts_with = "no_cache")]
+    pub cache: bool,
+
+    /// Force caching off for all tasks and scripts.
+    #[clap(long, conflicts_with = "cache")]
+    pub no_cache: bool,
+}
+
+impl RunFlags {
+    #[must_use]
+    pub const fn cache_override(&self) -> CacheOverride {
+        if self.cache {
+            CacheOverride::ForceEnabled
+        } else if self.no_cache {
+            CacheOverride::ForceDisabled
+        } else {
+            CacheOverride::None
+        }
+    }
 }
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -155,19 +177,23 @@ impl ResolvedRunCommand {
         let raw_specifier = self.task_specifier.ok_or(CLITaskQueryError::MissingTaskSpecifier)?;
         let task_specifier = TaskSpecifier::parse_raw(&raw_specifier);
 
+        let cache_override = self.flags.cache_override();
+        let include_explicit_deps = !self.flags.ignore_depends_on;
+
         let (package_query, is_cwd_only) =
             self.flags.package_query.into_package_query(task_specifier.package_name, cwd)?;
 
-        let include_explicit_deps = !self.flags.ignore_depends_on;
-
         Ok((
             QueryPlanRequest {
                 query: TaskQuery {
                     package_query,
                     task_name: task_specifier.task_name,
                     include_explicit_deps,
                 },
-                plan_options: PlanOptions { extra_args: self.additional_args.into() },
+                plan_options: PlanOptions {
+                    extra_args: self.additional_args.into(),
+                    cache_override,
+                },
             },
             is_cwd_only,
         ))

crates/vite_task_graph/src/config/mod.rs

@@ -100,29 +100,18 @@ pub enum ResolveTaskConfigError {
 }
 
 impl ResolvedTaskConfig {
-    /// Resolve from package.json script only (no vite-task.json config for this task)
+    /// Resolve from package.json script only (no config entry for this task).
     ///
-    /// The `cache_scripts` parameter determines whether caching is enabled for the script.
-    /// When `true`, caching is enabled with default settings.
-    /// When `false`, caching is disabled.
+    /// Always resolves with caching enabled (default settings).
+    /// The global cache config is applied at plan time, not here.
     #[must_use]
     pub fn resolve_package_json_script(
         package_dir: &Arc<AbsolutePath>,
         package_json_script: &str,
-        cache_scripts: bool,
     ) -> Self {
-        let cache_config = if cache_scripts {
-            UserCacheConfig::Enabled {
-                cache: None,
-                enabled_cache_config: EnabledCacheConfig { envs: None, pass_through_envs: None },
-            }
-        } else {
-            UserCacheConfig::Disabled { cache: MustBe!(false) }
-        };
-        let options = UserTaskOptions { cache_config, ..Default::default() };
         Self {
             command: package_json_script.into(),
-            resolved_options: ResolvedTaskOptions::resolve(options, package_dir),
+            resolved_options: ResolvedTaskOptions::resolve(UserTaskOptions::default(), package_dir),
         }
     }
 

crates/vite_task_graph/src/config/user.rs

@@ -150,6 +150,7 @@ pub enum UserGlobalCacheConfig {
 }
 
 /// Resolved global cache configuration with concrete boolean values.
+#[derive(Debug, Clone, Copy)]
 pub struct ResolvedGlobalCacheConfig {
     pub scripts: bool,
     pub tasks: bool,

crates/vite_task_graph/src/lib.rs

@@ -6,7 +6,7 @@ mod specifier;
 
 use std::{convert::Infallible, sync::Arc};
 
-use config::{ResolvedTaskConfig, UserRunConfig};
+use config::{ResolvedGlobalCacheConfig, ResolvedTaskConfig, UserRunConfig};
 use petgraph::graph::{DefaultIx, DiGraph, EdgeIndex, IndexType, NodeIndex};
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use serde::Serialize;
@@ -47,6 +47,15 @@ pub(crate) struct TaskId {
     pub task_name: Str,
 }
 
+/// Whether a task originates from the `tasks` map or from a package.json script.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+pub enum TaskSource {
+    /// Defined in the `tasks` map in the workspace config.
+    TaskConfig,
+    /// Pure package.json script (not in the tasks map).
+    PackageJsonScript,
+}
+
 /// A node in the task graph, representing a task with its resolved configuration.
 #[derive(Debug, Serialize)]
 pub struct TaskNode {
@@ -60,6 +69,9 @@ pub struct TaskNode {
     ///
     /// However, it does not contain external factors like additional args from cli and env vars.
     pub resolved_config: ResolvedTaskConfig,
+
+    /// Whether this task comes from the tasks map or a package.json script.
+    pub source: TaskSource,
 }
 
 impl vite_graph_ser::GetKey for TaskNode {
@@ -166,6 +178,9 @@ pub struct IndexedTaskGraph {
 
     /// task indices by task id for quick lookup
     pub(crate) node_indices_by_task_id: FxHashMap<TaskId, TaskNodeIndex>,
+
+    /// Global cache configuration resolved from the workspace root config.
+    resolved_global_cache: ResolvedGlobalCacheConfig,
 }
 
 pub type TaskGraph = DiGraph<TaskNode, TaskDependencyType, TaskIx>;
@@ -234,11 +249,9 @@ impl IndexedTaskGraph {
             package_configs.push((package_index, package_dir, user_config));
         }
 
-        let resolved_cache = config::ResolvedGlobalCacheConfig::resolve_from(root_cache.as_ref());
-        let cache_scripts = resolved_cache.scripts;
-        let cache_tasks = resolved_cache.tasks;
+        let resolved_global_cache = ResolvedGlobalCacheConfig::resolve_from(root_cache.as_ref());
 
-        // Second pass: create task nodes using resolved cache config
+        // Second pass: create task nodes (cache is NOT applied here; it's applied at plan time)
         for (package_index, package_dir, user_config) in package_configs {
             let package = &package_graph[package_index];
 
@@ -250,19 +263,15 @@ impl IndexedTaskGraph {
                 .map(|(name, value)| (name.as_str(), value.as_str()))
                 .collect();
 
-            for (task_name, mut task_user_config) in user_config.tasks.unwrap_or_default() {
-                // Apply cache.tasks kill switch: when false, override all tasks to disable caching
-                if !cache_tasks {
-                    task_user_config.options.cache_config = config::UserCacheConfig::disabled();
-                }
-                // For each task defined in vite.config.*, look up the corresponding package.json script (if any)
+            for (task_name, task_user_config) in user_config.tasks.unwrap_or_default() {
+                // For each task defined in the config, look up the corresponding package.json script (if any)
                 let package_json_script = package_json_scripts.remove(task_name.as_str());
 
                 let task_id = TaskId { task_name: task_name.clone(), package_index };
 
                 let dependency_specifiers = task_user_config.options.depends_on.clone();
 
-                // Resolve the task configuration combining vite.config.* and package.json script
+                // Resolve the task configuration combining config and package.json script
                 let resolved_config = ResolvedTaskConfig::resolve(
                     task_user_config,
                     &package_dir,
@@ -284,20 +293,20 @@ impl IndexedTaskGraph {
                         package_path: Arc::clone(&package_dir),
                     },
                     resolved_config,
+                    source: TaskSource::TaskConfig,
                 };
 
                 let node_index = task_graph.add_node(task_node);
                 task_ids_with_dependency_specifiers.push((task_id.clone(), dependency_specifiers));
                 node_indices_by_task_id.insert(task_id, node_index);
             }
 
-            // For remaining package.json scripts not defined in vite.config.*, create tasks with default config
+            // For remaining package.json scripts not in the tasks map, create tasks with default config
             for (script_name, package_json_script) in package_json_scripts {
                 let task_id = TaskId { task_name: Str::from(script_name), package_index };
                 let resolved_config = ResolvedTaskConfig::resolve_package_json_script(
                     &package_dir,
                     package_json_script,
-                    cache_scripts,
                 );
                 let node_index = task_graph.add_node(TaskNode {
                     task_display: TaskDisplay {
@@ -306,6 +315,7 @@ impl IndexedTaskGraph {
                         package_path: Arc::clone(&package_dir),
                     },
                     resolved_config,
+                    source: TaskSource::PackageJsonScript,
                 });
                 node_indices_by_task_id.insert(task_id, node_index);
             }
@@ -316,6 +326,7 @@ impl IndexedTaskGraph {
             task_graph,
             indexed_package_graph: IndexedPackageGraph::index(package_graph),
             node_indices_by_task_id,
+            resolved_global_cache,
         };
 
         // Add explicit dependencies
@@ -420,4 +431,9 @@ impl IndexedTaskGraph {
         let index = self.indexed_package_graph.get_package_index_from_cwd(cwd)?;
         Some(self.get_package_path(index))
     }
+
+    #[must_use]
+    pub const fn global_cache_config(&self) -> &ResolvedGlobalCacheConfig {
+        &self.resolved_global_cache
+    }
 }

crates/vite_task_plan/src/context.rs

@@ -3,7 +3,7 @@ use std::{env::JoinPathsError, ffi::OsStr, ops::Range, sync::Arc};
 use rustc_hash::FxHashMap;
 use vite_path::AbsolutePath;
 use vite_str::Str;
-use vite_task_graph::{IndexedTaskGraph, TaskNodeIndex};
+use vite_task_graph::{IndexedTaskGraph, TaskNodeIndex, config::ResolvedGlobalCacheConfig};
 
 use crate::{PlanRequestParser, path_env::prepend_path_env};
 
@@ -39,6 +39,9 @@ pub struct PlanContext<'a> {
     extra_args: Arc<[Str]>,
 
     indexed_task_graph: &'a IndexedTaskGraph,
+
+    /// Final resolved global cache config, combining the graph's config with any CLI override.
+    resolved_global_cache: ResolvedGlobalCacheConfig,
 }
 
 impl<'a> PlanContext<'a> {
@@ -48,6 +51,7 @@ impl<'a> PlanContext<'a> {
         envs: FxHashMap<Arc<OsStr>, Arc<OsStr>>,
         callbacks: &'a mut (dyn PlanRequestParser + 'a),
         indexed_task_graph: &'a IndexedTaskGraph,
+        resolved_global_cache: ResolvedGlobalCacheConfig,
     ) -> Self {
         Self {
             workspace_path,
@@ -57,6 +61,7 @@ impl<'a> PlanContext<'a> {
             task_call_stack: Vec::new(),
             indexed_task_graph,
             extra_args: Arc::default(),
+            resolved_global_cache,
         }
     }
 
@@ -115,6 +120,14 @@ impl<'a> PlanContext<'a> {
         self.extra_args = extra_args;
     }
 
+    pub const fn resolved_global_cache(&self) -> &ResolvedGlobalCacheConfig {
+        &self.resolved_global_cache
+    }
+
+    pub const fn set_resolved_global_cache(&mut self, config: ResolvedGlobalCacheConfig) {
+        self.resolved_global_cache = config;
+    }
+
     pub fn duplicate(&mut self) -> PlanContext<'_> {
         PlanContext {
             workspace_path: self.workspace_path,
@@ -124,6 +137,7 @@ impl<'a> PlanContext<'a> {
             task_call_stack: self.task_call_stack.clone(),
             indexed_task_graph: self.indexed_task_graph,
             extra_args: Arc::clone(&self.extra_args),
+            resolved_global_cache: self.resolved_global_cache,
         }
     }
 }

crates/vite_task_plan/src/lib.rs

@@ -16,7 +16,7 @@ pub use execution_graph::ExecutionGraph;
 pub use in_process::InProcessExecution;
 pub use path_env::{get_path_env, prepend_path_env};
 use plan::{ParentCacheConfig, plan_query_request, plan_synthetic_request};
-use plan_request::{PlanRequest, QueryPlanRequest, SyntheticPlanRequest};
+use plan_request::{CacheOverride, PlanRequest, QueryPlanRequest, SyntheticPlanRequest};
 use rustc_hash::FxHashMap;
 use serde::{Serialize, ser::SerializeMap as _};
 use vite_path::AbsolutePath;
@@ -200,16 +200,37 @@ pub async fn plan_query(
 ) -> Result<ExecutionGraph, Error> {
     let indexed_task_graph = task_graph_loader.load_task_graph().await?;
 
+    let resolved_global_cache = resolve_cache_with_override(
+        *indexed_task_graph.global_cache_config(),
+        query_plan_request.plan_options.cache_override,
+    );
+
     let context = PlanContext::new(
         workspace_path,
         Arc::clone(cwd),
         envs.clone(),
         plan_request_parser,
         indexed_task_graph,
+        resolved_global_cache,
     );
     plan_query_request(query_plan_request, context).await
 }
 
+const fn resolve_cache_with_override(
+    graph_cache: vite_task_graph::config::ResolvedGlobalCacheConfig,
+    cache_override: CacheOverride,
+) -> vite_task_graph::config::ResolvedGlobalCacheConfig {
+    match cache_override {
+        CacheOverride::ForceEnabled => {
+            vite_task_graph::config::ResolvedGlobalCacheConfig { scripts: true, tasks: true }
+        }
+        CacheOverride::ForceDisabled => {
+            vite_task_graph::config::ResolvedGlobalCacheConfig { scripts: false, tasks: false }
+        }
+        CacheOverride::None => graph_cache,
+    }
+}
+
 /// Plan a synthetic task execution, returning the resolved [`SpawnExecution`] directly.
 ///
 /// Unlike [`plan_query`] which returns a full execution graph, synthetic executions