docs/PROVISIONAL_TODO.md

Provisional full-game backlog

Planning revision: 2026-10-11. Target: the supplied Urban Terror 4.3.4 reference, rewritten in Rust + Bevy + Solari, with a working client and dedicated server on macOS and Linux.

This is a large provisional work breakdown, not a claim that the game has been fully understood. It expands the remaining work and makes dependencies visible. The canonical research, asset pipeline, rewrite, validation and file coverage checklists retain their current statuses. PROV IDs are stable planning references; all items below start unchecked. When promoting an item, link it to the canonical task and its evidence rather than copying completion status automatically.

Goals and scope

• Document everything found in the installation: binaries, libraries and DLL dependencies, QVMs, shaders, rendering, logic, textures, maps, models, audio, configuration, resources, metadata and auxiliary content.
• Preserve and analyze every extracted occurrence, including overridden, duplicate, unused and unknown variants. A representative example does not close a format or content family.
• Produce reproducible unpacking, analysis, conversion and validation scripts, then versioned runtime content with full source provenance.
• Replace the original client and server behavior with maintainable Rust systems and native platform delivery. The release must not require original executable or QVM gameplay code.
• Establish Solari feasibility on the intended macOS and Linux hardware before depending on its capabilities. Preserve gameplay-critical visibility and record rendering deviations explicitly.
• Keep original installation objects exclusively in ignored .cache/; extracted, analysis and converted assets belong under assets/ through Git LFS/Xet. Code and documentation belong in ordinary Git in the same Hugging Face repository.

See GOALS.md for the full definition of completion and STORAGE.md for the enforced repository policy.

Evidence baseline and limits

The current inventory records 39 original files and 23 PK3 archives. Extraction preserves 9,835 file occurrences and 743 directory entries. Static research has decoded all 659,048 QVM instructions and disassembled the eight supplied native files. Decoding and disassembly do not establish full semantic coverage. Imported or dynamically loaded DLLs are within scope even when no standalone DLL exists in the supplied snapshot.

Read findings, extraction evidence, binary research, native coverage, authentication drop, deferred authentication and engine control before using this list. The original binaries and complete QVM modules have not been launched in the current research baseline. Synthetic instruction fixtures are explicitly narrower evidence than original-runtime tests.

Working rules and ordering

Each task needs a concrete deliverable, a reproduction command or scenario, and recorded verification before completion. Format and subsystem tasks apply to every applicable inventory item. Write evidence with source hashes and exact addresses, instruction indices or member offsets; label hypotheses and approximations. Record negative findings and unexplained bytes as well as successful interpretations.

Use this dependency order: inventory and provenance → static recovery plus reference observation → behavioral specifications and fixtures → conversion contracts → a platform-verified vertical slice → complete implementation and content coverage → cross-platform conformance and release. Static analysis, reference-harness preparation and format inspection can progress together; renderer feasibility should happen early. There are no time estimates here because unresolved behavior and platform feasibility can change the work materially.

For implementation items, the minimum done condition is a documented contract, an implementation consuming traceable content, and a relevant reference comparison on the required platforms. For research items, it is reproducible evidence and explicit remaining uncertainty. For asset items, it is validated conversion with source/variant provenance and a loss report. Apply the research ledger conventions throughout.

Work breakdown

First research batch

Progress: RE-232–234 / TIME-001–003 now cover Linux ELF64 elapsed modification, event sources and pause predicates. The RE-237–239 follow-up resolves the pause-field address/bot chain and adds queue/journal evidence. The RE-241–243 announcement pass recovers label tables and recipient paths; The RE-245–247 cvar pass adds all 126 main registration rows and resolves auth_verbosity/callers. The RE-249–251 change pass adds cache/notification behavior, four numeric correction branches and direct registration coverage. The RE-253–255 query pass adds selector helpers, command-role routing and internal authentication modes. The RE-257–259 bounds/entry pass adds integer parsing, selector storage/count evidence and native/QVM/chat route connections. The RE-261–263 chat pass adds native command metadata/filter evidence and bounded message/recipient paths, including the documented argument-mapping correction. The RE-265–267 delivery pass adds bounded dead-chat predicates, formatter argument routing and echo/fanout calls. The RE-269–271 expansion pass adds marker states, twelve key comparisons and health/momo branches. The RE-273–275 item/time pass adds packed ammunition fields, sampled names and countdown branches. The RE-277–279 location pass adds leader selection, cache/format boundaries and location-list/spatial evidence. The RE-281–283 crosshair pass adds finite geometry fixtures, trace arguments and result routing. The RE-285–287 native spatial pass confirms Linux trig/spatial services, VM pointer branches and collision/query evidence. The RE-289–291 collision pass adds native candidate filters, result decisions and model/field evidence. The RE-293–295 composition pass adds three-lane byte-copy/status agreement and world-result routing. The RE-297–299 loop pass adds signed count/status gates, parity scheduling and related sentinel normalization. The RE-301–303 area pass adds registered address arithmetic, inclusive overlap and count/split ordering boundaries. The RE-305–307 world-link pass adds bounded sector construction, strict placement/head insertion and unlink state/repair behavior. The RE-309–311 bounds pass adds radius/padding composition, leaf-return gates and inline removal evidence. The RE-313–315 metadata pass adds area-slot/cluster loops and guarded leaf/query output contracts. PROV-002 remains open for full output/reset coverage. PROV-001 remains open for complete scheduling and platform coverage.

Start with the open questions raised by the current binary evidence. These tasks depend on the linked reports, not on a working rewrite.

• PROV-001: Trace Com_EventLoop, Com_Frame and SV_Frame together, including elapsed-time adjustment, timescale, pause, catch-up and restart ordering; extend RE-231.
• PROV-002: Recover the authentication announcement helper’s format strings, recipients, role/status predicates and third argument; extend RE-230.
• PROV-003: Find every reset and aliased access to the deferred authentication fields, beyond literal offset references.
• PROV-004: Trace Linux error recovery through every mode, recursive errors, rapid-error promotion and cleanup; compare with Windows and macOS.
• PROV-005: Render the reconstructed Windows icons and classify the surplus DIB bytes with byte-preserving evidence; extend RE-217.
• PROV-006: Trace address-parser failures, unchecked send arguments and client-drop state transitions across all native targets.
• PROV-007: Build a prioritized list of the remaining 519 unresolved QVM indirect-call sites, with targets, confidence and blockers.
• PROV-008: Create a cross-platform comparison table for the custom authentication exports and traps; distinguish absence from missing evidence.
• PROV-009: Define a reference execution harness and select an environment for each original architecture before launching binaries.
• PROV-010: Produce the first reference fixture for one fully traced gameplay behavior, recording synthetic versus original-runtime evidence.
• PROV-011: Audit existing scripts for assumptions about instruction indices, signed arithmetic and partial function boundaries.
• PROV-012: Promote the next bounded research batch into canonical RE tasks with concrete deliverables and checks.

Evidence, scope and coverage

Apply these tasks to every installation file and every archive-member occurrence. Existing inventory and extraction manifests are the starting point.

• PROV-013: Freeze a reference snapshot identity with original hashes, archive identities and game version.
• PROV-014: Reconcile the installation inventory against the cache, including hidden files and auxiliary directories.
• PROV-015: Assign every file an owner, format, analysis status and final disposition in a machine-readable coverage registry.
• PROV-016: Assign every archive member occurrence a source identity independent of its eventual runtime path.
• PROV-017: Record overridden, duplicate, case-colliding and apparently unused variants without discarding them.
• PROV-018: Classify unknown file signatures through bounded parsers and hex inspection.
• PROV-019: Record trailing bytes, alignment, padding and unexplained regions for every binary format.
• PROV-020: Separate verified observations, source-based comparisons, hypotheses and implementation decisions in reports.
• PROV-021: Attach addresses, instruction indices, offsets, hashes and reproduction commands to behavior claims.
• PROV-022: Document uncertainty and competing interpretations instead of assigning premature semantic names.
• PROV-023: Record all scripts’ versions, inputs, outputs, dependencies and deterministic regeneration commands.
• PROV-024: Create a report index that connects each behavior specification to evidence, fixtures and implementation tasks.
• PROV-025: Audit all completed canonical tasks against their documented acceptance evidence.
• PROV-026: Define how newly discovered files, services or behaviors expand the backlog.
• PROV-027: Document the handling of authoring files, examples, broken content and nonplayable maps.
• PROV-028: Establish a final coverage gate requiring a justified disposition for every file, member variant and unknown region.

Reference execution and observation

Execution work is future work: static decoding and synthetic instruction tests do not establish runtime conformance.

• PROV-029: Prepare reproducible reference environments for Linux x86 and x86_64 executables.
• PROV-030: Prepare a reference environment for Windows PE32 client and dedicated server.
• PROV-031: Prepare a compatible reference environment for the macOS x86_64 executable and bundled SDL library.
• PROV-032: Record original platform prerequisites and distinguish environmental failures from game behavior.
• PROV-033: Capture process arguments, environment, configuration, package search paths and startup logs.
• PROV-034: Instrument native-to-QVM calls, syscall arguments, return values and error exits.
• PROV-035: Capture user commands, snapshots, entity states and game events at stable boundaries.
• PROV-036: Control seeds, clocks, inputs and initial state for repeatable gameplay traces.
• PROV-037: Capture reference images with camera, map, settings, frame time and viewport metadata.
• PROV-038: Capture audio events and output with timing and channel metadata.
• PROV-039: Capture network traffic for local server, remote connection, authentication and downloads.
• PROV-040: Create isolated local substitutes for unavailable external endpoints where protocol evidence permits.
• PROV-041: Document what cannot be observed when historical services are unavailable.
• PROV-042: Build replayable scenarios for startup, connect, map change, reconnect, disconnect and shutdown.
• PROV-043: Test malformed input and recoverable failure paths with resource and timeout limits.
• PROV-044: Compare synthetic QVM fixtures against original execution before using them as conformance oracles.

QVM decoding, ABI and program recovery

Extend the existing complete instruction decode into a behavior specification for cgame, qagame and ui.

• PROV-045: Validate QVM headers, segments, BSS, relocation/jump metadata and loader rejection rules.
• PROV-046: Verify function boundaries, shared tails and unusual control flow against VM interpreter semantics.
• PROV-047: Recover all vmMain command dispatch cases and argument layouts for each module.
• PROV-048: Recover the complete standard and custom syscall table for each module.
• PROV-049: Trace every direct and indirect call into a module call graph.
• PROV-050: Resolve jump tables, computed branches and function-pointer tables with bounds and provenance.
• PROV-051: Track globals and local-stack objects through loads, stores, aliases and pointer arithmetic.
• PROV-052: Recover arrays and record strides, capacities, sentinels and initialization order.
• PROV-053: Recover game, client, player, entity, UI and network-related structure layouts.
• PROV-054: Identify constants, flags, enums and bitfields without treating inferred names as original symbols.
• PROV-055: Recover string tables, formatting conventions, localization assumptions and command parsers.
• PROV-056: Identify compiler/library idioms and separate them from game-specific behavior.
• PROV-057: Document integer overflow, shifts, sign extension, division and float conversion semantics.
• PROV-058: Document VM memory checking, pointer translation and host-call marshalling.
• PROV-059: Determine required QVM version and extension support across native engines.
• PROV-060: Recover cgame prediction, interpolation, HUD and visual event processing.
• PROV-061: Recover qagame authoritative initialization, simulation, client lifecycle and shutdown.
• PROV-062: Recover UI menu flow, settings, server browser and authentication response handling.
• PROV-063: Recover bot-related QVM behavior and engine interfaces.
• PROV-064: Compare common algorithms duplicated between modules for drift or shared invariants.
• PROV-065: Build an annotated intermediate representation suitable for cross-references and structured analysis.
• PROV-066: Create small executable fixtures for recovered branches and boundary conditions.
• PROV-067: Track unresolved instructions, calls and data regions explicitly through completion.
• PROV-068: Document which VM behavior is research-only and which semantics the Rust implementation must preserve.

Native binaries, libraries and DLLs

Analyze all eight supplied native files and all discovered imported, dynamically loaded or statically linked components.

• PROV-069: Map executable headers, sections, segments, entry points and load permissions for every target.
• PROV-070: Analyze imports, exports, relocations, thunks, linkage tables and dynamic loader behavior.
• PROV-071: Inventory external Windows DLL requirements and dynamically constructed library names.
• PROV-072: Inventory Linux shared libraries, symbol versions and platform-specific dependencies.
• PROV-073: Inventory macOS frameworks, dylibs, install names and architecture requirements.
• PROV-074: Recover statically linked library boundaries and likely versions with confidence labels.
• PROV-075: Compare the bundled SDL implementation and retained symbols with pinned upstream sources.
• PROV-076: Annotate all retained STABS records and map source/object provenance to code ranges.
• PROV-077: Document the absence or presence of debug types and limits on structure recovery.
• PROV-078: Classify all native text ranges, data tables, resources and unexplained gaps.
• PROV-079: Analyze startup, command-line parsing, configuration loading and shutdown order.
• PROV-080: Recover platform input, window, clipboard, cursor, focus and fullscreen behavior.
• PROV-081: Recover audio initialization, mixing interfaces, device changes and cleanup.
• PROV-082: Recover native renderer entry points, GL state management and shader/backend paths.
• PROV-083: Recover engine networking, packet queues, address handling and socket error policy.
• PROV-084: Recover native VM loading, dispatch, extension gates and runtime checks.
• PROV-085: Recover filesystem mounting, package checks, pure-server behavior and downloads.
• PROV-086: Recover console, command buffer, cvar registry and command registration semantics.
• PROV-087: Analyze threading, synchronization, jobs, signal handlers and crash paths.
• PROV-088: Classify anti-cheat, authentication and integrity-related code with precise evidence.
• PROV-089: Recover PE resources and inspect all icon planes, masks and surplus data.
• PROV-090: Analyze macOS application metadata and platform bootstrap code.
• PROV-091: Produce a per-component decision: replace in Rust, use a dependency, retain only as research evidence, or investigate further.
• PROV-092: Verify every replacement decision against the required behavior rather than library-name similarity.

Engine timing, filesystem and configuration

Specify engine services before relying on them in gameplay or asset conversion.

