gameplay: resolve full defuse effect feedback

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

@@ -1,3 +1,4 @@
+use urt_gameplay::defuse::*;
 use urt_gameplay::effect_feedback::*;
 fn list(v: &[u32]) -> String {
     format!(
@@ -29,6 +30,7 @@ fn main() {
         "radio" => println!("{}", radio(&w)),
         "finish" => println!("{}", fragment(&w, DefusePhase::Finish)),
         "begin" => println!("{}", fragment(&w, DefusePhase::Begin)),
+        "complete" => println!("{}", complete(&w)),
         _ => panic!("unknown contract"),
     }
 }
@@ -267,3 +269,118 @@ fn fragment(w: &[u32], phase: DefusePhase) -> String {
     let o = resolve_defuse_fragment(&mut s, &mut f, i, &c, phase).unwrap();
     format!("{{{}}}", feedback_fields(s, &f, &o))
 }
+
+fn decode_full(w: &[u32]) -> (DefuseWorld, FullDefuseInput) {
+    use urt_gameplay::move_callbacks::ObjectiveClient;
+    assert_eq!(w.len(), 31);
+    let (state, base) = decode_defuse(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 complete(w: &[u32]) -> String {
+    assert!(w.len() >= 36);
+    assert_eq!(w.len(), 36 + w[35] as usize);
+    let (mut world, i) = decode_full(&w[..31]);
+    let mut f = feedback(w[33] != 0);
+    let c = EffectContext {
+        paused: w[31] != 0,
+        constructed: w[32] != 0,
+        tick: w[7],
+        origin: [0; 3],
+        radio: RadioInput {
+            follow: 0,
+            health: 1,
+            team: 1,
+            slot: 2,
+            mode: 8,
+            count: w[25] as usize,
+            tick: w[7],
+            code: 7,
+            success: w[34] != 0,
+            payload: w[36..].iter().map(|v| *v as u8).collect(),
+        },
+        clients: vec![],
+    };
+    let o = resolve_defuse_world(&mut world, &mut f, i, &c).unwrap();
+    let lookups = o
+        .defuse
+        .lookups
+        .iter()
+        .map(|v| v.map(|i| i.to_string()).unwrap_or("null".into()))
+        .collect::<Vec<_>>()
+        .join(",");
+    format!(
+        r#"{{{},"lookups":[{}],"distances":{},"missing":{}}}"#,
+        feedback_fields(world.state, &f, &o.feedback),
+        lookups,
+        list(&o.defuse.distances),
+        o.defuse.missing
+    )
+}

crates/urt-gameplay/src/effect_feedback.rs

@@ -467,3 +467,144 @@ mod resolved_begin_tests {
         assert_eq!((s, f), old);
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ResolvedWorldOutput {
+    pub defuse: crate::defuse::DefuseOutcome,
+    pub feedback: ResolvedOutput,
+}
+/// Complete defuse policy with resolved constructor/radio/score/counter feedback.
+/// Both world and feedback commit only after all modeled policies succeed.
+pub fn resolve_defuse_world(
+    world: &mut crate::defuse::DefuseWorld,
+    feedback: &mut FeedbackState,
+    input: crate::defuse::FullDefuseInput,
+    context: &EffectContext,
+) -> Result<ResolvedWorldOutput, Error> {
+    let mut next = world.clone();
+    let mut fb = feedback.clone();
+    let defuse = crate::defuse::process_defuse(&mut next, input)?;
+    let mut context = context.clone();
+    context.tick = input.base.tick;
+    context.radio.tick = input.base.tick;
+    context.radio.slot = input.base.slot;
+    context.radio.mode = 8;
+    context.radio.count = input.count;
+    context.clients = next
+        .clients
+        .iter()
+        .map(|c| RadioClient {
+            connection: c.connection,
+            team: c.team,
+        })
+        .collect();
+    if let Some(c) = next.clients.get(input.base.slot as usize) {
+        context.radio.follow = c.follow;
+        context.radio.health = c.health;
+        context.radio.team = c.team;
+    }
+    if let Some(Some(index)) = defuse.lookups.first() {
+        context.origin = next.bombs[*index].point;
+    }
+    let output = resolve_effects(&next.state, &mut fb, defuse.effects.clone(), &context)?;
+    *world = next;
+    *feedback = fb;
+    Ok(ResolvedWorldOutput {
+        defuse,
+        feedback: output,
+    })
+}
+#[cfg(test)]
+mod resolved_world_tests {
+    use super::resolved_finish_tests::{context, feedback};
+    use super::*;
+    use crate::defuse::*;
+    use crate::move_callbacks::ObjectiveClient;
+    fn world() -> DefuseWorld {
+        DefuseWorld {
+            state: DefuseState {
+                flags: 32772,
+                flags104: 16,
+                busy: 1,
+                clock: 5000,
+                complete: 0,
+                animation: 99,
+                weapon: 11,
+                event: [7, 0x80000001],
+            },
+            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: [10f32.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: 0,
+            count: 3,
+        }
+    }
+    #[test]
+    fn full_completion_materializes_event_score_and_counter() {
+        let mut w = world();
+        let mut f = feedback();
+        let c = EffectContext {
+            constructed: true,
+            ..context()
+        };
+        let o = resolve_defuse_world(&mut w, &mut f, input(), &c).unwrap();
+        assert_eq!(w.state.complete, 1);
+        assert_eq!(f.score.player, 0);
+        assert_eq!(f.counters[5], 0);
+        let e = f.event_record.unwrap();
+        assert_eq!(e.kind, 103);
+        assert_eq!(e.origin, [10f32.to_bits(), 0, 0]);
+        assert!(o.feedback.effects.contains(&ResolvedEffect::Rank));
+        assert!(o.feedback.radio.is_empty());
+    }
+    #[test]
+    fn missing_bomb_and_late_error_preserve_state() {
+        let mut w = world();
+        w.bombs.clear();
+        let mut f = feedback();
+        let old = (w.clone(), f.clone());
+        assert!(
+            resolve_defuse_world(&mut w, &mut f, input(), &context())
+                .unwrap()
+                .defuse
+                .missing
+        );
+        assert_eq!((w, f), old);
+        let mut w = world();
+        let mut f = feedback();
+        f.counters.clear();
+        let old = (w.clone(), f.clone());
+        assert!(resolve_defuse_world(&mut w, &mut f, input(), &context()).is_err());
+        assert_eq!((w, f), old);
+    }
+}

docs/FINDINGS.md

@@ -2005,3 +2005,7 @@ RE-1030: Sixteen source cases execute defuse start with actual277695/278138 even
 RE-1031: Rust composes the recovered event constructor and team-radio policies across16 source cases. Metadata, snapped origins, caller event flags and radio commands/marker state match actual source bodies. Explicit allocate/link/radio order replaces the historical sound tag. Tests verify origin snapping and unchanged score/counters, plus rollback of prior start writes on an unsupported origin. Base allocation, linking, location and sending remain boundaries. [Evidence](research/RUST_EFFECT_DEFUSE_BEGIN.md).
 
 RE-1032: Forty-eight coherent source cases execute full defuse gates/lookup/distance with actual constructor, team-radio, score and counter bodies. Reports compare event records, command plans, marker deadlines, player/team scores and counters alongside defuse state. Paused scoring, inactive gates, decoy bombs and missing-bomb boundary are covered. Base allocation, location/formatting and native link/send/ranking/log remain supplied/modeled/captured. No teleport or five-point award is inferred. [Evidence](research/QVM_EFFECT_DEFUSE_COMPLETE.md).
+
+RE-1033: Rust matches48 full-source scenarios with actual constructor/radio/score/counter policies. Selected bomb origin and live teammate table feed the resolved effects rather than fixed synthetic responses. Missing-bomb and paused-score boundaries are preserved; world and feedback stage together on late errors. Tests materialize event84, wrapped score/counter changes and missing/error preservation. Native allocation/link/send/ranking/log and location/formatter boundaries remain explicit. [Evidence](research/RUST_EFFECT_DEFUSE_COMPLETE.md).
+
+RE-1024–1033 batch validation passed:1,998 Python tests,329 Rust tests,141 deterministic affected producers and612 documentation files. Source205260 is score update,283463 is indexed counter increment and193620 is team radio; old capture names remain compatibility labels. [Resolved feedback and next work](research/QVM_EFFECT_FEEDBACK_BATCH.md).

docs/PROVISIONAL_TODO.md

@@ -2065,3 +2065,8 @@ RE-974–983 completed routing, command rewrite, inactivity, movement-parameter
 - [x] RE-1031 Port resolved defuse event and radio feedback ([evidence](research/RUST_EFFECT_DEFUSE_BEGIN.md)).
 
 - [x] RE-1032 Resolve full defuse callback effect feedback ([evidence](research/QVM_EFFECT_DEFUSE_COMPLETE.md)).
+
+- [x] RE-1033 Port full defuse policy with resolved effect bodies ([evidence](research/RUST_EFFECT_DEFUSE_COMPLETE.md)).
+
+- [x] RE-1024–1033 resolved-feedback batch:174 paired scenarios with corrected score/counter/radio identities and actual QVM effect bodies ([evidence](research/QVM_EFFECT_FEEDBACK_BATCH.md)).
+- [ ] RE-1034 connect remaining allocation/location/format/ranking/native feedback and migrate legacy labels ([scope](research/QVM_EFFECT_FEEDBACK_BATCH.md#next-work-re-1034)).

docs/RESEARCH_LEDGER.md

@@ -2803,3 +2803,7 @@ Rust composes the recovered event constructor and team-radio policies across16 s
 ## 2026-10-29 — RE-1032 Resolve full defuse callback effect feedback
 
 Forty-eight coherent source cases execute full defuse gates/lookup/distance with actual constructor, team-radio, score and counter bodies. Reports compare event records, command plans, marker deadlines, player/team scores and counters alongside defuse state. Paused scoring, inactive gates, decoy bombs and missing-bomb boundary are covered. Base allocation, location/formatting and native link/send/ranking/log remain supplied/modeled/captured. No teleport or five-point award is inferred. Focused `cargo xtask test-group qvm-effect-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-1033 Port full defuse policy with resolved effect bodies
+
+Rust matches48 full-source scenarios with actual constructor/radio/score/counter policies. Selected bomb origin and live teammate table feed the resolved effects rather than fixed synthetic responses. Missing-bomb and paused-score boundaries are preserved; world and feedback stage together on late errors. Tests materialize event84, wrapped score/counter changes and missing/error preservation. Native allocation/link/send/ranking/log and location/formatter boundaries remain explicit. Focused `cargo xtask test-group rust-effect-defuse-complete` passes with deterministic report regeneration and selected regressions. The single `cargo xtask test-full --since 74572275` run at the tenth-commit boundary passed: **1,998 Python tests** across549 modules, **329 Rust tests** (assets10, gameplay289, xtask30), **141 deterministic affected report producers**, storage policy, links across **612 documentation files** and whitespace guards. Regeneration left no changes, including earlier defuse outputs. 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

@@ -2102,3 +2102,8 @@ RE-974–983 recover routing, command rewriting, inactivity and composed setup t
 - [x] RE-1031 Port resolved defuse event and radio feedback ([evidence](research/RUST_EFFECT_DEFUSE_BEGIN.md)).
 
 - [x] RE-1032 Resolve full defuse callback effect feedback ([evidence](research/QVM_EFFECT_DEFUSE_COMPLETE.md)).
+
+- [x] RE-1033 Port full defuse policy with resolved effect bodies ([evidence](research/RUST_EFFECT_DEFUSE_COMPLETE.md)).
+
+- [x] RE-1024–1033 resolved-feedback batch:174 paired scenarios with corrected score/counter/radio identities and actual QVM effect bodies ([evidence](research/QVM_EFFECT_FEEDBACK_BATCH.md)).
+- [ ] RE-1034 connect remaining allocation/location/format/ranking/native feedback and migrate legacy labels ([scope](research/QVM_EFFECT_FEEDBACK_BATCH.md#next-work-re-1034)).

docs/TESTING.md

@@ -193,3 +193,5 @@ Movement-callback focused pairs: `qvm-move-meter`/`rust-move-meter`, `qvm-move-s
 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).
+
+Resolved-feedback focused pairs: `qvm-effect-counter`/`rust-effect-counter`, `qvm-effect-radio`/`rust-effect-radio`, `qvm-effect-defuse-finish`/`rust-effect-defuse-finish`, `qvm-effect-defuse-begin`/`rust-effect-defuse-begin`, and `qvm-effect-defuse-complete`/`rust-effect-defuse-complete`. Run one group per invocation. Feedback/score/constructor and defuse inputs select affected producers plus gameplay test-count metadata. Function205260 is score,283463 is indexed counter increment and193620 is team radio; historical labels remain compatible. Full validation after task ten: `cargo xtask test-full --since 74572275`. [Evidence and correction](research/QVM_EFFECT_FEEDBACK_BATCH.md).

docs/research/QVM_DEFUSE_BATCH.md

@@ -59,7 +59,9 @@ Event allocation277695 is supplied. Team radio193620, logs7259, score update2052
 
 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
+## Follow-up from RE-1024
+
+The [RE-1024–1033 feedback batch](QVM_EFFECT_FEEDBACK_BATCH.md) corrects effect identities and connects actual constructor/radio/score/counter bodies. Allocation, location/formatter, ranking and native transport/lifecycle feedback remain open. The original follow-up scope was:
 
 - [ ] Recover allocation277695, team radio193620, score update205260 and counter update283463 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.

docs/research/QVM_EFFECT_FEEDBACK_BATCH.md

@@ -0,0 +1,69 @@
+# Resolved defuse effect feedback: RE-1024–1033
+
+Ten tasks recover five source/Rust contracts across **174 paired scenarios**. They extend the [defuse batch](QVM_DEFUSE_BATCH.md), correcting misleading capture labels and replacing several supplied effects with actual QVM bodies and matching Rust policies. Each task has its own commit and focused validation.
+
+| Tasks | Contract | Paired scenarios |
+| --- | --- | ---: |
+| RE-1024 / RE-1025 | [Source objective counter](QVM_EFFECT_COUNTER.md) / [Rust counter](RUST_EFFECT_COUNTER.md) | 12 |
+| RE-1026 / RE-1027 | [Source team radio](QVM_EFFECT_RADIO.md) / [Rust radio](RUST_EFFECT_RADIO.md) | 34 |
+| RE-1028 / RE-1029 | [Source completion feedback](QVM_EFFECT_DEFUSE_FINISH.md) / [Rust completion](RUST_EFFECT_DEFUSE_FINISH.md) | 64 |
+| RE-1030 / RE-1031 | [Source start feedback](QVM_EFFECT_DEFUSE_BEGIN.md) / [Rust start](RUST_EFFECT_DEFUSE_BEGIN.md) | 16 |
+| RE-1032 / RE-1033 | [Source full feedback](QVM_EFFECT_DEFUSE_COMPLETE.md) / [Rust full feedback](RUST_EFFECT_DEFUSE_COMPLETE.md) | 48 |
+
+## Semantic correction
+
+Earlier assistance/defuse reports used capture labels `teleport`, `award` and `sound` for functions205260,283463 and193620. Inspection of their bodies establishes:
+
+- **205260 adds score.** It checks client existence and global34992512, increments client248 by the supplied delta, optionally updates team scores in mode3, and requests ranking5864. Its origin argument is unused. The generic score policy was already recovered elsewhere; the defuse resolver now applies it.
+- **283463 increments a selected counter by1.** It computes client3036+4×index and wraps that word upward once. Defuse passes index5. This is separate from the one-point score update.
+- **193620 routes team radio commands.** It obtains location text and sends `rsay` commands. It performs no direct native audio playback in this body; downstream radio/audio consumers remain separate work.
+
+Historical JSON schemas and Rust enum tags remain compatible. Their numeric function IDs/arguments remain evidence, but names such as `Teleport`, `Award` and `Sound` must not be used as semantic instructions. Rust variants carry compatibility notes, affected findings have been corrected, and new feedback reports use `score`, `counter` and `radio` tags. New adapters interpret these IDs explicitly. This corrects earlier findings rather than claiming new movement or five-point reward behavior.
+
+## Objective counter283463
+
+Twelve probes execute actual283463 through its void-return boundary, covering indices0/5/14 and zero/ordinary/high-bit/wrapping values. Only the selected word changes. Guards at client3032 and3096 survive. The15-word research window is a bounded supplied storage view, not proof of the complete counter enum or lifecycle. Rust validates its caller-owned slice and performs one wrapping increment.
+
+## Team radio193620
+
+The sender must be live, non-following and not team3. Source268637 location text is supplied with a success result. A failed lookup clears the first buffer byte. Actual33715 classifies modes: connected same-team recipients receive messages in team modes or the explicit mode9 exception; mode11 and signed negative modes do not route. Recipient health/follow state is not checked by this body, and the sender's connection word is not its initial admission gate.
+
+The command format is `rsay sender -1 type "location"`. The fixed integer/string formatter is modeled; payload quotes are preserved without invented escaping. Text-provider behavior beyond the supplied bounded string and native transport remain open. Existing source formatter policies can be connected separately.
+
+After a send, an existing sender marker6168 receives deadline84=tick+3500 and active204=1. No recipients means no marker change; a null marker pointer is not dereferenced. Thirty-four cases cover mode/team/connection gates, zero/64 counts, failed text, quotes, absent marker and time wrapping. Source tests execute actual193620/33715; Rust returns command plans with matching marker state.
+
+## Completion score and counter feedback
+
+Sixty-four active completion scenarios execute actual153644,205260 and283463. Waiting leaves state unchanged. On completion, the ordered observations are log, event allocation, score request, optional ranking request and counter-index5 increment. Starting score and counter values at0xffffffff verifies independent wrapping.
+
+Paused scoring returns before player/team writes or ranking. The later indexed counter increment still occurs because283463 has no pause gate. Defuse runs in mode8, so the source score helper changes the player score without changing team scores. Ranking5864, logging and allocation remain explicit boundaries in this pair. Rust reuses the established score policy and stages completion, score and counter state together; late unsupported counter storage rolls back prior planned updates.
+
+## Event construction and radio at start
+
+Sixteen start cases execute actual277695,278138,193620 and33715. Base allocator277165 still supplies an event pointer. The constructor writes type=event+19, original class metadata/hash, event time and free-after-event state. It snaps origin components through integer conversion and back to f32, initializes trajectory/velocity and copies current origin. Native link-31 is captured before the caller writes duration payload and event mask32.
+
+The source then executes radio routing rather than supplying a sound effect result. Reports compare constructed fields, snapped negative/fractional origins, caller flags/payload, command bytes and marker state. Rust reuses `transition::temporary_event` and the recovered radio policy. Start does not change score/counters. Invalid origin conversion rejects without committing prior start state in the typed adapter.
+
+## Full defuse composition
+
+Forty-eight probes execute full153419 with actual bomb lookup/distance and the resolved constructor/radio/score/counter bodies. Selected bomb origin feeds event construction. Current client connection/team state feeds radio recipients rather than fixed responses. Cases include paused score updates, three selectors, waiting/completion/cancellation, blocking teammates, decoy bombs and the missing-bomb fatal boundary.
+
+Reports compare defuse fields, event records, ordered semantic requests, location/getter counts, command plans, marker state, player/team scores and counter words. Rust stages world and feedback state together. Missing bomb remains an explicit stop before fatal2319; no continuation or native runtime behavior is invented.
+
+## Validation and remaining boundaries
+
+Each task runs its corresponding `cargo xtask test-group qvm-effect-*` or `rust-effect-*` before committing. Selected reports regenerate twice identically. Source reports retain original QVM identity and traces; independent expectations check gates, arithmetic, field writes and order. Rust reports retain source-report SHA256 and compare all projected fields. Ten added Rust tests cover wrapping counters, radio routing, score pause behavior, construction and atomic errors.
+
+Dependency mappings include the feedback module/CLI, score and event-constructor modules, defuse consumers and gameplay test-count metadata. The registry regression verifies selection. One full-suite run follows task ten: `cargo xtask test-full --since 74572275`. Python uses only the flake-declared Nix runtime, including Git hooks. Generated Rust build caches were cleared after a disk-space failure; source/assets were preserved and final validation runs without incremental compilation to limit cache growth.
+
+Remaining boundaries: base allocation277165, native links/sends, location268637, fixed formatter70458, ranking5864 and logs7259. Some have existing generic research elsewhere, but their full feedback is not connected in these probes. This is QVM/Rust policy evidence, not actual game or native platform conformance.
+
+The single `cargo xtask test-full --since 74572275` run at the tenth-commit boundary passed: **1,998 Python tests** across549 modules, **329 Rust tests** (assets10, gameplay289, xtask30), **141 deterministic affected report producers**, storage policy, links across **612 documentation files** and whitespace guards. Regeneration left no changes, including earlier defuse outputs. Focused dependency-registry regression passed. Validation notes are amended into task ten, preserving ten commits.
+
+## Next work: RE-1034
+
+- [ ] Connect actual location/formatter, allocation/lifetime, ranking and native link/send/log adapters into defuse and assistance feedback, reusing existing generic findings where applicable.
+- [ ] Migrate legacy effect-tag APIs/report readers to corrected semantic types without losing provenance or compatibility.
+- [ ] Verify bomb/objective counter enum ownership and event83/84 plus radio7 downstream rendering/audio consumers.
+- [ ] Compose resolved defuse and assistance/self-recovery feedback with full154089 preparation, movement54475 and timer155714.
+- [ ] Expand identity/aliasing, geometry, wrap/configuration and longer lifecycle scenarios; continue asset conversion, Bevy/Solari rendering and playable macOS/Linux acceptance.

docs/research/README.md

@@ -1633,3 +1633,7 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-1031: Port resolved defuse event and radio feedback](RUST_EFFECT_DEFUSE_BEGIN.md).
 
 - [RE-1032: Resolve full defuse callback effect feedback](QVM_EFFECT_DEFUSE_COMPLETE.md).
+
+- [RE-1033: Port full defuse policy with resolved effect bodies](RUST_EFFECT_DEFUSE_COMPLETE.md).
+
+- [Resolved defuse effect feedback: RE-1024–1033](QVM_EFFECT_FEEDBACK_BATCH.md).

docs/research/RUST_EFFECT_DEFUSE_COMPLETE.md

@@ -0,0 +1,5 @@
+# Port full defuse policy with resolved effect bodies
+
+RE-1033. Focused validation: `cargo xtask test-group rust-effect-defuse-complete`. [Machine report](rust-effect-defuse-complete.json).
+
+Rust matches48 full-source scenarios with actual constructor/radio/score/counter policies. Selected bomb origin and live teammate table feed the resolved effects rather than fixed synthetic responses. Missing-bomb and paused-score boundaries are preserved; world and feedback stage together on late errors. Tests materialize event84, wrapped score/counter changes and missing/error preservation. Native allocation/link/send/ranking/log and location/formatter boundaries remain explicit.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_effect_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-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-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', 'score', 'teams', 'counters', 'radio', 'marker', 'event_record', 'lookups', 'distances', 'missing']},rust=result(binary,'complete',encode(p['input']))))
+ write_json(Path('docs/research/rust-effect-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_complete import encode as base_encode
+def encode(a):
+ payload=bytes.fromhex(a['payload'])
+ return base_encode(a)+[a['paused'],a['constructed'],a['marker'],a['success'],len(payload),*payload]
+if __name__=='__main__':main()

scripts/test_rust_effect_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-effect-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-effect-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

@@ -4482,3 +4482,40 @@ report	scripts/analyze_qvm_effect_defuse_complete.py	docs/research/qvm-effect-de
 edge	docs/research/qvm-effect-defuse-complete.json	scripts/test_qvm_effect_defuse_complete.py
 group	qvm-effect-defuse-complete	scripts/analyze_qvm_effect_defuse_complete.py
 edge	scripts/analyze_qvm_effect_defuse_complete.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_rust_effect_defuse_complete.py	docs/research/rust-effect-defuse-complete.json
+edge	docs/research/rust-effect-defuse-complete.json	scripts/test_rust_effect_defuse_complete.py
+group	rust-effect-defuse-complete	scripts/analyze_rust_effect_defuse_complete.py
+edge	scripts/analyze_rust_effect_defuse_complete.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_effect_defuse_complete.py
+edge	Cargo.lock	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/filter_loading.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/filter_lifecycle.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-filter-loading.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	docs/research/qvm-effect-defuse-complete.json	scripts/analyze_rust_effect_defuse_complete.py
+group	rust-effect-defuse-complete	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/filter_commands.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-filter-commands.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/client_timer.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-client-timer.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/client_processing.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-client-processing.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/client_move_context.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-client-move-context.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-move-callbacks.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/assistance.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-assistance.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/defuse.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-defuse.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/effect_feedback.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/bin/urt-effect-feedback.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/score.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/transition.rs	scripts/analyze_rust_effect_defuse_complete.py
+edge	crates/urt-gameplay/src/defuse.rs	scripts/analyze_rust_effect_defuse_complete.py

xtask/src/lib.rs

@@ -1174,6 +1174,10 @@ mod integration_tests {
             ("effect_feedback", "effect_defuse_begin"),
             ("score", "effect_defuse_begin"),
             ("transition", "effect_defuse_begin"),
+            ("effect_feedback", "effect_defuse_complete"),
+            ("defuse", "effect_defuse_complete"),
+            ("score", "effect_defuse_complete"),
+            ("transition", "effect_defuse_complete"),
             ("client_move_context", "client_move_scratch"),
             ("client_processing", "client_routing"),
             ("client_timer", "client_routing"),
@@ -1411,6 +1415,7 @@ mod integration_tests {
             ("qvm-effect-radio", "effect_radio"),
             ("qvm-effect-defuse-finish", "effect_defuse_finish"),
             ("qvm-effect-defuse-begin", "effect_defuse_begin"),
+            ("qvm-effect-defuse-complete", "effect_defuse_complete"),
             ("qvm-client-move-scratch", "client_move_scratch"),
             ("qvm-client-routing", "client_routing"),
             ("qvm-client-command-rewrite", "client_command_rewrite"),