fix(test): address Codex round-6 findings

The run tempdir is dropped before Conclusion::exit so runs no longer leak
staged trees. vpt cp copies into existing directories like real cp.
Real-tool resolution happens after per-step envs apply, so a step PATH
override selects the tool the child sees. after-cleanup steps get their
per-step envs (and PATH-aware resolution) too. detect-changes ORs in a
crates/vite_cli_snapshots filter so baseline-only .md changes still run
the snapshot jobs.

Claude-Session: https://claude.ai/code/session_01NRgjMi2Vus3iJctudGEWPT

Author: fengmk2

.github/workflows/ci.yml

@@ -44,7 +44,10 @@ jobs:
       contents: read
       pull-requests: read
     outputs:
-      code-changed: ${{ steps.filter.outputs.code }}
+      # snapshots is OR-ed in because the PTY harness stores its assertions
+      # as .md files (fixtures/**/snapshots/*.md), which the code filter's
+      # markdown exclusion would otherwise classify as docs-only.
+      code-changed: ${{ steps.filter.outputs.code == 'true' || steps.filter.outputs.snapshots == 'true' }}
     steps:
       - uses: taiki-e/checkout-action@7d1e50e93dc4fb3bba58f85018fadf77898aee8b # v1.4.2
       - uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
@@ -58,6 +61,8 @@ jobs:
               - '!.github/workflows/deploy-docs-preview.yml'
               - '!.github/workflows/deploy-docs.yml'
               - '!netlify.toml'
+            snapshots:
+              - 'crates/vite_cli_snapshots/**'
 
   docs-fmt:
     name: Docs format check

crates/vite_cli_snapshots/src/bin/vpt/cp.rs

@@ -13,7 +13,13 @@ pub fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
         }
         copy_dir_recursive(src, dst)?;
     } else {
-        std::fs::copy(src, dst)?;
+        // `cp file existing-dir` copies INTO the directory, like real cp.
+        let target = if dst.is_dir() {
+            dst.join(src.file_name().ok_or("source has no file name")?)
+        } else {
+            dst.to_path_buf()
+        };
+        std::fs::copy(src, target)?;
     }
     Ok(())
 }

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/vpt_selftest/snapshots.toml

@@ -12,6 +12,8 @@ steps = [
   { argv = ["vpt", "touch-file", "created-by-touch.txt"], comment = "touch-file creates missing files" },
   { argv = ["vpt", "stat-file", "created-by-touch.txt", "notes"], comment = "stat-file reports the entry type: file, dir, or missing" },
   { argv = ["vpt", "rm", "-f", "never-existed.txt"], comment = "rm -f ignores missing targets" },
+  { argv = ["vpt", "cp", "created-by-touch.txt", "notes"], comment = "cp into an existing directory, like real cp" },
+  ["vpt", "list-dir", "notes"],
   { argv = ["vpt", "list-dir", "notes/hello.txt"], comment = "list-dir on a file prints the path, like ls" },
   { argv = ["vpt", "chmod", "+x", "created-by-touch.txt"], comment = "symbolic +x is accepted (no-op on Windows)" },
   { argv = ["vpt", "pipe-stdin", "--", "vpt", "read-stdin"], comment = "empty pipe-stdin data means empty stdin, not a bare newline" },

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/vpt_selftest/snapshots/file_roundtrip.md

@@ -66,6 +66,20 @@ rm -f ignores missing targets
 ```
 ```
 
+## `vpt cp created-by-touch.txt notes`
+
+cp into an existing directory, like real cp
+
+```
+```
+
+## `vpt list-dir notes`
+
+```
+created-by-touch.txt
+hello.txt
+```
+
 ## `vpt list-dir notes/hello.txt`
 
 list-dir on a file prints the path, like ls

crates/vite_cli_snapshots/tests/cli_snapshots/main.rs

@@ -653,7 +653,6 @@ fn run_case(
     for step in &case.steps {
         let argv = step.argv();
         assert!(!argv.is_empty(), "step argv must not be empty");
-        let program = runtime.resolve_program(&argv[0], &case_path)?;
 
         // Most steps add no env of their own; borrow the case env then.
         let step_env_override;
@@ -667,6 +666,10 @@ fn run_case(
             step_env_override = env;
             &step_env_override
         };
+        // Resolution honors a per-step PATH override, so steps testing shims
+        // or custom prefixes run exactly the tool the child would see.
+        let step_path = step_env.get("PATH").cloned().unwrap_or_else(|| case_path.clone());
+        let program = runtime.resolve_program(&argv[0], &step_path)?;
         let step_cwd = stage.join(step.cwd().unwrap_or(case.cwd.as_str()));
         let timeout = step.timeout();
 
@@ -827,15 +830,29 @@ fn run_case(
         }
     }
 
-    // Cleanup steps: best-effort, never snapshotted.
+    // Cleanup steps: best-effort, never snapshotted. Per-step envs apply
+    // here too: cleanup often depends on the same PATH/prefix overrides as
+    // the step it tears down.
     for step in &case.after {
         let argv = step.argv();
         assert!(!argv.is_empty(), "after-step argv must not be empty");
-        if let Ok(program) = runtime.resolve_program(&argv[0], &case_path) {
+        let after_env_override;
+        let after_env: &BTreeMap<String, OsString> = if step.envs().is_empty() {
+            &case_env
+        } else {
+            let mut env = case_env.clone();
+            for (k, v) in step.envs() {
+                env.insert(k.clone(), v.into());
+            }
+            after_env_override = env;
+            &after_env_override
+        };
+        let after_path = after_env.get("PATH").cloned().unwrap_or_else(|| case_path.clone());
+        if let Ok(program) = runtime.resolve_program(&argv[0], &after_path) {
             let _ = std::process::Command::new(program)
                 .args(&argv[1..])
                 .env_clear()
-                .envs(&case_env)
+                .envs(after_env)
                 .current_dir(stage.join(step.cwd().unwrap_or(case.cwd.as_str())))
                 .stdin(std::process::Stdio::null())
                 .output();
@@ -966,5 +983,9 @@ fn main() {
         }
     }
 
-    libtest_mimic::run(&args, tests).exit();
+    let conclusion = libtest_mimic::run(&args, tests);
+    // exit() never returns, so the staged run tree must be dropped first or
+    // every run would leave its full tempdir behind.
+    drop(tmp_dir);
+    conclusion.exit();
 }