fix: handle tasks that close stdio without exiting

Add cancellation-aware wait after pipe reads in spawn_with_tracking.
If a child closes stdout/stderr but stays alive (e.g., daemonizes),
the pipe reads EOF but child.wait() would block forever without
cancellation support.

Add --daemonize flag to barrier test tool and e2e test verifying
that daemonized concurrent tasks are properly killed on failure.

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

Author: branchseer

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

@@ -208,8 +208,12 @@ pub async fn spawn_with_tracking(
     }
 
     // Wait for process termination and collect results.
+    // The child may have closed its pipes without exiting (e.g., daemonized),
+    // so we still need a cancellation arm here.
     match child_wait {
         ChildWait::Fspy(tracked_child) => {
+            // fspy's wait_handle already monitors the cancellation token internally,
+            // so no additional select! is needed here.
             let termination = tracked_child.wait_handle.await?;
             let duration = start.elapsed();
 
@@ -285,7 +289,13 @@ pub async fn spawn_with_tracking(
             Ok(SpawnResult { exit_status: termination.status, duration })
         }
         ChildWait::Tokio(mut child) => {
-            let exit_status = child.wait().await?;
+            let exit_status = tokio::select! {
+                status = child.wait() => status?,
+                () = cancellation_token.cancelled() => {
+                    child.start_kill()?;
+                    child.wait().await?
+                }
+            };
             Ok(SpawnResult { exit_status, duration: start.elapsed() })
         }
     }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/concurrent-execution/packages/a/package.json

@@ -2,6 +2,7 @@
   "name": "@concurrent/a",
   "scripts": {
     "build": "barrier ../../.barrier sync 2",
-    "test": "barrier ../../.barrier test-sync 2 --exit=1"
+    "test": "barrier ../../.barrier test-sync 2 --exit=1",
+    "daemon": "barrier ../../.barrier daemon-sync 2 --exit=1"
   }
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/concurrent-execution/packages/b/package.json

@@ -2,6 +2,7 @@
   "name": "@concurrent/b",
   "scripts": {
     "build": "barrier ../../.barrier sync 2",
-    "test": "barrier ../../.barrier test-sync 2 --hang"
+    "test": "barrier ../../.barrier test-sync 2 --hang",
+    "daemon": "barrier ../../.barrier daemon-sync 2 --daemonize"
   }
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/concurrent-execution/snapshots.toml

@@ -20,3 +20,10 @@ steps = ["vt run -r test"]
 [[e2e]]
 name = "failure kills concurrent cached tasks"
 steps = ["vt run -r --cache test"]
+
+# Task b closes stdout/stderr after the barrier but stays alive (daemonizes).
+# The pipe reads EOF but the process doesn't exit. The runner must still be
+# able to kill it via the cancellation token + Job Object.
+[[e2e]]
+name = "failure kills daemonized concurrent tasks"
+steps = ["vt run -r --cache daemon"]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/concurrent-execution/snapshots/failure kills daemonized concurrent tasks.snap

@@ -0,0 +1,11 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+---
+[1]> vt run -r --cache daemon
+~/packages/a$ barrier ../../.barrier daemon-sync 2 --exit=1
+~/packages/b$ barrier ../../.barrier daemon-sync 2 --daemonize
+
+
+---
+vt run: 0/2 cache hit (0%), 2 failed. (Run `vt run --last-details` for full details)

packages/tools/src/barrier.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 
-// barrier <dir> <prefix> <count> [--exit=<code>] [--hang]
+// barrier <dir> <prefix> <count> [--exit=<code>] [--hang] [--daemonize]
 //
 // Cross-platform concurrency barrier for testing.
 // Creates <dir>/<prefix>_<pid>, then waits (via fs.watch) for <count> files
 // matching <prefix>_* to exist in <dir>.
 //
 // Options:
 //   --exit=<code>  Exit with the given code after the barrier is met.
-//   --hang         Block on stdin after the barrier is met (for kill tests).
+//   --hang         Keep process alive after the barrier (for kill tests).
+//   --daemonize    Close stdout/stderr but keep process alive (for daemon kill tests).
 //
 // If tasks run concurrently, all participants arrive and the barrier resolves.
 // If tasks run sequentially, the first participant waits forever (test timeout).
@@ -19,12 +20,15 @@ import path from 'node:path';
 const positional = [];
 let exitCode = 0;
 let hang = false;
+let daemonize = false;
 
 for (const arg of process.argv.slice(2)) {
   if (arg.startsWith('--exit=')) {
     exitCode = parseInt(arg.slice(7), 10);
   } else if (arg === '--hang') {
     hang = true;
+  } else if (arg === '--daemonize') {
+    daemonize = true;
   } else {
     positional.push(arg);
   }
@@ -44,6 +48,14 @@ function countMatches() {
 }
 
 function onBarrierMet() {
+  if (daemonize) {
+    // Close stdout/stderr but keep the process alive. Simulates a daemon that
+    // detaches from stdio — tests that the runner can still kill such processes.
+    process.stdout.end();
+    process.stderr.end();
+    setInterval(() => {}, 1 << 30);
+    return;
+  }
   if (hang) {
     // Keep the process alive indefinitely — killed via signal when the runner cancels.
     // Use setInterval rather than stdin.resume() for cross-platform reliability.