| # Dependency-aware validation |
|
|
| ## Development toolchain |
|
|
| Run analysis and validation inside `nix develop`. The pinned flake declares Python as a development dependency and sets `PYTHON` to its absolute Nix-store executable, which `cargo xtask` and its Python-using Rust integration tests require. Without it, they stop before launching an interpreter; there is no PATH/system fallback. Do not use Python from macOS Command Line Tools. For a one-shot run, use `nix develop --command cargo xtask test-group <name>`; the same environment supplies Python for direct analysis scripts and their subprocesses. The shell also supplies Rust, Cargo, Git and pkg-config on macOS and Linux. Directly executing an analysis script outside this shell can still follow its `env python3` shebang, so run those scripts inside the flake too. |
|
|
| The Rust `xtask` workspace package selects and runs the existing Python research tests and Rust crate tests. It has no third-party Rust dependencies. Python remains necessary for the existing analyzers/tests and a syntax-only AST reader; selection, Git inspection, scheduling, determinism checks and command execution live in Rust. |
|
|
| ## Commands |
|
|
| Run from anywhere inside the checkout: |
|
|
| ```sh |
| # Preview checks for staged, unstaged and untracked changes. |
| cargo xtask test-changed --dry-run |
| |
| # Regenerate affected reports and test their consumers. |
| cargo xtask test-changed |
| |
| # Include every committed change since a known validated commit, plus local changes. |
| cargo xtask test-changed --since <validated-commit> |
| |
| # Explicit component scope, independent of unrelated working-tree changes. |
| cargo xtask list-groups |
| cargo xtask test-group health |
| cargo xtask test-group contact --dry-run |
| |
| # All Python test modules and Rust workspace tests, plus regeneration affected by local changes. |
| cargo xtask test-full |
| cargo xtask test-full --since <batch-base> |
| ``` |
|
|
| `--path scripts/qvm_health_support.py` adds an explicit changed input to `test-changed` or `test-full`, useful for previews without editing a file. Paths are repository-relative. `--dry-run` prints the selected report producers, test modules, reasons and fallback conditions without executing analyzers/tests/checks. Cargo may still compile the runner. |
|
|
| Use focused validation before each task commit. For ten-commit batches, run `test-full --since <batch-base>` once after the tenth commit and before pushing. If registry/workspace edits would force broad automatic fallback during a batch, use a reviewed explicit group plus relevant package tests, then retain the full batch gate; do not disable fallback or omit affected shared-helper consumers. Full native macOS/Linux runtime, rendering and release validation remain separate project gates; this runner does not execute the original game or establish those milestones. |
|
|
| Cargo, rustc, Python 3 and Git must be available. Set `RUSTC` if the compiler is outside PATH, and `PYTHON` to override the default `python3` executable. Set up the repository's [storage filters](STORAGE.md) first: every executed validation requires `storage_policy.py check --require-setup`. Asset corpus checks require the local extracted assets. Native analyzers also require their original inputs, pinned reference files and existing native-analysis tools. The runner does not fetch those prerequisites or install dependencies. |
|
|
| ## What gets selected |
|
|
| The graph follows input → consumer edges through local Python imports, report producers/outputs, report readers and imported test oracles. Changes to a generated report also select its producer, so testing cannot silently accept a hand-edited cached report. Changes under `crates/urt-assets/` select its Rust/Python corpus parity producer and downstream consumers, plus Rust workspace tests. |
|
|
| For example, `qvm_health_support.py` selects the health-gates/knockback analyzers and their growing downstream health, contact and Rust parity consumers. Preview the current scope with `cargo xtask test-group health --dry-run`; group membership is not a fixed test count. A shared QVM evaluator or broad native parser change can correctly select most of the research suite. Selection is conservative at the Python module level, not individual function level. |
|
|
| The graph combines: |
|
|
| - Current Python syntax, inspected with `ast` without importing repository modules. This handles imports and literal report reads/writes, including test-to-test helper dependencies. |
| - The versioned [registry](../xtask/checks.tsv), which declares report ownership, dynamic path dependencies, reviewed multi-output writers and named groups. |
| - Rust crate-to-corpus validation rules in the runner and registry. The gameplay crate declares its source/manifest dependencies explicitly in the registry. |
|
|
| Groups currently include `health`, `contact`, `damage`, `md3`, `movement`, `native`, `network` and `storage`. A group is a set of graph roots and includes downstream dependents; it is not an isolated folder or a promise to exclude dependent systems. Imports can make a broad native group reach most research tests. |
|
|
| Unknown paths, runner/workspace/toolchain changes, unregistered literal outputs and code changes with no mapped test consumers select all Python test modules and Rust workspace tests. A documentation-only Markdown change runs the storage/link/whitespace checks without code tests. An empty change set likewise runs only these guards. |
|
|
| Deleted files and both sides of a rename are included. Staged and unstaged paths are collected separately, so a staged edit followed by an unstaged reversal is still considered changed. `--since` adds a commit-to-HEAD diff; it does not replace local-change detection. Invalid revisions fail immediately. |
|
|
| ## Report freshness and execution order |
|
|
| Each selected producer executes twice, with its selected producer prerequisites ordered first. The runner reads every registered output after each execution and requires byte-identical results. It compares the two new runs, rather than requiring equality with the old committed report: intentional evidence updates are allowed. Missing outputs, analyzer failures, conflicting ownership, dependency cycles and nondeterministic results stop validation before consumer tests. |
|
|
| Imports alone do not require running the imported module's `main()`. Regeneration order follows produced report dependencies, including reads inside imported helpers. Unchanged upstream reports are reused. Each selected producer executes once per pass even when several consumers need it; a producer with several outputs verifies them together. |
|
|
| After regeneration: |
|
|
| 1. Selected Rust workspace tests run offline when Rust/full validation is required. |
| 2. Selected Python modules run through `unittest`, in bounded command-line batches. |
| 3. Storage setup/policy, local Markdown links under `docs/`, and staged/unstaged Git whitespace checks run. |
|
|
| `test-full` means full test coverage plus affected report regeneration. It does **not** rebuild every historical report on each invocation. Use `--since` to include the whole batch's affected reports. Native multi-output producers may update filtered `assets/analysis/` files; ordinary research producers write their registered reports. Generated files remain available for review and are never automatically staged or committed. On failure, inspect any partially regenerated outputs before retrying. |
|
|
| ## Maintaining the registry |
|
|
| Registry records are tab-separated, with exactly one `version` record: |
|
|
| ```text |
| version<TAB>1 |
| report<TAB>scripts/analyze_example.py<TAB>docs/research/example.json |
| edge<TAB>docs/research/example.json<TAB>scripts/test_example.py |
| dynamic<TAB>scripts/analyze_legacy_multi_output.py |
| group<TAB>example<TAB>scripts/test_example.py |
| ``` |
|
|
| A `report` row declares a single output owner; repeat rows for all outputs of a producer, including JSONL/compressed/derived asset outputs. An `edge` row declares an input and its consumer. A `dynamic` row acknowledges a reviewed writer whose output destinations cannot all be derived from literals; it does not discover outputs automatically. A `group` row adds a path prefix to that group's roots. |
|
|
| When adding or changing analysis: |
|
|
| - Register every output and every dynamically constructed input path, including paths reached through subprocesses, report metadata or directory scans. Add edges for script dependencies that imports cannot express. |
| - Register a matching test consumer, and extend groups where useful. |
| - Review legacy formatted-path expansions carefully: native base-image reports are distinct from metadata/dispatch/coverage reports. Overbroad expansions can invent cycles. |
| - Run the xtask tests, a focused group and a dry run of affected selection. The Rust tests also check current literal ownership, the full registry DAG and representative health/Rust selections. |
|
|
| Unregistered dynamic writers or dynamic imports on an affected producer fail closed, with an instruction to review the registry. A full test fallback alone cannot prove freshness when output ownership is unknown. Syntax-reader failures likewise stop execution. Arbitrary Python runtime I/O cannot be inferred completely; the explicit registry and its review are part of the validation contract. |
|
|
| The MD3 report producer runs `cargo test --offline --package urt-assets`, preserving its recorded asset-crate test count independently of xtask's own tests. Broad Rust validation still uses the full workspace. |
|
|
| ## Protected lifecycle and Rust parity groups |
|
|
| Use `cargo xtask test-group lifecycle` for protected152386, or the stage groups `mode10-entry`, `mode10-animation`, `mode10-obituary`, `mode10-scoring`, `mode10-complete`, and `health-mode10` for their owned contracts. `cargo xtask test-group health` follows shared health dependencies for a broader focused regression. `cargo xtask test-group gameplay` regenerates all four Rust parity reports and runs scoped gameplay package tests through the impulse producer; it does not request Rust workspace tests. |
|
|
| Gameplay module changes have explicit edges to their parity adapters and to the package test-count report. Source fixture reports feed their Rust consumers. Common lifecycle executable changes select every lifecycle adapter. Generic dependency/toolchain or unknown-file changes still conservatively fall back to the full suite in `test-changed`; use a reviewed explicit group when following the ten-commit cadence. Run `cargo xtask test-full --since <batch-base>` once at the batch boundary and before releases. See the [lifecycle batch](research/QVM_LIFECYCLE_RUST_BATCH.md) for fixture/native boundaries. |
|
|
| ## Score, statistics and recipient groups |
|
|
| Use `cargo xtask test-group score`, `notifications`, `stat-slots`, `stat-updates`, or `record-clear` for individual recovered contracts. `resolved-protected` and `resolved-mode10` exercise actual child composition; `health` follows shared dependencies for a broader focused regression. `gameplay` now covers seven Rust parity contracts, including score, method counters and cross-client clearing. Explicit module edges also refresh the impulse-owned scoped package test-count metadata. The registry integration test verifies those edges. Continue focused checks before each task commit and one `test-full --since <batch-base>` run after ten commits. See the [score/statistics batch](research/QVM_SCORE_STATS_RUST_BATCH.md) for fixture and native boundaries. |
|
|
| ## Totals, reporting and ranking setup groups |
|
|
| Focused groups now include `stat-totals`, `stat-ratios`, `team-counters`, `recent-awards`, `recipient-single`, `recipient-pair` and `ranking-setup`. Recipient groups cover numeric source body boundaries with explicit text/native stand-ins. `gameplay` runs ten Rust parity adapters and scoped gameplay package tests, including totals/ratios, recent awards and recipient projection. Explicit module edges and registry integration tests also refresh the package test-count metadata. Continue focused checks before each commit and one full-suite run after ten commits. See the [reporting batch](research/QVM_REPORTING_RUST_BATCH.md) for evidence limits. |
|
|
| ## Ranking, leaderboard and wire-model groups |
|
|
| Focused groups include `rank-comparator`, `rank-small-sort`, `ranking-complete`, `leaderboard-layout`, `leaderboard-selector`, `leaderboard-categories` and `recipient-wire`. `gameplay` now covers13 Rust parity reports, including raw ranking, leaderboard selection and modeled wire bytes. Module edges and registry integration tests refresh their adapters and package test-count metadata. New source compositions use corrected repeated-call tracing; legacy consumers require the [audit](research/QVM_RANKING_WIRE_RUST_BATCH.md#tracer-finding-and-required-audit). Keep focused checks before each task and one full-suite run after ten commits. |
|
|
|
|
| ## Bounded tracer audit groups |
|
|
| Use `cargo xtask test-group resumer-audit`, `return-placement`, `reentry-witness` or `execute-reentry` for inventory and synthetic trace contracts. Source migrations use `notification-reentry`, `award-reentry`, `counter-reentry` and `movement-reentry`; sorting uses `rank-partition-helpers` and `rank-large-sort`. Each name is a separate argument after `test-group`. Groups follow downstream dependency closure, so shared constants/helpers can select additional source and Rust parity reports. The static inventory scanner has explicit edges from current non-test Python scripts; register newly added scan inputs. Unknown changes retain full-suite fallback. |
|
|
| For ten-task batches, run focused validation before each commit, then `cargo xtask test-full --since <batch-base>` once after commit ten. Review all regenerated report diffs and record the outcome in the batch document before pushing. See [RE-780–789](research/QVM_RESUMER_PARTITION_BATCH.md). |
|
|
|
|
| ## Ranking composition groups |
|
|
| Additional focused groups: `child-word-memory`, `ranking-large-caller`, `ranking-population`, `rust-rank-sort`, `rust-ranking-complete`, `rust-ranking-population`, `rust-ranking-mixed`, `stat-composition`, `scoreboard-broadcast` and `rust-scoreboard`. Invoke each as `cargo xtask test-group <name>`. Rust groups refresh scoped gameplay test-count metadata. New source-report paths assembled from strings have explicit registry edges to their parity producers; the registry regression verifies those selections. [Batch contracts and limits](research/QVM_RUST_RANKING_PUBLICATION_BATCH.md). |
|
|
|
|
| ## Coherent memory and scoreboard groups |
|
|
| Use `cargo xtask test-group <name>` with `coherent-memory`, `child-byte-effects`, `string-memory`, `scoreboard-rows`, `scoreboard-wire`, `rust-scoreboard-rows`, `rust-scoreboard-packet`, `scoreboard-stream`, `rust-scoreboard-stream` or `stat-award-composition`. Source memory modes and native models are explicitly scoped in the [batch findings](research/QVM_SCOREBOARD_MEMORY_BATCH.md). The registry checks the three new source-report parity edges and the scoreboard_wire module selection; scoped gameplay tests refresh their existing impulse-report test-count metadata. Full validation remains once after ten task commits. |
| |
| |
| ## Original formatter and exit-rule groups |
| |
| Use `cargo xtask test-group <name>` with `format-string`, `format-integer`, `formatter`, `scoreboard-formatter`, `rust-qvm-format`, `rust-scoreboard-original`, `format-wrappers`, `rust-format-wrappers`, `exit-prefix` or `rust-exit-prefix`. The registry regression verifies source-report selections for the new Rust parity producers and both new module paths. See [contract limits and corrected formatter assumptions](research/QVM_ORIGINAL_FORMATTER_BATCH.md). Full validation remains once after ten task commits. |
| |
| |
| ## Float formatter and complete exit-rule groups |
| |
| Use `cargo xtask test-group <name>` with `format-float`, `rust-format-float`, `exit-class`, `rust-exit-class`, `exit-limits`, `rust-exit-limits`, `exit-timers`, `rust-exit-timers`, `exit-complete` or `rust-exit-complete`. The registry regression verifies each source-report dependency selects its Rust adapter and test. Scoped gameplay checks refresh test-count metadata. Keep focused validation before each commit and one full run after ten commits. See the [batch evidence and remaining effects](research/QVM_FLOAT_EXIT_RULES_BATCH.md). |
| |
| |
| ## Exit predicate and intermission groups |
| |
| Focused source/Rust pairs: `exit-predicate`/`rust-exit-predicate`, `intermission-ready`/`rust-intermission-ready`, `intermission-begin`/`rust-intermission-begin`, `exit-log`/`rust-exit-log`, and `intermission-flow`/`rust-intermission-flow`. Run `cargo xtask test-group <name>` before the task commit. The scoped intermission executable has its own adapter inputs; common module changes select every intermission consumer and scoped gameplay test-count metadata. The registry regression verifies source-report edges and module selection. Run one `test-full --since <batch-base>` after ten commits. See the [batch contracts and boundaries](research/QVM_INTERMISSION_BATCH.md). |
| |
| |
| ## Camera, map and event groups |
| |
| Focused source/Rust pairs: `camera-place`/`rust-camera-place`, `camera-select`/`rust-camera-select`, `nextmap-series`/`rust-nextmap-series`, `nextmap-reset`/`rust-nextmap-reset`, and `event-construct`/`rust-event-construct`. Invoke `cargo xtask test-group <name>` before each task commit. The scoped transition adapter covers each word-level contract; Rust groups also run scoped gameplay tests and refresh their test-count metadata. The registry regression verifies source-report edges, transition module consumers and the shared mode-classifier dependency. Continue one full suite after ten commits. [Batch contracts and boundaries](research/QVM_CAMERA_MAP_EVENT_BATCH.md). |
| |
| |
| ## Entity search and composed world camera groups |
| |
| Use the source/Rust pairs `entity-hash`/`rust-entity-hash`, `entity-field`/`rust-entity-field`, `target-pick`/`rust-target-pick`, `camera-angles`/`rust-camera-angles` and `camera-world`/`rust-camera-world`. Run them inside the flake shell. Registry regression checks report, module and shared transition dependencies; Rust groups refresh scoped gameplay test counts. Git hooks require the flake's absolute Nix-store `PYTHON` and refuse to fall back to system Python. Run `storage` after hook changes and one full suite after ten commits. [Batch evidence and limits](research/QVM_CAMERA_WORLD_BATCH.md). |
| |
| |
| ## Fallback spawn and normal map-command groups |
| |
| Source/Rust pairs: `spawn-fallback`/`rust-spawn-fallback`, `camera-spawn`/`rust-camera-spawn`, `rotation-advance`/`rust-rotation-advance`, `map-select`/`rust-map-select`, and `normal-map-flow`/`rust-normal-map-flow`. Run one group per `cargo xtask test-group <name>` invocation with the flake's explicit PYTHON. Groups regenerate dependency closure; Rust groups include scoped gameplay tests/test-count metadata. Registry regression checks parity edges, module consumers and shared transition/intermission dependencies. Continue focused checks per task and one full run after ten commits. [Batch evidence and native boundaries](research/QVM_SPAWN_MAP_COMMAND_BATCH.md). |
| |
| |
| RE-874–883 adds focused groups `qvm-bot-best`, `rust-bot-best`, `qvm-bot-breed`, `rust-bot-breed`, `qvm-post-map-clients`, `rust-post-map-clients`, `qvm-spawn-overlap`, `rust-spawn-overlap`, `qvm-bot-rotation` and `rust-bot-rotation`. Invoke one group per `cargo xtask test-group <name>`. Source/Rust report identity and native_policy dependencies are covered by the registry regression. Full validation at the tenth-commit boundary uses `cargo xtask test-full --since 40af75ff` in the flake tool environment with explicit Nix-store PYTHON. |
|
|
|
|
| RE-884–893 adds focused groups `qvm-queried-spawn`, `rust-queried-spawn`, `qvm-queried-camera`, `rust-queried-camera`, `qvm-session-write`, `rust-session-write`, `qvm-post-map-session`, `rust-post-map-session`, `qvm-normal-map-session` and `rust-normal-map-session`. Invoke one group per `cargo xtask test-group <name>`. Full batch validation after task ten uses `cargo xtask test-full --since b9a94452` with explicit flake-declared Nix PYTHON. [Evidence and limits](research/QVM_QUERIED_PERSISTENCE_BATCH.md). |
|
|
|
|
| RE-894–903 adds focused groups `qvm-info-lookup`, `rust-info-lookup`, `qvm-numeric-scan`, `rust-numeric-scan`, `qvm-position-save`, `rust-position-save`, `qvm-position-load`, `rust-position-load`, `qvm-session-restore` and `rust-session-restore`. Use one group per invocation. Full validation after task ten uses `cargo xtask test-full --since 6e01995b` with explicit flake-declared Nix PYTHON. [Source domains and scratch ownership](research/QVM_SAVED_RESTORE_BATCH.md). |
|
|
|
|
| RE-904–913 adds focused groups `qvm-session-init`, `rust-session-init`, `qvm-post-map-files`, `rust-post-map-files`, `qvm-normal-map-files`, `rust-normal-map-files`, `qvm-persistence-roundtrip`, `rust-persistence-roundtrip`, `qvm-connect-session` and `rust-connect-session`. Invoke one group per command. The full suite after task ten uses `cargo xtask test-full --since 6d0ce63f` with explicit flake-declared Nix PYTHON. [Bounded lifecycle evidence](research/QVM_SESSION_LIFECYCLE_BATCH.md). |
|
|
|
|
| RE-914–923 adds `qvm-byte-compare`, `rust-byte-compare`, `qvm-address-filter`, `rust-address-filter`, `qvm-connect-admission`, `rust-connect-admission`, `qvm-connect-tail`, `rust-connect-tail`, `qvm-connect-complete` and `rust-connect-complete`. Invoke one group per command. Full validation after task ten uses `cargo xtask test-full --since 2b1ac7ec` with explicit flake-declared Nix PYTHON. [Bounded connect evidence](research/QVM_CONNECT_POLICY_BATCH.md). |
|
|
|
|
| RE-924–933 adds `qvm-bot-settings`, `rust-bot-settings`, `qvm-team-announcement`, `rust-team-announcement`, `qvm-resolved-connect-tail`, `rust-resolved-connect-tail`, `qvm-resolved-connect-complete`, `rust-resolved-connect-complete`, `qvm-filter-insert` and `rust-filter-insert`. Use one group per invocation. Full validation after task ten uses `cargo xtask test-full --since bc3e7621` with explicit flake-declared Nix PYTHON. [Callback/filter evidence](research/QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md). |
|
|
| Filter persistence focused groups: `qvm-filter-export`, `rust-filter-export`, `qvm-filter-remove`, `rust-filter-remove`, `qvm-filter-metadata`, `rust-filter-metadata`, `qvm-filter-insert-export`, `rust-filter-insert-export`, `qvm-filter-remove-export` and `rust-filter-remove-export`. The shared Rust filter lifecycle module and adapter select all affected parity reports and scoped gameplay test metadata; formatter edits also select these consumers. Run one group per invocation. Native file effects are captured plans in these checks. |
|
|
| Filter loading focused groups: `qvm-filter-time`, `rust-filter-time`, `qvm-filter-expiry`, `rust-filter-expiry`, `qvm-filter-load`, `rust-filter-load`, `qvm-filter-duration`, `rust-filter-duration`, `qvm-filter-roundtrip` and `rust-filter-roundtrip`. The shared loading module/adapter, native policies, lifecycle module and formatter inputs select affected parity producers and scoped gameplay test-count metadata. Run one group per invocation. Time/file replies are supplied snapshots; native effects are captured. |
|
|
| Filter command/caller focused groups: `qvm-filter-add-command`, `rust-filter-add-command`, `qvm-filter-remove-command`, `rust-filter-remove-command`, `qvm-filter-duration-export`, `rust-filter-duration-export`, `qvm-filter-expiry-admission`, `rust-filter-expiry-admission`, `qvm-filter-frame-prefix` and `rust-filter-frame-prefix`. Shared command/loading/lifecycle/native-policy/formatter changes select their parity reports and scoped gameplay test-count metadata. Run one group per invocation. Full-capacity source loops use bounded262144-instruction budgets; native effects remain supplied/captured. |
|
|
| Client timer focused groups: `qvm-client-timer-terminal`, `rust-client-timer-terminal`, `qvm-client-timer-ticks`, `rust-client-timer-ticks`, `qvm-client-timer-recovery`, `rust-client-timer-recovery`, `qvm-client-timer-complete`, `rust-client-timer-complete`, `qvm-client-timer-prepare` and `rust-client-timer-prepare`. Shared timer and dependent gameplay modules select parity producers plus scoped gameplay test-count metadata. Run one group per invocation. Full-body probes keep native time supplied and damage effects captured; caller-prefix probes stop explicitly at154210 or155716. |
|
|
| Client processing focused groups: `qvm-client-routing`, `rust-client-routing`, `qvm-client-command-rewrite`, `rust-client-command-rewrite`, `qvm-client-inactivity`, `rust-client-inactivity`, `qvm-client-movement-setup`, `rust-client-movement-setup`, `qvm-client-pre-movement` and `rust-client-pre-movement`. Shared processing and dependent gameplay modules select parity producers plus scoped gameplay test-count metadata. Run one group per invocation. Source prefixes stop at explicit154544/155716 boundaries; native callbacks remain captured. |
|
|
| Movement-context focused pairs: `qvm-client-move-scratch`/`rust-client-move-scratch`, `qvm-client-move-suppression`/`rust-client-move-suppression`, `qvm-client-move-mask`/`rust-client-move-mask`, `qvm-client-move-context`/`rust-client-move-context`, and `qvm-client-move-assembly`/`rust-client-move-assembly`. Run one group per invocation. Shared `client_move_context` and CLI changes select all five Rust producers plus gameplay test-count metadata. Source151954 executes in linked-mask probes; mode callbacks are captured with explicitly supplied feedback in composition. The batch full check is `cargo xtask test-full --since 99a6f51a` after ten commits. [Contracts and next work](research/QVM_MOVE_CONTEXT_BATCH.md). |
|
|
| Movement-callback focused pairs: `qvm-move-meter`/`rust-move-meter`, `qvm-move-self-recovery`/`rust-move-self-recovery`, `qvm-move-assist-cleanup`/`rust-move-assist-cleanup`, `qvm-move-mode8-eligibility`/`rust-move-mode8-eligibility`, and `qvm-move-resolved-self`/`rust-move-resolved-self`. Use one group per invocation. Shared callback module/CLI changes select their Rust producers and gameplay test-count metadata; movement-context changes also select resolved self composition. One full check follows the tenth task: `cargo xtask test-full --since ad83778f`. [Evidence and boundaries](research/QVM_MOVE_CALLBACK_BATCH.md). |
|
|
| Assistance focused pairs: `qvm-assist-acquire`/`rust-assist-acquire`, `qvm-assist-cancel`/`rust-assist-cancel`, `qvm-assist-progress`/`rust-assist-progress`, `qvm-assist-complete`/`rust-assist-complete`, and `qvm-assist-sequence`/`rust-assist-sequence`. Use one group per invocation. Assistance module/CLI and recovered meter/cleanup inputs select affected Rust reports plus gameplay test-count metadata. Complete/replay probes execute actual152792/65655/152386 with modeled sqrt and captured/supplied native effects. The batch full check is `cargo xtask test-full --since 19fce7e8` after ten tasks. [Evidence and limits](research/QVM_ASSISTANCE_BATCH.md). |
|
|
| Defuse focused pairs: `qvm-defuse-begin`/`rust-defuse-begin`, `qvm-defuse-cancel`/`rust-defuse-cancel`, `qvm-defuse-finish`/`rust-defuse-finish`, `qvm-defuse-complete`/`rust-defuse-complete`, and `qvm-defuse-sequence`/`rust-defuse-sequence`. Run one group per invocation. Defuse module/CLI and eligibility inputs select affected Rust producers plus gameplay test-count metadata. Full/replay source checks execute actual153419/276433/65655 with modeled sqrt and supplied/captured native effects; missing lookup stops before fatal2319. Batch-wide validation after task ten is `cargo xtask test-full --since 26cfc686`. [Evidence and boundaries](research/QVM_DEFUSE_BATCH.md). |
|
|
| Resolved-feedback focused pairs: `qvm-effect-counter`/`rust-effect-counter`, `qvm-effect-radio`/`rust-effect-radio`, `qvm-effect-defuse-finish`/`rust-effect-defuse-finish`, `qvm-effect-defuse-begin`/`rust-effect-defuse-begin`, and `qvm-effect-defuse-complete`/`rust-effect-defuse-complete`. Run one group per invocation. Feedback/score/constructor and defuse inputs select affected producers plus gameplay test-count metadata. Function205260 is score,283463 is indexed counter increment and193620 is team radio; historical labels remain compatible. Full validation after task ten: `cargo xtask test-full --since 74572275`. [Evidence and correction](research/QVM_EFFECT_FEEDBACK_BATCH.md). |
|
|
| Location/allocation focused pairs: `qvm-location-nearest`/`rust-location-nearest`, `qvm-location-text`/`rust-location-text`, `qvm-location-radio`/`rust-location-radio`, `qvm-location-allocation`/`rust-location-allocation`, and `qvm-location-allocated-defuse`/`rust-location-allocated-defuse`. Use one group per invocation. Shared location/formatter/radio/defuse/constructor inputs select affected producers and gameplay test-count metadata. Native box/PVS/send/link/registration remain supplied or captured; allocator terminal prefixes are preserved and allocated-defuse stops before radio. Full validation after ten tasks: `cargo xtask test-full --since a1fd4e2b`. [Evidence and scope](research/QVM_LOCATION_ALLOCATION_BATCH.md). |
|
|
