feat: add Rust replay test runner with concurrent execution support

New crate: openwa-test-runner — discovers and runs all headless replay
tests, compares output logs byte-for-byte, prints pass/fail summary.

Concurrency infrastructure:
- Per-instance event names (OpenWA_HooksReady_{pid}) in launcher + DLL
- Configurable OpenWA.log path via OPENWA_LOG_PATH env var
- Per-instance playback.thm paths to avoid replay map data races
- 1s launch stagger for concurrent mode stability

Usage: openwa-test [-j N] [--no-build] [filter]
Default is serial (j=1). Concurrent mode (-j 4) gives ~3x speedup
but has a known flaky race in WA.exe startup (needs procmon investigation).

Also normalizes CRLF in log comparison for cross-platform robustness.

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

.gitignore

@@ -4,3 +4,4 @@
 start-mcp.ps1
 docs/re-notes/decompiled/
 testdata/logs/
+testdata/runs/

Cargo.lock

@@ -1462,6 +1462,10 @@ dependencies = [
 name = "openwa-launcher"
 version = "0.1.0"
 
+[[package]]
+name = "openwa-test-runner"
+version = "0.1.0"
+
 [[package]]
 name = "openwa-wormkit"
 version = "0.1.0"

crates/openwa-core/src/log.rs

@@ -1,12 +1,27 @@
-//! Shared logging — writes to `OpenWA.log` in the working directory.
+//! Shared logging — writes to `OpenWA.log` in the working directory,
+//! or to the path specified by `OPENWA_LOG_PATH` env var.
 
-/// Append a line to `OpenWA.log`.
+use std::path::PathBuf;
+use std::sync::OnceLock;
+
+/// Resolve the log file path once. Uses `OPENWA_LOG_PATH` env var if set,
+/// otherwise defaults to `"OpenWA.log"`.
+fn log_path() -> &'static PathBuf {
+    static PATH: OnceLock<PathBuf> = OnceLock::new();
+    PATH.get_or_init(|| {
+        std::env::var_os("OPENWA_LOG_PATH")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| PathBuf::from("OpenWA.log"))
+    })
+}
+
+/// Append a line to the OpenWA log file.
 pub fn log_line(msg: &str) -> std::io::Result<()> {
     use std::io::Write;
     let mut f = std::fs::OpenOptions::new()
         .create(true)
         .append(true)
-        .open("OpenWA.log")?;
+        .open(log_path())?;
     writeln!(f, "{msg}")?;
     Ok(())
 }

crates/openwa-launcher/src/main.rs

