gameplay: port bomb defuse replay snapshots

crates/urt-gameplay/src/bin/urt-defuse.rs

@@ -85,6 +85,7 @@ fn main() {
             println!("{{{}}}", fields(s, &e));
         }
         "full" => println!("{}", full(&w)),
+        "sequence" => println!("{}", sequence(&w)),
         _ => panic!("unknown policy"),
     }
 }
@@ -180,3 +181,36 @@ fn full(w: &[u32]) -> String {
     let o = process_defuse(&mut world, i).unwrap();
     format!("{{{}}}", full_fields(world.state, &o))
 }
+
+fn sequence(w: &[u32]) -> String {
+    assert_eq!(w.len(), 32);
+    let (mut world, i) = decode_full(&w[..31]);
+    let profile = w[31];
+    let steps = [0, 1000, 2000, 5000, 6000]
+        .into_iter()
+        .enumerate()
+        .map(|(j, offset)| DefuseReplayStep {
+            tick: i.base.tick.wrapping_add(offset),
+            bomb_move: if j == 1 && profile == 3 {
+                Some((4, [10f32.to_bits(), 0, 0]))
+            } else {
+                None
+            },
+            press_button: j == 1 && profile == 5,
+            release_teammate: if j == 1 && profile == 16 {
+                Some(w[26] as usize)
+            } else {
+                None
+            },
+        })
+        .collect::<Vec<_>>();
+    let frames = replay_defuse(&mut world, i, &steps).unwrap();
+    format!(
+        r#"{{"frames":[{}]}}"#,
+        frames
+            .iter()
+            .map(|f| format!("{{{}}}", full_fields(f.world.state, &f.outcome)))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}

crates/urt-gameplay/src/defuse.rs

@@ -518,3 +518,170 @@ mod full_tests {
         assert_eq!(w, old);
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct DefuseReplayStep {
+    pub tick: u32,
+    pub bomb_move: Option<(usize, [u32; 3])>,
+    pub press_button: bool,
+    pub release_teammate: Option<usize>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DefuseFrame {
+    pub world: DefuseWorld,
+    pub outcome: DefuseOutcome,
+}
+/// Bounded research replay with scripted external inputs. Missing-bomb boundary
+/// ends replay, matching the source fatal boundary rather than inventing a return.
+/// Typed replay errors roll back the batch; native effect plans perform no IO.
+pub fn replay_defuse(
+    world: &mut DefuseWorld,
+    input: FullDefuseInput,
+    steps: &[DefuseReplayStep],
+) -> Result<Vec<DefuseFrame>, Error> {
+    if steps.len() > 256 {
+        return Err(Error::InvalidCount);
+    }
+    let mut next = world.clone();
+    let mut frames = vec![];
+    for step in steps {
+        if let Some((index, point)) = step.bomb_move {
+            next.bombs.get_mut(index).ok_or(Error::InvalidIndex)?.point = point;
+        }
+        if step.press_button {
+            next.state.flags |= 32768;
+        }
+        if let Some(index) = step.release_teammate {
+            next.clients.get_mut(index).ok_or(Error::InvalidIndex)?.busy = 0;
+        }
+        let outcome = process_defuse(
+            &mut next,
+            FullDefuseInput {
+                base: DefuseInput {
+                    tick: step.tick,
+                    ..input.base
+                },
+                ..input
+            },
+        )?;
+        let stop = outcome.missing;
+        frames.push(DefuseFrame {
+            world: next.clone(),
+            outcome,
+        });
+        if stop {
+            break;
+        }
+    }
+    *world = next;
+    Ok(frames)
+}
+#[cfg(test)]
+mod replay_tests {
+    use super::*;
+    use crate::move_callbacks::ObjectiveClient;
+    fn world() -> DefuseWorld {
+        DefuseWorld {
+            state: DefuseState {
+                flags: 32768,
+                flags104: 0,
+                busy: 0,
+                clock: 0,
+                complete: 0,
+                animation: 99,
+                weapon: 11,
+                event: [7, 1],
+            },
+            clients: vec![
+                ObjectiveClient {
+                    connection: 2,
+                    health: 1,
+                    follow: 0,
+                    team: 1,
+                    busy: 0
+                };
+                3
+            ],
+            bombs: vec![DefuseBomb {
+                in_use: true,
+                has_class: true,
+                hash: BOMB_CLASS_HASH,
+                point: [0; 3],
+            }],
+            actor_point: [0; 3],
+        }
+    }
+    fn input() -> FullDefuseInput {
+        FullDefuseInput {
+            base: DefuseInput {
+                tick: 10000,
+                duration: 5,
+                index: 3,
+                slot: 2,
+            },
+            entity: true,
+            client: true,
+            enabled_a: 1,
+            enabled_b: 1,
+            start: 8000,
+            delay: 1,
+            selector: 0,
+            count: 3,
+        }
+    }
+    fn step(tick: u32) -> DefuseReplayStep {
+        DefuseReplayStep {
+            tick,
+            bomb_move: None,
+            press_button: false,
+            release_teammate: None,
+        }
+    }
+    #[test]
+    fn completion_latch_prevents_duplicate_reward() {
+        let mut w = world();
+        let steps = [10000, 11000, 12000, 15000, 16000].map(step);
+        let f = replay_defuse(&mut w, input(), &steps).unwrap();
+        assert_eq!(
+            f.iter()
+                .map(|f| f.outcome.effects.len())
+                .collect::<Vec<_>>(),
+            [2, 0, 0, 4, 0]
+        );
+        assert_eq!(w.state.complete, 1);
+        assert_eq!(f[3].world.state.event, [1, 33]);
+        assert!(f[4].outcome.lookups.is_empty());
+        assert_eq!(
+            f.iter()
+                .flat_map(|f| &f.outcome.effects)
+                .filter(|e| matches!(e, DefuseEffect::Award { .. }))
+                .count(),
+            1
+        );
+    }
+    #[test]
+    fn missing_bomb_stops_and_late_script_error_rolls_back() {
+        let mut w = world();
+        w.bombs.clear();
+        let f = replay_defuse(&mut w, input(), &[step(10000), step(11000)]).unwrap();
+        assert_eq!(f.len(), 1);
+        assert!(f[0].outcome.missing);
+        let mut w = world();
+        let old = w.clone();
+        assert!(
+            replay_defuse(
+                &mut w,
+                input(),
+                &[
+                    step(10000),
+                    DefuseReplayStep {
+                        bomb_move: Some((99, [0; 3])),
+                        ..step(11000)
+                    }
+                ]
+            )
+            .is_err()
+        );
+        assert_eq!(w, old);
+    }
+}

docs/FINDINGS.md

@@ -1983,3 +1983,7 @@ RE-1020: Ninety-six source scenarios connect original admission/teammate scan to
 RE-1021: Rust composes verified eligibility, first eligible bomb hash lookup, finite f32 distance and start/cancel/finish across96 source cases. Missing bomb returns the source fatal boundary diagnostic without inventing subsequent behavior. Radius equality does not start defusing; decoy identity and selector semantics match source. State and effect plans stage before commit, with missing/invalid geometry unit tests preserving prior state. Native effects remain captured plans. [Evidence](research/RUST_DEFUSE_COMPLETE.md).
 
 RE-1022: Thirty coherent source scenarios replay up to five complete callbacks, producing138 snapshots. Scripted motion, held-button changes and teammate release test cancellation/restart; shared state persists through waiting and exact completion. Completed latch prevents repeated allocation/log/award. Missing-bomb boundary stops after one call. Actual lookup/distance bodies execute, while native effect feedback and scheduling remain modeled/captured inputs. [Evidence](research/QVM_DEFUSE_SEQUENCE.md).
+
+RE-1023: Rust matches138 source snapshots across30 scripted sequences. Motion/button/teammate inputs apply before each call, while clock/flags/event state persist. Completion latch suppresses duplicate reward requests and missing-bomb diagnostic ends replay. Bounded typed replay stages all updates and snapshots on errors; tests verify exactly one reward, fatal-boundary stop and rollback after a prior successful start. Native effects and frame scheduling remain outside scope. [Evidence](research/RUST_DEFUSE_SEQUENCE.md).
+
+RE-1014–1023 batch validation passed:1,978 Python tests,319 Rust tests,131 deterministic affected producers and601 documentation files. All ten tasks have separate commits and focused checks. [Defuse evidence and next work](research/QVM_DEFUSE_BATCH.md).

docs/PROVISIONAL_TODO.md

@@ -2042,3 +2042,8 @@ RE-974–983 completed routing, command rewrite, inactivity, movement-parameter
 - [x] RE-1021 Port complete bomb-defuse lookup and state policy ([evidence](research/RUST_DEFUSE_COMPLETE.md)).
 
 - [x] RE-1022 Recover bomb-defuse sequences and completion latching ([evidence](research/QVM_DEFUSE_SEQUENCE.md)).
+
+- [x] RE-1023 Port bomb-defuse replay and fatal/completion boundaries ([evidence](research/RUST_DEFUSE_SEQUENCE.md)).
+
+- [x] RE-1014–1023 bomb-defuse batch:278 paired scenarios, including138 repeated-call snapshots ([evidence](research/QVM_DEFUSE_BATCH.md)).
+- [ ] RE-1024 recover objective/native effect feedback and compose defusing with full client preparation/movement/timer execution ([scope](research/QVM_DEFUSE_BATCH.md#next-work-re-1024)).

docs/RESEARCH_LEDGER.md

@@ -2763,3 +2763,7 @@ Rust composes verified eligibility, first eligible bomb hash lookup, finite f32
 ## 2026-10-29 — RE-1022 Recover bomb-defuse sequences and completion latching
 
 Thirty coherent source scenarios replay up to five complete callbacks, producing138 snapshots. Scripted motion, held-button changes and teammate release test cancellation/restart; shared state persists through waiting and exact completion. Completed latch prevents repeated allocation/log/award. Missing-bomb boundary stops after one call. Actual lookup/distance bodies execute, while native effect feedback and scheduling remain modeled/captured inputs. Focused `cargo xtask test-group qvm-defuse-sequence` passes with deterministic report regeneration and selected regressions. Full suite deferred to task ten. Original assets unchanged; Python uses the flake-declared Nix runtime.
+
+## 2026-10-29 — RE-1023 Port bomb-defuse replay and fatal/completion boundaries
+
+Rust matches138 source snapshots across30 scripted sequences. Motion/button/teammate inputs apply before each call, while clock/flags/event state persist. Completion latch suppresses duplicate reward requests and missing-bomb diagnostic ends replay. Bounded typed replay stages all updates and snapshots on errors; tests verify exactly one reward, fatal-boundary stop and rollback after a prior successful start. Native effects and frame scheduling remain outside scope. Focused `cargo xtask test-group rust-defuse-sequence` passes with deterministic report regeneration and selected regressions. The single `cargo xtask test-full --since 26cfc686` run at the tenth-commit boundary passed: **1,978 Python tests** across539 modules, **319 Rust tests** (assets10, gameplay279, xtask30), **131 deterministic affected report producers**, storage policy, links across **601 documentation files** and whitespace guards. Regeneration left no changes. Focused dependency-registry regression passed. Validation notes are amended into task ten, preserving ten commits. Original assets unchanged; Python uses the flake-declared Nix runtime.

docs/REVERSE_ENGINEERING_TODO.md

@@ -2079,3 +2079,8 @@ RE-974–983 recover routing, command rewriting, inactivity and composed setup t
 - [x] RE-1021 Port complete bomb-defuse lookup and state policy ([evidence](research/RUST_DEFUSE_COMPLETE.md)).
 
 - [x] RE-1022 Recover bomb-defuse sequences and completion latching ([evidence](research/QVM_DEFUSE_SEQUENCE.md)).
+
+- [x] RE-1023 Port bomb-defuse replay and fatal/completion boundaries ([evidence](research/RUST_DEFUSE_SEQUENCE.md)).
+
+- [x] RE-1014–1023 bomb-defuse batch:278 paired scenarios, including138 repeated-call snapshots ([evidence](research/QVM_DEFUSE_BATCH.md)).
+- [ ] RE-1024 recover objective/native effect feedback and compose defusing with full client preparation/movement/timer execution ([scope](research/QVM_DEFUSE_BATCH.md#next-work-re-1024)).

docs/TESTING.md

@@ -191,3 +191,5 @@ Movement-context focused pairs: `qvm-client-move-scratch`/`rust-client-move-scra
 Movement-callback focused pairs: `qvm-move-meter`/`rust-move-meter`, `qvm-move-self-recovery`/`rust-move-self-recovery`, `qvm-move-assist-cleanup`/`rust-move-assist-cleanup`, `qvm-move-mode8-eligibility`/`rust-move-mode8-eligibility`, and `qvm-move-resolved-self`/`rust-move-resolved-self`. Use one group per invocation. Shared callback module/CLI changes select their Rust producers and gameplay test-count metadata; movement-context changes also select resolved self composition. One full check follows the tenth task: `cargo xtask test-full --since ad83778f`. [Evidence and boundaries](research/QVM_MOVE_CALLBACK_BATCH.md).
 
 Assistance focused pairs: `qvm-assist-acquire`/`rust-assist-acquire`, `qvm-assist-cancel`/`rust-assist-cancel`, `qvm-assist-progress`/`rust-assist-progress`, `qvm-assist-complete`/`rust-assist-complete`, and `qvm-assist-sequence`/`rust-assist-sequence`. Use one group per invocation. Assistance module/CLI and recovered meter/cleanup inputs select affected Rust reports plus gameplay test-count metadata. Complete/replay probes execute actual152792/65655/152386 with modeled sqrt and captured/supplied native effects. The batch full check is `cargo xtask test-full --since 19fce7e8` after ten tasks. [Evidence and limits](research/QVM_ASSISTANCE_BATCH.md).
+
+Defuse focused pairs: `qvm-defuse-begin`/`rust-defuse-begin`, `qvm-defuse-cancel`/`rust-defuse-cancel`, `qvm-defuse-finish`/`rust-defuse-finish`, `qvm-defuse-complete`/`rust-defuse-complete`, and `qvm-defuse-sequence`/`rust-defuse-sequence`. Run one group per invocation. Defuse module/CLI and eligibility inputs select affected Rust producers plus gameplay test-count metadata. Full/replay source checks execute actual153419/276433/65655 with modeled sqrt and supplied/captured native effects; missing lookup stops before fatal2319. Batch-wide validation after task ten is `cargo xtask test-full --since 26cfc686`. [Evidence and boundaries](research/QVM_DEFUSE_BATCH.md).

docs/research/QVM_ASSISTANCE_BATCH.md

@@ -58,7 +58,9 @@ Event publication278003, logs7259, teleport205260 and reset6369 remain captured
 
 The single `cargo xtask test-full --since 19fce7e8` run at the tenth-commit boundary passed: **1,958 Python tests** across529 modules, **309 Rust tests** (assets10, gameplay269, xtask30), **126 deterministic affected report producers**, storage policy, links across **590 documentation files** and whitespace guards. Regeneration left no changes. Focused dependency-registry regression passed. Validation notes are amended into task ten, preserving ten commits.
 
-## Next work: RE-1014
+## Follow-up from RE-1014
+
+The [RE-1014–1023 defuse batch](QVM_DEFUSE_BATCH.md) now covers mode8 objective transitions, actual hash/distance lookup and coherent replay. Native effect feedback and full client/physics integration remain open. The original follow-up scope was:
 
 - [ ] Recover153596 onward mode8 objective lookup, distance/progress/clock transitions, weapon/animation changes and completion effects.
 - [ ] Resolve actual event publication278003, teleport205260, reset6369 and allocation277695 for assistance consumers; replace captured native feedback and verify field ownership.

docs/research/QVM_DEFUSE_BATCH.md

@@ -0,0 +1,65 @@
+# Bomb-defuse transitions and replay: RE-1014–1023
+
+Ten tasks recover five source/Rust contracts across **278 paired scenarios**, including138 repeated-call snapshots. They extend the [assistance batch](QVM_ASSISTANCE_BATCH.md) through the mode8 bomb-defuse callback153419. Every task has a separate commit and focused validation. Native nested effect bodies, actual frame scheduling and full game/platform acceptance remain outside this evidence.
+
+| Tasks | Contract | Paired scenarios |
+| --- | --- | ---: |
+| RE-1014 / RE-1015 | [Source start](QVM_DEFUSE_BEGIN.md) / [Rust start](RUST_DEFUSE_BEGIN.md) | 72 |
+| RE-1016 / RE-1017 | [Source cancellation](QVM_DEFUSE_CANCEL.md) / [Rust cancellation](RUST_DEFUSE_CANCEL.md) | 48 |
+| RE-1018 / RE-1019 | [Source completion](QVM_DEFUSE_FINISH.md) / [Rust completion](RUST_DEFUSE_FINISH.md) | 32 |
+| RE-1020 / RE-1021 | [Complete source callback](QVM_DEFUSE_COMPLETE.md) / [Rust callback](RUST_DEFUSE_COMPLETE.md) | 96 |
+| RE-1022 / RE-1023 | [Source sequences](QVM_DEFUSE_SEQUENCE.md) / [Rust replay](RUST_DEFUSE_SEQUENCE.md) | 30 |
+
+## Starting a defuse
+
+The153774 fragment assumes prior eligibility, near distance, mask32768 and inactive busy state. It reads a low-byte kind from the current weapon-table word at client312+4×client144. If client220 mask32 is set, it clears masks32/64 and writes animation148=2. The tested kinds11/13/other have the same projected outcome; the temporary selected kind does not alter the stored weapon word.
+
+Start then stores the current tick into shared clock35000484, busy6164=1, client220 mask4 and client104 mask16. Event83 is allocated at the selected bomb origin24, its parameter184 receives configured duration34080132, and its entity424 gains mask32. Sound helper193620 is requested with sound7 and the acting entity after event setup.
+
+Seventy-two source cases exercise raw masks, weapon low bytes, zero/positive/negative duration words and high-bit ticks. Source event-field sentinels on both sides of parameter184 survive. Rust typed arrays own the corresponding copy boundaries and reject unsupported weapon/client indices before mutation. Direct fragment cases are synthetic selected-branch inputs; complete callback cases separately establish routing.
+
+## Cancelling
+
+Both153927 unflagged and154008 far-target branches check only whether busy6164 is nonzero. Active cancellation clears shared clock35000484, busy6164, client220 mask4 and client104 mask16. It allocates event84 with parameter0 and event mask32. Weapon, animation, completion latch and unrelated bits remain unchanged.
+
+If busy is zero, cancellation preserves stale clocks and flags and requests no event. Forty-eight cases compare both branches, nonzero high-bit busy words and stale inactive state. Rust cancellation is idempotent and does not evaluate unused weapon/client inputs on an inactive exit.
+
+## Completion and timing
+
+The active153644 path compares signed wrapped elapsed tick minus clock against signed wrapped duration×1000. Unlike the initial eligibility delay, completion accepts equality. Waiting retains all state and emits no effects. Thirty-two cases cover equality, immediately before the threshold, negative elapsed, wrapping ticks, negative duration and multiplication overflow.
+
+Completion requests the original bomb-defused log, sets completion35000396=1, clears clock/busy and the owned masks, allocates event84 with parameter1 and mask32, then requests teleport205260 and award283463 value5. The source order is log, allocation, teleport, award. Weapon and animation remain unchanged. Rust keeps this order as an effect plan and rejects ready invalid client input before mutation; waiting does not evaluate unused indices.
+
+## Complete153419 callback
+
+Ninety-six scenarios execute admission, teammate exclusion, actual class lookup276433, actual distance65655 and the defuse transitions through154087. Both initial enables and the strict admission delay must pass. Completion must be zero; self must be connected/live/non-following and on the selected team. Selector exactly1 chooses team2; other values choose team1. A live connected non-following same-team client with nonzero6164 blocks entry; self is excluded from that scan.
+
+Lookup uses the original precomputed class hash -82007226 and first eligible entity order. Entity532 must be nonzero, class pointer536 nonnull and hash540 matching. Fixtures include inactive, classless and hash-mismatched first candidates with a valid later entity. The table identity and precomputed hashes are supplied; this does not recover bomb creation or class-hash production.
+
+Actual65655 computes distance from actor origin488 to selected bomb origin24 with finite native sqrt modeled. Distance must be strictly below75 to start or continue; equality is far. Near mask32768 chooses start/wait/completion. Far distance or absent mask32768 chooses cancellation.
+
+If lookup returns null, source execution stops at153612 immediately before fatal2319. Rust returns an explicit missing-bomb boundary diagnostic and does not invent post-error behavior. The replay stops there. Cases cover all three selectors, exact radius, zero/64 teammate counts, gating failures, completed latch, decoys and wrapped timing. Distance fixtures are finite and axis-aligned; broader geometry domains remain open.
+
+## Repeated coherent calls
+
+Thirty scenarios preserve state across calls at offsets0/1000/2000/5000/6000. Scripted external updates move a bomb inside the radius, press the defuse button or release a blocking teammate before a later call. The source and Rust compare138 snapshots; three missing-bomb scenarios stop after one call, while the other27 execute five calls.
+
+Snapshots include flags, busy state, shared clock, completion latch, animation/weapon words, allocated event parameters, ordered effects, lookup results and distance bits. They verify cancellation/restart, waiting, exact completion and suppression of duplicate rewards after completion. The scripted updates are inputs, not evidence for movement/input/native scheduling behavior. Rust bounded replay stages the batch on typed errors and stores immutable snapshots; this is an adapter guarantee beyond the per-call source routine.
+
+## Validation and limits
+
+Each task runs its own `cargo xtask test-group qvm-defuse-*` or `rust-defuse-*` before committing. Selected reports regenerate twice identically. Source reports retain verified QVM identity and trace summaries; independent gate/arithmetic/state expectations check the probes. Rust reports compare every projected source field and retain source-report SHA256. Ten added Rust tests cover bit preservation, effect order, timing, stale exits, radius/lookup boundaries, completion latching, missing-bomb stopping and late-error rollback.
+
+Dependency mappings cover all five source/Rust pairs, the defuse module/CLI and existing eligibility policy inputs, including gameplay test-count metadata. The registry regression checks those mappings. One full-suite run follows task ten: `cargo xtask test-full --since 26cfc686`. All Python uses the flake-declared Nix runtime, including Git hooks. Assets and original binaries are unchanged.
+
+Event allocation277695 is supplied. Sound193620, logs7259, teleport205260 and award283463 are captured plans. Their actual allocation, positional, score, network and other state feedback is not executed. Full client routing/movement/timer integration and native macOS/Linux runtime conformance remain open.
+
+The single `cargo xtask test-full --since 26cfc686` run at the tenth-commit boundary passed: **1,978 Python tests** across539 modules, **319 Rust tests** (assets10, gameplay279, xtask30), **131 deterministic affected report producers**, storage policy, links across **601 documentation files** and whitespace guards. Regeneration left no changes. Focused dependency-registry regression passed. Validation notes are amended into task ten, preserving ten commits.
+
+## Next work: RE-1024
+
+- [ ] Recover allocation277695, sound193620, teleport205260 and award283463 for bomb/assistance consumers, then replace captured state feedback with verified adapters.
+- [ ] Recover bomb creation/class ownership and objective event83/84 client rendering/audio consumers; verify shared-clock and teammate ownership across actual lifecycle transitions.
+- [ ] Compose mode8 defusing and nonempty mode10 assistance/self recovery with full154089 client preparation, movement54475 and timer155714.
+- [ ] Recover post-movement event/link/health handling, native trace/contents and time/file/network boundaries, with source-backed longer scenarios.
+- [ ] Expand geometry, aliasing, identity, wrap/configuration and input domains; continue asset/shader conversion, Bevy/Solari rendering and playable macOS/Linux acceptance.

docs/research/README.md

@@ -1611,3 +1611,7 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-1021: Port complete bomb-defuse lookup and state policy](RUST_DEFUSE_COMPLETE.md).
 
 - [RE-1022: Recover bomb-defuse sequences and completion latching](QVM_DEFUSE_SEQUENCE.md).
+
+- [RE-1023: Port bomb-defuse replay and fatal/completion boundaries](RUST_DEFUSE_SEQUENCE.md).
+
+- [Bomb-defuse transitions and replay: RE-1014–1023](QVM_DEFUSE_BATCH.md).

docs/research/RUST_DEFUSE_SEQUENCE.md

@@ -0,0 +1,5 @@
+# Port bomb-defuse replay and fatal/completion boundaries
+
+RE-1023. Focused validation: `cargo xtask test-group rust-defuse-sequence`. [Machine report](rust-defuse-sequence.json).
+
+Rust matches138 source snapshots across30 scripted sequences. Motion/button/teammate inputs apply before each call, while clock/flags/event state persist. Completion latch suppresses duplicate reward requests and missing-bomb diagnostic ends replay. Bounded typed replay stages all updates and snapshots on errors; tests verify exactly one reward, fatal-boundary stop and rollback after a prior successful start. Native effects and frame scheduling remain outside scope.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_defuse_sequence.py

@@ -0,0 +1,17 @@
+"""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-defuse'],check=True,capture_output=True)
+ binary=Path(os.environ.get('CARGO_TARGET_DIR','target'))/'debug'/'urt-defuse'
+ path=Path('docs/research/qvm-defuse-sequence.json');data=path.read_bytes();probes=[]
+ for p in json.loads(data)['probes']:
+  probes.append(dict(source={k:p[k] for k in ['frames']},rust=result(binary,'sequence',encode(p['input']))))
+ write_json(Path('docs/research/rust-defuse-sequence.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.'))
+
+from analyze_rust_defuse_complete import encode as base_encode
+def encode(a):return base_encode(a)+[a['profile']]
+if __name__=='__main__':main()

scripts/test_rust_defuse_sequence.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-defuse-sequence.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-defuse-sequence.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

@@ -4282,3 +4282,35 @@ report	scripts/analyze_qvm_defuse_sequence.py	docs/research/qvm-defuse-sequence.
 edge	docs/research/qvm-defuse-sequence.json	scripts/test_qvm_defuse_sequence.py
 group	qvm-defuse-sequence	scripts/analyze_qvm_defuse_sequence.py
 edge	scripts/analyze_qvm_defuse_sequence.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_rust_defuse_sequence.py	docs/research/rust-defuse-sequence.json
+edge	docs/research/rust-defuse-sequence.json	scripts/test_rust_defuse_sequence.py
+group	rust-defuse-sequence	scripts/analyze_rust_defuse_sequence.py
+edge	scripts/analyze_rust_defuse_sequence.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_defuse_sequence.py
+edge	Cargo.lock	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/filter_loading.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/filter_lifecycle.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-filter-loading.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_defuse_sequence.py
+edge	docs/research/qvm-defuse-sequence.json	scripts/analyze_rust_defuse_sequence.py
+group	rust-defuse-sequence	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/filter_commands.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-filter-commands.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/client_timer.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-client-timer.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/client_processing.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-client-processing.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/client_move_context.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-client-move-context.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-move-callbacks.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/assistance.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-assistance.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/defuse.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/bin/urt-defuse.rs	scripts/analyze_rust_defuse_sequence.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_defuse_sequence.py

xtask/src/lib.rs

@@ -1160,6 +1160,8 @@ mod integration_tests {
             ("move_callbacks", "defuse_finish"),
             ("defuse", "defuse_complete"),
             ("move_callbacks", "defuse_complete"),
+            ("defuse", "defuse_sequence"),
+            ("move_callbacks", "defuse_sequence"),
             ("client_move_context", "client_move_scratch"),
             ("client_processing", "client_routing"),
             ("client_timer", "client_routing"),
@@ -1392,6 +1394,7 @@ mod integration_tests {
             ("qvm-defuse-cancel", "defuse_cancel"),
             ("qvm-defuse-finish", "defuse_finish"),
             ("qvm-defuse-complete", "defuse_complete"),
+            ("qvm-defuse-sequence", "defuse_sequence"),
             ("qvm-client-move-scratch", "client_move_scratch"),
             ("qvm-client-routing", "client_routing"),
             ("qvm-client-command-rewrite", "client_command_rewrite"),