test(e2e): make snapshot tests self-contained (#302)

## Why
Enable cross-compiling e2e snapshot tests and running them on another
machine (e.g. Windows VM via cargo-xtest). The target machine has no
guarantees about installed tools — no bash, no node, no system PATH.
Tests must be fully self-contained, relying only on the `vt` and `vtt`
binaries built by cargo.

## Summary
Make e2e snapshot tests fully self-contained by removing all external
dependencies (bash, node, system PATH). Tests now spawn `vt`/`vtt`
directly without a shell wrapper.

- Replace shell command strings with structured `argv` arrays in all
fixtures
- Add `comment` and `envs` fields to step config for metadata and env
vars
- Spawn processes directly via `CommandBuilder` instead of `sh -c`
- Add vtt subcommands to replace external tools: `pipe-stdin`,
`write-file`,
  `cp`, `mkdir`, `rm`, `exit`
- Replace `node` usage in fixtures with vtt equivalents
- Remove `replay-logs-chronological-order` fixture (required node)
- Remove `INSTA_REQUIRE_FULL_MATCH` (incompatible with remote execution)
- Document Conventional Commits format for PR titles in CLAUDE.md

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

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

Author: branchseer

CLAUDE.md

@@ -38,6 +38,8 @@ just doc           # Documentation generation
 
 If `gt` (Graphite CLI) is available in PATH, use it instead of `gh` to create pull requests.
 
+PR titles must use [Conventional Commits](https://www.conventionalcommits.org) format: `type(scope): summary` (scope is optional), e.g. `feat(cache): add LRU eviction`, `fix: handle symlink loops`, `test(e2e): add ctrl-c propagation test`.
+
 ## Tests
 
 ```bash

Cargo.lock

@@ -36,8 +36,10 @@ pty_terminal = { workspace = true }
 pty_terminal_test = { workspace = true }
 regex = { workspace = true }
 serde = { workspace = true, features = ["derive", "rc"] }
+shell-escape = { workspace = true }
 tempfile = { workspace = true }
 toml = { workspace = true }
+vec1 = { workspace = true, features = ["serde"] }
 vite_path = { workspace = true, features = ["absolute-redaction"] }
 vite_workspace = { workspace = true }
 

crates/vite_task_bin/Cargo.toml

@@ -0,0 +1,7 @@
+pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    if args.len() != 2 {
+        return Err("Usage: vtt cp <src> <dst>".into());
+    }
+    std::fs::copy(&args[0], &args[1])?;
+    Ok(())
+}

crates/vite_task_bin/src/vtt/cp.rs

@@ -0,0 +1,4 @@
+pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let code: i32 = args.first().map(|s| s.parse()).transpose()?.unwrap_or(0);
+    std::process::exit(code);
+}

crates/vite_task_bin/src/vtt/exit.rs

@@ -8,20 +8,26 @@
 
 mod barrier;
 mod check_tty;
+mod cp;
+mod exit;
+mod mkdir;
+mod pipe_stdin;
 mod print;
 mod print_cwd;
 mod print_env;
 mod print_file;
 mod read_stdin;
 mod replace_file_content;
+mod rm;
 mod touch_file;
+mod write_file;
 
 fn main() {
     let args: Vec<String> = std::env::args().collect();
     if args.len() < 2 {
         eprintln!("Usage: vtt <subcommand> [args...]");
         eprintln!(
-            "Subcommands: barrier, check-tty, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, touch-file"
+            "Subcommands: barrier, check-tty, cp, exit, mkdir, pipe-stdin, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, touch-file, write-file"
         );
         std::process::exit(1);
     }
@@ -32,6 +38,9 @@ fn main() {
             check_tty::run();
             Ok(())
         }
+        "cp" => cp::run(&args[2..]),
+        "exit" => exit::run(&args[2..]),
+        "mkdir" => mkdir::run(&args[2..]),
         "print" => {
             print::run(&args[2..]);
             Ok(())
@@ -41,7 +50,10 @@ 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..]),
         other => {
             eprintln!("Unknown subcommand: {other}");
             std::process::exit(1);

crates/vite_task_bin/src/vtt/main.rs

@@ -0,0 +1,21 @@
+pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let mut parents = false;
+    let mut paths = Vec::new();
+    for arg in args {
+        match arg.as_str() {
+            "-p" => parents = true,
+            _ => paths.push(arg.as_str()),
+        }
+    }
+    if paths.is_empty() {
+        return Err("Usage: vtt mkdir [-p] <path>...".into());
+    }
+    for path in paths {
+        if parents {
+            std::fs::create_dir_all(path)?;
+        } else {
+            std::fs::create_dir(path)?;
+        }
+    }
+    Ok(())
+}

crates/vite_task_bin/src/vtt/mkdir.rs

@@ -0,0 +1,33 @@
+/// pipe-stdin `<data>` -- `<command>` \[`<args>`...\]
+///
+/// Spawns `<command>` with `<data>` piped to its stdin, then exits with
+/// the child's exit code. If `<data>` is empty, an empty stdin is provided.
+pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let sep = args
+        .iter()
+        .position(|a| a == "--")
+        .ok_or("Usage: vtt pipe-stdin <data> -- <command> [args...]")?;
+    let data = &args[..sep].join(" ");
+    let cmd_args = &args[sep + 1..];
+    if cmd_args.is_empty() {
+        return Err("Usage: vtt pipe-stdin <data> -- <command> [args...]".into());
+    }
+
+    let mut child = std::process::Command::new(&cmd_args[0])
+        .args(&cmd_args[1..])
+        .stdin(std::process::Stdio::piped())
+        .spawn()?;
+
+    {
+        use std::io::Write;
+        let mut stdin = child.stdin.take().unwrap();
+        if !data.is_empty() {
+            stdin.write_all(data.as_bytes())?;
+        }
+        stdin.write_all(b"\n")?;
+        // stdin is closed when dropped, signaling EOF
+    }
+
+    let status = child.wait()?;
+    std::process::exit(status.code().unwrap_or(1));
+}

crates/vite_task_bin/src/vtt/pipe_stdin.rs

@@ -0,0 +1,22 @@
+pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let mut recursive = false;
+    let mut paths = Vec::new();
+    for arg in args {
+        match arg.as_str() {
+            "-r" | "-rf" | "-f" => recursive = true,
+            _ => paths.push(arg.as_str()),
+        }
+    }
+    if paths.is_empty() {
+        return Err("Usage: vtt rm [-rf] <path>...".into());
+    }
+    for path in paths {
+        let p = std::path::Path::new(path);
+        if p.is_dir() && recursive {
+            std::fs::remove_dir_all(p)?;
+        } else {
+            std::fs::remove_file(p)?;
+        }
+    }
+    Ok(())
+}

crates/vite_task_bin/src/vtt/rm.rs

@@ -0,0 +1,7 @@
+pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    if args.len() < 2 {
+        return Err("Usage: vtt write-file <filename> <content>".into());
+    }
+    std::fs::write(&args[0], &args[1])?;
+    Ok(())
+}