gameplay: port mode8 eligibility policy

crates/urt-gameplay/src/bin/urt-move-callbacks.rs

@@ -70,6 +70,7 @@ fn main() {
         }
         "self" => println!("{}", self_recovery(&w)),
         "cleanup" => println!("{}", cleanup(&w)),
+        "eligibility" => println!("{}", eligibility(&w)),
         _ => panic!("unknown policy"),
     }
 }
@@ -158,3 +159,53 @@ fn cleanup(w: &[u32]) -> String {
         .join(",");
     format!(r#"{{"clients":[{}],"proceed":{}}}"#, rows, proceed)
 }
+
+fn eligibility(w: &[u32]) -> String {
+    assert_eq!(w.len(), 22);
+    let selected = if w[20] == 1 { 2 } else { 1 };
+    let own = if w[17] == 0 { selected } else { w[17] };
+    let other = if w[16] == 0 { selected } else { w[16] };
+    let mut c = vec![
+        ObjectiveClient {
+            connection: 2,
+            health: 1,
+            team: selected,
+            ..ObjectiveClient::default()
+        };
+        (w[18] as usize).max(3)
+    ];
+    c[w[19] as usize] = ObjectiveClient {
+        connection: w[13],
+        health: w[14],
+        follow: w[15],
+        team: other,
+        busy: w[12],
+    };
+    c[2] = ObjectiveClient {
+        connection: w[8],
+        health: w[9],
+        follow: w[10],
+        team: own,
+        busy: w[11],
+    };
+    let old = c.clone();
+    let eligible = mode8_eligible(
+        &c,
+        Mode8EligibilityInput {
+            entity: w[0] != 0,
+            client: w[1] != 0,
+            enabled_a: w[2],
+            enabled_b: w[3],
+            tick: w[4],
+            start: w[5],
+            delay: w[6],
+            complete: w[7],
+            selector: w[20],
+            self_index: 2,
+            count: w[18] as usize,
+        },
+    )
+    .unwrap();
+    assert_eq!(w[21], 0);
+    format!(r#"{{"eligible":{},"unchanged":{}}}"#, eligible, c == old)
+}

crates/urt-gameplay/src/move_callbacks.rs

@@ -401,3 +401,135 @@ mod cleanup_tests {
         assert_eq!(c, old);
     }
 }
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ObjectiveClient {
+    pub connection: u32,
+    pub health: u32,
+    pub follow: u32,
+    pub team: u32,
+    pub busy: u32,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Mode8EligibilityInput {
+    pub entity: bool,
+    pub client: bool,
+    pub enabled_a: u32,
+    pub enabled_b: u32,
+    pub tick: u32,
+    pub start: u32,
+    pub delay: u32,
+    pub complete: u32,
+    pub selector: u32,
+    pub self_index: usize,
+    pub count: usize,
+}
+/// Original153419 admission through153596. No objective lookup or mutation.
+pub fn mode8_eligible(
+    clients: &[ObjectiveClient],
+    input: Mode8EligibilityInput,
+) -> Result<bool, Error> {
+    if !input.entity
+        || !input.client
+        || input.enabled_a == 0
+        || input.enabled_b == 0
+        || input.tick.wrapping_sub(input.start) as i32 <= input.delay.wrapping_mul(1000) as i32
+        || input.complete != 0
+    {
+        return Ok(false);
+    }
+    let own = *clients.get(input.self_index).ok_or(Error::InvalidIndex)?;
+    if own.connection != 2
+        || own.health as i32 <= 0
+        || own.follow != 0
+        || own.team != if input.selector == 1 { 2 } else { 1 }
+    {
+        return Ok(false);
+    }
+    if input.count > 64 || input.count > clients.len() {
+        return Err(Error::InvalidCount);
+    }
+    for (j, c) in clients[..input.count].iter().enumerate() {
+        if j != input.self_index
+            && c.connection == 2
+            && c.health as i32 > 0
+            && c.follow == 0
+            && c.team == own.team
+            && c.busy != 0
+        {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+#[cfg(test)]
+mod eligibility_tests {
+    use super::*;
+    fn input() -> Mode8EligibilityInput {
+        Mode8EligibilityInput {
+            entity: true,
+            client: true,
+            enabled_a: 1,
+            enabled_b: 1,
+            tick: 10000,
+            start: 9000,
+            delay: 1,
+            complete: 0,
+            selector: 2,
+            self_index: 2,
+            count: 3,
+        }
+    }
+    fn clients() -> [ObjectiveClient; 3] {
+        [ObjectiveClient {
+            connection: 2,
+            health: 1,
+            follow: 0,
+            team: 1,
+            busy: 0,
+        }; 3]
+    }
+    #[test]
+    fn strict_time_and_exact_selector_are_preserved() {
+        let c = clients();
+        assert_eq!(mode8_eligible(&c, input()), Ok(false));
+        assert_eq!(
+            mode8_eligible(
+                &c,
+                Mode8EligibilityInput {
+                    tick: 10001,
+                    ..input()
+                }
+            ),
+            Ok(true)
+        );
+        assert_eq!(
+            mode8_eligible(
+                &c,
+                Mode8EligibilityInput {
+                    tick: 10001,
+                    selector: 1,
+                    ..input()
+                }
+            ),
+            Ok(false)
+        );
+    }
+    #[test]
+    fn self_busy_is_skipped_and_only_live_teammates_block() {
+        let mut c = clients();
+        c[2].busy = 1;
+        let i = Mode8EligibilityInput {
+            tick: 10001,
+            ..input()
+        };
+        assert_eq!(mode8_eligible(&c, i), Ok(true));
+        c[0].busy = 1;
+        assert_eq!(mode8_eligible(&c, i), Ok(false));
+        c[0].follow = 1;
+        assert_eq!(mode8_eligible(&c, i), Ok(true));
+        let old = c;
+        assert!(mode8_eligible(&c, Mode8EligibilityInput { count: 65, ..i }).is_err());
+        assert_eq!(c, old);
+    }
+}

docs/FINDINGS.md

@@ -1935,3 +1935,5 @@ RE-998: Twenty-eight original-QVM fixtures recover152792 admission and its first
 RE-999: Rust ports152792 admission and first scan across28 original cases, including full64-slot and zero-count pools. Typed indices replace supplied entity/client pointers; inactive targets are not dereferenced. Protected self returns before scanning, preserving other helpers. Dead/disconnected/following targets clear only assistance mask8192, active state and target. Invalid active indices/counts reject atomically; unit tests cover high-bit preservation, early bypass and rollback after a prior planned cleanup. [Evidence](research/RUST_MOVE_ASSIST_CLEANUP.md).
 
 RE-1000: Sixty-six original-QVM cases recover153419 admission through153596. Both global enables, strict signed wrapped elapsed greater than delay*1000, incomplete state, connected/live/non-following self and selected team are required. Selector exactly1 chooses team2; other values choose team1. A live connected non-following teammate with nonzero6164 blocks entry, while self is excluded. All fields remain unchanged. Exact/negative/wrapped times, three selectors, zero/64 pools and teammate bypasses are covered; flag search and objective effects remain open. [Evidence](research/QVM_MOVE_MODE8_ELIGIBILITY.md).
+
+RE-1001: Rust ports the read-only mode8 eligibility boundary across66 original cases. Time comparisons wrap as signed words; selector exactly1 chooses team2. Typed teammate scanning excludes self and requires connected/live/non-following same-team busy state before blocking. Counts and indices reject explicitly when used. Unit tests cover strict timing, selector2, self exclusion, inactive teammates and input immutability. Objective search and mutation remain unimplemented. [Evidence](research/RUST_MOVE_MODE8_ELIGIBILITY.md).

docs/PROVISIONAL_TODO.md

@@ -1992,3 +1992,5 @@ RE-974–983 completed routing, command rewrite, inactivity, movement-parameter
 - [x] RE-999 Port assistance cleanup and typed target ownership ([evidence](research/RUST_MOVE_ASSIST_CLEANUP.md)).
 
 - [x] RE-1000 Recover mode8 eligibility and teammate exclusion ([evidence](research/QVM_MOVE_MODE8_ELIGIBILITY.md)).
+
+- [x] RE-1001 Port mode8 eligibility and teammate exclusion ([evidence](research/RUST_MOVE_MODE8_ELIGIBILITY.md)).

docs/RESEARCH_LEDGER.md

@@ -2675,3 +2675,7 @@ Rust ports152792 admission and first scan across28 original cases, including ful
 ## 2026-10-29 — RE-1000 Recover mode8 eligibility and teammate exclusion
 
 Sixty-six original-QVM cases recover153419 admission through153596. Both global enables, strict signed wrapped elapsed greater than delay*1000, incomplete state, connected/live/non-following self and selected team are required. Selector exactly1 chooses team2; other values choose team1. A live connected non-following teammate with nonzero6164 blocks entry, while self is excluded. All fields remain unchanged. Exact/negative/wrapped times, three selectors, zero/64 pools and teammate bypasses are covered; flag search and objective effects remain open. Focused `cargo xtask test-group qvm-move-mode8-eligibility` passes with deterministic report regeneration and selected regressions. Full suite deferred to task ten. Original assets unchanged; Python uses the flake-declared Nix runtime.
+
+## 2026-10-29 — RE-1001 Port mode8 eligibility and teammate exclusion
+
+Rust ports the read-only mode8 eligibility boundary across66 original cases. Time comparisons wrap as signed words; selector exactly1 chooses team2. Typed teammate scanning excludes self and requires connected/live/non-following same-team busy state before blocking. Counts and indices reject explicitly when used. Unit tests cover strict timing, selector2, self exclusion, inactive teammates and input immutability. Objective search and mutation remain unimplemented. Focused `cargo xtask test-group rust-move-mode8-eligibility` passes with deterministic report regeneration and selected regressions. Full suite deferred to task ten. Original assets unchanged; Python uses the flake-declared Nix runtime.

docs/REVERSE_ENGINEERING_TODO.md

@@ -2029,3 +2029,5 @@ RE-974–983 recover routing, command rewriting, inactivity and composed setup t
 - [x] RE-999 Port assistance cleanup and typed target ownership ([evidence](research/RUST_MOVE_ASSIST_CLEANUP.md)).
 
 - [x] RE-1000 Recover mode8 eligibility and teammate exclusion ([evidence](research/QVM_MOVE_MODE8_ELIGIBILITY.md)).
+
+- [x] RE-1001 Port mode8 eligibility and teammate exclusion ([evidence](research/RUST_MOVE_MODE8_ELIGIBILITY.md)).

docs/research/README.md

@@ -1563,3 +1563,5 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-999: Port assistance cleanup and typed target ownership](RUST_MOVE_ASSIST_CLEANUP.md).
 
 - [RE-1000: Recover mode8 eligibility and teammate exclusion](QVM_MOVE_MODE8_ELIGIBILITY.md).
+
+- [RE-1001: Port mode8 eligibility and teammate exclusion](RUST_MOVE_MODE8_ELIGIBILITY.md).

docs/research/RUST_MOVE_MODE8_ELIGIBILITY.md

@@ -0,0 +1,5 @@
+# Port mode8 eligibility and teammate exclusion
+
+RE-1001. Focused validation: `cargo xtask test-group rust-move-mode8-eligibility`. [Machine report](rust-move-mode8-eligibility.json).
+
+Rust ports the read-only mode8 eligibility boundary across66 original cases. Time comparisons wrap as signed words; selector exactly1 chooses team2. Typed teammate scanning excludes self and requires connected/live/non-following same-team busy state before blocking. Counts and indices reject explicitly when used. Unit tests cover strict timing, selector2, self exclusion, inactive teammates and input immutability. Objective search and mutation remain unimplemented.

docs/research/rust-health-impulse.json

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

docs/research/rust-move-mode8-eligibility.json

@@ -0,0 +1,667 @@
+{
+  "limits": "Finite source/Rust contract parity; native time/file/network replies remain supplied or captured.",
+  "probes": [
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": true,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": true,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    },
+    {
+      "rust": {
+        "eligible": false,
+        "unchanged": true
+      },
+      "source": {
+        "eligible": false,
+        "unchanged": true
+      }
+    }
+  ],
+  "source_report": "docs/research/qvm-move-mode8-eligibility.json",
+  "source_report_sha256": "035e884e8f9d7ea4aef6bd63b16dcf92fd7e8542ddd001b88b4adabb158d5764"
+}

scripts/analyze_rust_move_mode8_eligibility.py

@@ -0,0 +1,16 @@
+"""Compare recovered Rust policy with original QVM fixtures."""
+import hashlib,json,os,subprocess
+from pathlib import Path
+from analyze_qvm import write_json
+from rust_lifecycle_support import result
+
+def main():
+ subprocess.run(['cargo','build','--offline','--package','urt-gameplay','--bin','urt-move-callbacks'],check=True,capture_output=True)
+ binary=Path(os.environ.get('CARGO_TARGET_DIR','target'))/'debug'/'urt-move-callbacks'
+ path=Path('docs/research/qvm-move-mode8-eligibility.json');data=path.read_bytes();probes=[]
+ for p in json.loads(data)['probes']:
+  probes.append(dict(source={k:p[k] for k in ['eligible', 'unchanged']},rust=result(binary,'eligibility',encode(p['input']))))
+ write_json(Path('docs/research/rust-move-mode8-eligibility.json'),dict(source_report=str(path),source_report_sha256=hashlib.sha256(data).hexdigest(),probes=probes,limits='Finite source/Rust contract parity; native time/file/network replies remain supplied or captured.'))
+
+def encode(a):return [a['entity'],a['client'],a['enabled_a'],a['enabled_b'],a['tick'],a['start'],a['delay'],a['complete'],a['connection'],a['health'],a['follow'],a['own_busy'],a['other_busy'],a['other_connection'],a['other_health'],a['other_follow'],a['other_team'],a['team'],a['count'],a['busy_slot'],a['selector'],0]
+if __name__=='__main__':main()

scripts/test_rust_move_mode8_eligibility.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class PortTests(unittest.TestCase):
+ def test_original_parity(self):
+  r=json.loads(Path('docs/research/rust-move-mode8-eligibility.json').read_text());self.assertGreaterEqual(len(r['probes']),12)
+  for p in r['probes']:self.assertEqual(p['source'],p['rust'])
+ def test_identity(self):
+  r=json.loads(Path('docs/research/rust-move-mode8-eligibility.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

@@ -3908,3 +3908,29 @@ report	scripts/analyze_qvm_move_mode8_eligibility.py	docs/research/qvm-move-mode
 edge	docs/research/qvm-move-mode8-eligibility.json	scripts/test_qvm_move_mode8_eligibility.py
 group	qvm-move-mode8-eligibility	scripts/analyze_qvm_move_mode8_eligibility.py
 edge	scripts/analyze_qvm_move_mode8_eligibility.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_rust_move_mode8_eligibility.py	docs/research/rust-move-mode8-eligibility.json
+edge	docs/research/rust-move-mode8-eligibility.json	scripts/test_rust_move_mode8_eligibility.py
+group	rust-move-mode8-eligibility	scripts/analyze_rust_move_mode8_eligibility.py
+edge	scripts/analyze_rust_move_mode8_eligibility.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_move_mode8_eligibility.py
+edge	Cargo.lock	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/filter_loading.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/filter_lifecycle.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/bin/urt-filter-loading.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	docs/research/qvm-move-mode8-eligibility.json	scripts/analyze_rust_move_mode8_eligibility.py
+group	rust-move-mode8-eligibility	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/filter_commands.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/bin/urt-filter-commands.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/client_timer.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/bin/urt-client-timer.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/client_processing.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/bin/urt-client-processing.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/client_move_context.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/bin/urt-client-move-context.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/move_callbacks.rs	scripts/analyze_rust_move_mode8_eligibility.py
+edge	crates/urt-gameplay/src/bin/urt-move-callbacks.rs	scripts/analyze_rust_move_mode8_eligibility.py

xtask/src/lib.rs

@@ -1139,6 +1139,7 @@ mod integration_tests {
             ("move_callbacks", "move_meter"),
             ("move_callbacks", "move_self_recovery"),
             ("move_callbacks", "move_assist_cleanup"),
+            ("move_callbacks", "move_mode8_eligibility"),
             ("client_move_context", "client_move_scratch"),
             ("client_processing", "client_routing"),
             ("client_timer", "client_routing"),
@@ -1360,6 +1361,7 @@ mod integration_tests {
             ("qvm-move-meter", "move_meter"),
             ("qvm-move-self-recovery", "move_self_recovery"),
             ("qvm-move-assist-cleanup", "move_assist_cleanup"),
+            ("qvm-move-mode8-eligibility", "move_mode8_eligibility"),
             ("qvm-client-move-scratch", "client_move_scratch"),
             ("qvm-client-routing", "client_routing"),
             ("qvm-client-command-rewrite", "client_command_rewrite"),