feat: test runner crash detection, ERRORLOG capture, and dialog suppression

- Launcher passes /silentcrash to WA.exe in headless mode, preventing
the crash handler from relaunching with /handlecrash and showing the
"Fatal error" dialog that blocks test execution
- Hook ERRORLOG.TXT creation via OPENWA_ERRORLOG_PATH env var to
redirect crash logs to per-test paths in the run directory
- Detect crashes by NTSTATUS exit codes or ERRORLOG.TXT presence,
show CRASH status with exception details and first 20 lines of
the error log (using lossy UTF-8 for binary memory dumps)
- Strip ANSI color codes when stdout is not a terminal
- Add RE notes for Frontend__MainNavigationLoop (crash handler mechanism)

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

crates/openwa-launcher/src/main.rs

@@ -139,6 +139,13 @@ fn run() -> Result<(), String> {
         .parent()
         .ok_or("WA.exe path has no parent directory")?;
 
+    // In headless mode, suppress WA.exe's crash dialog. The crash handler
+    // (SEH at 0x5A5A20) checks this flag before deciding to relaunch with
+    // /handlecrash — if set, it silently writes ERRORLOG.TXT and returns.
+    if std::env::var("OPENWA_HEADLESS").is_ok() {
+        wa_args.push("/silentcrash".to_string());
+    }
+
     let cmdline = build_cmdline(&wa_exe, &wa_args);
 
     println!(

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

@@ -7,6 +7,7 @@
 use std::env;
 use std::fmt::Write as FmtWrite;
 use std::fs;
+use std::io::IsTerminal;
 use std::os::windows::process::CommandExt;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -38,6 +39,13 @@ struct TestCase {
     output_log: PathBuf,
 }
 
+#[derive(Clone)]
+struct CrashInfo {
+    exit_code: u32,
+    name: &'static str,
+    errorlog_content: Option<String>,
+}
+
 #[derive(Clone)]
 struct TestResult {
     name: String,
@@ -45,6 +53,7 @@ struct TestResult {
     duration: Duration,
     diff_lines: Vec<String>,
     error: Option<String>,
+    crashed: Option<CrashInfo>,
 }
 
 struct Args {
@@ -222,6 +231,7 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
 
     // Per-instance log paths
     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(wa_exe)
@@ -229,6 +239,7 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
         .arg(&test.replay_path)
         .env("OPENWA_HEADLESS", "1")
         .env("OPENWA_LOG_PATH", &openwa_log)
+        .env("OPENWA_ERRORLOG_PATH", &errorlog_path)
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null())
         .creation_flags(CREATE_NO_WINDOW)
@@ -243,8 +254,11 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
             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(),
@@ -252,6 +266,40 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
                     duration,
                     diff_lines: Vec::new(),
                     error: Some("Timeout".to_string()),
+                    crashed: None,
+                };
+            }
+
+            // Check for crash: either an NTSTATUS exit code (negative i32)
+            // or the presence of ERRORLOG.TXT (WA.exe's SEH handler catches
+            // exceptions and exits cleanly, so exit code may be 0).
+            // Use lossy conversion — ERRORLOG.TXT may contain binary
+            // memory dump data that isn't valid UTF-8.
+            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 exception from ERRORLOG first line, e.g.
+                    // "WA caused an Access Violation (0xc0000005)"
+                    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,
+                    }),
                 };
             }
 
@@ -269,9 +317,9 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
                     duration,
                     diff_lines: Vec::new(),
                     error: Some(format!(
-                        "No output log generated (exit code: {})",
-                        status.code().unwrap_or(-1)
+                        "No output log generated (exit code: {exit_code})"
                     )),
+                    crashed: None,
                 };
             }
 
@@ -288,6 +336,7 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
                     duration,
                     diff_lines: Vec::new(),
                     error: None,
+                    crashed: None,
                 }
             } else {
                 let mut diff = compute_diff(&expected, &actual);
@@ -305,6 +354,7 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
                     duration,
                     diff_lines: diff,
                     error: None,
+                    crashed: None,
                 }
             }
         }
