gameplay: integrate connect session lifecycle branch

crates/urt-gameplay/src/bin/urt-native-policy.rs

@@ -713,6 +713,66 @@ fn run() -> Result<String, String> {
                 out.ring_advance
             ))
         }
+        "connect-session" => {
+            if w.len() != 6 {
+                return Err("invalid connect header".into());
+            }
+            let mut client = vec![0xdd; CLIENT_BYTES];
+            let mut entity = ConnectEntity {
+                linked_slot: None,
+                field764: 0xaabbccdd,
+                field768: 0xaabbccdd,
+            };
+            let mut selector = 0;
+            let out = connect_session(
+                &mut client,
+                &mut entity,
+                ConnectInput {
+                    first_time: w[1] as i32,
+                    new_session: w[2] as i32,
+                    flags: 1,
+                    initialize: InitializeInput {
+                        mode: w[0] as i32,
+                        slot: w[4] as usize,
+                        userinfo: b"\\team\\S\\cl_guid\\ID",
+                        limit: 2,
+                        occupancy: 1,
+                        seconds: 0,
+                        clock: 100,
+                        ticks: 17,
+                        handle: w[5],
+                        client_id: 999,
+                        enabled: 1,
+                        mapname: b"ut4_test",
+                        file_length: 11,
+                        file_data: b"9,8,7,6,5,4",
+                    },
+                    session: b"1,-2,3,4,5,1,1,1,1",
+                    ignore_text: b"1,3,",
+                    scratch: [w[3]; 5],
+                },
+                &mut selector,
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            let nonzero = client
+                .chunks_exact(4)
+                .enumerate()
+                .filter_map(|(j, b)| {
+                    let v = u32::from_le_bytes(b.try_into().unwrap());
+                    (v != 0).then_some(vec![4 * j as u32, v])
+                })
+                .collect::<Vec<_>>();
+            Ok(format!(
+                "{{\"raw\":\"{}\",\"nonzero\":{},\"choice\":[{}],\"entity_linked\":{},\"entity_clear\":[{},{}],\"ring\":{},\"info_ring\":{selector}}}",
+                hex(&client[3096..3096 + SESSION_BYTES]),
+                nested(&nonzero),
+                if out.fresh { 247520 } else { 247219 },
+                entity.linked_slot == Some(w[4] as usize),
+                entity.field764,
+                entity.field768,
+                out.ring_advance
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }

crates/urt-gameplay/src/native_policy.rs

@@ -1894,3 +1894,201 @@ mod memory_persistence_tests {
         assert_eq!(selector, 0);
     }
 }
+
+pub const CLIENT_BYTES: usize = 6336;
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConnectEntity {
+    pub linked_slot: Option<usize>,
+    pub field764: u32,
+    pub field768: u32,
+}
+pub struct ConnectInput<'a> {
+    pub first_time: i32,
+    pub new_session: i32,
+    pub flags: u32,
+    pub initialize: InitializeInput<'a>,
+    pub session: &'a [u8],
+    pub ignore_text: &'a [u8],
+    pub scratch: [u32; 5],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConnectedSession {
+    pub fresh: bool,
+    pub initialized: Option<InitializedSession>,
+    pub restored: Option<RestoredSession>,
+    pub ring_advance: u32,
+}
+/// Bounded173979 caller path after authentication and before later team
+/// normalization. Clearing client memory does not initialize caller scratch.
+pub fn connect_session(
+    client: &mut [u8],
+    entity: &mut ConnectEntity,
+    input: ConnectInput<'_>,
+    info_ring: &mut u32,
+) -> Result<ConnectedSession, Error> {
+    let mut cfg = input.initialize;
+    let slot = cfg.slot;
+    if client.len() != CLIENT_BYTES || slot >= 64 {
+        return Err(Error::InvalidCount);
+    }
+    let mut bytes = vec![0; CLIENT_BYTES];
+    let mut selector = *info_ring;
+    raw_store(&mut bytes, 468, 1);
+    raw_store(&mut bytes, 6156, slot as u32);
+    cfg.client_id = 0;
+    let fresh = input.first_time != 0 || input.new_session != 0;
+    let mut initialized = None;
+    let mut restored = None;
+    let ring_advance;
+    if fresh {
+        let out = initialize_session(&mut bytes[3096..3096 + SESSION_BYTES], cfg, &mut selector)?;
+        ring_advance = out.ring_advance;
+        initialized = Some(out);
+    } else {
+        let mut state = RestoreState {
+            values: [0; 9],
+            ignore: [0; 64],
+            position: [0; 6],
+        };
+        let out = restore_session(
+            &mut state,
+            RestoreInput {
+                flags: input.flags,
+                session: input.session,
+                ignore_text: input.ignore_text,
+                scratch: input.scratch,
+                position: PositionInput {
+                    mode: cfg.mode,
+                    enabled: cfg.enabled,
+                    slot,
+                    userinfo: cfg.userinfo,
+                    mapname: cfg.mapname,
+                    name: b"",
+                    values: [0; 6],
+                    handle: cfg.handle,
+                },
+                file_length: cfg.file_length,
+                file_data: cfg.file_data,
+            },
+            &mut selector,
+        )?;
+        for (j, o) in [0, 60, 48, 44, 52, 56, 612, 616, 644]
+            .into_iter()
+            .enumerate()
+        {
+            raw_store(&mut bytes, 3096 + o, state.values[j] as u32);
+        }
+        for (j, v) in state.ignore.iter().enumerate() {
+            raw_store(&mut bytes, 3780 + 4 * j, *v as u32);
+        }
+        for (j, v) in state.position.iter().enumerate() {
+            raw_store(&mut bytes, 3716 + 4 * j, *v);
+        }
+        ring_advance = out.ring_advance;
+        restored = Some(out);
+    }
+    client.copy_from_slice(&bytes);
+    *entity = ConnectEntity {
+        linked_slot: Some(slot),
+        field764: 0,
+        field768: 0,
+    };
+    *info_ring = selector;
+    Ok(ConnectedSession {
+        fresh,
+        initialized,
+        restored,
+        ring_advance,
+    })
+}
+#[cfg(test)]
+mod connect_tests {
+    use super::*;
+    #[test]
+    fn rejected_client_preserves_entity_and_selector() {
+        let mut client = [];
+        let mut entity = ConnectEntity {
+            linked_slot: None,
+            field764: 7,
+            field768: 8,
+        };
+        let before = entity.clone();
+        let mut selector = 1;
+        let out = connect_session(
+            &mut client,
+            &mut entity,
+            ConnectInput {
+                first_time: 1,
+                new_session: 0,
+                flags: 0,
+                initialize: InitializeInput {
+                    mode: 0,
+                    slot: 0,
+                    userinfo: b"",
+                    limit: 0,
+                    occupancy: 0,
+                    seconds: 0,
+                    clock: 0,
+                    ticks: 0,
+                    handle: 0,
+                    client_id: 0,
+                    enabled: 1,
+                    mapname: b"m",
+                    file_length: 0,
+                    file_data: b"",
+                },
+                session: b"",
+                ignore_text: b"",
+                scratch: [0; 5],
+            },
+            &mut selector,
+        );
+        assert_eq!(out, Err(Error::InvalidCount));
+        assert_eq!(entity, before);
+        assert_eq!(selector, 1);
+    }
+    #[test]
+    fn clear_client_does_not_zero_supplied_scratch() {
+        let mut client = vec![0xdd; CLIENT_BYTES];
+        let mut entity = ConnectEntity {
+            linked_slot: None,
+            field764: 7,
+            field768: 8,
+        };
+        let mut selector = 0;
+        let out = connect_session(
+            &mut client,
+            &mut entity,
+            ConnectInput {
+                first_time: 0,
+                new_session: 0,
+                flags: 1,
+                initialize: InitializeInput {
+                    mode: 3,
+                    slot: 0,
+                    userinfo: b"",
+                    limit: 0,
+                    occupancy: 0,
+                    seconds: 0,
+                    clock: 0,
+                    ticks: 0,
+                    handle: 0,
+                    client_id: 0,
+                    enabled: 1,
+                    mapname: b"m",
+                    file_length: 0,
+                    file_data: b"",
+                },
+                session: b"1,-2,3",
+                ignore_text: b"",
+                scratch: [1; 5],
+            },
+            &mut selector,
+        )
+        .unwrap();
+        assert!(!out.fresh);
+        assert_eq!(raw_word(&client, 3152), 1);
+        assert_eq!(raw_word(&client, 468), 1);
+        assert_eq!(client[6332..], [0; 4]);
+    }
+}

docs/FINDINGS.md

@@ -1736,3 +1736,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-912:** 96 bounded173979 caller-path executions cover174081..174173 after userinfo/authentication: entity-client linking, actual6336-byte clear via modeled native memset, connecting-state/client-slot writes and the first-time OR new-session choice between actual247520 initialization and247219 restore. Both children execute recovered load/format/scanner policies. Uppercase team S below capacity is not the lowercase s shortcut. Authentication before the slice, post-branch normalization and native engine integration remain open. [Evidence](research/QVM_CONNECT_SESSION.md).
+
+
+**RE-913:** Rust matches96 bounded173979 caller paths, including client/entity initialization, first-time OR new-session dispatch, actual initialization/restore policies and saved-position loading. Client memory clear does not erase supplied caller scratch. Errors stage client/entity/selector changes. Authentication and later caller normalization, native IO and full client-connect acceptance remain open. [Evidence](research/RUST_CONNECT_SESSION.md).

docs/PROVISIONAL_TODO.md

@@ -1773,3 +1773,9 @@ RE-911: Rust matches144 original save/session-write/restore/read compositions us
 
 
 RE-912: 96 bounded173979 caller-path executions cover174081..174173 after userinfo/authentication: entity-client linking, actual6336-byte clear via modeled native memset, connecting-state/client-slot writes and the first-time OR new-session choice between actual247520 initialization and247219 restore. Both children execute recovered load/format/scanner policies. Uppercase team S below capacity is not the lowercase s shortcut. Authentication before the slice, post-branch normalization and native engine integration remain open. Full runtime completion remains open. [Evidence](research/QVM_CONNECT_SESSION.md).
+
+
+RE-913: Rust matches96 bounded173979 caller paths, including client/entity initialization, first-time OR new-session dispatch, actual initialization/restore policies and saved-position loading. Client memory clear does not erase supplied caller scratch. Errors stage client/entity/selector changes. Authentication and later caller normalization, native IO and full client-connect acceptance remain open. Full runtime completion remains open. [Evidence](research/RUST_CONNECT_SESSION.md).
+
+
+RE-904–913 completed bounded initialization, full persistence, in-memory round trips and connect clear/dispatch policies. RE-914 tracks full connect/native IO, remaining scanner/alias domains and real runtime integration. [Batch and next work](research/QVM_SESSION_LIFECYCLE_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -2280,3 +2280,13 @@ Rust matches144 original save/session-write/restore/read compositions using owne
 ## 2026-10-28 — RE-912 Original connect clear and session-branch caller
 
 96 bounded173979 caller-path executions cover174081..174173 after userinfo/authentication: entity-client linking, actual6336-byte clear via modeled native memset, connecting-state/client-slot writes and the first-time OR new-session choice between actual247520 initialization and247219 restore. Both children execute recovered load/format/scanner policies. Uppercase team S below capacity is not the lowercase s shortcut. Authentication before the slice, post-branch normalization and native engine integration remain open. Focused `cargo xtask test-group qvm-connect-session` passes (4 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-28 — RE-913 Rust connect clear and session lifecycle branch
+
+Rust matches96 bounded173979 caller paths, including client/entity initialization, first-time OR new-session dispatch, actual initialization/restore policies and saved-position loading. Client memory clear does not erase supplied caller scratch. Errors stage client/entity/selector changes. Authentication and later caller normalization, native IO and full client-connect acceptance remain open. Focused `cargo xtask test-group rust-connect-session` 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-904–913 full batch validation (2026-10-28)
+
+At the tenth-commit boundary, the first full attempt exposed a helper filename collision with the pre-existing health lifecycle module. The original helper was restored byte-for-byte, session helpers moved to qvm_session_lifecycle_support.py, and an import smoke check added to the scoped registry regression. After focused repair checks, `cargo xtask test-full --since 6d0ce63f` completed successfully with the flake-declared Nix Python: 1,768 Python tests,207 Rust tests (assets10, gameplay167, xtask30),39 affected report producers regenerated twice deterministically, storage policy,480 documentation link checks and whitespace guards. No generated-report drift. Ten task commits since6d0ce63f; repair and results are amended into the tenth commit. [Findings and next work](research/QVM_SESSION_LIFECYCLE_BATCH.md).

docs/REVERSE_ENGINEERING_TODO.md

@@ -1782,7 +1782,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-903 Rust session restore with caller-scratch ownership ([evidence](research/RUST_SESSION_RESTORE.md)).
 
 
-- [ ] RE-904 Complete numeric/fatal/alias domains, scratch provenance, real reload and native IO/runtime integration ([next tasks](research/QVM_SAVED_RESTORE_BATCH.md)).
+- [ ] Follow-up after RE-903: complete numeric/fatal/alias domains, scratch provenance, real reload and native IO/runtime integration ([next tasks](research/QVM_SAVED_RESTORE_BATCH.md)).
 
 
 - [x] RE-904 Original session initialization and immediate persistence ([evidence](research/QVM_SESSION_INIT.md)).
@@ -1810,3 +1810,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-912 Original connect clear and session-branch caller ([evidence](research/QVM_CONNECT_SESSION.md)).
+
+
+- [x] RE-913 Rust connect clear and session lifecycle branch ([evidence](research/RUST_CONNECT_SESSION.md)).
+
+
+- [ ] RE-914 Complete connect authentication/normalization, native IO/reload, scanner/alias domains and full runtime integration ([next work](research/QVM_SESSION_LIFECYCLE_BATCH.md)).

docs/TESTING.md

@@ -166,3 +166,6 @@ RE-884–893 adds focused groups `qvm-queried-spawn`, `rust-queried-spawn`, `qvm
 
 
 RE-894–903 adds focused groups `qvm-info-lookup`, `rust-info-lookup`, `qvm-numeric-scan`, `rust-numeric-scan`, `qvm-position-save`, `rust-position-save`, `qvm-position-load`, `rust-position-load`, `qvm-session-restore` and `rust-session-restore`. Use one group per invocation. Full validation after task ten uses `cargo xtask test-full --since 6e01995b` with explicit flake-declared Nix PYTHON. [Source domains and scratch ownership](research/QVM_SAVED_RESTORE_BATCH.md).
+
+
+RE-904–913 adds focused groups `qvm-session-init`, `rust-session-init`, `qvm-post-map-files`, `rust-post-map-files`, `qvm-normal-map-files`, `rust-normal-map-files`, `qvm-persistence-roundtrip`, `rust-persistence-roundtrip`, `qvm-connect-session` and `rust-connect-session`. Invoke one group per command. The full suite after task ten uses `cargo xtask test-full --since 6d0ce63f` with explicit flake-declared Nix PYTHON. [Bounded lifecycle evidence](research/QVM_SESSION_LIFECYCLE_BATCH.md).

docs/research/QVM_SAVED_RESTORE_BATCH.md

@@ -43,7 +43,7 @@ Each task used focused `cargo xtask test-group <name>` before its commit, with d
 
 Dependency-selection regression coverage includes all five new source-to-Rust report pairs, native_policy consumers, formatting dependencies and intermission classification used by restore. Every Python process uses the resolved Nix runtime declared by flake.nix, with explicit PYTHON for xtask and Git hooks. No original asset payload changed. After commit ten, `cargo xtask test-full --since 6e01995b` passed once: 1,753 Python tests and199 Rust tests (assets10, gameplay159, xtask30). All22 affected report producers regenerated twice deterministically. Storage policy, links across469 documentation files and whitespace checks passed with no generated-report drift. These notes were amended into task ten.
 
-## Next work: RE-904
+## Follow-up work (expanded by RE-904–913)
 
 - [ ] Recover uppercase exponent behavior and remaining38355 conversions, non-ASCII parsing, oversized/fatal userinfo and pointer/buffer alias contracts.
 - [ ] Trace actual scratch provenance on malformed session restore; decide a documented production compatibility/default policy after validating native behavior.
@@ -53,3 +53,5 @@ Dependency-selection regression coverage includes all five new source-to-Rust re
 - [ ] Replace supplied spatial-query answers with recovered native broadphase, integrate bot rotation/native genetic behavior, and recover221662 map-list parsing.
 - [ ] Compose complete respawn/begin-intermission, event lifetime and ranking/scoreboard/network execution.
 - [ ] Validate actual Linux/macOS Rust/Bevy/Solari gameplay/rendering. Full-game completion remains open.
+
+[RE-904–913](QVM_SESSION_LIFECYCLE_BATCH.md) composes initialization, full persistence, byte-fed round trips and the bounded connect caller. Its RE-914 list supersedes the historical follow-up list above.

docs/research/QVM_SESSION_LIFECYCLE_BATCH.md

@@ -0,0 +1,55 @@
+# Session lifecycle and complete persistence: RE-904–913
+
+Ten separately committed tasks connect original QVM lifecycle routines and their Rust policies across448 paired source cases. They cover initialization, both post-map children, normal map flow, byte-fed write/restore and the bounded connect caller branch. Native files, userinfo/cvars, timing and selected callbacks remain supplied inputs or captured intentions. This evidence does not establish real network/client-connect acceptance or a complete playable game.
+
+| Task | Evidence | Cases |
+| --- | --- | ---: |
+| RE-904 | [Original247520 initializer](QVM_SESSION_INIT.md) | 96 |
+| RE-905 | [Rust initializer and raw-field ownership](RUST_SESSION_INIT.md) | 96 |
+| RE-906 | [Original249007 with246746/246963](QVM_POST_MAP_FILES.md) | 48 |
+| RE-907 | [Rust complete post-map persistence](RUST_POST_MAP_FILES.md) | 48 |
+| RE-908 | [Normal6939 with both persistence children](QVM_NORMAL_MAP_FILES.md) | 64 |
+| RE-909 | [Rust normal map/file/cvar flow](RUST_NORMAL_MAP_FILES.md) | 64 |
+| RE-910 | [Original byte-fed write/restore](QVM_PERSISTENCE_ROUNDTRIP.md) | 144 |
+| RE-911 | [Rust owned in-memory persistence](RUST_PERSISTENCE_ROUNDTRIP.md) | 144 |
+| RE-912 | [Bounded173979 caller clear/branch](QVM_CONNECT_SESSION.md) | 96 |
+| RE-913 | [Rust connect lifecycle branch](RUST_CONNECT_SESSION.md) | 96 |
+
+## Initialization ownership
+
+Actual247520 selects the initial team field at3096 through original33715 classification. Team-classified modes preserve a nonzero field, while zero becomes3. Other modes query userinfo key team through70503: a first byte of lowercase s selects3; otherwise a positive capacity limit34089308 reached by34992584 selects3, and other cases select0. The caller fixtures additionally verify uppercase S below capacity selects0.
+
+The initializer writes clock34992532 into selected fields, sets field3108 to1, and computes the timeout at3140 with wrapping arithmetic. A nonzero configured34085460 contributes seconds*1000, including negative values; zero uses60000. Field3148 receives a clock write and is later cleared. Native -3 supplies the tick snapshot stored at3156. A36-byte bounded copy writes one space and NUL padding at3164. Several fields are word-cleared, while the starts of string-like regions are only byte-cleared; neighboring bytes remain observable in warm-state fixtures. The64 ignore words at3780 are cleared. Coordinates3716..3736 survive unless the actual246554 load succeeds.
+
+Initialization then executes actual246963 session serialization and captures7259 diagnostics. The Rust API uses a944-byte block beginning at3096 to preserve byte/word distinctions, with explicit timing and file answers. It stages state/selector changes on typed errors. Metadata meanings, native timing/file semantics and full engine lifecycle remain open.
+
+## Post-map ordering and map transitions
+
+Actual249007 now executes both recovered client children. The first246746 child produces ordered userinfo/map/open/write/close intentions; the second246963 writes sessionN and sessIgnoreN. Each eligible client's file operations precede its cvar pair. The48 fixtures vary connected-state patterns, level count, mode, enable and supplied open handles, while formatter and info selectors carry across clients.
+
+The64 normal6939 fixtures compose122230,7188,249007 and both persistence children. Score/global resets precede persistence, and the final max-client state2-to1 scan follows it. Reset maximum and level count vary independently. The engine map bytes supplied to the map-command and saved-file paths are consistent. Rust shares action assembly between standalone and normal persistence; no file action is dispatched to an operating system. Bot callback internals,221662 map-list selection, actual cvar/console command dispatch and series-path composition remain open.
+
+## Byte-fed write/restore and caller integration
+
+The144 round trips execute actual246746 and246963, then feed their captured cvar/file bytes into actual247219/246554 on a fresh destination snapshot. The destination starts with explicit metadata/position values and a nonzero ignore table; caller scratch is also supplied. Session text containing negative/INT_MIN fields is not assumed invertible: recovered formatter and scanner behavior can produce partial writes and scratch-dependent booleans. Restored ignore entries accumulate, and six-float file prefixes remain readable with appended PLAYER text.
+
+Rust MemoryPersistence owns ordered cvar/file byte maps. It applies captured write intentions and supplies those bytes to the restore policies, staging adapter/destination/selector changes on errors. This validates an in-memory transcript; it does not validate a filesystem, native handle lifetime, actual reload or arbitrary concurrent engine effects.
+
+The final source fixtures execute173979's174081..174173 caller portion after its userinfo/authentication prefix. They link entity offset520 to the selected client, clear entity fields764/768, model the actual native6336-byte client memset, set connection468 to1, and copy the slot into6156. The first-time argument or nonzero global34992572 chooses actual247520 initialization; otherwise actual247219 restores. Both children execute recovered scanner/formatter/load policies. Clearing the client does not clear the separate VM caller scratch. The Rust API stages raw client bytes, typed entity linkage and selector together. Authentication before this slice, later team normalization from174174 onward, bot connection behavior, alias domains and real engine acceptance remain open.
+
+## Validation and storage
+
+Focused `cargo xtask test-group <name>` ran before each commit, with selected reports regenerated twice, source/Rust parity, scoped gameplay checks and storage/documentation/whitespace guards. The ten groups are qvm-session-init, rust-session-init, qvm-post-map-files, rust-post-map-files, qvm-normal-map-files, rust-normal-map-files, qvm-persistence-roundtrip, rust-persistence-roundtrip, qvm-connect-session and rust-connect-session. Shared persistence action assembly also received its standalone regression check.
+
+The dependency-selection regression covers the five source/Rust report pairs, native_policy consumers and shared transition/map/intermission dependencies. Its import smoke check also keeps the existing health lifecycle and new session lifecycle helper namespaces independent. The first full-suite attempt caught a helper filename collision: the original health helper was restored byte-for-byte from the batch baseline, the new code moved to qvm_session_lifecycle_support.py, and affected checks were rerun before final full validation. Python runs only through the resolved Nix runtime declared by flake.nix, with explicit PYTHON inherited by xtask and Git hooks. Original assets are unchanged. After the namespace repair documented above, `cargo xtask test-full --since 6d0ce63f` completed successfully at the tenth-commit boundary: 1,768 Python tests and207 Rust tests (assets10, gameplay167, xtask30). All39 affected report producers regenerated twice deterministically. Storage policy, links across480 documentation files and whitespace checks passed with no generated-report drift. Repair and validation notes were amended into task ten.
+
+## Next work: RE-914
+
+- [ ] Recover the173979 authentication/userinfo prefix and post-174174 team normalization, bot branch and downstream connect callbacks; compose the complete function.
+- [ ] Recover native file-open return/handle/close behavior and attach a platform-neutral engine IO adapter; validate actual reload and failure ownership on macOS/Linux.
+- [ ] Trace real VM scratch provenance, non-ASCII/tail parsing, uppercase exponent and other scanner conversions, oversized/fatal strings and pointer aliases.
+- [ ] Recover direct/indirect246938 session-clear use, remaining metadata producers, ignore-table mutations and live count/base changes during callbacks.
+- [ ] Integrate both persistence children into series6939/readiness, plus real cvar refresh/command dispatch, bot rotation/native genetics and221662 map-list parsing.
+- [ ] Replace supplied spatial-query answers with native broadphase/world collision and compare native math.
+- [ ] Compose complete respawn/intermission, event lifetime and ranking/scoreboard/network execution.
+- [ ] Validate actual Linux/macOS Rust/Bevy/Solari gameplay/rendering. Full-game completion remains open.

docs/research/README.md

@@ -1345,3 +1345,9 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-912: Original connect clear and session-branch caller](QVM_CONNECT_SESSION.md).
+
+
+[RE-913: Rust connect clear and session lifecycle branch](RUST_CONNECT_SESSION.md).
+
+
+[RE-904–913 lifecycle and complete persistence batch](QVM_SESSION_LIFECYCLE_BATCH.md).

docs/research/RUST_CONNECT_SESSION.md

@@ -0,0 +1,7 @@
+# Rust connect clear and session lifecycle branch
+
+RE-913. Reproduce with `python3 scripts/analyze_rust_connect_session.py`; focused validation: `cargo xtask test-group rust-connect-session`. [Machine report](rust-connect-session.json).
+
+Rust matches96 bounded173979 caller paths, including client/entity initialization, first-time OR new-session dispatch, actual initialization/restore policies and saved-position loading. Client memory clear does not erase supplied caller scratch. Errors stage client/entity/selector changes. Authentication and later caller normalization, native IO and full client-connect acceptance remain open.
+
+Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.

docs/research/qvm-resumer-audit.json

@@ -8919,6 +8919,17 @@
       "repeated_calls_opt_in": false,
       "repeated_calls_setting": "default_false"
     },
+    {
+      "backward_conditional_branches": [],
+      "calls": [],
+      "explicit_result_offsets": null,
+      "helper": "qvm_trace_support.resume",
+      "line": 39,
+      "literal_range": null,
+      "path": "scripts/qvm_lifecycle_support.py",
+      "repeated_calls_opt_in": false,
+      "repeated_calls_setting": "default_false"
+    },
     {
       "backward_conditional_branches": [],
       "calls": [],
@@ -10025,10 +10036,10 @@
     }
   },
   "summary": {
-    "call_expressions": 202,
-    "files": 154,
-    "legacy_expressions": 157,
-    "nonliteral_ranges": 27,
+    "call_expressions": 203,
+    "files": 155,
+    "legacy_expressions": 158,
+    "nonliteral_ranges": 28,
     "unresolved_mode_expressions": 3
   }
 }

docs/research/rust-health-impulse.json

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

scripts/analyze_qvm_connect_session.py

@@ -11,7 +11,7 @@ from analyze_qvm import write_json
 def main():
  q,raw,h,ins=source();rows=[]
  from qvm_persistence_support import environment,RESTORE,SCRATCH
- from qvm_lifecycle_support import connect_branch,raw_state,CLIENT_BYTES
+ from qvm_session_lifecycle_support import connect_branch,raw_state,CLIENT_BYTES
  from qvm_byte_memory_support import write_bytes
  for mode,first,new,positive,slot,handle in itertools.product([0,3,9],[0,1],[0,-1],[False,True],[0,3],[0,7]):
   m,b=environment(raw,h);write_bytes(m,b,{a:raw[h['data_offset']+a] for a in range(83568,83824)});pointer=CPOOL+6336*slot

scripts/analyze_qvm_normal_map_files.py

@@ -11,7 +11,7 @@ from analyze_qvm import write_json
 def main():
  q,raw,h,ins=source();rows=[]
  from qvm_persistence_support import environment
- from qvm_lifecycle_support import post_full
+ from qvm_session_lifecycle_support import post_full
  from qvm_session_support import records
  from qvm_map_commands_support import map_seed,normal_flow,put_string,CURSOR,ENABLED,LIMIT,WRITE,MIRROR
  from qvm_transition_support import state_seed,state_words

scripts/analyze_qvm_post_map_files.py

@@ -11,7 +11,7 @@ from analyze_qvm import write_json
 def main():
  q,raw,h,ins=source();rows=[]
  from qvm_persistence_support import environment
- from qvm_lifecycle_support import post_full
+ from qvm_session_lifecycle_support import post_full
  from qvm_session_support import records
  from qvm_map_commands_support import put_string
  for mode,count,pattern,enabled,opened in itertools.product([0,9],[0,1,4],range(2),[0,1],[False,True]):

scripts/analyze_qvm_session_init.py

@@ -11,10 +11,10 @@ from analyze_qvm import write_json
 def main():
  q,raw,h,ins=source();rows=[]
  from qvm_persistence_support import environment
- from qvm_lifecycle_support import initialize,raw_state,SIZE
+ from qvm_session_lifecycle_support import initialize,raw_state,SIZE
  from qvm_byte_memory_support import write_bytes
  from qvm_formatter_support import image_bytes
- profiles=[(b'',0,0,0,100,11),(b'\\team\\s\\cl_guid\\ID',2,1,0,100,17),(b'\\team\\S\\cl_guid\\ID',2,2,2,100,19),(b'\\team\\spectator\\cl_guid\\ID',2,2,-1,2147483647,0xffffffff)]
+ profiles=[(b'',0,0,0,100,11),(b'\\team\\s\\cl_guid\\ID',2,1,0,100,17),(b'\\team\\S\\cl_guid\\ID',2,2,2,2147483647,19),(b'\\team\\spectator\\cl_guid\\ID',2,2,-1,2147483647,0xffffffff)]
  for mode,team,profile,slot,handle in itertools.product([0,3,9],[0,2],range(4),[0,3],[0,7]):
   info,limit,occupancy,seconds,now,ticks=profiles[profile];m,b=environment(raw,h);write_bytes(m,b,{a:raw[h['data_offset']+a] for a in range(83568,83824)});pointer=CPOOL+6336*slot
   for j in range(0,SIZE,4):m[pointer+3096+j]=0xaabbccdd

scripts/analyze_rust_connect_session.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_native_policy_support import binary,result,invoke
+from analyze_qvm import write_json
+def encode(s):
+ a=s['input'];return [a[k] for k in ['mode','first','new','scratch','slot','handle']]
+def project(s):return {k:s[k] for k in ['raw','nonzero','choice','entity_linked','entity_clear','ring','info_ring']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-connect-session.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'connect-session',encode(s))})
+ write_json(Path('docs/research/rust-connect-session.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches96 bounded173979 caller paths, including client/entity initialization, first-time OR new-session dispatch, actual initialization/restore policies and saved-position loading. Client memory clear does not erase supplied caller scratch. Errors stage client/entity/selector changes. Authentication and later caller normalization, native IO and full client-connect acceptance remain open.'})
+if __name__=='__main__':main()

scripts/qvm_lifecycle_support.py

@@ -1,52 +1,40 @@
-"""Recovered session initialization and connected persistence compositions."""
-from qvm_camera_world_support import B,run
-from qvm_exit_rules_support import CPOOL
-from qvm_persistence_support import info_lookup,load_position,save_position
-from qvm_session_support import session,FIELDS
-from qvm_string_memory_support import cstring,copy_bounded
-from qvm_byte_memory_support import read_bytes
-INIT=B+0x50000
-SIZE=944
+"""Explicit finite fixtures for protected and mode10 lifecycle source ranges."""
+from qvm_health_effects_support import seed as health_seed,H,TARGET,ATTACKER,CLIENT,A_CLIENT
+from qvm_research_support import constants
+from qvm_trace_support import resume,captured
+from analyze_qvm_acceleration import word
+L=H+0xa0000
+EVENT=L+0x10000
+FIELDS=[4,12,44,76,84,104,140,144,148,184,208,220,232,236,280,3096,4300,4304,4308,4312,4380,4384,4388,4392,6324,6332]
+EFIELDS=[0,140,144,160,168,184,200,204,424]
 
-def initialize(ins,m,b,pointer,userinfo,handle,ticks):
- from qvm_persistence_support import INFO
- from qvm_map_commands_support import put_string
- put_string(m,b,INFO,userinfo);parts={};diagnostics=[]
- def classify(i,m,a,bs):
-  m,v,p,b=run(i,m,33715,33740,12,a,dict(bs),base=B+0x52000);return m,v,{'actual_source_child':33715}
- def lookup(i,m,a,bs):
-  m,v,p,b=info_lookup(i,m,dict(bs),a);return m,v,{'actual_source_child':70503,'child_memory_bytes':{v+j:x for j,x in enumerate(cstring(m,b,v)+b'\0')}}
- def clock(i,m,a,bs):return m,ticks,{'engine_ticks_supplied':True}
- def copy(i,m,a,bs):return copy_bounded(i,m,a,dict(bs))
- def load(i,m,a,bs):
-  data=b'9,8,7,6,5,4';m,p,b=load_position(i,m,dict(bs),a[8],userinfo,b'ut4_test',handle,len(data),data);parts['load']=p;return m,0,{'actual_source_child':246554}
- def write(i,m,a,bs):
-  m,p,b=session(i,m,dict(bs),a[8]);parts['session']=p;return m,0,{'actual_source_child':246963}
- def diagnostic(i,m,a,bs):diagnostics.append([a[8],a[12]&0xffffffff,a[16]&0xffffffff]);return m,0,{'diagnostic_captured':True}
- m,v,p,b=run(ins,m,247520,247806,40,{8:pointer,12:INFO},b,{33715:classify,70503:lookup,-3:clock,69338:copy,246554:load,246963:write,7259:diagnostic},base=INIT);p.update(parts=parts,diagnostics=diagnostics);return m,p,b
+def seed(raw,h,**a):
+    m=health_seed(raw,h)
+    m.update(constants(raw,h,list(range(29584,29808,4))+list(range(4032,17416,4))))
+    for o in range(0,180,4):m[L+o]=0
+    m.update({L+72:TARGET,L+76:ATTACKER if a.get('attacker',True) else 0,L+80:a.get('flag',0),L+164:TARGET,L+168:ATTACKER,L+172:a.get('method',12),34090788:a.get('mode',10),34999596:a.get('blocked',0),34992532:a.get('now',10000),98588:a.get('disclose',0),34999668:7,34999672:9,34087532:a.get('penalty',1),34075396:a.get('limit',3),TARGET+168:65,ATTACKER+168:7,ATTACKER+764:a.get('strikes',0),ATTACKER+768:a.get('last',0),ATTACKER+424:a.get('attacker_flags',0)})
+    for o in FIELDS:m[CLIENT+o]=a.get('c'+str(o),0x1ffff if o in (104,220,236) else 7)
+    m.update({CLIENT+232:a.get('count',31990),CLIENT+6332:word(a.get('heat',10)),CLIENT+4:a.get('state',0),CLIENT+12:a.get('flags12',8),CLIENT+144:0,CLIENT+312:a.get('weapon',1),CLIENT+3096:a.get('team',1),A_CLIENT+3096:a.get('attacker_team',1),A_CLIENT+232:1234,A_CLIENT+140:7})
+    return m
 
-def raw_state(m,b,pointer):return read_bytes(m,b,pointer+3096,SIZE).hex()
+def snapshot(m):
+    return {'client':{str(o):m[CLIENT+o]&0xffffffff for o in FIELDS},'attacker_count':m[A_CLIENT+232]&0xffffffff,'entity':{str(o):m[TARGET+o]&0xffffffff for o in [684,720]},'attacker':{str(o):m[ATTACKER+o]&0xffffffff for o in [764,768]},'team_counts':[m[34999668]&0xffffffff,m[34999672]&0xffffffff]}
 
-def post_full(ins,m,b,userinfos,names,handles):
- calls=[];files=[];sets=[];actions=[]
- def save(i,m,a,bs):
-  j=(a[8]-CPOOL)//6336;calls.append([246746,j]);m,p,b=save_position(i,m,dict(bs),a[8],userinfos[j],b'ut4_test',handles[j],-7);files.append([j,p['events']]);actions.extend(dict(e,kind='file',slot=j) for e in p['events']);return m,0,{'actual_source_child':246746}
- def write(i,m,a,bs):
-  j=(a[8]-CPOOL)//6336;calls.append([246963,j]);m,p,b=session(i,m,dict(bs),a[8]);sets.extend(p['sets']);actions.extend(dict(kind='cvar',slot=j,key=k,value=v) for k,v in p['sets']);return m,0,{'actual_source_child':246963}
- m,v,p,b=run(ins,m,249007,249058,16,b=b,handlers={246746:save,246963:write},base=B+0x54000);p.update(calls=calls,files=files,sets=sets,actions=actions);return m,p,b
+def handlers(effects,resolvers=None):
+    def event(ins,m,args):
+        p=EVENT+len(effects['events'])*880
+        for o in range(0,880,4):m[p+o]=0
+        effects['events'].append({'arguments':args,'pointer':p,'fixture_allocation':True})
+        return m,p,{'supplied_event_pointer':p,'original_allocator_not_executed':True}
+    hs={t:captured(t,effects['requests']) for t in [7259,205260,6369,6439,278834,285486,-17,-18]}
+    def predicate(ins,m,args):
+        from qvm_contact_support import predicate as actual
+        return actual(ins,m,args)
+    def formatting(ins,m,args):
+        effects['requests'].append({'target':70458,'arguments':args,'native_effect_not_executed':True});return m,EVENT+0x10000,{'supplied_string_pointer':EVENT+0x10000}
+    hs.update({277695:event,33715:predicate,70458:formatting});hs.update(resolvers or {});return hs
 
-CONNECT=B+0x58000
-CLIENT_BYTES=6336
-def connect_branch(ins,m,b,slot,first,userinfo,handle):
- import hashlib,json
- from qvm_map_commands_support import put_string
- from qvm_persistence_support import restore_session
- entity=34091368+880*slot;pointer=CPOOL+6336*slot;m[CONNECT+24]=entity;put_string(m,b,CONNECT+28,userinfo,1024);parts={};choice=[]
- def zero(i,m,a,bs):
-  if a[8]!=pointer or a[12]!=0 or a[16]!=6336:raise ValueError('unsupported connect memset')
-  return m,a[8],{'native_memset_modeled':True,'child_memory_bytes':{pointer+j:0 for j in range(6336)}}
- def fresh(i,m,a,bs):
-  choice.append(247520);m,p,b=initialize(i,m,dict(bs),a[8],userinfo,handle,17);parts.update(p);return m,0,{'actual_source_child':247520}
- def restored(i,m,a,bs):
-  choice.append(247219);data=b'9,8,7,6,5,4';m,p,b=restore_session(i,m,dict(bs),a[8],b'1,-2,3,4,5,1,1,1,1',b'1,3,',userinfo,b'ut4_test',handle,len(data),data);parts.update(p);return m,0,{'actual_source_child':247219}
- m,v,p,b=run(ins,m,174080,174174,1080,{8:slot,12:first,16:0},b,{-101:zero,247520:fresh,247219:restored},base=CONNECT);changes=p.pop('changes');p.update(change_count=len(changes),changes_sha256=hashlib.sha256(json.dumps(changes,sort_keys=True).encode()).hexdigest(),choice=choice,parts=parts,entity_linked=m[entity+520]==pointer,entity_clear=[m[entity+764]&0xffffffff,m[entity+768]&0xffffffff]);return m,p,b
+def probe(ins,m,start,stop,protected=False,resolvers=None):
+    before=snapshot(m);effects={'events':[],'requests':[]};end=152671 if protected else 207154
+    m,e=resume(ins,start,end,m,L,handlers=handlers(effects,resolvers),boundaries=[] if stop==end else [stop],limit=50000)
+    return m,{'initial':before,'final':snapshot(m),'effects':effects,'events':[{**v,'fields':{str(o):m[v['pointer']+o]&0xffffffff for o in EFIELDS}} for v in effects['events']],'execution':e}

scripts/qvm_session_lifecycle_support.py

@@ -0,0 +1,52 @@
+"""Recovered session initialization and connected persistence compositions."""
+from qvm_camera_world_support import B,run
+from qvm_exit_rules_support import CPOOL
+from qvm_persistence_support import info_lookup,load_position,save_position
+from qvm_session_support import session,FIELDS
+from qvm_string_memory_support import cstring,copy_bounded
+from qvm_byte_memory_support import read_bytes
+INIT=B+0x50000
+SIZE=944
+
+def initialize(ins,m,b,pointer,userinfo,handle,ticks):
+ from qvm_persistence_support import INFO
+ from qvm_map_commands_support import put_string
+ put_string(m,b,INFO,userinfo);parts={};diagnostics=[]
+ def classify(i,m,a,bs):
+  m,v,p,b=run(i,m,33715,33740,12,a,dict(bs),base=B+0x52000);return m,v,{'actual_source_child':33715}
+ def lookup(i,m,a,bs):
+  m,v,p,b=info_lookup(i,m,dict(bs),a);return m,v,{'actual_source_child':70503,'child_memory_bytes':{v+j:x for j,x in enumerate(cstring(m,b,v)+b'\0')}}
+ def clock(i,m,a,bs):return m,ticks,{'engine_ticks_supplied':True}
+ def copy(i,m,a,bs):return copy_bounded(i,m,a,dict(bs))
+ def load(i,m,a,bs):
+  data=b'9,8,7,6,5,4';m,p,b=load_position(i,m,dict(bs),a[8],userinfo,b'ut4_test',handle,len(data),data);parts['load']=p;return m,0,{'actual_source_child':246554}
+ def write(i,m,a,bs):
+  m,p,b=session(i,m,dict(bs),a[8]);parts['session']=p;return m,0,{'actual_source_child':246963}
+ def diagnostic(i,m,a,bs):diagnostics.append([a[8],a[12]&0xffffffff,a[16]&0xffffffff]);return m,0,{'diagnostic_captured':True}
+ m,v,p,b=run(ins,m,247520,247806,40,{8:pointer,12:INFO},b,{33715:classify,70503:lookup,-3:clock,69338:copy,246554:load,246963:write,7259:diagnostic},base=INIT);p.update(parts=parts,diagnostics=diagnostics);return m,p,b
+
+def raw_state(m,b,pointer):return read_bytes(m,b,pointer+3096,SIZE).hex()
+
+def post_full(ins,m,b,userinfos,names,handles):
+ calls=[];files=[];sets=[];actions=[]
+ def save(i,m,a,bs):
+  j=(a[8]-CPOOL)//6336;calls.append([246746,j]);m,p,b=save_position(i,m,dict(bs),a[8],userinfos[j],b'ut4_test',handles[j],-7);files.append([j,p['events']]);actions.extend(dict(e,kind='file',slot=j) for e in p['events']);return m,0,{'actual_source_child':246746}
+ def write(i,m,a,bs):
+  j=(a[8]-CPOOL)//6336;calls.append([246963,j]);m,p,b=session(i,m,dict(bs),a[8]);sets.extend(p['sets']);actions.extend(dict(kind='cvar',slot=j,key=k,value=v) for k,v in p['sets']);return m,0,{'actual_source_child':246963}
+ m,v,p,b=run(ins,m,249007,249058,16,b=b,handlers={246746:save,246963:write},base=B+0x54000);p.update(calls=calls,files=files,sets=sets,actions=actions);return m,p,b
+
+CONNECT=B+0x58000
+CLIENT_BYTES=6336
+def connect_branch(ins,m,b,slot,first,userinfo,handle):
+ import hashlib,json
+ from qvm_map_commands_support import put_string
+ from qvm_persistence_support import restore_session
+ entity=34091368+880*slot;pointer=CPOOL+6336*slot;m[CONNECT+24]=entity;put_string(m,b,CONNECT+28,userinfo,1024);parts={};choice=[]
+ def zero(i,m,a,bs):
+  if a[8]!=pointer or a[12]!=0 or a[16]!=6336:raise ValueError('unsupported connect memset')
+  return m,a[8],{'native_memset_modeled':True,'child_memory_bytes':{pointer+j:0 for j in range(6336)}}
+ def fresh(i,m,a,bs):
+  choice.append(247520);m,p,b=initialize(i,m,dict(bs),a[8],userinfo,handle,17);parts.update(p);return m,0,{'actual_source_child':247520}
+ def restored(i,m,a,bs):
+  choice.append(247219);data=b'9,8,7,6,5,4';m,p,b=restore_session(i,m,dict(bs),a[8],b'1,-2,3,4,5,1,1,1,1',b'1,3,',userinfo,b'ut4_test',handle,len(data),data);parts.update(p);return m,0,{'actual_source_child':247219}
+ m,v,p,b=run(ins,m,174080,174174,1080,{8:slot,12:first,16:0},b,{-101:zero,247520:fresh,247219:restored},base=CONNECT);changes=p.pop('changes');p.update(change_count=len(changes),changes_sha256=hashlib.sha256(json.dumps(changes,sort_keys=True).encode()).hexdigest(),choice=choice,parts=parts,entity_linked=m[entity+520]==pointer,entity_clear=[m[entity+764]&0xffffffff,m[entity+768]&0xffffffff]);return m,p,b

scripts/test_qvm_session_init.py

@@ -4,6 +4,7 @@ class OriginalTests(unittest.TestCase):
  def test_instruction_results(self):
   rows=json.loads(Path('docs/research/qvm-session-init.json').read_text())['probes']
   self.assertEqual(len(rows),96)
+  self.assertTrue(any(int.from_bytes(bytes.fromhex(p["raw"])[44:48],"little")>=2**31 for p in rows))
   import struct
   from analyze_qvm_acceleration import word
   for p in rows:

scripts/test_rust_connect_session.py

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

@@ -2887,3 +2887,21 @@ report	scripts/analyze_qvm_connect_session.py	docs/research/qvm-connect-session.
 edge	docs/research/qvm-connect-session.json	scripts/test_qvm_connect_session.py
 group	qvm-connect-session	scripts/analyze_qvm_connect_session.py
 edge	scripts/analyze_qvm_connect_session.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_connect_session.py
+edge	Cargo.lock	scripts/analyze_rust_connect_session.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_connect_session.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_connect_session.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_connect_session.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_connect_session.py
+edge	docs/research/qvm-connect-session.json	scripts/analyze_rust_connect_session.py
+group	rust-connect-session	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_connect_session.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_connect_session.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_connect_session.py
+report	scripts/analyze_rust_connect_session.py	docs/research/rust-connect-session.json
+edge	docs/research/rust-connect-session.json	scripts/test_rust_connect_session.py
+group	rust-connect-session	scripts/analyze_rust_connect_session.py
+edge	scripts/analyze_rust_connect_session.py	scripts/analyze_qvm_resumer_audit.py
+group	rust-connect-session	scripts/analyze_qvm_session_init.py
+edge	scripts/qvm_session_lifecycle_support.py	scripts/analyze_qvm_resumer_audit.py
+group	rust-connect-session	scripts/analyze_qvm_health_mode10.py

xtask/src/lib.rs

@@ -1055,6 +1055,10 @@ mod integration_tests {
         .unwrap();
         g.scanner(&output).unwrap();
         assert!(g.warnings.is_empty(), "{:?}", g.warnings);
+        // Keep independent health and session helper namespaces importable.
+        // A filename collision must fail this scoped registry regression.
+        capture(root,&Cmd::new(&python_runtime().expect("run cargo test inside nix develop"),["-I","-c","import sys; sys.path.insert(0, 'scripts'); from qvm_lifecycle_support import seed, probe; from qvm_session_lifecycle_support import initialize, post_full, connect_branch"])).unwrap();
+
         let health = plan(
             &g,
             &["scripts/qvm_health_support.py".into()]
@@ -1105,6 +1109,14 @@ mod integration_tests {
             ("native_policy", "position_load"),
             ("native_policy", "session_restore"),
             ("intermission", "session_restore"),
+            ("native_policy", "session_init"),
+            ("native_policy", "post_map_files"),
+            ("native_policy", "normal_map_files"),
+            ("native_policy", "persistence_roundtrip"),
+            ("native_policy", "connect_session"),
+            ("map_commands", "normal_map_files"),
+            ("transition", "normal_map_files"),
+            ("intermission", "connect_session"),
             ("protected", "protected_update"),
             ("mode10", "mode10_entry"),
             ("intercept_animation", "mode10_animation"),
@@ -1179,6 +1191,11 @@ mod integration_tests {
             ("qvm-position-save", "position_save"),
             ("qvm-position-load", "position_load"),
             ("qvm-session-restore", "session_restore"),
+            ("qvm-session-init", "session_init"),
+            ("qvm-post-map-files", "post_map_files"),
+            ("qvm-normal-map-files", "normal_map_files"),
+            ("qvm-persistence-roundtrip", "persistence_roundtrip"),
+            ("qvm-connect-session", "connect_session"),
             ("qvm-rank-small-sort", "rank_sort"),
             ("qvm-rank-large-sort", "rank_sort"),
             ("qvm-ranking-complete", "ranking_complete"),