• PROV-093: Specify engine, simulation, render, server and network clock domains and units.
• PROV-094: Specify clock wrap, discontinuity, pause, timescale and long-frame behavior.
• PROV-095: Specify fixed-step accumulation, catch-up limits and tick ordering.
• PROV-096: Specify map restart, full map change and persistent versus reset state.
• PROV-097: Specify error modes, cleanup order, frame aborts and fatal termination.
• PROV-098: Recover archive discovery and runtime mount precedence from original execution.
• PROV-099: Recover loose-file overrides, writable paths and case-sensitive lookup behavior.
• PROV-100: Recover package checksums, pure lists and client package eligibility.
• PROV-101: Specify missing-file behavior, fallback lookup and diagnostics.
• PROV-102: Recover cvar types, defaults, flags, latched changes and persistence.
• PROV-103: Recover console command tokenization, quoting, aliases and buffered execution.
• PROV-104: Recover config execution order, bindings and command-line overrides.
• PROV-105: Recover save locations and configuration migration behavior.
• PROV-106: Specify server info, user info and protocol-visible key/value constraints.
• PROV-107: Specify file-handle, memory and other resource limits and their failure behavior.
• PROV-108: Document resource lifetime across reconnect, restart and renderer reset.

Network, external services and demos

Do not assume historical services remain available; preserve protocol evidence and make replacement policy explicit.

• PROV-109: Recover packet framing, endian conventions, limits and sequence arithmetic.
• PROV-110: Recover connectionless discovery, challenge, connect and rejection messages.
• PROV-111: Recover reliable command queues, acknowledgements, retransmission and overflow behavior.
• PROV-112: Recover netchannel fragmentation, ordering, duplicate handling and timeouts.
• PROV-113: Recover user-command encoding, deltas, timestamps and validation.
• PROV-114: Recover snapshot/entity/player-state serialization and baseline selection.
• PROV-115: Recover configstrings, gamestate transmission and protocol negotiation.
• PROV-116: Recover bandwidth, rate, packet timing and snapshot scheduling settings.
• PROV-117: Recover prediction acknowledgements and reconciliation inputs.
• PROV-118: Specify disconnect, reconnect, zombie-client and timeout state transitions.
• PROV-119: Recover server browser, master registration and query protocols.
• PROV-120: Recover authentication packets, identities, permissions and deferred admission/drop behavior.
• PROV-121: Recover moderation, role announcements and failure/fallback policy.
• PROV-122: Recover download URLs, package negotiation, resume and integrity checks.
• PROV-123: Recover demo headers, message streams, playback clocks and compatibility rules.
• PROV-124: Recover demo seeking, interruption and malformed-demo handling.
• PROV-125: Identify voice, chat and radio network messages and recipient rules.
• PROV-126: Document LAN, IPv4, IPv6 and address parsing behavior where supported by evidence.
• PROV-127: Create protocol fixtures for every message family and edge case.
• PROV-128: Decide original-protocol compatibility versus a versioned replacement protocol with documented tradeoffs.
• PROV-129: Define local operation when external services are unavailable.
• PROV-130: Define authorization and transport requirements for any replacement external service.

Movement, collision and combat

Use measured reference trajectories and events to turn static findings into a gameplay contract.

• PROV-131: Recover player hulls, stance transitions and collision masks.
• PROV-132: Recover walking, running, sprinting, acceleration, friction and stopping.
• PROV-133: Recover jumping, wall movement, ledge interactions and chained movement.
• PROV-134: Recover stamina, exhaustion, recovery and movement restrictions.
• PROV-135: Recover crouch, slide and stance-dependent speed or weapon restrictions.
• PROV-136: Recover gravity, slopes, stairs, clipping and grounded-state decisions.
• PROV-137: Recover water, ladder, trigger and environmental movement.
• PROV-138: Recover moving-platform interaction and collision with other players.
• PROV-139: Recover fall damage, impact response and landing effects.
• PROV-140: Recover view angles, angle quantization, recoil and camera behavior.
• PROV-141: Recover weapon definitions, inventory slots and gear restrictions.
• PROV-142: Recover selection, switching, raising, lowering and interrupted actions.
• PROV-143: Recover firing modes, burst cadence, ammunition and reload timing.
• PROV-144: Recover spread, random seeds, recoil accumulation and recovery.
• PROV-145: Recover hit traces, hit regions, penetration and material interactions.
• PROV-146: Recover projectile trajectories, bounce, fuse, explosion and ownership.
• PROV-147: Recover damage, armor, bleeding, healing and death attribution.
• PROV-148: Recover friendly fire, team damage and self-damage rules.
• PROV-149: Recover melee and special interactions discovered in game logic.
• PROV-150: Recover spawn protection, respawn, telefrag and loadout initialization.
• PROV-151: Recover animation/event synchronization for local and remote combat.
• PROV-152: Create boundary fixtures for simultaneous hits, death, reload, weapon change and tick transitions.
• PROV-153: Define acceptable numeric tolerances from reference measurements.
• PROV-154: Investigate cross-platform float and integer differences before fixing deterministic simulation policy.

Entities, maps and game modes

Cover every supplied playable map and every discovered entity class; examples and unused variants still need documented dispositions.

• PROV-155: Recover map entity grammar, keys, defaults and parse errors.
• PROV-156: Recover spawn filters, mode flags, team restrictions and target linking.
• PROV-157: Recover movers, doors, buttons, platforms and timed entity thinks.
• PROV-158: Recover triggers, teleporters, hazards, breakables and usable objects.
• PROV-159: Recover item pickup, spawning, respawning and dropped-object behavior.
• PROV-160: Recover objective entities, ownership, activation and visibility rules.
• PROV-161: Recover map scripts, target chains and map-specific special behavior.
• PROV-162: Recover spawn-point choice, collision rejection and team balancing.
• PROV-163: Specify FFA scoring, match completion and respawn flow.
• PROV-164: Specify Last Man Standing round flow and elimination rules.
• PROV-165: Investigate the absent game-type ID 2 and unsupported or reserved mode handling.
• PROV-166: Specify Team Deathmatch scoring and team lifecycle.
• PROV-167: Specify Team Survivor rounds, readiness, elimination and tie resolution.
• PROV-168: Specify Follow the Leader selection, protection and victory conditions.
• PROV-169: Specify Capture and Hold objectives, timing and scoring.
• PROV-170: Specify Capture the Flag pickups, drops, returns and captures.
• PROV-171: Specify Bomb planting, defusing, timers and round outcomes.
• PROV-172: Specify Jump mode rules, timing, checkpoints and map metadata.
• PROV-173: Specify Freeze Tag freeze, thaw, elimination and round flow.
• PROV-174: Specify Gun Game progression, demotion and victory conditions.
• PROV-175: Specify instagib and other modifiers independently of base mode IDs.
• PROV-176: Specify warmup, ready state, intermission, overtime, timeouts and match restarts.
• PROV-177: Specify spectators, following, substitutes and team changes.
• PROV-178: Specify scoring, statistics, medals and end-of-match reporting.
• PROV-179: Specify votes, team votes, admin commands and permissions.
• PROV-180: Specify bot spawning, navigation, tactics and difficulty behavior.
• PROV-181: Create per-map entity, collision, lighting, objective and mode coverage records.
• PROV-182: Classify ut4_jumpents and other examples without assuming they are normal playable maps.
• PROV-183: Define the expected result for broken, unreachable or unused entity content.
• PROV-184: Create complete scenario matrices for every supported mode and supplied playable map.

Client UI, input and audio behavior

Include the interactions around gameplay, not only the simulation.

• PROV-185: Recover startup screens, menu hierarchy and transitions.
• PROV-186: Recover server browser sorting, filtering, favorites and refresh behavior.
• PROV-187: Recover connect/download/loading progress and cancellation.
• PROV-188: Recover character, team, weapon and equipment selection flows.
• PROV-189: Recover HUD layout, scaling, colors, indicators and timers.
• PROV-190: Recover scoreboard, spectator overlays and match information.
• PROV-191: Recover console history, completion, scrolling and notifications.
• PROV-192: Recover chat, radio menus, message formatting and recipient feedback.
• PROV-193: Recover key bindings, mouse sensitivity, acceleration and controller-related paths if present.
• PROV-194: Recover focus loss, key repeat, text input and cursor capture.
• PROV-195: Recover localization, font fallback, text limits and encoding behavior.
• PROV-196: Recover audio event selection, spatialization, attenuation and channel priorities.
• PROV-197: Recover sound interruption, looping, music, volume and mute semantics.
• PROV-198: Recover accessibility-relevant visual/audio cues and current configuration behavior.
• PROV-199: Recover screenshot, demo recording and other user-facing utilities.
• PROV-200: Specify disconnected, unavailable-service and malformed-content error presentations.
• PROV-201: Create UI flow fixtures and reference captures for all menu states.
• PROV-202: Distinguish fidelity requirements from optional usability improvements in a decision log.

Extraction, variants and conversion infrastructure

Keep original installation objects only in .cache. Preserve extracted variants under assets/extracted and converted products under clearly versioned asset paths.

• PROV-203: Revalidate all 23 PK3 manifests, occurrences, hashes and extraction safety guarantees.
• PROV-204: Verify extraction reproducibility from the original cache on a clean working directory.
• PROV-205: Audit path traversal, absolute paths, collisions and duplicate ZIP names.
• PROV-206: Record archive encoding, compression, CRC and damaged-member behavior.
• PROV-207: Build a format registry with strict parsers and explicit unsupported-format reports.
• PROV-208: Define stable source/member/content IDs for converted assets.
• PROV-209: Define a variant resolver only after runtime VFS precedence is established.
• PROV-210: Define conversion schemas, tool versions, settings and output manifests.
• PROV-211: Separate archival extraction, inspection products and runtime bundles.
• PROV-212: Add incremental conversion keyed by source hashes and settings.
• PROV-213: Add dependency tracking and invalidation for shared materials, models and maps.
• PROV-214: Provide dry-run, targeted conversion, full conversion and verification commands.
• PROV-215: Make conversion failures actionable with source identity and byte offsets.
• PROV-216: Preserve raw unknown subrecords and surplus bytes alongside interpreted data.
• PROV-217: Define archive/member provenance in every generated runtime asset.
• PROV-218: Detect missing references, cycles, case mismatches and cross-package dependencies.
• PROV-219: Provide content statistics, conversion coverage and semantic-loss reports.
• PROV-220: Verify parallel conversion produces deterministic output.
• PROV-221: Validate bundle schemas and checksums independently of the game runtime.
• PROV-222: Document fresh-checkout reconstruction and cache requirements.

Textures, shaders, materials and fonts

Rendering conversion must retain the legacy semantics and document any approximation needed by Solari.

• PROV-223: Inventory every image format, dimensions, channels, alpha and color-space assumptions.
• PROV-224: Decode all texture variants without destructive overwriting.
• PROV-225: Recover texture coordinate orientation, wrapping and filtering behavior.
• PROV-226: Recover mip generation, compression, picmip and texture quality rules.
• PROV-227: Analyze alpha cutout thresholds, transparent edges and premultiplied-alpha assumptions.
• PROV-228: Classify diffuse, lightmap, normal-like, environment and UI imagery by actual use.
• PROV-229: Parse the complete shader-script grammar and preserve unknown directives.
• PROV-230: Recover shader lookup, duplicate definitions and missing-shader fallback behavior.
• PROV-231: Recover stage ordering, texture animation and blend functions.
• PROV-232: Recover alpha tests, depth writes/tests, culling and sorting.
• PROV-233: Recover tcGen, tcMod, rgbGen and alphaGen behavior.
• PROV-234: Recover vertex deformation, billboards, autosprites and wave functions.
• PROV-235: Recover sky, fog, portals, mirrors and environment mapping.
• PROV-236: Recover surface parameters that affect collision, footsteps, damage or gameplay.
• PROV-237: Recover lightmap, vertex lighting, dynamic light and fullbright interactions.
• PROV-238: Define a source-shader-to-runtime-material mapping with supported, approximated and unresolved fields.
• PROV-239: Document how multipass or nonphysical effects interact with Solari lighting.
• PROV-240: Convert font atlases and recover glyph metrics, kerning and text placement.
• PROV-241: Convert UI textures with reference pixel alignment and scaling checks.
• PROV-242: Build representative material scenes and compare all distinct shader feature combinations.
• PROV-243: Keep every original shader and texture variant traceable through the converted bundle.
• PROV-244: Generate a material compatibility report rather than silently dropping unsupported stages.

Models, animation, maps and sound assets

Format names and variants must be confirmed from inventory signatures rather than presumed from extensions.

• PROV-245: Implement parsers for every discovered model format and version.
• PROV-246: Recover model coordinate systems, units, bounds and orientation.
• PROV-247: Recover surfaces, vertices, indices, normals, UVs and per-surface materials.
• PROV-248: Recover frame animation, skeletons, weights and compression where present.
• PROV-249: Recover tags, attachment transforms and weapon/character assembly.
• PROV-250: Recover animation configuration, frame ranges, looping and transition timing.
• PROV-251: Recover skins, body parts, team variants and customization references.
• PROV-252: Validate animation interpolation, bounds and normal reconstruction against reference output.
• PROV-253: Convert models into versioned runtime formats with preserved provenance.
• PROV-254: Implement parsers for every discovered BSP version and lump.
• PROV-255: Recover brush planes, solids, collision contents and trace rules.
• PROV-256: Recover world surfaces, triangle soups, patches and tessellation rules.
• PROV-257: Recover inline models, mover origins and transform conventions.
• PROV-258: Recover BSP tree, leaves, visibility clusters and area connectivity.
• PROV-259: Recover lightmaps, light grids, vertex colors and lighting metadata.
• PROV-260: Recover entity lumps and references to external assets.
• PROV-261: Recover sky, fog volumes, portals and map-specific rendering data.
• PROV-262: Investigate navigation files and bot authoring data separately from render geometry.
• PROV-263: Convert map visual, collision, visibility, entity and navigation products independently.
• PROV-264: Validate every map’s extents, scale, spawn positions and world orientation.
• PROV-265: Decode every audio format and preserve source variant identities.
• PROV-266: Recover sample rates, channels, loop points and codec metadata.
• PROV-267: Convert runtime audio with documented resampling and loudness decisions.
• PROV-268: Inventory music, voice, radio, ambient and effects categories and dependencies.
• PROV-269: Inspect auxiliary text, scripts, configs, thumbnails, icons and authoring files.
• PROV-270: Produce a final disposition and conversion result for every nonruntime auxiliary asset.

Bevy and Solari feasibility and renderer

The target remains Rust + Bevy + Solari on macOS and Linux. Support is a research gate, not an assumed property of an unverified version or GPU.

