gameplay: resolve defuse score and counter feedback

crates/urt-gameplay/src/bin/urt-effect-feedback.rs

@@ -27,6 +27,7 @@ fn main() {
             );
         }
         "radio" => println!("{}", radio(&w)),
+        "finish" => println!("{}", fragment(&w, DefusePhase::Finish)),
         _ => panic!("unknown contract"),
     }
 }
@@ -81,3 +82,187 @@ fn radio(w: &[u32]) -> String {
         list(&m)
     )
 }
+fn decode_defuse(
+    w: &[u32],
+) -> (
+    urt_gameplay::defuse::DefuseState,
+    urt_gameplay::defuse::DefuseInput,
+) {
+    use urt_gameplay::defuse::*;
+    (
+        DefuseState {
+            flags: w[0],
+            flags104: w[1],
+            busy: w[2],
+            clock: w[3],
+            complete: w[4],
+            animation: w[5],
+            weapon: w[6],
+            event: [7, 0x80000001],
+        },
+        DefuseInput {
+            tick: w[7],
+            duration: w[8],
+            index: w[9],
+            slot: 2,
+        },
+    )
+}
+fn feedback(marker: bool) -> FeedbackState {
+    let mut counters = (100..115).collect::<Vec<_>>();
+    counters[5] = u32::MAX;
+    FeedbackState {
+        score: urt_gameplay::score::State {
+            player: -1,
+            teams: [100, 101, 102, 103],
+        },
+        counters,
+        marker: if marker {
+            Some(RadioMarker {
+                deadline: 17,
+                active: 18,
+            })
+        } else {
+            None
+        },
+        event_record: None,
+    }
+}
+fn effect_events(v: &[ResolvedEffect]) -> String {
+    v.iter()
+        .map(|e| match e {
+            ResolvedEffect::Log { format, slot } => {
+                format!(r#"{{"op":"log","format":"{}","slot":{slot}}}"#, hex(format))
+            }
+            ResolvedEffect::Allocate { event } => format!(r#"{{"op":"allocate","event":{event}}}"#),
+            ResolvedEffect::Link => r#"{"op":"link"}"#.into(),
+            ResolvedEffect::Score { delta } => format!(r#"{{"op":"score","delta":{delta}}}"#),
+            ResolvedEffect::Rank => r#"{"op":"rank"}"#.into(),
+            ResolvedEffect::Counter { index } => format!(r#"{{"op":"counter","index":{index}}}"#),
+            ResolvedEffect::Radio { code } => format!(r#"{{"op":"radio","code":{code}}}"#),
+        })
+        .collect::<Vec<_>>()
+        .join(",")
+}
+fn event_record(record: &Option<urt_gameplay::transition::EventRecord>) -> String {
+    let Some(e) = record else {
+        return "null".into();
+    };
+    let keys = [
+        4, 12, 16, 20, 24, 28, 32, 36, 40, 44, 84, 140, 400, 424, 488, 492, 496, 536, 540, 568, 572,
+    ];
+    let values = [
+        e.kind,
+        e.trajectory[0],
+        e.trajectory[1],
+        e.trajectory[2],
+        e.origin[0],
+        e.origin[1],
+        e.origin[2],
+        e.velocity[0],
+        e.velocity[1],
+        e.velocity[2],
+        e.caller_time,
+        e.owner,
+        e.field400,
+        e.flags,
+        e.current_origin[0],
+        e.current_origin[1],
+        e.current_origin[2],
+        e.class_token,
+        e.class_hash,
+        e.event_time as u32,
+        e.free_after_event,
+    ];
+    format!(
+        "{{{}}}",
+        keys.iter()
+            .zip(values)
+            .map(|(k, v)| format!("\"{k}\":{v}"))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+fn feedback_fields(
+    s: urt_gameplay::defuse::DefuseState,
+    f: &FeedbackState,
+    o: &ResolvedOutput,
+) -> String {
+    let marker = f.marker.map(|v| [v.deadline, v.active]).unwrap_or([17, 18]);
+    let radio = o
+        .radio
+        .iter()
+        .map(|r| {
+            format!(
+                r#"{{"commands":[{}],"getter_calls":{},"marker":{}}}"#,
+                commands(&r.commands),
+                r.getter_calls,
+                list(&marker)
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(",");
+    format!(
+        r#""flags":{},"flags104":{},"busy":{},"clock":{},"complete":{},"animation":{},"weapon":{},"event":{},"guards":[2864434397,287454020],"events":[{}],"score":{},"teams":{},"counters":{},"radio":[{}],"marker":{},"event_record":{}"#,
+        s.flags,
+        s.flags104,
+        s.busy,
+        s.clock,
+        s.complete,
+        s.animation,
+        s.weapon,
+        list(&s.event),
+        effect_events(&o.effects),
+        f.score.player as u32,
+        list(&f.score.teams.map(|v| v as u32)),
+        list(&f.counters),
+        radio,
+        list(&marker),
+        event_record(&f.event_record)
+    )
+}
+fn fragment(w: &[u32], phase: DefusePhase) -> String {
+    assert!(w.len() >= 18);
+    let n = w[17] as usize;
+    assert_eq!(w.len(), 18 + n);
+    let (mut s, i) = decode_defuse(w);
+    let mut f = feedback(w[12] != 0);
+    let c = EffectContext {
+        paused: w[10] != 0,
+        constructed: w[11] != 0,
+        tick: w[7],
+        origin: w[14..17].try_into().unwrap(),
+        radio: RadioInput {
+            follow: 0,
+            health: 1,
+            team: 1,
+            slot: 2,
+            mode: 8,
+            count: 4,
+            tick: w[7],
+            code: 7,
+            success: w[13] != 0,
+            payload: w[18..].iter().map(|v| *v as u8).collect(),
+        },
+        clients: vec![
+            RadioClient {
+                connection: 2,
+                team: 1,
+            },
+            RadioClient {
+                connection: 2,
+                team: 2,
+            },
+            RadioClient {
+                connection: 2,
+                team: 1,
+            },
+            RadioClient {
+                connection: 1,
+                team: 2,
+            },
+        ],
+    };
+    let o = resolve_defuse_fragment(&mut s, &mut f, i, &c, phase).unwrap();
+    format!("{{{}}}", feedback_fields(s, &f, &o))
+}

crates/urt-gameplay/src/effect_feedback.rs

@@ -181,3 +181,235 @@ mod radio_tests {
         assert_eq!(m, old);
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FeedbackState {
+    pub score: crate::score::State,
+    pub counters: Vec<u32>,
+    pub marker: Option<RadioMarker>,
+    pub event_record: Option<crate::transition::EventRecord>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct EffectContext {
+    pub paused: bool,
+    pub constructed: bool,
+    pub tick: u32,
+    pub origin: [u32; 3],
+    pub radio: RadioInput,
+    pub clients: Vec<RadioClient>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ResolvedEffect {
+    Log { format: Vec<u8>, slot: i32 },
+    Allocate { event: u32 },
+    Link,
+    Score { delta: i32 },
+    Rank,
+    Counter { index: usize },
+    Radio { code: u32 },
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ResolvedOutput {
+    pub effects: Vec<ResolvedEffect>,
+    pub radio: Vec<RadioOutcome>,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DefusePhase {
+    Begin,
+    Finish,
+}
+fn allocated_event() -> crate::transition::EventRecord {
+    let v = 0x13579bdf;
+    crate::transition::EventRecord {
+        kind: v,
+        trajectory: [v; 3],
+        origin: [v; 3],
+        velocity: [v; 3],
+        caller_time: v,
+        owner: v,
+        field400: v,
+        flags: 0x80000001,
+        current_origin: [v; 3],
+        class_token: v,
+        class_hash: v,
+        event_time: v as i32,
+        free_after_event: v,
+    }
+}
+fn resolve_effects(
+    state: &crate::defuse::DefuseState,
+    feedback: &mut FeedbackState,
+    effects: Vec<crate::defuse::DefuseEffect>,
+    context: &EffectContext,
+) -> Result<ResolvedOutput, Error> {
+    use crate::defuse::DefuseEffect;
+    let mut out = ResolvedOutput::default();
+    for effect in effects {
+        match effect {
+            DefuseEffect::Log { format, slot } => {
+                out.effects.push(ResolvedEffect::Log { format, slot })
+            }
+            DefuseEffect::Allocate { event } => {
+                out.effects.push(ResolvedEffect::Allocate { event });
+                if context.constructed {
+                    let mut record = feedback
+                        .event_record
+                        .clone()
+                        .unwrap_or_else(allocated_event);
+                    crate::transition::temporary_event(
+                        &mut record,
+                        context.origin,
+                        event,
+                        context.tick as i32,
+                    )
+                    .map_err(|_| Error::InvalidInput)?;
+                    feedback.event_record = Some(record);
+                    out.effects.push(ResolvedEffect::Link);
+                }
+            }
+            // Compatibility tag Teleport is numeric205260: score addition, origin unused.
+            DefuseEffect::Teleport { .. } => {
+                out.effects.push(ResolvedEffect::Score { delta: 1 });
+                let (score, rank) =
+                    crate::score::add(true, context.paused, 8, false, 1, 1, feedback.score)
+                        .map_err(|_| Error::InvalidInput)?;
+                feedback.score = score;
+                if rank {
+                    out.effects.push(ResolvedEffect::Rank);
+                }
+            }
+            // Compatibility tag Award is numeric283463: increment a counter index once.
+            DefuseEffect::Award { value, .. } => {
+                increment_objective_counter(&mut feedback.counters, value as usize)?;
+                out.effects.push(ResolvedEffect::Counter {
+                    index: value as usize,
+                });
+            }
+            DefuseEffect::Sound { slot, sound } => {
+                out.effects.push(ResolvedEffect::Radio { code: sound });
+                let mut input = context.radio.clone();
+                input.slot = slot;
+                input.code = sound;
+                out.radio
+                    .push(team_radio(&mut feedback.marker, &context.clients, &input)?);
+            }
+        }
+    }
+    if let Some(record) = &mut feedback.event_record {
+        record.flags = state.event[1];
+    }
+    Ok(out)
+}
+/// Defuse fragments with actual score/counter/radio/event-constructor policies.
+/// Ranking, native sends/linking and base event allocation remain caller work.
+pub fn resolve_defuse_fragment(
+    state: &mut crate::defuse::DefuseState,
+    feedback: &mut FeedbackState,
+    input: crate::defuse::DefuseInput,
+    context: &EffectContext,
+    phase: DefusePhase,
+) -> Result<ResolvedOutput, Error> {
+    let mut next = *state;
+    let mut fb = feedback.clone();
+    let effects = match phase {
+        DefusePhase::Begin => crate::defuse::begin_defuse(&mut next, input)?,
+        DefusePhase::Finish => crate::defuse::finish_defuse(&mut next, input)?,
+    };
+    let out = resolve_effects(&next, &mut fb, effects, context)?;
+    *state = next;
+    *feedback = fb;
+    Ok(out)
+}
+#[cfg(test)]
+mod resolved_finish_tests {
+    use super::*;
+    pub(super) fn state() -> crate::defuse::DefuseState {
+        crate::defuse::DefuseState {
+            flags: 0x80008004,
+            flags104: 16,
+            busy: 1,
+            clock: 0,
+            complete: 0,
+            animation: 99,
+            weapon: 11,
+            event: [7, 0x80000001],
+        }
+    }
+    pub(super) fn feedback() -> FeedbackState {
+        let mut counters = (100..115).collect::<Vec<_>>();
+        counters[5] = u32::MAX;
+        FeedbackState {
+            score: crate::score::State {
+                player: -1,
+                teams: [100, 101, 102, 103],
+            },
+            counters,
+            marker: Some(RadioMarker {
+                deadline: 17,
+                active: 18,
+            }),
+            event_record: None,
+        }
+    }
+    pub(super) fn context() -> EffectContext {
+        EffectContext {
+            paused: false,
+            constructed: false,
+            tick: 10000,
+            origin: [0; 3],
+            radio: RadioInput {
+                follow: 0,
+                health: 1,
+                team: 1,
+                slot: 2,
+                mode: 8,
+                count: 3,
+                tick: 10000,
+                code: 7,
+                success: true,
+                payload: b"Bomb site".to_vec(),
+            },
+            clients: vec![
+                RadioClient {
+                    connection: 2,
+                    team: 1
+                };
+                3
+            ],
+        }
+    }
+    pub(super) fn input() -> crate::defuse::DefuseInput {
+        crate::defuse::DefuseInput {
+            tick: 10000,
+            duration: 5,
+            index: 3,
+            slot: 2,
+        }
+    }
+    #[test]
+    fn paused_completion_increments_counter_but_not_score() {
+        let mut s = state();
+        let mut f = feedback();
+        let c = EffectContext {
+            paused: true,
+            ..context()
+        };
+        let o = resolve_defuse_fragment(&mut s, &mut f, input(), &c, DefusePhase::Finish).unwrap();
+        assert_eq!(f.score.player, -1);
+        assert_eq!(f.counters[5], 0);
+        assert!(!o.effects.contains(&ResolvedEffect::Rank));
+        assert_eq!(s.complete, 1);
+    }
+    #[test]
+    fn unsupported_counter_rolls_back_prior_completion_and_score() {
+        let mut s = state();
+        let mut f = feedback();
+        f.counters.clear();
+        let old = (s, f.clone());
+        assert!(
+            resolve_defuse_fragment(&mut s, &mut f, input(), &context(), DefusePhase::Finish)
+                .is_err()
+        );
+        assert_eq!((s, f), old);
+    }
+}

docs/FINDINGS.md

@@ -1997,3 +1997,5 @@ RE-1026: Thirty-four original-QVM scenarios recover193620 with actual mode class
 RE-1027: Rust matches34 source team-radio scenarios, including the mode9 exception, mode11/signed exclusions, failed location text, raw quote preservation and64-recipient tables. Only actual sends update an existing marker; empty routing leaves it unchanged. Tests cover connected same-team routing, wrapped marker deadlines and invalid payload atomicity. Text location and native network sends remain boundaries. [Evidence](research/RUST_EFFECT_RADIO.md).
 
 RE-1028: Sixty-four source probes execute defuse completion with actual205260 and283463. Ready completion adds one player score point and requests ranking unless paused, then increments counter index5 by1 regardless of pause. Both score and counter wrap independently. Waiting does neither. Corrected ordered requests are log, allocate, score, optional rank, counter; allocation/log/ranking remain boundaries. This replaces the earlier misleading teleport/five-point labels with actual state feedback. [Evidence](research/QVM_EFFECT_DEFUSE_FINISH.md).
+
+RE-1029: Rust executes the existing score policy and indexed counter update for defuse completion across64 source cases. Paused score remains unchanged without a ranking request, while counter index5 wraps independently. Correct semantic trace tags replace historical aliases in these new reports. Whole completion and feedback state stage atomically; unit tests cover paused behavior and late counter failure after a planned score update. Ranking/log/allocation remain boundaries. [Evidence](research/RUST_EFFECT_DEFUSE_FINISH.md).

docs/PROVISIONAL_TODO.md

@@ -2057,3 +2057,5 @@ RE-974–983 completed routing, command rewrite, inactivity, movement-parameter
 - [x] RE-1027 Port team radio command planning and marker feedback ([evidence](research/RUST_EFFECT_RADIO.md)).
 
 - [x] RE-1028 Resolve defuse completion score and objective counter ([evidence](research/QVM_EFFECT_DEFUSE_FINISH.md)).
+
+- [x] RE-1029 Port resolved defuse score and counter feedback ([evidence](research/RUST_EFFECT_DEFUSE_FINISH.md)).

docs/RESEARCH_LEDGER.md

@@ -2787,3 +2787,7 @@ Rust matches34 source team-radio scenarios, including the mode9 exception, mode1
 ## 2026-10-29 — RE-1028 Resolve defuse completion score and objective counter
 
 Sixty-four source probes execute defuse completion with actual205260 and283463. Ready completion adds one player score point and requests ranking unless paused, then increments counter index5 by1 regardless of pause. Both score and counter wrap independently. Waiting does neither. Corrected ordered requests are log, allocate, score, optional rank, counter; allocation/log/ranking remain boundaries. This replaces the earlier misleading teleport/five-point labels with actual state feedback. Focused `cargo xtask test-group qvm-effect-defuse-finish` 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-1029 Port resolved defuse score and counter feedback
+
+Rust executes the existing score policy and indexed counter update for defuse completion across64 source cases. Paused score remains unchanged without a ranking request, while counter index5 wraps independently. Correct semantic trace tags replace historical aliases in these new reports. Whole completion and feedback state stage atomically; unit tests cover paused behavior and late counter failure after a planned score update. Ranking/log/allocation remain boundaries. Focused `cargo xtask test-group rust-effect-defuse-finish` 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

@@ -2094,3 +2094,5 @@ RE-974–983 recover routing, command rewriting, inactivity and composed setup t
 - [x] RE-1027 Port team radio command planning and marker feedback ([evidence](research/RUST_EFFECT_RADIO.md)).
 
 - [x] RE-1028 Resolve defuse completion score and objective counter ([evidence](research/QVM_EFFECT_DEFUSE_FINISH.md)).
+
+- [x] RE-1029 Port resolved defuse score and counter feedback ([evidence](research/RUST_EFFECT_DEFUSE_FINISH.md)).

docs/research/README.md

@@ -1625,3 +1625,5 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-1027: Port team radio command planning and marker feedback](RUST_EFFECT_RADIO.md).
 
 - [RE-1028: Resolve defuse completion score and objective counter](QVM_EFFECT_DEFUSE_FINISH.md).
+
+- [RE-1029: Port resolved defuse score and counter feedback](RUST_EFFECT_DEFUSE_FINISH.md).

docs/research/RUST_EFFECT_DEFUSE_FINISH.md

@@ -0,0 +1,5 @@
+# Port resolved defuse score and counter feedback
+
+RE-1029. Focused validation: `cargo xtask test-group rust-effect-defuse-finish`. [Machine report](rust-effect-defuse-finish.json).
+
+Rust executes the existing score policy and indexed counter update for defuse completion across64 source cases. Paused score remains unchanged without a ranking request, while counter index5 wraps independently. Correct semantic trace tags replace historical aliases in these new reports. Whole completion and feedback state stage atomically; unit tests cover paused behavior and late counter failure after a planned score update. Ranking/log/allocation remain boundaries.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_effect_defuse_finish.py

@@ -0,0 +1,20 @@
+"""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-effect-feedback'],check=True,capture_output=True)
+ binary=Path(os.environ.get('CARGO_TARGET_DIR','target'))/'debug'/'urt-effect-feedback'
+ path=Path('docs/research/qvm-effect-defuse-finish.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', 'score', 'teams', 'counters', 'radio', 'marker', 'event_record']},rust=result(binary,'finish',encode(p['input']))))
+ write_json(Path('docs/research/rust-effect-defuse-finish.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
+ payload=bytes.fromhex(a['payload'])
+ return base_encode(a)+[a['paused'],a['constructed'],a['marker'],a['success'],*[word(v) for v in a['origin']],len(payload),*payload]
+if __name__=='__main__':main()

scripts/test_rust_effect_defuse_finish.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-effect-defuse-finish.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-effect-defuse-finish.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

@@ -4400,3 +4400,40 @@ report	scripts/analyze_qvm_effect_defuse_finish.py	docs/research/qvm-effect-defu
 edge	docs/research/qvm-effect-defuse-finish.json	scripts/test_qvm_effect_defuse_finish.py
 group	qvm-effect-defuse-finish	scripts/analyze_qvm_effect_defuse_finish.py
 edge	scripts/analyze_qvm_effect_defuse_finish.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_rust_effect_defuse_finish.py	docs/research/rust-effect-defuse-finish.json
+edge	docs/research/rust-effect-defuse-finish.json	scripts/test_rust_effect_defuse_finish.py
+group	rust-effect-defuse-finish	scripts/analyze_rust_effect_defuse_finish.py
+edge	scripts/analyze_rust_effect_defuse_finish.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_effect_defuse_finish.py
+edge	Cargo.lock	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/filter_loading.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/filter_lifecycle.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-filter-loading.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	docs/research/qvm-effect-defuse-finish.json	scripts/analyze_rust_effect_defuse_finish.py
+group	rust-effect-defuse-finish	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/filter_commands.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-filter-commands.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/client_timer.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-client-timer.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/client_processing.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-client-processing.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/client_move_context.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-client-move-context.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-move-callbacks.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/assistance.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-assistance.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/defuse.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-defuse.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/effect_feedback.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/bin/urt-effect-feedback.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/score.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/transition.rs	scripts/analyze_rust_effect_defuse_finish.py
+edge	crates/urt-gameplay/src/defuse.rs	scripts/analyze_rust_effect_defuse_finish.py

xtask/src/lib.rs

@@ -1168,6 +1168,9 @@ mod integration_tests {
             ("effect_feedback", "effect_radio"),
             ("score", "effect_radio"),
             ("transition", "effect_radio"),
+            ("effect_feedback", "effect_defuse_finish"),
+            ("score", "effect_defuse_finish"),
+            ("transition", "effect_defuse_finish"),
             ("client_move_context", "client_move_scratch"),
             ("client_processing", "client_routing"),
             ("client_timer", "client_routing"),
@@ -1403,6 +1406,7 @@ mod integration_tests {
             ("qvm-defuse-sequence", "defuse_sequence"),
             ("qvm-effect-counter", "effect_counter"),
             ("qvm-effect-radio", "effect_radio"),
+            ("qvm-effect-defuse-finish", "effect_defuse_finish"),
             ("qvm-client-move-scratch", "client_move_scratch"),
             ("qvm-client-routing", "client_routing"),
             ("qvm-client-command-rewrite", "client_command_rewrite"),