fix: high-concurrency test crashes from premature thread resume

Root cause: the launcher's hooks-ready event had a 10s timeout. Under
high concurrency (j=16), DLL loading + hook installation exceeds 10s
due to I/O contention, causing the launcher to resume WA.exe's main
thread before all hooks are installed. The FireWeapon trap then fires
because WeaponRelease (last hook in the chain) was never installed.

Fix: increase hooks-ready timeout to 120s (matching test runner timeout).

Also:
- Redirect all temp files to per-PID .openwa_tmp/{pid}/ directory
instead of individual per-PID suffixed filenames. Now covers
writetest.txt, mono.tmp, custom.dat, current.thm, playback.thm
in addition to existing land.dat, landgen.svg
- Clean up temp directory on DLL detach and in test runner
- Remove 200ms test stagger (no longer needed with proper isolation)
- Add .gitignore for replay output logs (only *_expected.log tracked)

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

crates/openwa-launcher/src/main.rs

@@ -230,9 +230,11 @@ unsafe fn launch(
     }
 
     // Wait for the DLL to signal that all hooks are installed.
-    // Timeout after 10s to avoid hanging if the DLL crashes during init.
+    // Use a generous timeout — under high concurrency (e.g. 16 parallel
+    // test instances), DLL loading + hook installation can exceed 10s due
+    // to I/O contention. 120s matches the test runner's own timeout.
     if !event.is_null() {
-        let wait_result = WaitForSingleObject(event, 10_000);
+        let wait_result = WaitForSingleObject(event, 120_000);
         if wait_result != 0 {
             eprintln!("openwa-launcher: warning: hooks-ready event timed out ({wait_result})");
         }

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

@@ -433,12 +433,7 @@ fn run_tests_parallel(
     }
     drop(tx); // Drop our sender so rx closes when all workers finish
 
-    // 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() {
-        if idx > 0 {
-            thread::sleep(Duration::from_millis(200));
-        }
         let _ = work_tx.send((idx, test));
     }
     drop(work_tx); // Signal no more work
@@ -605,27 +600,20 @@ 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
+/// Clean up temp files and directories left by the file isolation hook.
+///
+/// The DLL creates `.openwa_tmp/{pid}/` directories and cleans them on exit,
+/// but crashed processes may leave orphans. Also cleans stale ERRORLOG/CRASH files.
 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);
+    // Remove the .openwa_tmp directory tree (all per-PID temp dirs)
+    let tmp_dir = game_dir.join(".openwa_tmp");
+    if tmp_dir.exists() {
+        let _ = fs::remove_dir_all(&tmp_dir);
     }
 
     // Clean up any stale ERRORLOG.TXT / CRASH.DMP in the game directory
@@ -633,18 +621,6 @@ fn cleanup_temp_files(wa_exe: &Path) {
     let _ = fs::remove_file(game_dir.join("CRASH.DMP"));
 }
 
-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());

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

@@ -1,13 +1,13 @@
 //! 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
+//! Hooks `kernel32!CreateFileA` to redirect temp/scratch files to a per-PID
+//! subdirectory, 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
+//! Redirected files:
+//!   Game dir:  writetest.txt, mono.tmp, custom.dat
+//!   DATA\:     land.dat, landgen.svg, current.thm, playback.thm
+//!   ERRORLOG:  ERRORLOG.TXT → OPENWA_ERRORLOG_PATH (if set)
 
 use crate::log_line;
 
@@ -33,6 +33,7 @@ type CreateFileAFn = unsafe extern "system" fn(
 static ORIG_CREATE_FILE_A: AtomicU32 = AtomicU32::new(0);
 
 static ERRORLOG_PATH: OnceLock<Option<String>> = OnceLock::new();
+static TEMP_DIR: OnceLock<Option<String>> = OnceLock::new();
 
 fn errorlog_redirect() -> Option<&'static str> {
     ERRORLOG_PATH
@@ -40,34 +41,62 @@ fn errorlog_redirect() -> Option<&'static str> {
         .as_deref()
 }
 