• PROV-271: Verify current Bevy, Solari and wgpu requirements using pinned official sources before choosing versions.
• PROV-272: Build a minimal Solari executable on macOS and Linux using the intended toolchain.
• PROV-273: Measure required GPU features and limits on the intended macOS and Linux hardware.
• PROV-274: Record a support matrix for CPU architecture, GPU, driver, backend and operating system.
• PROV-275: Determine whether all target platforms can meet the Solari requirements; document blockers and a concrete decision gate.
• PROV-276: Define explicitly any approved renderer alternatives or target changes if feasibility fails; do not silently substitute them.
• PROV-277: Choose pinned dependency versions only after the feasibility experiment.
• PROV-278: Import a small real map section and one real animated model into the renderer.
• PROV-279: Validate geometry eligibility, material restrictions and acceleration structure behavior.
• PROV-280: Recover original renderer conventions for handedness, depth, projection and camera transforms.
• PROV-281: Define world chunking, mesh preparation and scene registration for Solari.
• PROV-282: Investigate animated meshes, dynamic movers, particles and geometry update costs.
• PROV-283: Map legacy lightmaps, emissive surfaces, dynamic lights and environment lighting into the chosen lighting model.
• PROV-284: Define treatment of transparency, alpha cutouts, fog, sky and special shader effects.
• PROV-285: Define viewmodel rendering, first-person depth and HUD compositing.
• PROV-286: Define shadow behavior and moving-object lighting requirements.
• PROV-287: Measure temporal history, disocclusion, motion and camera-cut artifacts.
• PROV-288: Test quality and noise under fast movement and gameplay-critical visibility.
• PROV-289: Define resolution scaling, anti-aliasing, post-processing and display color behavior.
• PROV-290: Measure frame pacing, pipeline compilation, loading stalls and memory use.
• PROV-291: Define GPU diagnostics, capability errors and device-loss recovery.
• PROV-292: Compare original and rewritten rendering with documented intentional differences.
• PROV-293: Establish acceptable visual and latency budgets from measured hardware results.
• PROV-294: Document renderer-specific conversion requirements and unsupported cases per asset.

Rust architecture and implementation

Implementation follows recovered specifications and fixtures; crate boundaries remain provisional until a vertical slice tests them.

• PROV-295: Design crate boundaries for shared simulation, protocol, content, client, server and tools.
• PROV-296: Define stable gameplay/content IDs independent of Bevy entity identifiers.
• PROV-297: Define typed simulation state, events, commands and schema versioning.
• PROV-298: Separate authoritative simulation, client prediction, interpolation and presentation.
• PROV-299: Implement deterministic fixed-step scheduling with the recovered ordering contract.
• PROV-300: Implement bounded numeric conversions, RNG and timestamp arithmetic.
• PROV-301: Implement collision queries and player movement against converted maps.
• PROV-302: Implement weapons, damage, inventory and player lifecycle from reference fixtures.
• PROV-303: Implement entity registry, triggers, movers and target chains.
• PROV-304: Implement each game mode with shared and mode-specific state machines.
• PROV-305: Implement bots and navigation after their behavior and assets are specified.
• PROV-306: Implement dedicated-server startup, configuration and headless scheduling.
• PROV-307: Implement protocol transport, serialization, queues and resource limits.
• PROV-308: Implement connection state machine, snapshots and reliable commands.
• PROV-309: Implement prediction, reconciliation and remote interpolation.
• PROV-310: Implement demos, recording, playback and protocol-version policy.
• PROV-311: Implement client states for startup, import, menu, connect, load, play and errors.
• PROV-312: Implement asynchronous asset loading with dependency progress and cancellation.
• PROV-313: Implement Bevy input, window management, audio and UI integration.
• PROV-314: Implement console, cvars, commands, bindings and persistence.
• PROV-315: Implement server browser, chat, radio, scoreboard and loadout UI.
• PROV-316: Implement authentication/service interfaces and offline behavior from explicit policy.
• PROV-317: Implement admin, votes, readiness, timeouts and match administration.
• PROV-318: Implement structured diagnostics and errors with recovered recovery boundaries.
• PROV-319: Implement resource cleanup across reconnect, map restart, unload and shutdown.
• PROV-320: Keep any QVM interpreter isolated as a research tool rather than release gameplay.
• PROV-321: Provide version/content negotiation and clear incompatible-bundle errors.
• PROV-322: Create a runnable vertical slice before committing to the complete architecture.
• PROV-323: Eliminate original executable, QVM and DLL runtime dependencies from the finished rewrite.
• PROV-324: Document public interfaces, invariants and subsystem maintenance procedures.

Platform delivery, performance and operations

Platform completion includes installation and operation, not only compilation.

• PROV-325: Define supported macOS and Linux releases and CPU architectures from measured feasibility.
• PROV-326: Validate Rust toolchain, compiler flags and native dependency requirements.
• PROV-327: Build client and dedicated server for each declared target.
• PROV-328: Validate macOS app bundles, resources, permissions and distribution requirements.
• PROV-329: Validate Linux packaging, launch integration and runtime library requirements.
• PROV-330: Test clean installation, first import, content verification and first launch.
• PROV-331: Test configuration paths, Unicode paths, permissions and read-only installations.
• PROV-332: Test display scaling, fullscreen, multiple monitors and focus changes.
• PROV-333: Test audio devices, hotplug and platform input behavior.
• PROV-334: Test offline play, LAN hosting, remote connections and server shutdown.
• PROV-335: Define server deployment, logs, monitoring and restart procedures.
• PROV-336: Profile simulation, networking, loading, render submission and GPU work.
• PROV-337: Set measurable CPU, GPU, memory, disk and bandwidth budgets.
• PROV-338: Investigate content streaming and memory eviction where measurements require it.
• PROV-339: Test sustained sessions, repeated map rotations and resource leaks.
• PROV-340: Test low-resource conditions, disk-full errors and unavailable devices.
• PROV-341: Document crash diagnostics and reproducible bug-report bundles.
• PROV-342: Validate upgrades, schema changes, cache invalidation and rollback behavior.

Conformance, regression and completion gates

A completed parser, rendered map or passing synthetic branch test is evidence for that slice only.

• PROV-343: Define per-subsystem acceptance criteria before checking implementation tasks complete.
• PROV-344: Create golden movement traces for all stances and movement interactions.
• PROV-345: Create golden combat traces for every weapon and damage interaction.
• PROV-346: Create golden entity and objective traces for all discovered classes.
• PROV-347: Create complete lifecycle traces for all game modes.
• PROV-348: Create network fixtures for loss, duplication, reordering, jitter and sequence wrap.
• PROV-349: Create protocol rejection and malformed-content regression fixtures.
• PROV-350: Create visual comparisons for every material feature and representative scene.
• PROV-351: Create per-map collision, visibility, spawn and objective validation suites.
• PROV-352: Create UI navigation and input-binding regression scenarios.
• PROV-353: Create audio event and spatialization comparison scenarios.
• PROV-354: Separate exact binary/protocol checks from tolerant physics, visual and audio comparisons.
• PROV-355: Run relevant fixtures on every declared macOS/Linux architecture and GPU tier.
• PROV-356: Verify client/server parity with mixed-platform sessions.
• PROV-357: Verify prediction under latency and correction without relying on local-only tests.
• PROV-358: Verify bots, spectators, downloads, demos and administration in complete sessions.
• PROV-359: Verify deterministic conversion and reproducible runtime bundles.
• PROV-360: Validate all original file/member dispositions and remaining unknown regions.
• PROV-361: Maintain a deviation register with justification, evidence and user-approved product decisions where needed.
• PROV-362: Define a first vertical-slice gate: imported map, movement, one weapon, local server and measured Solari rendering.
• PROV-363: Define a multiplayer gate: remote transport, prediction, combat and lifecycle across both platforms.
• PROV-364: Define an all-content gate: every supported mode and supplied playable map has recorded acceptance evidence.
• PROV-365: Define a release gate: native installation, complete provenance, required services, performance and recovery checks pass.
• PROV-366: Reject final completion while required unknown behaviors, unsupported assets or target-platform blockers remain.

Repository, distribution and ongoing planning

Use the single Hugging Face repository for code and assets. Original installation objects remain only in the ignored cache.

• PROV-367: Audit attributes so code/docs remain normal Git and assets remain LFS/Xet pointers.
• PROV-368: Verify original hashes cannot enter ordinary Git blobs, asset pointers or pushed history.
• PROV-369: Verify extracted and converted assets are clearly separated from original installation files.
• PROV-370: Test the storage hooks on a clean clone with missing setup and malformed pointers.
• PROV-371: Verify asset upload and download integrity through the configured Hugging Face remote.
• PROV-372: Document recovery from interrupted uploads and unavailable remote storage.
• PROV-373: Keep bulk analysis artifacts in assets and compact evidence/index documents in normal Git.
• PROV-374: Record licensing and provenance for every dependency and content category.
• PROV-375: Determine redistribution rights and requirements before assembling public runtime bundles.
• PROV-376: Define code, asset and research artifact release versioning.
• PROV-377: Document build, import, conversion, research and gameplay reproduction commands.
• PROV-378: Maintain CI for relevant script checks, Rust validation and storage-policy enforcement.
• PROV-379: Provide contributor instructions for evidence claims and checklist completion.
• PROV-380: Convert selected PROV tasks into canonical RE/AP/RW/QA/MAP/FILE tasks without losing cross-links.
• PROV-381: Review the provisional backlog after each research batch and split tasks revealed to contain independent unknowns.
• PROV-382: Keep IDs stable; retire obsolete tasks with reasons and replacement links rather than renumbering.
• PROV-383: Record unresolved decisions on protocol compatibility, service replacement, visual fidelity and target hardware.
• PROV-384: Publish milestone evidence and an honest remaining-work summary with each meaningful release.

Maintenance and next selection

This revision contains 384 provisional tasks. Select a few bounded items at a time, prioritizing the first research batch and the renderer/platform feasibility experiments. Selection does not waive the remaining scope. Update findings only when new evidence exists; this document adds planning detail, not new reverse-engineering conclusions.

Before marking a broad subsystem complete, reconcile it with the canonical checklist, the per-file coverage registry, variant conversion reports, runtime fixtures and the deviation register. Keep unfinished and blocked work visible with the specific missing evidence or dependency.

Research progress: BSP plane boundaries and bounded node traversal completes bounded RE-317–319. Broad geometry/runtime/port milestones remain open; see RE-320 for full traversal and loading work.

Research progress: native BSP payload loading completes bounded RE-321–323. Complete asset conversion and geometry milestones remain open; RE-324 tracks actual variant audits, validation, reference ownership and runtime fixtures.

Research progress: leaf references and area portal state completes bounded RE-325–327. Broad geometry/networking/runtime milestones remain open; RE-328 tracks complete flooding, reference ownership and snapshot consumers.

Research progress: area flooding and bit output completes bounded RE-329–331. Broad runtime/networking milestones remain open; RE-332 tracks real-map labels, lifecycle and snapshot consumers.

Research progress: snapshot area-mask lifecycle completes bounded RE-333–335. Full networking/renderer/runtime milestones remain open; RE-336 tracks real viewpoint selection, codecs, client parsing and mask consumers.

Research progress: client area-mask parsing completes bounded RE-337–339. Broad protocol/renderer/runtime milestones remain open; RE-340 tracks actual codec/cursors, validation/publication and real packet/platform coverage.

Research progress: message read modes and assembly completes bounded RE-341–343. Broad networking/runtime milestones remain open; RE-344 tracks real Huffman codecs, caller invariants and packet/platform fixtures.

Research progress: Huffman helper probes completes bounded RE-345–347. Broad protocol/runtime milestones remain open; RE-348 tracks full send, initialized trees/codebooks, actual packet round trips and platform coverage.

Research progress: bounded Huffman encoding completes RE-349–351. Broad network/runtime milestones remain open; RE-352 tracks adaptive initialization/codebooks, real message packets and platform fixtures.

Research progress: Huffman initialization completes bounded RE-353–355. Broad network/runtime milestones remain open; RE-356 tracks adaptive updates, initialized codewords and actual message/packet/platform fixtures.

Research progress: adaptive Huffman updates completes bounded RE-357–359. Broad network/runtime milestones remain open; RE-360 tracks complete swap/tie paths, second-object equivalence, actual trained codebooks and real packet/platform fixtures.

Research progress: differential Huffman codebook completes bounded RE-361–363. Broad network/runtime milestones remain open; RE-364 tracks full native-training/codeword conformance and complete real packet/platform contracts.

Research progress: message byte codec completes bounded RE-365–367. Broad network/runtime milestones remain open; RE-368 tracks general message/snapshot codecs, overflow/truncation/padding and real native packet/platform validation.

Research progress: message width codecs completes bounded RE-369–371. Broad network/runtime milestones remain open; RE-372 tracks wrappers/delta/snapshot codecs, message lifecycle and actual packet/platform validation.

Research progress: message wrappers completes bounded RE-373–375. RE-376 leaves ReadData/compressed/string/delta/snapshot compositions, sentinel/lifecycle/alias and actual packet/platform validation open.

Research progress: message strings and data reads completes bounded RE-377–379. RE-380 leaves compressed/library/caller-lifetime/alias/lifecycle and higher-level packet/platform contracts open.

Research progress: numeric message codecs completes bounded RE-381–383. RE-384 leaves delta/snapshot/angle callers and complete compressed/numeric-control/runtime/platform contracts open.

Research progress: scalar message deltas completes bounded RE-385–387. RE-388 leaves keyed/usercmd/entity/player/snapshot and complete caller/overflow/EOF/floating/runtime/platform contracts open.

Research progress: keyed message deltas completes bounded RE-389–391. RE-392 leaves keyed caller/narrowing/index reachability, higher-level codecs and actual runtime/packet/platform contracts open.

Research progress: keyed usercmd codecs completes bounded RE-393–395 (time/key dispatch, record fields/narrowing and 204 modeled-tree streams). RE-392/396 retain legal callers, packet baselines/higher-level codecs and actual runtime/platform work; broad networking and rendering milestones remain open.

Research progress: usercmd caller/hash/bundle evidence completes bounded RE-397–399. RE-396/400 retain state producers, timestamp/VM acceptance, full bundle/netchan/runtime/platform and higher-level codecs; broad game/network/rendering milestones remain open.

Research progress: server usercmd acceptance completes bounded RE-401–403. RE-400/404 retain producers/time clamping/QVM effects/full packet/runtime/platform work; game/network/rendering milestones remain open.

Research progress: native/QVM usercmd bridge completes bounded RE-405–407. RE-404/408 retain producers/translation/VM effects/movement/full packet/runtime/platform contracts; broad game/network/rendering milestones remain open.

