feat(cache): add output_config to cache key, output_archive to value, and archive module

- Add `output_config` to `CacheEntryKey` so changing output config invalidates cache
- Add `output_archive: Option<Str>` to `CacheEntryValue` for the tar.zst filename
- Bump DB version from 10 to 11 (resets old databases)
- Add `FingerprintMismatch::OutputConfig` variant with display support
- Create `archive.rs` module with tar+zstd create/extract operations

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

Author: branchseer

crates/vite_task/docs/task-cache.md

@@ -92,7 +92,7 @@ The cache entry key uniquely identifies a command execution context:
 ```rust
 pub struct CacheEntryKey {
     pub spawn_fingerprint: SpawnFingerprint,
-    pub input_config: ResolvedInputConfig,
+    pub input_config: ResolvedGlobConfig,
 }
 ```
 
@@ -303,7 +303,7 @@ Cache entries are serialized using `bincode` for efficient storage.
 │  ──────────────────────                                      │
 │    CacheEntryKey {                                           │
 │        spawn_fingerprint: SpawnFingerprint { ... },          │
-│        input_config: ResolvedInputConfig { ... },            │
+│        input_config: ResolvedGlobConfig { ... },            │
 │    }                                                         │
 │    ExecutionCacheKey::UserTask {                              │
 │        task_name: "build",                                   │

crates/vite_task/src/session/cache/archive.rs

@@ -0,0 +1,61 @@
+//! Output archive creation and extraction using tar + zstd compression.
+
+use std::fs::File;
+
+use vite_path::{AbsolutePath, RelativePathBuf};
+
+/// Create a tar.zst archive from workspace-relative output file paths.
+///
+/// Files that no longer exist are silently skipped (the task may delete
+/// temporary files during execution).
+///
+/// # Errors
+///
+/// Returns an error if creating the archive file or adding entries fails.
+pub fn create_output_archive(
+    workspace_root: &AbsolutePath,
+    output_files: &[RelativePathBuf],
+    archive_path: &AbsolutePath,
+) -> anyhow::Result<()> {
+    let file = File::create(archive_path.as_path())?;
+    let encoder = zstd::Encoder::new(file, 0)?.auto_finish();
+    let mut builder = tar::Builder::new(encoder);
+
+    for rel_path in output_files {
+        let abs_path = workspace_root.join(rel_path);
+        // Skip files that no longer exist (task may delete temp files)
+        if !abs_path.as_path().exists() {
+            continue;
+        }
+        let metadata = std::fs::metadata(abs_path.as_path())?;
+        if metadata.is_file() {
+            let mut file = File::open(abs_path.as_path())?;
+            let mut header = tar::Header::new_gnu();
+            header.set_metadata(&metadata);
+            header.set_cksum();
+            builder.append_data(&mut header, rel_path.as_str(), &mut file)?;
+        }
+    }
+
+    builder.finish()?;
+    Ok(())
+}
+
+/// Extract a tar.zst archive, restoring files relative to workspace root.
+///
+/// Parent directories are created automatically. Existing files are overwritten.
+///
+/// # Errors
+///
+/// Returns an error if opening the archive or extracting entries fails.
+pub fn extract_output_archive(
+    workspace_root: &AbsolutePath,
+    archive_path: &AbsolutePath,
+) -> anyhow::Result<()> {
+    let file = File::open(archive_path.as_path())?;
+    let decoder = zstd::Decoder::new(file)?;
+    let mut archive = tar::Archive::new(decoder);
+
+    archive.unpack(workspace_root.as_path())?;
+    Ok(())
+}

crates/vite_task/src/session/cache/display.rs

@@ -174,6 +174,7 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
                     }
                 }
                 FingerprintMismatch::InputConfig => "input configuration changed",
