gameplay: port complete bomb defuse callback

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

@@ -84,6 +84,99 @@ fn main() {
             let e = finish_defuse(&mut s, i).unwrap();
             println!("{{{}}}", fields(s, &e));
         }
+        "full" => println!("{}", full(&w)),
         _ => panic!("unknown policy"),
     }
 }
+fn decode_full(w: &[u32]) -> (DefuseWorld, FullDefuseInput) {
+    use urt_gameplay::move_callbacks::ObjectiveClient;
+    assert_eq!(w.len(), 31);
+    let (state, base) = decode(w);
+    let selected = if w[27] == 1 { 2 } else { 1 };
+    let own_team = if w[19] == 0 { selected } else { w[19] };
+    let other_team = if w[24] == 0 { selected } else { w[24] };
+    let mut clients = vec![
+        ObjectiveClient {
+            connection: 2,
+            health: 1,
+            follow: 0,
+            team: selected,
+            busy: 0
+        };
+        (w[25] as usize).max(3)
+    ];
+    clients[w[26] as usize] = ObjectiveClient {
+        connection: w[21],
+        health: w[22],
+        follow: w[23],
+        team: other_team,
+        busy: w[20],
+    };
+    clients[2] = ObjectiveClient {
+        connection: w[16],
+        health: w[17],
+        follow: w[18],
+        team: own_team,
+        busy: state.busy,
+    };
+    let mut bombs = vec![
+        DefuseBomb {
+            in_use: true,
+            has_class: true,
+            hash: 0,
+            point: [0; 3]
+        };
+        6
+    ];
+    for j in [4, 5] {
+        bombs[j].hash = BOMB_CLASS_HASH;
+        bombs[j].point[0] = if j == 4 { w[28] } else { 30f32.to_bits() };
+    }
+    match w[29] {
+        1 => bombs[4].in_use = false,
+        2 => bombs[4].has_class = false,
+        3 => bombs[4].hash = 0,
+        _ => {}
+    }
+    if w[30] != 0 {
+        bombs[4].hash = 0;
+        bombs[5].hash = 0;
+    }
+    (
+        DefuseWorld {
+            state,
+            clients,
+            bombs,
+            actor_point: [0; 3],
+        },
+        FullDefuseInput {
+            base,
+            entity: w[10] != 0,
+            client: w[11] != 0,
+            enabled_a: w[12],
+            enabled_b: w[13],
+            start: w[14],
+            delay: w[15],
+            selector: w[27],
+            count: w[25] as usize,
+        },
+    )
+}
+fn full_fields(s: DefuseState, o: &DefuseOutcome) -> String {
+    format!(
+        r#"{},"lookups":[{}],"distances":{},"missing":{}"#,
+        fields(s, &o.effects),
+        o.lookups
+            .iter()
+            .map(|v| v.map(|i| i.to_string()).unwrap_or("null".into()))
+            .collect::<Vec<_>>()
+            .join(","),
+        list(&o.distances),
+        o.missing
+    )
+}
+fn full(w: &[u32]) -> String {
+    let (mut world, i) = decode_full(w);
+    let o = process_defuse(&mut world, i).unwrap();
+    format!("{{{}}}", full_fields(world.state, &o))
+}

crates/urt-gameplay/src/defuse.rs

@@ -327,3 +327,194 @@ mod finish_tests {
         assert_eq!(s.complete, 1);
     }
 }
