Add ctrl-c e2e test and handle SIGINT gracefully in vt

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`, synchronizes via milestone protocol,
then sends ctrl-c and verifies both tasks receive and handle it.

Handle SIGINT/CTRL_C gracefully in vt: ignore the signal in the parent
process (so it survives Ctrl+C) while resetting to SIG_DFL in pre_exec
for child processes (so they can install their own handlers). This lets
vt wait for tasks to exit and report their actual exit status.

Also adds `ctrl-c` as a new `write-key` interaction type, fixes
`expect_milestone` to preserve unmatched milestones, and strips `^C`
terminal echo in redaction for cross-platform consistency.

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

Author: branchseer

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

@@ -560,6 +560,7 @@ async fn spawn_inherited(
                     }
                 }
             }
+
             Ok(())
         });
     }

crates/vite_task_bin/src/main.rs

@@ -4,10 +4,24 @@ 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() -> anyhow::Result<ExitCode> {
+    // Ignore SIGINT before the tokio runtime starts, so that Ctrl+C does not
+    // kill this process. Child tasks receive SIGINT directly from the terminal
+    // driver (same process group) and handle it themselves. This lets the
+    // runner wait for tasks to exit and report their actual exit status.
+    // Child processes reset to SIG_DFL in pre_exec (see spawn_inherited).
+    ignore_ctrlc();
+
+    tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
+        let exit_status = run().await?;
+        Ok(exit_status.0.into())
+    })
+}
+
+fn ignore_ctrlc() {
+    // Register a no-op Ctrl+C handler. After exec, signal handlers are reset
+    // to SIG_DFL, so child processes can install their own handlers normally.
+    ctrlc::set_handler(|| {}).expect("failed to set ctrl-c handler");
 }
 
 async fn run() -> anyhow::Result<ExitStatus> {

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/snapshots/ctrl-c terminates running tasks.snap

@@ -2,7 +2,7 @@
 source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
 expression: e2e_outputs
 ---
-[1]> vt run -r dev
+> vt run -r dev
 @ expect-milestone: ready
 ~/packages/a$ vtt exit-on-ctrlc ⊘ cache disabled
 ~/packages/b$ vtt exit-on-ctrlc ⊘ cache disabled
@@ -12,4 +12,7 @@ expression: e2e_outputs
 @ write-key: ctrl-c
 ~/packages/a$ vtt exit-on-ctrlc ⊘ cache disabled
 ~/packages/b$ vtt exit-on-ctrlc ⊘ cache disabled
-^Cctrl-c receivedctrl-c received
+ctrl-c receivedctrl-c received
+
+---
+vt run: 0/2 cache hit (0%). (Run `vt run --last-details` for full details)

crates/vite_task_bin/tests/e2e_snapshots/redact.rs

@@ -101,6 +101,15 @@ pub fn redact_e2e_output(mut output: String, workspace_root: &str) -> String {
     let mise_warning_regex = regex::Regex::new(r"(?m)^mise WARN\s+.*\n?").unwrap();
     output = mise_warning_regex.replace_all(&output, "").into_owned();
 
+    // Remove ^C echo that Unix terminal drivers emit when ETX (0x03) is written
+    // to the PTY. Windows ConPTY does not echo it.
+    {
+        use cow_utils::CowUtils as _;
+        if let Cow::Owned(replaced) = output.as_str().cow_replace("^C", "") {
+            output = replaced;
+        }
+    }
+
     // Sort consecutive diagnostic blocks to handle non-deterministic tool output
     // (e.g., oxlint reports warnings in arbitrary order due to multi-threading).
     // Each block starts with "  ! " and ends at the next empty line.