gameplay: port connect completion callback order

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

@@ -843,6 +843,36 @@ fn run() -> Result<String, String> {
             .map_err(|e| format!("{e:?}"))?;
             Ok(admission_json(&out, ring))
         }
+        "connect-tail" => {
+            if w.len() != 8 {
+                return Err("invalid tail words".into());
+            }
+            let mut client = 0xaabbccddu32.to_le_bytes().repeat(1584);
+            client[3096..3100].copy_from_slice(&w[1].to_le_bytes());
+            client[504..516].fill(0);
+            client[504..507].copy_from_slice(b"old");
+            let mut entity = ConnectTailEntity {
+                flags: 32,
+                in_use: 0,
+            };
+            let out = finish_connect(
+                &mut client,
+                &mut entity,
+                ConnectTailInput {
+                    mode: w[0] as i32,
+                    slot: 3,
+                    first_time: w[3] as i32,
+                    bot: w[2] as i32,
+                    bot_answer: w[4] as i32,
+                    clock: w[6] as i32,
+                    seconds: w[7] as i32,
+                    after_team: if w[5] != 0 { Some(2) } else { None },
+                    name: b"new^1name",
+                },
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            Ok(tail_json(&out, &client, &entity))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -1167,3 +1197,64 @@ fn admission_json(out: &Admission, ring: u32) -> String {
         out.accepted
     )
 }
+
+fn tail_events(events: &[ConnectTailEvent]) -> String {
+    format!(
+        "[{}]",
+        events
+            .iter()
+            .map(|e| match e {
+                ConnectTailEvent::Classify(mode) => format!(r#"{{"op":"classify","mode":{mode}}}"#),
+                ConnectTailEvent::Bot { slot, restart } => format!(
+                    r#"{{"op":"bot","slot":{slot},"restart":{}}}"#,
+                    u32::from(*restart)
+                ),
+                ConnectTailEvent::Zero { offset, length } =>
+                    format!(r#"{{"op":"zero","offset":{offset},"length":{length}}}"#),
+                ConnectTailEvent::Log(slot) => format!(r#"{{"op":"log","slot":{slot}}}"#),
+                ConnectTailEvent::Userinfo(slot) => format!(r#"{{"op":"userinfo","slot":{slot}}}"#),
+                ConnectTailEvent::Format => r#"{"op":"format"}"#.into(),
+                ConnectTailEvent::Send { recipient, text } => format!(
+                    r#"{{"op":"send","recipient":{recipient},"text":"{}"}}"#,
+                    hex(text)
+                ),
+                ConnectTailEvent::Join { slot, choice } =>
+                    format!(r#"{{"op":"join","slot":{slot},"choice":{choice}}}"#),
+                ConnectTailEvent::Rank => r#"{"op":"rank"}"#.into(),
+            })
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+fn watched_words(client: &[u8]) -> String {
+    let mut offsets = vec![504, 508, 512, 516, 3096, 3140];
+    offsets.extend((668..696).step_by(4));
+    offsets.extend((3204..3592).step_by(4));
+    format!(
+        "{{{}}}",
+        offsets
+            .iter()
+            .map(|o| format!(
+                r#""{o}":{}"#,
+                u32::from_le_bytes(client[*o..*o + 4].try_into().unwrap())
+            ))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+fn tail_json(out: &ConnectTail, client: &[u8], entity: &ConnectTailEntity) -> String {
+    let msg = out
+        .message
+        .as_ref()
+        .map(|v| format!(r#""{}""#, hex(v)))
+        .unwrap_or("null".into());
+    format!(
+        r#"{{"accepted":{},"message":{msg},"events":{},"words":{},"entity_flags":{},"in_use":{},"ring":{}}}"#,
+        out.accepted,
+        tail_events(&out.events),
+        watched_words(client),
+        entity.flags,
+        entity.in_use as u32,
+        out.ring_advance
+    )
+}

crates/urt-gameplay/src/native_policy.rs

@@ -2319,3 +2319,199 @@ mod admission_tests {
         assert_eq!(r, 1);
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConnectTailEntity {
+    pub flags: u32,
+    pub in_use: i32,
+}
+pub struct ConnectTailInput<'a> {
+    pub mode: i32,
+    pub slot: usize,
+    pub first_time: i32,
+    pub bot: i32,
+    pub bot_answer: i32,
+    pub clock: i32,
+    pub seconds: i32,
+    pub after_team: Option<i32>,
+    pub name: &'a [u8],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ConnectTailEvent {
+    Classify(i32),
+    Bot { slot: usize, restart: bool },
+    Zero { offset: usize, length: usize },
+    Log(usize),
+    Userinfo(usize),
+    Format,
+    Send { recipient: i32, text: Vec<u8> },
+    Join { slot: usize, choice: i32 },
+    Rank,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConnectTail {
+    pub accepted: bool,
+    pub message: Option<Vec<u8>>,
+    pub events: Vec<ConnectTailEvent>,
+    pub ring_advance: u32,
+}
+/// Original173979 suffix with supplied bot/userinfo answers and captured jobs.
+/// Bot rejection preserves mutations that precede that return in the source.
+pub fn finish_connect(
+    client: &mut [u8],
+    entity: &mut ConnectTailEntity,
+    input: ConnectTailInput<'_>,
+) -> Result<ConnectTail, Error> {
+    if client.len() != CLIENT_BYTES || input.slot >= 64 || cbytes(input.name).len() >= 128 {
+        return Err(Error::InvalidInput);
+    }
+    let mut bytes = client.to_vec();
+    let mut e = entity.clone();
+    let mut out = ConnectTail {
+        accepted: true,
+        message: None,
+        events: vec![ConnectTailEvent::Classify(input.mode)],
+        ring_advance: 0,
+    };
+    let mut team = raw_word(&bytes, 3096);
+    team = if crate::intermission::team_mode(input.mode) {
+        if team == 0 { 3 } else { team }
+    } else {
+        if team == 3 { 3 } else { 0 }
+    };
+    raw_store(&mut bytes, 3096, team);
+    if input.bot != 0 {
+        e.flags |= 8;
+        e.in_use = 1;
+        out.events.push(ConnectTailEvent::Bot {
+            slot: input.slot,
+            restart: input.first_time == 0,
+        });
+        if input.bot_answer == 0 {
+            out.accepted = false;
+            out.message = Some(b"BotConnectfailed".to_vec());
+            client.copy_from_slice(&bytes);
+            *entity = e;
+            return Ok(out);
+        }
+    }
+    if input.first_time != 0 {
+        bytes[668..696].fill(0);
+        raw_store(
+            &mut bytes,
+            3140,
+            input.clock.wrapping_add(input.seconds.wrapping_mul(1000)) as u32,
+        );
+        out.events.push(ConnectTailEvent::Zero {
+            offset: 668,
+            length: 28,
+        });
+    }
+    out.events.push(ConnectTailEvent::Log(input.slot));
+    if input.first_time != 0 {
+        raw_store(&mut bytes, 3588, 0);
+        bytes[3204..3332].fill(0);
+        bytes[3332..3588].fill(0);
+        out.events.extend([
+            ConnectTailEvent::Zero {
+                offset: 3204,
+                length: 128,
+            },
+            ConnectTailEvent::Zero {
+                offset: 3332,
+                length: 256,
+            },
+        ]);
+    }
+    out.events.push(ConnectTailEvent::Userinfo(input.slot));
+    if let Some(team) = input.after_team {
+        raw_store(&mut bytes, 3096, team as u32);
+    }
+    let name = cbytes(input.name);
+    bytes[504..504 + name.len()].copy_from_slice(name);
+    bytes[504 + name.len()] = 0;
+    if input.first_time != 0 {
+        let text = crate::qvm_format::render(
+            b"print \"%s^7 connected\n\"",
+            &[crate::qvm_format::Argument::Bytes(Some(name))],
+        )
+        .map_err(|_| Error::InvalidInput)?;
+        let text = cbytes(&text).to_vec();
+        out.events.extend([
+            ConnectTailEvent::Format,
+            ConnectTailEvent::Send {
+                recipient: -1,
+                text,
+            },
+        ]);
+        out.ring_advance = 1;
+    }
+    out.events.push(ConnectTailEvent::Classify(input.mode));
+    if crate::intermission::team_mode(input.mode) && raw_word(&bytes, 3096) != 3 {
+        out.events.push(ConnectTailEvent::Join {
+            slot: input.slot,
+            choice: -1,
+        });
+    }
+    out.events.push(ConnectTailEvent::Rank);
+    client.copy_from_slice(&bytes);
+    *entity = e;
+    Ok(out)
+}
+#[cfg(test)]
+mod connect_tail_tests {
+    use super::*;
+    #[test]
+    fn bot_reject_keeps_prior_flags_and_team_change() {
+        let mut raw = vec![0; CLIENT_BYTES];
+        let mut e = ConnectTailEntity {
+            flags: 32,
+            in_use: 0,
+        };
+        let out = finish_connect(
+            &mut raw,
+            &mut e,
+            ConnectTailInput {
+                mode: 3,
+                slot: 0,
+                first_time: 1,
+                bot: 1,
+                bot_answer: 0,
+                clock: 100,
+                seconds: 0,
+                after_team: Some(2),
+                name: b"new",
+            },
+        )
+        .unwrap();
+        assert!(!out.accepted);
+        assert_eq!(raw_word(&raw, 3096), 3);
+        assert_eq!(e.flags, 40);
+        assert_eq!(out.events.len(), 2);
+    }
+    #[test]
+    fn first_time_zero_seconds_has_no_initializer_default() {
+        let mut raw = vec![0; CLIENT_BYTES];
+        let mut e = ConnectTailEntity {
+            flags: 0,
+            in_use: 0,
+        };
+        finish_connect(
+            &mut raw,
+            &mut e,
+            ConnectTailInput {
+                mode: 0,
+                slot: 0,
+                first_time: 1,
+                bot: 0,
+                bot_answer: 1,
+                clock: 100,
+                seconds: 0,
+                after_team: None,
+                name: b"new",
+            },
+        )
+        .unwrap();
+        assert_eq!(raw_word(&raw, 3140), 100);
+    }
+}

docs/FINDINGS.md

@@ -1760,3 +1760,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-920:** 144 actual173979 suffix cases execute original mode classification and broadcast formatting with explicit bot/userinfo answers. Team normalization precedes bot flags/admission; failed bots return after those mutations. First-time paths clear selected ranges and overwrite timeout without the initializer60-second default. Updated userinfo/name precedes broadcast and a second team decision; ranking is requested last. Bot, userinfo, join, ranking, logs/network and native memset remain supplied/captured/modeled boundaries. [Evidence](research/QVM_CONNECT_TAIL.md).
+
+
+**RE-921:** Rust matches144 original173979 suffix cases with ordered bot admission, first-time clears, timeout wrapping, supplied userinfo changes, original broadcast bytes, team callback and ranking intentions. Bot rejection retains prior team/flag mutations. Native callbacks/logging/network/ranking and real caller acceptance remain open. [Evidence](research/RUST_CONNECT_TAIL.md).

docs/PROVISIONAL_TODO.md

@@ -1800,3 +1800,6 @@ RE-919: Rust matches160 original173979 admission prefixes, preserving bot bypass
 
 
 RE-920: 144 actual173979 suffix cases execute original mode classification and broadcast formatting with explicit bot/userinfo answers. Team normalization precedes bot flags/admission; failed bots return after those mutations. First-time paths clear selected ranges and overwrite timeout without the initializer60-second default. Updated userinfo/name precedes broadcast and a second team decision; ranking is requested last. Bot, userinfo, join, ranking, logs/network and native memset remain supplied/captured/modeled boundaries. Full runtime completion remains open. [Evidence](research/QVM_CONNECT_TAIL.md).
+
+
+RE-921: Rust matches144 original173979 suffix cases with ordered bot admission, first-time clears, timeout wrapping, supplied userinfo changes, original broadcast bytes, team callback and ranking intentions. Bot rejection retains prior team/flag mutations. Native callbacks/logging/network/ranking and real caller acceptance remain open. Full runtime completion remains open. [Evidence](research/RUST_CONNECT_TAIL.md).

docs/RESEARCH_LEDGER.md

@@ -2325,3 +2325,8 @@ Rust matches160 original173979 admission prefixes, preserving bot bypass, addres
 ## 2026-10-28 — RE-920 Original post-session connect normalization and callbacks
 
 144 actual173979 suffix cases execute original mode classification and broadcast formatting with explicit bot/userinfo answers. Team normalization precedes bot flags/admission; failed bots return after those mutations. First-time paths clear selected ranges and overwrite timeout without the initializer60-second default. Updated userinfo/name precedes broadcast and a second team decision; ranking is requested last. Bot, userinfo, join, ranking, logs/network and native memset remain supplied/captured/modeled boundaries. Focused `cargo xtask test-group qvm-connect-tail` 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-921 Rust post-session connect callbacks and normalization
+
+Rust matches144 original173979 suffix cases with ordered bot admission, first-time clears, timeout wrapping, supplied userinfo changes, original broadcast bytes, team callback and ranking intentions. Bot rejection retains prior team/flag mutations. Native callbacks/logging/network/ranking and real caller acceptance remain open. Focused `cargo xtask test-group rust-connect-tail` 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.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1837,3 +1837,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-920 Original post-session connect normalization and callbacks ([evidence](research/QVM_CONNECT_TAIL.md)).
+
+
+- [x] RE-921 Rust post-session connect callbacks and normalization ([evidence](research/RUST_CONNECT_TAIL.md)).

docs/research/README.md

@@ -1372,3 +1372,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-920: Original post-session connect normalization and callbacks](QVM_CONNECT_TAIL.md).
+
+
+[RE-921: Rust post-session connect callbacks and normalization](RUST_CONNECT_TAIL.md).

docs/research/RUST_CONNECT_TAIL.md

@@ -0,0 +1,7 @@
+# Rust post-session connect callbacks and normalization
+
+RE-921. Reproduce with `python3 scripts/analyze_rust_connect_tail.py`; focused validation: `cargo xtask test-group rust-connect-tail`. [Machine report](rust-connect-tail.json).
+
+Rust matches144 original173979 suffix cases with ordered bot admission, first-time clears, timeout wrapping, supplied userinfo changes, original broadcast bytes, team callback and ranking intentions. Bot rejection retains prior team/flag mutations. Native callbacks/logging/network/ranking and real caller acceptance 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": 173,
+  "rust_unit_tests": 175,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_connect_tail.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','team','bot','first','answer','changed','now','seconds']]
+def project(s):return {k:s[k] for k in ['accepted','message','events','words','entity_flags','in_use','ring']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-connect-tail.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'connect-tail',encode(s))})
+ write_json(Path('docs/research/rust-connect-tail.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches144 original173979 suffix cases with ordered bot admission, first-time clears, timeout wrapping, supplied userinfo changes, original broadcast bytes, team callback and ranking intentions. Bot rejection retains prior team/flag mutations. Native callbacks/logging/network/ranking and real caller acceptance remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_connect_tail.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-tail.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-tail.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

@@ -2966,3 +2966,18 @@ edge	docs/research/qvm-connect-tail.json	scripts/test_qvm_connect_tail.py
 group	qvm-connect-tail	scripts/analyze_qvm_connect_tail.py
 edge	scripts/analyze_qvm_connect_tail.py	scripts/analyze_qvm_resumer_audit.py
 edge	scripts/qvm_connect_tail_oracle.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_connect_tail.py
+edge	Cargo.lock	scripts/analyze_rust_connect_tail.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_connect_tail.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_connect_tail.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_connect_tail.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_connect_tail.py
+edge	docs/research/qvm-connect-tail.json	scripts/analyze_rust_connect_tail.py
+group	rust-connect-tail	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_connect_tail.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_connect_tail.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_connect_tail.py
+report	scripts/analyze_rust_connect_tail.py	docs/research/rust-connect-tail.json
+edge	docs/research/rust-connect-tail.json	scripts/test_rust_connect_tail.py
+group	rust-connect-tail	scripts/analyze_rust_connect_tail.py
+edge	scripts/analyze_rust_connect_tail.py	scripts/analyze_qvm_resumer_audit.py