+
+pub const BOMB_CLASS_HASH: u32 = (-82007226i32) as u32;
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct DefuseBomb {
+    pub in_use: bool,
+    pub has_class: bool,
+    pub hash: u32,
+    pub point: [u32; 3],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DefuseWorld {
+    pub state: DefuseState,
+    pub clients: Vec<crate::move_callbacks::ObjectiveClient>,
+    pub bombs: Vec<DefuseBomb>,
+    pub actor_point: [u32; 3],
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FullDefuseInput {
+    pub base: DefuseInput,
+    pub entity: bool,
+    pub client: bool,
+    pub enabled_a: u32,
+    pub enabled_b: u32,
+    pub start: u32,
+    pub delay: u32,
+    pub selector: u32,
+    pub count: usize,
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct DefuseOutcome {
+    pub effects: Vec<DefuseEffect>,
+    pub lookups: Vec<Option<usize>>,
+    pub distances: Vec<u32>,
+    pub missing: bool,
+}
+fn distance(a: [u32; 3], b: [u32; 3]) -> Result<f32, Error> {
+    let mut d = [0.; 3];
+    for j in 0..3 {
+        let a = f32::from_bits(a[j]);
+        let b = f32::from_bits(b[j]);
+        if !a.is_finite() || !b.is_finite() {
+            return Err(Error::NonFinite);
+        }
+        d[j] = b - a;
+    }
+    let square = (d[0] * d[0] + d[1] * d[1]) + d[2] * d[2];
+    if !square.is_finite() {
+        return Err(Error::NonFinite);
+    }
+    Ok(square.sqrt())
+}
+/// Original153419 through the void-return/fatal boundary. Lookup uses supplied
+/// entity identity and precomputed class hash. Missing bomb returns a diagnostic
+/// boundary without invoking fatal2319. Native actions remain effect plans.
+pub fn process_defuse(
+    world: &mut DefuseWorld,
+    input: FullDefuseInput,
+) -> Result<DefuseOutcome, Error> {
+    use crate::move_callbacks::{Mode8EligibilityInput, mode8_eligible};
+    let mut out = DefuseOutcome::default();
+    let mut clients = world.clients.clone();
+    if let Some(own) = clients.get_mut(input.base.slot as usize) {
+        own.busy = world.state.busy;
+    }
+    if !mode8_eligible(
+        &clients,
+        Mode8EligibilityInput {
+            entity: input.entity,
+            client: input.client,
+            enabled_a: input.enabled_a,
+            enabled_b: input.enabled_b,
+            tick: input.base.tick,
+            start: input.start,
+            delay: input.delay,
+            complete: world.state.complete,
+            selector: input.selector,
+            self_index: input.base.slot as usize,
+            count: input.count,
+        },
+    )? {
+        return Ok(out);
+    }
+    let bomb = world
+        .bombs
+        .iter()
+        .position(|b| b.in_use && b.has_class && b.hash == BOMB_CLASS_HASH);
+    out.lookups.push(bomb);
+    let Some(index) = bomb else {
+        out.missing = true;
+        return Ok(out);
+    };
+    let d = distance(world.actor_point, world.bombs[index].point)?;
+    out.distances.push(d.to_bits());
+    let mut next = world.state;
+    out.effects = if d >= 75. || next.flags & 32768 == 0 {
+        cancel_defuse(&mut next, input.base)?
+    } else {
+        finish_defuse(&mut next, input.base)?
+    };
+    clients[input.base.slot as usize].busy = next.busy;
+    world.clients = clients;
+    world.state = next;
+    Ok(out)
+}
+#[cfg(test)]
+mod full_tests {
+    use super::*;
+    use crate::move_callbacks::ObjectiveClient;
+    fn world() -> DefuseWorld {
+        DefuseWorld {
+            state: DefuseState {
+                flags: 32768,
+                busy: 0,
+                clock: 0,
+                flags104: 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: false,
+                    has_class: true,
+                    hash: BOMB_CLASS_HASH,
+                    point: [0; 3],
+                },
+                DefuseBomb {
+                    in_use: true,
+                    has_class: true,
+                    hash: BOMB_CLASS_HASH,
+                    point: [75f32.to_bits(), 0, 0],
+                },
+            ],
+            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: 2,
+            count: 3,
+        }
+    }
+    #[test]
+    fn lookup_skips_decoys_and_radius_equality_does_not_start() {
+        let mut w = world();
+        let o = process_defuse(&mut w, input()).unwrap();
+        assert_eq!(o.lookups, vec![Some(1)]);
+        assert!(o.effects.is_empty());
+        assert_eq!(w.state.busy, 0);
+        w.bombs[1].point[0] = 74f32.to_bits();
+        let o = process_defuse(&mut w, input()).unwrap();
+        assert_eq!(w.state.busy, 1);
+        assert_eq!(o.effects.len(), 2);
+    }
+    #[test]
+    fn missing_bomb_and_bad_distance_preserve_state() {
+        let mut w = world();
+        w.bombs[1].has_class = false;
+        let old = w.clone();
+        assert!(process_defuse(&mut w, input()).unwrap().missing);
+        assert_eq!(w, old);
+        w.bombs[1].has_class = true;
+        w.bombs[1].point[0] = f32::MAX.to_bits();
+        let old = w.clone();
+        assert!(process_defuse(&mut w, input()).is_err());
+        assert_eq!(w, old);
+    }
+}

docs/FINDINGS.md

@@ -1979,3 +1979,5 @@ RE-1018: Thirty-two source cases recover active completion when signed wrapped e
 RE-1019: Rust matches32 active source completion cases with signed wrapped elapsed/duration arithmetic and equality completion. The original log/event84/teleport/award order is preserved as plans. Inactive selected state reuses start policy; waiting avoids unused index evaluation, while ready invalid client indices reject before mutation. Unit cases cover exact and wrapped completion, high-bit preservation and waiting/error atomicity. [Evidence](research/RUST_DEFUSE_FINISH.md).
 
 RE-1020: Ninety-six source scenarios connect original admission/teammate scan to actual276433 bomb hash lookup and65655 distance, then start/wait/cancel/complete transitions. Three selectors, radius75 equality, zero/64 teammate counts, inactive/classless/hash-mismatched decoys, wrapped time, completed latch and missing bomb are covered. Missing lookup stops before original2319 fatal handler. Native sqrt is modeled; event/native effect feedback is captured or supplied, not executed. [Evidence](research/QVM_DEFUSE_COMPLETE.md).
+
+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).

docs/PROVISIONAL_TODO.md

@@ -2038,3 +2038,5 @@ RE-974–983 completed routing, command rewrite, inactivity, movement-parameter
 - [x] RE-1019 Port timed bomb-defuse completion and captured effects ([evidence](research/RUST_DEFUSE_FINISH.md)).
 
 - [x] RE-1020 Recover complete mode8 bomb-defuse callback ([evidence](research/QVM_DEFUSE_COMPLETE.md)).
+
+- [x] RE-1021 Port complete bomb-defuse lookup and state policy ([evidence](research/RUST_DEFUSE_COMPLETE.md)).

docs/RESEARCH_LEDGER.md

@@ -2755,3 +2755,7 @@ Rust matches32 active source completion cases with signed wrapped elapsed/durati
 ## 2026-10-29 — RE-1020 Recover complete mode8 bomb-defuse callback
 
 Ninety-six source scenarios connect original admission/teammate scan to actual276433 bomb hash lookup and65655 distance, then start/wait/cancel/complete transitions. Three selectors, radius75 equality, zero/64 teammate counts, inactive/classless/hash-mismatched decoys, wrapped time, completed latch and missing bomb are covered. Missing lookup stops before original2319 fatal handler. Native sqrt is modeled; event/native effect feedback is captured or supplied, not executed. Focused `cargo xtask test-group qvm-defuse-complete` 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-1021 Port complete bomb-defuse lookup and state policy
+
+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. Focused `cargo xtask test-group rust-defuse-complete` passes with deterministic report regeneration and selected regressions. Full suite deferred to task ten. Original assets unchanged; Python uses the flake-declared Nix runtime.

docs/REVERSE_ENGINEERING_TODO.md

@@ -2075,3 +2075,5 @@ RE-974–983 recover routing, command rewriting, inactivity and composed setup t
 - [x] RE-1019 Port timed bomb-defuse completion and captured effects ([evidence](research/RUST_DEFUSE_FINISH.md)).
 
 - [x] RE-1020 Recover complete mode8 bomb-defuse callback ([evidence](research/QVM_DEFUSE_COMPLETE.md)).
+
+- [x] RE-1021 Port complete bomb-defuse lookup and state policy ([evidence](research/RUST_DEFUSE_COMPLETE.md)).

docs/research/README.md

@@ -1607,3 +1607,5 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-1019: Port timed bomb-defuse completion and captured effects](RUST_DEFUSE_FINISH.md).
 
 - [RE-1020: Recover complete mode8 bomb-defuse callback](QVM_DEFUSE_COMPLETE.md).