Research progress: QVM think routes/inactivity/mode gates completes bounded RE-409–411. RE-408/412 retain producers/action effects/movement/simulation/full-command/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM movement-frame setup completes bounded RE-413–415. RE-412/416 retain consumers/physics/callbacks/producers/full simulation/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM movement scheduler/output gates completes bounded RE-417–419. RE-416/420 retain actual child clock/physics/callbacks/event effects/full movement/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM child flags/clock/dispatch completes bounded RE-421–423. RE-420/424 retain omitted child/callee/physics/native effects and complete gameplay/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM view/basis/position tails completes bounded RE-425–427. RE-424/428 retain native trig/callees/full mode physics/composition/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM command scale/acceleration completes bounded RE-429–431. RE-428/432 retain native sqrt/friction/producers/legal ranges/full mode/collision/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM friction policies completes bounded RE-433–435. RE-432/436 retain live coefficients/producers/native sqrt/full mode-state/collision/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM content/ground producers completes bounded RE-437–439. RE-436/440 retain native callbacks/helper effects/full collision-state composition/live policy/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM posture bounds and transitions completes bounded RE-441–443. RE-440/444 retain native collision/callee effects/resource and semantic producers/full state composition/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM animation helpers and contacts completes bounded RE-445–447. RE-444/448 retain native collision/resource/semantic producers, live animation tables/contact consumers/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM animation assets and tables completes bounded RE-449–451: verified variants/symbols/model selectors, loader records/partial EOF and source-derived timed-helper bridges. RE-448/452 retain native preprocessing/live tables/playback/contact/full-state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM resource update and consumers completes bounded RE-453–455: reset/drain/recovery/counter policy, selected caller arguments and resource/posture/scale bridges. RE-444/448/452/456 retain native effects/semantic producers/live animation/contact/full-state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM timer aging and main routing completes bounded RE-457–459: countdown policy, main request/mode ordering and clock/posture/animation bridges. RE-456/460 retain actual helpers/producers/full environment-state composition/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM traversal-query recovery completes bounded RE-461–463: direction/release, short hull transition policy and evaluated query-to-main outputs. RE-460/464 retain native collision/clearance/actions/producers/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM side-hull and conditional gravity recovery completes bounded RE-465–467:56335 geometry/acceptance, derived query/main Boolean chains and41768 tail/main handoffs. RE-464/468 retain actual collision/native effects/producers/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM step/wrapper collision policy completes bounded RE-469–471: raised/down/overlap traces and clipping, fallback/height stores, evaluated wrapper-to-gravity composition. RE-468/472 retain actual slide/native collision/producers/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM slide preparation/first trace completes bounded RE-473–475: gravity/planes, complete first exits and partial contact/touch policy, actual clear-slide caller chain. RE-472/476 retain multi-plane/repeated-bump/native collision/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM slide plane gate/candidates completes bounded RE-477–479: capacity/dedup/nudge, first candidate/impact/both clips and real contact-prefix continuations. RE-476/480 retain secondary planes/crease/commit/repeated bumps/native collision/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM secondary-plane solver completes bounded RE-481–483: independent reclip/commit, original-vector crease projections/two supplied roots/third-plane return and40 contact continuations. Three chains complete an early slide return; normal paths remain partial before bump advance. RE-480/484 retain repeated bumps/native collision/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM bump/common exit/second trace completes bounded RE-485–487: four-bump gate, end/saved vector precedence/flag/return policy and48 evaluated contact-to-second-request chains with complete supplied clear/allsolid exits. RE-484/488 retain repeated contact/native collision/full state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM continuous repeated contacts completes bounded RE-489–491: actual trace3/4, accumulated plane/time/end/touch/impact state and four-bump exhaustion versus early returns across76 probes. Native responses remain supplied. RE-488/492 retain native collision/full callers/legal state/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM contact slide caller composition completes bounded RE-493–495: both actual slide children inside step/wrapper, down/overlap/fallback/height policy and actual mode-tail state across22 fixtures. Native responses remain supplied. RE-492/496 retain native collision/legal state/main/full runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM clock/main/contact composition completes bounded RE-497–499: actual clock/timer state, exact-expiry source routing and selected contact chain back to main requests across48 fixtures. Native responses/other main effects remain supplied or omitted. RE-496/500 retain missing producers/native collision/full main/scheduler/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM pre/post main environment completes bounded RE-501–503: actual content/ground producers, ground touches/derived routing, normal-to-motion and post-resampling state across48 fixtures. Native responses/other callee effects remain supplied or omitted. RE-500/504 retain posture/ground callees/native collision/action/other modes/full main/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM actual main posture completes bounded RE-505–507: live posture transitions/resource, evaluated animation-before-height/timer ordering and derived hull/viewheight consumers across28 fixtures. Native responses/remaining main effects stay supplied or omitted. RE-504/508 retain ground/native/input/resource/other modes/full main/runtime/platform work; broad game/rendering milestones remain open.

Research progress: QVM ground loss and landing prefix completes bounded RE-509–511: actual ground-loss body/animation, landing discriminant/time/impact/timer prefix and16 main caller-order chains. Full landing/native/action effects remain open under RE-508/512; broad game/rendering/runtime/platform milestones remain open.

Research progress: QVM landing severity/event queue/caller completes bounded RE-513–515: two-slot queue writers, full landing body and actual ground/main timer ordering. Numeric event/PS216 semantics and native/remaining main effects remain open under RE-512/516; broad game/rendering/runtime/platform milestones remain open.

Research progress: QVM allsolid recovery completes bounded RE-517–519: ordered27-point search, original-origin retrace/record priority and16 ground/main continuations. Trace responses remain supplied; RE-516/520 retain native collision/legal/combined main/runtime/platform work and broad game/rendering milestones.

Research progress: QVM combined posture/ground callees completes bounded RE-521–523: source-ordered shared posture/recovery/lost/landing/animation/touch state, temporal timers/hulls and reached movement/post environment across18 fixtures. RE-520/524 retain native/action/query/other modes/consumers/full runtime/platform work and broad game/rendering milestones.

Research progress: QVM54981 forward traces/rebase/main routing completes bounded RE-525–527: contact-bit geometry/retrace, recursive origin/landing and actual post-timer main producer across42 standalone/16 main cases. RE-524/528 retain nested ground-loss action/query/other modes/native/consumers/full runtime/platform work and broad game/rendering milestones.

Research progress: QVM nested ground-loss action completes bounded RE-529–531: actual54981(1) before sentinel/flags, rebased deep-query priority and distinct later main54981(0) across48 standalone/12 main cases. RE-528/532 retain query/other modes/native/consumers/full runtime/platform work and broad game/rendering milestones.

Research progress: QVM shared query/main acquisition event completes bounded RE-533–535: actual side-clearance child, full query state into main and reached event23 queue across30 standalone/20 main cases. RE-532/536 retain other modes/combined producers/native/consumers/full runtime/platform work and broad game/rendering milestones.

Research progress: QVM57312 active-state mode completes bounded RE-537–539: live friction/scale/acceleration, wish overwrite, stationary query and gravity-off slide across66 standalone/12 main cases. RE-536/540 retain combined producers/other modes/native/runtime work. The progress assessment estimates5–10% overall and0% playable Rust runtime, with evidence and uncertainty.

Research progress: QVM55465 flagged movement completes bounded RE-541–543: relevant entry impulse/byte writes, bit16 bypass, wish/cap/inline clip, measured post-slide resource and actual main branch across50 standalone/8 main cases. RE-540/544 retain other entry/movement bodies, combined/native/reference/full runtime/platform scope. No Rust runtime or assets change.

Research progress: full40966 entry completes RE-545 with84 finite helper fixtures; native/caller/platform and content work remain open.

Research progress: walking entry routing completes RE-546 with24 prefix/4 main fixtures; full movement/native/platform work remains open.

Research progress: ordinary air continuation completes RE-547 with12 air/10 main fixtures. RE-548 retains wall/walking/other-mode/native/combined/full runtime and platform scope. No assets or Rust runtime change.

Research progress: RE-549 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-550 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-551 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-552 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-553 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-554 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-555 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-556 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-557 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-558 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-560 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-561 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-562 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-563 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-564 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-565 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-566 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-567 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-568 report; remaining native/content/runtime/platform scope stays open.

The RE-560–569 consumer batch closes bounded freeflight, water events, torso/reload/interaction controls and locomotion. The weapon body beyond50871 still prevents a complete main tick. Prioritize the ten concrete follow-ups listed there; full native/reference/content/platform gameplay scope remains open.

Research progress: RE-569 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-571 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-572 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-573 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-574 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-575 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-576 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-577 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-578 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-579 report; remaining native/content/runtime/platform scope stays open.

The RE-571–580 weapon batch closes bounded lookup, selection/completion, helper50525 and pre-firing return branches. Its next ten tasks prioritize51802+ firing/availability and complete main/reference validation. Rust/Bevy/Solari macOS/Linux runtime, native/content/rendering and whole-game scope remain open.

Research progress: RE-580 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-582 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-583 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-584 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-585 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-586 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-587 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-588 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-589 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-590 report; remaining native/content/runtime/platform scope stays open.

The RE-582–591 firing batch completes the bounded50746 QVM producer, six-consumer main suffix and timer/publication sequences. Prioritize its next ten tasks for event31 consumers, native/reference contracts, complete step/scheduler composition, asset identity and Rust/Bevy/Solari macOS/Linux runtime work.

Research progress: RE-591 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-593 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-594 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-595 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-596 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-597 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-598 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-599 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-600 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-601 report; remaining native/content/runtime/platform scope stays open.

The RE-593–602 server firing batch recovers event31 routing, server basis/muzzle/dispatch and selected temp-event/grenade/base setup. Its next ten tasks prioritize293732/295018, real entity allocation/query/linking and projectile/damage callbacks. Original reference, asset mapping and full Rust/Bevy/Solari macOS/Linux/native/rendering/network scope remain open.

Research progress: RE-602 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-604 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-605 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-606 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-607 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-608 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-609 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-610 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-611 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-612 report; remaining native/content/runtime/platform scope stays open.

The RE-604–613 allocation/spread batch recovers source allocation and its temp-event/grenade compositions, spread prefixes/sampling and shot frames. Follow its ten concrete next tasks for remaining aim, trace/contact/damage and lifecycle work. Original references and full Rust/Bevy/Solari macOS/Linux/native/content/network/rendering scope remain open.

Research progress: RE-613 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-615 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-616 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-617 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-618 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-619 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-620 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-621 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-622 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-623 report; remaining native/content/runtime/platform scope stays open.

The RE-615–624 aim/trace batch recovers complete bounded aim, trace preparation, point rotation and the event57 first-pellet trace boundary. Its next ten tasks prioritize trace results/rewind/restoration, contact/damage and full pellet aggregation. Original reference and the full Rust/Bevy/Solari macOS/Linux/native/content/network/rendering scope remain open.

Research progress: RE-624 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-626 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-627 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-628 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-629 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-630 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-631 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-632 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-633 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-634 report; remaining native/content/runtime/platform scope stays open.

The RE-626–635 trace/rewind batch recovers trace cleanup under supplied responses, snapshot/restore state, fixed player selectors and configured player_bb construction. Its next ten tasks prioritize history interpolation, model hits, contact/damage and full pellet aggregation. Original reference and full Rust/Bevy/Solari macOS/Linux/native/content/network/rendering scope remain open.

Research progress: RE-635 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-637 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-638 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-639 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-640 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-641 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-642 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-643 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-644 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-645 report; remaining native/content/runtime/platform scope stays open.

The RE-637–646 history/pellet batch recovers complete history rewind/restore and an allocated event57 twenty-pellet return path under supplied world responses. Current next tasks prioritize history production, model hits, contact/damage and nonzero-hit aggregation. Original reference and full Rust/Bevy/Solari macOS/Linux/native/content/network/rendering scope remain open.

Research progress: RE-646 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-648 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-649 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-650 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-651 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-652 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-653 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-654 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-655 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-656 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-657 report; remaining native/content/runtime/platform scope stays open.

RE-648–657 batch complete: history production and model-hit preparation. RE-658 tracks the next bounded research work; original/native parity and full Rust/Bevy/Solari gameplay remain open.

Research progress: RE-659 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-660 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-661 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-662 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-663 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-664 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-665 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-666 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-667 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-668 report; remaining native/content/runtime/platform scope stays open.

RE-659–668 batch complete: complete finite pose and lifecycle composition. RE-669 tracks continued model/trace/lifecycle recovery; original/native parity and playable Rust/Bevy/Solari integration remain open.

Research progress: RE-670 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-671 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-672 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-673 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-674 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-675 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-676 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-677 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-678 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-679 report; remaining native/content/runtime/platform scope stays open.

RE-670–679 batch complete: model transforms, resources and grenade prelude. RE-680 tracks continued geometry/trace/damage/lifecycle recovery; original/native parity and playable Rust/Bevy/Solari integration remain open.

Research progress: RE-681 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-682 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-683 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-684 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-685 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-686 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-687 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-688 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-689 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-690 report; remaining native/content/runtime/platform scope stays open.

RE-681–690 batch complete: source model geometry through rewound trace. RE-691 tracks original asset/reference validation and downstream contact/damage; playable Rust/Bevy/Solari integration remains open.

Research progress: RE-692 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-693 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-694 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-695 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-696 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-697 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-698 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-699 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-700 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-701 report; remaining native/content/runtime/platform scope stays open.

RE-692–701 batch complete: original models and Rust asset foundation. RE-702 tracks Bevy integration, native parity and downstream contact/damage; playable macOS/Linux Solari gameplay remains open.

Research progress: RE-703 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-704 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-705 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-706 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-707 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-708 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-709 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-710 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-711 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-712 report; remaining native/content/runtime/platform scope stays open.

RE-703–712 batch complete: damage factor and contact dispatch. Complete289594 handles original-model contact factors and wound bookkeeping;211239 is still captured. RE-702 is partially advanced and RE-713 tracks contact/event/health composition, native parity and Rust/Bevy/Solari platform work. No playable-game milestone is claimed.

Research progress: RE-714 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-715 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-716 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-717 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-718 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-719 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-720 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-721 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-722 report; remaining native/content/runtime/platform scope stays open.

Research progress: RE-723 report; remaining native/content/runtime/platform scope stays open.

RE-714–723 batch complete: complete contact and health prefixes. Complete292545 now uses original-model contexts through actual factor/event/feedback children;211239 entry gates and knockback selection are bounded recoveries. Full health mutations/callbacks, native parity and playable Rust/Bevy/Solari work remain open. RE-713 is partially advanced and RE-724 tracks the next work.

Research progress: RE-725 report; full native/platform/game scope remains open.

Research progress: RE-726 report; full native/platform/game scope remains open.

Research progress: RE-727 report; full native/platform/game scope remains open.

Research progress: RE-728 report; full native/platform/game scope remains open.

Research progress: RE-729 report; full native/platform/game scope remains open.

