feat(session): add CacheUpdateStatus to ExecutionEventKind::Finish

Add CacheUpdateStatus enum to track whether cache was updated after task
execution and why. This provides visibility into cache behavior in the
Finish event.

- Add CacheNotUpdatedReason enum with CacheHit, CacheDisabled, NonZeroExitStatus
- Add CacheUpdateStatus enum with Updated and NotUpdated variants
- Include cache_update_status in ExecutionEventKind::Finish
- Update all Finish event emissions to include appropriate status

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

Author: branchseer

crates/vite_task/src/session/event.rs

@@ -19,6 +19,24 @@ pub enum CacheDisabledReason {
     CycleDetected,
 }
 
+#[derive(Debug)]
+pub enum CacheNotUpdatedReason {
+    /// Cache was hit - task was replayed from cache, no update needed
+    CacheHit,
+    /// Caching was disabled for this task
+    CacheDisabled,
+    /// Execution exited with non-zero status
+    NonZeroExitStatus,
+}
+
+#[derive(Debug)]
+pub enum CacheUpdateStatus {
+    /// Cache was successfully updated with new fingerprint and outputs
+    Updated,
+    /// Cache was not updated (with reason)
+    NotUpdated(CacheNotUpdatedReason),
+}
+
 #[derive(Debug)]
 pub enum CacheStatus {
     Disabled(CacheDisabledReason),
@@ -50,5 +68,5 @@ pub enum ExecutionEventKind {
     Start { display: Option<ExecutionItemDisplay>, cache_status: CacheStatus },
     Output { kind: OutputKind, content: BString },
     Error { message: String },
-    Finish { status: Option<i32> },
+    Finish { status: Option<i32>, cache_update_status: CacheUpdateStatus },
 }

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

@@ -18,8 +18,8 @@ use self::{
 use super::{
     cache::{CommandCacheValue, ExecutionCache},
     event::{
-        CacheDisabledReason, CacheStatus, ExecutionEvent, ExecutionEventKind, ExecutionId,
-        ExecutionItemDisplay, OutputKind,
+        CacheDisabledReason, CacheNotUpdatedReason, CacheStatus, CacheUpdateStatus, ExecutionEvent,
+        ExecutionEventKind, ExecutionId, ExecutionItemDisplay, OutputKind,
     },
     reporter::{ExitStatus, Reporter},
 };
@@ -153,10 +153,15 @@ impl ExecutionContext<'_> {
                     },
                 });
 
-                // Emit Finish WITHOUT cache_status (already in Start event)
+                // Emit Finish with CacheDisabled status (in-process executions don't cache)
                 self.event_handler.handle_event(ExecutionEvent {
                     execution_id,
-                    kind: ExecutionEventKind::Finish { status: Some(0) },
+                    kind: ExecutionEventKind::Finish {
+                        status: Some(0),
+                        cache_update_status: CacheUpdateStatus::NotUpdated(
+                            CacheNotUpdatedReason::CacheDisabled,
+                        ),
+                    },
                 });
             }
             LeafExecutionKind::Spawn(spawn_execution) => {
@@ -228,10 +233,15 @@ impl ExecutionContext<'_> {
                     },
                 });
             }
-            // Emit Finish without cache_status (status already in Start event)
+            // Emit Finish with CacheHit status (no cache update needed)
             self.event_handler.handle_event(ExecutionEvent {
                 execution_id,
-                kind: ExecutionEventKind::Finish { status: Some(0) },
+                kind: ExecutionEventKind::Finish {
+                    status: Some(0),
+                    cache_update_status: CacheUpdateStatus::NotUpdated(
+                        CacheNotUpdatedReason::CacheHit,
+                    ),
+                },
             });
             return Ok(());
         }
@@ -276,51 +286,62 @@ impl ExecutionContext<'_> {
             }
         };
 
-        // 5. Update cache if successful
-        //    Only update cache if: (a) tracking was enabled, and (b) execution succeeded
-        if let Some((track_result, cache_metadata)) = track_result_with_cache_metadata
-            && result.exit_status.success()
+        // 5. Update cache if successful and determine cache update status
+        let cache_update_status = if let Some((track_result, cache_metadata)) =
+            track_result_with_cache_metadata
         {
-            let fingerprint_ignores =
-                cache_metadata.spawn_fingerprint.fingerprint_ignores().map(|v| v.as_slice());
-            match PostRunFingerprint::create(
-                &track_result.path_reads,
-                &*self.cache_base_path,
-                fingerprint_ignores,
-            ) {
-                Ok(post_run_fingerprint) => {
-                    let cache_value = CommandCacheValue {
-                        post_run_fingerprint,
-                        std_outputs: track_result.std_outputs.clone().into(),
-                        duration: result.duration,
-                    };
-                    if let Err(err) = self.cache.update(cache_metadata, cache_value).await {
+            if result.exit_status.success() {
+                // Execution succeeded, attempt cache update
+                let fingerprint_ignores =
+                    cache_metadata.spawn_fingerprint.fingerprint_ignores().map(|v| v.as_slice());
+                match PostRunFingerprint::create(
+                    &track_result.path_reads,
+                    &*self.cache_base_path,
+                    fingerprint_ignores,
+                ) {
+                    Ok(post_run_fingerprint) => {
+                        let cache_value = CommandCacheValue {
+                            post_run_fingerprint,
+                            std_outputs: track_result.std_outputs.clone().into(),
+                            duration: result.duration,
+                        };
+                        if let Err(err) = self.cache.update(cache_metadata, cache_value).await {
+                            self.event_handler.handle_event(ExecutionEvent {
+                                execution_id,
+                                kind: ExecutionEventKind::Error {
+                                    message: format!("Failed to update cache: {err}"),
+                                },
+                            });
+                            return Err(ExecutionAborted);
+                        }
+                        CacheUpdateStatus::Updated
+                    }
+                    Err(err) => {
                         self.event_handler.handle_event(ExecutionEvent {
                             execution_id,
                             kind: ExecutionEventKind::Error {
-                                message: format!("Failed to update cache: {err}"),
+                                message: format!("Failed to create post-run fingerprint: {err}"),
                             },
                         });
                         return Err(ExecutionAborted);
                     }
                 }
-                Err(err) => {
-                    self.event_handler.handle_event(ExecutionEvent {
-                        execution_id,
-                        kind: ExecutionEventKind::Error {
-                            message: format!("Failed to create post-run fingerprint: {err}"),
-                        },
-                    });
-                    return Err(ExecutionAborted);
-                }
+            } else {
+                // Execution failed with non-zero exit status, don't update cache
+                CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus)
             }
-        }
+        } else {
+            // Caching was disabled for this task
+            CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled)
+        };
 
-        // 6. Emit finish WITHOUT cache_status
-        //    Cache status was already emitted in Start event
+        // 6. Emit finish with cache_update_status
         self.event_handler.handle_event(ExecutionEvent {
             execution_id,
-            kind: ExecutionEventKind::Finish { status: result.exit_status.code() },
+            kind: ExecutionEventKind::Finish {
+                status: result.exit_status.code(),
+                cache_update_status,
+            },
         });
 
         Ok(())

crates/vite_task/src/session/reporter.rs

@@ -489,7 +489,7 @@ impl<W: Write> Reporter for LabeledReporter<W> {
             ExecutionEventKind::Error { message } => {
                 self.handle_error(event.execution_id, message);
             }
-            ExecutionEventKind::Finish { status } => {
+            ExecutionEventKind::Finish { status, cache_update_status: _ } => {
                 self.handle_finish(event.execution_id, status);
             }
         }