gameplay: port scoreboard dispatch policy

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

@@ -341,6 +341,65 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "scoreboard-recipients" if !w.is_empty() && w[0] <= 64 => {
+            let n = w[0] as usize;
+            if w.len() != 1 + n {
+                return Err("invalid scoreboard states".into());
+            }
+            let states: Vec<_> = w[1..].iter().map(|v| *v as i32).collect();
+            let r = urt_gameplay::scoreboard::recipients(&states)
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            println!(
+                "{{\"recipients\":[{}]}}",
+                r.iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+            );
+        }
+        "rank-publish" if w.len() >= 5 && w[3] <= 1 && w[4] <= 64 => {
+            let n = w[4] as usize;
+            if w.len() != 5 + 12 * n {
+                return Err("invalid ranking publication words".into());
+            }
+            let slots: Vec<_> = w[5..]
+                .chunks_exact(12)
+                .map(|v| urt_gameplay::ranking_population::Slot {
+                    client: ranking_client(v),
+                    entity_flags: v[10],
+                    rank: v[11],
+                })
+                .collect();
+            let r = urt_gameplay::scoreboard::ranking_plan(
+                w[0] as i32,
+                &slots,
+                [w[1] as i32, w[2] as i32],
+                w[3] != 0,
+            )
+            .map_err(|e| format!("unsupported input: {e:?}"))?;
+            println!(
+                "{{\"order\":[{}],\"ranks\":[{}],\"globals\":{},\"recipients\":[{}]}}",
+                r.ranking
+                    .population
+                    .order
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(","),
+                r.ranking
+                    .ranks
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(","),
+                population_json(&r.ranking.population),
+                r.recipients
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+            );
+        }
         "rank-mixed" if w.len() >= 4 && w[3] <= 64 => {
             let n = w[3] as usize;
             if w.len() != 4 + 12 * n {

crates/urt-gameplay/src/lib.rs

@@ -161,3 +161,5 @@ pub mod stat_totals;
 pub mod rank_sort;
 
 pub mod ranking_population;
+
+pub mod scoreboard;

crates/urt-gameplay/src/scoreboard.rs

@@ -0,0 +1,84 @@
+//! QVM6328 recipient policy and a pure captured-7805 ranking publication plan.
+use crate::ranking_population::{self, PopulationError, RankedPopulation, Slot};
+/// Includes connected spectators. Entity flags/activity do not gate6328.
+pub fn recipients(states: &[i32]) -> Result<Vec<usize>, PopulationError> {
+    if states.len() > 64 {
+        return Err(PopulationError::TooManyClients);
+    }
+    Ok(states
+        .iter()
+        .enumerate()
+        .filter_map(|(id, &state)| (state == 2).then_some(id))
+        .collect())
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RankingPlan {
+    pub ranking: RankedPopulation,
+    pub recipients: Vec<usize>,
+}
+/// Pure fixture contract:7805 is captured without effects. A live caller must
+/// execute its exit-rule effects before re-evaluating6328 connection states.
+pub fn ranking_plan(
+    mode: i32,
+    slots: &[Slot],
+    scores: [i32; 2],
+    broadcast: bool,
+) -> Result<RankingPlan, PopulationError> {
+    let ranking = ranking_population::ranked(mode, slots, scores)?;
+    let recipients = if broadcast {
+        recipients(
+            &slots
+                .iter()
+                .map(|s| s.client.connection)
+                .collect::<Vec<_>>(),
+        )?
+    } else {
+        vec![]
+    };
+    Ok(RankingPlan {
+        ranking,
+        recipients,
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ranking::Client;
+    #[test]
+    fn exact_connection_gate_and_scan_order() {
+        assert_eq!(recipients(&[-1, 0, 1, 2, 3, 2]).unwrap(), [3, 5]);
+        assert_eq!(recipients(&[]).unwrap(), []);
+    }
+    #[test]
+    fn count_limit_and_all_connected() {
+        assert_eq!(recipients(&[2; 64]).unwrap(), (0..64).collect::<Vec<_>>());
+        assert_eq!(recipients(&[2; 65]), Err(PopulationError::TooManyClients));
+    }
+    #[test]
+    fn connected_spectator_plan_respects_gate_and_preserves_ranking() {
+        let c = Client {
+            spectator_state: 0,
+            follow_index: 0,
+            connection: 2,
+            team: 3,
+            spectator_time: 0,
+            time: 0,
+            class: 0,
+            score: 0,
+            deaths: 0,
+            awards: 0,
+        };
+        let s = [Slot {
+            client: c,
+            entity_flags: 8,
+            rank: 333,
+        }];
+        let yes = ranking_plan(0, &s, [0, 0], true).unwrap();
+        let no = ranking_plan(0, &s, [0, 0], false).unwrap();
+        assert_eq!(yes.recipients, [0]);
+        assert_eq!(no.recipients, []);
+        assert_eq!(yes.ranking, no.ranking);
+        assert_eq!(yes.ranking.ranks, [333]);
+        assert_eq!(yes.ranking.population.playing, 0);
+    }
+}

docs/ASSET_PIPELINE_TODO.md

@@ -1024,3 +1024,6 @@ Research progress: RE-789 [report](research/QVM_RANK_LARGE_SORT.md); original as
 
 
 RE-780–789 uses original verified QVM bytes without changing assets. Shared byte-memory interfaces and remaining native/runtime conversions remain open. [Batch evidence](research/QVM_RESUMER_PARTITION_BATCH.md).
+
+
+RE-791–800 uses verified original QVM bytes and updates code/docs only. No original assets changed; full runtime/conversion/platform acceptance remains open. [Batch evidence](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md).

docs/FINDINGS.md

@@ -1397,3 +1397,9 @@ RE-780–789 exposes and bounds legacy resumer timing/byte-state flaws, migrates
 
 
 **RE-799:** 6328 dispatches179363 to every state2 client in scan order, including spectators, and now executes inside48 complete ranking caller fixtures. [Evidence](research/QVM_SCOREBOARD_BROADCAST.md).
+
+
+**RE-800:** Rust reproduces all6328 recipient requests and exact rank-plan outputs across69 source fixtures, including connected spectators and both broadcast gates. [Evidence](research/RUST_SCOREBOARD.md).
+
+
+RE-791–800 adds exact Rust source-sort/ranking parity, mixed count/prefix semantics, composed stat ratios and source/Rust scoreboard dispatch. [Batch evidence](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md).

docs/PROVISIONAL_TODO.md

@@ -1401,3 +1401,12 @@ RE-798: 278834 now optionally composes actual team counters and both ratio refre
 
 
 RE-799: 6328 dispatches179363 to every state2 client in scan order, including spectators, and now executes inside48 complete ranking caller fixtures. Full runtime completion remains open. [Evidence](research/QVM_SCOREBOARD_BROADCAST.md).
+
+
+RE-800: Rust reproduces all6328 recipient requests and exact rank-plan outputs across69 source fixtures, including connected spectators and both broadcast gates. Full runtime completion remains open. [Evidence](research/RUST_SCOREBOARD.md).
+
+
+RE-791–800 completes additional bounded source/Rust ranking and dispatch contracts. Remaining legacy traces, native serialization, runtime integration and platform acceptance stay open. [Batch evidence](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md).
+
+
+RE-791–800 validation: 1,562 Python and102 Rust tests pass;226 affected producers reproduce byte-identically. Exact Rust sorting/ranking and source/Rust broadcast contracts advance the bounded rewrite. Native exit-rule/serialization effects, remaining tracing consumers, full runtime integration and Linux/macOS Bevy/Solari acceptance remain open. [Evidence](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -1659,3 +1659,15 @@ Rust matches exact order, rank words and count globals for144 complete mixed/eli
 ## 2026-10-26 — RE-799 Actual scoreboard broadcast dispatch and full ranking caller gate
 
 6328 dispatches179363 to every state2 client in scan order, including spectators, and now executes inside48 complete ranking caller fixtures. Focused `cargo xtask test-group scoreboard-broadcast` passes (6 Python tests); selected reports regenerate twice deterministically, with storage, documentation links and whitespace guards. Full suite deferred to task ten. Original assets unchanged; source fixtures do not establish complete native/runtime parity.
+
+
+## 2026-10-26 — RE-800 Rust scoreboard recipient policy and bounded ranking publication plan
+
+Rust reproduces all6328 recipient requests and exact rank-plan outputs across69 source fixtures, including connected spectators and both broadcast gates. Focused `cargo xtask test-group rust-scoreboard` passes (10 Python tests); selected reports regenerate twice deterministically, with storage, documentation links and whitespace guards. Full suite deferred to task ten. Original assets unchanged; source fixtures do not establish complete native/runtime parity.
+
+RE-800 final focused recheck passes10 Python tests and deterministic report/storage/link/whitespace checks after batch documentation and explicit formatted-source registry edges. The scoped xtask registry integration test also passes, verifying all ten new source-report mappings and new module selection paths. Full validation starts only after commit ten.
+
+
+## 2026-10-26 — RE-791–800 full batch validation
+
+After exactly ten task commits from `c6b4a1eb`, the single `cargo xtask test-full --since c6b4a1eb` run passed 1,562 Python tests (516+346+331+369) and102 Rust tests (10 assets,64 gameplay,28 xtask). All226 affected report producers regenerated twice byte-identically. Storage policy,359 documentation files and whitespace checks passed; regeneration left the working tree clean. Final documentation-only notes are checked separately and amended into task ten without repeating the full suite. [Batch contracts and RE-801 work](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md).

docs/REVERSE_ENGINEERING_TODO.md

@@ -1447,3 +1447,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-799 Actual scoreboard broadcast dispatch and full ranking caller gate ([evidence](research/QVM_SCOREBOARD_BROADCAST.md)).
+
+
+- [x] RE-800 Rust scoreboard recipient policy and bounded ranking publication plan ([evidence](research/RUST_SCOREBOARD.md)).
+
+
+- [ ] RE-801 Continue legacy/shared-byte tracing audits, exit-rule7805 and scoreboard179363 effects/serialization, complete stat and runtime ownership integration, native sort variants and Linux/macOS Bevy/Solari validation. [Next tasks](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md#next-work--re-801).

docs/TESTING.md

@@ -113,3 +113,8 @@ Focused groups include `rank-comparator`, `rank-small-sort`, `ranking-complete`,
 Use `cargo xtask test-group resumer-audit`, `return-placement`, `reentry-witness` or `execute-reentry` for inventory and synthetic trace contracts. Source migrations use `notification-reentry`, `award-reentry`, `counter-reentry` and `movement-reentry`; sorting uses `rank-partition-helpers` and `rank-large-sort`. Each name is a separate argument after `test-group`. Groups follow downstream dependency closure, so shared constants/helpers can select additional source and Rust parity reports. The static inventory scanner has explicit edges from current non-test Python scripts; register newly added scan inputs. Unknown changes retain full-suite fallback.
 
 For ten-task batches, run focused validation before each commit, then `cargo xtask test-full --since <batch-base>` once after commit ten. Review all regenerated report diffs and record the outcome in the batch document before pushing. See [RE-780–789](research/QVM_RESUMER_PARTITION_BATCH.md).
+
+
+## Ranking composition groups
+
+Additional focused groups: `child-word-memory`, `ranking-large-caller`, `ranking-population`, `rust-rank-sort`, `rust-ranking-complete`, `rust-ranking-population`, `rust-ranking-mixed`, `stat-composition`, `scoreboard-broadcast` and `rust-scoreboard`. Invoke each as `cargo xtask test-group <name>`. Rust groups refresh scoped gameplay test-count metadata. New source-report paths assembled from strings have explicit registry edges to their parity producers; the registry regression verifies those selections. [Batch contracts and limits](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md).

docs/research/QVM_RUST_RANKING_PUBLICATION_BATCH.md

@@ -0,0 +1,41 @@
+# Ranking caller composition, Rust sorting and scoreboard dispatch
+
+RE-791–800; baseline `c6b4a1eb`. Ten task commits, focused `cargo xtask` validation before each, one full-suite run after commit ten. Original assets remain unchanged.
+
+| Task | Result | Evidence |
+| --- | --- | --- |
+| RE-791 | Explicit child word-to-byte synchronization in corrected resumers | [Child memory](QVM_CHILD_WORD_MEMORY.md) |
+| RE-792 | Complete5864 with actual sort through64 eligible clients | [Large caller](QVM_RANKING_LARGE_CALLER.md) |
+| RE-793 | Mixed population counters and positional rank-prefix behavior | [Population](QVM_RANKING_POPULATION.md) |
+| RE-794 | Rust source-shaped aligned sort, including exact unstable ties | [Rust sort](RUST_RANK_SORT.md) |
+| RE-795 | Rust complete eligible ranking composition | [Rust caller](RUST_RANKING_COMPLETE.md) |
+| RE-796 | Rust collection and all eight source count globals | [Rust population](RUST_RANKING_POPULATION.md) |
+| RE-797 | Rust mixed population sorting and rank-word composition | [Rust mixed caller](RUST_RANKING_MIXED.md) |
+| RE-798 | Actual team counters and ratio refreshes inside method updates | [Stat composition](QVM_STAT_COMPOSITION.md) |
+| RE-799 | Actual6328 broadcast and full ranking caller gate | [Broadcast](QVM_SCOREBOARD_BROADCAST.md) |
+| RE-800 | Rust recipient policy and bounded publication plan | [Rust scoreboard](RUST_SCOREBOARD.md) |
+
+## Findings
+
+The source sort's equal-key swaps are observable. Rust follows its insertion, pivot, median/ninther, partition, recursive and tail-loop paths, matching exact source permutations rather than substituting a stable host sort. The raw comparator is still not an Ord contract: connecting/deferred prefilters can be asymmetric. The mixed-population implementation executes the source-shaped algorithm without using Rust's sorting APIs.
+
+The source collects nonzero connection states, counts connected non-spectators separately from playing state2 records, and excludes bot-flagged records only from human/team-human totals. First-playing identifiers can name bots. Ordinary rank assignment writes a positional prefix of the sorted collected array; deferred fixtures demonstrate that this prefix can differ from the active-client set. Team modes assign every collected slot, including spectators/connecting clients. Inactive and other untouched rank words preserve caller state.
+
+Broadcast6328 filters only connection state2, so connected spectators receive requests even when playing count is zero. Full caller fixtures execute this dispatch after a captured7805 exit-rule call. Rust's publication plan has the same capture assumption: it does not implement7805 effects or179363 scoreboard formatting/sends. A runtime must apply exit-rule effects before reselecting recipients.
+
+Explicit child-word synchronization makes changed/new aligned words visible to subsequent byte loads while preserving unchanged parent byte overlays. It rejects unsupported/deleted words and requires corrected reentry. It does not unify every STORE1/LOAD4/child byte effect into a complete shared VM memory model. The asymmetric64-record source sort fixtures also require more than512 bounded segments; only that sort opts into4096, below the shared configurable cap8192. This allowance does not establish native runtime cost.
+
+## Validation and selection
+
+Each focused group regenerates its selected reports twice, runs affected tests and checks storage, documentation links and whitespace. Scoped gameplay tests accompany Rust changes. Explicit source-report edges cover the formatted paths used by the new parity producers; the xtask registry regression checks every mapping as well as module-to-parity and scoped-test-metadata selection.
+
+After exactly ten task commits, the single `cargo xtask test-full --since c6b4a1eb` run passed **1,562 Python tests and 102 Rust tests** (10 assets, 64 gameplay, 28 xtask). All 226 affected report producers regenerated twice byte-identically. Storage policy, links across 359 documentation files and whitespace guards passed. Regeneration left the working tree clean, with no additional report refreshes to review. Final validation notes are checked with documentation-only xtask selection and included by amending the tenth commit; the full suite is not repeated. Native executable, Linux/macOS gameplay and interactive Bevy/Solari acceptance remain open.
+
+## Next work — RE-801
+
+- Continue auditing the remaining156 default/literal legacy resumer expressions and three unresolved mode expressions.22 computed ranges still require manual review; inventory categories overlap and are not counts of proven bugs.
+- Implement an explicit child byte-write interface and unify supported byte/word reads and writes before claiming a complete shared VM model. Retain fail-closed handling for unsupported overlap, deletion or callback boundaries.
+- Recover7805 exit-rule effects and179363 scoreboard body, formatting limits, native send ABI and actual serialized messages. Validate state changes between ranking and broadcast.
+- Extend stat-update compositions through awards285227 and leaderboard283622; bound divisor costs and integrate the resulting state with runtime entity/client ownership.
+- Recover byte/unaligned sort variants and validate native ABI/error domains. Expand original/native trace comparison beyond the finite synthetic QVM fixtures.
+- Connect the pure Rust contracts to the game runtime; continue world collision, movement, combat, protocol, maps/models/materials/audio and rendering. Validate native macOS/Linux builds and interactive Bevy/Solari acceptance.

docs/research/README.md

@@ -987,3 +987,9 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-799: Actual scoreboard broadcast dispatch and full ranking caller gate](QVM_SCOREBOARD_BROADCAST.md).
+
+
+[RE-800: Rust scoreboard recipient policy and bounded ranking publication plan](RUST_SCOREBOARD.md).
+
+
+[RE-791–800 batch: Rust ranking and publication](QVM_RUST_RANKING_PUBLICATION_BATCH.md).

docs/research/RUST_SCOREBOARD.md

@@ -0,0 +1,9 @@
+# Rust scoreboard recipient policy and bounded ranking publication plan
+
+RE-800. Reproduce with `python3 scripts/analyze_rust_scoreboard.py`; focused validation: `cargo xtask test-group rust-scoreboard`. [Machine report](rust-scoreboard.json).
+
+The recipient policy filters only connection state2 in scan order and bounds safe slices at64. A pure ranking plan composes the recovered mixed-population ranking contract with this gate.21 standalone and48 full source fixtures check exact order, ranks, globals and recipients. Unit tests cover signed connection states,64/65 boundaries and spectator rank preservation.7805 exit-rule effects and179363 scoreboard body/native sends remain unimplemented; a live runtime must execute exit-rule effects before selecting fresh recipients.
+
+Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.
+
+Formatted input paths in all five new Rust parity producers are declared explicitly in the xtask registry. The registry regression verifies each source-report-to-producer/test mapping without full fallback.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_scoreboard.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from analyze_rust_ranking import words
+from rust_lifecycle_support import binary,result,invoke
+from qvm_notification_support import POOL
+from analyze_qvm import write_json
+
+def ids(p):return [(r['arguments']['8']-POOL)//880 for r in p['requests']]
+def main():
+    b=binary();p=Path('docs/research/qvm-scoreboard-broadcast.json');data=p.read_bytes();source=json.loads(data);rows=[];callers=[]
+    for s in source['probes']:rows.append({'states':s['states'],'source':ids(s),'rust':result(b,'scoreboard-recipients',[len(s['states']),*s['states']])})
+    for s in source['callers']:
+        a=s['input'];c=a['clients'];r=result(b,'rank-publish',[a['mode'],*a['team_scores'],a['blocked'],len(c),*[v for client in c for v in [*words(client),client.get('flags',0),77]]]);callers.append({'input':a,'source_order':s['order'],'source_ranks':s['ranks'],'source_globals':s['globals'],'source_recipients':[id for effect in s['broadcasts'] for id in ids(effect)],'rust':r})
+    bad=invoke(b,'scoreboard-recipients',[65],check=False);assert bad.returncode
+    write_json(Path('docs/research/rust-scoreboard.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'callers':callers,'rejections':[bad.returncode],'limits':'Rust6328 state2 recipient policy and captured-7805 ranking publication plan match21 standalone and48 full source callers. Negative raw count represented by empty slice. No native scoreboard body179363/text/send execution; real7805 effects must precede fresh recipient selection in a runtime.'})
+if __name__=='__main__':main()

scripts/test_rust_scoreboard.py

@@ -0,0 +1,14 @@
+import hashlib,json,unittest
+from pathlib import Path
+class RustScoreboardTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/rust-scoreboard.json').read_text())
+    def test_raw_source_and_independent_connection_policy(self):
+        self.assertEqual(len(self.r['probes']),21)
+        for p in self.r['probes']:self.assertEqual(p['rust']['recipients'],p['source']);self.assertEqual(p['source'],[j for j,state in enumerate(p['states']) if state==2])
+    def test_full_rank_plan_exact_source_outputs_and_gate(self):
+        self.assertEqual(len(self.r['callers']),48)
+        for p in self.r['callers']:
+            r=p['rust'];self.assertEqual(r['order'],p['source_order']);self.assertEqual(r['ranks'],p['source_ranks']);self.assertEqual(r['globals'],p['source_globals']);self.assertEqual(r['recipients'],p['source_recipients']);self.assertEqual(r['recipients'],[j for j,c in enumerate(p['input']['clients']) if c['468']==2] if p['input']['blocked'] else [])
+    def test_identity_and_count_rejection(self):self.assertEqual(hashlib.sha256(Path(self.r['source_report']).read_bytes()).hexdigest(),self.r['source_report_sha256']);self.assertTrue(all(self.r['rejections']))
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1862,3 +1862,30 @@ edge	docs/research/qvm-scoreboard-broadcast.json	scripts/test_qvm_scoreboard_bro
 group	scoreboard-broadcast	scripts/analyze_qvm_scoreboard_broadcast.py
 edge	scripts/analyze_qvm_scoreboard_broadcast.py	scripts/analyze_qvm_resumer_audit.py
 edge	scripts/qvm_scoreboard_broadcast_support.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_scoreboard.py
+edge	Cargo.lock	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/scoreboard.rs	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/ranking_population.rs	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/rank_sort.rs	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/ranking.rs	scripts/analyze_rust_scoreboard.py
+edge	crates/urt-gameplay/src/scoreboard.rs	scripts/analyze_rust_health_impulse.py
+edge	crates/urt-gameplay/src/ranking.rs	scripts/analyze_rust_ranking_population.py
+group	gameplay	scripts/analyze_rust_scoreboard.py
+group	rust-scoreboard	scripts/analyze_rust_health_impulse.py
+report	scripts/analyze_rust_scoreboard.py	docs/research/rust-scoreboard.json
+edge	docs/research/rust-scoreboard.json	scripts/test_rust_scoreboard.py
+group	rust-scoreboard	scripts/analyze_rust_scoreboard.py
+edge	scripts/analyze_rust_scoreboard.py	scripts/analyze_qvm_resumer_audit.py
+edge	docs/research/qvm-rank-small-sort.json	scripts/analyze_rust_rank_sort.py
+edge	docs/research/qvm-rank-large-sort.json	scripts/analyze_rust_rank_sort.py
+edge	docs/research/qvm-ranking-complete.json	scripts/analyze_rust_ranking_complete.py
+edge	docs/research/qvm-ranking-large-caller.json	scripts/analyze_rust_ranking_complete.py
+edge	docs/research/qvm-ranking-setup.json	scripts/analyze_rust_ranking_population.py
+edge	docs/research/qvm-ranking-large-caller.json	scripts/analyze_rust_ranking_population.py
+edge	docs/research/qvm-ranking-population.json	scripts/analyze_rust_ranking_population.py
+edge	docs/research/qvm-ranking-large-caller.json	scripts/analyze_rust_ranking_mixed.py
+edge	docs/research/qvm-ranking-population.json	scripts/analyze_rust_ranking_mixed.py
+edge	docs/research/qvm-scoreboard-broadcast.json	scripts/analyze_rust_scoreboard.py

xtask/src/lib.rs

@@ -1043,6 +1043,7 @@ mod integration_tests {
             ("ranking", "ranking"),
             ("rank_sort", "rank_sort"),
             ("ranking_population", "ranking_population"),
+            ("scoreboard", "scoreboard"),
             ("leaderboard", "leaderboard"),
             ("recipient_wire", "recipient_wire"),
         ] {
@@ -1072,6 +1073,41 @@ mod integration_tests {
                     .contains(&format!("scripts/test_rust_{producer}.py"))
             );
         }
+        // Formatted source-report paths are explicit registry inputs. Each
+        // must select its Rust parity report without full fallback.
+        for (source, target) in [
+            ("qvm-rank-small-sort", "rank_sort"),
+            ("qvm-rank-large-sort", "rank_sort"),
+            ("qvm-ranking-complete", "ranking_complete"),
+            ("qvm-ranking-large-caller", "ranking_complete"),
+            ("qvm-ranking-setup", "ranking_population"),
+            ("qvm-ranking-large-caller", "ranking_population"),
+            ("qvm-ranking-population", "ranking_population"),
+            ("qvm-ranking-large-caller", "ranking_mixed"),
+            ("qvm-ranking-population", "ranking_mixed"),
+            ("qvm-scoreboard-broadcast", "scoreboard"),
+        ] {
+            let selected = plan(
+                &g,
+                &[format!("docs/research/{source}.json")]
+                    .into_iter()
+                    .collect(),
+                false,
+                root,
+            )
+            .unwrap();
+            assert!(selected.fallback.is_empty());
+            assert!(
+                selected
+                    .producers
+                    .contains(&format!("scripts/analyze_rust_{target}.py"))
+            );
+            assert!(
+                selected
+                    .tests
+                    .contains(&format!("scripts/test_rust_{target}.py"))
+            );
+        }
         // Validate the entire registry DAG, including multi-output native/QVM writers.
         g.producers_in_order(&g.outputs.keys().cloned().collect())
             .unwrap();