feat: hook CreateFileA for per-instance landscape file isolation

Hook kernel32!CreateFileA in headless mode to redirect landscape
generation temp files (mono.tmp, land.dat, landgen.svg) to per-PID
paths. This prevents concurrent WA.exe instances from clobbering
each other's landscape data during parallel replay testing.

Also: update test runner to default j=4, clean up per-PID temp files
after test runs, remove unnecessary launch stagger comment.

Concurrent test results: 7 tests in ~12s (j=4) vs ~36s (serial).
Occasional flakiness at j=7 from unidentified remaining shared resource.

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

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

@@ -15,10 +15,7 @@ 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 DEFAULT_JOBS: usize = 4;
 const TIMEOUT_SECS: u64 = 120;
 const REPLAYS_DIR: &str = "testdata/replays";
 const RUNS_DIR: &str = "testdata/runs";
@@ -228,6 +225,7 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
         .stderr(std::process::Stdio::null())
         .status();
 
+
     let duration = start.elapsed();
 
     match result {
@@ -374,12 +372,13 @@ fn run_tests_parallel(
     }
     drop(tx); // Drop our sender so rx closes when all workers finish
 
-    // Submit work with small stagger to avoid startup races
+    // Submit work with small stagger to reduce startup races from unidentified
+    // shared resources (writetest.txt, steam.dat, or unknown Win32 globals).
     for (idx, test) in tests.into_iter().enumerate() {
-        let _ = work_tx.send((idx, test));
         if idx > 0 {
-            thread::sleep(Duration::from_millis(1000));
+            thread::sleep(Duration::from_millis(200));
         }
+        let _ = work_tx.send((idx, test));
     }
     drop(work_tx); // Signal no more work
 
@@ -460,6 +459,45 @@ fn write_summary(results: &[TestResult], wall_time: Duration, path: &Path) {
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
+/// Clean up per-PID temp files left by the file isolation hook.
+/// Matches patterns: mono_*.tmp, land_*.dat, landgen_*.svg, playback_*.thm, cur_*.thm
+fn cleanup_temp_files(wa_exe: &Path) {
+    let game_dir = match wa_exe.parent() {
+        Some(d) => d,
+        None => return,
+    };
+
+    let patterns = [
+        (game_dir, "mono_", ".tmp"),
+        (game_dir, "cur_", ".thm"),
+    ];
+    let data_dir = game_dir.join("DATA");
+    let data_patterns = [
+        ("land_", ".dat"),
+        ("landgen_", ".svg"),
+        ("playback_", ".thm"),
+    ];
+
+    for (dir, prefix, suffix) in &patterns {
+        cleanup_matching(dir, prefix, suffix);
+    }
+    for (prefix, suffix) in &data_patterns {
+        cleanup_matching(&data_dir, prefix, suffix);
+    }
+}
+
+fn cleanup_matching(dir: &Path, prefix: &str, suffix: &str) {
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let name = entry.file_name();
+            let name = name.to_string_lossy();
+            if name.starts_with(prefix) && name.ends_with(suffix) {
+                let _ = fs::remove_file(entry.path());
+            }
+        }
+    }
+}
+
 /// Normalize CRLF to LF for cross-platform comparison.
 fn normalize_crlf(data: &[u8]) -> Vec<u8> {
     let mut out = Vec::with_capacity(data.len());
@@ -541,6 +579,9 @@ fn main() {
     print_summary(&results, wall_time);
     write_summary(&results, wall_time, &run_dir.join("summary.txt"));
 
+    // Clean up per-PID temp files from the game directory
+    cleanup_temp_files(&wa_exe);
+
     let failed = results.iter().any(|r| !r.passed);
     if failed {
         std::process::exit(1);

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

@@ -0,0 +1,127 @@
+//! Per-instance file path isolation for concurrent test execution.
+//!
+//! Hooks `kernel32!CreateFileA` to redirect landscape generation temp files
+//! to per-PID paths, preventing races when multiple WA.exe instances run
+//! simultaneously. Only active when `OPENWA_HEADLESS=1` is set.
+//!
+//! Redirected files (in game directory):
+//!   mono.tmp        → mono_{pid}.tmp
+//!   DATA\land.dat   → DATA\land_{pid}.dat
+//!   DATA\landgen.svg → DATA\landgen_{pid}.svg
+
+use crate::log_line;
+
+use core::ffi::c_void;
+use core::sync::atomic::{AtomicU32, Ordering};
+use std::ffi::CStr;
+
+type HANDLE = *mut c_void;
+type DWORD = u32;
+type BOOL = i32;
+type LPSECURITY_ATTRIBUTES = *mut c_void;
+
+type CreateFileAFn = unsafe extern "system" fn(
+    lpFileName: *const u8,
+    dwDesiredAccess: DWORD,
+    dwShareMode: DWORD,
+    lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
+    dwCreationDisposition: DWORD,
+    dwFlagsAndAttributes: DWORD,
+    hTemplateFile: HANDLE,
+) -> HANDLE;
+
+static ORIG_CREATE_FILE_A: AtomicU32 = AtomicU32::new(0);
+
+/// Check if a path ends with one of our target filenames (case-insensitive).
+/// Returns the replacement path if it matches, None otherwise.
+fn redirect_path(path: &str) -> Option<String> {
+    let pid = std::process::id();
+    let lower = path.to_ascii_lowercase();
+
+    if lower.ends_with("\\mono.tmp") || lower == "mono.tmp" {
+        let prefix = &path[..path.len() - "mono.tmp".len()];
+        Some(format!("{prefix}mono_{pid}.tmp"))
+    } else if lower.ends_with("\\land.dat") || lower.ends_with("/land.dat") {
+        let prefix = &path[..path.len() - "land.dat".len()];
+        Some(format!("{prefix}land_{pid}.dat"))
+    } else if lower.ends_with("\\landgen.svg") || lower.ends_with("/landgen.svg") {
+        let prefix = &path[..path.len() - "landgen.svg".len()];
+        Some(format!("{prefix}landgen_{pid}.svg"))
+    } else {
+        None
+    }
+}
+
+unsafe extern "system" fn hook_create_file_a(
+    lp_file_name: *const u8,
+    desired_access: DWORD,
+    share_mode: DWORD,
+    security_attributes: LPSECURITY_ATTRIBUTES,
+    creation_disposition: DWORD,
+    flags_and_attributes: DWORD,
+    template_file: HANDLE,
+) -> HANDLE {
+    let orig: CreateFileAFn = core::mem::transmute(ORIG_CREATE_FILE_A.load(Ordering::Relaxed));
+
+    if !lp_file_name.is_null() {
+        if let Ok(path) = CStr::from_ptr(lp_file_name as *const i8).to_str() {
+            if let Some(new_path) = redirect_path(path) {
+                let cstr: Vec<u8> = new_path.bytes().chain(std::iter::once(0)).collect();
+                return orig(
+                    cstr.as_ptr(),
+                    desired_access,
+                    share_mode,
+                    security_attributes,
+                    creation_disposition,
+                    flags_and_attributes,
+                    template_file,
+                );
+            }
+        }
+    }
+
+    orig(
+        lp_file_name,
+        desired_access,
+        share_mode,
+        security_attributes,
+        creation_disposition,
+        flags_and_attributes,
+        template_file,
+    )
+}
+
+pub fn install() -> Result<(), String> {
+    if std::env::var("OPENWA_HEADLESS").is_err() {
+        return Ok(()); // Only active in headless mode
+    }
+
+    unsafe {
+        let module = windows_sys::Win32::System::LibraryLoader::GetModuleHandleA(
+            b"kernel32.dll\0".as_ptr(),
+        );
+        if module.is_null() {
+            return Err("kernel32.dll not loaded".to_string());
+        }
+
+        let proc = windows_sys::Win32::System::LibraryLoader::GetProcAddress(
+            module,
+            b"CreateFileA\0".as_ptr(),
+        );
+        let addr = proc.ok_or("CreateFileA not found in kernel32.dll")?;
+        let target = addr as *mut c_void;
+        let trampoline = minhook::MinHook::create_hook(target, hook_create_file_a as *mut c_void)
+            .map_err(|e| format!("MinHook create_hook failed for CreateFileA: {e}"))?;
+        minhook::MinHook::enable_hook(target)
+            .map_err(|e| format!("MinHook enable_hook failed for CreateFileA: {e}"))?;
+
+        ORIG_CREATE_FILE_A.store(trampoline as u32, Ordering::Relaxed);
+
+        let pid = std::process::id();
+        let _ = log_line(&format!(
+            "[FileIsolation] Hooked CreateFileA (pid={pid}): mono.tmp, land.dat, landgen.svg → per-PID paths"
+        ));
+    }
+
+    Ok(())
+}

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

@@ -1,6 +1,7 @@
 mod config;
 mod ddgame_init;
 mod display;
+mod file_isolation;
 mod frontend;
 mod game_session;
 mod game_state_hooks;
@@ -22,6 +23,7 @@ pub fn write_gameplay_report() {
 
 pub fn install_all() -> Result<(), String> {
     headless::install()?;
+    file_isolation::install()?;
     display::install()?;
     game_session::install()?;
     hardware_init::install()?;