Research progress: RE-730 report; full native/platform/game scope remains open.

Research progress: RE-731 report; full native/platform/game scope remains open.

Research progress: RE-732 report; full native/platform/game scope remains open.

Research progress: RE-733 report; full native/platform/game scope remains open.

Research progress: RE-734 report; full native/platform/game scope remains open.

RE-725–734 batch: health, contact and Rust impulse findings. Complete finite211239/213009 and original-context contact composition now execute with explicit unresolved callback/native boundaries. The Rust impulse primitive matches96 fixtures; full Bevy/Solari/platform gameplay remains open. RE-724 is partially advanced and RE-735 tracks subsequent work.

Research progress: RE-736 report; full native/platform/game scope remains open.

Research progress: RE-737 report; full native/platform/game scope remains open.

Research progress: RE-738 report; full native/platform/game scope remains open.

Research progress: RE-739 report; full native/platform/game scope remains open.

Research progress: RE-740 report; full native/platform/game scope remains open.

Research progress: RE-741 report; full native/platform/game scope remains open.

Research progress: RE-742 report; full native/platform/game scope remains open.

Research progress: RE-743 report; full native/platform/game scope remains open.

Research progress: RE-744 report; full native/platform/game scope remains open.

Research progress: RE-745 report; full native/platform/game scope remains open.

RE-736–745 batch validation:1413 Python and56 Rust tests pass after ten separately checked task commits. Protected lifecycle and mode10 finite QVM contracts now have three additional pure Rust primitives. Full game completion is still gated by actual lifecycle child ownership, simulation/runtime integration, native parity, Linux and interactive Bevy/Solari validation.

Research progress: RE-747 report; full native/platform/game scope remains open.

Research progress: RE-748 report; full native/platform/game scope remains open.

Research progress: RE-749 report; full native/platform/game scope remains open.

Research progress: RE-750 report; full native/platform/game scope remains open.

Research progress: RE-751 report; full native/platform/game scope remains open.

Research progress: RE-752 report; full native/platform/game scope remains open.

Research progress: RE-753 report; full native/platform/game scope remains open.

Research progress: RE-754 report; full native/platform/game scope remains open.

Research progress: RE-755 report; full native/platform/game scope remains open.

Research progress: RE-756 report; full native/platform/game scope remains open.

RE-747–756 batch validation:1443 Python and68 Rust tests pass after ten separately checked task commits. Score updates, recipient loops, method statistics and cross-client clearing have additional finite QVM evidence; scoring, method counters and record clearing now have Rust primitives. Actual ranking/recipient/report children, full simulation/runtime ownership, native parity, Linux and interactive Bevy/Solari completion remain open.

Research progress: RE-758 report; full native/platform/game scope remains open.

Research progress: RE-759 report; full native/platform/game scope remains open.

Research progress: RE-760 report; full native/platform/game scope remains open.

Research progress: RE-761 report; full native/platform/game scope remains open.

Research progress: RE-762 report; full native/platform/game scope remains open.

Research progress: RE-763 report; full native/platform/game scope remains open.

Research progress: RE-764 report; full native/platform/game scope remains open.

Research progress: RE-765 report; full native/platform/game scope remains open.

Research progress: RE-766 report; full native/platform/game scope remains open.

Research progress: RE-767 report; full native/platform/game scope remains open.

RE-758–767 batch validation:1473 Python and80 Rust tests pass after ten independently committed tasks. Totals/ratios, team counters, recent awards, recipient numeric bodies and ranking setup have finite source evidence; Rust adds totals/ratios, recent-award records and recipient numeric/cache contracts. Ranking sort/publication, real serialization, full runtime ownership, native parity, Linux and interactive Bevy/Solari acceptance remain open.

Research progress: RE-769 report; full native/platform/game scope remains open.

Research progress: RE-770 report; full native/platform/game scope remains open.

Research progress: RE-771 report; full native/platform/game scope remains open.

Research progress: RE-772 report; full native/platform/game scope remains open.

Research progress: RE-773 report; full native/platform/game scope remains open.

Research progress: RE-774 report; full native/platform/game scope remains open.

Research progress: RE-775 report; full native/platform/game scope remains open.

Research progress: RE-776 report; full native/platform/game scope remains open.

Research progress: RE-777 report; full native/platform/game scope remains open.

Research progress: RE-778 report; full native/platform/game scope remains open.

RE-769–778 batch validation:1504 Python and92 Rust tests pass after ten task commits;290 affected producers regenerate deterministically. Ranking, leaderboard selection and modeled recipient bytes have additional source/Rust evidence. Highest priority is the legacy repeated-call/dynamic-return tracer audit, then remaining native sort/publication/serialization, runtime ownership, Linux and interactive Bevy/Solari acceptance.

Research progress: RE-780 report; full native/platform/game scope remains open.

Research progress: RE-781 report; full native/platform/game scope remains open.

Research progress: RE-782 report; full native/platform/game scope remains open.

Research progress: RE-783 report; full native/platform/game scope remains open.

Research progress: RE-784 report; full native/platform/game scope remains open.

Research progress: RE-785 report; full native/platform/game scope remains open.

Research progress: RE-786 report; full native/platform/game scope remains open.

Research progress: RE-787 report; full native/platform/game scope remains open.

Research progress: RE-788 report; full native/platform/game scope remains open.

Research progress: RE-789 report; full native/platform/game scope remains open.

RE-780–789 adds source-tracer audit witnesses, selected migrations and actual aligned sorting through64 clients. Full native/runtime/macOS/Linux/Bevy/Solari completion remains open; RE-790 tracks the next work. Batch evidence.

RE-780–789 batch validation: 1,537 Python and 92 Rust tests pass;216 affected report producers reproduce byte-identically. Selected tracer consumers and aligned source sorting now have stronger evidence. Remaining legacy consumers, complete runtime ownership, native parity and Linux/macOS Bevy/Solari acceptance remain open. Evidence.

RE-791: Both resumers can synchronize new and changed child words into byte lanes without erasing unchanged parent byte overlays. Full runtime completion remains open. Evidence.

RE-792: 5864 now composes actual35095 sorting and rank writes over80 larger eligible populations with explicit publication captures. Full runtime completion remains open. Evidence.

RE-793: Ranking count globals follow connection/team/bot gates, but deferred records can move active clients out of the positional prefix that receives rank words. Full runtime completion remains open. Evidence.

RE-794: Rust now executes the recovered insertion/partition/median/ninther sort without assuming comparator Ord; source parity includes unstable tie permutations. Full runtime completion remains open. Evidence.

RE-795: Rust composes recovered source sorting and rank writes, matching exact order and tied/team rank words for128 full caller fixtures. Full runtime completion remains open. Evidence.

RE-796: Rust reproduces source collection, first-playing identifiers and bot/team counters across185 setup and complete caller fixtures. Full runtime completion remains open. Evidence.

RE-797: Rust matches exact order, rank words and count globals for144 complete mixed/eligible caller fixtures, without reinterpreting asymmetric prefilters as Ord. Full runtime completion remains open. Evidence.

RE-798: 278834 now optionally composes actual team counters and both ratio refreshes;64 fixtures verify counter aliases, totals, divisor and float32 publication together. Full runtime completion remains open. Evidence.

RE-799: 6328 dispatches179363 to every state2 client in scan order, including spectators, and now executes inside48 complete ranking caller fixtures. Full runtime completion remains open. Evidence.

RE-800: Rust reproduces all6328 recipient requests and exact rank-plan outputs across69 source fixtures, including connected spectators and both broadcast gates. Full runtime completion remains open. Evidence.

RE-791–800 completes additional bounded source/Rust ranking and dispatch contracts. Remaining legacy traces, native serialization, runtime integration and platform acceptance stay open. Batch evidence.

RE-791–800 validation: 1,562 Python and102 Rust tests pass;226 affected producers reproduce byte-identically. Exact Rust sorting/ranking and source/Rust broadcast contracts advance the bounded rewrite. Native exit-rule/serialization effects, remaining tracing consumers, full runtime integration and Linux/macOS Bevy/Solari acceptance remain open. Evidence.

RE-802: Bounded tracing can now preserve byte/word coherence and execute unaligned byte copies without changing legacy observations. Full runtime completion remains open. Evidence.

RE-803: Both bounded resumers now support validated child byte writes, coherent word mirroring and explicit word/byte/return precedence. Full runtime completion remains open. Evidence.

RE-804: Actual strlen36038 and strcpy36185 execute against coherent bytes, preserving destination guards; bounded copy69338 retains an explicit native strncpy model. Full runtime completion remains open. Evidence.

RE-805: 179363 differs from single-recipient payloads: raw class is preserved, only connecting state1 forces999 ping, and overflow candidates mutate cache before rejection. Full runtime completion remains open. Evidence.

RE-806: 179363 now executes its real string and format wrappers, admission loop and rotating final buffer; exact byte output is checked under explicit formatter/native-copy models. Full runtime completion remains open. Evidence.

RE-807: Rust reproduces every attempted source scoreboard row and cache update while preserving the differences from existing single/pair recipient projections. Full runtime completion remains open. Evidence.

RE-808: Rust matches exact modeled scoreboard bytes, accepted/attempted counts, rejected-row cache mutations and output-ring wrap for18 source compositions. Full runtime completion remains open. Evidence.

RE-809: 6328 now composes actual scoreboard bodies for successive recipients, preserving cache mutations, refreshed frame arguments and alternating output pointers. Full runtime completion remains open. Evidence.

RE-810: Rust now matches successive source scoreboard packets with shared cache and ring state, rather than producing isolated per-recipient projections. Full runtime completion remains open. Evidence.

RE-811: 278834 now composes actual recent-award scanning after actual team/ratio children in canonical actor/victim storage across64 mode/count/time/self fixtures. Full runtime completion remains open. Evidence.

RE-802–811 advances source/Rust scoreboard packet and shared-stat contracts. Native formatting/copy/send behavior, exit rules, full runtime ownership and platform acceptance remain open. Batch evidence.

RE-802–811 validation: 1,587 Python and109 Rust tests pass;320 affected producers reproduce byte-identically. Opt-in coherent memory, source/Rust scoreboard packet streams and shared stat-award contracts advance the rewrite. Actual formatter/native copy/send parity, exit-rule behavior, full runtime integration and macOS/Linux Bevy/Solari acceptance remain open. Evidence.

RE-813: 37768 truncates non-null strings by precision, always pads on the right, and ignores supplied precision for null strings by using its source fallback literal. Full runtime completion remains open. Evidence.

RE-814: 37279 pads zeroes before a negative sign and renders wrapping INT_MIN remainder bytes noncanonically; narrow left-padding domains fail bounded execution. Full runtime completion remains open. Evidence.

RE-815: 37914 now executes original dispatch tables and integer/string children; pointer conversion is decimal, unknown conversions consume one low-byte word, and source padding/minimum quirks propagate. Full runtime completion remains open. Evidence.

RE-816: Replacing the standard-decimal boundary with actual37914 exposes signed-minimum byte differences; prior modeled results remain explicitly separate. Full runtime completion remains open. Evidence.

RE-817: Rust now matches actual37914 rather than host printf for decimal/string/character dispatch, including signed-minimum, null precision and padding quirks. Full runtime completion remains open. Evidence.

RE-818: Rust scoreboard construction now uses recovered decimal/format semantics, replacing the earlier host-decimal assumption and matching actual source formatter packets. Full runtime completion remains open. Evidence.

RE-819: 70386 warns at count>=capacity, returns the clipped count and copies a guaranteed terminal NUL; embedded NUL separates reported count from visible string length. Full runtime completion remains open. Evidence.

RE-820: Rust matches original clipping counts, visible bytes, warning thresholds and alternating buffer counters across56 wrapper cases. Full runtime completion remains open. Evidence.

RE-821: 7805 first handles blocked state, then a pending1000/5000 transition using signed wrapped elapsed time; only a ready transition clears the pending global. Full runtime completion remains open. Evidence.

RE-822: Rust matches source7805 blocked/pending prefix behavior over144 cases, preserving pending time on blocked/wait paths and clearing only ready transitions. Full runtime completion remains open. Evidence.

RE-813–822 advances original formatter and Rust publication contracts, including explicit differences from the prior byte model. Native/JIT acceptance, transition effects and full runtime/platform work remain open. Batch evidence.

RE-813–822 validation: 1,608 Python and117 Rust tests pass;34 affected producers reproduce byte-identically. Original formatter execution now replaces the scoreboard decimal assumption, and Rust matches its byte quirks. Native copy/send acceptance, complete exit rules and macOS/Linux Bevy/Solari runtime integration remain open. Evidence.

RE-824: 37498 pads only the signed integer portion, ignores formatting flags and iteratively truncates fractional f32 digits without rounding; negative zero has no sign. Full runtime completion remains open. Evidence.

RE-825: Rust now reproduces original37498 fractional truncation and integer-only width padding, including negative-zero and ignored flag behavior. Full runtime completion remains open. Evidence.

RE-826: Mode11 exits on the first state2/team0 client whose signed class exceeds20, using the configured max-client count rather than the collected client count. Full runtime completion remains open. Evidence.

RE-827: Rust reproduces the original first-offender mode11 guard and keeps the configured scan bound explicit and safe. Full runtime completion remains open. Evidence.

RE-828: The exit suffix requires at least two playing clients, selects limits across the raw mode5 boundary, and checks first/second global scores before a low-mode client scan. Full runtime completion remains open. Evidence.

RE-829: Rust matches all125 source suffix decisions, including nonzero negative limits, playing-count gates and configured low-mode scans. Full runtime completion remains open. Evidence.

RE-830: The active round gate bypasses time-limit evaluation; expired mode9 time limits reset qualifying clients and populate supplied event records before exit requests. Full runtime completion remains open. Evidence.

RE-831: Rust matches116 original timer cases, including active-round bypass, signed multiply/clock wrap and exact mode9 client resets. Full runtime completion remains open. Evidence.

RE-832: Complete7805 execution now composes prefix, class, supplied predicate, round/time and limit policies with shared mutations across438 finite fixtures. Full runtime completion remains open. Evidence.

RE-833: Rust now composes the full recovered7805 priority and matches438 continuous source cases, including pending clears and mode9 reset/event intentions. Full runtime completion remains open. Evidence.

• RE-834–843: Recover exit predicate and intermission child policies; remaining native/runtime scope is tracked under RE-844. Batch evidence.

RE-834: Actual 7662 and child 33715 execute across 168 cases. Playing count and the enabled global gate ties; team-classified modes compare global scores, mode9 uses ranked field308, mode11 field696, and other modes field248. Raw numeric names remain conservative; ranked pointer legality and native execution remain open. Full runtime completion remains open. Evidence.

