refactor: split input.rs into frame_hook, replay_test, debug_utils

The old input.rs was a grab-bag of unrelated concerns. Split into:

- frame_hook.rs: TurnManager_ProcessFrame hook, debug_sync, watchpoint
arming. Always installed (including baseline/trace-desync mode).
- replay_test.rs: Fast-forward + gameplay milestone tracking. Only for
headful replay testing — headless runs at max CPU speed already.
- debug_utils.rs: dump_region memory inspection (used by validation).

Moved get_ddgame()/get_wrapper() to openwa-core::engine::game_session
as shared #[cfg(x86)] accessors, eliminating duplicates in wormkit
and debugui.

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

crates/openwa-core/src/engine/game_session.rs

@@ -93,3 +93,39 @@ pub struct GameSession {
 }
 
 const _: () = assert!(core::mem::size_of::<GameSession>() == 0x120);
+
+// ─── Runtime accessors (DLL-injected context only) ──────────────────────
+
+#[cfg(target_arch = "x86")]
+use crate::address::va;
+#[cfg(target_arch = "x86")]
+use crate::engine::ddgame::DDGame;
+#[cfg(target_arch = "x86")]
+use crate::rebase::rb;
+
+/// Get the DDGameWrapper pointer from the global game session.
+///
+/// Returns null if the session or wrapper hasn't been initialized yet.
+#[cfg(target_arch = "x86")]
+#[inline]
+pub unsafe fn get_wrapper() -> *mut DDGameWrapper {
+    let session = *(rb(va::G_GAME_SESSION) as *const *mut GameSession);
+    if session.is_null() {
+        return core::ptr::null_mut();
+    }
+    (*session).ddgame_wrapper
+}
+
+/// Get the DDGame pointer from the global game session.
+///
+/// Follows the chain: G_GAME_SESSION → GameSession.ddgame_wrapper → DDGameWrapper.ddgame.
+/// Returns null if any link in the chain is uninitialized.
+#[cfg(target_arch = "x86")]
+#[inline]
+pub unsafe fn get_ddgame() -> *mut DDGame {
+    let wrapper = get_wrapper();
+    if wrapper.is_null() {
+        return core::ptr::null_mut();
+    }
+    (*wrapper).ddgame
+}

crates/openwa-debugui/src/app.rs

@@ -1,6 +1,6 @@
 use eframe::egui;
 use openwa_core::address::va;