+                FingerprintMismatch::OutputConfig => "output configuration changed",
                 FingerprintMismatch::InputChanged { kind, path } => {
                     let desc = format_input_change_str(*kind, path.as_str());
                     return Some(vite_str::format!("○ cache miss: {desc}, executing"));

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

@@ -1,5 +1,6 @@
 //! Execution cache for storing and retrieving cached command results.
 
+pub mod archive;
 pub mod display;
 
 use std::{collections::BTreeMap, fmt::Display, fs::File, io::Write, sync::Arc, time::Duration};
@@ -15,7 +16,8 @@ use rusqlite::{Connection, OptionalExtension as _, config::DbConfig};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 use vite_path::{AbsolutePath, RelativePathBuf};
-use vite_task_graph::config::ResolvedInputConfig;
+use vite_str::Str;
+use vite_task_graph::config::ResolvedGlobConfig;
 use vite_task_plan::cache_metadata::{CacheMetadata, ExecutionCacheKey, SpawnFingerprint};
 
 use super::execute::{fingerprint::PostRunFingerprint, spawn::StdOutput};
@@ -38,14 +40,18 @@ pub struct CacheEntryKey {
     pub spawn_fingerprint: SpawnFingerprint,
     /// Resolved input configuration that affects cache behavior.
     /// Glob patterns are workspace-root-relative.
-    pub input_config: ResolvedInputConfig,
+    pub input_config: ResolvedGlobConfig,
+    /// Resolved output configuration that affects cache restoration.
+    /// Glob patterns are workspace-root-relative.
+    pub output_config: ResolvedGlobConfig,
 }
 
 impl CacheEntryKey {
     fn from_metadata(cache_metadata: &CacheMetadata) -> Self {
         Self {
             spawn_fingerprint: cache_metadata.spawn_fingerprint.clone(),
             input_config: cache_metadata.input_config.clone(),
+            output_config: cache_metadata.output_config.clone(),
         }
     }
 }
@@ -64,6 +70,9 @@ pub struct CacheEntryValue {
     /// Path is relative to workspace root, value is `xxHash3_64` of file content.
     /// Stored in the value (not the key) so changes can be detected and reported.
     pub globbed_inputs: BTreeMap<RelativePathBuf, u64>,
+    /// Filename of the output archive (e.g. `{uuid}.tar.zst`) stored alongside
+    /// `cache.db` in the cache directory. `None` if no output files were produced.
+    pub output_archive: Option<Str>,
 }
 
 #[derive(Debug)]
@@ -105,6 +114,8 @@ pub enum FingerprintMismatch {
     },
     /// Found a previous cache entry key for the same task, but `input_config` differs.
     InputConfig,
+    /// Found a previous cache entry key for the same task, but `output_config` differs.
+    OutputConfig,
 
     InputChanged {
         kind: InputChangeKind,
@@ -121,6 +132,9 @@ impl Display for FingerprintMismatch {
             Self::InputConfig => {
                 write!(f, "input configuration changed")
             }
+            Self::OutputConfig => {
+                write!(f, "output configuration changed")
+            }
             Self::InputChanged { kind, path } => {
                 write!(f, "{}", display::format_input_change_str(*kind, path.as_str()))
             }
@@ -168,16 +182,16 @@ impl ExecutionCache {
                         "CREATE TABLE task_fingerprints (key BLOB PRIMARY KEY, value BLOB);",
                         (),
                     )?;
-                    conn.execute("PRAGMA user_version = 10", ())?;
+                    conn.execute("PRAGMA user_version = 11", ())?;
                 }
-                1..=9 => {
+                1..=10 => {
                     // old internal db version. reset
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, true)?;
                     conn.execute("VACUUM", ())?;
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, false)?;
                 }
-                10 => break, // current version
-                11.. => {
+                11 => break, // current version
+                12.. => {
                     return Err(anyhow::anyhow!("Unrecognized database version: {user_version}"));
                 }
             }
@@ -233,11 +247,20 @@ impl ExecutionCache {
             self.get_cache_key_by_execution_key(execution_cache_key).await?
         {
             // Destructure to ensure we handle all fields when new ones are added
-            let CacheEntryKey { spawn_fingerprint: old_spawn_fingerprint, input_config: _ } =
-                old_cache_key;
+            let CacheEntryKey {
+                spawn_fingerprint: old_spawn_fingerprint,
+                input_config: old_input_config,
+                output_config: old_output_config,
+            } = old_cache_key;
             let mismatch = if old_spawn_fingerprint == *spawn_fingerprint {
-                // spawn fingerprint is the same but input_config or glob_base changed
-                FingerprintMismatch::InputConfig
+                // spawn fingerprint is the same but input_config or output_config changed
+                if old_input_config != cache_metadata.input_config {
+                    FingerprintMismatch::InputConfig
+                } else if old_output_config != cache_metadata.output_config {
+                    FingerprintMismatch::OutputConfig
+                } else {
+                    FingerprintMismatch::InputConfig
+                }
             } else {
                 FingerprintMismatch::SpawnFingerprint {
                     old: old_spawn_fingerprint,

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

@@ -254,7 +254,9 @@ impl SavedCacheMissReason {
                 FingerprintMismatch::SpawnFingerprint { old, new } => {
                     Self::SpawnFingerprintChanged(detect_spawn_fingerprint_changes(old, new))
                 }
-                FingerprintMismatch::InputConfig => Self::ConfigChanged,
+                FingerprintMismatch::InputConfig | FingerprintMismatch::OutputConfig => {
+                    Self::ConfigChanged
+                }
                 FingerprintMismatch::InputChanged { kind, path } => {
                     Self::InputChanged { kind: *kind, path: Str::from(path.as_str()) }
                 }