gameplay: compose recovered exit rules

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

@@ -426,6 +426,77 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "exit-complete" if w.len() >= 22 && w[20] <= 64 && w[21] <= 64 => {
+            use urt_gameplay::exit_rules::{
+                Decision, LimitHit, LimitState, State, TimerState, advance,
+            };
+            let n = w[20] as usize;
+            let e = w[21] as usize;
+            if w.len() != 22 + 10 * n + e {
+                return Err("invalid complete exit clients".into());
+            }
+            let mut clients: Vec<_> = w[22..22 + 10 * n]
+                .chunks_exact(10)
+                .map(exit_client)
+                .collect();
+            let mut s = State {
+                blocked: w[0] != 0,
+                pending: w[1] as i32,
+                slow: w[2] != 0,
+                predicate: w[19] != 0,
+                timer: TimerState {
+                    now: w[3] as i32,
+                    mode: w[4] as i32,
+                    client_count: w[6] as usize,
+                    round_limit: w[7] as i32,
+                    round_active: w[8] != 0,
+                    round_count: w[9] as i32,
+                    countdown: w[10] as i32,
+                    time_limit: w[11] as i32,
+                    paused: w[12] != 0,
+                    start: w[13] as i32,
+                },
+                limits: LimitState {
+                    mode: w[4] as i32,
+                    max_clients: w[5] as usize,
+                    playing: w[14] as i32,
+                    score_limit: w[15] as i32,
+                    team_limit: w[16] as i32,
+                    scores: [w[17] as i32, w[18] as i32],
+                },
+            };
+            let p = advance(&mut s, &mut clients, &w[22 + 10 * n..])
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            let (kind, id) = match p.decision {
+                Decision::Blocked => ("blocked", -1),
+                Decision::Wait => ("wait", -1),
+                Decision::Transition => ("transition", -1),
+                Decision::Class(id) => ("class", id as i32),
+                Decision::Predicate => ("predicate", -1),
+                Decision::Round => ("round", -1),
+                Decision::Time => ("time", -1),
+                Decision::None => ("none", -1),
+                Decision::Limit(hit) => match hit {
+                    LimitHit::LowFirst => ("low_first", -1),
+                    LimitHit::LowSecond => ("low_second", -1),
+                    LimitHit::HighFirst => ("high_first", -1),
+                    LimitHit::HighSecond => ("high_second", -1),
+                    LimitHit::Client(id) => ("client", id as i32),
+                },
+            };
+            println!(
+                "{{\"kind\":\"{}\",\"client\":{},\"pending\":{},\"clients\":[{}],\"resets\":[{}]}}",
+                kind,
+                id,
+                s.pending as u32,
+                clients
+                    .iter()
+                    .map(exit_client_json)
+                    .collect::<Vec<_>>()
+                    .join(","),
+                exit_resets_json(&p.resets)
+            );
+        }
         "exit-timer" if w.len() >= 12 && w[10] <= 64 && w[11] <= 64 => {
             use urt_gameplay::exit_rules::{TimerHit, TimerState, apply_timer};
             let n = w[10] as usize;

crates/urt-gameplay/src/exit_rules.rs

@@ -16,6 +16,7 @@ pub struct Client {
 pub enum Error {
     InvalidScan,
     InvalidEntity,
+    InvalidState,
 }
 fn scan(clients: &[Client], count: usize) -> Result<&[Client], Error> {
     if clients.len() > 64 || count > clients.len() {
@@ -184,9 +185,162 @@ pub fn apply_timer(
     }
     Ok(TimerOutcome { hit, resets })
 }
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct State {
+    pub blocked: bool,
+    pub pending: i32,
+    pub slow: bool,
+    pub predicate: bool,
+    pub timer: TimerState,
+    pub limits: LimitState,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Decision {
+    Blocked,
+    Wait,
+    Transition,
+    Class(usize),
+    Predicate,
+    Round,
+    Time,
+    Limit(LimitHit),
+    None,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Outcome {
+    pub decision: Decision,
+    pub resets: Vec<Reset>,
+}
+/// Complete recovered7805 policy order; supplied predicate and effect intents
+/// deliberately do not implement native transitions, allocation or messages.
+pub fn advance(
+    state: &mut State,
+    clients: &mut [Client],
+    entity_ids: &[u32],
+) -> Result<Outcome, Error> {
+    if state.timer.mode != state.limits.mode {
+        return Err(Error::InvalidState);
+    }
+    scan(clients, state.limits.max_clients)?;
+    scan(clients, state.timer.client_count)?;
+    let simple = |decision| Outcome {
+        decision,
+        resets: vec![],
+    };
+    use crate::exit_prefix::Action;
+    match crate::exit_prefix::advance(
+        state.blocked,
+        &mut state.pending,
+        state.slow,
+        state.timer.now,
+    ) {
+        Action::Blocked => return Ok(simple(Decision::Blocked)),
+        Action::Wait => return Ok(simple(Decision::Wait)),
+        Action::StartTransition => return Ok(simple(Decision::Transition)),
+        Action::ContinueModeRules => {}
+    }
+    if let Some(id) = class_guard(state.timer.mode, clients, state.limits.max_clients)? {
+        return Ok(simple(Decision::Class(id)));
+    }
+    if state.predicate {
+        return Ok(simple(Decision::Predicate));
+    }
+    let timed = apply_timer(state.timer, clients, entity_ids)?;
+    if let Some(hit) = timed.hit {
+        return Ok(Outcome {
+            decision: if hit == TimerHit::Round {
+                Decision::Round
+            } else {
+                Decision::Time
+            },
+            resets: timed.resets,
+        });
+    }
+    Ok(simple(
+        limit(state.limits, clients)?.map_or(Decision::None, Decision::Limit),
+    ))
+}
 #[cfg(test)]
 mod tests {
     use super::*;
+    fn state() -> State {
+        State {
+            blocked: false,
+            pending: 0,
+            slow: false,
+            predicate: false,
+            timer: TimerState {
+                mode: 11,
+                time_limit: 1,
+                now: 60000,
+                client_count: 1,
+                ..TimerState::default()
+            },
+            limits: LimitState {
+                mode: 11,
+                playing: 2,
+                score_limit: 10,
+                team_limit: 10,
+                scores: [20, 20],
+                max_clients: 1,
+            },
+        }
+    }
+    #[test]
+    fn complete_order_preserves_earlier_decision_priority() {
+        let mut c = [Client {
+            connection: 2,
+            class: 21,
+            ..Client::default()
+        }];
+        let mut s = state();
+        s.blocked = true;
+        s.pending = 59000;
+        s.predicate = true;
+        assert_eq!(
+            advance(&mut s, &mut c, &[100]).unwrap().decision,
+            Decision::Blocked
+        );
+        assert_eq!(s.pending, 59000);
+        s.blocked = false;
+        assert_eq!(
+            advance(&mut s, &mut c, &[100]).unwrap().decision,
+            Decision::Transition
+        );
+        assert_eq!(s.pending, 0);
+        assert_eq!(
+            advance(&mut s, &mut c, &[100]).unwrap().decision,
+            Decision::Class(0)
+        );
+        c[0].class = 0;
+        assert_eq!(
+            advance(&mut s, &mut c, &[100]).unwrap().decision,
+            Decision::Predicate
+        );
+        s.predicate = false;
+        assert_eq!(
+            advance(&mut s, &mut c, &[100]).unwrap().decision,
+            Decision::Time
+        );
+        s.timer.time_limit = 0;
+        assert_eq!(
+            advance(&mut s, &mut c, &[100]).unwrap().decision,
+            Decision::Limit(LimitHit::HighFirst)
+        );
+    }
+    #[test]
+    fn inconsistent_mode_state_rejects_before_mutation() {
+        let mut s = state();
+        s.pending = 59000;
+        s.limits.mode = 9;
+        let before = s;
+        let mut clients = [Client::default()];
+        assert_eq!(
+            advance(&mut s, &mut clients, &[100]),
+            Err(Error::InvalidState)
+        );
+        assert_eq!(s, before);
+    }
     #[test]
     fn round_gate_bypasses_time_even_when_not_winning() {
         let s = TimerState {

docs/FINDINGS.md

@@ -1496,3 +1496,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-832:** Complete7805 execution now composes prefix, class, supplied predicate, round/time and limit policies with shared mutations across438 finite fixtures. [Evidence](research/QVM_EXIT_COMPLETE.md).
+
+
+**RE-833:** Rust now composes the full recovered7805 priority and matches438 continuous source cases, including pending clears and mode9 reset/event intentions. [Evidence](research/RUST_EXIT_COMPLETE.md).

docs/PROVISIONAL_TODO.md

@@ -1509,3 +1509,9 @@ RE-831: Rust matches116 original timer cases, including active-round bypass, sig
 
 
 RE-832: Complete7805 execution now composes prefix, class, supplied predicate, round/time and limit policies with shared mutations across438 finite fixtures. Full runtime completion remains open. [Evidence](research/QVM_EXIT_COMPLETE.md).
+
+
+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).

docs/RESEARCH_LEDGER.md

@@ -1830,3 +1830,12 @@ Rust matches116 original timer cases, including active-round bypass, signed mult
 ## 2026-10-27 — RE-832 Continuous original exit-rule body with all recovered priority branches
 
 Complete7805 execution now composes prefix, class, supplied predicate, round/time and limit policies with shared mutations across438 finite fixtures. Focused `cargo xtask test-group exit-complete` 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-833 Rust complete recovered exit-rule decision and mutation composition
+
+Rust now composes the full recovered7805 priority and matches438 continuous source cases, including pending clears and mode9 reset/event intentions. Focused `cargo xtask test-group rust-exit-complete` 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-833 final review: added five explicit source-to-Rust dependency edges and registry regression assertions; the targeted registry test and repeated `rust-exit-complete` focused group pass. Added the ten-task batch summary and RE-834 follow-up scope.
+
+Batch RE-824–833 boundary: the single `cargo xtask test-full --since 1ed43d40` run passed after task ten: 1,628 Python tests, 127 Rust tests (assets 10, gameplay 89, xtask 28), 43 deterministic report producers, storage policy, 392 documentation files and whitespace checks. No generated report drift; validation notes amended into task ten.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1546,3 +1546,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-832 Continuous original exit-rule body with all recovered priority branches ([evidence](research/QVM_EXIT_COMPLETE.md)).
+
+
+- [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).

docs/TESTING.md

@@ -128,3 +128,8 @@ Use `cargo xtask test-group <name>` with `coherent-memory`, `child-byte-effects`
 ## Original formatter and exit-rule groups
 
 Use `cargo xtask test-group <name>` with `format-string`, `format-integer`, `formatter`, `scoreboard-formatter`, `rust-qvm-format`, `rust-scoreboard-original`, `format-wrappers`, `rust-format-wrappers`, `exit-prefix` or `rust-exit-prefix`. The registry regression verifies source-report selections for the new Rust parity producers and both new module paths. See [contract limits and corrected formatter assumptions](research/QVM_ORIGINAL_FORMATTER_BATCH.md). Full validation remains once after ten task commits.
+
+
+## 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).

docs/research/QVM_FLOAT_EXIT_RULES_BATCH.md

@@ -0,0 +1,37 @@
+# Float formatter and exit-rule composition: RE-824–833
+
+Ten tasks recover original float formatting and compose the exit-rule body 7805 into Rust. These are bounded source contracts, not a running game or complete native parity.
+
+| Task | Result |
+| --- | --- |
+| RE-824 | [Float formatter source arithmetic](QVM_FORMAT_FLOAT.md) |
+| RE-825 | [Rust float formatter](RUST_FORMAT_FLOAT.md) |
+| RE-826 | [Mode11 class guard](QVM_EXIT_CLASS.md) |
+| RE-827 | [Rust class guard](RUST_EXIT_CLASS.md) |
+| RE-828 | [Score/team exit limit priority](QVM_EXIT_LIMITS.md) |
+| RE-829 | [Rust limit policy](RUST_EXIT_LIMITS.md) |
+| RE-830 | [Round/time gates and mode 9 reset effects](QVM_EXIT_TIMERS.md) |
+| RE-831 | [Rust timers and reset intentions](RUST_EXIT_TIMERS.md) |
+| RE-832 | [Continuous exit-rule source composition](QVM_EXIT_COMPLETE.md) |
+| RE-833 | [Rust complete recovered exit policy](RUST_EXIT_COMPLETE.md) |
+
+## Evidence and boundaries
+
+The float helper has 126 fixtures, plus 12 central formatter fixtures. It truncates repeated f32 fractional arithmetic; width applies to the integer portion. Negative zero loses its sign. Rust rejects nonfinite/out-of-domain values and bounds precision and width explicitly.
+
+Exit class, limit and timer contracts have 45, 125 and 116 fixtures respectively. Continuous 7805 execution covers 438 cases, including conflicting priorities and shared client mutations. Rust matches those decisions, pending-state updates and reset intentions. The active round gate bypasses time-limit evaluation; the mode 9 path distinguishes collected client count from configured scan bounds.
+
+Child 7662 remains a supplied predicate. Calls 7525/6825/7367, formatting, sending, logging and event allocation are captured or supplied effects. Event 69 intentions expose owner/time and flag OR 256; the source fixture supplies initial constructor flags 16. Neither adapter establishes the real allocator or transition implementation. Native/JIT execution, real game traces and unrestricted memory legality remain unverified.
+
+## Validation
+
+Focused cargo xtask groups passed before each task commit. Reports were regenerated twice with deterministic output, relevant Python and scoped Rust checks, storage policy, documentation links and whitespace validation. After commit ten, `cargo xtask test-full --since 1ed43d40` passed: 1,628 Python tests, 127 Rust tests (assets 10, gameplay 89, xtask 28), 43 affected producers regenerated twice deterministically, storage policy, 392 documentation files and whitespace checks. Generated reports left no uncommitted differences. This was the only full-suite invocation in the batch.
+
+## Next work: RE-834
+
+- [ ] Recover 7662 and replace the supplied predicate with original instruction evidence.
+- [ ] Recover 7525/6825/7367 transition effects and their world/state ownership.
+- [ ] Resolve formatting, copy, log, send and event constructors used by these paths.
+- [ ] Integrate ranking, exit decisions and scoreboard publication across shared state.
+- [ ] Audit legacy trace/memory assumptions and compare actual native/gameplay traces.
+- [ ] Connect verified policies to the game runtime and validate macOS/Linux Bevy/Solari behavior.

docs/research/README.md

@@ -1086,3 +1086,8 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-832: Continuous original exit-rule body with all recovered priority branches](QVM_EXIT_COMPLETE.md).
+
+
+[RE-833: Rust complete recovered exit-rule decision and mutation composition](RUST_EXIT_COMPLETE.md).
+
+- [RE-824–833 float formatter and exit-rule batch](QVM_FLOAT_EXIT_RULES_BATCH.md).

docs/research/RUST_EXIT_COMPLETE.md

@@ -0,0 +1,7 @@
+# Rust complete recovered exit-rule decision and mutation composition
+
+RE-833. Reproduce with `python3 scripts/analyze_rust_exit_complete.py`; focused validation: `cargo xtask test-group rust-exit-complete`. [Machine report](rust-exit-complete.json).
+
+The typed state validates safe scan bounds and consistent mode inputs, then composes prefix, class, supplied predicate, timers and limit policies. Source parity checks every decision, offender, pending word, client field and reset intention, with an independent composition oracle. Unit tests stress conflicting priorities and rejection before mutation. Actual predicate/transition/allocation/log/send effects and full game runtime integration remain open.
+
+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": 87,
+  "rust_unit_tests": 89,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_exit_complete.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from analyze_rust_exit_class import words
+from analyze_rust_exit_limits import decode
+from qvm_exit_rules_support import GLOBALS
+from qvm_notification_support import CPOOL,POOL
+from rust_lifecycle_support import binary,result
+from analyze_qvm import write_json
+
+def outcome(s):
+    req=s['requests'];a=s['input'];kind='none';id=-1
+    if not req:kind='wait'
+    elif req[0]['target']==7525:kind='blocked'
+    elif req[0]['target']==6825:kind='transition'
+    elif req[0]['target']==7367:kind='class';id=(req[1]['arguments']['20']-CPOOL-504)//6336
+    elif a['predicate']:kind='predicate'
+    elif len(req)>1:
+        if req[-1]['arguments']['8'] in [34577,34461]:kind='round' if req[-1]['arguments']['8']==34577 else 'time'
+        else:decoded=decode(req[1:]);kind=decoded['kind'];id=decoded['client']
+    resets=[]
+    for call,event,log in zip([r for r in req if r['target']==277695],s['events'],[r for r in req if r['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({'client':slot,'entity':entity,'owner':event['fields']['140'],'time':event['fields']['84'],'kind':69,'flags_or':event['fields']['424']&256,'logged_value':log['arguments']['16']})
+    return {'kind':kind,'client':id,'pending':s['pending_after'],'clients':s['clients_after'],'resets':resets}
+
+def main():
+    b=binary();p=Path('docs/research/qvm-exit-complete.json');data=p.read_bytes();rows=[]
+    for i,s in enumerate(json.loads(data)['probes']):
+        a=s['input'];c=s['clients_before'];args=[a[k] for k in GLOBALS]+[a['predicate'],len(c),64,*[v for j,c in enumerate(c) for v in words(c,j)],*[100+j for j in range(64)]];rows.append({'case':i,'source':outcome(s),'rust':result(b,'exit-complete',args)})
+    write_json(Path('docs/research/rust-exit-complete.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust complete recovered7805 decision and shared mutation contract matches438 continuous original source fixtures.7662 predicate is supplied, event allocation and all transition/log/format/send effects remain intentions. Invalid raw pointer/count ABI and native/runtime acceptance remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_exit_complete.py

@@ -0,0 +1,13 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_exit_complete import oracle,signed
+from test_qvm_exit_limits import decision
+class RustCompleteExitTests(unittest.TestCase):
+    def test_exact_source_outputs_and_independent_composition(self):
+        r=json.loads(Path('docs/research/rust-exit-complete.json').read_text());source=json.loads(Path(r['source_report']).read_text());self.assertEqual(len(r['probes']),438)
+        for p in r['probes']:
+            s=source['probes'][p['case']];pending,req,ids,kind=oracle(s['input'],s['clients_before']);self.assertEqual(p['rust'],p['source']);self.assertEqual(p['rust']['pending'],pending);self.assertEqual(p['rust']['kind'],kind);self.assertEqual(p['rust']['clients'],s['clients_after']);self.assertEqual(len(p['rust']['resets']),len(ids))
+            if kind=='client':self.assertEqual(p['rust']['client'],decision(s['input'],[{k:signed(v) for k,v in c.items()} for c in s['clients_before']])[1])
+    def test_source_identity(self):
+        r=json.loads(Path('docs/research/rust-exit-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

@@ -2136,3 +2136,21 @@ report	scripts/analyze_qvm_exit_complete.py	docs/research/qvm-exit-complete.json
 edge	docs/research/qvm-exit-complete.json	scripts/test_qvm_exit_complete.py
 group	exit-complete	scripts/analyze_qvm_exit_complete.py
 edge	scripts/analyze_qvm_exit_complete.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_exit_complete.py
+edge	Cargo.lock	scripts/analyze_rust_exit_complete.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_exit_complete.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_exit_complete.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_exit_complete.py
+edge	crates/urt-gameplay/src/exit_rules.rs	scripts/analyze_rust_exit_complete.py
+edge	crates/urt-gameplay/src/exit_prefix.rs	scripts/analyze_rust_exit_complete.py
+group	gameplay	scripts/analyze_rust_exit_complete.py
+group	rust-exit-complete	scripts/analyze_rust_health_impulse.py
+report	scripts/analyze_rust_exit_complete.py	docs/research/rust-exit-complete.json
+edge	docs/research/rust-exit-complete.json	scripts/test_rust_exit_complete.py
+group	rust-exit-complete	scripts/analyze_rust_exit_complete.py
+edge	scripts/analyze_rust_exit_complete.py	scripts/analyze_qvm_resumer_audit.py
+edge	docs/research/qvm-format-float.json	scripts/analyze_rust_format_float.py
+edge	docs/research/qvm-exit-class.json	scripts/analyze_rust_exit_class.py
+edge	docs/research/qvm-exit-limits.json	scripts/analyze_rust_exit_limits.py
+edge	docs/research/qvm-exit-timers.json	scripts/analyze_rust_exit_timers.py
+edge	docs/research/qvm-exit-complete.json	scripts/analyze_rust_exit_complete.py

xtask/src/lib.rs

@@ -1098,6 +1098,11 @@ mod integration_tests {
             ("qvm-scoreboard-formatter", "scoreboard_packet"),
             ("qvm-format-wrappers", "format_wrappers"),
             ("qvm-exit-prefix", "exit_prefix"),
+            ("qvm-format-float", "format_float"),
+            ("qvm-exit-class", "exit_class"),
+            ("qvm-exit-limits", "exit_limits"),
+            ("qvm-exit-timers", "exit_timers"),
+            ("qvm-exit-complete", "exit_complete"),
         ] {
             let selected = plan(
                 &g,