feat(cache): add explicit auto output tracking

Co-authored-by: GPT-5 Codex <codex@openai.com>

Author: wan9chi

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 - **Added** Runner-aware tools can now call `ignoreInput(path)` to exclude non-semantic reads from auto-inferred task cache inputs.
 - **Added** Runner-aware tools can now call `ignoreOutput(path)` to exclude non-semantic writes from read/write overlap checks.
+- **Added** Cached tasks can opt into automatic output restoration with `output: [{ auto: true }]`.
 - **Changed** Tracked environment values in task cache fingerprints are now stored only as SHA-256 digests, and env-related cache miss details report names without values.
 - **Added** Runner-aware `getEnvs` match sets can now participate in task cache fingerprints, so changing, adding, or removing a matching env var invalidates the cache ([#450](https://github.com/voidzero-dev/vite-task/pull/450)).
 - **Added** Runner-aware `getEnvs` calls now return env values served by the runner for matching env glob patterns ([#449](https://github.com/voidzero-dev/vite-task/pull/449)).

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

@@ -28,6 +28,9 @@ use crate::{
 /// value is only ever `Some` when tracking happened (see [`observe_fspy`]).
 struct TrackingOutcome {
     path_reads: HashMap<RelativePathBuf, PathRead>,
+    /// Auto-output writes after output exclusions are applied. Empty when
+    /// `output_config.includes_auto` is false.
+    path_writes: FxHashSet<RelativePathBuf>,
     /// First path that was both read and written during execution, if any.
     /// A non-empty value means caching this task is unsound.
     read_write_overlap: Option<RelativePathBuf>,
@@ -58,7 +61,6 @@ pub(super) async fn update_cache(
 ) -> (CacheUpdateStatus, Option<ExecutionError>) {
     let CacheState { metadata, globbed_inputs, std_outputs, tracking } = state;
     let fspy = tracking.fspy.as_ref();
-    let input_negative_globs = fspy.map(|t| t.input_negative_globs.as_slice());
 
     if let Some(reports) = reports
         && reports.cache_disabled
@@ -89,7 +91,8 @@ pub(super) async fn update_cache(
 
     let fspy_outcome = observe_fspy(
         outcome,
-        input_negative_globs,
+        metadata,
+        fspy,
         &ignored_input_rels,
         &ignored_output_rels,
         workspace_root,
@@ -150,7 +153,12 @@ pub(super) async fn update_cache(
         }
     };
 
-    let output_archive = match collect_and_archive_outputs(metadata, workspace_root, cache_dir) {
+    let output_archive = match collect_and_archive_outputs(
+        metadata,
+        fspy_outcome.as_ref(),
+        workspace_root,
+        cache_dir,
+    ) {
         Ok(archive) => archive,
         Err(err) => {
             return (
@@ -177,12 +185,18 @@ pub(super) async fn update_cache(
 }
 
 /// Summarize the run's fspy observations. `Some` iff tracking was both
-/// requested (`input_negative_globs.is_some()`) and compiled in (`cfg(fspy)`). On a
+/// requested (`tracking.fspy.is_some()`) and compiled in (`cfg(fspy)`). On a
 /// `cfg(not(fspy))` build this is always `None`, and [`update_cache`]
 /// short-circuits to `FspyUnsupported` when tracking was needed.
+///
+/// `path_reads` is gated on `input_config.includes_auto`, filtered by
+/// user-configured input negatives, and by tool-reported `ignoreInput` paths.
+/// `path_writes` is filtered by user-configured output negatives and
+/// tool-reported `ignoreOutput` paths before read-write overlap detection.
 fn observe_fspy(
     outcome: &ChildOutcome,
-    input_negative_globs: Option<&[wax::Glob<'static>]>,
+    metadata: &CacheMetadata,
+    fspy: Option<&super::FspyTracking>,
     ignored_input_rels: &FxHashSet<RelativePathBuf>,
     ignored_output_rels: &FxHashSet<RelativePathBuf>,
     workspace_root: &AbsolutePath,
@@ -191,31 +205,56 @@ fn observe_fspy(
     {
         use super::tracked_accesses::TrackedPathAccesses;
 
-        outcome.path_accesses.as_ref().zip(input_negative_globs).map(|(raw, negatives)| {
-            let tracked = TrackedPathAccesses::from_raw(raw, workspace_root, negatives);
-            let path_reads: HashMap<RelativePathBuf, PathRead> = tracked
-                .path_reads
-                .into_iter()
-                .filter(|(path, _)| !is_ignored(path, ignored_input_rels))
-                .collect();
-            let path_writes: FxHashSet<RelativePathBuf> = tracked
-                .path_writes
-                .into_iter()
-                .filter(|path| !is_ignored(path, ignored_output_rels))
-                .collect();
-            let read_write_overlap = path_reads.keys().find(|p| path_writes.contains(*p)).cloned();
-            TrackingOutcome { path_reads, read_write_overlap }
+        outcome.path_accesses.as_ref().map(|raw| {
+            let tracked = TrackedPathAccesses::from_raw(raw, workspace_root);
+            let filtered_path_reads: HashMap<RelativePathBuf, PathRead> =
+                // fspy can be attached for auto-output-only tasks. In that
+                // mode reads must not become inferred inputs.
+                if metadata.input_config.includes_auto
+                    && let Some(fspy) = fspy
+                {
+                    tracked
+                        .path_reads
+                        .iter()
+                        .filter(|(path, _)| {
+                            !matches_any_glob(path, &fspy.input_negative_globs)
+                                && !is_ignored(path, ignored_input_rels)
+                        })
+                        .map(|(path, read)| (path.clone(), *read))
+                        .collect()
+                } else {
+                    HashMap::default()
+                };
+            let filtered_path_writes: FxHashSet<RelativePathBuf> =
+                // fspy can also be attached for auto-input-only tasks. In that
+                // mode writes must not become auto outputs or overlap candidates.
+                if metadata.output_config.includes_auto
+                    && let Some(fspy) = fspy
+                {
+                    tracked
+                        .path_writes
+                        .iter()
+                        .filter(|path| {
+                            !matches_any_glob(path, &fspy.output_negative_globs)
+                                && !is_ignored(path, ignored_output_rels)
+                        })
+                        .cloned()
+                        .collect()
+                } else {
+                    FxHashSet::default()
+                };
+            let read_write_overlap =
+                filtered_path_reads.keys().find(|p| filtered_path_writes.contains(*p)).cloned();
+            TrackingOutcome {
+                path_reads: filtered_path_reads,
+                path_writes: filtered_path_writes,
+                read_write_overlap,
+            }
         })
     }
     #[cfg(not(fspy))]
     {
-        let _ = (
-            outcome,
-            input_negative_globs,
-            ignored_input_rels,
-            ignored_output_rels,
-            workspace_root,
-        );
+        let _ = (outcome, metadata, fspy, ignored_input_rels, ignored_output_rels, workspace_root);
         None
     }
 }
@@ -256,6 +295,12 @@ fn is_ignored(path: &RelativePathBuf, ignored: &FxHashSet<RelativePathBuf>) -> b
     ignored.contains(path) || ignored.iter().any(|ig| path.strip_prefix(ig).is_some())
 }
 
+fn matches_any_glob(path: &RelativePathBuf, globs: &[wax::Glob<'static>]) -> bool {
+    use wax::Program as _;
+
+    globs.iter().any(|glob| glob.is_match(path.as_str()))
+}
+
 /// Select tool-reported env records to embed in the post-run fingerprint.
 /// Names that the user already declared as fingerprinted are skipped because
 /// their values are already in the spawn fingerprint.
@@ -309,36 +354,49 @@ fn collect_tracked_env_globs(reports: &Reports) -> anyhow::Result<TrackedEnvGlob
     Ok(tracked_env_globs)
 }
 
-/// Collect output files matching the configured globs and create a tar.zst
-/// archive in the cache directory.
+/// Collect output files and create a tar.zst archive in the cache directory.
+///
+/// Output files are determined by:
+/// - fspy-tracked writes (already empty when `output_config.includes_auto` is false)
+/// - Positive output globs (always, if configured)
+/// - Negative output globs and tool-reported `ignoreOutput` paths filter
+///   fspy-tracked writes before this function receives them
 ///
-/// Returns `Some(archive_filename)` if files were archived, `None` if the
-/// output config has no positive globs or no files matched.
+/// Returns `Some(archive_filename)` if files were archived, `None` if no output files.
 fn collect_and_archive_outputs(
     cache_metadata: &CacheMetadata,
+    tracking: Option<&TrackingOutcome>,
     workspace_root: &AbsolutePath,
     cache_dir: &AbsolutePath,
 ) -> anyhow::Result<Option<Str>> {
     let output_config = &cache_metadata.output_config;
 
-    if output_config.positive_globs.is_empty() {
-        return Ok(None);
+    let mut output_files: FxHashSet<RelativePathBuf> = FxHashSet::default();
+
+    if let Some(t) = tracking {
+        output_files.extend(t.path_writes.iter().cloned());
     }
 
-    let output_files = glob::collect_glob_paths(
-        workspace_root,
-        &output_config.positive_globs,
-        &output_config.negative_globs,
-    )?;
+    if !output_config.positive_globs.is_empty() {
+        let glob_paths = glob::collect_glob_paths(
+            workspace_root,
+            &output_config.positive_globs,
+            &output_config.negative_globs,
+        )?;
+        output_files.extend(glob_paths);
+    }
 
     if output_files.is_empty() {
         return Ok(None);
     }
 
+    let mut sorted_files: Vec<RelativePathBuf> = output_files.into_iter().collect();
+    sorted_files.sort();
+
     let archive_name: Str = vite_str::format!("{}.tar.zst", uuid::Uuid::new_v4());
     let archive_path = cache_dir.join(archive_name.as_str());
 
-    archive::create_output_archive(workspace_root, &output_files, &archive_path)?;
+    archive::create_output_archive(workspace_root, &sorted_files, &archive_path)?;
 
     Ok(Some(archive_name))
 }

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

@@ -89,9 +89,9 @@ struct CacheState<'a> {
     /// always present (possibly empty) once we reach the cache-update phase.
     std_outputs: Vec<StdOutput>,
     /// Runner-aware tracking for cached tasks: an IPC server is always
-    /// available, and fspy path tracing is attached only when auto input
-    /// inference needs it. Parts are borrowed in place during the wait/join;
-    /// the struct is never moved out.
+    /// available, and fspy path tracing is attached only when auto input or
+    /// output inference needs it. Parts are borrowed in place during the
+    /// wait/join; the struct is never moved out.
     tracking: Tracking,
 }
 
@@ -100,9 +100,10 @@ struct CacheState<'a> {
 type IpcDriver = LocalBoxFuture<'static, Result<Recorder, vite_task_server::Error>>;
 
 /// fspy path-tracking state, present only when a cached task needs automatic
-/// input inference.
+/// input or output inference.
 struct FspyTracking {
     input_negative_globs: Vec<wax::Glob<'static>>,
+    output_negative_globs: Vec<wax::Glob<'static>>,
 }
 
 /// Per-task runner-aware tracking: IPC server handle plus optional fspy state.
@@ -164,17 +165,24 @@ impl<'a> ExecutionMode<'a> {
             });
         };
 
-        let fspy = if metadata.input_config.includes_auto {
-            // Resolve input negative globs for fspy path filtering (already
+        let fspy = if metadata.input_config.includes_auto || metadata.output_config.includes_auto {
+            // Resolve negative globs for fspy path filtering (already
             // workspace-root-relative).
-            let negatives = metadata
+            let input_negative_globs = metadata
                 .input_config
                 .negative_globs
                 .iter()
                 .map(|p| Ok(wax::Glob::new(p.as_str())?.into_owned()))
                 .collect::<anyhow::Result<Vec<_>>>()
                 .map_err(ExecutionError::PostRunFingerprint)?;
-            Some(FspyTracking { input_negative_globs: negatives })
+            let output_negative_globs = metadata
+                .output_config
+                .negative_globs
+                .iter()
+                .map(|p| Ok(wax::Glob::new(p.as_str())?.into_owned()))
+                .collect::<anyhow::Result<Vec<_>>>()
+                .map_err(ExecutionError::PostRunFingerprint)?;
+            Some(FspyTracking { input_negative_globs, output_negative_globs })
         } else {
             None
         };

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

@@ -1,4 +1,8 @@
 //! Normalize raw fspy path accesses into workspace-relative, filtered form.
+//!
+//! User-configured negative globs are NOT applied here. They are applied later,
+//! separately for reads (input config) and writes (output config), since those
+//! two configs are independent.
 #![cfg(fspy)]
 
 use std::collections::hash_map::Entry;
@@ -21,22 +25,19 @@ pub struct TrackedPathAccesses {
 }
 
 impl TrackedPathAccesses {
-    /// Build from fspy's raw iterable by stripping the workspace prefix,
-    /// normalizing `..` components, and filtering against the negative globs.
-    pub fn from_raw(
-        raw: &PathAccessIterable,
-        workspace_root: &AbsolutePath,
-        resolved_negatives: &[wax::Glob<'static>],
-    ) -> Self {
+    /// Build from fspy's raw iterable by stripping the workspace prefix and
+    /// normalizing `..` components. `.git/*` paths are skipped. User-configured
+    /// negatives are applied by the caller (see module docs).
+    pub fn from_raw(raw: &PathAccessIterable, workspace_root: &AbsolutePath) -> Self {
         let mut accesses = Self::default();
         for access in raw.iter() {
-            // Strip workspace root, clean `..` components, and filter in one pass.
+            // Strip workspace root and clean `..` components in one pass.
             // fspy may report paths like `packages/sub-pkg/../shared/dist/output.js`.
             let relative_path = access.path.strip_path_prefix(workspace_root, |strip_result| {
                 let Ok(stripped_path) = strip_result else {
                     return None;
                 };
-                normalize_tracked_workspace_path(stripped_path, resolved_negatives)
+                normalize_tracked_workspace_path(stripped_path)
             });
 
             let Some(relative_path) = relative_path else {
@@ -71,10 +72,7 @@ impl TrackedPathAccesses {
     clippy::disallowed_types,
     reason = "fspy strip_path_prefix exposes std::path::Path; convert to RelativePathBuf immediately"
 )]
-fn normalize_tracked_workspace_path(
-    stripped_path: &std::path::Path,
-    resolved_negatives: &[wax::Glob<'static>],
-) -> Option<RelativePathBuf> {
+fn normalize_tracked_workspace_path(stripped_path: &std::path::Path) -> Option<RelativePathBuf> {
     // On Windows, paths are possible to be still absolute after stripping the workspace root.
     // For example: c:\workspace\subdir\c:\workspace\subdir
     // Just ignore those accesses.
@@ -90,12 +88,6 @@ fn normalize_tracked_workspace_path(
         return None;
     }
 
-    if !resolved_negatives.is_empty()
-        && resolved_negatives.iter().any(|neg| wax::Program::is_match(neg, relative.as_str()))
-    {
-        return None;
-    }
-
     Some(relative)
 }
 
@@ -111,8 +103,7 @@ mod tests {
             clippy::disallowed_types,
             reason = "normalize_tracked_workspace_path requires std::path::Path for fspy strip_path_prefix output"
         )]
-        let relative_path =
-            normalize_tracked_workspace_path(std::path::Path::new(r"foo\C:\bar"), &[]);
+        let relative_path = normalize_tracked_workspace_path(std::path::Path::new(r"foo\C:\bar"));
         assert!(relative_path.is_none());
     }
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input_read_write_not_cached/packages/normal-pkg/package.json

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

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input_read_write_not_cached/packages/normal-pkg/vite-task.json

@@ -0,0 +1,8 @@
+{
+  "tasks": {
+    "task": {
+      "command": "vtt print hello",
+      "output": [{ "auto": true }]
+    }
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input_read_write_not_cached/packages/rw-pkg/package.json

@@ -1,8 +1,5 @@
 {
   "name": "@test/rw-pkg",
-  "scripts": {
-    "task": "vtt replace-file-content src/data.txt i !"
-  },
   "dependencies": {
     "@test/touch-pkg": "workspace:*"
   }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input_read_write_not_cached/packages/rw-pkg/vite-task.json

@@ -0,0 +1,8 @@
+{
+  "tasks": {
+    "task": {
+      "command": "vtt replace-file-content src/data.txt i !",
+      "output": [{ "auto": true }]
+    }
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/input_read_write_not_cached/packages/touch-pkg/package.json

@@ -1,8 +1,5 @@
 {
   "name": "@test/touch-pkg",
-  "scripts": {
-    "task": "vtt touch-file src/data.txt"
-  },
   "dependencies": {
     "@test/normal-pkg": "workspace:*"
   }