gameplay: port timer phases and damage requests

crates/urt-gameplay/src/bin/urt-client-timer.rs

@@ -29,6 +29,50 @@ fn main() {
                 input.stamp
             );
         }
+        "tick" => println!("{}", tick(&w)),
         _ => panic!("unknown timer policy"),
     }
 }
+
+fn list(v: &[u32]) -> String {
+    format!(
+        "[{}]",
+        v.iter()
+            .map(|v| v.to_string())
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+fn damage_json(v: &[TimerDamage]) -> String {
+    v.iter().map(|r|format!(r#"{{"target":{},"inflictor":{},"attacker":{},"direction":{},"point":{},"amount":{},"flags":{},"means":{},"weapon":{}}}"#,r.target,r.inflictor,r.attacker,r.direction,r.point,r.amount,r.flags,r.means,r.weapon)).collect::<Vec<_>>().join(",")
+}
+fn loop_state(w: &[u32]) -> TimerLoopState {
+    TimerLoopState {
+        flags: w[0],
+        status: w[1],
+        rate: w[2],
+        phase: w[3],
+        timer: w[4],
+        residual: w[5],
+    }
+}
+fn loop_words(s: TimerLoopState) -> [u32; 6] {
+    [s.flags, s.status, s.rate, s.phase, s.timer, s.residual]
+}
+fn tick(w: &[u32]) -> String {
+    assert_eq!(w.len(), 8);
+    let mut s = loop_state(w);
+    let input = TimerLoopInput {
+        health: w[6],
+        weapon: w[7],
+        target: 2,
+        owner: 3,
+    };
+    let damage = timer_tick_loop(&mut s, input).unwrap();
+    format!(
+        r#"{{"damage":[{}],"state":{},"health":{}}}"#,
+        damage_json(&damage),
+        list(&loop_words(s)),
+        w[6]
+    )
+}

crates/urt-gameplay/src/client_timer.rs

@@ -87,3 +87,132 @@ mod terminal_tests {
         assert_eq!(s.entity_flag, 7);
     }
 }
+
+use crate::native_policy::Error;
+pub const TIMER_DIVISORS: [i32; 6] = [1120403456, 9, 4, 3, 2, 1];
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TimerLoopState {
+    pub flags: u32,
+    pub status: u32,
+    pub rate: u32,
+    pub phase: u32,
+    pub timer: u32,
+    pub residual: u32,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TimerLoopInput {
+    pub health: u32,
+    pub weapon: u32,
+    pub target: u32,
+    pub owner: u32,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TimerDamage {
+    pub target: u32,
+    pub inflictor: u32,
+    pub attacker: u32,
+    pub direction: u32,
+    pub point: u32,
+    pub amount: u32,
+    pub flags: u32,
+    pub means: u32,
+    pub weapon: u32,
+}
+/// Original150810 loop subset with flag512 disabled. Damage effects are requests;
+/// supplied health is deliberately unchanged. Rate0 aliases the preceding word.
+pub fn timer_tick_loop(
+    state: &mut TimerLoopState,
+    input: TimerLoopInput,
+) -> Result<Vec<TimerDamage>, Error> {
+    if state.rate > 5 {
+        return Err(Error::InvalidIndex);
+    }
+    if state.flags & 512 != 0 || state.residual as i32 > 10000 {
+        return Err(Error::InvalidInput);
+    }
+    let mut next = *state;
+    let mut damage = vec![];
+    while next.residual as i32 >= 100 {
+        next.phase =
+            ((next.phase.wrapping_add(1) as i32) % TIMER_DIVISORS[next.rate as usize]) as u32;
+        next.residual = next.residual.wrapping_sub(100);
+        if next.flags & 256 != 0 && (input.health as i32) > 0 && next.phase == 0 {
+            damage.push(TimerDamage {
+                target: input.target,
+                inflictor: input.owner,
+                attacker: input.owner,
+                direction: 0,
+                point: 0,
+                amount: 1,
+                flags: 0,
+                means: 23,
+                weapon: input.weapon,
+            });
+        }
+    }
+    *state = next;
+    Ok(damage)
+}
+#[cfg(test)]
+mod tick_tests {
+    use super::*;
+    fn input() -> TimerLoopInput {
+        TimerLoopInput {
+            health: 1,
+            weapon: 7,
+            target: 2,
+            owner: 3,
+        }
+    }
+    #[test]
+    fn phase_wrap_signed_remainder_alias_and_request_arguments() {
+        let mut s = TimerLoopState {
+            flags: 256,
+            status: 3,
+            rate: 0,
+            phase: 0,
+            timer: 0,
+            residual: 250,
+        };
+        assert!(timer_tick_loop(&mut s, input()).unwrap().is_empty());
+        assert_eq!(s.phase, 2);
+        assert_eq!(s.residual, 50);
+        s.rate = 5;
+        s.residual = 100;
+        s.phase = i32::MAX as u32;
+        let p = timer_tick_loop(&mut s, input()).unwrap();
+        assert_eq!(s.phase, 0);
+        assert_eq!(
+            p,
+            [TimerDamage {
+                target: 2,
+                inflictor: 3,
+                attacker: 3,
+                direction: 0,
+                point: 0,
+                amount: 1,
+                flags: 0,
+                means: 23,
+                weapon: 7
+            }]
+        );
+    }
+    #[test]
+    fn negative_residual_skips_and_unsupported_domains_are_atomic() {
+        let mut s = TimerLoopState {
+            flags: 256,
+            status: 3,
+            rate: 2,
+            phase: 0,
+            timer: 0,
+            residual: u32::MAX,
+        };
+        let old = s;
+        assert!(timer_tick_loop(&mut s, input()).unwrap().is_empty());
+        assert_eq!(s, old);
+        s.rate = 6;
+        let old = s;
+        assert!(timer_tick_loop(&mut s, input()).is_err());
+        assert_eq!(s, old);
+    }
+}

docs/FINDINGS.md

@@ -1865,3 +1865,5 @@ RE-964: A144-case source contract executes disjoint150791..150810 and151085..151
 RE-965: Rust matches144 original terminal-fragment cases, preserving wrapping cooldown arithmetic before signed comparisons, strict equality behavior, unrelated flag bits and elapsed-total wrap. Separate pre-loop and post-loop APIs allow later composition in original order. Unit tests cover equal/expired deadlines and signed overflow; this contract does not execute the intervening timer loop or native scheduling. [Evidence](research/RUST_CLIENT_TIMER_TERMINAL.md).
 
 RE-966: A288-case source loop contract covers signed residual thresholds, wrapping phase increments and signed remainder with rates0/1/2/5. Rate0 reads preceding word1120403456 instead of a zero divisor. Flag256 plus positive supplied health and phase0 request damage1, means23 and caller weapon/owner pointers. Damage effects remain captured and flag512 is disabled in this stage; health mutation and other branches remain open. [Evidence](research/QVM_CLIENT_TIMER_TICKS.md).
+
+RE-967: Rust matches288 original tick-loop cases with signed residual/remainder and wrapping phase behavior. Rate0 retains the preceding-word divisor1120403456. Typed damage requests retain all source arguments without mutating supplied health. Unit tests cover alias behavior, signed wrap, exact request ABI and atomic invalid-rate rejection. Flag512 is deliberately outside this first loop subset; the residual budget bounds execution. [Evidence](research/RUST_CLIENT_TIMER_TICKS.md).

docs/PROVISIONAL_TODO.md

@@ -1917,3 +1917,5 @@ RE-954–963 completed add/remove wrappers, resolved duration export, full-capac
 - [x] RE-965 Rust client timer deadlines and terminal accumulation ([evidence](research/RUST_CLIENT_TIMER_TERMINAL.md)).
 
 - [x] RE-966 Original100ms timer phase loop and damage-request ABI ([evidence](research/QVM_CLIENT_TIMER_TICKS.md)).
+
+- [x] RE-967 Rust100ms phase loop and captured damage requests ([evidence](research/RUST_CLIENT_TIMER_TICKS.md)).

docs/RESEARCH_LEDGER.md

@@ -2535,3 +2535,7 @@ Rust matches144 original terminal-fragment cases, preserving wrapping cooldown a
 ## 2026-10-28 — RE-966 Original100ms timer phase loop and damage-request ABI
 
 A288-case source loop contract covers signed residual thresholds, wrapping phase increments and signed remainder with rates0/1/2/5. Rate0 reads preceding word1120403456 instead of a zero divisor. Flag256 plus positive supplied health and phase0 request damage1, means23 and caller weapon/owner pointers. Damage effects remain captured and flag512 is disabled in this stage; health mutation and other branches remain open. Focused `cargo xtask test-group qvm-client-timer-ticks` passes with deterministic report regeneration, relevant regressions and storage/documentation/whitespace checks. Full suite deferred to the tenth-commit boundary. Original assets unchanged; native IO effects remain captured.
+
+## 2026-10-28 — RE-967 Rust100ms phase loop and captured damage requests
+
+Rust matches288 original tick-loop cases with signed residual/remainder and wrapping phase behavior. Rate0 retains the preceding-word divisor1120403456. Typed damage requests retain all source arguments without mutating supplied health. Unit tests cover alias behavior, signed wrap, exact request ABI and atomic invalid-rate rejection. Flag512 is deliberately outside this first loop subset; the residual budget bounds execution. Focused `cargo xtask test-group rust-client-timer-ticks` passes with deterministic report regeneration, relevant regressions and storage/documentation/whitespace checks. Full suite deferred to the tenth-commit boundary. Original assets unchanged; native IO effects remain captured.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1954,3 +1954,5 @@ RE-954–963 recover bounded command wrappers, resolved duration export, full-ca
 - [x] RE-965 Rust client timer deadlines and terminal accumulation ([evidence](research/RUST_CLIENT_TIMER_TERMINAL.md)).
 
 - [x] RE-966 Original100ms timer phase loop and damage-request ABI ([evidence](research/QVM_CLIENT_TIMER_TICKS.md)).
+
+- [x] RE-967 Rust100ms phase loop and captured damage requests ([evidence](research/RUST_CLIENT_TIMER_TICKS.md)).

docs/research/README.md

@@ -1489,3 +1489,5 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-965: Rust client timer deadlines and terminal accumulation](RUST_CLIENT_TIMER_TERMINAL.md).
 
 - [RE-966: Original100ms timer phase loop and damage-request ABI](QVM_CLIENT_TIMER_TICKS.md).
+
+- [RE-967: Rust100ms phase loop and captured damage requests](RUST_CLIENT_TIMER_TICKS.md).

docs/research/RUST_CLIENT_TIMER_TICKS.md

@@ -0,0 +1,5 @@
+# Rust100ms phase loop and captured damage requests
+
+RE-967. Focused validation: `cargo xtask test-group rust-client-timer-ticks`. [Machine report](rust-client-timer-ticks.json).
+
+Rust matches288 original tick-loop cases with signed residual/remainder and wrapping phase behavior. Rate0 retains the preceding-word divisor1120403456. Typed damage requests retain all source arguments without mutating supplied health. Unit tests cover alias behavior, signed wrap, exact request ABI and atomic invalid-rate rejection. Flag512 is deliberately outside this first loop subset; the residual budget bounds execution.

docs/research/rust-health-impulse.json

@@ -2985,7 +2985,7 @@
       "exit_code": 2
     }
   ],
-  "rust_unit_tests": 222,
+  "rust_unit_tests": 224,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_client_timer_ticks.py

@@ -0,0 +1,18 @@
+"""Compare recovered Rust policy with original QVM fixtures."""
+import hashlib,json,os,subprocess
+from pathlib import Path
+from analyze_qvm import write_json
+from rust_lifecycle_support import result
+
+def main():
+ subprocess.run(['cargo','build','--offline','--package','urt-gameplay','--bin','urt-client-timer'],check=True,capture_output=True)
+ binary=Path(os.environ.get('CARGO_TARGET_DIR','target'))/'debug'/'urt-client-timer'
+ path=Path('docs/research/qvm-client-timer-ticks.json');data=path.read_bytes();probes=[]
+ for p in json.loads(data)['probes']:
+  probes.append(dict(source={k:p[k] for k in ['damage', 'state', 'health']},rust=result(binary,'tick',encode(p['input']))))
+ write_json(Path('docs/research/rust-client-timer-ticks.json'),dict(source_report=str(path),source_report_sha256=hashlib.sha256(data).hexdigest(),probes=probes,limits='Finite source/Rust contract parity; native time/file/network replies remain supplied or captured.'))
+
+def encode(a):
+ from analyze_qvm_acceleration import word
+ return [a['flags'],a['status'],a['rate'],a['phase'],word(a['timer']),a['residual'],a['health'],a['weapon']]
+if __name__=='__main__':main()

scripts/test_rust_client_timer_ticks.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class PortTests(unittest.TestCase):
+ def test_original_parity(self):
+  r=json.loads(Path('docs/research/rust-client-timer-ticks.json').read_text());self.assertGreaterEqual(len(r['probes']),12)
+  for p in r['probes']:self.assertEqual(p['source'],p['rust'])
+ def test_identity(self):
+  r=json.loads(Path('docs/research/rust-client-timer-ticks.json').read_text());self.assertEqual(hashlib.sha256(Path(r['source_report']).read_bytes()).hexdigest(),r['source_report_sha256'])
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -3446,3 +3446,23 @@ report	scripts/analyze_qvm_client_timer_ticks.py	docs/research/qvm-client-timer-
 edge	docs/research/qvm-client-timer-ticks.json	scripts/test_qvm_client_timer_ticks.py
 group	qvm-client-timer-ticks	scripts/analyze_qvm_client_timer_ticks.py
 edge	scripts/analyze_qvm_client_timer_ticks.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_rust_client_timer_ticks.py	docs/research/rust-client-timer-ticks.json
+edge	docs/research/rust-client-timer-ticks.json	scripts/test_rust_client_timer_ticks.py
+group	rust-client-timer-ticks	scripts/analyze_rust_client_timer_ticks.py
+edge	scripts/analyze_rust_client_timer_ticks.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_client_timer_ticks.py
+edge	Cargo.lock	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/filter_loading.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/filter_lifecycle.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/bin/urt-filter-loading.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	docs/research/qvm-client-timer-ticks.json	scripts/analyze_rust_client_timer_ticks.py
+group	rust-client-timer-ticks	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/filter_commands.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/bin/urt-filter-commands.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/client_timer.rs	scripts/analyze_rust_client_timer_ticks.py
+edge	crates/urt-gameplay/src/bin/urt-client-timer.rs	scripts/analyze_rust_client_timer_ticks.py