gameplay: compose complete connect caller policy

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

@@ -873,6 +873,92 @@ fn run() -> Result<String, String> {
             .map_err(|e| format!("{e:?}"))?;
             Ok(tail_json(&out, &client, &entity))
         }
+        "connect-complete" => {
+            if w.len() < 9 {
+                return Err("missing complete header".into());
+            }
+            let n = w[8] as usize;
+            if n > 1024 || w.len() < 9 + 2 * n {
+                return Err("invalid complete table".into());
+            }
+            let entries = w[9..9 + 2 * n]
+                .chunks_exact(2)
+                .map(|v| (v[0], v[1]))
+                .collect::<Vec<_>>();
+            let mut p = 9 + 2 * n;
+            let info = input_blob(&w, &mut p)?.ok_or("null complete info")?;
+            let password = input_blob(&w, &mut p)?.ok_or("null complete password")?;
+            if p != w.len() {
+                return Err("trailing complete words".into());
+            }
+            let mut client = 0xaabbccddu32.to_le_bytes().repeat(1584);
+            client[504..516].fill(0);
+            client[504..507].copy_from_slice(b"old");
+            let mut entity = CompleteConnectEntity {
+                session: ConnectEntity {
+                    linked_slot: None,
+                    field764: 0xaabbccdd,
+                    field768: 0xaabbccdd,
+                },
+                tail: ConnectTailEntity {
+                    flags: 32,
+                    in_use: 0,
+                },
+            };
+            let mut ring = 0;
+            let out = complete_connect(
+                &mut client,
+                &mut entity,
+                CompleteConnectInput {
+                    admission: AdmissionInput {
+                        slot: 3,
+                        bot: w[3] as i32,
+                        userinfo: &info,
+                        password: &password,
+                        entries: &entries,
+                        count: n as i32,
+                        mode: 1,
+                        scratch: w[6],
+                    },
+                    first_time: w[1] as i32,
+                    new_session: w[2] as i32,
+                    flags: 1,
+                    initialize: InitializeInput {
+                        mode: w[0] as i32,
+                        slot: 3,
+                        userinfo: &info,
+                        limit: 2,
+                        occupancy: 1,
+                        seconds: 0,
+                        clock: 100,
+                        ticks: 17,
+                        handle: 7,
+                        client_id: 0,
+                        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[5]; 5],
+                    tail: ConnectTailInput {
+                        mode: w[0] as i32,
+                        slot: 3,
+                        first_time: w[1] as i32,
+                        bot: w[3] as i32,
+                        bot_answer: w[4] as i32,
+                        clock: 100,
+                        seconds: 0,
+                        after_team: if w[7] != 0 { Some(2) } else { None },
+                        name: b"new^1name",
+                    },
+                },
+                &mut ring,
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            Ok(complete_json(&out, &client, &entity, ring))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -1258,3 +1344,66 @@ fn tail_json(out: &ConnectTail, client: &[u8], entity: &ConnectTailEntity) -> St
         out.ring_advance
     )
 }