RE-835: Rust matches all 168 source cases with typed signed mode classification, global-score and ranked-field selection, early gate handling and safe rank rejection. A separate scoped intermission adapter avoids rebuilding unrelated lifecycle fixtures; original runtime remains open. Full runtime completion remains open. Evidence.

RE-836: 131 original 7525 cases recover connected/entity-flag8 exclusion, nonzero readiness, first16-slot mask and independent counts. Signed wrapped timestamp additions gate a five-second minimum and ten-second wait; all-ready includes an empty eligible set. Actual 6939 next-map transition remains captured. Full runtime completion remains open. Evidence.

RE-837: Rust matches 131 original readiness cases, including slot16 mask exclusion, empty eligible sets, nonzero ready/wait flags, signed wrap and exact timeout boundaries. Safe scan rejection preserves state; next-map execution remains an explicit exit intention. Full runtime completion remains open. Evidence.

RE-838: 39 original 6825 cases recover the once-only blocked guard, clock assignment, optional slow setup, connected-client fallback ID, entity-client field4324 clear and ordered preparation/respawn/move/publication requests. Child effects remain captured; the zero clock case exposes the raw timestamp-as-guard behavior. Full runtime completion remains open. Evidence.

RE-839: Rust matches 39 original begin-transition cases, preserving timestamp guard semantics, fallback IDs, entity-client field clear and preparation/slow/respawn/move/publication order. Native work stays typed effects; invalid counts reject before mutation. Full runtime completion remains open. Evidence.

RE-840: 83 original 7367 cases recover Exit header, pending now−50, publication/configstring22 ordering, team score log, signed ping clamp and at most32 ranked connected nonspectator rows. Verified original format strings are recorded. Logging, publication and syscall effects remain captured. Full runtime completion remains open. Evidence.

RE-841: Rust matches 83 original exit-log cases with signed ping clamp, negative/zero/over32 rank counts, ranked filters, optional team score projection and wrapping pending timestamp. Rendering and ordered publication/configstring/log effects remain caller-owned; invalid ranks reject before mutation. Full runtime completion remains open. Evidence.

RE-842: 150 continuous 7805 fixtures now execute actual tie, readiness, begin-transition and exit-log children on shared world memory with separate child frames. Independent policy and nested ABI checks cover conflicting gates, client mutations and publication intentions. Lower-level next-map/respawn/camera/I/O and allocation still remain captured. Full runtime completion remains open. Evidence.

RE-843: Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity. Full runtime completion remains open. Evidence.

• RE-844–853: Recover bounded camera, map-reset and event-construction policies; deeper native/runtime work continues under RE-854. Batch evidence.

RE-844: 72 original 6575 fixtures recover entity/player origin and view-angle copies, velocity clear, movement type5 and cleared entity/client fields. Coherent byte copies preserve arbitrary float words, including NaN payloads; two entity-to-client targets prove indirection. Mode/field4324 gates converge without extra effects. Native renderer/camera integration remains open. Full runtime completion remains open. Evidence.

RE-845: Rust matches all 72 original camera fixtures, copying raw float words exactly and clearing the verified fields. The parity adapter resolves either entity-to-client target; the library accepts an already-resolved mutable client. Native camera/rendering and unrestricted pointer alias behavior remain open. Full runtime completion remains open. Evidence.

RE-846: 36 original 6717 cases recover fallback/selected view copies, optional target lookup and f32 target-minus-origin direction. Exact search/fallback/angle-conversion request ABI is checked. Search results and fallback writes are supplied; 62944 angle conversion and native selection/rendering remain open. Full runtime completion remains open. Evidence.

RE-847: Rust matches 36 original view-selection cases: supplied fallback/search results, copied angles and exact finite f32 direction subtraction, with typed ordered search/fallback/aim effects. Nonfinite arithmetic rejects; raw copies retain words. Angle conversion62944 and native selection remain open. Full runtime completion remains open. Evidence.

RE-848: 300 original 6939 cases recover the positive-phase/team-classified gate, option/flag2+4 restart priority, saved score order, flag clearing and configstring1005/2 requests. Normal reset stops at its boundary. Actual33715 executes; text formatting and downstream map/native effects remain supplied or captured. Full runtime completion remains open. Evidence.

RE-849: Rust matches 300 original series-branch cases, reusing the verified mode classifier and preserving restart priority, saved score order, raw flags and pending/blocked clearing. Formatting/configstring/map calls remain ordered intentions; the normal branch is left for its own policy. Full runtime completion remains open. Evidence.

RE-850: 48 original 6939 suffix cases recover round/blocked/global score clears, connected-client score resets, extra mode9 field304/308 resets, then connection2→1 after captured249007. A mid-call snapshot proves ordering; pending, phase, series flags and saved scores remain unchanged. Actual map/command children remain captured. Full runtime completion remains open. Evidence.

RE-851: Rust matches 48 original normal-reset cases with separate pre-map score reset and post-map connection transition APIs. The adapter captures a no-op map child; production callers can apply its real mutations between stages. Safe count errors preserve state, and pending/phase/series data remain unchanged. Full runtime completion remains open. Evidence.

RE-852: 144 original 277695/278138 cases recover tempEntity metadata, wrapped event kind+19, CVFI/CVIF origin snapping, trajectory/current-origin writes and link order. Five invalid float domains reject. Allocator flags424 and caller-owned84/140 are preserved; allocation277165 and native linking remain supplied/captured. Full runtime completion remains open. Evidence.

RE-853: Rust matches 144 original temporary-event cases, including exact snap words, event-kind wrapping, metadata and preservation of allocator/caller fields. Five invalid source domains reject atomically in Rust. Allocation and native linking remain caller-owned; source class tokens require runtime metadata resolution. Full runtime completion remains open. Evidence.

• RE-854–863: Recover entity searches, target RNG, corrected angles and composed camera placement. Native/runtime integration continues under RE-864. Evidence.

RE-854: 80 original 276433 cases recover nonzero active/class-pointer filtering, first match after cursor, scan limits and raw hash equality. Class text is never compared, so collisions return the first eligible hash match. Read-only world behavior is verified; unsafe pointers and native/runtime behavior remain open. Full runtime completion remains open. Evidence.

RE-855: Rust matches 80 original class-hash search cases, including inactive/null class filtering, collisions, nonzero signed active values and cursors beyond the scan count. Bounded safe entity slices reject invalid cursors/counts; class text is intentionally not compared because the source does not compare it. Full runtime completion remains open. Evidence.

RE-856: 150 original 276505 searches and 256 actual 69386 comparisons recover cursor/active/null-field filtering, ASCII folding, signed high-byte ordering, embedded NUL, nullable pointer order and zero-count behavior. Source calls the comparator with99999. Safe finite strings only; raw invalid pointers and runtime integration remain open. Full runtime completion remains open. Evidence.

RE-857: Rust matches 150 original field searches and 256 comparator cases, preserving nullable ordering, signed high bytes, ASCII folding, embedded NUL and count gates. The API receives resolved logical fields with bounded entity/string sizes; raw pointer/offset ABI remains outside this safe contract. Full runtime completion remains open. Evidence.

RE-858: 168 original 276586 cases compose actual 276505/69386 matching and actual36717 random state updates. At most32 matches are collected; random state advances exactly once only when matches exist, then selects by modulo. Five six-step RNG sequences and null/missing diagnostic paths are verified. Native initialization/world ownership remain open. Full runtime completion remains open. Evidence.

RE-859: Rust matches 168 original target selections and five six-step RNG sequences. It preserves first32-match collection, actual xorshift word transitions, single conditional draw, modulo selection and null/missing diagnostic intentions. Native initialization, message rendering and live world ownership remain open. Full runtime completion remains open. Evidence.

RE-860: 96 actual 62944 cases use corrected repeated child reentry and coherent full/partial alias memory, preserving staged f32 arithmetic and exact output words. All24 older fixtures are compared explicitly. atan2/sqrt remain supplied finite f32 math models; original native library bit parity is not established. Full runtime completion remains open. Evidence.

RE-861: Rust matches 96 corrected source angle cases exactly through checked math transcripts. A separate host-math path is compared within four f32 ULPs, preserving source staging and signed-zero behavior. Safe nonfinite domains and stale math transcripts reject; original native atan2/sqrt bit parity remains unverified. Full runtime completion remains open. Evidence.

RE-862: 96 continuous setup→placement cases now execute class-hash, field/string, capped random target, RNG and angle bodies on shared coherent world state, including collision/fallback/missing/self/capped target and client-indirection cases. Only fallback168114 and finite math responses remain supplied. Runtime/respawn integration and native math parity remain open. Full runtime completion remains open. Evidence.

RE-863: Rust matches all96 composed source setup/placement fixtures across searches, actual RNG state transitions, checked angle-math transcripts and resolved player indirection. Fallible resolution stages RNG before committing it and performs placement only after success. Fallback selection and native math parity remain explicit boundaries; intermission/respawn/runtime integration is still open. Full runtime completion remains open. Evidence.

• RE-864–873: Recover fallback spawn/camera and normal map command/reset contracts. Remaining native/runtime scope continues under RE-874. Evidence.

RE-864: 112 original168114 cases execute actual class-hash search and RNG, recovering stable farthest-first insertion,64-entry cap, far-half draw at8+, first-class fallback when blocked, +9 Z and a no-spawn fatal boundary. Telefrag answers and finite sqrt remain supplied; collision/native/runtime parity is open. Full runtime completion remains open. Evidence.

RE-865: Rust matches112 original fallback cases with checked distance-math responses, stable64-candidate cap, far-half random selection at8+, blocked first-class fallback and +9 Z. Safe no-spawn/domain errors preserve random state. Actual telefrag/collision tests, native math and runtime spawn ownership remain open. Full runtime completion remains open. Evidence.

RE-866: 128 coherent setup→placement cases replace supplied fallback view writes with actual168114 selection, composing searches, capped distance ranking, RNG and angle execution. Existing intermission-camera paths and two player indirections are checked together. Telefrag answers and finite native math remain supplied; respawn/runtime integration is open. Full runtime completion remains open. Evidence.

RE-867: Rust matches128 continuous source camera/fallback/placement cases with shared RNG state and checked native-math transcripts. The supplied fallback view has been replaced by recovered spawn ranking and +9 Z. Telefrag answers stay caller-owned; no-spawn errors preserve placement state. Native collision/math and runtime integration remain open. Full runtime completion remains open. Evidence.

RE-868: 192 original122230 cases execute actual strlen and recover signed counter wrapping, threshold priority and refresh→optional filename callback/clear→reset order. Engine-5 refresh writes are supplied explicitly, including empty, NUL and high-byte filenames. Actual122143/121987 callbacks and native runtime ownership remain open. Full runtime completion remains open. Evidence.

RE-869: Rust matches192 original rotation cases, preserving signed cursor wrap, enable/threshold gating, refreshed filename C-string handling and ordered refresh/write/clear/reset intentions. Engine refresh input is explicit; invalid refreshed data rejects before boundary mutations. Native callbacks remain unimplemented. Full runtime completion remains open. Evidence.

RE-870: 90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a128-byte local map-name buffer (127-byte payload), requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured. Full runtime completion remains open. Evidence.

RE-871: Rust matches90 original map-selection cases with empty/NUL mirror gates,127-byte engine-mapname truncation, raw non-UTF8 bytes, unchanged VM mirror and exact truncated-override mode2 map command text. The typed effect order matches source cvar/read/command requests. Engine callbacks, native copy and actual command dispatch remain outside the port. Full runtime completion remains open. Evidence.

RE-872: 192 actual6939 normal-path cases compose recovered rotation, map selection, mode classification, copy and formatter bodies on shared state. Optional supplied249007 connection changes prove the final scan sees child mutations. Cvar/engine bytes, native copy and lower callback/runtime effects remain explicit boundaries. Full runtime completion remains open. Evidence.

RE-873: Rust matches192 original normal6939 cases, staging rotation, override map-command intentions, global/client resets and post-callback connection changes atomically. The API refuses team-series inputs and invalid callback indices. VM mirrors/pending/series data remain source-faithful; native callbacks, engine refresh and runtime integration remain open. Full runtime completion remains open. Evidence.

• RE-874: Recover telefrag/native math, respawn/slow setup, lower map/rotation callbacks, allocation/publication and actual macOS/Linux runtime integration. Scope.

RE-874: 64 actual122143 cases recover a 64-slot bot population scan, wrapping (wins<<1)-loss converted to f32, strict positive best score and first-wins ties. Only the winner handle and unchanged filename pointer reach captured native -546. Zero/negative fitness means no write. Extreme counters exercise signed wrap and f32 precision. Native botlib serialization remains open. Full runtime completion remains open. Evidence.

RE-875: Rust matches all64 original bot winner cases, with wrapping fitness arithmetic before f32 conversion, strict first-wins comparison and typed rejection of incomplete populations. Native botlib genome writes are returned as intentions, without assuming file serialization or runtime integration. Full runtime completion remains open. Evidence.

RE-876: 64 actual121987 cases recover all64 native fitness words, supplied native -565 parent/child selection, ordered -566 interbreed and -567 mutation(handle,1.0), then zeroing both counters of currently active slots. A supplied selection callback activates slot63 to prove reset rereads live state after native calls. Selection algorithm and native genetic/file behavior remain open; invalid native indices are excluded. Full runtime completion remains open. Evidence.

RE-877: Rust matches all64 actual121987 fitness/selection/interbreed/mutation/reset transcripts, including callback activation before the counter reset. API validates supplied indices before mutation and retains inactive counters. Native bot selection and genetic mutation are explicit answer/effect boundaries, not Rust implementations of botlib. Full runtime completion remains open. Evidence.

RE-878: 72 actual249007 cases recover signed live client-count iteration and connected-state2 gating. Each accepted client calls246746 then246963 unconditionally; a supplied first-child disconnect does not suppress its second child, and activation of a later slot affects subsequent dispatch. This uses level count34992524, not max-clients cvar34089604. Child bodies, native effects and callback changes to count/base pointer remain open. Full runtime completion remains open. Evidence.

RE-879: Rust matches all72 original249007 schedules and state snapshots, including disconnect-before-second-child and activation-before-later-scan cases. The bounded API accepts typed callbacks and validates the count before invoking them. Count/base remain stable; actual246746/246963 child bodies and engine integration remain open. Full runtime completion remains open. Evidence.

RE-880: 32 actual167638 cases recover f32 origin-plus-six-source-bounds construction, native -33 box query with capacity1024 and returned-index iteration. Any entity with nonzero client pointer at offset520 blocks the spawn; other activity/health/team flags are not tested here. Covers duplicate indices, negative/zero query counts, signed/nonzero client words, f32 rounding and a client at result1024. Engine spatial query answers remain supplied; invalid engine counts/indices and nonfinite bounds are excluded. Full runtime completion remains open. Evidence.

