gameplay: compose intermission state machine

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

@@ -11,7 +11,7 @@ fn run() -> Result<String, String> {
     }
     let n = w[14] as usize;
     let nr = w[15] as usize;
-    if n > 64 || nr > 64 || w.len() != 16 + 11 * n + nr {
+    if n > 64 || nr > 64 || w.len() != 16 + 15 * n + nr + if kind == "flow" { 9 } else { 0 } {
         return Err("invalid record count".into());
     }
     let mut state = State {
@@ -29,8 +29,8 @@ fn run() -> Result<String, String> {
         client_count: w[12] as usize,
         rank_count: w[13] as i32,
     };
-    let mut clients = w[16..16 + 11 * n]
-        .chunks_exact(11)
+    let mut clients = w[16..16 + 15 * n]
+        .chunks_exact(15)
         .map(|v| Client {
             connection: v[0] as i32,
             id: v[1] as i32,
@@ -43,9 +43,13 @@ fn run() -> Result<String, String> {
             ready: v[8] as i32,
             entity_flags: v[9],
             field4324: v[10] as i32,
+            field304: v[11] as i32,
+            field3692: v[12] as i32,
+            field3700: v[13] as i32,
+            packed: v[14],
         })
         .collect::<Vec<_>>();
-    let rank = w[16 + 11 * n..]
+    let rank = w[16 + 15 * n..16 + 15 * n + nr]
         .iter()
         .map(|v| *v as usize)
         .collect::<Vec<_>>();
@@ -107,6 +111,123 @@ fn run() -> Result<String, String> {
                 state.pending as u32
             ))
         }
+        "flow" => {
+            let v = &w[16 + 15 * n + nr..];
+            let timer = urt_gameplay::exit_rules::TimerState {
+                mode: state.mode,
+                now: state.now,
+                client_count: state.client_count,
+                round_limit: v[0] as i32,
+                round_active: v[1] != 0,
+                round_count: v[2] as i32,
+                countdown: v[3] as i32,
+                time_limit: v[4] as i32,
+                paused: v[5] != 0,
+                start: v[6] as i32,
+            };
+            let limits = urt_gameplay::exit_rules::LimitState {
+                mode: state.mode,
+                playing: state.playing,
+                max_clients: state.max_clients,
+                scores: state.scores,
+                score_limit: v[7] as i32,
+                team_limit: v[8] as i32,
+            };
+            let entities = (100..164).collect::<Vec<u32>>();
+            let r = advance_exit(&mut state, timer, limits, &mut clients, &rank, &entities)
+                .map_err(|e| format!("{e:?}"))?;
+            use urt_gameplay::exit_rules::{Decision, LimitHit};
+            let kind = match r.decision {
+                Decision::Blocked => "blocked",
+                Decision::Wait => "wait",
+                Decision::Transition => "transition",
+                Decision::Class(_) => "class",
+                Decision::Predicate => "predicate",
+                Decision::Round => "round",
+                Decision::Time => "time",
+                Decision::None => "none",
+                Decision::Limit(h) => match h {
+                    LimitHit::LowFirst => "low_first",
+                    LimitHit::LowSecond => "low_second",
+                    LimitHit::HighFirst => "high_first",
+                    LimitHit::HighSecond => "high_second",
+                    LimitHit::Client(_) => "client",
+                },
+            };
+            let ready = r
+                .readiness
+                .map(|v| v.exit.to_string())
+                .unwrap_or("null".into());
+            let begin = r
+                .begin
+                .iter()
+                .map(|e| match e {
+                    BeginEffect::Prepare => "[6717,-1]".into(),
+                    BeginEffect::SlowCvar => "[-6,-1]".into(),
+                    BeginEffect::SlowSetup => "[156523,-1]".into(),
+                    BeginEffect::Respawn(j) => format!("[175123,{j}]"),
+                    BeginEffect::Move(j) => format!("[6575,{j}]"),
+                    BeginEffect::Publish => "[6328,-1]".into(),
+                })
+                .collect::<Vec<String>>()
+                .join(",");
+            let log = r
+                .log
+                .map(|v| {
+                    let team = v
+                        .team_scores
+                        .map(|v| format!("[{},{}]", v[0], v[1]))
+                        .unwrap_or("null".into());
+                    let rows = v
+                        .rows
+                        .iter()
+                        .map(|v| format!("[{},{},{}]", v.score, v.ping, v.client))
+                        .collect::<Vec<_>>()
+                        .join(",");
+                    format!("{{\"team_scores\":{team},\"rows\":[{rows}]}}")
+                })
+                .unwrap_or("null".into());
+            let c = clients
+                .iter()
+                .map(|c| {
+                    format!(
+                        "[{}, {}, {}, {}, {}, {}, {}]",
+                        c.id as u32,
+                        c.field4324 as u32,
+                        c.field304 as u32,
+                        c.field308 as u32,
+                        c.field3692 as u32,
+                        c.field3700 as u32,
+                        c.packed
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(",");
+            let resets = r
+                .resets
+                .iter()
+                .map(|v| {
+                    format!(
+                        "[{}, {}, {}, {}, {}, {}, {}]",
+                        v.client,
+                        v.entity,
+                        v.owner,
+                        v.time as u32,
+                        v.kind,
+                        v.flags_or,
+                        v.logged_value
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(",");
+            Ok(format!(
+                "{{\"kind\":\"{kind}\",\"state\":[{},{},{},{}],\"clients\":[{c}],\"ready_exit\":{ready},\"begin\":[{begin}],\"log\":{log},\"resets\":[{resets}]}}",
+                state.blocked as u32,
+                state.pending as u32,
+                state.waiting as u32,
+                state.wait_start as u32
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }

crates/urt-gameplay/src/intermission.rs

@@ -12,6 +12,10 @@ pub struct Client {
     pub ready: i32,
     pub entity_flags: u32,
     pub field4324: i32,
+    pub field304: i32,
+    pub field3692: i32,
+    pub field3700: i32,
+    pub packed: u32,
 }
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct State {
@@ -33,6 +37,8 @@ pub struct State {
 pub enum Error {
     InvalidCount,
     InvalidRank,
+    InvalidState,
+    InvalidPolicy,
 }
 fn count(clients: &[Client], n: usize) -> Result<(), Error> {
     if clients.len() > 64 || n > clients.len() {
@@ -373,3 +379,179 @@ mod log_tests {
         assert_eq!(s, old);
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Flow {
+    pub decision: crate::exit_rules::Decision,
+    pub readiness: Option<Readiness>,
+    pub begin: Vec<BeginEffect>,
+    pub log: Option<ExitLog>,
+    pub resets: Vec<crate::exit_rules::Reset>,
+}
+/// Atomic safe composition of the recovered exit body and intermission children.
+/// World transitions, camera/respawn work, allocation, publication and I/O remain intentions.
+pub fn advance_exit(
+    state: &mut State,
+    timer: crate::exit_rules::TimerState,
+    limits: crate::exit_rules::LimitState,
+    clients: &mut [Client],
+    rank: &[usize],
+    entity_ids: &[u32],
+) -> Result<Flow, Error> {
+    if timer.mode != state.mode
+        || timer.now != state.now
+        || timer.client_count != state.client_count
+        || limits.mode != state.mode
+        || limits.playing != state.playing
+        || limits.max_clients != state.max_clients
+        || limits.scores != state.scores
+    {
+        return Err(Error::InvalidState);
+    }
+    let mut staged = state.clone();
+    let mut c = clients.to_vec();
+    let mut raw = c
+        .iter()
+        .map(|c| crate::exit_rules::Client {
+            connection: c.connection,
+            team: c.team,
+            class: c.class,
+            id: c.id,
+            score: c.score,
+            field304: c.field304,
+            field308: c.field308,
+            packed: c.packed,
+            field3692: c.field3692,
+            field3700: c.field3700,
+        })
+        .collect::<Vec<_>>();
+    let mut pending = staged.pending;
+    let prefix = crate::exit_prefix::advance(
+        staged.blocked != 0,
+        &mut pending,
+        staged.slow != 0,
+        staged.now,
+    );
+    let predicate = if prefix == crate::exit_prefix::Action::ContinueModeRules
+        && crate::exit_rules::class_guard(staged.mode, &raw, staged.max_clients)
+            .map_err(|_| Error::InvalidPolicy)?
+            .is_none()
+    {
+        tied(&staged, &c, rank)?
+    } else {
+        false
+    };
+    let mut rule = crate::exit_rules::State {
+        blocked: staged.blocked != 0,
+        pending: staged.pending,
+        slow: staged.slow != 0,
+        predicate,
+        timer,
+        limits,
+    };
+    let out = crate::exit_rules::advance(&mut rule, &mut raw, entity_ids)
+        .map_err(|_| Error::InvalidPolicy)?;
+    staged.pending = rule.pending;
+    for (c, r) in c.iter_mut().zip(raw) {
+        c.field304 = r.field304;
+        c.field308 = r.field308;
+        c.packed = r.packed;
+        c.field3692 = r.field3692;
+        c.field3700 = r.field3700;
+    }
+    let mut flow = Flow {
+        decision: out.decision,
+        readiness: None,
+        begin: vec![],
+        log: None,
+        resets: out.resets,
+    };
+    use crate::exit_rules::Decision;
+    match flow.decision {
+        Decision::Blocked => flow.readiness = Some(readiness(&mut staged, &c)?),
+        Decision::Transition => flow.begin = begin(&mut staged, &mut c)?,
+        Decision::Class(_) | Decision::Round | Decision::Time | Decision::Limit(_) => {
+            flow.log = Some(log_exit(&mut staged, &c, rank)?)
+        }
+        _ => {}
+    }
+    *state = staged;
+    clients.copy_from_slice(&c);
+    Ok(flow)
+}
+#[cfg(test)]
+mod flow_tests {
+    use super::*;
+    fn timer(s: &State) -> crate::exit_rules::TimerState {
+        crate::exit_rules::TimerState {
+            mode: s.mode,
+            now: s.now,
+            client_count: s.client_count,
+            ..Default::default()
+        }
+    }
+    fn limits(s: &State) -> crate::exit_rules::LimitState {
+        crate::exit_rules::LimitState {
+            mode: s.mode,
+            playing: s.playing,
+            max_clients: s.max_clients,
+            scores: s.scores,
+            score_limit: 1,
+            team_limit: 1,
+        }
+    }
+    #[test]
+    fn tied_blocks_limit_and_log_updates_pending() {
+        let mut s = State {
+            now: 60000,
+            playing: 2,
+            enabled: 1,
+            max_clients: 2,
+            client_count: 2,
+            rank_count: 2,
+            scores: [2, 2],
+            ..State::default()
+        };
+        let mut c = [Client {
+            connection: 2,
+            score: 3,
+            ..Client::default()
+        }; 2];
+        let t = timer(&s);
+        let l = limits(&s);
+        let r = advance_exit(&mut s, t, l, &mut c, &[0, 1], &[100, 101]).unwrap();
+        assert_eq!(r.decision, crate::exit_rules::Decision::Predicate);
+        s.enabled = 0;
+        let t = timer(&s);
+        let l = limits(&s);
+        let r = advance_exit(&mut s, t, l, &mut c, &[0, 1], &[100, 101]).unwrap();
+        assert!(r.log.is_some());
+        assert_eq!(s.pending, 59950);
+    }
+    #[test]
+    fn invalid_composition_is_atomic() {
+        let mut s = State {
+            now: 60000,
+            playing: 2,
+            max_clients: 1,
+            client_count: 1,
+            rank_count: 1,
+            scores: [2, 0],
+            ..State::default()
+        };
+        let mut c = [Client {
+            connection: 2,
+            ..Client::default()
+        }];
+        let old = s.clone();
+        let before = c;
+        let t = timer(&s);
+        let l = limits(&s);
+        assert_eq!(
+            advance_exit(&mut s, t, l, &mut c, &[99], &[100]),
+            Err(Error::InvalidRank)
+        );
+        assert_eq!(s, old);
+        assert_eq!(c, before);
+    }
+}

docs/FINDINGS.md

@@ -1526,3 +1526,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-842:** 150 continuous 7805 fixtures now execute actual tie, readiness, begin-transition and exit-log children on shared world memory with separate child frames. Independent policy and nested ABI checks cover conflicting gates, client mutations and publication intentions. Lower-level next-map/respawn/camera/I/O and allocation still remain captured. [Evidence](research/QVM_INTERMISSION_FLOW.md).
+
+
+**RE-843:** Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity. [Evidence](research/RUST_INTERMISSION_FLOW.md).

docs/PROVISIONAL_TODO.md

@@ -1514,7 +1514,7 @@ RE-832: Complete7805 execution now composes prefix, class, supplied predicate, r
 RE-833: Rust now composes the full recovered7805 priority and matches438 continuous source cases, including pending clears and mode9 reset/event intentions. Full runtime completion remains open. [Evidence](research/RUST_EXIT_COMPLETE.md).
 
 
-- [ ] RE-834: Recover supplied exit predicate/transition/native effects, compose ranking→exit→scoreboard state, and validate actual runtime traces and macOS/Linux rendering. [Batch scope](research/QVM_FLOAT_EXIT_RULES_BATCH.md).
+- [x] RE-834–843: Recover exit predicate and intermission child policies; remaining native/runtime scope is tracked under RE-844. [Batch evidence](research/QVM_INTERMISSION_BATCH.md).
 
 
 RE-834: Actual 7662 and child 33715 execute across 168 cases. Playing count and the enabled global gate ties; team-classified modes compare global scores, mode9 uses ranked field308, mode11 field696, and other modes field248. Raw numeric names remain conservative; ranked pointer legality and native execution remain open. Full runtime completion remains open. [Evidence](research/QVM_EXIT_PREDICATE.md).
@@ -1542,3 +1542,9 @@ RE-841: Rust matches 83 original exit-log cases with signed ping clamp, negative
 
 
 RE-842: 150 continuous 7805 fixtures now execute actual tie, readiness, begin-transition and exit-log children on shared world memory with separate child frames. Independent policy and nested ABI checks cover conflicting gates, client mutations and publication intentions. Lower-level next-map/respawn/camera/I/O and allocation still remain captured. Full runtime completion remains open. [Evidence](research/QVM_INTERMISSION_FLOW.md).
+
+
+RE-843: Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity. Full runtime completion remains open. [Evidence](research/RUST_INTERMISSION_FLOW.md).
+
+
+- [ ] RE-844: Recover next-map/respawn/camera/publication/event allocation effects, broaden pointer/identity fixtures, and integrate ranking→intermission→scoreboard runtime traces. [Scope](research/QVM_INTERMISSION_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -1884,3 +1884,12 @@ Rust matches 83 original exit-log cases with signed ping clamp, negative/zero/ov
 ## 2026-10-27 — RE-842 Original exit flow composed with recovered intermission children
 
 150 continuous 7805 fixtures now execute actual tie, readiness, begin-transition and exit-log children on shared world memory with separate child frames. Independent policy and nested ABI checks cover conflicting gates, client mutations and publication intentions. Lower-level next-map/respawn/camera/I/O and allocation still remain captured. Focused `cargo xtask test-group intermission-flow` passes (5 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-27 — RE-843 Rust composed exit and intermission state machine
+
+Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity. Focused `cargo xtask test-group rust-intermission-flow` passes (9 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-843 final review: targeted xtask registry regression passes for the intermission module and all five source-to-Rust report dependencies. Added batch evidence, validation cadence and RE-844 lower-level/runtime follow-ups.
+
+Batch RE-834–843 boundary: the single `cargo xtask test-full --since 5f7b2df8` run passed after task ten: 1,648 Python tests, 137 Rust tests (assets 10, gameplay 99, xtask 28), 45 deterministic report producers, storage policy, 403 documentation files and whitespace checks. No generated report drift; validation notes amended into task ten. Original assets unchanged.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1551,7 +1551,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-833 Rust complete recovered exit-rule decision and mutation composition ([evidence](research/RUST_EXIT_COMPLETE.md)).
 
 
-- [ ] RE-834: Recover supplied exit predicate/transition/native effects, compose ranking→exit→scoreboard state, and validate actual runtime traces and macOS/Linux rendering. [Batch scope](research/QVM_FLOAT_EXIT_RULES_BATCH.md).
+- [x] RE-834–843: Recover exit predicate and intermission child policies; remaining native/runtime scope is tracked under RE-844. [Batch evidence](research/QVM_INTERMISSION_BATCH.md).
 
 
 - [x] RE-834 Original exit tie predicate and mode classifier ([evidence](research/QVM_EXIT_PREDICATE.md)).
@@ -1579,3 +1579,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-842 Original exit flow composed with recovered intermission children ([evidence](research/QVM_INTERMISSION_FLOW.md)).
+
+
+- [x] RE-843 Rust composed exit and intermission state machine ([evidence](research/RUST_INTERMISSION_FLOW.md)).
+
+
+- [ ] RE-844: Recover next-map/respawn/camera/publication/event allocation effects, broaden pointer/identity fixtures, and integrate ranking→intermission→scoreboard runtime traces. [Scope](research/QVM_INTERMISSION_BATCH.md).

docs/TESTING.md

@@ -133,3 +133,8 @@ Use `cargo xtask test-group <name>` with `format-string`, `format-integer`, `for
 ## Float formatter and complete exit-rule groups
 
 Use `cargo xtask test-group <name>` with `format-float`, `rust-format-float`, `exit-class`, `rust-exit-class`, `exit-limits`, `rust-exit-limits`, `exit-timers`, `rust-exit-timers`, `exit-complete` or `rust-exit-complete`. The registry regression verifies each source-report dependency selects its Rust adapter and test. Scoped gameplay checks refresh test-count metadata. Keep focused validation before each commit and one full run after ten commits. See the [batch evidence and remaining effects](research/QVM_FLOAT_EXIT_RULES_BATCH.md).
+
+
+## Exit predicate and intermission groups
+
+Focused source/Rust pairs: `exit-predicate`/`rust-exit-predicate`, `intermission-ready`/`rust-intermission-ready`, `intermission-begin`/`rust-intermission-begin`, `exit-log`/`rust-exit-log`, and `intermission-flow`/`rust-intermission-flow`. Run `cargo xtask test-group <name>` before the task commit. The scoped intermission executable has its own adapter inputs; common module changes select every intermission consumer and scoped gameplay test-count metadata. The registry regression verifies source-report edges and module selection. Run one `test-full --since <batch-base>` after ten commits. See the [batch contracts and boundaries](research/QVM_INTERMISSION_BATCH.md).

docs/research/QVM_INTERMISSION_BATCH.md

@@ -0,0 +1,44 @@
+# Exit predicate and intermission composition: RE-834–843
+
+This batch replaces four supplied children of the recovered exit body with original QVM instruction execution and matching Rust policies. It advances the bounded lifecycle model; it does not establish a running game or native runtime parity.
+
+| Task | Original evidence or Rust port |
+| --- | --- |
+| RE-834 | [7662 tie predicate and 33715 classifier](QVM_EXIT_PREDICATE.md) |
+| RE-835 | [Rust ranked tie predicate](RUST_EXIT_PREDICATE.md) |
+| RE-836 | [7525 readiness and timeout](QVM_INTERMISSION_READY.md) |
+| RE-837 | [Rust readiness policy](RUST_INTERMISSION_READY.md) |
+| RE-838 | [6825 begin-intermission state](QVM_INTERMISSION_BEGIN.md) |
+| RE-839 | [Rust begin state and intentions](RUST_INTERMISSION_BEGIN.md) |
+| RE-840 | [7367 exit logging and publication](QVM_EXIT_LOG.md) |
+| RE-841 | [Rust exit log projection](RUST_EXIT_LOG.md) |
+| RE-842 | [Continuous exit body with recovered children](QVM_INTERMISSION_FLOW.md) |
+| RE-843 | [Rust composed exit/intermission API](RUST_INTERMISSION_FLOW.md) |
+
+## Findings
+
+The tie predicate uses signed mode classification: modes below 3 and modes 9/11 are not team-classified. It requires at least two playing clients and nonzero enabled state. Team-classified modes compare global scores; mode 9 compares ranked field 308, mode 11 field 696, and other modes field 248. There are 168 source fixtures.
+
+Readiness scans configured slots, excludes disconnected clients and entity flag 8, counts nonzero ready fields and computes a first 16-slot mask. It uses signed comparisons against wrapped timestamp additions: blocked + 5000, then wait_start + 10000. An empty eligible set passes the all-ready test. The mask/counts are local values; this body does not publish them. There are 131 source fixtures.
+
+Begin-intermission uses the raw blocked timestamp as a once-only guard. It stores the current clock, optionally sets ui_singlePlayerActive to 0 and requests additional setup, then visits connected collected clients. Mismatched IDs become field 6156; entity-client field 4324 clears before respawn/move intentions. Publication follows the loop. Zero current time leaves the raw guard zero. There are 39 source fixtures.
+
+Exit logging writes pending=now−50, requests publication and configstring 22 before optional team scores and ranked rows. It caps the rank count at 32, excludes team 3 and non-state 2 records, and applies min(ping,999), preserving negative ping. The original strings identify Exit, red/blue scores, and score/ping/client/name rows. There are 83 source fixtures.
+
+The final 150 source fixtures execute 7805 with actual 7662/33715,7525,6825 and7367, using isolated child frames and shared world memory. Independent tests check priority, exact nested request ABI/order and final world/client mutations. Rust composes these policies with the existing exit timers/limits, stages mutations atomically, and returns typed effect intentions.
+
+## Validation and dependency selection
+
+Each task used a focused cargo xtask group before its own commit. Source and Rust reports regenerated twice; relevant Python tests and scoped gameplay Rust tests passed. Registry regression covers the intermission module and all five source-report-to-Rust dependencies. The single full-suite run after commit ten, `cargo xtask test-full --since 5f7b2df8`, passed: 1,648 Python tests and 137 Rust tests (assets 10, gameplay 99, xtask 28). All 45 affected report producers regenerated twice deterministically. Storage policy, links across 403 documentation files and whitespace checks passed. There was no generated report drift. Validation notes were amended into the tenth commit.
+
+Focused group names: `exit-predicate`, `rust-exit-predicate`, `intermission-ready`, `rust-intermission-ready`, `intermission-begin`, `rust-intermission-begin`, `exit-log`, `rust-exit-log`, `intermission-flow`, `rust-intermission-flow`. Use `cargo xtask test-group <name>`.
+
+## Remaining boundaries and RE-844
+
+- [ ] Recover 6939 next-map selection and command effects; readiness currently returns an exit intention.
+- [ ] Recover 6717/156523/175123/6575 preparation, respawn and camera effects.
+- [ ] Execute 6328 publication and lower-level logging/configstring/network work with verified formatting and state ownership.
+- [ ] Recover 277695 event construction and allocation, including constructor flag ownership.
+- [ ] Add pointer-alias and entity-client indirection fixtures. Current finite layouts seed entity-to-client pointers and readiness entity identities explicitly; typed Rust inputs require resolved entity flags and safe ranks/counts.
+- [ ] Integrate ranking→exit/intermission→scoreboard publication into the runtime and compare actual game/native traces.
+- [ ] Continue legacy trace audits and validate macOS/Linux Bevy/Solari gameplay and rendering. Neither platform runtime acceptance nor full-game completion is established by these policies.

docs/research/README.md

@@ -1118,3 +1118,8 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-842: Original exit flow composed with recovered intermission children](QVM_INTERMISSION_FLOW.md).
+
+
+[RE-843: Rust composed exit and intermission state machine](RUST_INTERMISSION_FLOW.md).
+
+- [RE-834–843 intermission batch findings, validation and follow-up scope](QVM_INTERMISSION_BATCH.md).

docs/research/RUST_INTERMISSION_FLOW.md

@@ -0,0 +1,7 @@
+# Rust composed exit and intermission state machine
+
+RE-843. Reproduce with `python3 scripts/analyze_rust_intermission_flow.py`; focused validation: `cargo xtask test-group rust-intermission-flow`. [Machine report](rust-intermission-flow.json).
+
+Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity.
+
+Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_intermission_flow.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_intermission_support import binary,encode,result
+from analyze_qvm import write_json
+from test_qvm_intermission_flow import expected
+from test_qvm_exit_complete import signed
+from qvm_notification_support import POOL
+
+def project(s):
+ kind,_,_,_=expected(s);children=s['children'];ready=next((bool(c['report']['requests']) for c in children if c['target']==7525),None);begin=[];log=None
+ for c in children:
+  if c['target']==6825:begin=[[r['target'],(r['arguments']['8']-POOL)//880 if r['target'] in [175123,6575] else -1] for r in c['report']['requests']]
+  if c['target']==7367:
+   req=c['report']['requests'];team=next(([signed(v['arguments']['12']),signed(v['arguments']['16'])] for v in req if v['target']==7259 and v['arguments']['8']==34691),None);rows=[[signed(v['arguments']['12']),signed(v['arguments']['16']),v['arguments']['20']] for v in req if v['target']==7259 and v['arguments']['8']==34655];log={'team_scores':team,'rows':rows}
+ req=s['requests'];resets=[]
+ for call,event,r in zip([v for v in req if v['target']==277695],s['events'],[v for v in req if v['target']==7259]):
+  entity=(call['arguments']['8']-POOL-24)//880;slot=next(j for j,c in enumerate(s['clients_before']) if c['140']==entity);resets.append([slot,entity,event['fields']['140'],event['fields']['84'],69,event['fields']['424']&256,signed(r['arguments']['16'])])
+ return {'kind':kind,'state':[s['state_after'][k] for k in ['blocked','pending','waiting','wait_start']],'clients':[[c[str(o)] for o in [140,4324,304,308,3692,3700,300]] for c in s['clients_after']],'ready_exit':ready,'begin':begin,'log':log,'resets':resets}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-intermission-flow.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'flow',encode(s['input'],s['clients'])+[s['input'].get(k,0) for k in ['round_limit','round_active','round_count','countdown','time_limit','paused','start','score_limit','team_limit']])})
+ write_json(Path('docs/research/rust-intermission-flow.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity.'})
+if __name__=='__main__':main()

scripts/rust_intermission_support.py

@@ -2,7 +2,7 @@
 import os,subprocess
 from pathlib import Path
 from rust_lifecycle_support import result
-FIELDS=[468,140,6156,248,452,3096,696,308,4036,'entity_flags',4324]
+FIELDS=[468,140,6156,248,452,3096,696,308,4036,'entity_flags',4324,304,3692,3700,300]
 def binary():
     subprocess.run(['cargo','build','--offline','--package','urt-gameplay','--bin','urt-intermission'],capture_output=True,text=True,check=True)
     return Path(os.environ.get('CARGO_TARGET_DIR','target'))/'debug'/'urt-intermission'

scripts/test_rust_intermission_flow.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class ParityTests(unittest.TestCase):
+ def test_source_cases_and_length(self):
+  r=json.loads(Path('docs/research/rust-intermission-flow.json').read_text());source=json.loads(Path(r['source_report']).read_text());self.assertEqual(len(r['probes']),len(source['probes']));self.assertGreater(len(r['probes']),20)
+  for p in r['probes']:self.assertEqual(p['source'],p['rust'])
+ def test_source_identity(self):
+  r=json.loads(Path('docs/research/rust-intermission-flow.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

@@ -2229,3 +2229,18 @@ report	scripts/analyze_qvm_intermission_flow.py	docs/research/qvm-intermission-f
 edge	docs/research/qvm-intermission-flow.json	scripts/test_qvm_intermission_flow.py
 group	intermission-flow	scripts/analyze_qvm_intermission_flow.py
 edge	scripts/analyze_qvm_intermission_flow.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_intermission_flow.py
+edge	Cargo.lock	scripts/analyze_rust_intermission_flow.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_intermission_flow.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_intermission_flow.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_intermission_flow.py
+edge	crates/urt-gameplay/src/bin/urt-intermission.rs	scripts/analyze_rust_intermission_flow.py
+edge	docs/research/qvm-intermission-flow.json	scripts/analyze_rust_intermission_flow.py
+group	rust-intermission-flow	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_intermission_flow.py
+edge	crates/urt-gameplay/src/exit_prefix.rs	scripts/analyze_rust_intermission_flow.py
+edge	crates/urt-gameplay/src/exit_rules.rs	scripts/analyze_rust_intermission_flow.py
+report	scripts/analyze_rust_intermission_flow.py	docs/research/rust-intermission-flow.json
+edge	docs/research/rust-intermission-flow.json	scripts/test_rust_intermission_flow.py
+group	rust-intermission-flow	scripts/analyze_rust_intermission_flow.py
+edge	scripts/analyze_rust_intermission_flow.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1048,6 +1048,7 @@ mod integration_tests {
             ("qvm_format", "qvm_format"),
             ("exit_prefix", "exit_prefix"),
             ("exit_rules", "exit_class"),
+            ("intermission", "intermission_flow"),
             ("leaderboard", "leaderboard"),
             ("recipient_wire", "recipient_wire"),
         ] {
@@ -1103,6 +1104,11 @@ mod integration_tests {
             ("qvm-exit-limits", "exit_limits"),
             ("qvm-exit-timers", "exit_timers"),
             ("qvm-exit-complete", "exit_complete"),
+            ("qvm-exit-predicate", "exit_predicate"),
+            ("qvm-intermission-ready", "intermission_ready"),
+            ("qvm-intermission-begin", "intermission_begin"),
+            ("qvm-exit-log", "exit_log"),
+            ("qvm-intermission-flow", "intermission_flow"),
         ] {
             let selected = plan(
                 &g,