-use openwa_core::engine::{DDGame, DDGameWrapper};
+use openwa_core::engine::{game_session, DDGame};
 use openwa_core::rebase::rb;
 use openwa_core::registry;
 use openwa_core::task::{
@@ -51,19 +51,8 @@ unsafe fn entity_label(addr: u32) -> String {
 
 /// Returns a pointer to DDGame, or None if not in-game.
 unsafe fn get_ddgame() -> Option<*const DDGame> {
-    let session_ptr = *(rb(va::G_GAME_SESSION) as *const u32);
-    if session_ptr == 0 {
-        return None;
-    }
-    let wrapper_addr = *((session_ptr + 0xA0) as *const u32);
-    if wrapper_addr == 0 {
-        return None;
-    }
-    let ddgame_ptr = (*(wrapper_addr as *const DDGameWrapper)).ddgame;
-    if ddgame_ptr.is_null() {
-        return None;
-    }
-    Some(ddgame_ptr)
+    let ptr = game_session::get_ddgame();
+    if ptr.is_null() { None } else { Some(ptr) }
 }
 
 /// Unlock all weapons: set ammo to unlimited (-1) and delays to 0 for all teams.

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

@@ -0,0 +1,78 @@
+//! Debug memory inspection utilities.
+//!
+//! Contains `dump_region` for logging classified DWORD dumps of memory regions.
+//! Used by the validation module for struct inspection.
+
+use crate::log_line;
+use openwa_core::address::va;
+use openwa_core::rebase::rb;
+
+/// Dump a memory region as DWORDs with automatic pointer classification.
+///
+/// Uses `openwa_core::mem::classify_pointer` for pointer detection.
+pub unsafe fn dump_region(base_ptr: *const u8, offset: usize, size: usize, struct_name: &str) {
+    use openwa_core::mem;
+    use openwa_debug_proto::PointerKind;
+
+    let wa_base = rb(va::IMAGE_BASE);
+    let delta = wa_base.wrapping_sub(va::IMAGE_BASE);
+
+    let _ = log_line(&format!(
+        "\n=== {}+0x{:04X}..0x{:04X} ===",
+        struct_name,
+        offset,
+        offset + size
+    ));
+
+    let dword_count = size / 4;
+    for i in 0..dword_count {
+        let field_offset = offset + i * 4;
+        let val = *(base_ptr.add(field_offset) as *const u32);
+        if val == 0 {
+            continue;
+        }
+
+        if let Some(info) = mem::classify_pointer(val, delta) {
+            let detail_str = info.detail.as_deref().unwrap_or("");
+            match info.kind {
+                PointerKind::Vtable => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [VTABLE] g:0x{:08X} {}",
+                        field_offset, val, info.ghidra_value, detail_str
+                    ));
+                }
+                PointerKind::Code => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [CODE] g:0x{:08X}",
+                        field_offset, val, info.ghidra_value
+                    ));
+                }
+                PointerKind::Data => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [DATA] g:0x{:08X}",
+                        field_offset, val, info.ghidra_value
+                    ));
+                }
+                PointerKind::Object => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [OBJECT] {}",
+                        field_offset, val, detail_str
+                    ));
+                }
+                PointerKind::Heap => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [ptr] {}",
+                        field_offset, val, detail_str
+                    ));
+                }
+            }
+        } else if val < 0x10000 {
+            let _ = log_line(&format!(
+                "  +0x{:04X}: 0x{:08X} [small={}]",
+                field_offset, val, val
+            ));
+        } else {
+            let _ = log_line(&format!("  +0x{:04X}: 0x{:08X} [value]", field_offset, val));
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+//! Per-frame hook on TurnManager_ProcessFrame (0x55FDA0).
+//!
+//! Provides the central frame boundary hook used by multiple subsystems:
+//! - Debug synchronization (pause/resume/step via debug CLI)
+//! - Hardware watchpoint arming at specific frames
+//!
+//! This hook is always installed (both normal and baseline modes).
+
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use crate::hook;
+use crate::log_line;
+use openwa_core::address::va;
+use openwa_core::engine::game_session;
+
+/// Trampoline to the original TurnManager_ProcessFrame.
+static ORIG_TURN_MANAGER: AtomicU32 = AtomicU32::new(0);
+
+/// Total frames processed by TurnManager_ProcessFrame.
+static FRAMES_PROCESSED: AtomicU32 = AtomicU32::new(0);
+
+/// Get the number of frames processed so far.
+pub fn frames_processed() -> u32 {
+    FRAMES_PROCESSED.load(Ordering::Relaxed)
+}
+
+/// Hook for TurnManager_ProcessFrame (stdcall, 1 param = TurnGame*).
+unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
+    // Check debug sync BEFORE processing the frame — allows pausing at frame boundary
+    let ddgame = game_session::get_ddgame();
+    if !ddgame.is_null() {
+        let game_frame = (*ddgame).frame_counter;
+        crate::debug_sync::on_frame_start(game_frame);
+
+        // Hardware watchpoint: arm once at the watch frame
+        static WATCH_ARMED: core::sync::atomic::AtomicBool =
+            core::sync::atomic::AtomicBool::new(false);
+        if !WATCH_ARMED.load(Ordering::Relaxed) {
+            if let Ok(val) = std::env::var("OPENWA_WATCH_FRAME") {
+                let target: i32 = val.parse().unwrap_or(0);
+                if game_frame >= target {
+                    WATCH_ARMED.store(true, Ordering::Relaxed);
+                    crate::debug_watchpoint::prepare();
+                    // Select watchpoint base: DDGame, DDGameWrapper, or Display
+                    let watch_base = if std::env::var("OPENWA_WATCH_DISPLAY").is_ok() {
+                        let wrapper = game_session::get_wrapper();
+                        *(wrapper.byte_add(0x4D0) as *const *mut u8)
+                    } else if std::env::var("OPENWA_WATCH_WRAPPER").is_ok() {
+                        game_session::get_wrapper() as *mut u8
+                    } else {
+                        ddgame as *mut u8
+                    };
+                    crate::debug_watchpoint::on_ddgame_alloc(watch_base);
+                }
+            }
+        }
+    }
+
+    // Call original
+    let orig: unsafe extern "stdcall" fn(u32) =
+        core::mem::transmute(ORIG_TURN_MANAGER.load(Ordering::Relaxed));
+    orig(turngame);
+
+    let frame = FRAMES_PROCESSED.fetch_add(1, Ordering::Relaxed) + 1;
+
+    // Replay test: fast-forward + milestone tracking (no-op if not in replay test mode)
+    super::replay_test::on_frame(frame);
+}
+
+pub fn install() -> Result<(), String> {
+    let _ = log_line("[FrameHook] Hooking TurnManager_ProcessFrame");
+
+    unsafe {
+        let trampoline = hook::install(
+            "TurnManager_ProcessFrame",
+            va::TURN_MANAGER_PROCESS_FRAME,
+            hook_turn_manager as *const (),
+        )?;
+        ORIG_TURN_MANAGER.store(trampoline as u32, Ordering::Relaxed);
+    }
+
+    Ok(())
+}

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

