feat: add gameplay milestone checks to replay testing

Replace misleading "133 PASS" output (all static checks) with two
distinct categories:

- Static checks ([STATIC PASS/FAIL]): vtables, struct offsets, prologues
- Gameplay checks ([GAMEPLAY PASS/FAIL]): game init, match start, match end

Gameplay milestones are detected hook-based via TurnManager_ProcessFrame
(no timers): frame counter for init, health-based alive-team counting
for match start/completion. Report written from DLL_PROCESS_DETACH.

Key finding: team arena indices are 1-based (index 0 is unused preamble),
and sentinel header fields like worm_count are populated lazily — direct
worm health checks are more reliable for early-frame detection.

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

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

@@ -33,9 +33,11 @@ powershell -ExecutionPolicy Bypass -File replay-test.ps1 -Headless
 - If `testdata/logs/errorlog_latest.txt` exists, WA.exe crashed. Read it and report the crash (exception type, address, registers)
 
 **Headful mode:**
-- Read `testdata/logs/validation_latest.log` and summarize total PASS/FAIL counts
-- Quote any [FAIL] lines exactly
-- Note whether validation completed or safety timeout triggered
+- Read `testdata/logs/validation_latest.log` and check two categories:
+  - **Static checks** (`[STATIC PASS]`/`[STATIC FAIL]`): vtable addresses, struct offsets, function prologues. These verify memory layout correctness but NOT that the game actually ran.
+  - **Gameplay checks** (`[GAMEPLAY PASS]`/`[GAMEPLAY FAIL]`): milestone-based detection of game initialization, match start (multiple alive teams), and match completion (winner decided). These confirm the replay actually played through.
+- Quote any FAIL lines exactly
+- Note whether safety timeout triggered
 - If `testdata/logs/openwa_latest.log` exists, check for errors or interesting hook activity
 
 **Headless mode:**

crates/openwa-wormkit/src/lib.rs

@@ -14,6 +14,7 @@ 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
@@ -32,6 +33,10 @@ unsafe extern "system" fn DllMain(
                 let _ = log_line(&format!("[FATAL] {e}"));
             }
         });
+    } else if reason == DLL_PROCESS_DETACH {
+        // Write gameplay milestone report before the process exits.
+        // This fires on natural exit, safety timeout, and headless mode.
+        replacements::write_gameplay_report();
     }
     1 // TRUE
 }

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

@@ -1,4 +1,4 @@
-//! Replay fast-forward via DDGame+0x98B0.
+//! Replay fast-forward via DDGame+0x98B0 and gameplay milestone tracking.
 //!
 //! When `OPENWA_REPLAY_TEST=1`, hooks TurnManager_ProcessFrame (0x55FDA0)
 //! and sets DDGame+0x98B0 (fast-forward active flag) each frame.
@@ -9,14 +9,25 @@
 //! FUN_0055BDD0), so we re-set it every frame.
 //!
 //! This is the same mechanism triggered by key 0x35 (spacebar) during replay.
+//!
+//! ## Gameplay Milestones
+//!
+//! The frame hook also tracks gameplay milestones via atomic flags:
+//! - **Game initialized**: TurnManager_ProcessFrame called at least once
+//! - **Match started**: Multiple teams with alive worms detected
+//! - **Match completed**: Only one (or zero) teams have alive worms remaining
+//!
+//! These milestones are reported by `write_gameplay_report()` at DLL detach,
+//! providing reliable hook-based game progress detection without timers.
 
 #![allow(dead_code)]
 
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU32, Ordering};
 
 use crate::hook;
 use crate::log_line;
 use openwa_core::address::va;
+use openwa_core::engine::ddgame::{offsets, TeamArenaRef};
 use openwa_core::engine::{DDGame, DDGameWrapper};
 use openwa_core::rebase::rb;
 
@@ -30,6 +41,28 @@ static ORIG_TURN_MANAGER: AtomicU32 = AtomicU32::new(0);
 /// Whether to set fast-forward flag (only in replay test mode).
 static FAST_FORWARD: AtomicBool = AtomicBool::new(false);
 