@@ -415,15 +465,53 @@ fn run_tests_parallel(
 
 // ─── Output ─────────────────────────────────────────────────────────────────
 
+fn use_color() -> bool {
+    std::io::stdout().is_terminal()
+}
+
+fn green(text: &str) -> String {
+    if use_color() {
+        format!("\x1b[32m{text}\x1b[0m")
+    } else {
+        text.to_string()
+    }
+}
+
+fn red(text: &str) -> String {
+    if use_color() {
+        format!("\x1b[31m{text}\x1b[0m")
+    } else {
+        text.to_string()
+    }
+}
+
 fn print_result(result: &TestResult) {
     let status = if result.passed {
-        "\x1b[32m  PASS\x1b[0m"
+        green("  PASS")
+    } else if result.crashed.is_some() {
+        red(" CRASH")
     } else {
-        "\x1b[31m  FAIL\x1b[0m"
+        red("  FAIL")
     };
     let secs = result.duration.as_secs_f64();
     println!("{status}  {:<28} ({secs:.1}s)", result.name);
 
+    if let Some(crash) = &result.crashed {
+        println!(
+            "        {} (exit code: 0x{:08X})",
+            crash.name, crash.exit_code
+        );
+        if let Some(content) = &crash.errorlog_content {
+            println!("        --- ERRORLOG.TXT ---");
+            let lines: Vec<&str> = content.lines().collect();
+            for line in lines.iter().take(20) {
+                println!("        | {line}");
+            }
+            if lines.len() > 20 {
+                println!("        | ... ({} lines truncated)", lines.len() - 20);
+            }
+        }
+    }
     if let Some(err) = &result.error {
         println!("        {err}");
     }
@@ -434,34 +522,62 @@ fn print_result(result: &TestResult) {
 
 fn print_summary(results: &[TestResult], wall_time: Duration) {
     let passed = results.iter().filter(|r| r.passed).count();
+    let crashed = results.iter().filter(|r| r.crashed.is_some()).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()
-        );
+        let msg = format!("{} tests: all passed", results.len());
+        println!("{} (wall {wall:.1}s, cpu {cpu_time:.1}s)", green(&msg));
     } else {
-        println!(
-            "\x1b[31m{} tests: {passed} passed, {failed} failed\x1b[0m (wall {wall:.1}s, cpu {cpu_time:.1}s)",
+        let crash_info = if crashed > 0 {
+            format!(" ({crashed} crashed)")
+        } else {
+            String::new()
+        };
+        let msg = format!(
+            "{} tests: {passed} passed, {failed} failed{crash_info}",
             results.len()
         );
+        println!("{} (wall {wall:.1}s, cpu {cpu_time:.1}s)", red(&msg));
     }
 }
 
 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 status = if r.passed {
+            "PASS"
+        } else if r.crashed.is_some() {
+            "CRASH"
+        } else {
+            "FAIL"
+        };
         let _ = writeln!(
             s,
             "{status}  {:<28} ({:.1}s)",
             r.name,
             r.duration.as_secs_f64()
         );
+        if let Some(crash) = &r.crashed {
+            let _ = writeln!(
+                s,
+                "        {} (exit code: 0x{:08X})",
+                crash.name, crash.exit_code
+            );
+            if let Some(content) = &crash.errorlog_content {
+                let _ = writeln!(s, "        --- ERRORLOG.TXT ---");
+                for line in content.lines().take(20) {
+                    let _ = writeln!(s, "        | {line}");
+                }
+                let line_count = content.lines().count();
+                if line_count > 20 {
+                    let _ = writeln!(s, "        | ... ({} lines truncated)", line_count - 20);
+                }
+            }
+        }
         if let Some(err) = &r.error {
             let _ = writeln!(s, "        {err}");
         }
@@ -470,10 +586,16 @@ fn write_summary(results: &[TestResult], wall_time: Duration, path: &Path) {
         }
     }
     let passed = results.iter().filter(|r| r.passed).count();
+    let crashed = results.iter().filter(|r| r.crashed.is_some()).count();
     let failed = results.len() - passed;
+    let crash_info = if crashed > 0 {
+        format!(" ({crashed} crashed)")
+    } else {
+        String::new()
+    };
     let _ = writeln!(
         s,
-        "\n{} tests: {passed} passed, {failed} failed (wall {:.1}s)",
+        "\n{} tests: {passed} passed, {failed} failed{crash_info} (wall {:.1}s)",
         results.len(),
         wall_time.as_secs_f64()
     );
@@ -505,6 +627,10 @@ fn cleanup_temp_files(wa_exe: &Path) {
     for (prefix, suffix) in &data_patterns {
         cleanup_matching(&data_dir, prefix, suffix);
     }
+
+    // Clean up any stale ERRORLOG.TXT / CRASH.DMP in the game directory
+    let _ = fs::remove_file(game_dir.join("ERRORLOG.TXT"));
+    let _ = fs::remove_file(game_dir.join("CRASH.DMP"));
 }
 
 fn cleanup_matching(dir: &Path, prefix: &str, suffix: &str) {
@@ -540,6 +666,45 @@ fn strip_unc(p: PathBuf) -> PathBuf {
     }
 }
 
+/// Map common NTSTATUS exception codes to human-readable names.
+fn ntstatus_name(code: u32) -> &'static str {
+    match code {
+        0xC0000005 => "access violation",
+        0xC0000374 => "heap corruption",
+        0xC00000FD => "stack overflow",
+        0xC0000409 => "stack buffer overrun",
+        0xC000001D => "illegal instruction",
+        0xC0000135 => "DLL not found",
+        0xC0000142 => "DLL init failed",
+        0x80000003 => "breakpoint",
+        0xE06D7363 => "C++ exception", // MSVC __CxxThrowException
+        _ => "exception",
+    }
+}
+
+/// NTSTATUS exception codes have the high bit set, so they're negative as i32.
+fn is_crash_exit_code(code: i32) -> bool {
+    code < 0
+}
+
+/// Parse the exception name from the first line of ERRORLOG.TXT.
+/// Expected format: "WA caused an Access Violation (0xc0000005)"
+fn parse_errorlog_exception(content: Option<&str>) -> &'static str {
+    if let Some(line) = content.and_then(|c| c.lines().next()) {
+        // Try to extract the NTSTATUS code from parentheses
+        if let Some(start) = line.find("(0x") {
+            let hex_start = start + 1; // skip '('
+            if let Some(end) = line[hex_start..].find(')') {
+                let hex_str = &line[hex_start + 2..hex_start + end]; // skip "0x"
+                if let Ok(code) = u32::from_str_radix(hex_str, 16) {
+                    return ntstatus_name(code);
+                }
+            }
+        }
+    }
+    "crash (SEH handled)"
+}
+
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 fn main() {

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

@@ -14,6 +14,7 @@ use crate::log_line;
 use core::ffi::c_void;
 use core::sync::atomic::{AtomicU32, Ordering};
 use std::ffi::CStr;
+use std::sync::OnceLock;
 
 type HANDLE = *mut c_void;
 type DWORD = u32;
@@ -31,9 +32,27 @@ type CreateFileAFn = unsafe extern "system" fn(
 
 static ORIG_CREATE_FILE_A: AtomicU32 = AtomicU32::new(0);
 
+static ERRORLOG_PATH: OnceLock<Option<String>> = OnceLock::new();
+
+fn errorlog_redirect() -> Option<&'static str> {
+    ERRORLOG_PATH
+        .get_or_init(|| std::env::var("OPENWA_ERRORLOG_PATH").ok())
+        .as_deref()
+}
+
 /// 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> {
+    // 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")
+            || lower == "errorlog.txt"
+        {
+            return Some(target.to_string());
+        }
+    }
+
     let pid = std::process::id();
     let lower = path.to_ascii_lowercase();
 