@@ -1,15 +1,17 @@
 mod config;
+pub(crate) mod debug_utils;
 mod ddgame_init;
 mod display;
 pub(crate) mod file_isolation;
+mod frame_hook;
 mod frontend;
 mod game_session;
 mod game_state_hooks;
 mod hardware_init;
 mod headless;
-pub(crate) mod input;
 mod render;
 mod replay;
+mod replay_test;
 mod scheme;
 mod sound;
 mod speech;
@@ -21,7 +23,7 @@ mod weapon_release;
 
 /// Write gameplay milestone report and clean up. Called from DLL_PROCESS_DETACH.
 pub fn write_gameplay_report() {
-    input::write_gameplay_report();
+    replay_test::write_gameplay_report();
     trace_desync::flush();
     file_isolation::cleanup();
 }
@@ -30,17 +32,18 @@ pub fn install_all() -> Result<(), String> {
     // Infrastructure hooks — always installed
     headless::install()?;
     file_isolation::install()?;
+    frame_hook::install()?;
     trace_desync::install()?;
 
     // Baseline mode: only install minimal hooks needed for replay playback.
     // Skips all gameplay hooks to provide a "nearly vanilla" reference run.
     if std::env::var("OPENWA_TRACE_BASELINE").is_ok() {
-        input::install()?;
         replay::install()?;
         return Ok(());
     }
 
     // Normal mode: install all hooks
+    replay_test::install()?;
     display::install()?;
     game_session::install()?;
     hardware_init::install()?;
@@ -52,7 +55,6 @@ pub fn install_all() -> Result<(), String> {
     render::install()?;
     sound::install()?;
     speech::install()?;
-    input::install()?;
     ddgame_init::install()?;
     game_state_hooks::install()?;
     replay::install()?;

crates/openwa-wormkit/src/replacements/{input.rs → replay_test.rs}

@@ -1,49 +1,33 @@
-//! Replay fast-forward via DDGame+0x98B0 and gameplay milestone tracking.
+//! Headful replay test support: fast-forward and gameplay milestone tracking.
 //!
-//! When `OPENWA_REPLAY_TEST=1`, hooks TurnManager_ProcessFrame (0x55FDA0)
-//! and sets DDGame+0x98B0 (fast-forward active flag) each frame.
+//! When `OPENWA_REPLAY_TEST=1`, enables:
+//! - **Fast-forward**: Sets DDGame+0x98B0 each frame so WA processes up to 50
+//!   game frames per render cycle (same as spacebar during replay playback).
+//! - **Gameplay milestones**: Tracks match start/completion via alive team counting,
+//!   reported at DLL detach for machine-readable test validation.
 //!
-//! When this flag is set, FUN_005307A0 processes up to 50 game frames per
-//! render cycle. Sound is suppressed (FUN_00546B50) and rendering is skipped
-//! (FUN_00529F30). The flag gets cleared at turn boundaries (FUN_00534540,
-//! 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)]
+//! These features are specific to headful (interactive) replay testing.
+//! Headless tests run at maximum CPU speed without needing fast-forward,
+//! and use log comparison instead of milestone markers.
 
 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;
+use openwa_core::engine::game_session;
+use openwa_core::engine::DDGame;
 
-/// Trampoline to the original TurnManager_ProcessFrame.
-static ORIG_TURN_MANAGER: AtomicU32 = AtomicU32::new(0);
+// ---------------------------------------------------------------------------
+// Fast-forward
+// ---------------------------------------------------------------------------
 
-/// Whether to set fast-forward flag (only in replay test mode).
+/// Whether fast-forward is active (set once at install, read every frame).
 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);
 
@@ -59,99 +43,29 @@ 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 {
-    let session = *(rb(va::G_GAME_SESSION) as *const u32);
-    if session == 0 {
-        return core::ptr::null_mut();
-    }
-    let wrapper_ptr = *((session + 0xA0) as *const *const DDGameWrapper);
-    if wrapper_ptr.is_null() {
-        return core::ptr::null_mut();
-    }
-    (*wrapper_ptr).ddgame
-}
-
-/// Dump a memory region as DWORDs with automatic classification.
+/// Called every frame from frame_hook (after the original TurnManager runs).
 ///
-/// Uses `openwa_core::mem::classify_pointer` for pointer detection.
-/// See that module for the classification categories.
-pub unsafe fn dump_region(base_ptr: *const u8, offset: usize, size: usize, struct_name: &str) {
-    use openwa_core::address::va;
-    use openwa_core::mem;
-    use openwa_core::rebase::rb;
-    use openwa_debug_proto::PointerKind;
-
-    let wa_base = rb(va::IMAGE_BASE);
-    let delta = wa_base.wrapping_sub(va::IMAGE_BASE);
-
-    let _ = log_line(&format!(
-        "\n=== {}+0x{:04X}..0x{:04X} ===",
-        struct_name,
-        offset,
-        offset + size
-    ));
+/// Handles fast-forward flag setting and periodic milestone checks.
+pub unsafe fn on_frame(frame: u32) {
+    let ddgame = game_session::get_ddgame();
+    if ddgame.is_null() {
+        return;
+    }
 
-    let dword_count = size / 4;
-    for i in 0..dword_count {
-        let field_offset = offset + i * 4;
-        let val = *(base_ptr.add(field_offset) as *const u32);
-        if val == 0 {
-            continue;
-        }
+    // Re-set fast-forward each frame (WA clears it at turn boundaries)
+    if FAST_FORWARD.load(Ordering::Relaxed) {
+        (*ddgame).fast_forward_active = 1;
+    }
 
-        if let Some(info) = mem::classify_pointer(val, delta) {
-            let detail_str = info.detail.as_deref().unwrap_or("");
-            match info.kind {
-                PointerKind::Vtable => {
-                    let _ = log_line(&format!(
-                        "  +0x{:04X}: 0x{:08X} [VTABLE] g:0x{:08X} {}",
-                        field_offset, val, info.ghidra_value, detail_str
-                    ));
-                }
-                PointerKind::Code => {
-                    let _ = log_line(&format!(
-                        "  +0x{:04X}: 0x{:08X} [CODE] g:0x{:08X}",
-                        field_offset, val, info.ghidra_value
-                    ));
-                }
-                PointerKind::Data => {
-                    let _ = log_line(&format!(
-                        "  +0x{:04X}: 0x{:08X} [DATA] g:0x{:08X}",
-                        field_offset, val, info.ghidra_value
-                    ));
-                }
-                PointerKind::Object => {
-                    let _ = log_line(&format!(
-                        "  +0x{:04X}: 0x{:08X} [OBJECT] {}",
-                        field_offset, val, detail_str
-                    ));
-                }
-                PointerKind::Heap => {
-                    let _ = log_line(&format!(
-                        "  +0x{:04X}: 0x{:08X} [ptr] {}",
-                        field_offset, val, detail_str
-                    ));
-                }
-            }
-        } else if val < 0x10000 {
-            let _ = log_line(&format!(
-                "  +0x{:04X}: 0x{:08X} [small={}]",
-                field_offset, val, val
-            ));
-        } else {
-            let _ = log_line(&format!("  +0x{:04X}: 0x{:08X} [value]", field_offset, val));
-        }
+    // Milestone detection (check every 50 frames to reduce overhead).
+    // Skip the first 100 frames to let game state fully initialize.
+    if frame >= 100 && frame.is_multiple_of(50) {
+        check_milestones(ddgame, frame);
     }
 }
 
 /// 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;
@@ -162,7 +76,6 @@ unsafe fn count_alive_teams(ddgame: *const DDGame) -> (i32, i32) {
     }
 
     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 {
@@ -179,63 +92,6 @@ unsafe fn count_alive_teams(ddgame: *const DDGame) -> (i32, i32) {
     (alive_teams, team_count)
 }
 
-/// Hook for TurnManager_ProcessFrame (stdcall, 1 param = TurnGame*).
-unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
-    // Check debug sync BEFORE processing the frame — allows pausing at frame boundary
-    let ddgame = get_ddgame();
-    if !ddgame.is_null() {
-        let game_frame = (*ddgame).frame_counter;
-        crate::debug_sync::on_frame_start(game_frame);
-
-        // Hardware watchpoint: arm once at the watch frame
-        static WATCH_ARMED: core::sync::atomic::AtomicBool =
-            core::sync::atomic::AtomicBool::new(false);
-        if !WATCH_ARMED.load(Ordering::Relaxed) {
-            if let Ok(val) = std::env::var("OPENWA_WATCH_FRAME") {
-                let target: i32 = val.parse().unwrap_or(0);
-                if game_frame >= target {
-                    WATCH_ARMED.store(true, Ordering::Relaxed);
-                    crate::debug_watchpoint::prepare();
-                    // Select watchpoint base: DDGame, DDGameWrapper, or Display
-                    let watch_base = if std::env::var("OPENWA_WATCH_DISPLAY").is_ok() {
-                        let session = *(rb(va::G_GAME_SESSION) as *const u32);
-                        let wrapper = *((session + 0xA0) as *const *const u8);
-                        *(wrapper.add(0x4D0) as *const *mut u8)
-                    } else if std::env::var("OPENWA_WATCH_WRAPPER").is_ok() {
-                        let session = *(rb(va::G_GAME_SESSION) as *const u32);
-                        *((session + 0xA0) as *const *mut u8)
-                    } else {
-                        ddgame as *mut u8
-                    };
-                    crate::debug_watchpoint::on_ddgame_alloc(watch_base);
-                }
-            }
-        }
-    }
-
-    // Call original
-    let orig: unsafe extern "stdcall" fn(u32) =
-        core::mem::transmute(ORIG_TURN_MANAGER.load(Ordering::Relaxed));
-    orig(turngame);
-
-    let frame = FRAMES_PROCESSED.fetch_add(1, Ordering::Relaxed) + 1;
-
-    if ddgame.is_null() {
-        return;
-    }
-
-    // Fast-forward for replay test
-    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.is_multiple_of(50) {
-        check_milestones(ddgame, frame);
-    }
-}
-
 /// Check and update gameplay milestones.
 unsafe fn check_milestones(ddgame: *const DDGame, frame: u32) {
     if MATCH_COMPLETED.load(Ordering::Relaxed) {
@@ -249,32 +105,26 @@ unsafe fn check_milestones(ddgame: *const DDGame, frame: u32) {
             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);
-        }
+    } else 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 frames = super::frame_hook::frames_processed();
     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",
@@ -286,7 +136,6 @@ pub fn write_gameplay_report() {
         );
     }
 
-    // Milestone 2: Match started (multiple teams with alive worms)
     if started {
         let teams = TEAMS_AT_START.load(Ordering::Relaxed);
         let _ = log_validation(&format!(
@@ -300,7 +149,6 @@ pub fn write_gameplay_report() {
         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);
@@ -324,18 +172,7 @@ pub fn write_gameplay_report() {
 pub fn install() -> Result<(), String> {
     if std::env::var("OPENWA_REPLAY_TEST").is_ok() {
         FAST_FORWARD.store(true, Ordering::Relaxed);
-        let _ = log_line("[Input] Replay test mode — fast-forward enabled");
-    }
-
-    let _ = log_line("[Input] Hooking TurnManager_ProcessFrame");
-
-    unsafe {
-        let trampoline = hook::install(
-            "TurnManager_ProcessFrame",
-            va::TURN_MANAGER_PROCESS_FRAME,
-            hook_turn_manager as *const (),
-        )?;
-        ORIG_TURN_MANAGER.store(trampoline as u32, Ordering::Relaxed);
+        let _ = log_line("[ReplayTest] Replay test mode — fast-forward enabled");
     }
 
     Ok(())

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

@@ -1190,7 +1190,7 @@ fn dump_worm_tasks() {
 // ---------------------------------------------------------------------------
 
 fn dump_turngame() {
-    use crate::replacements::input::dump_region;
+    use crate::replacements::debug_utils::dump_region;
     use openwa_core::task::CTaskTurnGame;
 
     let _ = log_validation("");
@@ -1366,7 +1366,7 @@ fn dump_turngame() {
 // we can verify against what WA actually stores at runtime.
 
 fn dump_ctask_children() {
-    use crate::replacements::input::dump_region;
+    use crate::replacements::debug_utils::dump_region;
 
     let _ = log_validation("");
     let _ = log_validation("--- CTask children sub-struct dump ---");
@@ -1458,7 +1458,7 @@ fn dump_ctask_children() {
 // ---------------------------------------------------------------------------
 
 fn dump_ctaskteam_entities() {
-    use crate::replacements::input::dump_region;
+    use crate::replacements::debug_utils::dump_region;
     use openwa_core::task::CTaskTeam;
 
     let _ = log_validation("");