RE-881: Rust matches all32 original167638 box/query/filter cases, including the full1024-result scan and f32 rounding. The API separates box construction from supplied engine indices, rejects nonfinite/overflow bounds and malformed positive counts/indices, and tests client-pointer nonzero alone. Actual collision broadphase and integration into fallback selection remain open. Full runtime completion remains open. Evidence.

RE-882: 96 actual122230 compositions execute actual122143/121987/36038 with shared population/cvar state. Engine refresh bytes and native genetic selection are supplied, while writes/interbreed/mutation are captured. Nonempty refreshed filename requests best-genome write before breeding; an empty filename still breeds and resets. Disabled/below-threshold paths preserve population. A supplied selection callback activates slot63 before reset. Native algorithm/file/engine/runtime parity remains open. Full runtime completion remains open. Evidence.

RE-883: Rust matches all96 original122230/122143/121987 compositions, with staged counter/cvar changes and write-before-breed ordering. Winner selection uses pre-reset fitness; supplied activity changes affect reset only at the native selection boundary. Disabled/below-threshold paths preserve bot state. Invalid callback indices reject atomically. Native botlib algorithms, files and engine dispatch remain open. Full runtime completion remains open. Evidence.

Next batch RE-884: integrate collision queries and recovered callbacks; recover their native/engine behavior and complete map/intermission/runtime ownership. See remaining work.

RE-884: 64 actual168114/167638 compositions replace supplied telefrag booleans with original query/filter execution. Native -33 spatial result lists are supplied, including empty/nonclient/blocked/mixed/duplicate results. Class filtering determines query order; accepted candidates then consume modeled sqrt before RNG, preserving64-cap and all-blocked/no-spawn behavior. Native broadphase, math and runtime ownership remain open. Full runtime completion remains open. Evidence.

RE-885: Rust matches64 original168114/167638 compositions and their ordered box query transcripts. The typed spatial-query callback runs only after class filtering and before each candidate distance. Existing boolean-based callers retain behavior. Query/domain errors preserve RNG; native broadphase/math and external callback effects remain open. Full runtime completion remains open. Evidence.

RE-886: 128 coherent6717/168114/167638/6575 cases execute box construction and client filtering inside camera fallback. Existing primary cameras issue no spatial queries; fallback class matches issue ordered native -33 requests. Result/view/player fields and checked math match the prior boolean-boundary fixtures. Native broadphase and math remain supplied; respawn and complete intermission/runtime remain open. Full runtime completion remains open. Evidence.

RE-887: Rust matches128 original continuous camera/queried-fallback/placement cases, including exact query order and primary-camera bypass. Spatial callbacks use the same recovered box/filter policy as standalone fallback. Existing camera/spawn APIs retain their contracts; native broadphase/math and complete respawn/intermission remain open. Full runtime completion remains open. Evidence.

RE-888: 60 actual246963 cases execute original70458/37914 integer formatting and70031/36038/69338 bounded concatenation. Five raw integers and four normalized booleans populate sessionN; sessIgnoreN follows entity client-pointer indirection, accepts flag exactly1, keeps duplicates, caps scan64 and truncates to127 bytes. Includes negative/oversized counts, two slots, INT_MIN formatter behavior and saturation. Native memset/strncpy are modeled and engine cvar writes captured; restore/engine persistence remain open. Full runtime completion remains open. Evidence.

RE-889: Rust matches60 actual246963 byte-for-byte cvar fixtures, preserving recovered integer formatting, booleans, pointer-indirected duplicates,64-entry scan cap,127-byte saturation and original formatter-ring advance. Checked typed indices reject malformed inputs. Native cvar storage, session restore and runtime ownership remain open. Full runtime completion remains open. Evidence.

RE-890: 64 continuous249007/246963 compositions execute session cvar serialization after the captured246746 child. Supplied first-child disconnection still allows persistence; later activation affects dispatch, and changed session fields are serialized immediately. Source formatter ring carries between clients. Native first-child behavior, engine cvars and count/base changes remain open. Full runtime completion remains open. Evidence.

RE-891: Rust matches64 original249007/246963 compositions, including first-child disconnect/activation/field updates, exact cvar bytes and carried formatter-ring advance. Client changes stage atomically on typed callback errors. The first child and engine storage remain caller-owned; native effects and count/base mutation are outside this contract. Full runtime completion remains open. Evidence.

RE-892: 64 actual6939 normal-path compositions execute122230/7188/249007/246963 and recovered formatter/string bodies on shared state. Distinct max-clients and level counts prove reset, persistence dispatch and final state2-to1 scan use their own bounds. First-child disconnect/activation/session-field effects are supplied and observed before persistence and final scan. Bot children, map-list fallback221662, first client child246746 and engine behavior remain explicit boundaries. Full runtime completion remains open. Evidence.

RE-893: Rust matches64 continuous original6939/249007/246963 compositions. Independent max-clients/live-level bounds preserve score-reset, session-write and final connection-scan ordering; supplied first-child field/connection changes are staged with global/cvar intentions. Invalid counts reject without partial state commits. Native first child, bot/map-list callbacks and engine persistence remain open. Full runtime completion remains open. Evidence.

RE-884–893 completed bounded queried spawn/camera and map persistence compositions. RE-894 tracks saved-position behavior, restore, native collision and full runtime integration. Batch and remaining tasks.

RE-894: 96 actual70503 cases execute actual36038/69386, recovering optional leading separator, case-insensitive first-match keys, incomplete-pair rejection, empty values, embedded NUL and null-pointer early exits. Non-null calls XOR the two-buffer selector even on misses; null arguments preserve it. Oversized info fatal/aliasing/native userinfo retrieval remain open. Full runtime completion remains open. Evidence.

RE-895: Rust matches96 original70503 key/value and selector cases, preserving first-match case folding, incomplete-pair rejection, empty values, embedded NUL and null early exits. Oversized logical inputs reject without changing the selector. Native userinfo retrieval, raw pointer aliases and fatal semantics remain open. Full runtime completion remains open. Evidence.

RE-896: 72 actual38326/38355/37159/36779 cases recover comma-template numeric scanning with partial writes. Integer conversions accept leading digits only, including wrapping overflow; signs/leading spaces write0 without assignment. Floats use staged f32 accumulation, sign/whitespace and decimal scaling; lowercase e terminates the number. Literal mismatch returns-1 even after assignments. Empty/unparsed final fields still write0. Uppercase exponent, other scanf conversions and unsafe destinations remain open. Full runtime completion remains open. Evidence.

RE-897: Rust matches72 actual38326/38355/37159/36779 cases, preserving digits-only integer entry, wrapping overflow, staged f32 decimal arithmetic, partial destination writes and literal-mismatch return-1. Caller supplies untouched destination words. Uppercase exponent, non-ASCII input and other scanf conversions reject; native ABI and complete scanner semantics remain open. Full runtime completion remains open. Evidence.

RE-898: 96 actual246746 cases execute70503/69386/36038,70458/37914,70386 and float formatting. Mode9, enabled>=1, nonempty cl_guid and nonzero position gate file writes; angles alone do not. Mapname truncates63 bytes and GUID bytes pass into positions/map/GUID.pos without sanitization in this body. Open return is ignored; a nonzero supplied handle leads to exact float/name bytes, write then close. Engine buffers, native strncpy and file effects remain supplied/modeled/captured. Full runtime completion remains open. Evidence.

RE-899: Rust matches96 original246746 cases with recovered userinfo, path construction and floating formatter bytes. Mode/enabled/position gates,63-byte map truncation, unsanitized GUID path bytes, ignored open return and write/close ordering are preserved. Typed unsupported format errors preserve the selector. Engine userinfo, native files and unsafe paths/ABI ownership remain open. Full runtime completion remains open. Evidence.

RE-900: 96 actual246554 cases execute70503,70458/37914 and38326/38355/36779. A nonzero handle and signed length>0 with unsigned length<1023 permit reading. Exactly6 scanner assignments replace all position/angle words; malformed or truncated input preserves the original six words. Successful read paths close even after scan failure; zero/negative/oversized lengths return without a close in this body. Native file buffers/handles and real engine ownership remain supplied/captured. Full runtime completion remains open. Evidence.

RE-901: Rust matches96 original246554 read cases, preserving mode/enabled/userinfo gating, strict1..1022 byte lengths, exact scan-result gating, all-six position updates and read/close order. Invalid-length exits retain the observed absence of close. Native file ownership and unsupported scanner domains remain open; this API returns intentions and supplied answers rather than performing file IO. Full runtime completion remains open. Evidence.

RE-902: 144 actual247219 compositions execute original scanner, signed atoi, comma search, mode classifier and246554 load. Session scan result is ignored: partial fields and explicitly supplied caller-scratch words determine subsequent values; restored booleans use>0, with the final one also requiring team mode and flag1. Ignore tokens set in-range entries to1 without clearing old entries; invalid text maps to0. Actual saved-position load follows cvar restoration. Engine cvars/file bytes and initial scratch are supplied, not assumed initialized; native ownership and full reload integration remain open. Full runtime completion remains open. Evidence.

RE-903: Rust matches144 actual247219/scanner/atoi/mode/position-load compositions, preserving ignored parse result, explicit caller scratch, positive-only booleans and final team/flag gate. Ignore entries accumulate without clearing and invalid numeric text addresses slot0. State and selector stage atomically on unsupported domains. Native cvars/files, real scratch provenance and full map reload remain open. Full runtime completion remains open. Evidence.

RE-894–903 completed bounded userinfo/scanner/saved-file/session-restore source and Rust contracts. RE-904 tracks remaining numeric/scratch domains, real reload and native IO/runtime integration. Batch and next work.

RE-904: 96 actual247520 compositions execute team classification, userinfo lookup, bounded copy, saved-position load and session serialization. Team/default/capacity policy, wrapping timeout arithmetic, native tick snapshot, byte-only versus word clears,36-byte text initialization and64 ignored-client clears are recovered. Existing position fields persist unless the recovered load succeeds. Diagnostic7259 and engine/file operations remain captured/supplied; caller authentication and post-initialization behavior remain open. Full runtime completion remains open. Evidence.

RE-905: Rust matches96 original247520 initialization/load/write cases, preserving raw byte/word clears, timeout wrapping, team/capacity selection,64 ignore clears and immediate session cvar bytes. Existing coordinates survive failed/suppressed loads. Engine clock/userinfo/files and diagnostic logging remain supplied/intended; caller behavior and native lifecycle remain open. Full runtime completion remains open. Evidence.

RE-906: 48 actual249007/246746/246963 compositions execute both post-map children on shared state. Ordered native file intentions precede each client session/ignore cvar pair; mode/enabled/zero-position/open-handle gates, pointer-indirected ignore lists and shared formatter/userinfo selectors are verified. Connected-state filtering remains original. Engine userinfo/files/cvars and native copy remain supplied/modeled/captured. Full runtime completion remains open. Evidence.

RE-907: Rust matches48 original249007 compositions with both actual saved-file and session-cvar children. Typed file/cvar actions preserve per-client order and shared selector/ring advances, and invalid domains preserve selector state. Native open answers remain supplied; no actual engine file/cvar dispatch or map reload is claimed. Full runtime completion remains open. Evidence.

RE-908: 64 actual6939 normal transitions compose122230/7188/249007/246746/246963. File actions and per-client session writes occur between score/global resets and the final connection2-to1 scan; reset maximum and level count vary independently. Engine-map bytes are coherent across map-command and saved-file paths. Bot children, map-list fallback221662, native IO and actual command dispatch remain supplied/captured boundaries. Full runtime completion remains open. Evidence.

RE-909: Rust matches64 original normal transitions with actual saved-file and cvar child policies. Shared client counts, score/reset ordering, native file intentions, command bytes and formatter/selector carry are preserved. Existing standalone persistence uses the same action assembly. Native engine dispatch, bot internals and map-list parsing remain open. Full runtime completion remains open. Evidence.

RE-910: 144 finite original246746/246963/247219/246554 compositions feed actual captured cvar/file bytes into a fresh destination snapshot. Negative and INT_MIN integer formatting is deliberately not assumed invertible; original partial scanner writes and supplied scratch are preserved. Ignore entries accumulate over the destination table, and six-float file prefixes survive appended names. The engine is a supplied in-memory transcript, not a native filesystem or real map reload. Full runtime completion remains open. Evidence.

RE-911: Rust matches144 original save/session-write/restore/read compositions using owned in-memory cvar/file bytes. Partial integer parsing and caller scratch preserve the observed non-invertibility of negative/INT_MIN session text; file prefixes and ignore accumulation remain exact. Engine/destination/selector changes stage atomically on errors. This adapter does not own native handles or perform OS file IO. Full runtime completion remains open. Evidence.

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.

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.

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.

RE-914: 256 actual36306 cases recover the word-at-a-time comparison used by admission/password filtering. Result is the exact unsigned-byte difference at the first mismatch, with NUL termination, case sensitivity, high bytes and all four synthetic pointer alignments checked. Guard bytes are explicit fixture memory; native pointer validity and aliases remain open. Full runtime completion remains open. Evidence.

RE-915: Rust matches256 original36306 fixtures across alignment/case/NUL/high-byte domains, preserving the exact byte difference rather than only its sign. Typed logical strings reject oversized inputs. Raw word lookahead, invalid pointers and aliases remain outside the portable contract. Full runtime completion remains open. Evidence.

RE-916: 270 actual252643/36306 cases recover exact localhost bypass, byte-wrapping components, permissive single-byte separators, colon termination and little-endian mask matching. Short/empty inputs preserve explicit prior scratch bytes; nonzero filter mode rejects matches and zero mode rejects misses. Signed negative table count skips scanning. This is the observed policy, not strict IP validation; parser scratch provenance, table writers and native network acceptance remain open. Full runtime completion remains open. Evidence.

RE-917: Rust matches270 original252643 parser/filter cases, retaining byte wrapping, permissive separators, colon/localhost rules, supplied scratch bytes, signed table-count behavior and mode inversion. Malformed positive counts reject. Table population, native network behavior and actual scratch provenance remain open. Full runtime completion remains open. Evidence.

RE-918: 160 actual173979 prefix cases execute userinfo70503, address252643, unsigned36306 and case-folded69386. Native userinfo is fetched first; nonzero bot flag bypasses address/password checks. Banned rejection precedes password lookup. Empty server password or case-insensitive none disables the final case-sensitive check. Rejections occur before client clear; exact messages, lookup order and selector carry are verified. Filter scratch, engine userinfo/password and native admission remain explicit boundaries. Full runtime completion remains open. Evidence.