+
+- [RE-1021: Port complete bomb-defuse lookup and state policy](RUST_DEFUSE_COMPLETE.md).

docs/research/RUST_DEFUSE_COMPLETE.md

@@ -0,0 +1,5 @@
+# Port complete bomb-defuse lookup and state policy
+
+RE-1021. Focused validation: `cargo xtask test-group rust-defuse-complete`. [Machine report](rust-defuse-complete.json).
+
+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.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_defuse_complete.py

@@ -0,0 +1,19 @@
+"""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-complete.json');data=path.read_bytes();probes=[]
+ for p in json.loads(data)['probes']:
+  probes.append(dict(source={k:p[k] for k in ['flags', 'flags104', 'busy', 'clock', 'complete', 'animation', 'weapon', 'event', 'guards', 'events', 'lookups', 'distances', 'missing']},rust=result(binary,'full',encode(p['input']))))
+ write_json(Path('docs/research/rust-defuse-complete.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_begin import encode as base_encode
+def encode(a):
+ from analyze_qvm_acceleration import word
+ return base_encode(a)+[a['entity'],a['client'],a['enabled_a'],a['enabled_b'],a['start'],a['delay'],a['connection'],a['health'],a['follow'],a['team'],a['other_busy'],a['other_connection'],a['other_health'],a['other_follow'],a['other_team'],a['count'],a['busy_slot'],a['selector'],word(a['distance']),a['bomb_first'],a['bomb_missing']]
+if __name__=='__main__':main()

scripts/test_rust_defuse_complete.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-complete.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-complete.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

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

xtask/src/lib.rs

@@ -1158,6 +1158,8 @@ mod integration_tests {
             ("move_callbacks", "defuse_cancel"),
             ("defuse", "defuse_finish"),
             ("move_callbacks", "defuse_finish"),
+            ("defuse", "defuse_complete"),
+            ("move_callbacks", "defuse_complete"),
             ("client_move_context", "client_move_scratch"),
             ("client_processing", "client_routing"),
             ("client_timer", "client_routing"),
@@ -1389,6 +1391,7 @@ mod integration_tests {
             ("qvm-defuse-begin", "defuse_begin"),
             ("qvm-defuse-cancel", "defuse_cancel"),
             ("qvm-defuse-finish", "defuse_finish"),
+            ("qvm-defuse-complete", "defuse_complete"),
             ("qvm-client-move-scratch", "client_move_scratch"),
             ("qvm-client-routing", "client_routing"),
             ("qvm-client-command-rewrite", "client_command_rewrite"),