@@ -190,7 +190,18 @@ unsafe fn launch(
     // Create a named event that the DLL will signal after all hooks are
     // installed. This ensures the main thread doesn't run any WA code
     // before our hooks are in place.
-    let event_name = b"OpenWA_HooksReady\0";
+    //
+    // Use a per-instance event name based on the child PID to allow
+    // concurrent launcher instances (e.g., parallel test runner).
+    let event_name_str = format!("OpenWA_HooksReady_{}\0", pi.dwProcessId);
+    let event_name = event_name_str.as_bytes();
+    // Also set env var so the DLL (in the child process) knows the event name.
+    // The child inherits our env, but it was created before we set this var.
+    // Instead, we write the event name into a small shared memory region:
+    // we use SetEnvironmentVariableA in the child's context — but that's not
+    // possible for a suspended process. So we rely on the DLL reading the
+    // event name from a fixed pattern: OpenWA_HooksReady_{its_own_pid}.
+    // The DLL can call GetCurrentProcessId() to reconstruct the same name.
     let event = CreateEventA(ptr::null_mut(), 1, 0, event_name.as_ptr());
     // event may be null if CreateEventA fails — we'll fall through gracefully.
 

crates/openwa-test-runner/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "openwa-test-runner"
+version = "0.1.0"
+edition = "2021"
+description = "Headless replay test runner with concurrent execution"
+
+[[bin]]
+name = "openwa-test"
+path = "src/main.rs"

crates/openwa-test-runner/src/main.rs

@@ -0,0 +1,584 @@
+//! Headless replay test runner with concurrent execution.
+//!
+//! Discovers all `testdata/replays/*.WAgame` files with matching `*_expected.log`,
+//! builds the DLL + launcher, then runs each replay through WA.exe's `/getlog` mode
+//! and compares output byte-for-byte.
+
+use std::env;
+use std::fmt::Write as FmtWrite;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::mpsc;
+use std::thread;
+use std::time::{Duration, Instant};
+
+// ─── Configuration ──────────────────────────────────────────────────────────
+
+/// Default to serial — concurrent mode (-j N) has a known flaky race in WA.exe
+/// startup that causes occasional checksum mismatches. Use procmon to identify
+/// the shared resource. The 1s launch stagger helps but doesn't fully fix it.
+const DEFAULT_JOBS: usize = 1;
+const TIMEOUT_SECS: u64 = 120;
+const REPLAYS_DIR: &str = "testdata/replays";
+const RUNS_DIR: &str = "testdata/runs";
+
+/// Known WA.exe locations to try if not specified.
+const WA_CANDIDATES: &[&str] = &[
+    "I:/games/SteamLibrary/steamapps/common/Worms Armageddon/WA.exe",
+    "C:/Program Files (x86)/Steam/steamapps/common/Worms Armageddon/WA.exe",
+];
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+struct TestCase {
+    name: String,
+    replay_path: PathBuf,
+    expected_log: PathBuf,
+    output_log: PathBuf,
+}
+
+#[derive(Clone)]
+struct TestResult {
+    name: String,
+    passed: bool,
+    duration: Duration,
+    diff_lines: Vec<String>,
+    error: Option<String>,
+}
+
+struct Args {
+    filter: Option<String>,
+    jobs: usize,
+    no_build: bool,
+    wa_path: Option<PathBuf>,
+}
+
+// ─── Argument parsing ───────────────────────────────────────────────────────
+
+fn parse_args() -> Args {
+    let mut args = Args {
+        filter: None,
+        jobs: DEFAULT_JOBS,
+        no_build: false,
+        wa_path: None,
+    };
+
+    let argv: Vec<String> = env::args().skip(1).collect();
+    let mut i = 0;
+    while i < argv.len() {
+        match argv[i].as_str() {
+            "-j" | "--jobs" => {
+                i += 1;
+                if i < argv.len() {
+                    args.jobs = argv[i].parse().unwrap_or(DEFAULT_JOBS);
+                }
+            }
+            "--no-build" => args.no_build = true,
+            "--wa-path" => {
+                i += 1;
+                if i < argv.len() {
+                    args.wa_path = Some(PathBuf::from(&argv[i]));
+                }
+            }
+            s if !s.starts_with('-') => {
+                args.filter = Some(s.to_string());
+            }
+            other => {
+                eprintln!("Unknown argument: {other}");
+                eprintln!("Usage: openwa-test [filter] [-j N] [--no-build] [--wa-path PATH]");
+                std::process::exit(1);
+            }
+        }
+        i += 1;
+    }
+
+    args
+}
+
+// ─── Test discovery ─────────────────────────────────────────────────────────
+
+fn discover_tests(filter: Option<&str>) -> Vec<TestCase> {
+    let replays_dir = Path::new(REPLAYS_DIR);
+    let mut tests = Vec::new();
+
+    let entries = match fs::read_dir(replays_dir) {
+        Ok(e) => e,
+        Err(e) => {
+            eprintln!("Cannot read {REPLAYS_DIR}: {e}");
+            return tests;
+        }
+    };
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("WAgame") {
+            continue;
+        }
+
+        let stem = match path.file_stem().and_then(|s| s.to_str()) {
+            Some(s) => s.to_string(),
+            None => continue,
+        };
+
+        if let Some(filter) = filter {
+            if !stem.contains(filter) {
+                continue;
+            }
+        }
+
+        let expected = replays_dir.join(format!("{stem}_expected.log"));
+        if !expected.exists() {
+            continue; // Skip replays without expected logs
+        }
+
+        let output = path.with_extension("log");
+
+        // WA.exe runs in the game directory, so replay/log paths must be absolute.
+        // Strip \\?\ UNC prefix that canonicalize adds on Windows — WA.exe can't handle it.
+        let replay_abs = strip_unc(fs::canonicalize(&path).unwrap_or(path.clone()));
+        let expected_abs = strip_unc(fs::canonicalize(&expected).unwrap_or(expected.clone()));
+        let output_abs = replay_abs.with_extension("log");
+
+        tests.push(TestCase {
+            name: stem,
+            replay_path: replay_abs,
+            expected_log: expected_abs,
+            output_log: output_abs,
+        });
+    }
+
+    tests.sort_by(|a, b| a.name.cmp(&b.name));
+    tests
+}
+
+// ─── WA.exe location ────────────────────────────────────────────────────────
+
+fn find_wa_exe(override_path: Option<&Path>) -> Option<PathBuf> {
+    if let Some(p) = override_path {
+        if p.exists() {
+            return Some(p.to_path_buf());
+        }
+    }
+
+    if let Ok(p) = env::var("OPENWA_WA_PATH") {
+        let path = PathBuf::from(p);
+        if path.exists() {
+            return Some(path);
+        }
+    }
+
+    for candidate in WA_CANDIDATES {
+        let path = PathBuf::from(candidate);
+        if path.exists() {
+            return Some(path);
+        }
+    }
+
+    None
+}
+
+fn find_launcher() -> Option<PathBuf> {
+    // Look for the launcher in the release build output
+    let p = PathBuf::from("target/i686-pc-windows-msvc/release/openwa-launcher.exe");
+    if p.exists() {
+        return Some(p);
+    }
+    let p = PathBuf::from("target/release/openwa-launcher.exe");
+    if p.exists() {
+        return Some(p);
+    }
+    None
+}
+
+// ─── Build ──────────────────────────────────────────────────────────────────
+
+fn build() -> Result<Duration, String> {
+    let start = Instant::now();
+    let status = Command::new("cargo")
+        .args(["build", "--release", "-p", "openwa-wormkit", "-p", "openwa-launcher"])
+        .status()
+        .map_err(|e| format!("Failed to run cargo: {e}"))?;
+
+    if !status.success() {
+        return Err("Build failed".to_string());
+    }
+
+    Ok(start.elapsed())
+}
+
+// ─── Single test execution ──────────────────────────────────────────────────
+
+fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) -> TestResult {
+    let start = Instant::now();
+
+    // Remove stale output log
+    let _ = fs::remove_file(&test.output_log);
+
+    // Per-instance log paths
+    let openwa_log = run_dir.join(format!("{}.openwa.log", test.name));
+
+    let result = Command::new(launcher)
+        .arg(wa_exe)
+        .arg("/getlog")
+        .arg(&test.replay_path)
+        .env("OPENWA_HEADLESS", "1")
+        .env("OPENWA_LOG_PATH", &openwa_log)
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status();
+
+    let duration = start.elapsed();
+
+    match result {
+        Err(e) => TestResult {
+            name: test.name.clone(),
+            passed: false,
+            duration,
+            diff_lines: Vec::new(),
+            error: Some(format!("Failed to launch: {e}")),
+        },
+        Ok(status) => {
+            if duration >= Duration::from_secs(TIMEOUT_SECS) {
+                return TestResult {
+                    name: test.name.clone(),
+                    passed: false,
+                    duration,
+                    diff_lines: Vec::new(),
+                    error: Some("Timeout".to_string()),
+                };
+            }
+
+            // Copy output log to run dir
+            if test.output_log.exists() {
+                let dest = run_dir.join(format!("{}.log", test.name));
+                let _ = fs::copy(&test.output_log, &dest);
+            }
+
+            // Compare output
+            if !test.output_log.exists() {
+                return TestResult {
+                    name: test.name.clone(),
+                    passed: false,
+                    duration,
+                    diff_lines: Vec::new(),
+                    error: Some(format!("No output log generated (exit code: {})",
+                        status.code().unwrap_or(-1))),
+                };
+            }
+
+            // Normalize CRLF → LF for comparison (WA mixes line endings)
+            let expected = normalize_crlf(&fs::read(&test.expected_log).unwrap_or_default());
+            let actual = normalize_crlf(&fs::read(&test.output_log).unwrap_or_default());
+
+            if expected == actual {
+                // Clean up the output log on success
+                let _ = fs::remove_file(&test.output_log);
+                TestResult {
+                    name: test.name.clone(),
+                    passed: true,
+                    duration,
+                    diff_lines: Vec::new(),
+                    error: None,
+                }
+            } else {
+                let mut diff = compute_diff(&expected, &actual);
+                if diff.is_empty() {
+                    diff.push(format!(
+                        "  (byte-level difference: expected {} bytes, actual {} bytes)",
+                        expected.len(), actual.len()
+                    ));
+                }
+                let _ = fs::remove_file(&test.output_log);
+                TestResult {
+                    name: test.name.clone(),
+                    passed: false,
+                    duration,
+                    diff_lines: diff,
+                    error: None,
+                }
+            }
+        }
+    }
+}
+
+/// Compute a simple line diff (first 10 differing lines).
+fn compute_diff(expected: &[u8], actual: &[u8]) -> Vec<String> {
+    let exp_str = String::from_utf8_lossy(expected);
+    let act_str = String::from_utf8_lossy(actual);
+    let exp_lines: Vec<&str> = exp_str.lines().collect();
+    let act_lines: Vec<&str> = act_str.lines().collect();
+
+    let mut diffs = Vec::new();
+    let max = exp_lines.len().max(act_lines.len());
+
+    for i in 0..max {
+        let e = exp_lines.get(i).copied().unwrap_or("");
+        let a = act_lines.get(i).copied().unwrap_or("");
+        if e != a {
+            if !e.is_empty() {
+                diffs.push(format!("  - expected: {e}"));
+            }
+            if !a.is_empty() {
+                diffs.push(format!("  + actual:   {a}"));
+            }
+            if diffs.len() >= 10 {
+                diffs.push("  ... (truncated)".to_string());
+                break;
+            }
+        }
+    }
+
+    diffs
+}
+
+// ─── Thread pool ────────────────────────────────────────────────────────────
+
+fn run_tests_parallel(
+    tests: Vec<TestCase>,
+    jobs: usize,
+    launcher: &Path,
+    wa_exe: &Path,
+    run_dir: &Path,
+) -> Vec<TestResult> {
+    let (tx, rx) = mpsc::channel::<(usize, TestResult)>();
+    let (work_tx, work_rx) = mpsc::channel::<(usize, TestCase)>();
+    let work_rx = std::sync::Arc::new(std::sync::Mutex::new(work_rx));
+
+    let launcher = launcher.to_path_buf();
+    let wa_exe = wa_exe.to_path_buf();
+    let run_dir = run_dir.to_path_buf();
+
+    // Spawn worker threads
+    let mut handles = Vec::new();
+    for _ in 0..jobs.min(tests.len()) {
+        let rx = work_rx.clone();
+        let tx = tx.clone();
+        let launcher = launcher.clone();
+        let wa_exe = wa_exe.clone();
+        let run_dir = run_dir.clone();
+
+        handles.push(thread::spawn(move || {
+            loop {
+                // Lock only long enough to recv, then drop the guard before running the test
+                let item = rx.lock().unwrap().recv();
+                match item {
+                    Ok((idx, test)) => {
+                        let result = run_test(&test, &launcher, &wa_exe, &run_dir);
+                        let _ = tx.send((idx, result));
+                    }
+                    Err(_) => break, // Channel closed, no more work
+                }
+            }
+        }));
+    }
+    drop(tx); // Drop our sender so rx closes when all workers finish
+
+    // Submit work with small stagger to avoid startup races
+    for (idx, test) in tests.into_iter().enumerate() {
+        let _ = work_tx.send((idx, test));
+        if idx > 0 {
+            thread::sleep(Duration::from_millis(1000));
+        }
+    }
+    drop(work_tx); // Signal no more work
+
+    // Collect results
+    let mut results: Vec<Option<TestResult>> = vec![None; handles.len() + 100]; // oversize
+    let mut count = 0;
+    for (idx, result) in rx {
+        if idx >= results.len() {
+            results.resize(idx + 1, None);
+        }
+        // Print result as it arrives
+        print_result(&result);
+        results[idx] = Some(result);
+        count += 1;
+    }
+
+    for h in handles {
+        let _ = h.join();
+    }
+
+    results.into_iter().take(count).flatten().collect()
+}
+
+// ─── Output ─────────────────────────────────────────────────────────────────
+
+fn print_result(result: &TestResult) {
+    let status = if result.passed { "\x1b[32m  PASS\x1b[0m" } else { "\x1b[31m  FAIL\x1b[0m" };
+    let secs = result.duration.as_secs_f64();
+    println!("{status}  {:<28} ({secs:.1}s)", result.name);
+
+    if let Some(err) = &result.error {
+        println!("        {err}");
+    }
+    for line in &result.diff_lines {
+        println!("        {line}");
+    }
+}
+
+fn print_summary(results: &[TestResult], wall_time: Duration) {
+    let passed = results.iter().filter(|r| r.passed).count();
+    let failed = results.len() - passed;
+    let cpu_time: f64 = results.iter().map(|r| r.duration.as_secs_f64()).sum();
+    let wall = wall_time.as_secs_f64();
+
+    println!();
+    if failed == 0 {
+        println!(
+            "\x1b[32m{} tests: all passed\x1b[0m (wall {wall:.1}s, cpu {cpu_time:.1}s)",
+            results.len()
+        );
+    } else {
+        println!(
+            "\x1b[31m{} tests: {passed} passed, {failed} failed\x1b[0m (wall {wall:.1}s, cpu {cpu_time:.1}s)",
+            results.len()
+        );
+    }
+}
+
+fn write_summary(results: &[TestResult], wall_time: Duration, path: &Path) {
+    let mut s = String::new();
+    for r in results {
+        let status = if r.passed { "PASS" } else { "FAIL" };
+        let _ = writeln!(s, "{status}  {:<28} ({:.1}s)", r.name, r.duration.as_secs_f64());
+        if let Some(err) = &r.error {
+            let _ = writeln!(s, "        {err}");
+        }
+        for line in &r.diff_lines {
+            let _ = writeln!(s, "        {line}");
+        }
+    }
+    let passed = results.iter().filter(|r| r.passed).count();
+    let failed = results.len() - passed;
+    let _ = writeln!(s, "\n{} tests: {passed} passed, {failed} failed (wall {:.1}s)",
+        results.len(), wall_time.as_secs_f64());
+
+    let _ = fs::write(path, s);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/// Normalize CRLF to LF for cross-platform comparison.
+fn normalize_crlf(data: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(data.len());
+    for &b in data {
+        if b != b'\r' {
+            out.push(b);
+        }
+    }
+    out
+}
+
+/// Strip the `\\?\` UNC prefix that `fs::canonicalize` adds on Windows.
+fn strip_unc(p: PathBuf) -> PathBuf {
+    let s = p.to_string_lossy();
+    if let Some(stripped) = s.strip_prefix(r"\\?\") {
+        PathBuf::from(stripped)
+    } else {
+        p
+    }
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+fn main() {
+    let args = parse_args();
+
+    // Discover tests
+    let tests = discover_tests(args.filter.as_deref());
+    if tests.is_empty() {
+        eprintln!("No replay tests found in {REPLAYS_DIR}/");
+        if let Some(f) = &args.filter {
+            eprintln!("  (filter: \"{f}\")");
+        }
+        std::process::exit(1);
+    }
+
+    // Build
+    if !args.no_build {
+        eprint!("Building... ");
+        match build() {
+            Ok(d) => eprintln!("done ({:.1}s)", d.as_secs_f64()),
+            Err(e) => {
+                eprintln!("FAILED: {e}");
+                std::process::exit(1);
+            }
+        }
+    }
+
+    // Find executables
+    let wa_exe = find_wa_exe(args.wa_path.as_deref()).unwrap_or_else(|| {
+        eprintln!("Cannot find WA.exe. Use --wa-path or set OPENWA_WA_PATH.");
+        std::process::exit(1);
+    });
+    let launcher = find_launcher().unwrap_or_else(|| {
+        eprintln!("Cannot find openwa-launcher.exe. Run cargo build first.");
+        std::process::exit(1);
+    });
+
+    // Create run directory
+    let timestamp = chrono_lite();
+    let run_dir = PathBuf::from(RUNS_DIR).join(&timestamp);
+    let _ = fs::create_dir_all(&run_dir);
+    let run_dir = strip_unc(fs::canonicalize(&run_dir).unwrap_or(run_dir));
+
+    let jobs = args.jobs.max(1);
+    println!(
+        "Running {} test{} ({} concurrent)...\n",
+        tests.len(),
+        if tests.len() == 1 { "" } else { "s" },
+        jobs
+    );
+
+    // Run
+    let wall_start = Instant::now();
+    let results = run_tests_parallel(tests, jobs, &launcher, &wa_exe, &run_dir);
+    let wall_time = wall_start.elapsed();
+
+    // Summary
+    print_summary(&results, wall_time);
+    write_summary(&results, wall_time, &run_dir.join("summary.txt"));
+
+    let failed = results.iter().any(|r| !r.passed);
+    if failed {
+        std::process::exit(1);
+    }
+}
+
+/// Simple timestamp without chrono dependency.
+fn chrono_lite() -> String {
+    use std::time::SystemTime;
+    let d = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap_or_default();
+    let secs = d.as_secs();
+    // Convert to roughly readable format (not perfect but unique)
+    let s = secs % 60;
+    let m = (secs / 60) % 60;
+    let h = (secs / 3600) % 24;
+    let days = secs / 86400;
+    // Days since epoch → approximate date
+    let (y, mo, day) = days_to_ymd(days);
+    format!("{y:04}-{mo:02}-{day:02}_{h:02}-{m:02}-{s:02}")
+}
+
+fn days_to_ymd(mut days: u64) -> (u64, u64, u64) {
+    // Rough Gregorian approximation
+    let mut y = 1970;
+    loop {
+        let ydays = if y % 4 == 0 && (y % 100 != 0 || y % 400 == 0) { 366 } else { 365 };
+        if days < ydays { break; }
+        days -= ydays;
+        y += 1;
+    }
+    let leap = y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
+    let mdays = [31, if leap { 29 } else { 28 }, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    let mut m = 0;
+    while m < 12 && days >= mdays[m] {
+        days -= mdays[m];
+        m += 1;
+    }
+    (y, m as u64 + 1, days + 1)
+}

crates/openwa-wormkit/src/lib.rs

@@ -19,10 +19,11 @@ mod validation;
 const DLL_PROCESS_ATTACH: u32 = 1;
 const DLL_PROCESS_DETACH: u32 = 0;
 
-/// Named event shared with the launcher. The launcher waits on this event
-/// after DLL injection before resuming WA.exe's main thread, guaranteeing
-/// all hooks are installed before any WA code runs.
-const HOOKS_READY_EVENT: &[u8] = b"OpenWA_HooksReady\0";
+/// Named event prefix shared with the launcher. The full event name is
+/// `OpenWA_HooksReady_{pid}` where pid is the WA.exe process ID. Both the
+/// launcher (which knows the child PID) and the DLL (via GetCurrentProcessId)
+/// independently construct the same name, enabling concurrent instances.
+const HOOKS_READY_EVENT_PREFIX: &str = "OpenWA_HooksReady_";
 
 #[no_mangle]
 unsafe extern "system" fn DllMain(
@@ -51,7 +52,8 @@ unsafe extern "system" fn DllMain(
 pub use openwa_core::log::log_line;
 
 fn clear_log() -> std::io::Result<()> {
-    std::fs::write("OpenWA.log", "")?;
+    let path = std::env::var_os("OPENWA_LOG_PATH").unwrap_or("OpenWA.log".into());
+    std::fs::write(path, "")?;
     Ok(())
 }
 
@@ -61,7 +63,9 @@ fn clear_log() -> std::io::Result<()> {
 
 fn run() -> Result<(), String> {
     let _ = clear_log();
-    let _ = std::fs::write("OpenWA_validation.log", "");
+    let validation_path = std::env::var_os("OPENWA_VALIDATION_LOG_PATH")
+        .unwrap_or("OpenWA_validation.log".into());
+    let _ = std::fs::write(validation_path, "");
 
     // Install panic hook that writes to our log file
     std::panic::set_hook(Box::new(|info| {
@@ -106,24 +110,26 @@ fn run() -> Result<(), String> {
     Ok(())
 }
 
-/// Signal the `OpenWA_HooksReady` named event so the launcher knows it's
-/// safe to resume WA.exe's main thread.
+/// Signal the `OpenWA_HooksReady_{pid}` named event so the launcher knows
+/// it's safe to resume WA.exe's main thread.
 fn signal_hooks_ready() {
     use windows_sys::Win32::Foundation::CloseHandle;
-    use windows_sys::Win32::System::Threading::{OpenEventA, SetEvent};
+    use windows_sys::Win32::System::Threading::{GetCurrentProcessId, OpenEventA, SetEvent};
 
     const EVENT_MODIFY_STATE: u32 = 0x0002;
 
     unsafe {
+        let pid = GetCurrentProcessId();
+        let event_name = format!("{}{}\0", HOOKS_READY_EVENT_PREFIX, pid);
         let handle = OpenEventA(
             EVENT_MODIFY_STATE,
             0, // bInheritHandle = FALSE
-            HOOKS_READY_EVENT.as_ptr(),
+            event_name.as_ptr(),
         );
         if !handle.is_null() {
             SetEvent(handle);
             CloseHandle(handle);
-            let _ = log_line("=== Signalled OpenWA_HooksReady ===");
+            let _ = log_line(&format!("=== Signalled {}{} ===", HOOKS_READY_EVENT_PREFIX, pid));
         }
         // If handle is null, we weren't launched by our launcher — that's fine.
     }

crates/openwa-wormkit/src/replacements/replay.rs

@@ -23,6 +23,15 @@ use std::os::windows::io::FromRawHandle;
 use std::path::Path;
 use std::path::PathBuf;
 
+// ─── Per-instance playback.thm path ─────────────────────────────────────────
+
+/// Returns a per-process playback.thm path to avoid races during concurrent tests.
+/// Uses PID suffix so multiple WA instances don't clobber each other's map data.
+fn playback_thm_path() -> String {
+    let pid = std::process::id();
+    format!("data\\playback_{pid}.thm")
+}
+
 // ─── WA CRT FILE* conversion ────────────────────────────────────────────────
 //
 // WA's CRT FILE* can't be used with Rust's std::fs::File directly, but we can
@@ -137,8 +146,9 @@ unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
     let first_dword = *(payload as *const i32);
     (*gi).replay_map_type = first_dword;
     if first_dword >= 1 {
-        // Write payload to playback.thm using Rust File
-        let _ = std::fs::write("data\\playback.thm", payload_slice);
+        // Write payload to a per-instance temp file to avoid races during concurrent testing.
+        let thm_path = playback_thm_path();
+        let _ = std::fs::write(&thm_path, payload_slice);
     } else {
         (*gi).replay_payload_2 = *(payload.add(4) as *const i32);
         if first_dword >= -4 && first_dword < -2 {
@@ -571,7 +581,9 @@ unsafe fn parse_and_write_v2plus(
 
         let load: unsafe extern "stdcall" fn(*mut MapView, *const u8, i32) -> i32 =
             core::mem::transmute(rb(va::MAP_VIEW_LOAD));
-        let ok = load(map, b"data\\playback.thm\0".as_ptr(), 0);
+        let thm_path = playback_thm_path();
+        let thm_cstr: Vec<u8> = thm_path.bytes().chain(std::iter::once(0)).collect();
+        let ok = load(map, thm_cstr.as_ptr(), 0);
 
         if ok == 0 {
             if !map.is_null() {