Add ctrl-c e2e test for SIGINT propagation to running tasks

Add a `vtt exit-on-ctrlc` subcommand and e2e fixture that verifies SIGINT
propagates to concurrent tasks when the user presses Ctrl+C. The test runs
two packages with `vt run -r dev` (using argv spawn mode), synchronizes
via milestone protocol, then sends ctrl-c and verifies both tasks handle it.

Changes:
- `vtt exit-on-ctrlc`: sets up ctrl-c handler, emits "ready" milestone,
  prints "ctrl-c received" and exits on SIGINT. On Windows, clears the
  inherited CONSOLE_IGNORE_CTRL_C flag (set by an ancestor process via
  CREATE_NEW_PROCESS_GROUP) before registering the handler.
- `vt main.rs`: register no-op ctrlc handler before tokio runtime so vt
  survives Ctrl+C and reports actual task exit status. Use process::exit
  to avoid Windows runtime cleanup issues.
- `ctrl-c` WriteKey variant for e2e test interactions (rename_all kebab-case)
- Fix `expect_milestone` to preserve unmatched milestones in a local buffer
  instead of dropping them via `take_unhandled_osc_sequences`
- Strip `^C` terminal echo and normalize `ctrl-c received` count in e2e
  redaction for cross-platform consistency
- Fix incorrect comment in pty_terminal test about CTRL_C ignore flag source

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

Author: branchseer

Cargo.lock