+// ---------------------------------------------------------------------------
+// Gameplay milestone tracking
+// ---------------------------------------------------------------------------
+
+/// Total frames processed by TurnManager_ProcessFrame.
+static FRAMES_PROCESSED: AtomicU32 = AtomicU32::new(0);
+
+/// Milestone: at least 2 teams with alive worms detected.
+static MATCH_STARTED: AtomicBool = AtomicBool::new(false);
+
+/// Milestone: match decided — only 0 or 1 teams have alive worms.
+static MATCH_COMPLETED: AtomicBool = AtomicBool::new(false);
+
+/// Number of teams that had alive worms when match started.
+static TEAMS_AT_START: AtomicU32 = AtomicU32::new(0);
+
+/// Frame number when match completion was detected.
+static COMPLETION_FRAME: AtomicU32 = AtomicU32::new(0);
+
+/// Number of alive teams when match completed (0 = draw, 1 = winner).
+static ALIVE_AT_END: AtomicI32 = AtomicI32::new(-1);
+
 /// Get the DDGame pointer (session+0xA0 → DDGameWrapper.ddgame).
 #[inline]
 unsafe fn get_ddgame() -> *mut DDGame {
@@ -148,6 +181,39 @@ pub unsafe fn dump_region(base_ptr: *const u8, offset: usize, size: usize, struc
     }
 }
 
+/// Count how many teams have at least one alive worm.
+///
+/// Iterates all 8 worm slots per team and checks `health > 0` (reliable
+/// even before sentinel headers are fully populated). This is more
+/// conservative than checking headers, which may be populated lazily.
+///
+/// Returns (alive_team_count, total_team_count).
+unsafe fn count_alive_teams(ddgame: *const DDGame) -> (i32, i32) {
+    let arena_base = (ddgame as u32) + offsets::TEAM_ARENA_STATE as u32;
+    let arena = TeamArenaRef::from_raw(arena_base);
+    let team_count = arena.state().team_count;
+    if team_count <= 0 || team_count > 6 {
+        return (0, 0);
+    }
+
+    let mut alive_teams = 0i32;
+    // Teams are 1-indexed in the arena (index 0 is unused preamble).
+    for t in 1..=team_count as usize {
+        let mut team_has_alive = false;
+        for w in 1..=8usize {
+            let worm = arena.team_worm(t, w);
+            if worm.health > 0 {
+                team_has_alive = true;
+                break;
+            }
+        }
+        if team_has_alive {
+            alive_teams += 1;
+        }
+    }
+    (alive_teams, team_count)
+}
+
 /// Hook for TurnManager_ProcessFrame (stdcall, 1 param = TurnGame*).
 unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
     // Call original first
@@ -155,6 +221,8 @@ unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
         core::mem::transmute(ORIG_TURN_MANAGER.load(Ordering::Relaxed));
     orig(turngame);
 