+/// Get (and lazily create) a per-PID temp directory under the game folder.
+fn temp_dir() -> Option<&'static str> {
+    TEMP_DIR
+        .get_or_init(|| {
+            // Build path: {game_dir}\.openwa_tmp\{pid}\
+            let pid = std::process::id();
+            let mut game_dir = std::env::current_dir().ok()?;
+            game_dir.push(format!(".openwa_tmp\\{pid}"));
+            std::fs::create_dir_all(&game_dir).ok()?;
+            // Also create DATA subdirectory
+            std::fs::create_dir_all(game_dir.join("DATA")).ok()?;
+            Some(game_dir.to_string_lossy().into_owned())
+        })
+        .as_deref()
+}
+
+/// Files in the game root directory that need isolation.
+const ROOT_FILES: &[&str] = &["writetest.txt", "mono.tmp", "custom.dat"];
+
+/// Files in the DATA subdirectory that need isolation.
+const DATA_FILES: &[&str] = &["land.dat", "landgen.svg", "current.thm", "playback.thm"];
+
 /// 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 lower = path.to_ascii_lowercase();
+
     // ERRORLOG.TXT → env var path (if set by test runner)
     if let Some(target) = errorlog_redirect() {
-        let lower = path.to_ascii_lowercase();
-        if lower.ends_with("\\errorlog.txt") || lower.ends_with("/errorlog.txt")
+        if lower.ends_with("\\errorlog.txt")
+            || lower.ends_with("/errorlog.txt")
             || lower == "errorlog.txt"
         {
             return Some(target.to_string());
         }
     }
 
-    let pid = std::process::id();
-    let lower = path.to_ascii_lowercase();
+    let tmp = temp_dir()?;
 
-    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
+    // Check root-level files (writetest.txt, mono.tmp, custom.dat)
+    for &name in ROOT_FILES {
+        if lower.ends_with(&format!("\\{name}")) || lower == name {
+            return Some(format!("{tmp}\\{name}"));
+        }
     }
+
+    // Check DATA\ files (land.dat, landgen.svg, current.thm, playback.thm)
+    for &name in DATA_FILES {
+        let pattern_bs = format!("\\{name}");
+        let pattern_fs = format!("/{name}");
+        if lower.ends_with(&pattern_bs) || lower.ends_with(&pattern_fs) {
+            return Some(format!("{tmp}\\DATA\\{name}"));
+        }
+    }
+
+    None
 }
 
 unsafe extern "system" fn hook_create_file_a(
@@ -135,15 +164,27 @@ pub fn install() -> Result<(), String> {
         ORIG_CREATE_FILE_A.store(trampoline as u32, Ordering::Relaxed);
 
         let pid = std::process::id();
-        let errorlog_msg = if let Some(target) = errorlog_redirect() {
-            format!(", ERRORLOG.TXT → {target}")
-        } else {
-            String::new()
-        };
+        let tmp_msg = temp_dir()
+            .map(|d| format!(" → {d}"))
+            .unwrap_or_default();
+        let errorlog_msg = errorlog_redirect()
+            .map(|t| format!(", ERRORLOG.TXT → {t}"))
+            .unwrap_or_default();
         let _ = log_line(&format!(
-            "[FileIsolation] Hooked CreateFileA (pid={pid}): mono.tmp, land.dat, landgen.svg → per-PID paths{errorlog_msg}"
+            "[FileIsolation] Hooked CreateFileA (pid={pid}): temp files{tmp_msg}{errorlog_msg}"
         ));
     }
 
     Ok(())
 }
+
+/// Clean up the per-PID temp directory. Called during DLL detach or test cleanup.
+pub fn cleanup() {
+    if let Some(tmp) = TEMP_DIR.get().and_then(|o| o.as_deref()) {
+        let _ = std::fs::remove_dir_all(tmp);
+        // Also try to remove parent .openwa_tmp if empty
+        if let Some(parent) = std::path::Path::new(tmp).parent() {
+            let _ = std::fs::remove_dir(parent);
+        }
+    }
+}

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

@@ -18,9 +18,10 @@ mod team;
 mod weapon;
 mod weapon_release;
 
-/// Write gameplay milestone report. Called from DLL_PROCESS_DETACH.
+/// Write gameplay milestone report and clean up. Called from DLL_PROCESS_DETACH.
 pub fn write_gameplay_report() {
     input::write_gameplay_report();
+    file_isolation::cleanup();
 }
 
 pub fn install_all() -> Result<(), String> {

testdata/replays/.gitignore

@@ -0,0 +1,3 @@
+# Output logs from WA.exe /getlog mode — only *_expected.log baselines are tracked
+*.log
+!*_expected.log