RE-919: Rust matches160 original173979 admission prefixes, preserving bot bypass, address-before-password rejection, none/empty server password behavior, exact case-sensitive password results, messages and userinfo selector order. Typed invalid domains preserve selector state. Native userinfo/filter population and complete caller acceptance remain open. Full runtime completion remains open. Evidence.

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.

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.

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.

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.

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.

RE-924: 288 actual161744 cases execute original userinfo lookup, bounded copy and37144/36779 float conversion. The292-byte setup record contains144-byte characterfile, raw f32 skill and144-byte team fields; logical strings truncate143 bytes and pad with NUL. Three lookups alternate the userinfo buffer selector. Supplied125185 setup result is normalized to0/1; zero requests native client drop with exact text. Actual bot setup125185, engine userinfo/drop and native strncpy remain supplied/captured/modeled boundaries. Full runtime completion remains open. Evidence.

RE-925: Rust matches288 original161744 fixed-record and effect cases, preserving143-byte logical string caps, raw f32 skill, userinfo lookup order, restart forwarding and nonzero-result normalization. Typed unsupported skills preserve selector state. Actual125185 bot setup and engine userinfo/drop remain open. Full runtime completion remains open. Evidence.

RE-926: 162 actual182896 cases execute original70458/37914 integer/string formatting and capture broadcast-18. Teams0/1/2 emit ccprint payloads with code5 and team number; team3 emits spectator text only when the previous team differs from3. Other values do nothing. The body does not mutate team selection. Raw name bytes, exact quote/newline framing and wrapping formatter counter are verified; native network delivery and other team-switch callbacks remain open. Full runtime completion remains open. Evidence.

RE-927: Rust matches162 original182896 payload/counter cases, retaining exact ccprint/spectator framing, raw name bytes, previous-team suppression and wrapping formatter counter. It does not select or mutate teams. Native broadcast delivery and additional team-switch logic remain open. Full runtime completion remains open. Evidence.

RE-928: 144 original173979 suffix cases execute actual161744 settings/drop wrapper and182896 announcement body instead of supplied bot booleans and captured team callback. Parent control/state remains source-identical; extra userinfo selector toggles, setup records, drops, exact announcement bytes and formatter carry are verified. Native125185 setup,171668 userinfo mutation, ranking/network/logging remain supplied/captured. Full runtime completion remains open. Evidence.

RE-929: Rust matches144 original suffix compositions with actual161744/182896 policies, retaining caller mutations/messages while adding precise bot records, drop requests, announcement bytes and selector/counter carry. The wrapper stages typed errors and preserves ordinary rejection mutations. Native bot setup/userinfo/ranking/network/logging remain open. Full runtime completion remains open. Evidence.

RE-930: 96 complete173979 executions replace supplied161744 booleans and captured182896 with actual bot settings/drop and announcement bodies. Parent decisions, client/entity bytes and persistence timing are preserved; setup records, exact broadcasts and extra selector/formatter carry are verified. Native125185 setup,171668 mutation, ranking/logging/network/IO remain supplied/captured. Full runtime completion remains open. Evidence.

RE-931: Rust matches96 complete source173979/161744/182896 compositions, including settings/drop records, extra selector toggles and announcement/counter carry while preserving prior caller state, cvar timing and return decisions. Typed errors stage all caller state. Native setup/userinfo/ranking/network/IO remain explicit boundaries. Full runtime completion remains open. Evidence.

RE-932: 132 actual252829/252304/37159 cases recover first-hole reuse, append/count growth,4096 capacity, wildcard/numeric masks, modulo-byte values and permissive separators. Parsing failure still returns outer success1, marks comparison-1 and preserves other fields; count growth is not rolled back. Successful insert sets metadata-1. Optional252500 export is requested even after parse failure; full-capacity refusal skips it. Full-table scans execute with a bounded262144-instruction budget. Table/export/network provenance and malformed counts remain open. Full runtime completion remains open. Evidence.

RE-933: Rust matches132 original252829/252304 table cases including4096-capacity scans, first-hole reuse, wildcard/numeric masks and comparison-1 sentinel behavior. Parser failure retains count growth and requests optional export, matching the source. Typed malformed counts/token-overflow domains reject atomically. Export body252500, live table writers and native network acceptance remain open. Full runtime completion remains open. Evidence.

RE-924–933 completed bounded bot settings, announcement, connect-child composition and filter insertion contracts. The following batch recovers filter persistence; bot setup/userinfo, native resource/network acceptance and complete runtime integration remain open. Batch and next work.

• RE-934 Original filter export and native file-operation order (evidence).

• RE-935 Rust filter export policy and bounded storage (evidence).

• RE-936 Original exact-match filter removal (evidence).

• RE-937 Rust exact-match filter removal and diagnostics (evidence).

• RE-938 Original filter metadata update and save gating (evidence).

• RE-939 Rust first-match filter metadata policy (evidence).

• RE-940 Original insertion composed with recovered export (evidence).

• RE-941 Rust insertion with recovered export composition (evidence).

• RE-942 Original removal composed with export and survivor serialization (evidence).

• RE-943 Rust removal with survivor export and typed file effects (evidence).

RE-934–943 completed bounded filter export/removal/metadata and insertion/removal persistence compositions. The following batch recovers time, expiry, loading and duration contracts; remaining command callers, live adapters and runtime integration remain open. Batch and next work.

• RE-944 Original filter time flattening and asymmetric inverse (evidence).

• RE-945 Rust filter time arithmetic and asymmetric inverse (evidence).

• RE-946 Original full-table filter expiry and unsigned time gates (evidence).

• RE-947 Rust full-table expiry with unsigned metadata gates (evidence).

• RE-948 Original banlist loading and duplicate metadata routing (evidence).

• RE-949 Rust bounded loading with explicit read replies (evidence).

• RE-950 Original expiration-duration command and usage paths (evidence).

• RE-951 Rust expiration command with typed time and usage effects (evidence).

• RE-952 Original export reload and lossy persistence behavior (evidence).

• RE-953 Rust export reload composition and persistence-loss regressions (evidence).

RE-944–953 completed bounded time/expiry/loading/duration and export/reload contracts. The following batch recovers command and caller-prefix compositions; complete callers, native ownership and runtime acceptance remain open. Batch and next work.

• RE-954 Original add-filter client lookup and queued kick command (evidence).

• RE-955 Rust add-filter wrapper and unconditional queued kick (evidence).

• RE-956 Original remove-filter command and usage routing (evidence).

• RE-957 Rust remove-filter wrapper and source usage effects (evidence).

• RE-958 Original duration command with metadata and export resolved (evidence).

• RE-959 Rust duration command with resolved persistence plan (evidence).

• RE-960 Original expiry composed with full-capacity address admission (evidence).

• RE-961 Rust full-capacity expiry and address-admission composition (evidence).

• RE-962 Original client-frame prefix with unconditional expiry (evidence).

• RE-963 Rust client-frame prefix with source motion gates and expiry (evidence).

RE-954–963 completed add/remove wrappers, resolved duration export, full-capacity expiry/admission and a bounded frame prefix. The following batch recovers the timer body and caller preparation; remaining callers/native ownership and runtime integration remain open. Batch and next work.

• RE-964 Original client timer deadline and terminal-counter fragments (evidence).

• RE-965 Rust client timer deadlines and terminal accumulation (evidence).

• RE-966 Original100ms timer phase loop and damage-request ABI (evidence).

• RE-967 Rust100ms phase loop and captured damage requests (evidence).

• RE-968 Original float countdown and flag-recovery loop (evidence).

• RE-969 Rust float countdown and ordered flag recovery (evidence).

• RE-970 Complete original client timer body with expiry and ordered damage requests (evidence).

• RE-971 Rust complete client timer with transactional persistent state (evidence).

• RE-972 Original timer caller timing preparation and early gates (evidence).

• RE-973 Rust caller timestamp preparation and delta semantics (evidence).

RE-964–973 completed timer deadline/phase/recovery contracts, whole-body composition and caller timing preparation. The following batch recovers pre-movement processing; remaining caller paths, damage feedback and native/runtime integration remain open. Batch and next work.

• RE-974 Original client intermission and spectator routing (evidence).

• RE-975 Rust early client routing with captured callbacks (evidence).

• RE-976 Original command angle preservation and movement-byte masking (evidence).

• RE-977 Rust client command rewriting and byte preservation (evidence).

• RE-978 Original inactivity policy and ordered warning timeout effects (evidence).

• RE-979 Rust inactivity deadlines and typed timeout effects (evidence).

• RE-980 Original movement parameter selection and packed words (evidence).

• RE-981 Rust finite movement parameters and one-shot controller handling (evidence).

• RE-982 Original pre-movement client pipeline and early-exit state (evidence).

• RE-983 Rust composed pre-movement pipeline with source early-exit mutations (evidence).

RE-974–983 completed routing, command rewrite, inactivity, movement-parameter setup and composed prefix through154544. RE-984 tracks later callbacks/physics and native/runtime integration. Batch and next work.

• RE-984 Recover movement scratch initialization and mode dispatch (evidence).

• RE-985 Port movement scratch initialization and callback plans (evidence).

• RE-986 Recover movement suppression and command snapshot (evidence).

• RE-987 Port signed movement suppression and snapshot (evidence).

• RE-988 Recover movement masks and linked overlap cleanup (evidence).

• RE-989 Port linked overlap and movement mask selection (evidence).

• RE-990 Recover native movement context and vector snapshots (evidence).

• RE-991 Port typed native movement context assembly (evidence).

• RE-992 Compose source movement setup through physics boundary (evidence).

• RE-993 Compose Rust movement setup with callback feedback (evidence).

• RE-984–993 movement-context batch:280 paired source/Rust fixtures through154867 (evidence).

• RE-994 recover actual mode callback bodies and movement54475, then post-movement/timer integration and native macOS/Linux acceptance (scope).

• RE-994 Recover meter completion and thaw event effects (evidence).

• RE-995 Port meter completion and captured thaw effects (evidence).

• RE-996 Recover timed mode10 self-recovery (evidence).

• RE-997 Port timed self-recovery with atomic state updates (evidence).

• RE-998 Recover mode10 assistance admission and cleanup scan (evidence).

• RE-999 Port assistance cleanup and typed target ownership (evidence).

• RE-1000 Recover mode8 eligibility and teammate exclusion (evidence).

• RE-1001 Port mode8 eligibility and teammate exclusion (evidence).

• RE-1002 Compose actual mode10 self callbacks with movement setup (evidence).

• RE-1003 Compose actual Rust self callbacks with movement setup (evidence).

• RE-994–1003 callback batch:244 paired source/Rust fixtures for meter completion, self-recovery, assistance cleanup, mode8 eligibility and resolved mode10 self setup (evidence).

• RE-1004 recover nonempty assistance proximity search, mode8 objective transitions and nested native callback feedback (scope).

• RE-1004 Recover assistance acquisition and target ownership (evidence).

• RE-1005 Port assistance acquisition and ownership guard (evidence).

• RE-1006 Recover far and unprotected assistance cancellation (evidence).

• RE-1007 Port conditional assistance cancellation (evidence).

• RE-1008 Recover assisted thaw progress and target completion (evidence).

• RE-1009 Port assisted progress with target meter feedback (evidence).

• RE-1010 Recover complete mode10 assistance callback (evidence).

• RE-1011 Port complete mode10 assistance scan (evidence).

• RE-1012 Recover assistance transitions across repeated calls (evidence).

• RE-1013 Port bounded assistance replay and transition snapshots (evidence).

• RE-1004–1013 assistance search/replay batch:212 paired scenarios, including100 repeated-call snapshots (evidence).

• RE-1014 recover mode8 objective transitions, actual nested effects and nonempty assistance/self/movement composition (scope).

• RE-1014 Recover bomb-defuse start and weapon state changes (evidence).

• RE-1015 Port bomb-defuse start and effect ordering (evidence).

• RE-1016 Recover bomb-defuse cancellation branches (evidence).

• RE-1017 Port conditional bomb-defuse cancellation (evidence).

• RE-1018 Recover timed bomb-defuse completion and effect order (evidence).

• RE-1019 Port timed bomb-defuse completion and captured effects (evidence).

• RE-1020 Recover complete mode8 bomb-defuse callback (evidence).

• RE-1021 Port complete bomb-defuse lookup and state policy (evidence).

• RE-1022 Recover bomb-defuse sequences and completion latching (evidence).

• RE-1023 Port bomb-defuse replay and fatal/completion boundaries (evidence).

• RE-1014–1023 bomb-defuse batch:278 paired scenarios, including138 repeated-call snapshots (evidence).

• RE-1024 recover objective/native effect feedback and compose defusing with full client preparation/movement/timer execution (scope).

• RE-1024 Correct native effect identities and recover objective counter (evidence).

• RE-1025 Port indexed objective counters and label compatibility notes (evidence).

• RE-1026 Recover team radio routing and marker state (evidence).

• RE-1027 Port team radio command planning and marker feedback (evidence).

• RE-1028 Resolve defuse completion score and objective counter (evidence).

• RE-1029 Port resolved defuse score and counter feedback (evidence).

• RE-1030 Resolve defuse start event construction and radio feedback (evidence).

• RE-1031 Port resolved defuse event and radio feedback (evidence).

• RE-1032 Resolve full defuse callback effect feedback (evidence).

• RE-1033 Port full defuse policy with resolved effect bodies (evidence).

• RE-1024–1033 resolved-feedback batch:174 paired scenarios with corrected score/counter/radio identities and actual QVM effect bodies (evidence).

• RE-1034 connect remaining allocation/location/format/ranking/native feedback and migrate legacy labels (scope).

• RE-1034 Recover cached trigger and nearest location selection (evidence).

• RE-1035 Port cached trigger and nearest location policy (evidence).

• RE-1036 Recover location text wrapper and bounded formatting (evidence).

• RE-1037 Port bounded location text and missing-result semantics (evidence).

• RE-1038 Resolve team radio location and source formatting chain (evidence).

• RE-1039 Port located team radio and formatter state (evidence).

• RE-1040 Recover objective-event allocator reuse and terminal boundaries (evidence).

• RE-1041 Port fixed-pool allocation and terminal-state semantics (evidence).

• RE-1042 Resolve defuse start through actual event allocation (evidence).

• RE-1043 Port allocated defuse start with preserved record state (evidence).

• RE-1034–1043 location/format/allocation batch:115 paired scenarios with actual location and formatter/radio chains plus allocated defuse events (evidence).

• RE-1044 combine allocated events and located radio with full lifecycle/native adapters (scope).