+    let frame = FRAMES_PROCESSED.fetch_add(1, Ordering::Relaxed) + 1;
+
     let ddgame = get_ddgame();
     if ddgame.is_null() {
         return;
@@ -164,6 +232,89 @@ unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
     if FAST_FORWARD.load(Ordering::Relaxed) {
         (*ddgame).fast_forward_active = 1;
     }
+
+    // Milestone detection (check every 50 frames to reduce overhead).
+    // Skip the first 100 frames to let game state fully initialize.
+    if frame >= 100 && frame % 50 == 0 {
+        check_milestones(ddgame, frame);
+    }
+}
+
+/// Check and update gameplay milestones.
+unsafe fn check_milestones(ddgame: *const DDGame, frame: u32) {
+    if MATCH_COMPLETED.load(Ordering::Relaxed) {
+        return;
+    }
+
+    let (alive, _total) = count_alive_teams(ddgame);
+
+    if !MATCH_STARTED.load(Ordering::Relaxed) {
+        if alive >= 2 {
+            MATCH_STARTED.store(true, Ordering::Relaxed);
+            TEAMS_AT_START.store(alive as u32, Ordering::Relaxed);
+        }
+    } else {
+        // Match started — check if it's now decided
+        if alive <= 1 {
+            MATCH_COMPLETED.store(true, Ordering::Relaxed);
+            COMPLETION_FRAME.store(frame, Ordering::Relaxed);
+            ALIVE_AT_END.store(alive, Ordering::Relaxed);
+        }
+    }
+}
+
+/// Write gameplay milestone report to the validation log.
+///
+/// Called from DLL_PROCESS_DETACH to provide a final summary of game progress.
+/// Uses `[GAMEPLAY PASS]` / `[GAMEPLAY FAIL]` markers so the PowerShell script
+/// can distinguish these from static checks.
+pub fn write_gameplay_report() {
+    use crate::validation::log_validation;
+
+    let frames = FRAMES_PROCESSED.load(Ordering::Relaxed);
+    let started = MATCH_STARTED.load(Ordering::Relaxed);
+    let completed = MATCH_COMPLETED.load(Ordering::Relaxed);
+
+    let _ = log_validation("");
+    let _ = log_validation("--- Gameplay Checks ---");
+
+    // Milestone 1: Game initialized (frame hook was called)
+    if frames > 0 {
+        let _ = log_validation(&format!(
+            "[GAMEPLAY PASS] Game initialized - {} frames processed",
+            frames
+        ));
+    } else {
+        let _ = log_validation("[GAMEPLAY FAIL] Game initialized - no frames processed (game may not have started)");
+    }
+
+    // Milestone 2: Match started (multiple teams with alive worms)
+    if started {
+        let teams = TEAMS_AT_START.load(Ordering::Relaxed);
+        let _ = log_validation(&format!(
+            "[GAMEPLAY PASS] Match started - {} teams with alive worms detected",
+            teams
+        ));
+    } else if frames > 0 {
+        let _ = log_validation("[GAMEPLAY FAIL] Match started - never detected multiple alive teams");
+    } else {
+        let _ = log_validation("[GAMEPLAY FAIL] Match started - game never initialized");
+    }
+
+    // Milestone 3: Match completed (one or zero teams remain)
+    if completed {
+        let end_frame = COMPLETION_FRAME.load(Ordering::Relaxed);
+        let alive = ALIVE_AT_END.load(Ordering::Relaxed);
+        let outcome = if alive == 1 { "winner decided" } else { "draw (all eliminated)" };
+        let _ = log_validation(&format!(
+            "[GAMEPLAY PASS] Match completed - {} at frame {}",
+            outcome, end_frame
+        ));
+    } else if started {
+        let _ = log_validation("[GAMEPLAY FAIL] Match completed - match started but never finished");
+    } else {
+        let _ = log_validation("[GAMEPLAY FAIL] Match completed - match never started");
+    }
 }
 
 pub fn install() -> Result<(), String> {

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

@@ -15,6 +15,11 @@ mod speech;
 mod team;
 mod weapon;
 
+/// Write gameplay milestone report. Called from DLL_PROCESS_DETACH.
+pub fn write_gameplay_report() {
+    input::write_gameplay_report();
+}
+
 pub fn install_all() -> Result<(), String> {
     headless::install()?;
     display::install()?;

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

@@ -55,10 +55,10 @@ impl ValidationResult {
     fn check(&mut self, name: &str, ok: bool, detail: &str) {
         if ok {
             self.pass += 1;
-            let _ = log_validation(&format!("[PASS] {} - {}", name, detail));
+            let _ = log_validation(&format!("[STATIC PASS] {} - {}", name, detail));
         } else {
             self.fail += 1;
-            let _ = log_validation(&format!("[FAIL] {} - {}", name, detail));
+            let _ = log_validation(&format!("[STATIC FAIL] {} - {}", name, detail));
         }
     }
 
@@ -1705,7 +1705,7 @@ pub fn run() -> Result<(), String> {
     validate_struct_offsets(&mut result);
 
     let _ = log_validation("");
-    let _ = log_validation("--- Static Validation Summary ---");
+    let _ = log_validation("--- Static Checks (vtables, struct offsets, prologues) ---");
     let _ = log_validation(&format!("  {}", result.summary_line()));
 
     match hooks::install_all() {

replay-test.ps1

@@ -166,17 +166,25 @@ if ($Headless) {
     Write-Host "=== Validation Summary ===" -ForegroundColor Cyan
     if (Test-Path "$logDir\validation_latest.log") {
         $content = Get-Content "$logDir\validation_latest.log" -Raw
-        $passes = ([regex]::Matches($content, "\[PASS\]")).Count
-        $fails  = ([regex]::Matches($content, "\[FAIL\]")).Count
-        Write-Host "  PASS: $passes" -ForegroundColor Green
-        Write-Host "  FAIL: $fails" -ForegroundColor $(if ($fails -gt 0) { "Red" } else { "Green" })
+
+        # 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
-        } elseif ($content -match "deferred global validation") {
-            Write-Host "  Validation: completed" -ForegroundColor Green
-        } else {
-            Write-Host "  Validation: NOT found in log (may not have reached gameplay)" -ForegroundColor Yellow
         }
     }
     # Check for Rust panics in OpenWA log