@@ -305,8 +305,12 @@ fn send_ctrl_c_interrupts_process() {
         // On macOS/Windows, use ctrlc which works fine (no .init_array/musl issue).
         #[cfg(not(target_os = "linux"))]
         {
-            // On Windows, clear the "ignore CTRL_C" flag set by Rust runtime
-            // so that CTRL_C_EVENT reaches the ctrlc handler.
+            // On Windows, an ancestor process may have been created with
+            // CREATE_NEW_PROCESS_GROUP, which implicitly sets the per-process
+            // CTRL_C ignore flag (CONSOLE_IGNORE_CTRL_C in PEB ConsoleFlags).
+            // This flag is inherited by all descendants and silently drops
+            // CTRL_C_EVENT before it reaches registered handlers. Clear it.
+            // Ref: https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
             #[cfg(windows)]
             {
                 // SAFETY: Declaring correct signature for SetConsoleCtrlHandler from kernel32.

crates/pty_terminal/tests/terminal.rs

@@ -1,4 +1,7 @@
-use std::io::{BufReader, Read};
+use std::{
+    collections::VecDeque,
+    io::{BufReader, Read},
+};
 
 pub use portable_pty::CommandBuilder;
 use pty_terminal::terminal::{PtyReader, Terminal};
@@ -25,6 +28,8 @@ pub struct TestTerminal {
 pub struct Reader {
     pty: BufReader<PtyReader>,
     child_handle: ChildHandle,
+    /// OSC sequences taken from the PTY but not yet consumed by `expect_milestone`.
+    pending_osc: VecDeque<Vec<Vec<u8>>>,
 }
 
 impl TestTerminal {
@@ -37,7 +42,11 @@ impl TestTerminal {
         let Terminal { pty_reader, pty_writer, child_handle, .. } = Terminal::spawn(size, cmd)?;
         Ok(Self {
             writer: pty_writer,
-            reader: Reader { pty: BufReader::new(pty_reader), child_handle: child_handle.clone() },
+            reader: Reader {
+                pty: BufReader::new(pty_reader),
+                child_handle: child_handle.clone(),
+                pending_osc: VecDeque::new(),
+            },
             child_handle,
         })
     }
@@ -71,15 +80,24 @@ impl Reader {
         let mut buf = [0u8; 4096];
 
         loop {
-            let found = self
-                .pty
-                .get_ref()
-                .take_unhandled_osc_sequences()
-                .into_iter()
-                .filter_map(|params| {
-                    pty_terminal_test_client::decode_milestone_from_osc8_params(&params)
-                })
-                .any(|decoded| decoded == name);
+            // Drain new sequences from the PTY into our local buffer.
+            self.pending_osc.append(&mut self.pty.get_ref().take_unhandled_osc_sequences());
+
+            // Scan for the first matching milestone, keeping the rest.
+            let mut found = false;
+            let mut remaining = VecDeque::with_capacity(self.pending_osc.len());
+            for params in self.pending_osc.drain(..) {
+                if !found
+                    && pty_terminal_test_client::decode_milestone_from_osc8_params(&params)
+                        .is_some_and(|decoded| decoded == name)
+                {
+                    found = true;
+                    continue;
+                }
+                remaining.push_back(params);
+            }
+            self.pending_osc = remaining;
+
             if found {
                 return self.screen_contents();
             }

crates/pty_terminal_test/src/lib.rs

@@ -16,8 +16,10 @@ path = "src/vtt/main.rs"
 
 [dependencies]
 anyhow = { workspace = true }
+ctrlc = { workspace = true }
 libc = { workspace = true }
 notify = { workspace = true }
+pty_terminal_test_client = { workspace = true, features = ["testing"] }
 async-trait = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 jsonc-parser = { workspace = true }

crates/vite_task_bin/Cargo.toml

@@ -1,13 +1,27 @@
-use std::process::ExitCode;
-
 use clap::Parser as _;
 use vite_task::{Command, ExitStatus, Session};
 use vite_task_bin::OwnedSessionConfig;
 
-#[tokio::main]
-async fn main() -> anyhow::Result<ExitCode> {
-    let exit_status = run().await?;
-    Ok(exit_status.0.into())
+fn main() -> ! {
+    // Ignore SIGINT/CTRL_C before the tokio runtime starts. Child tasks
+    // receive the signal directly from the terminal driver and handle it
+    // themselves. This lets the runner wait for tasks to exit and report
+    // their actual exit status rather than being killed mid-flight.
+    let _ = ctrlc::set_handler(|| {});
+
+    let exit_code: i32 =
+        tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
+            match run().await {
+                Ok(status) => i32::from(status.0),
+                #[expect(clippy::print_stderr, reason = "top-level error reporting")]
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    1
+                }
+            }
+        });
+
+    std::process::exit(exit_code);
 }
 
 async fn run() -> anyhow::Result<ExitStatus> {

crates/vite_task_bin/src/main.rs

@@ -0,0 +1,40 @@
+/// exit-on-ctrlc
+///
+/// Sets up a Ctrl+C handler, emits a "ready" milestone, then waits.
+/// When Ctrl+C is received, prints "ctrl-c received" and exits.
+pub fn run() -> Result<(), Box<dyn std::error::Error>> {
+    // On Windows, an ancestor process (e.g. cargo, the test harness) may have
+    // been created with CREATE_NEW_PROCESS_GROUP, which implicitly calls
+    // SetConsoleCtrlHandler(NULL, TRUE) and sets CONSOLE_IGNORE_CTRL_C in the
+    // PEB's ConsoleFlags. This flag is inherited by all descendants and takes
+    // precedence over registered handlers — CTRL_C_EVENT is silently dropped.
+    // Clear it so our handler can fire.
+    // Ref: https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
+    #[cfg(windows)]
+    {
+        // SAFETY: Passing (None, FALSE) clears the per-process CTRL_C ignore flag.
+        unsafe extern "system" {
+            fn SetConsoleCtrlHandler(
+                handler: Option<unsafe extern "system" fn(u32) -> i32>,
+                add: i32,
+            ) -> i32;
+        }
+        // SAFETY: Clearing the inherited ignore flag.
+        unsafe {
+            SetConsoleCtrlHandler(None, 0);
+        }
+    }
+
+    ctrlc::set_handler(move || {
+        use std::io::Write;
+        let _ = write!(std::io::stdout(), "ctrl-c received");
+        let _ = std::io::stdout().flush();
+        std::process::exit(0);
+    })?;
+
+    pty_terminal_test_client::mark_milestone("ready");
+
+    loop {
+        std::thread::park();
+    }
+}

crates/vite_task_bin/src/vtt/exit_on_ctrlc.rs

@@ -9,6 +9,7 @@
 mod barrier;
 mod check_tty;
 mod cp;
+mod exit_on_ctrlc;
 mod mkdir;
 mod pipe_stdin;
 mod print;
@@ -26,7 +27,7 @@ fn main() {
     if args.len() < 2 {
         eprintln!("Usage: vtt <subcommand> [args...]");
         eprintln!(
-            "Subcommands: barrier, check-tty, cp, mkdir, pipe-stdin, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, touch-file, write-file"
+            "Subcommands: barrier, check-tty, cp, exit-on-ctrlc, mkdir, pipe-stdin, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, touch-file, write-file"
         );
         std::process::exit(1);
     }
@@ -38,7 +39,9 @@ fn main() {
             Ok(())
         }
         "cp" => cp::run(&args[2..]),
+        "exit-on-ctrlc" => exit_on_ctrlc::run(),
         "mkdir" => mkdir::run(&args[2..]),
+        "pipe-stdin" => pipe_stdin::run(&args[2..]),
         "print" => {
             print::run(&args[2..]);
             Ok(())
@@ -48,7 +51,6 @@ fn main() {
         "print-file" => print_file::run(&args[2..]),
         "read-stdin" => read_stdin::run(),
         "replace-file-content" => replace_file_content::run(&args[2..]),
-        "pipe-stdin" => pipe_stdin::run(&args[2..]),
         "rm" => rm::run(&args[2..]),
         "touch-file" => touch_file::run(&args[2..]),
         "write-file" => write_file::run(&args[2..]),

crates/vite_task_bin/src/vtt/main.rs

@@ -0,0 +1,4 @@
+{
+  "name": "ctrl-c-test",
+  "private": true
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@ctrl-c/a",
+  "scripts": {
+    "dev": "vtt exit-on-ctrlc"
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/packages/a/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@ctrl-c/b",
+  "scripts": {
+    "dev": "vtt exit-on-ctrlc"
+  }
+}