feat: add headful replay testing to Rust test runner

Merge replay-test.ps1's headful mode into openwa-test as a new
`headful` subcommand. Runs with graphics+sound, checks for crashes,
panics, and [GAMEPLAY PASS/FAIL] markers. Supports filter by name
or direct .WAgame path, with configurable --timeout (default 150s).

replay-test.ps1 is now a thin wrapper like run-tests.ps1.

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

.claude/skills/replay-test/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: replay-test
-description: Run automated replay-based testing - builds, launches WA.exe with a replay file, captures validation logs, and presents results. Supports headful (graphics + validation) and headless (pure simulation + log diff) modes.
+description: Run automated replay-based testing - builds, launches WA.exe with a replay file, and presents results. Supports headful (graphics + gameplay checks) and headless (pure simulation + log diff) modes via the openwa-test binary.
 ---
 
 # Replay Test
 
 Run the replay-based automated testing pipeline.
 
-## Quick Start — Run All Tests
+## Quick Start — Run All Tests (Headless)
 
 The fastest way to run all replay tests:
 
@@ -15,7 +15,7 @@ The fastest way to run all replay tests:
 .\run-tests.ps1
 ```
 
-This builds and runs the `openwa-test` binary via `cargo run`, which then builds the DLL + launcher, discovers all `testdata/replays/*.WAgame` files with matching `*_expected.log`, and runs them concurrently (default 4 workers) in headless mode. Output:
+This builds and runs the `openwa-test` binary, which builds the DLL + launcher, discovers all `testdata/replays/*.WAgame` files with matching `*_expected.log`, and runs them concurrently (default 4 workers) in headless mode. Output:
 
 ```
 Building... done (2.1s)
@@ -35,48 +35,45 @@ Options:
 
 ## Modes
 
-### Headless test runner (primary)
+### Headless (primary)
 
 Uses WA's built-in `/getlog` mode: no rendering, pure CPU simulation. Compares the output log byte-for-byte against an expected baseline.
 
 ```bash
-# All tests:
 .\run-tests.ps1
-
-# Single replay via old script:
-powershell -ExecutionPolicy Bypass -File replay-test.ps1 -Headless testdata/replays/longbow.WAgame
+.\run-tests.ps1 longbow
 ```
 
-### Headful (interactive) — graphics, sound, validation
+### Headful — graphics, sound, gameplay validation
 
-Tests hooks, struct layouts, and game state with the full rendering pipeline active. Use for debugging specific replays.
+Tests hooks, struct layouts, and game state with the full rendering pipeline active. Runs sequentially. The game window must be focused once for the replay to start advancing, after which it runs to completion on its own.
 
 ```bash
-powershell -ExecutionPolicy Bypass -File replay-test.ps1
+.\replay-test.ps1
+.\replay-test.ps1 bots
+.\replay-test.ps1 testdata/replays/bots.WAgame
+.\replay-test.ps1 bots --timeout 600    # 10 minute timeout
 ```
 
+Both scripts are thin wrappers around `openwa-test` / `openwa-test headful`.
+
 ## Steps (for Claude)
 
 1. Run the appropriate test command.
 
 2. Read the output and present results:
 
-**Headless (test runner):**
+**Headless:**
 - PASS/FAIL summary is printed directly
 - Per-run logs stored in `testdata/runs/<timestamp>/`
 - FAIL shows first differing lines between expected and actual
 
-**Headless (single replay via script):**
-- PASS means byte-identical output to `<replay>_expected.log`
-- FAIL shows the diff lines
-
-**Headful mode:**
-- If `testdata/logs/errorlog_latest.txt` exists, WA.exe crashed. Read it and report the crash
-- Read `testdata/logs/validation_latest.log`:
-  - **Static checks** (`[STATIC PASS]`/`[STATIC FAIL]`): vtable addresses, struct offsets
-  - **Gameplay checks** (`[GAMEPLAY PASS]`/`[GAMEPLAY FAIL]`): game init, match start, match completion
-- Quote any FAIL lines exactly
-- Check `testdata/logs/openwa_latest.log` for `[PANIC]` errors
+**Headful:**
+- PASS/FAIL summary is printed directly
+- Per-run logs stored in `testdata/runs/headful-<timestamp>/`
+- Checks OpenWA.log for `[PANIC]` errors and `[GAMEPLAY PASS]`/`[GAMEPLAY FAIL]` markers
+- PASS requires: no crash, no panics, no gameplay fails, at least one gameplay pass
+- CRASH shows NTSTATUS name and ERRORLOG.TXT content
 
 ## Environment Variables
 
@@ -84,15 +81,15 @@ powershell -ExecutionPolicy Bypass -File replay-test.ps1
 - `OPENWA_REPLAY_TEST=1` — (headful) Enable fast-forward mode (50x speed)
 - `OPENWA_LOG_PATH=<path>` — Override OpenWA.log location (per-instance isolation)
 
-All are set automatically by the test runner / replay-test.ps1.
+All are set automatically by the test runner.
 
 ## Key Paths
 
 - Replay files + expected logs: `testdata/replays/*.WAgame` + `*_expected.log`
 - Per-run output: `testdata/runs/<timestamp>/` (gitignored)
 - Test runner: `crates/openwa-test-runner/` (`openwa-test` binary)
-- Convenience script: `run-tests.ps1`
-- Single-replay script: `replay-test.ps1`
+- Headless script: `run-tests.ps1`
+- Headful script: `replay-test.ps1`
 
 ## Adding New Replay Tests
 
@@ -103,6 +100,7 @@ All are set automatically by the test runner / replay-test.ps1.
 
 ## Notes
 
-- Headful replay: ~15-30s; headless: ~5s per test
+- Headful replay: ~15-30s per test; headless: ~5s per test
+- Headful timeout defaults to 150s, configurable with `--timeout SECS`
 - Concurrent headless tests use per-PID event names, log paths, and temp files (CreateFileA hook)
 - Named event: `OpenWA_HooksReady_{pid}` — ensures hooks installed before WA main thread runs

CLAUDE.md

@@ -29,16 +29,31 @@ Unit tests: `cargo test`. These are standard Rust tests covering parsers and typ
 
 WA.exe can deterministically replay recorded games (`.WAgame` files). Each replay test runs the game with the injected DLL and checks that the output matches a baseline log (`*_expected.log`) captured from unmodified WA.exe.
 
-**Headless** (`.\run-tests.ps1`): Pure CPU simulation, no rendering. Fast, runs in parallel (default 4 concurrent). Validates game logic — a log mismatch means the Rust code caused a desync. Spurious flakes from race conditions can occur; retry with `-j 1` to confirm.
+Two ways to run replay tests:
 
-**Headful** (`/replay-test` skill): Runs with graphics and sound. Requires user interaction. Needed to validate visual/audio hooks — code can pass headless but crash headful (or vice versa) since rendering and sound paths are only exercised headfully.
+### Headless (`.\run-tests.ps1`)
 
-**Use replay testing to validate assumptions and test theories.** Implement a hypothesis, run tests, iterate. You can add temporary log statements and see their results by running replay tests.
+Pure CPU simulation, no rendering. Fast, runs in parallel (default 4 concurrent). Validates game logic — a log mismatch means the Rust code caused a desync. Spurious flakes from race conditions can occur; retry with `-j 1` to confirm.
 
-**IMPORTANT:** The `*_expected.log` baselines are ground truth from unmodified WA.exe. They must NEVER be deleted or regenerated. If a test fails, the Rust code is wrong.
+### Headful (`.\replay-test.ps1` or `openwa-test headful`)
+
+Runs with graphics and sound. The game window must be focused once to start. Needed to validate visual/audio hooks — code can pass headless but crash headful (or vice versa) since rendering and sound paths are only exercised headfully. Checks for crashes, panics, and `[GAMEPLAY PASS/FAIL]` markers. Timeout configurable with `--timeout SECS` (default 150s).
 
 See `crates/openwa-test-runner/CLAUDE.md` for test isolation, crash detection, adding new tests, and env vars. Use `/desync-debug` skill after a test failure to diagnose.
 
+### Use replay testing to validate assumptions and test theories
+
+Implement a hypothesis, run tests, iterate. You can add temporary log statements and see their results by running replay tests.
+
+### **IMPORTANT**: Replay tests can only test two things:
+
+- The game simulation matches the original WA.exe, to the extent covered by the replay log and the replay's built-in checksums
+- The game doesn't crash
+
+You, as an agent, CANNOT see or hear the game, and therefore you can't verify that anything related to graphics or audio is correct. A passing headful replay test is NOT a guarantee that the rendering is correct. You need to involve the user to verify all graphics and audio related changes before committing or merging.
+
+### **IMPORTANT:** The `*_expected.log` baselines are ground truth from unmodified WA.exe. They must NEVER be deleted or regenerated, unless explicitly requested by the user. If a test fails, the Rust code is wrong.
+
 ## Debug CLI
 
 Use the `/debug-cli` skill for live memory inspection, struct inspection, frame-level control, and pointer chain traversal.

crates/openwa-test-runner/CLAUDE.md

@@ -1,6 +1,12 @@
 # openwa-test-runner
 
-Headless replay test runner (`openwa-test` binary). Discovers replay tests in `testdata/replays/`, runs them concurrently via WA.exe's `/getlog` mode, and compares output logs byte-for-byte against expected baselines.
+Replay test runner (`openwa-test` binary). Supports headless (concurrent, log-diff) and headful (sequential, gameplay checks) modes.
+
+## Subcommands
+
+- `openwa-test [filter] [-j N] [--no-build] [--wa-path PATH]` — Headless: discovers `testdata/replays/*.WAgame` with `*_expected.log`, runs concurrently via `/getlog`, compares output byte-for-byte.
+- `openwa-test headful [filter|replay.WAgame] [--no-build] [--wa-path PATH] [--timeout SECS]` — Headful: runs with graphics+sound, checks for crashes/panics/gameplay markers. Default timeout 150s.
+- `openwa-test trace-desync <replay.WAgame> [--no-build] [--wa-path PATH]` — Compares per-frame checksums between baseline and hooked runs.
 
 ## Test Isolation
 
@@ -18,6 +24,10 @@ All isolation mechanisms are active in headless mode only:
 
 Tests that crash show `CRASH` (not `FAIL`) with NTSTATUS name and ERRORLOG.TXT content. ERRORLOG.TXT is redirected to the per-test run directory via `OPENWA_ERRORLOG_PATH`.
 
+## Headful Pass Criteria
+
+A headful test passes when: no crash, no `[PANIC]` in OpenWA.log, no `[GAMEPLAY FAIL]`, and at least one `[GAMEPLAY PASS]` marker present.
+
 ## Adding New Replay Tests
 
 1. Record a game in WA.exe (the replay `.WAgame` file is saved automatically)
@@ -28,11 +38,13 @@ Tests that crash show `CRASH` (not `FAIL`) with NTSTATUS name and ERRORLOG.TXT c
 ## Environment Variables
 
 - `OPENWA_HEADLESS=1` — Headless mode: hooks MessageBoxA to auto-dismiss, launcher uses SW_HIDE, file isolation hook active, semaphore renamed per-PID
+- `OPENWA_REPLAY_TEST=1` — Headful mode: enables fast-forward replay (50x speed)
 - `OPENWA_LOG_PATH=<path>` — Override OpenWA.log location (used for per-instance isolation)
 - `OPENWA_ERRORLOG_PATH=<path>` — Redirect ERRORLOG.TXT to specified path (crash capture)
 
 ## Key Paths
 
 - Replay files + expected logs: `testdata/replays/*.WAgame` + `*_expected.log`
-- Per-run output: `testdata/runs/<timestamp>/` (gitignored)
-- Convenience script: `run-tests.ps1`
+- Per-run output: `testdata/runs/<timestamp>/` (headless), `testdata/runs/headful-<timestamp>/` (headful)
+- Headless script: `run-tests.ps1`
+- Headful script: `replay-test.ps1`

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

@@ -667,6 +667,334 @@ fn parse_errorlog_exception(content: Option<&str>) -> &'static str {
     "crash (SEH handled)"
 }
 
+// ─── Headful subcommand ────────────────────────────────────────────────────
+
+const DEFAULT_HEADFUL_TIMEOUT_SECS: u64 = 150;
+
+struct HeadfulArgs {
+    filter_or_replay: Option<String>,
+    no_build: bool,
+    wa_path: Option<PathBuf>,
+    timeout_secs: u64,
+}
+
+fn parse_headful_args(argv: &[String]) -> HeadfulArgs {
+    let mut args = HeadfulArgs {
+        filter_or_replay: None,
+        no_build: false,
+        wa_path: None,
+        timeout_secs: DEFAULT_HEADFUL_TIMEOUT_SECS,
+    };
+    let mut i = 0;
+    while i < argv.len() {
+        match argv[i].as_str() {
+            "--no-build" => args.no_build = true,
+            "--wa-path" => {
+                i += 1;
+                if i < argv.len() {
+                    args.wa_path = Some(PathBuf::from(&argv[i]));
+                }
+            }
+            "--timeout" | "-t" => {
+                i += 1;
+                if i < argv.len() {
+                    args.timeout_secs = argv[i]
+                        .parse()
+                        .unwrap_or(DEFAULT_HEADFUL_TIMEOUT_SECS);
+                }
+            }
+            s if !s.starts_with('-') && args.filter_or_replay.is_none() => {
+                args.filter_or_replay = Some(s.to_string());
+            }
+            other => {
+                eprintln!("Unknown argument: {other}");
+                eprintln!(
+                    "Usage: openwa-test headful [filter|replay.WAgame] [--no-build] [--wa-path PATH] [--timeout SECS]"
+                );
+                std::process::exit(1);
+            }
+        }
+        i += 1;
+    }
+    args
+}
+
+/// Discover replays for headful testing. Unlike headless, doesn't require _expected.log.
+/// If `filter_or_replay` ends with .WAgame and exists, treat it as a direct path.
+fn discover_headful_tests(filter_or_replay: Option<&str>) -> Vec<TestCase> {
+    // Direct .WAgame path?
+    if let Some(arg) = filter_or_replay {
+        let path = Path::new(arg);
+        if arg.ends_with(".WAgame") && path.exists() {
+            let abs = strip_unc(fs::canonicalize(path).unwrap_or(path.to_path_buf()));
+            let stem = abs
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .unwrap_or("unknown")
+                .to_string();
+            return vec![TestCase {
+                name: stem,
+                replay_path: abs.clone(),
+                expected_log: abs.with_extension("expected.log"),
+                output_log: abs.with_extension("log"),
+            }];
+        }
+    }
+
+    // Scan replays dir with optional filter
+    let replays_dir = Path::new(REPLAYS_DIR);
+    let entries = match fs::read_dir(replays_dir) {
+        Ok(e) => e,
+        Err(e) => {
+            eprintln!("Cannot read {REPLAYS_DIR}: {e}");
+            return Vec::new();
+        }
+    };
+
+    let mut tests = Vec::new();
+    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_or_replay {
+            if !stem.contains(filter) {
+                continue;
+            }
+        }
+        // No _expected.log requirement for headful
+        let abs = strip_unc(fs::canonicalize(&path).unwrap_or(path.clone()));
+        tests.push(TestCase {
+            name: stem,
+            replay_path: abs.clone(),
+            expected_log: abs.with_extension("expected.log"),
+            output_log: abs.with_extension("log"),
+        });
+    }
+    tests.sort_by(|a, b| a.name.cmp(&b.name));
+    tests
+}
+
+/// Analyze an OpenWA.log for panics and gameplay check markers.
+struct HeadfulLogAnalysis {
+    panics: Vec<String>,
+    gameplay_passes: Vec<String>,
+    gameplay_fails: Vec<String>,
+}
+
+fn analyze_headful_log(log_path: &Path) -> HeadfulLogAnalysis {
+    let content = fs::read_to_string(log_path).unwrap_or_default();
+    let mut analysis = HeadfulLogAnalysis {
+        panics: Vec::new(),
+        gameplay_passes: Vec::new(),
+        gameplay_fails: Vec::new(),
+    };
+    for line in content.lines() {
+        if line.contains("[PANIC]") {
+            analysis.panics.push(line.to_string());
+        } else if line.contains("[GAMEPLAY PASS]") {
+            analysis.gameplay_passes.push(line.to_string());
+        } else if line.contains("[GAMEPLAY FAIL]") {
+            analysis.gameplay_fails.push(line.to_string());
+        }
+    }
+    analysis
+}
+
+/// Run a single headful replay test.
+fn run_headful_test(
+    test: &TestCase,
+    launcher: &Path,
+    wa_exe: &Path,
+    run_dir: &Path,
+    timeout_secs: u64,
+) -> TestResult {
+    let start = Instant::now();
+
+    let openwa_log = run_dir.join(format!("{}.openwa.log", test.name));
+    let errorlog_path = run_dir.join(format!("{}.errorlog.txt", test.name));
+
+    let result = Command::new(launcher)
+        .arg("--minimized")
+        .arg(wa_exe)
+        .arg(&test.replay_path)
+        .env("OPENWA_REPLAY_TEST", "1")
+        .env("OPENWA_LOG_PATH", &openwa_log)
+        .env("OPENWA_ERRORLOG_PATH", &errorlog_path)
+        .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}")),
+            crashed: None,
+        },
+        Ok(status) => {
+            let exit_code = status.code().unwrap_or(0);
+
+            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()),
+                    crashed: None,
+                };
+            }
+
+            // Crash detection (same as headless)
+            let errorlog_content = fs::read(&errorlog_path)
+                .ok()
+                .filter(|b| !b.is_empty())
+                .map(|b| String::from_utf8_lossy(&b).into_owned());
+
+            if is_crash_exit_code(exit_code) || errorlog_content.is_some() {
+                let unsigned = exit_code as u32;
+                let name = if is_crash_exit_code(exit_code) {
+                    ntstatus_name(unsigned)
+                } else {
+                    parse_errorlog_exception(errorlog_content.as_deref())
+                };
+                return TestResult {
+                    name: test.name.clone(),
+                    passed: false,
+                    duration,
+                    diff_lines: Vec::new(),
+                    error: None,
+                    crashed: Some(CrashInfo {
+                        exit_code: unsigned,
+                        name,
+                        errorlog_content,
+                    }),
+                };
+            }
+
+            // Analyze OpenWA.log for panics and gameplay markers
+            let analysis = analyze_headful_log(&openwa_log);
+
+            let mut detail_lines = Vec::new();
+            for line in &analysis.panics {
+                detail_lines.push(format!("PANIC: {line}"));
+            }
+            for line in &analysis.gameplay_fails {
+                detail_lines.push(format!("FAIL: {line}"));
+            }
+            for line in &analysis.gameplay_passes {
+                detail_lines.push(line.clone());
+            }
+
+            let passed = analysis.panics.is_empty()
+                && analysis.gameplay_fails.is_empty()
+                && !analysis.gameplay_passes.is_empty();
+
+            let error = if analysis.gameplay_passes.is_empty()
+                && analysis.panics.is_empty()
+                && analysis.gameplay_fails.is_empty()
+            {
+                Some(format!(
+                    "No gameplay markers found in log (exit code: {exit_code})"
+                ))
+            } else {
+                None
+            };
+
+            TestResult {
+                name: test.name.clone(),
+                passed,
+                duration,
+                diff_lines: detail_lines,
+                error,
+                crashed: None,
+            }
+        }
+    }
+}
+
+fn run_headful(args: HeadfulArgs) {
+    let tests = discover_headful_tests(args.filter_or_replay.as_deref());
+    if tests.is_empty() {
+        eprintln!("No replay tests found in {REPLAYS_DIR}/");
+        if let Some(f) = &args.filter_or_replay {
+            eprintln!("  (filter/path: \"{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);
+            }
+        }
+    }
+
+    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);
+    });
+
+    // Clean stale files from game dir
+    if let Some(game_dir) = wa_exe.parent() {
+        let _ = fs::remove_file(game_dir.join("ERRORLOG.TXT"));
+        let _ = fs::remove_file(game_dir.join("OpenWA.log"));
+    }
+
+    let timestamp = timestamp();
+    let run_dir = PathBuf::from(RUNS_DIR).join(format!("headful-{timestamp}"));
+    let _ = fs::create_dir_all(&run_dir);
+    let run_dir = strip_unc(fs::canonicalize(&run_dir).unwrap_or(run_dir));
+
+    println!(
+        "Running {} headful test{}...\n",
+        tests.len(),
+        if tests.len() == 1 { "" } else { "s" }
+    );
+
+    let wall_start = Instant::now();
+    let mut results = Vec::new();
+
+    for test in &tests {
+        let result = run_headful_test(test, &launcher, &wa_exe, &run_dir, args.timeout_secs);
+        print_result(&result);
+        results.push(result);
+    }
+
+    let wall_time = wall_start.elapsed();
+
+    print_summary(&results, wall_time);
+    write_summary(&results, wall_time, &run_dir.join("summary.txt"));
+
+    // Report startup check failures
+    report_startup_check_failures(&results, &run_dir);
+
+    cleanup_temp_files(&wa_exe);
+
+    let failed = results.iter().any(|r| !r.passed);
+    if failed {
+        std::process::exit(1);
+    }
+}
+
 // ─── Trace-desync subcommand ─────────────────────────────────────────────
 
 struct TraceDesyncArgs {
@@ -995,10 +1323,18 @@ fn report_startup_check_failures(results: &[TestResult], run_dir: &Path) {
 fn main() {
     // Check for subcommands before normal arg parsing
     let argv: Vec<String> = env::args().skip(1).collect();
-    if argv.first().map(|s| s.as_str()) == Some("trace-desync") {
-        let sub_args = parse_trace_desync_args(&argv[1..]);
-        run_trace_desync(sub_args);
-        return;
+    match argv.first().map(|s| s.as_str()) {
+        Some("headful") => {
+            let sub_args = parse_headful_args(&argv[1..]);
+            run_headful(sub_args);
+            return;
+        }
+        Some("trace-desync") => {
+            let sub_args = parse_trace_desync_args(&argv[1..]);
+            run_trace_desync(sub_args);
+            return;
+        }
+        _ => {}
     }
 
     let args = parse_args();

replay-test.ps1

@@ -1,217 +1,6 @@
-# replay-test.ps1 - Automated replay-based testing
-# Usage: powershell -File replay-test.ps1 [-Headless] [replay-file]
-#
-# Modes:
-#   Default (headful): Fast-forward replay with validation, graphics & sound active.
-#   -Headless:         Uses WA's /getlog mode -- no window, pure simulation.
-#                      Compares output log to expected log for determinism checking.
+# Run a headful replay test via the Rust test runner.
+# Usage: .\replay-test.ps1 [filter|replay.WAgame] [--no-build] [--wa-path PATH]
+cargo build -p openwa-test-runner --release
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
 
-param(
-    [switch]$Headless,
-    [string]$ReplayFile = "testdata\replays\bots.WAgame"
-)
-
-$ErrorActionPreference = "Stop"
-
-# Resolve WA installation directory using the same priority order as openwa-config:
-#   1. OPENWA_WA_PATH env var (may be WA.exe path or directory)
-#   2. HKCU\SOFTWARE\Team17SoftwareLTD\WormsArmageddon, value PATH
-function Get-WaDir {
-    if ($env:OPENWA_WA_PATH) {
-        $p = $env:OPENWA_WA_PATH
-        if ($p -match '\.exe$') { return Split-Path $p }
-        return $p
-    }
-    try {
-        $reg = Get-ItemPropertyValue -Path 'HKCU:\SOFTWARE\Team17SoftwareLTD\WormsArmageddon' -Name 'PATH' -ErrorAction Stop
-        if ($reg) { return $reg }
-    } catch {}
-    return $null
-}
-
-$gameDir = Get-WaDir
-if (-not $gameDir) {
-    Write-Error "Cannot find WA installation. Set OPENWA_WA_PATH or ensure the registry key HKCU\SOFTWARE\Team17SoftwareLTD\WormsArmageddon\PATH is set."
-    exit 1
-}
-$waExe   = Join-Path $gameDir "WA.exe"
-$src     = "target\i686-pc-windows-msvc\release"
-$logDir  = "testdata\logs"
-
-# Resolve replay file to absolute path
-if (-not [System.IO.Path]::IsPathRooted($ReplayFile)) {
-    $ReplayFile = Join-Path (Get-Location) $ReplayFile
-}
-
-if (-not (Test-Path $ReplayFile)) {
-    Write-Error "Replay file not found: $ReplayFile"
-    exit 1
-}
-
-# 1. Build launcher + DLL
-Write-Host "Building..." -ForegroundColor Cyan
-cargo build --release -p openwa-launcher -p openwa-wormkit
-if ($LASTEXITCODE -ne 0) { exit 1 }
-
-$launcher = "$src\openwa-launcher.exe"
-
-# 2. Clear old logs
-Remove-Item "$gameDir\OpenWA.log"            -ErrorAction SilentlyContinue
-Remove-Item "$gameDir\OpenWA_validation.log" -ErrorAction SilentlyContinue
-Remove-Item "$gameDir\ERRORLOG.TXT"          -ErrorAction SilentlyContinue
-
-# Remove old WormKit DLL if present from a previous deployment
-if (Test-Path "$gameDir\wkOpenWA.dll") {
-    Write-Host "Note: removing legacy $gameDir\wkOpenWA.dll" -ForegroundColor Yellow
-    Remove-Item "$gameDir\wkOpenWA.dll"
-}
-if (Test-Path "$gameDir\wkOpenWAValidator.dll") {
-    Remove-Item "$gameDir\wkOpenWAValidator.dll"
-}
-
-# 3. Launch via launcher with replay, env vars set
-if ($Headless) {
-    Write-Host "Launching WA.exe in HEADLESS mode: $ReplayFile" -ForegroundColor Cyan
-    Write-Host "  (No window -- pure simulation via /getlog)" -ForegroundColor Yellow
-
-    # Remove any previous output log next to the replay file
-    $replayBase = [System.IO.Path]::ChangeExtension($ReplayFile, ".log")
-    Remove-Item $replayBase -ErrorAction SilentlyContinue
-
-    $env:OPENWA_HEADLESS = "1"
-    $proc = Start-Process -FilePath $launcher -ArgumentList "`"$waExe`" /getlog `"$ReplayFile`"" -PassThru
-    $timeout = 120
-} else {
-    Write-Host "Launching WA.exe with replay: $ReplayFile" -ForegroundColor Cyan
-    Write-Host "  (Fast-forward mode: replay will be auto-advanced, game exits when done)" -ForegroundColor Yellow
-
-    $env:OPENWA_REPLAY_TEST = "1"
-    $proc = Start-Process -FilePath $launcher -ArgumentList "--minimized `"$waExe`" `"$ReplayFile`"" -PassThru
-    $timeout = 150
-}
-
-if (-not $proc.WaitForExit($timeout * 1000)) {
-    Write-Host "WARNING: launcher did not exit within ${timeout}s, killing..." -ForegroundColor Red
-    $proc.Kill()
-    $proc.WaitForExit(5000)
-}
-$env:OPENWA_REPLAY_TEST = $null
-$env:OPENWA_HEADLESS    = $null
-$env:OPENWA_WA_PATH     = $null
-
-Write-Host "Launcher exited with code $($proc.ExitCode)" -ForegroundColor Cyan
-
-# 4. Copy logs back
-if (-not (Test-Path $logDir)) {
-    New-Item -ItemType Directory -Path $logDir | Out-Null
-}
-
-$timestamp = Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
-
-if (Test-Path "$gameDir\OpenWA_validation.log") {
-    Copy-Item "$gameDir\OpenWA_validation.log" "$logDir\validation_$timestamp.log"
-    Copy-Item "$gameDir\OpenWA_validation.log" "$logDir\validation_latest.log"
-    Write-Host "Validation log copied." -ForegroundColor Green
-} else {
-    Write-Host "WARNING: No validation log found!" -ForegroundColor Red
-}
-
-if (Test-Path "$gameDir\OpenWA.log") {
-    Copy-Item "$gameDir\OpenWA.log" "$logDir\openwa_$timestamp.log"
-    Copy-Item "$gameDir\OpenWA.log" "$logDir\openwa_latest.log"
-    Write-Host "OpenWA log copied." -ForegroundColor Green
-}
-
-$crashed = $false
-if (Test-Path "$gameDir\ERRORLOG.TXT") {
-    Copy-Item "$gameDir\ERRORLOG.TXT" "$logDir\errorlog_$timestamp.txt"
-    Copy-Item "$gameDir\ERRORLOG.TXT" "$logDir\errorlog_latest.txt"
-    Write-Host "ERRORLOG.TXT copied (crash detected)." -ForegroundColor Red
-    $crashed = $true
-} else {
-    Remove-Item "$logDir\errorlog_latest.txt" -ErrorAction SilentlyContinue
-}
-
-# 5. Crash check (before summary, so it always runs)
-if ($crashed) {
-    Write-Host ""
-    Write-Host "=== CRASH DETECTED ===" -ForegroundColor Red
-    Get-Content "$logDir\errorlog_latest.txt" -TotalCount 5 | ForEach-Object {
-        Write-Host "  $_" -ForegroundColor Red
-    }
-    Write-Host "  ..." -ForegroundColor Red
-    Write-Host "  Full log: $logDir\errorlog_latest.txt" -ForegroundColor Gray
-    exit 1
-}
-
-# 6. Print summary
-Write-Host ""
-if ($Headless) {
-    Write-Host "=== Headless Log Comparison ===" -ForegroundColor Cyan
-    $replayBase = [System.IO.Path]::ChangeExtension($ReplayFile, ".log")
-    $expectedLog = [System.IO.Path]::Combine(
-        [System.IO.Path]::GetDirectoryName($ReplayFile),
-        [System.IO.Path]::GetFileNameWithoutExtension($ReplayFile) + "_expected.log"
-    )
-
-    if (-not (Test-Path $replayBase)) {
-        Write-Host "  FAIL: No output log generated at $replayBase" -ForegroundColor Red
-        exit 1
-    }
-    if (-not (Test-Path $expectedLog)) {
-        Write-Host "  No expected log found -- saving output as expected: $expectedLog" -ForegroundColor Yellow
-        Copy-Item $replayBase $expectedLog
-        Write-Host "  PASS (first run -- expected log created)" -ForegroundColor Green
-    } else {
-        $diff = Compare-Object (Get-Content $expectedLog) (Get-Content $replayBase)
-        if ($diff) {
-            Write-Host "  FAIL: Output differs from expected log" -ForegroundColor Red
-            Write-Host ""
-            $diff | ForEach-Object {
-                $indicator = if ($_.SideIndicator -eq "<=") { "expected" } else { "actual  " }
-                Write-Host "  $indicator | $($_.InputObject)" -ForegroundColor $(if ($_.SideIndicator -eq "<=") { "Red" } else { "Yellow" })
-            }
-            exit 1
-        } else {
-            Write-Host "  PASS: Output matches expected log" -ForegroundColor Green
-        }
-    }
-    # Clean up the generated log
-    Remove-Item $replayBase -ErrorAction SilentlyContinue
-} else {
-    Write-Host "=== Validation Summary ===" -ForegroundColor Cyan
-    if (Test-Path "$logDir\validation_latest.log") {
-        $content = Get-Content "$logDir\validation_latest.log" -Raw
-
-        # Static checks (vtables, struct offsets, prologues)
-        $staticPasses = ([regex]::Matches($content, "\[STATIC PASS\]")).Count
-        $staticFails  = ([regex]::Matches($content, "\[STATIC FAIL\]")).Count
-        $staticColor = if ($staticFails -gt 0) { "Red" } else { "Green" }
-        Write-Host "  Static checks:   $staticPasses pass, $staticFails fail  (vtables, struct offsets, prologues)" -ForegroundColor $staticColor
-
-        # Gameplay checks (milestones from frame hook)
-        $gameplayPasses = ([regex]::Matches($content, "\[GAMEPLAY PASS\]")).Count
-        $gameplayFails  = ([regex]::Matches($content, "\[GAMEPLAY FAIL\]")).Count
-        if ($gameplayPasses + $gameplayFails -gt 0) {
-            $gameplayColor = if ($gameplayFails -gt 0) { "Red" } else { "Green" }
-            Write-Host "  Gameplay checks: $gameplayPasses pass, $gameplayFails fail  (init, match start, match end)" -ForegroundColor $gameplayColor
-        } else {
-            Write-Host "  Gameplay checks: not found (DLL may not have detached cleanly)" -ForegroundColor Yellow
-        }
-
-        if ($content -match "Safety timeout reached") {
-            Write-Host "  Replay: TIMEOUT (safety timeout triggered)" -ForegroundColor Red
-        }
-    }
-    # Check for Rust panics in OpenWA log
-    if (Test-Path "$logDir\openwa_latest.log") {
-        $panics = Select-String -Path "$logDir\openwa_latest.log" -Pattern "\[PANIC\]"
-        if ($panics) {
-            Write-Host ""
-            Write-Host "=== RUST PANIC DETECTED ===" -ForegroundColor Red
-            $panics | ForEach-Object { Write-Host "  $($_.Line)" -ForegroundColor Red }
-        }
-    }
-
-    Write-Host "  Logs: $logDir\" -ForegroundColor Gray
-}
+& "$PSScriptRoot\target\i686-pc-windows-msvc\release\openwa-test.exe" headful @args