feat(execute): implement output file collection, archiving, and restoration

- Enable fspy tracking when either input or output uses auto-detection
- Add `collect_and_archive_outputs()` to gather output files from fspy writes
  and/or output globs, then create a tar.zst archive on cache update
- Restore output files from archive on cache hit via `extract_output_archive()`
- Add `collect_glob_paths()` to glob_inputs.rs for path-only collection
- Thread `cache_dir` through `ExecutionContext` and `execute_spawn`

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: branchseer

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

@@ -109,6 +109,58 @@ pub fn compute_globbed_inputs(
     Ok(result)
 }
 
+/// Collect file paths matching positive globs, filtered by negative globs.
+///
+/// Like [`compute_globbed_inputs`] but only collects paths (no hashing).
+/// Used for determining which output files to archive.
+pub fn collect_glob_paths(
+    workspace_root: &AbsolutePath,
+    positive_globs: &std::collections::BTreeSet<Str>,
+    negative_globs: &std::collections::BTreeSet<Str>,
+) -> anyhow::Result<Vec<RelativePathBuf>> {
+    if positive_globs.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let negatives: Vec<Glob<'static>> = negative_globs
+        .iter()
+        .map(|p| Ok(Glob::new(p.as_str())?.into_owned()))
+        .collect::<anyhow::Result<_>>()?;
+    let negation = wax::any(negatives)?;
+
+    let mut result = Vec::new();
+
+    for pattern in positive_globs {
+        let glob = Glob::new(pattern.as_str())?.into_owned();
+        let walk = glob.walk(workspace_root.as_path());
+        for entry in walk.not(negation.clone())? {
+            let entry = match entry {
+                Ok(entry) => entry,
+                Err(err) => {
+                    let io_err: io::Error = err.into();
+                    if io_err.kind() == io::ErrorKind::NotFound {
+                        continue;
+                    }
+                    return Err(io_err.into());
+                }
+            };
+            if !entry.file_type().is_file() {
+                continue;
+            }
+            let path = entry.path();
+            let Some(stripped) = path.strip_prefix(workspace_root.as_path()).ok() else {
+                continue;
+            };
+            let relative = RelativePathBuf::new(stripped)?;
+            result.push(relative);
+        }
+    }
+
+    result.sort();
+    result.dedup();
+    Ok(result)
+}
+
 #[expect(clippy::disallowed_types, reason = "receives std::path::Path from wax glob walker")]
 fn hash_file_content(path: &std::path::Path) -> io::Result<u64> {
     super::hash::hash_content(io::BufReader::new(File::open(path)?))

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

@@ -7,22 +7,24 @@ use std::{cell::RefCell, collections::BTreeMap, io::Write as _, process::Stdio,
 
 use futures_util::{FutureExt, StreamExt, future::LocalBoxFuture, stream::FuturesUnordered};
 use petgraph::Direction;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use tokio::sync::Semaphore;
 use tokio_util::sync::CancellationToken;
-use vite_path::AbsolutePath;
+use vite_path::{AbsolutePath, RelativePathBuf};
+use vite_str::Str;
 use vite_task_plan::{
     ExecutionGraph, ExecutionItemDisplay, ExecutionItemKind, LeafExecutionKind, SpawnCommand,
     SpawnExecution, execution_graph::ExecutionNodeIndex,
 };
+use wax::Program as _;
 
 use self::{
     fingerprint::PostRunFingerprint,
     glob_inputs::compute_globbed_inputs,
     spawn::{SpawnResult, TrackedPathAccesses, spawn_with_tracking},
 };
 use super::{
-    cache::{CacheEntryValue, ExecutionCache},
+    cache::{CacheEntryValue, ExecutionCache, archive},
     event::{
         CacheDisabledReason, CacheErrorKind, CacheNotUpdatedReason, CacheStatus, CacheUpdateStatus,
         ExecutionError,
@@ -67,6 +69,8 @@ struct ExecutionContext<'a> {
     /// Base path for resolving relative paths in cache entries.
     /// Typically the workspace root.
     cache_base_path: &'a Arc<AbsolutePath>,
+    /// Directory where cache files (db, archives) are stored.
+    cache_dir: &'a AbsolutePath,
     /// Token cancelled when a task fails. Kills in-flight child processes
     /// (via `start_kill` in spawn.rs), prevents scheduling new tasks, and
     /// prevents caching results of concurrently-running tasks.
@@ -228,6 +232,7 @@ impl ExecutionContext<'_> {
                     spawn_execution,
                     self.cache,
                     self.cache_base_path,
+                    self.cache_dir,
                     self.fast_fail_token.clone(),
                     self.interrupt_token.clone(),
                 )
@@ -269,6 +274,7 @@ pub async fn execute_spawn(
     spawn_execution: &SpawnExecution,
     cache: &ExecutionCache,
     cache_base_path: &Arc<AbsolutePath>,
+    cache_dir: &AbsolutePath,
     fast_fail_token: CancellationToken,
     interrupt_token: CancellationToken,
 ) -> SpawnOutcome {
@@ -341,6 +347,18 @@ pub async fn execute_spawn(
             let _ = writer.write_all(&output.content);
             let _ = writer.flush();
         }
+        // Restore output files from the cached archive
+        if let Some(ref archive_name) = cached.output_archive {
+            let archive_path = cache_dir.join(archive_name.as_str());
+            if let Err(err) = archive::extract_output_archive(cache_base_path, &archive_path) {
+                leaf_reporter.finish(
+                    None,
+                    CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheHit),
+                    Some(ExecutionError::Cache { kind: CacheErrorKind::Lookup, source: err }),
+                );
+                return SpawnOutcome::Failed;
+            }
+        }
         leaf_reporter.finish(
             None,
             CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheHit),
@@ -385,15 +403,16 @@ pub async fn execute_spawn(
 
     // 5. Piped mode: execute spawn with tracking, streaming output to writers.
     //    - std_outputs: always captured when caching is enabled (for cache replay)
-    //    - path_accesses: only tracked when includes_auto is true (fspy inference)
+    //    - path_accesses: tracked when input or output uses auto (fspy inference)
     let (mut std_outputs, mut path_accesses, cache_metadata_and_inputs) =
         cache_metadata.map_or((None, None, None), |cache_metadata| {
-            // On musl targets, LD_PRELOAD-based tracking is unavailable but seccomp
-            // unotify provides equivalent file access tracing.
-            let path_accesses = if cache_metadata.input_config.includes_auto {
+            // Enable fspy when either input or output needs auto-detection.
+            let needs_fspy = cache_metadata.input_config.includes_auto
+                || cache_metadata.output_config.includes_auto;
+            let path_accesses = if needs_fspy {
                 Some(TrackedPathAccesses::default())
             } else {
-                None // Skip fspy when inference is disabled or unavailable
+                None // Skip fspy when inference is disabled for both input and output
             };
             (Some(Vec::new()), path_accesses, Some((cache_metadata, globbed_inputs)))
         });
@@ -451,71 +470,95 @@ pub async fn execute_spawn(
 
     // 6. Update cache if successful and determine cache update status.
     //    Errors during cache update are terminal (reported through finish).
-    let (cache_update_status, cache_error) = if let Some((cache_metadata, globbed_inputs)) =
-        cache_metadata_and_inputs
-    {
-        let cancelled = fast_fail_token.is_cancelled() || interrupt_token.is_cancelled();
-        if cancelled {
-            // Cancelled (Ctrl-C or sibling failure) — result is untrustworthy
-            (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::Cancelled), None)
-        } else if result.exit_status.success() {
-            // Check for read-write overlap: if the task wrote to any file it also
-            // read, the inputs were modified during execution — don't cache.
-            // Note: this only checks fspy-inferred reads, not globbed_inputs keys.
-            // A task that writes to a glob-matched file without reading it causes
-            // perpetual cache misses (glob detects the hash change) but not a
-            // correctness bug, so we don't handle that case here.
-            if let Some(path) = path_accesses
-                .as_ref()
-                .and_then(|pa| pa.path_reads.keys().find(|p| pa.path_writes.contains(*p)))
-            {
-                (
-                    CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::InputModified {
-                        path: path.clone(),
-                    }),
-                    None,
-                )
-            } else {
-                // path_reads is empty when inference is disabled (path_accesses is None)
-                let empty_path_reads = HashMap::default();
-                let path_reads =
-                    path_accesses.as_ref().map_or(&empty_path_reads, |pa| &pa.path_reads);
-
-                // Execution succeeded — attempt to create fingerprint and update cache.
-                // Paths already in globbed_inputs are skipped: Rule 1 (above) guarantees
-                // no input modification, so the prerun hash is the correct post-exec hash.
-                match PostRunFingerprint::create(path_reads, cache_base_path, &globbed_inputs) {
-                    Ok(post_run_fingerprint) => {
-                        let new_cache_value = CacheEntryValue {
-                            post_run_fingerprint,
-                            std_outputs: std_outputs.unwrap_or_default().into(),
-                            duration: result.duration,
-                            globbed_inputs,
-                        };
-                        match cache.update(cache_metadata, new_cache_value).await {
-                            Ok(()) => (CacheUpdateStatus::Updated, None),
-                            Err(err) => (
-                                CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
-                                Some(ExecutionError::Cache {
-                                    kind: CacheErrorKind::Update,
-                                    source: err,
-                                }),
-                            ),
+    let (cache_update_status, cache_error) = 'cache_update: {
+        if let Some((cache_metadata, globbed_inputs)) = cache_metadata_and_inputs {
+            let cancelled = fast_fail_token.is_cancelled() || interrupt_token.is_cancelled();
+            if cancelled {
+                // Cancelled (Ctrl-C or sibling failure) — result is untrustworthy
+                (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::Cancelled), None)
+            } else if result.exit_status.success() {
+                // Check for read-write overlap: if the task wrote to any file it also
+                // read, the inputs were modified during execution — don't cache.
+                // Note: this only checks fspy-inferred reads, not globbed_inputs keys.
+                // A task that writes to a glob-matched file without reading it causes
+                // perpetual cache misses (glob detects the hash change) but not a
+                // correctness bug, so we don't handle that case here.
+                if let Some(path) = path_accesses
+                    .as_ref()
+                    .and_then(|pa| pa.path_reads.keys().find(|p| pa.path_writes.contains(*p)))
+                {
+                    (
+                        CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::InputModified {
+                            path: path.clone(),
+                        }),
+                        None,
+                    )
+                } else {
+                    // path_reads is empty when inference is disabled (path_accesses is None)
+                    let empty_path_reads = HashMap::default();
+                    let path_reads =
+                        path_accesses.as_ref().map_or(&empty_path_reads, |pa| &pa.path_reads);
+
+                    // Execution succeeded — attempt to create fingerprint and update cache.
+                    // Paths already in globbed_inputs are skipped: Rule 1 (above) guarantees
+                    // no input modification, so the prerun hash is the correct post-exec hash.
+                    match PostRunFingerprint::create(path_reads, cache_base_path, &globbed_inputs) {
+                        Ok(post_run_fingerprint) => {
+                            // Collect output files and create archive
+                            let output_archive = match collect_and_archive_outputs(
+                                cache_metadata,
+                                path_accesses.as_ref(),
+                                cache_base_path,
+                                cache_dir,
+                            ) {
+                                Ok(archive) => archive,
+                                Err(err) => {
+                                    break 'cache_update (
+                                        CacheUpdateStatus::NotUpdated(
+                                            CacheNotUpdatedReason::CacheDisabled,
+                                        ),
+                                        Some(ExecutionError::Cache {
+                                            kind: CacheErrorKind::Update,
+                                            source: err,
+                                        }),
+                                    );
+                                }
+                            };
+
+                            let new_cache_value = CacheEntryValue {
+                                post_run_fingerprint,
+                                std_outputs: std_outputs.unwrap_or_default().into(),
+                                duration: result.duration,
+                                globbed_inputs,
+                                output_archive,
+                            };
+                            match cache.update(cache_metadata, new_cache_value).await {
+                                Ok(()) => (CacheUpdateStatus::Updated, None),
+                                Err(err) => (
+                                    CacheUpdateStatus::NotUpdated(
+                                        CacheNotUpdatedReason::CacheDisabled,
+                                    ),
+                                    Some(ExecutionError::Cache {
+                                        kind: CacheErrorKind::Update,
+                                        source: err,
+                                    }),
+                                ),
+                            }
                         }
+                        Err(err) => (
+                            CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
+                            Some(ExecutionError::PostRunFingerprint(err)),
+                        ),
                     }
-                    Err(err) => (
-                        CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
-                        Some(ExecutionError::PostRunFingerprint(err)),
-                    ),
                 }
+            } else {
+                // Execution failed with non-zero exit status — don't update cache
+                (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus), None)
             }
         } else {
-            // Execution failed with non-zero exit status — don't update cache
-            (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus), None)
+            // Caching was disabled for this task
+            (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled), None)
         }
-    } else {
-        // Caching was disabled for this task
-        (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled), None)
     };
 
     // 7. Finish the leaf execution with the result and optional cache error.
@@ -607,6 +650,68 @@ async fn spawn_inherited(
     Ok(SpawnResult { exit_status, duration: start.elapsed() })
 }
 
+/// Collect output files and create a tar.zst archive in the cache directory.
+///
+/// Output files are determined by:
+/// - fspy-tracked writes (when `output_config.includes_auto` is true)
+/// - Positive output globs (always, if configured)
+/// - Filtered by negative output globs
+///
+/// Returns `Some(archive_filename)` if files were archived, `None` if no output files.
+fn collect_and_archive_outputs(
+    cache_metadata: &vite_task_plan::cache_metadata::CacheMetadata,
+    path_accesses: Option<&TrackedPathAccesses>,
+    workspace_root: &AbsolutePath,
+    cache_dir: &AbsolutePath,
+) -> anyhow::Result<Option<Str>> {
+    let output_config = &cache_metadata.output_config;
+
+    // Collect output files from auto-detection (fspy writes)
+    let mut output_files: FxHashSet<RelativePathBuf> = FxHashSet::default();
+
+    if output_config.includes_auto
+        && let Some(pa) = path_accesses
+    {
+        output_files.extend(pa.path_writes.iter().cloned());
+    }
+
+    // Collect output files from positive globs
+    if !output_config.positive_globs.is_empty() {
+        let glob_paths = glob_inputs::collect_glob_paths(
+            workspace_root,
+            &output_config.positive_globs,
+            &output_config.negative_globs,
+        )?;
+        output_files.extend(glob_paths);
+    }
+
+    // Apply negative globs to auto-detected files
+    if output_config.includes_auto && !output_config.negative_globs.is_empty() {
+        let negatives: Vec<wax::Glob<'static>> = output_config
+            .negative_globs
+            .iter()
+            .map(|p| Ok(wax::Glob::new(p.as_str())?.into_owned()))
+            .collect::<anyhow::Result<_>>()?;
+        output_files.retain(|path| !negatives.iter().any(|neg| neg.is_match(path.as_str())));
+    }
+
+    if output_files.is_empty() {
+        return Ok(None);
+    }
+
+    // Sort for deterministic archive content
+    let mut sorted_files: Vec<RelativePathBuf> = output_files.into_iter().collect();
+    sorted_files.sort();
+
+    // Create archive with UUID filename
+    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, &sorted_files, &archive_path)?;
+
+    Ok(Some(archive_name))
+}
+
 /// Win32 Job Object utilities for process tree management.
 ///
 /// On Windows, `TerminateProcess` only kills the direct child process, not its
@@ -733,6 +838,7 @@ impl Session<'_> {
             reporter: &reporter,
             cache,
             cache_base_path: &self.workspace_path,
+            cache_dir: &self.cache_path,
             fast_fail_token: CancellationToken::new(),
             interrupt_token,
         };

crates/vite_task/src/session/mod.rs

@@ -676,6 +676,7 @@ impl<'a> Session<'a> {
             &spawn_execution,
             cache,
             &self.workspace_path,
+            &self.cache_path,
             tokio_util::sync::CancellationToken::new(),
             tokio_util::sync::CancellationToken::new(),
         )