+
+fn complete_json(
+    out: &CompleteConnect,
+    client: &[u8],
+    entity: &CompleteConnectEntity,
+    ring: u32,
+) -> String {
+    let message = out
+        .message
+        .as_ref()
+        .map(|v| format!(r#""{}""#, hex(v)))
+        .unwrap_or("null".into());
+    let steps = out
+        .admission
+        .steps
+        .iter()
+        .map(|v| format!(r#""{v}""#))
+        .collect::<Vec<_>>()
+        .join(",");
+    let filter = out
+        .admission
+        .filter
+        .as_ref()
+        .map(|f| {
+            format!(
+                r#"{{"filter_result":{},"parsed":{}}}"#,
+                u32::from(f.rejected),
+                f.parsed.map(|v| v.to_string()).unwrap_or("null".into())
+            )
+        })
+        .unwrap_or("{}".into());
+    let (choice, sets, reads) = if let Some(life) = &out.lifecycle {
+        (
+            format!("[{}]", if life.fresh { 247520 } else { 247219 }),
+            life.initialized
+                .as_ref()
+                .map(|v| sets_json(&v.session.sets))
+                .unwrap_or("[]".into()),
+            life.restored
+                .as_ref()
+                .map(|v| sets_json(&v.cvars))
+                .unwrap_or("[]".into()),
+        )
+    } else {
+        ("[]".into(), "[]".into(), "[]".into())
+    };
+    let checksum = client.iter().fold(14695981039346656037u64, |v, b| {
+        (v ^ *b as u64).wrapping_mul(1099511628211)
+    });
+    format!(
+        r#"{{"accepted":{},"message":{message},"steps":[{steps}],"filter":{filter},"events":{},"choice":{choice},"raw":"{}","client_checksum":{checksum},"words":{},"entity":[{},{},{},{},{}],"sets":{sets},"reads":{reads},"ring":{},"info_ring":{ring}}}"#,
+        out.accepted,
+        tail_events(&out.events),
+        hex(&client[3096..4040]),
+        watched_words(client),
+        entity.tail.flags,
+        entity.tail.in_use as u32,
+        entity.session.field764,
+        entity.session.field768,
+        u32::from(entity.session.linked_slot == Some(3)),
+        out.ring_advance
+    )
+}

crates/urt-gameplay/src/native_policy.rs

@@ -2515,3 +2515,175 @@ mod connect_tail_tests {
         assert_eq!(raw_word(&raw, 3140), 100);
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CompleteConnectEntity {
+    pub session: ConnectEntity,
+    pub tail: ConnectTailEntity,
+}
+pub struct CompleteConnectInput<'a> {
+    pub admission: AdmissionInput<'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],
+    pub tail: ConnectTailInput<'a>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CompleteConnect {
+    pub admission: Admission,
+    pub lifecycle: Option<ConnectedSession>,
+    pub tail: Option<ConnectTail>,
+    pub accepted: bool,
+    pub message: Option<Vec<u8>>,
+    pub events: Vec<ConnectTailEvent>,
+    pub ring_advance: u32,
+}
+/// Compose the complete173979 policy. Ordinary denial is a source return, not
+/// a typed error: auth denial changes only the selector; bot denial keeps prior
+/// lifecycle/entity changes. Unsupported domains stage all state atomically.
+pub fn complete_connect(
+    client: &mut [u8],
+    entity: &mut CompleteConnectEntity,
+    input: CompleteConnectInput<'_>,
+    info_ring: &mut u32,
+) -> Result<CompleteConnect, Error> {
+    if client.len() != CLIENT_BYTES
+        || input.admission.slot != input.initialize.slot
+        || input.tail.slot != input.initialize.slot
+        || input.tail.mode != input.initialize.mode
+        || input.tail.first_time != input.first_time
+        || input.tail.bot != input.admission.bot
+    {
+        return Err(Error::InvalidInput);
+    }
+    let mut selector = *info_ring;
+    let admission = admit_connect(input.admission, &mut selector)?;
+    if !admission.accepted {
+        let message = admission.message.clone();
+        *info_ring = selector;
+        return Ok(CompleteConnect {
+            admission,
+            lifecycle: None,
+            tail: None,
+            accepted: false,
+            message,
+            events: vec![],
+            ring_advance: 0,
+        });
+    }
+    let mut bytes = client.to_vec();
+    let mut e = entity.clone();
+    let lifecycle = connect_session(
+        &mut bytes,
+        &mut e.session,
+        ConnectInput {
+            first_time: input.first_time,
+            new_session: input.new_session,
+            flags: input.flags,
+            initialize: input.initialize,
+            session: input.session,
+            ignore_text: input.ignore_text,
+            scratch: input.scratch,
+        },
+        &mut selector,
+    )?;
+    let tail = finish_connect(&mut bytes, &mut e.tail, input.tail)?;
+    let accepted = tail.accepted;
+    let message = tail.message.clone();
+    let mut events = vec![ConnectTailEvent::Zero {
+        offset: 0,
+        length: CLIENT_BYTES,
+    }];
+    events.extend(tail.events.clone());
+    let ring_advance = lifecycle.ring_advance + tail.ring_advance;
+    client.copy_from_slice(&bytes);
+    *entity = e;
+    *info_ring = selector;
+    Ok(CompleteConnect {
+        admission,
+        lifecycle: Some(lifecycle),
+        tail: Some(tail),
+        accepted,
+        message,
+        events,
+        ring_advance,
+    })
+}
+#[cfg(test)]
+mod complete_connect_tests {
+    use super::*;
+    #[test]
+    fn invalid_record_is_atomic_before_admission() {
+        let mut bytes = [];
+        let mut entity = CompleteConnectEntity {
+            session: ConnectEntity {
+                linked_slot: None,
+                field764: 7,
+                field768: 8,
+            },
+            tail: ConnectTailEntity {
+                flags: 32,
+                in_use: 0,
+            },
+        };
+        let before = entity.clone();
+        let mut ring = 0;
+        let result = complete_connect(
+            &mut bytes,
+            &mut entity,
+            CompleteConnectInput {
+                admission: AdmissionInput {
+                    slot: 0,
+                    bot: 0,
+                    userinfo: b"",
+                    password: b"",
+                    entries: &[],
+                    count: 0,
+                    mode: 1,
+                    scratch: 0,
+                },
+                first_time: 0,
+                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: 0,
+                    mapname: b"m",
+                    file_length: 0,
+                    file_data: b"",
+                },
+                session: b"",
+                ignore_text: b"",
+                scratch: [0; 5],
+                tail: ConnectTailInput {
+                    mode: 0,
+                    slot: 0,
+                    first_time: 0,
+                    bot: 0,
+                    bot_answer: 1,
+                    clock: 0,
+                    seconds: 0,
+                    after_team: None,
+                    name: b"n",
+                },
+            },
+            &mut ring,
+        );
+        assert_eq!(result, Err(Error::InvalidInput));
+        assert_eq!(entity, before);
+        assert_eq!(ring, 0);
+    }
+}

docs/FINDINGS.md

@@ -1766,3 +1766,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-922:** 96 complete173979 executions compose actual userinfo/address/password admission, native client-clear boundary,247520 initialization or247219 restore, team normalization and bot/callback completion. Ordinary authentication rejection preserves client/entity state; bot rejection occurs after lifecycle side effects. Initializer-persisted timeout can precede a first-time overwrite. Client-wide checksums, watched bytes, exact messages, cvar order and selector/formatter carry are verified. Native admission/userinfo/team/ranking/IO/network callbacks remain supplied/captured; this is not native multiplayer acceptance. [Evidence](research/QVM_CONNECT_COMPLETE.md).
+
+
+**RE-923:** Rust matches96 complete173979 executions across admission, client clear, initialization/restore, bot admission and callback completion. Auth denial preserves client/entity state; bot denial retains lifecycle effects. Source messages, cvar timing, full-client checksums, raw watched bytes and selector/formatter carry match. Native callback bodies, actual network/IO acceptance and runtime integration remain open. [Evidence](research/RUST_CONNECT_COMPLETE.md).

docs/PROVISIONAL_TODO.md

@@ -1806,3 +1806,9 @@ RE-921: Rust matches144 original173979 suffix cases with ordered bot admission,
 
 
 RE-922: 96 complete173979 executions compose actual userinfo/address/password admission, native client-clear boundary,247520 initialization or247219 restore, team normalization and bot/callback completion. Ordinary authentication rejection preserves client/entity state; bot rejection occurs after lifecycle side effects. Initializer-persisted timeout can precede a first-time overwrite. Client-wide checksums, watched bytes, exact messages, cvar order and selector/formatter carry are verified. Native admission/userinfo/team/ranking/IO/network callbacks remain supplied/captured; this is not native multiplayer acceptance. Full runtime completion remains open. [Evidence](research/QVM_CONNECT_COMPLETE.md).
+
+
+RE-923: Rust matches96 complete173979 executions across admission, client clear, initialization/restore, bot admission and callback completion. Auth denial preserves client/entity state; bot denial retains lifecycle effects. Source messages, cvar timing, full-client checksums, raw watched bytes and selector/formatter carry match. Native callback bodies, actual network/IO acceptance and runtime integration remain open. Full runtime completion remains open. [Evidence](research/RUST_CONNECT_COMPLETE.md).
+
+
+RE-914–923 completed bounded comparison/filter/admission/completion and whole173979 caller composition. RE-924 tracks concrete callback bodies, filter writers, native engine ownership and full runtime integration. [Batch and next work](research/QVM_CONNECT_POLICY_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -2335,3 +2335,13 @@ Rust matches144 original173979 suffix cases with ordered bot admission, first-ti
 ## 2026-10-28 — RE-922 Complete original connect caller with recovered admission/lifecycle/tail
 
 96 complete173979 executions compose actual userinfo/address/password admission, native client-clear boundary,247520 initialization or247219 restore, team normalization and bot/callback completion. Ordinary authentication rejection preserves client/entity state; bot rejection occurs after lifecycle side effects. Initializer-persisted timeout can precede a first-time overwrite. Client-wide checksums, watched bytes, exact messages, cvar order and selector/formatter carry are verified. Native admission/userinfo/team/ranking/IO/network callbacks remain supplied/captured; this is not native multiplayer acceptance. Focused `cargo xtask test-group qvm-connect-complete` passes (13 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-923 Rust complete connect policy composition
+
+Rust matches96 complete173979 executions across admission, client clear, initialization/restore, bot admission and callback completion. Auth denial preserves client/entity state; bot denial retains lifecycle effects. Source messages, cvar timing, full-client checksums, raw watched bytes and selector/formatter carry match. Native callback bodies, actual network/IO acceptance and runtime integration remain open. Focused `cargo xtask test-group rust-connect-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-914–923 full batch validation (2026-10-28)
+
+After the tenth commit, `cargo xtask test-full --since 2b1ac7ec` passed on its first full attempt with the flake-declared Nix Python: 1,783 Python tests,216 Rust tests (assets10, gameplay176, xtask30),32 affected report producers regenerated twice deterministically, storage policy,491 documentation link checks and whitespace guards. No generated-report drift. Ten task commits since2b1ac7ec; validation notes are amended into the tenth commit. [Findings and next work](research/QVM_CONNECT_POLICY_BATCH.md).

docs/REVERSE_ENGINEERING_TODO.md

@@ -1815,7 +1815,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [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)).
+- [ ] Follow-up after RE-913: complete connect authentication/normalization, native IO/reload, scanner/alias domains and full runtime integration ([next work](research/QVM_SESSION_LIFECYCLE_BATCH.md)).
 
 
 - [x] RE-914 Original unsigned byte string comparison ([evidence](research/QVM_BYTE_COMPARE.md)).
@@ -1843,3 +1843,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-922 Complete original connect caller with recovered admission/lifecycle/tail ([evidence](research/QVM_CONNECT_COMPLETE.md)).
+
+
+- [x] RE-923 Rust complete connect policy composition ([evidence](research/RUST_CONNECT_COMPLETE.md)).
+
+
+- [ ] RE-924 Recover bot/userinfo/team/ranking callback bodies, filter writers and native engine acceptance, with remaining scalar/alias and full runtime integration ([next work](research/QVM_CONNECT_POLICY_BATCH.md)).

docs/TESTING.md

@@ -169,3 +169,6 @@ RE-894–903 adds focused groups `qvm-info-lookup`, `rust-info-lookup`, `qvm-num
 
 
 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).
+
+
+RE-914–923 adds `qvm-byte-compare`, `rust-byte-compare`, `qvm-address-filter`, `rust-address-filter`, `qvm-connect-admission`, `rust-connect-admission`, `qvm-connect-tail`, `rust-connect-tail`, `qvm-connect-complete` and `rust-connect-complete`. Invoke one group per command. Full validation after task ten uses `cargo xtask test-full --since 2b1ac7ec` with explicit flake-declared Nix PYTHON. [Bounded connect evidence](research/QVM_CONNECT_POLICY_BATCH.md).

docs/research/QVM_CONNECT_POLICY_BATCH.md

@@ -0,0 +1,55 @@
+# Complete connect caller policy: RE-914–923
+
+Ten separately committed tasks recover admission and completion policies and compose the entire original173979 QVM caller across926 paired source/Rust cases. The caller body executes, while bot admission, userinfo changes, team joining, ranking, engine buffers, files, logging and network sends remain supplied/captured boundaries. These finite policies do not establish native multiplayer acceptance or a complete playable game.
+
+| Task | Evidence | Cases |
+| --- | --- | ---: |
+| RE-914 | [Unsigned36306 comparison](QVM_BYTE_COMPARE.md) | 256 |
+| RE-915 | [Rust exact byte comparison](RUST_BYTE_COMPARE.md) | 256 |
+| RE-916 | [Address252643 parsing/filtering](QVM_ADDRESS_FILTER.md) | 270 |
+| RE-917 | [Rust address/scratch policy](RUST_ADDRESS_FILTER.md) | 270 |
+| RE-918 | [173979 admission prefix](QVM_CONNECT_ADMISSION.md) | 160 |
+| RE-919 | [Rust admission order](RUST_CONNECT_ADMISSION.md) | 160 |
+| RE-920 | [173979 completion suffix](QVM_CONNECT_TAIL.md) | 144 |
+| RE-921 | [Rust completion policy](RUST_CONNECT_TAIL.md) | 144 |
+| RE-922 | [Complete173979 caller](QVM_CONNECT_COMPLETE.md) | 96 |
+| RE-923 | [Rust complete caller composition](RUST_CONNECT_COMPLETE.md) | 96 |
+
+## Strings, addresses and admission
+
+Actual36306 compares words but returns the unsigned-byte difference at the first differing character. It is case-sensitive, terminates at NUL and is distinct from the previously recovered69386 case-folded comparison. Fixtures cover four pointer alignments, embedded NUL, case and high-byte differences. Guard bytes are explicit fixture memory; arbitrary pointer validity/aliases remain open.
+
+Actual252643 first compares the input with exact lowercase localhost and bypasses filtering on that match. Otherwise it constructs up to four bytes at a caller-stack word. Each numeric component wraps modulo256; any single non-digit separator advances the component index, while colon or NUL ends parsing. Short/empty strings leave explicitly supplied prior bytes in untouched components. Thus this body is not strict IP validation. The result is a little-endian word tested against mask/value entries at36275952/36275956 with stride12 and signed count36275948. Nonzero34082796 returns true on a match; zero mode returns true on a miss. Negative counts skip scanning. Table population, raw network provenance and actual scratch provenance remain open.
+
+The173979 prefix fetches userinfo first. A nonzero bot argument bypasses both address and password checks. Other clients look up ip, invoke the actual filter and return exact Banned. text before any password lookup when rejected. If permitted, password is looked up even when the server password is empty. Nonempty server passwords are compared case-insensitively with none; other values invoke exact36306 comparison against the supplied password. Mismatch returns Invalid password. Rejection precedes entity/client initialization. Userinfo buffer selectors carry in the actual lookup order.
+
+## Completion ordering and partial rejection state
+
+After the recovered initialize/restore branch, the caller normalizes team3096: team-classified modes replace zero with3; other modes replace values other than3 with0. Bot paths then set entity flag8 and in-use1 before requesting161744 with restart=!firstTime. A zero supplied result returns exact BotConnectfailed text after those mutations. The Rust policy preserves that ordinary rejection state; typed unsupported-domain errors stage state instead.
+
+Successful first-time paths clear client668..695 and compute timeout3140 as clock+seconds*1000, with no initializer60-second default. They log, clear3588 and the3204..3587 message regions, then request171668 userinfo processing. Fixtures supply the resulting team/name changes. The first-time connection announcement uses that updated name and exact original70458/37914 formatting: the logical native command includes its print wrapper, quotes and newline. The Rust boundary removes the formatter's terminating NUL from its logical command bytes. A second team classification/decision observes the updated team, optionally requests182896 with choice-1, and5864 ranking is requested last. Native callback bodies and their arbitrary global effects remain open.
+
+## Whole caller composition
+
+The96 complete original173979 executions combine admission, client/entity clear, actual247520 initialization or247219 restore, bot admission and completion. The corpus includes ordinary auth denial, localhost, partial addresses with supplied scratch, bot bypass/failure, negative new-session control, both lifecycle choices and mode0/3/9. Full6336-byte client checksums accompany watched words, the944-byte session block, entity state, exact messages, ordered events/cvar writes/reads and selector/formatter carry. The checksum is an FNV-1a coverage check, not a cryptographic identity claim.
+
+Authentication denial leaves client/entity state intact. Bot rejection occurs later and retains prior lifecycle effects, including cvar/file intentions. Initialization can serialize timeout60100 before a first-time suffix overwrites the in-memory value with100; no second persistence write occurs in this caller. Stable engine userinfo snapshots are supplied across nested reads in this corpus. Mutating globals/counts between callbacks, raw VM pointer aliasing and native engine resource/network behavior remain outside the verified domain.
+
+The new helper qvm_connect_policy_support.py has a distinct filename. Original packed string regions are seeded directly from the verified QVM image, including initializer literals needed by the whole-call composition. Independent Python state/event oracles and Rust parity caught logical string boundary issues before commit. No original game binary or asset payload was modified.
+
+## Validation
+
+Every task ran focused `cargo xtask test-group <name>` before its own commit, with deterministic double regeneration, relevant source/Rust parity, scoped gameplay tests and storage/documentation/whitespace checks. Groups are qvm-byte-compare, rust-byte-compare, qvm-address-filter, rust-address-filter, qvm-connect-admission, rust-connect-admission, qvm-connect-tail, rust-connect-tail, qvm-connect-complete and rust-connect-complete. Shared admission/address/tail helpers also received focused regression checks.
+
+Dependency-selection regression coverage includes the five new source/Rust report pairs, native_policy consumers and intermission/formatting dependencies. The existing health/session helper import smoke check remains in place. Every Python process uses the resolved Nix runtime declared by flake.nix, with explicit PYTHON for xtask and Git hooks. After commit ten, `cargo xtask test-full --since 2b1ac7ec` passed on its first full attempt: 1,783 Python tests and216 Rust tests (assets10, gameplay176, xtask30). All32 affected report producers regenerated twice deterministically. Storage policy, links across491 documentation files and whitespace checks passed with no generated-report drift. Validation notes were amended into task ten.
+
+## Next work: RE-924
+
+- [ ] Recover161744 bot admission,171668 userinfo mutation and182896 team-join callback bodies, then compose them with173979 and actual5864 ranking/publication.
+- [ ] Recover address-filter table writers and native IP/userinfo provenance; verify partial-address stack provenance, aliases, malformed counts and live configuration changes.
+- [ ] Recover native logging/network/cvar/file-open and handle ownership, attach real engine adapters and validate actual connect/reload/failure behavior on macOS/Linux.
+- [ ] Extend scalar/string domains: non-ASCII tails, uppercase exponents, remaining scanf conversions, oversized/fatal strings and native pointer boundaries.
+- [ ] Compose both persistence children into series6939/readiness, native command dispatch, bot rotation/genetics and221662 map-list parsing.
+- [ ] Replace supplied spatial-query answers with recovered native broadphase/world collision and compare native math.
+- [ ] Compose complete respawn/intermission, event lifetime and scoreboard/network execution.
+- [ ] Validate actual Linux/macOS Rust/Bevy/Solari gameplay/rendering. Full-game completion remains open.

docs/research/QVM_SESSION_LIFECYCLE_BATCH.md

@@ -43,7 +43,7 @@ Focused `cargo xtask test-group <name>` ran before each commit, with selected re
 
 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
+## Follow-up work (expanded by RE-914–923)
 
 - [ ] 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.
@@ -53,3 +53,5 @@ The dependency-selection regression covers the five source/Rust report pairs, na
 - [ ] 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.
+
+[RE-914–923](QVM_CONNECT_POLICY_BATCH.md) recovers admission/completion and composes the complete bounded173979 caller. Its RE-924 list supersedes the historical follow-up list above.

docs/research/README.md

@@ -1378,3 +1378,9 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-922: Complete original connect caller with recovered admission/lifecycle/tail](QVM_CONNECT_COMPLETE.md).
+
+
+[RE-923: Rust complete connect policy composition](RUST_CONNECT_COMPLETE.md).
+
+
+[RE-914–923 complete connect caller policy batch](QVM_CONNECT_POLICY_BATCH.md).

docs/research/RUST_CONNECT_COMPLETE.md

@@ -0,0 +1,7 @@
+# Rust complete connect policy composition
+
+RE-923. Reproduce with `python3 scripts/analyze_rust_connect_complete.py`; focused validation: `cargo xtask test-group rust-connect-complete`. [Machine report](rust-connect-complete.json).
+
+Rust matches96 complete173979 executions across admission, client clear, initialization/restore, bot admission and callback completion. Auth denial preserves client/entity state; bot denial retains lifecycle effects. Source messages, cvar timing, full-client checksums, raw watched bytes and selector/formatter carry match. Native callback bodies, actual network/IO acceptance and 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": 175,
+  "rust_unit_tests": 176,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_connect_complete.py

@@ -0,0 +1,15 @@
+#!/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 blob(s):return [len(bytes.fromhex(s)),*bytes.fromhex(s)]
+def encode(s):
+ a=s['input'];return [a[k] for k in ['mode','first','new','bot','answer','scratch','filter_scratch','changed']]+[len(a['entries']),*[v for row in a['entries'] for v in row],*blob(a['userinfo']),*blob(a['password'])]
+def project(s):return {k:s[k] for k in ['accepted','message','steps','filter','events','choice','raw','client_checksum','words','entity','sets','reads','ring','info_ring']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-connect-complete.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'connect-complete',encode(s))})
+ write_json(Path('docs/research/rust-connect-complete.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches96 complete173979 executions across admission, client clear, initialization/restore, bot admission and callback completion. Auth denial preserves client/entity state; bot denial retains lifecycle effects. Source messages, cvar timing, full-client checksums, raw watched bytes and selector/formatter carry match. Native callback bodies, actual network/IO acceptance and runtime integration remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_connect_complete.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-complete.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-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

@@ -2990,3 +2990,18 @@ edge	scripts/analyze_qvm_connect_complete.py	scripts/analyze_qvm_resumer_audit.p
 edge	scripts/qvm_connect_complete_oracle.py	scripts/analyze_qvm_resumer_audit.py
 group	qvm-connect-complete	scripts/analyze_qvm_connect_admission.py
 group	qvm-connect-complete	scripts/analyze_qvm_address_filter.py
+edge	Cargo.toml	scripts/analyze_rust_connect_complete.py
+edge	Cargo.lock	scripts/analyze_rust_connect_complete.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_connect_complete.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_connect_complete.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_connect_complete.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_connect_complete.py
+edge	docs/research/qvm-connect-complete.json	scripts/analyze_rust_connect_complete.py
+group	rust-connect-complete	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_connect_complete.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_connect_complete.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_connect_complete.py
+report	scripts/analyze_rust_connect_complete.py	docs/research/rust-connect-complete.json
+edge	docs/research/rust-connect-complete.json	scripts/test_rust_connect_complete.py
+group	rust-connect-complete	scripts/analyze_rust_connect_complete.py
+edge	scripts/analyze_rust_connect_complete.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1117,6 +1117,12 @@ mod integration_tests {
             ("map_commands", "normal_map_files"),
             ("transition", "normal_map_files"),
             ("intermission", "connect_session"),
+            ("native_policy", "byte_compare"),
+            ("native_policy", "address_filter"),
+            ("native_policy", "connect_admission"),
+            ("native_policy", "connect_tail"),
+            ("native_policy", "connect_complete"),
+            ("intermission", "connect_complete"),
             ("protected", "protected_update"),
             ("mode10", "mode10_entry"),
             ("intercept_animation", "mode10_animation"),
@@ -1196,6 +1202,11 @@ mod integration_tests {
             ("qvm-normal-map-files", "normal_map_files"),
             ("qvm-persistence-roundtrip", "persistence_roundtrip"),
             ("qvm-connect-session", "connect_session"),
+            ("qvm-byte-compare", "byte_compare"),
+            ("qvm-address-filter", "address_filter"),
+            ("qvm-connect-admission", "connect_admission"),
+            ("qvm-connect-tail", "connect_tail"),
+            ("qvm-connect-complete", "connect_complete"),
             ("qvm-rank-small-sort", "rank_sort"),
             ("qvm-rank-large-sort", "rank_sort"),
             ("qvm-ranking-complete", "ranking_complete"),