feat: add stdin suggestion to reporter for spawned tasks

Add StdinSuggestion enum to LeafExecutionReporter trait so reporters can
suggest whether child processes should inherit stdin or use /dev/null.

PlainReporter always suggests inherited stdin (single synthetic execution).
LabeledReporter suggests inherited only when the graph has exactly one
spawn leaf (computed via count_spawn_leaves at build time).

The actual stdin is inherited only when BOTH conditions hold:
- Reporter suggests Inherited
- Task has no cache metadata (caching disabled)

This prevents non-deterministic user input from corrupting cached output
while allowing interactive stdin for single uncached tasks.

Includes 15 unit tests for stdin suggestion logic and 3 E2E snapshot
tests verifying stdin inheritance/null behavior end-to-end.

Author: branchseer

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

@@ -1,7 +1,7 @@
 pub mod fingerprint;
 pub mod spawn;
 
-use std::sync::Arc;
+use std::{process::Stdio, sync::Arc};
 
 use futures_util::FutureExt;
 use petgraph::{algo::toposort, stable_graph::StableGraph};
@@ -23,7 +23,7 @@ use super::{
     },
     reporter::{
         ExitStatus, GraphExecutionReporter, GraphExecutionReporterBuilder, LeafExecutionPath,
-        LeafExecutionReporter,
+        LeafExecutionReporter, StdinSuggestion,
     },
 };
 use crate::{Session, session::execute::spawn::SpawnTrackResult};
@@ -252,6 +252,18 @@ pub async fn execute_spawn(
     let mut track_result_with_cache_metadata =
         cache_metadata.map(|cache_metadata| (SpawnTrackResult::default(), cache_metadata));
 
+    // Determine the child process's stdin mode based on:
+    // - The reporter's suggestion (inherited only when appropriate, e.g., single task)
+    // - Whether caching is disabled (inherited stdin would make output non-deterministic,
+    //   breaking cache semantics)
+    let stdin = if leaf_reporter.stdin_suggestion() == StdinSuggestion::Inherited
+        && cache_metadata.is_none()
+    {
+        Stdio::inherit()
+    } else {
+        Stdio::null()
+    };
+
     // Execute command with tracking, streaming output in real-time via the reporter
     #[expect(
         clippy::large_futures,
@@ -260,6 +272,7 @@ pub async fn execute_spawn(
     let result = match spawn_with_tracking(
         &spawn_execution.spawn_command,
         cache_base_path,
+        stdin,
         |kind, content| {
             leaf_reporter.output(
                 match kind {

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

@@ -62,6 +62,7 @@ pub struct SpawnTrackResult {
 /// Returns the execution result including captured outputs, exit status,
 /// and tracked file accesses.
 ///
+/// - `stdin` controls the child process's stdin (typically `Stdio::null()` or `Stdio::inherit()`).
 /// - `on_output` is called in real-time as stdout/stderr data arrives.
 /// - `track_result` if provided, will be populated with captured outputs and path accesses for caching. If `None`, tracking is disabled.
 #[expect(
@@ -71,6 +72,7 @@ pub struct SpawnTrackResult {
 pub async fn spawn_with_tracking<F>(
     spawn_command: &SpawnCommand,
     workspace_root: &AbsolutePath,
+    stdin: Stdio,
     mut on_output: F,
     track_result: Option<&mut SpawnTrackResult>,
 ) -> anyhow::Result<SpawnResult>
@@ -90,7 +92,7 @@ where
     cmd.args(spawn_command.args.iter().map(vite_str::Str::as_str));
     cmd.envs(spawn_command.all_envs.iter());
     cmd.current_dir(&*spawn_command.cwd);
-    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
+    cmd.stdin(stdin).stdout(Stdio::piped()).stderr(Stdio::piped());
 
     let mut tracking_state = if let Some(track_result) = track_result {
         // track_result is Some. Spawn with tracking enabled