@@ -116,8 +135,13 @@ 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 _ = log_line(&format!(
-            "[FileIsolation] Hooked CreateFileA (pid={pid}): mono.tmp, land.dat, landgen.svg → per-PID paths"
+            "[FileIsolation] Hooked CreateFileA (pid={pid}): mono.tmp, land.dat, landgen.svg → per-PID paths{errorlog_msg}"
         ));
     }
 

docs/re-notes/frontend-main-navigation-loop.md

@@ -0,0 +1,94 @@
+# Frontend__MainNavigationLoop (0x4E6700)
+
+Ghidra address: `0x004E6700`
+Calling convention: `__fastcall` (ECX = CWinApp*)
+Size: ~3500 lines of decompiled C
+
+This is the main entry point / event loop of WA.exe. It handles:
+- Command-line argument parsing
+- Crash handling (`/handlecrash`, `/silentcrash`, `/disablecrashhandler`)
+- Replay playback (`/play`, `/playat`, `/getlog`, `/getmap`, `/getscheme`, `/getvideo`, `/getlogs`)
+- Sanitize/repair modes (`/sanitise`, `/repair`)
+- Network hosting (`/host`, `wa:` protocol)
+- WormKit module loading (`/wk`, `/nowk`, `/wkargs`)
+- Frontend screen navigation loop (main menu, multiplayer, campaigns, etc.)
+- Renderer selection (DirectDraw, OpenGL, D3D9, etc.)
+
+## Crash Handler Mechanism
+
+WA.exe's crash handler works by **relaunching itself** with `/handlecrash`:
+
+1. Original WA.exe crashes (C++ exception via `__CxxThrowException`)
+2. The crash handler (likely SEH-based) writes `ERRORLOG.TXT` and relaunches WA.exe with `/handlecrash`
+3. The new WA.exe instance processes `/handlecrash` in this function
+4. It checks `Options__GetCrashReportURL()` — if crash reporting is available, shows a dialog offering to send the report
+5. It checks `DAT_0088e410` (WormKit modules loaded flag) — if set, shows the "Fatal error" dialog with Yes/No asking to disable WormKit modules
+
+### Key flags:
+- `/silentcrash` → sets `DAT_007a0f10+1 = 1` — suppresses the crash dialog
+- `/disablecrashhandler` → sets `DAT_007a0f10+0 = 1` — disables the crash handler entirely
+- `/crash` → intentionally crashes via `__CxxThrowException("Goodbye, cruel world!")`
+
+### Crash dialog code (at ~0x4E6730):
+```c
+// Check for crash report URL
+iVar11 = Options__GetCrashReportURL();
+if (iVar11 != 0) {
+    // Show "send bug report?" dialog (MB_YESNO | MB_ICONQUESTION = 0x14)
+    iVar10 = MessageBoxA(NULL,
+        "Worms Armageddon has encountered an error...\nWould you like to send the bug report?",
+        "Fatal error", 0x14);
+    if (iVar10 == IDYES) FUN_005a6470(); // send crash report
+}
+
+// Check if WormKit modules were loaded
+if (DAT_0088e410 == 0) {
+    // No WormKit — just show error (MB_ICONERROR = 0x10)
+    MessageBoxA(NULL, error_msg, "Fatal error", 0x10);
+} else {
+    // WormKit loaded — ask to disable (MB_YESNO | MB_ICONQUESTION = 0x14)
+    FUN_00444d30(); // builds error message mentioning WormKit
+    iVar11 = MessageBoxA(NULL, error_msg, "Fatal error", 0x14);
+    if (iVar11 == IDYES) {
+        DAT_0088e410 = 0;
+        FUN_004c8c70(); // disable WormKit in registry
+        MessageBoxA(NULL, "WormKit modules have been disabled.", "Worms Armageddon", 0x40);
+    }
+}
+```
+
+## ERRORLOG.TXT
+
+String at `0x00677FE0`: `"ERRORLOG.TXT"`
+String at `0x00678484`: `"Can't open ERRORLOG.TXT"`
+Written by the crash handler before relaunching (separate from this function).
+
+## `/getlog` Mode
+
+The `/getlog` flag sets:
+- `DAT_0088cd4c = 1` (headless replay mode)
+- `local_31 = 1` (getlog flag)
+- Copies replay path to `DAT_0088af58`
+
+Later in the function, `/getlog` mode opens the replay for writing the game log output.
+
+## WormKit Module Loading
+
+Around line 1200 of decompilation:
+- Searches for `wk*.dll` files in the game directory
+- Loads each via `LoadLibraryA`
+- If loading fails, shows a MessageBox with the error
+- Flag at `DAT_0088e410` tracks whether WormKit modules are loaded
+
+## Key Addresses
+
+| Address | Purpose |
+|---------|---------|
+| `0x007A0F10+0` | `/disablecrashhandler` flag |
+| `0x007A0F10+1` | `/silentcrash` flag |
+| `0x0088E410` | WormKit modules loaded flag |
+| `0x0088AF58` | Replay path buffer |
+| `0x0088CD4C` | Headless replay mode flag |
+| `0x0088E17D` | Current directory buffer |
+| `0x006B1FEC` | argc |
+| `0x006B1FF0` | argv |