test(e2e): add argv step spawn mode

Add `argv` field to e2e step config that spawns the process directly
without a shell wrapper (`sh -c`). This avoids shell interference with
signal handling and exit codes on Windows where bash intercepts CTRL_C.

The program is resolved from `CARGO_BIN_EXE_<name>` env vars since
CommandBuilder doesn't do PATH lookup on all platforms.

Also:
- Use staged temp dir for insta snapshot paths so reads/writes work when
  fixture_path is on a remote filesystem (e.g. WebDAV via cargo-xtest)
- Remove INSTA_REQUIRE_FULL_MATCH (incompatible with remote execution
  where snapshot metadata differs)
- Document Conventional Commits format for PR titles in CLAUDE.md

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

crates/vite_task_bin/tests/e2e_snapshots/main.rs

@@ -64,16 +64,48 @@ enum Step {
 #[derive(serde::Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 struct StepConfig {
-    command: Str,
+    /// Shell command string (run via `sh -c`).
+    #[serde(default)]
+    command: Option<Str>,
+    /// Argument vector — spawned directly without a shell wrapper.
+    #[serde(default)]
+    argv: Option<Vec<Str>>,
     #[serde(default)]
     interactions: Vec<Interaction>,
 }
 
+/// How to spawn a step: either via shell or directly.
+enum StepSpawn<'a> {
+    /// Run through `sh -c "<command>"`.
+    Shell(&'a str),
+    /// Spawn directly with the given argv (first element is the program).
+    Direct(&'a [Str]),
+}
+
 impl Step {
-    fn command(&self) -> &str {
+    fn spawn_mode(&self) -> StepSpawn<'_> {
         match self {
-            Self::Command(command) => command.as_str(),
-            Self::Detailed(config) => config.command.as_str(),
+            Self::Command(command) => StepSpawn::Shell(command.as_str()),
+            Self::Detailed(config) => config.argv.as_deref().map_or_else(
+                || {
+                    StepSpawn::Shell(
+                        config
+                            .command
+                            .as_ref()
+                            .expect("step must have either 'command' or 'argv'")
+                            .as_str(),
+                    )
+                },
+                StepSpawn::Direct,
+            ),
+        }
+    }
+
+    #[expect(clippy::disallowed_types, reason = "String required by join")]
+    fn display_command(&self) -> String {
+        match self.spawn_mode() {
+            StepSpawn::Shell(cmd) => cmd.to_string(),
+            StepSpawn::Direct(argv) => argv.iter().map(Str::as_str).collect::<Vec<_>>().join(" "),
         }
     }
 
@@ -187,9 +219,12 @@ fn run_case(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, filter: Optio
     {
         println!("{fixture_name}");
     }
-    // Configure insta to write snapshots to fixture directory
+    // Point insta at the staged copy's snapshot dir. The original fixture_path
+    // may be on a read-only/remote filesystem (e.g. WebDAV via cargo-xtest).
+    // The stage_path is created by run_case_inner's copy_tree call.
+    let stage_snapshot_path = tmpdir.as_path().join(fixture_name).join("snapshots");
     let mut settings = insta::Settings::clone_current();
-    settings.set_snapshot_path(fixture_path.join("snapshots"));
+    settings.set_snapshot_path(stage_snapshot_path);
     settings.set_prepend_module_to_snapshot(false);
     settings.remove_snapshot_suffix();
 
@@ -276,10 +311,27 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
 
         let mut e2e_outputs = String::new();
         for step in &e2e.steps {
-            let step_command = step.command();
-            let mut cmd = CommandBuilder::new(&shell_exe);
-            cmd.arg("-c");
-            cmd.arg(step_command);
+            let step_display = step.display_command();
+            let mut cmd = match step.spawn_mode() {
+                StepSpawn::Shell(command) => {
+                    let mut cmd = CommandBuilder::new(&shell_exe);
+                    cmd.arg("-c");
+                    cmd.arg(command);
+                    cmd
+                }
+                StepSpawn::Direct(argv) => {
+                    // Resolve the program from CARGO_BIN_EXE_<name> if available,
+                    // since CommandBuilder doesn't do PATH lookup on all platforms.
+                    let program = argv[0].as_str();
+                    let exe_env = vite_str::format!("CARGO_BIN_EXE_{program}");
+                    let resolved = env::var_os(exe_env.as_str()).unwrap_or_else(|| program.into());
+                    let mut cmd = CommandBuilder::new(resolved);
+                    for arg in &argv[1..] {
+                        cmd.arg(arg.as_str());
+                    }
+                    cmd
+                }
+            };
             cmd.env_clear();
             cmd.env("PATH", &e2e_env_path);
             cmd.env("NO_COLOR", "1");
@@ -390,7 +442,7 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
             }
 
             e2e_outputs.push_str("> ");
-            e2e_outputs.push_str(step_command);
+            e2e_outputs.push_str(&step_display);
             e2e_outputs.push('\n');
 
             e2e_outputs.push_str(&redact_e2e_output(output, e2e_stage_path_str));
@@ -412,9 +464,6 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
 }
 
 fn main() {
-    // SAFETY: Called before any threads are spawned; insta reads this lazily on first assertion.
-    unsafe { std::env::set_var("INSTA_REQUIRE_FULL_MATCH", "1") };
-
     let filter = std::env::args().nth(1);
 
     let tmp_dir = tempfile::tempdir().unwrap();
@@ -430,7 +479,7 @@ fn main() {
 
         // Copy .node-version to the tmp dir so version manager shims can resolve the correct
         // Node.js binary when running task commands.
-        let repo_root = manifest_dir.join("../..").canonicalize().unwrap();
+        let repo_root = manifest_dir.parent().unwrap().parent().unwrap();
         std::fs::copy(repo_root.join(".node-version"), tmp_dir.path().join(".node-version"))
             .unwrap();