## Phase 72: Game Engine Industrial SOTA Gap Closure

**Purpose:** Close every remaining gap between the Oshun/Maya/Neith game engine
ecosystem and the state-of-the-art tooling used by AAA studios (Rockstar,
Bethesda, Epic, Naughty Dog, id Software, Insomniac, CD Projekt Red). This phase
covers 30 identified gaps across engine systems, production tools, platform
support, and live service infrastructure that have no existing task coverage in
TODOS.md.

**Scope:** Maya engine (Rust), Neith engine framework, and supporting
infrastructure. Each section is a self-contained subsystem with full task
breakdown.

**Audit status (2026-06-19):** All Phase 72 checklist boxes were reset to
unchecked after an evidence audit. A checked box in this file must mean the
specific task is implemented and verified, not merely specified, scaffolded,
documented, or represented by a planning manifest. See `TODOS/phase-72-audit.md`
for the audit basis and representative evidence gaps.

---

### 72.1 Neural Rendering Pipeline (NRC, Neural Shaders, Cooperative Vectors)

NVIDIA Neural Radiance Cache, Ray Reconstruction denoiser, DirectX Cooperative
Vectors for neural shaders — the bleeding edge of real-time rendering 2025-2026.

#### 72.1.1 Neural Radiance Cache (NRC)

- [x] **72.1.1.1** Design neural radiance cache architecture for Maya renderer
      (small MLP trained per-scene during gameplay to approximate indirect
      lighting)
  - Evidence (2026-06-19): Added
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`
    with validated feature layout, per-scene small MLP architecture, memory
    budget estimates, GI integration policy, async-compute pass descriptors,
    public exports, and focused Rust tests.
- [x] **72.1.1.2** Implement neural network training loop running on GPU async
      compute during frame rendering
  - Evidence (2026-06-19): Added `NeuralRadianceCacheTrainingLoop` in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`
    with validated training samples, per-frame batch draining, async-compute
    sample-compaction and chained MLP update submissions, execution-plan
    generation, GPU completion feedback, pending-batch/weights-version stats,
    public exports, and focused Rust tests proving async overlap with frame
    rendering work.
- [x] **72.1.1.3** Create training data generation from path-traced samples
      (position, normal, viewing direction → radiance)
  - Evidence (2026-06-19): Added `NeuralRadianceCachePathTracedSample` and
    `NeuralRadianceCacheTrainingDataGenerator` in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs` to
    validate path-traced hit data, normalize normal/view vectors, encode raw or
    Fourier position features, include optional material/direct-irradiance
    features, emit `NeuralRadianceCacheTrainingSample` targets, enqueue
    generated samples into the async trainer, expose generation stats, and
    verify the flow with focused Rust tests.
- [x] **72.1.1.4** Implement inference integration into GI pipeline (query NRC
      instead of additional bounces)
  - Evidence (2026-06-19): Added deployed NRC MLP inference types
    (`NeuralRadianceCacheInferenceWeights`, `NeuralRadianceCacheInferenceQuery`,
    `NeuralRadianceCacheInferencePipeline`) in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`
    and `DiffuseGiPipeline::compute_bounce_with_nrc` in
    `libs/maya/engine-core/crates/maya-renderer/src/diffuse_gi.rs` so additional
    diffuse bounces query NRC radiance with confidence-gated classical fallback,
    exported the API, and verified replacement/fallback behavior with focused
    Rust tests.
- [x] **72.1.1.5** Create temporal stability mechanisms for NRC output
      (exponential moving average, jitter suppression)
  - Evidence (2026-06-19): Added `NeuralRadianceCacheTemporalConfig` and
    `NeuralRadianceCacheTemporalKey` in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`
    plus temporal history in `NeuralRadianceCacheInferencePipeline` with EMA
    blending, query-interval history reuse, compatible-history reuse for invalid
    outputs, luminance-spike jitter suppression, temporal stats, and
    `DiffuseGiPipeline::compute_bounce_with_nrc` now querying the stable NRC
    path with focused Rust tests for NRC and GI behavior.
- [x] **72.1.1.6** Implement scene change detection for NRC retraining triggers
      (light moved, time-of-day change, door opened)
  - Evidence (2026-06-19): Added validated scene observation and retraining
    trigger APIs (`NeuralRadianceCacheSceneState`,
    `NeuralRadianceCacheSceneLight`, `NeuralRadianceCacheDoorState`,
    `NeuralRadianceCacheSceneChangeDetector`, and
    `NeuralRadianceCacheRetrainingDecision`) in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    The detector compares stable light IDs, normalized time-of-day, and door
    open fractions, records retraining epochs/event masks/stats, and
    `NeuralRadianceCacheTrainingLoop::observe_scene` clears stale queued samples
    plus loss history before new training after a trigger. Focused Rust tests
    cover light movement, time-of-day changes, door opening, invalid
    observations, config validation, and training-loop invalidation.
- [x] **72.1.1.7** Create NRC quality/performance scaling (network size,
      training rate, inference frequency)
  - Evidence (2026-06-19): Added `NeuralRadianceCacheScalingConfig`,
    `NeuralRadianceCacheScalingProfile`, `NeuralRadianceCachePerformanceSample`,
    `NeuralRadianceCacheQualityScaler`, and scaling decision/stats/reason types
    in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    Scaling profiles now bundle low-latency, balanced, and quality network
    layouts, training schedules, memory budgets, inference tile sizes, and query
    intervals; `NeuralRadianceCacheConfig::apply_scaling_profile` updates those
    knobs while preserving unrelated temporal/scene policies; and the runtime
    scaler downshifts on frame/NRC cost pressure and upshifts under sustained
    headroom. Focused Rust tests cover tier differences, config application,
    automatic downscale/upscale, and validation failures.
- [x] **72.1.1.8** Implement NRC warm-up strategy for level loads (pre-train
      from baked data, then refine live)
  - Evidence (2026-06-19): Added `NeuralRadianceCacheWarmupConfig`,
    `NeuralRadianceCacheBakedRadianceSample`,
    `NeuralRadianceCacheWarmupDataset`, `NeuralRadianceCacheWarmupController`,
    warm-up stage/frame-plan/stats types, and config/dataset validation in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    The controller accepts baked level data, converts it through the existing
    NRC training-data encoder over bounded warm-up frames, enqueues baked
    pretraining samples before live rendering, then transitions to live
    refinement with a separate sample-weight multiplier. Focused Rust tests
    cover multi-frame baked pretraining, live-refinement handoff, underfilled
    baked datasets, and invalid warm-up config.
- [x] **72.1.1.9** Create NRC memory budget management (VRAM allocation for
      network weights, training buffers)
  - Evidence (2026-06-19): Added `NeuralRadianceCacheMemoryResource`,
    allocation/plan/fit structs, `NeuralRadianceCacheMemoryManager`, and memory
    manager stats in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    The manager plans explicit VRAM pools for deployed weights, training
    weights, optimizer state, training sample buffers, and inference scratch;
    reserves/releases architecture allocations against the configured NRC memory
    budget; preserves existing budget-exceeded errors; and can choose the
    highest scaling profile that fits a constrained budget. Focused Rust tests
    cover allocation planning, release accounting, overflow rejection, and
    fit-to-budget downscaling.
- [x] **72.1.1.10** Implement NRC debugging visualization (show what the network
      learned vs ground truth path tracing)
  - Evidence (2026-06-19): Added CPU-side NRC debug visualization APIs
    (`NeuralRadianceCacheDebugVisualizer`,
    `NeuralRadianceCacheDebugVisualizationMode`,
    `NeuralRadianceCacheDebugSample`, `NeuralRadianceCacheDebugVisualization`,
    debug pixels, and debug stats) in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    The visualizer queries deployed NRC inference for screen-space debug
    samples, compares network radiance against path-traced ground truth,
    computes confidence, absolute/relative error metrics, and emits RGBA buffers
    for learned radiance, ground-truth radiance, error heatmaps, and confidence
    overlays. Focused Rust tests cover rendered comparison/error/confidence
    output and invalid sample bounds.
- [x] **72.1.1.11** Create NRC serialization for save/load (persist trained
      weights so returning to an area doesn't retrain from scratch)
  - Evidence (2026-06-19): Added versioned NRC save/load support via
    `NeuralRadianceCacheSerializedState`, `NRC_SERIALIZED_STATE_MAGIC`, and
    `NRC_SERIALIZED_STATE_VERSION` in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    Serialized states persist a level identifier, validated architecture,
    deployed inference weights, training stats, and saved frame index; encode
    and decode as JSON bytes with schema/magic validation; validate restored
    weights against the saved architecture; and can restore a
    `NeuralRadianceCacheInferencePipeline` directly. Focused Rust tests cover
    JSON round-trip restoration and corrupted-header rejection.
- [x] **72.1.1.12** Implement multi-resolution NRC (coarse network for distant
      lighting, fine network for near-field)
  - Evidence (2026-06-19): Added multi-resolution NRC support in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`
    through `NeuralRadianceCacheMultiResolutionConfig`,
    `NeuralRadianceCacheMultiResolutionArchitecture`,
    `NeuralRadianceCacheMultiResolutionInferencePipeline`, resolution tier
    selection/blending, and a
    `NeuralRadianceCacheMultiResolutionTrainingRouter`. The wrapper composes
    validated coarse/fine architectures from preset tiers, validates their
    combined memory footprint against the caller budget, exposes tier-prefixed
    pass plans/compute tasks, routes near-field queries to the fine MLP, distant
    queries to the coarse MLP, blends through the transition band, and splits
    transition training samples between coarse and fine trainers with weighted
    samples. Focused Rust tests cover architecture/pass/memory composition,
    distance-based inference routing and blending, transition training sample
    splitting, and invalid tier setup rejection.
- [x] **72.1.1.13** Create NRC integration with existing Lumen-class GI (NRC as
      acceleration structure for software ray tracing)
  - Evidence (2026-06-19): Added a software ray tracing NRC acceleration layer
    in `libs/maya/engine-core/crates/maya-renderer/src/software_rt.rs` with
    `NrcSoftwareRtConfig`, `NrcSoftwareRtQuery`, `NrcSoftwareRtResult`, and
    `SoftwareRtPipeline::trace_gi_with_nrc`. Diffuse GI rays now have a
    renderer-facing path that queries the trained NRC before falling back to the
    software BVH: confident learned radiance skips the BVH trace entirely,
    disabled/too-long/low-confidence/invalid NRC predictions fall back to the
    normal software trace with explicit reasons, temporal NRC keys are wired to
    pixel+bounce identity, and fallback traces preserve the software RT
    counters. Focused Rust tests cover confident NRC acceleration without BVH
    work, low-confidence fallback to software tracing, and disabled NRC fallback
    without querying the network.
- [x] **72.1.1.14** Implement NRC benchmarks comparing quality and performance
      against pure path tracing and probe-based GI
  - Evidence (2026-06-19): Added `NeuralRadianceCacheBenchmarkSuite` and public
    benchmark report/config/result types in
    `libs/maya/engine-core/crates/maya-renderer/src/neural_radiance_cache.rs`.
    The deterministic benchmark generates fixed GI queries, treats synthetic
    high-sample path tracing as ground truth, queries the live NRC inference
    runtime, seeds the existing probe-GI pipeline for the probe baseline, and
    reports luminance error, valid sample counts, confidence, estimated cost,
    and NRC/probe speedups versus path tracing. Focused Rust tests cover full
    path/NRC/probe report generation and invalid benchmark configuration
    rejection.
- [x] **72.1.1.15** Create NRC documentation and tuning guide for technical
      artists
  - Evidence (2026-06-19): Added and verified the NRC technical artist tuning
    guide at `libs/maya/renderer/docs/nrc-technical-artist-tuning-guide.md`. The
    guide covers when to use NRC, core controls, 60 fps/cinematic/low-memory
    starting presets, warm-up workflow, debug views, scene-change retraining,
    Lumen-class GI integration, benchmark gates, benchmark report
    interpretation, troubleshooting, and signoff checklist. Renderer tests now
    assert that the guide includes the required sections and references the
    `NeuralRadianceCacheBenchmarkReport` fields artists review for NRC approval.

#### 72.1.2 ML-Based Denoising (Ray Reconstruction)

- [x] **72.1.2.1** Implement temporal ML denoiser for ray-traced effects
      (shadows, reflections, GI) inspired by NVIDIA Ray Reconstruction
  - Evidence (2026-06-19): Verified the temporal ML ray reconstruction planner
    in `libs/maya/renderer/src/index.ts` via `planMayaTemporalMlDenoiser`,
    `MayaTemporalMlDenoiserInput`, `MayaTemporalMlDenoiserPlan`, and per-effect
    support for `raytraced-shadows`, `raytraced-reflections`, and
    `raytraced-diffuse-gi`. The planner validates G-buffer/motion-vector
    requirements, model effect coverage, temporal history, hardware ML
    availability, frame/memory budgets, and fallback policy; it emits feature
    packing, history reprojection, ML inference, temporal stabilization, and
    TAA/TSR handoff stages. Focused renderer tests cover the ready temporal ML
    denoiser path, blocked fallback conditions, and duplicate effect validation.
- [x] **72.1.2.2** Create denoiser training pipeline (generate noisy/clean pairs
      from offline rendering)
  - Evidence (2026-06-19): Verified the denoiser offline dataset builder in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserTrainingPipeline`,
    `MayaMlDenoiserTrainingPipelineInput`, and `MayaMlDenoiserTrainingPair`. The
    pipeline consumes offline low-spp noisy ray-traced samples and high-spp
    clean references, validates G-buffer/motion
    vectors/material/depth/hit-distance/reactive-mask data, encodes
    noisy-radiance/G-buffer/motion/effect features, creates residual targets,
    assigns train/validation splits, tracks per-effect coverage, rejects invalid
    samples when configured, and emits offline noisy render, clean reference
    render, G-buffer export, pair alignment, and dataset split stages. Focused
    renderer tests cover ready pair generation, rejected sample/missing coverage
    reporting, and strict invalid pair failure.
- [x] **72.1.2.3** Implement denoiser inference as post-process pass consuming
      G-buffer (normals, depth, motion vectors) plus noisy input
  - Evidence (2026-06-19): Verified the ML denoiser post-process integration in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserInferencePostProcessPass`,
    `MayaMlDenoiserPostProcessInput`, and
    `MayaMlDenoiserPostProcessIntegration`. The pass consumes noisy ray-traced
    effect attachments plus G-buffer resources for normals, depth, motion
    vectors, roughness, view direction, hit distance, and reactive mask; binds
    model resources, computes per-effect dispatch groups, emits denoised output
    attachments, selects async compute when the temporal plan supports it,
    validates attachment dimensions and required inputs, enforces post-process
    budgets, and falls back to spatial denoising or disables the pass when
    inputs are incomplete. Focused renderer tests cover ready ML post-process
    binding, blocked missing-input behavior, and invalid attachment dimensions.
- [x] **72.1.2.4** Create per-effect denoiser specialization (separate models
      for shadows vs reflections vs diffuse GI)
  - Evidence (2026-06-19): Verified per-effect denoiser specialization in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserPerEffectSpecialization`,
    `MayaMlDenoiserSpecializedModelCandidate`,
    `MayaMlDenoiserSpecializedModelSelection`, and
    `MayaMlDenoiserPerEffectSpecializationPlan`. The planner chooses separate
    effect-specific models for `raytraced-shadows`, `raytraced-reflections`, and
    `raytraced-diffuse-gi`, scores candidate quality, temporal stability, and
    inference cost, computes total per-effect cost and unique-model memory,
    supports configured shared-model fallback, reports missing model, quality,
    stability, inference-budget, and memory-budget issues, and emits bind/train
    actions. Focused renderer tests cover separate model selection, shared
    fallback, and blocked missing-model behavior.
- [x] **72.1.2.5** Implement denoiser temporal accumulation with motion
      vector–guided reprojection
  - Evidence (2026-06-19): Verified temporal ML denoiser history accumulation in
    `libs/maya/renderer/src/index.ts` via
    `accumulateMayaMlDenoiserTemporalHistory`,
    `MayaMlDenoiserTemporalSampleInput`,
    `MayaMlDenoiserTemporalAccumulatedSample`, and
    `MayaMlDenoiserTemporalAccumulationReport`. The accumulator reprojects
    history positions from per-pixel motion vectors and viewport dimensions,
    blends history and current radiance with motion/reactive-mask weighted
    history confidence, rejects history for excessive motion, depth
    disocclusion, normal changes, and reactive pixels, reports high rejection or
    disabled temporal-plan issues, and estimates variance reduction from the
    accepted history weight. Focused renderer tests cover motion-vector
    reprojection with stable blending, depth/reactive-mask rejection, high
    rejection reporting, and invalid viewport/sample metadata.
- [x] **72.1.2.6** Create denoiser quality presets (1spp aggressive denoise for
      low-end, 4spp light denoise for high-end)
  - Evidence (2026-06-19): Verified ML denoiser quality presets in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserQualityPresetPlan`, `MayaMlDenoiserQualityPresetId`,
    `MayaMlDenoiserQualityPresetSettings`, and
    `MayaMlDenoiserQualityPresetPlan`. The preset table defines
    `low-end-1spp-aggressive`, `balanced-2spp-temporal`, and
    `high-end-4spp-light`; the planner converts preset settings into temporal ML
    denoiser inputs, per-effect denoise strength, temporal blend weight,
    variance reduction, frame-cost and working-set budgets, quality and temporal
    stability estimates, history rejection thresholds, fallback actions, and
    blocking/warning issues. Focused renderer tests cover the 1spp aggressive
    low-end preset, 4spp light high-end preset, and blocked high-end behavior on
    under-budget hardware.
- [x] **72.1.2.7** Implement denoiser ghosting/lag artifact suppression
      (disocclusion detection, history invalidation)
  - Evidence (2026-06-19): Verified ML denoiser ghosting and lag suppression in
    `libs/maya/renderer/src/index.ts` via
    `suppressMayaMlDenoiserGhostingArtifacts`,
    `MayaMlDenoiserGhostingSampleInput`,
    `MayaMlDenoiserGhostingSuppressedSample`, and
    `MayaMlDenoiserGhostingSuppressionReport`. The suppressor computes
    disocclusion, lag, ghosting-risk, stale-history, low-confidence, radiance
    delta, motion, normal, and reactive-mask signals, invalidates history for
    disocclusion, normal/reactive changes, motion lag, radiance lag, or stale
    samples, scales retained history weights, outputs corrected radiance, and
    reports high ghosting or invalidation rates. Focused renderer tests cover
    stable history preservation, disocclusion invalidation, lag invalidation,
    corrected radiance, issue reporting, and invalid threshold/sample metadata.
- [x] **72.1.2.8** Create denoiser integration with existing TAA/TSR pipeline
      (avoid double-filtering)
  - Evidence (2026-06-19): Verified ML denoiser integration with the TAA/TSR
    pipeline in `libs/maya/renderer/src/index.ts` via
    `integrateMayaMlDenoiserWithTaaTsrPipeline`,
    `MayaMlDenoiserTaaTsrPipelineInput`, `MayaMlDenoiserTaaTsrResolvePolicy`,
    and `MayaMlDenoiserTaaTsrPipelineIntegration`. The planner feeds ML-denoised
    ray-traced outputs into a pre-TAA/pre-TSR composite, configures the resolve
    policy to avoid a second temporal filter, tracks denoised history feedback,
    emits composite, resolve, direct post-process, and history-feedback stages,
    estimates resolve cost, and reports disabled TAA/TSR, post-process,
    missing-output, double-filtering, history-feedback, and budget issues.
    Focused renderer tests cover pre-TSR composition without double filtering,
    direct post-process fallback when TAA/TSR is disabled, and blocked handoff
    when no denoised output exists.
- [x] **72.1.2.9** Implement ONNX Runtime integration for denoiser inference
      (cross-vendor: NVIDIA, AMD, Intel)
  - Evidence (2026-06-19): Verified cross-vendor ONNX Runtime denoiser
    integration in `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserOnnxRuntimeIntegration`,
    `MayaMlDenoiserOnnxProviderProfile`, `MayaMlDenoiserOnnxSessionOptions`, and
    `MayaMlDenoiserOnnxRuntimeIntegration`. The integration ranks NVIDIA
    TensorRT/CUDA, AMD DirectML, Intel OpenVINO, and CPU execution providers by
    vendor preference, precision support, availability, and latency; validates
    model metadata and tensor shapes; builds optimized session options, provider
    options, G-buffer input bindings, and per-effect output bindings; estimates
    inference cost and memory; configures CPU fallback; and reports blocked
    plans, provider availability/precision, I/O binding, inference budget, and
    memory issues. Focused renderer tests cover NVIDIA/AMD/Intel provider
    selection, CPU fallback, I/O binding fallback, tensor bindings, and invalid
    tensor shape validation.
- [x] **72.1.2.10** Create denoiser model quantization (FP16/INT8) for
      performance on consumer GPUs
  - Evidence (2026-06-19): Verified FP16/INT8 denoiser model quantization in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserModelQuantizationPlan`,
    `MayaMlDenoiserQuantizationInput`,
    `MayaMlDenoiserQuantizationCalibrationSample`, and
    `MayaMlDenoiserQuantizationPlan`. The planner selects INT8-capable ONNX
    providers for consumer GPU deployment, falls back to FP16 when allowed,
    tracks per-effect calibration coverage, estimates quantization quality loss,
    memory, and inference cost, emits export, calibration activation,
    quantize-weight, and validation stages, builds quantized model profiles, and
    reports unsupported precision, FP16 fallback, calibration coverage/outlier,
    quality, memory, and inference-budget issues. Focused renderer tests cover
    ready INT8 quantization, FP16 fallback when INT8 is unavailable, deployment
    actions, stage graphs, and invalid calibration activation ranges.
- [x] **72.1.2.11** Implement denoiser fallback to traditional spatial filters
      on hardware without ML inference support
  - Evidence (2026-06-19): Verified traditional spatial denoiser fallback in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserSpatialFallbackPlan`,
    `MayaMlDenoiserSpatialFallbackInput`,
    `MayaMlDenoiserSpatialFallbackEffectPlan`, and
    `MayaMlDenoiserSpatialFallbackPlan`. The planner switches to
    `traditional-spatial-filter` when ML inference hardware is unavailable or
    manual fallback is selected, requires noisy radiance plus normal/depth
    edge-stopping buffers, uses optional roughness, hit-distance, and reactive
    features, builds variance clamp, depth/normal bilateral, roughness-guided,
    specular-preserving, and atrous filter chains, emits variance
    classification, edge-aware prefilter, iterative filter, and composite
    stages, publishes history-free spatial outputs, estimates cost, quality, and
    variance reduction, and blocks on missing inputs, attachment mismatch, or
    budget/quality failures. Focused renderer tests cover ready legacy-GPU
    spatial fallback and blocked missing-buffer/missing-input behavior.
- [x] **72.1.2.12** Create denoiser A/B comparison tool for artists
      (split-screen noisy vs denoised vs reference)
  - Evidence (2026-06-19): Verified the artist denoiser A/B comparison tool in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserArtistComparisonTool`, `MayaMlDenoiserComparisonInput`,
    `MayaMlDenoiserComparisonPane`, and `MayaMlDenoiserComparisonTool`. The
    planner builds noisy, denoised, and reference panes for triple-split, A/B
    wipe, and stacked-reference layouts, synchronizes zoom/pan across panes,
    exposes effect tabs, layout selection, split slider, residual heatmap, and
    exposure lock controls, computes per-effect sample/reference confidence,
    noise reduction, and artifact-risk metrics, estimates comparison overlay
    cost, and reports missing inputs, missing references, attachment mismatches,
    small viewports, and budget issues. Focused renderer tests cover the
    triple-split comparison workspace with residual heatmap and blocked
    comparison when required reference panes are missing.
- [x] **72.1.2.13** Implement denoiser profiling (measure inference latency per
      frame, VRAM usage)
  - Evidence (2026-06-19): Verified denoiser profiling in
    `libs/maya/renderer/src/index.ts` via `createMayaMlDenoiserProfilingReport`,
    `MayaMlDenoiserProfilingFrameSample`, `MayaMlDenoiserProfilingFrameSummary`,
    and `MayaMlDenoiserProfilingReport`. The profiler captures frame-window
    samples with inference latency, post-process latency, queue wait, effect
    count, VRAM usage, and transient VRAM, computes average, p95, p99, and max
    inference latency, average and p95 frame cost, frame-budget hit rate,
    average and peak VRAM, per-frame exceeded budgets, and provider attribution,
    then reports blocked plans, runtime readiness, insufficient samples,
    latency, frame, VRAM, and transient-memory issues with latency/VRAM
    reduction actions. Focused renderer tests cover ready latency/VRAM reporting
    and blocked signoff when inference, frame, VRAM, and transient VRAM budgets
    fail.
- [x] **72.1.2.14** Create denoiser model hot-swap for experimentation (load new
      model without engine restart)
  - Evidence (2026-06-19): Verified denoiser model hot-swap planning in
    `libs/maya/renderer/src/index.ts` via
    `createMayaMlDenoiserModelHotSwapPlan`, `MayaMlDenoiserHotSwapInput`,
    `MayaMlDenoiserHotSwapCompatibility`, and `MayaMlDenoiserHotSwapPlan`. The
    planner validates active and candidate ONNX model metadata, checks effect
    coverage, precision support, temporal history compatibility, runtime
    readiness, memory, swap latency, and rollback availability, schedules
    candidate validation, model load, shadow runtime session creation, warmup,
    atomic session swap, and rollback-retain stages, computes swap frame,
    additional memory, swap latency, history preservation, and rollback
    retention, and emits remediation actions for incompatible candidates,
    unsupported precision, memory, latency, and runtime readiness. Focused
    renderer tests cover a ready warm hot-swap without engine restart and
    blocked incompatible candidates.
- [x] **72.1.2.15** Implement denoiser benchmark suite against traditional
      denoisers (SVGF, A-SVGF, BMFR)
  - Evidence (2026-06-19): Verified the ML denoiser benchmark suite in
    `libs/maya/renderer/src/index.ts` via
    `benchmarkMayaMlDenoiserAgainstTraditionalDenoisers`,
    `MayaMlDenoiserBenchmarkBaseline`, `MayaMlDenoiserBenchmarkResult`, and
    `MayaMlDenoiserBenchmarkSuite`. The suite compares ML temporal ray
    reconstruction against SVGF, A-SVGF, and BMFR baselines, derives ML metrics
    from measured values or profiling reports, computes FPS, normalized frame
    time, normalized quality, speedup-vs-ML, quality, temporal-stability, and
    memory deltas, selects the best traditional baseline, reports ML
    speedup/quality/stability/memory versus that baseline, recommends either ML
    or the winning traditional fallback, and raises plan/runtime, frame, memory,
    quality, temporal, quality regression, and speedup issues with
    keep-baseline, ship, retain-fallback, latency, memory, and
    reference-expansion actions. Focused renderer tests cover ML winning against
    SVGF/A-SVGF/BMFR, traditional BMFR winning blocked signoff, and invalid
    benchmark measurement validation.

#### 72.1.3 Neural Shaders & Cooperative Vectors

- [x] **72.1.3.1** Implement DirectX Cooperative Vectors API integration for
      executing small neural networks inside shader programs
  - Evidence (2026-06-19): Verified DX12 cooperative vector neural shader
    integration in `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderDx12CooperativeVectorIntegration`,
    `MayaNeuralShaderDx12HardwareProfile`, `MayaNeuralShaderNetworkProfile`, and
    `MayaNeuralShaderDx12IntegrationPlan`. The planner validates neural network
    layer topology, Shader Model 6.9/DXIL 1.8 cooperative vector support,
    adapter precision support, vector length, matrix input/output limits, weight
    memory, inference budget, and occupancy; selects cooperative-vector,
    scalar-fallback, or blocked mode; emits D3D12 feature-query, weight upload,
    HLSL module generation, DXIL compile, root-signature bind, and neural shader
    dispatch stages; binds input feature, weight, constants, and UAV output
    resources; and returns driver, network width, quantization, and profiling
    remediation actions. Focused renderer tests cover ready DX12 cooperative
    vector execution, unsupported adapter blocking, and invalid layer topology.
- [x] **72.1.3.2** Create Vulkan equivalent using cooperative matrix extensions
      (VK_KHR_cooperative_matrix)
  - Evidence (2026-06-19): Verified Vulkan cooperative matrix neural shader
    integration in `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderVulkanCooperativeMatrixIntegration`,
    `MayaNeuralShaderVulkanHardwareProfile`,
    `MayaNeuralShaderVulkanCooperativeMatrixProperty`, and
    `MayaNeuralShaderVulkanIntegrationPlan`. The planner validates Vulkan API
    version, `VK_KHR_cooperative_matrix`, SPIR-V cooperative matrix and Vulkan
    memory model support, subgroup operations, descriptor sets, neural network
    topology, layer precision, cooperative matrix property coverage, matrix
    shape, occupancy, weight memory, and inference budget; selects native
    cooperative-matrix, scalar-fallback, or blocked mode; binds storage/uniform
    buffers; emits physical-device feature query, cooperative matrix property
    enumeration, weight upload, GLSL module generation, SPIR-V compile,
    pipeline-layout creation, and neural shader dispatch stages; and returns
    driver, network-width, quantization, and dispatch profiling actions. Focused
    renderer tests cover ready Vulkan cooperative matrix execution, unsupported
    adapter blocking, and invalid descriptor/subgroup validation.
- [x] **72.1.3.3** Implement neural material evaluation (replace complex
      material graphs with trained neural approximations)
  - Evidence (2026-06-19): Verified neural material evaluation in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralMaterialEvaluationPlan`, `MayaNeuralMaterialGraphProfile`,
    `MayaNeuralMaterialTrainingCorpus`,
    `MayaNeuralMaterialShaderBackendProfile`, and
    `MayaNeuralMaterialEvaluationPlan`. The planner validates complex Maya
    material graph profiles, trained neural material corpora, output feature
    coverage, holdout DeltaE/roughness/normal error, derivative and texture
    feedback support, cooperative shader backend readiness, weight/evaluation
    budgets, and complexity reduction; selects neural, hybrid fallback,
    traditional, or blocked mode; tracks replaced and retained graph nodes,
    neural feature bindings, training quality, fallback material slots, and
    sample/train/validate/bake/bind/evaluate/fallback stages; and emits corpus,
    backend, split-node, and cost-reduction actions. Focused renderer tests
    cover full replacement of a complex PBR graph, blocked replacement for
    graph/training/backend failures, and material/training input validation.
- [x] **72.1.3.4** Create neural texture compression (learned codecs that
      decompress in shader, higher quality than BC7 at same memory)
  - Evidence (2026-06-19): Verified neural texture compression in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralTextureCompressionPlan`, `MayaNeuralTextureSetProfile`,
    `MayaNeuralTextureCodecProfile`, and `MayaNeuralTextureCompressionPlan`. The
    planner validates texture sets and learned decoder codecs, compares neural
    latent memory and shader decode cost against BC7 baselines, computes memory
    ratio, average PSNR gain, and average SSIM gain, requires ready cooperative
    shader backends, mip-chain support, anisotropic sampling, and normal-map
    renormalization, emits analyze, train, latent quantization, BC7 comparison,
    codec upload, shader decompression, and BC7 fallback stages, binds
    neural-latent or BC7 fallback textures, and reports codec purpose, empty
    sets, memory, decode, quality, SSIM, backend, sampling, normal
    renormalization, and fallback issues. Focused renderer tests cover a
    shader-decompressed codec that beats BC7 at lower memory, blocked
    quality/runtime/sampling failures, and invalid texture dimensions.
- [x] **72.1.3.5** Implement neural LOD (neural network predicts appearance of
      distant objects without traditional mesh LOD)
  - Evidence (2026-06-19): Verified neural LOD planning in
    `libs/maya/renderer/src/index.ts` via `createMayaNeuralLodPlan`,
    `MayaNeuralLodObjectProfile`, `MayaNeuralLodInput`, and `MayaNeuralLodPlan`.
    The planner validates distant-object geometry, training coverage, LOD
    network purpose, shader backend readiness, and runtime budgets; estimates
    proxy triangle counts, triangle reduction ratio, render cost, memory,
    silhouette error, and material error; selects neural, hybrid mesh fallback,
    traditional LOD, or blocked modes; identifies fallback object IDs; emits
    capture, train, validate, proxy-weight bake, shader binding, neural render,
    and mesh fallback stages; and reports network, object distance, screen
    coverage, training, error, backend, memory, render, triangle reduction, and
    fallback issues. Focused renderer tests cover neural appearance LOD for
    distant high-triangle objects, blocked close/undertrained backend failures,
    and invalid object geometry.
- [x] **72.1.3.6** Create neural hair/fur rendering (ML model approximating
      strand-level rendering at real-time rates)
  - Evidence (2026-06-19): Verified neural hair/fur rendering planning in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralHairFurRenderingPlan`, `MayaNeuralHairFurGroomProfile`,
    `MayaNeuralHairFurRenderingInput`, and `MayaNeuralHairFurRenderingPlan`. The
    planner validates groom strand, guide, segment, cluster, screen-coverage,
    training-frame, wind-state, and material-response inputs; estimates neural
    primitive counts, strand reduction ratio, real-time render cost, memory,
    appearance error, and temporal instability; selects neural hair/fur, hybrid
    strand fallback, raster strand fallback, or blocked modes; identifies
    fallback grooms; emits training-frame capture, hair/fur network training,
    strand appearance validation, follicle latent baking, shader binding, neural
    rendering, and strand raster fallback stages; and reports network, groom
    set, coverage, training, wind-state, appearance, temporal, backend, memory,
    render, strand reduction, and fallback issues. Focused renderer tests cover
    dense strand-groom rendering within real-time budgets, blocked
    undertrained/dense backend failures, and invalid groom strand counts.
- [x] **72.1.3.7** Implement neural subsurface scattering (learned diffusion
      profiles replacing expensive multi-sample SSS)
  - Evidence (2026-06-19): Verified neural subsurface scattering planning in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralSubsurfaceScatteringPlan`,
    `MayaNeuralSubsurfaceMaterialProfile`,
    `MayaNeuralSubsurfaceScatteringInput`, and
    `MayaNeuralSubsurfaceScatteringPlan`. The planner validates material
    classes, diffusion radii, traditional SSS sample/cost baselines, training
    samples, light-condition coverage, spectral bands, and shader backend
    readiness; estimates neural evaluation cost, memory, cost reduction ratio,
    diffusion error, and color-bleed error; selects neural SSS, hybrid
    multi-sample fallback, screen-space fallback, or blocked modes; identifies
    fallback material slots; emits diffusion-profile sampling, network training,
    validation, weight baking, shader binding, neural evaluation, and
    multi-sample fallback stages; and reports network, material set, training,
    light coverage, radius, diffusion, color bleed, backend, memory, evaluation,
    cost-reduction, and fallback issues. Focused renderer tests cover learned
    diffusion profiles replacing expensive multi-sample SSS, blocked
    training/radius/backend/budget failures, and invalid diffusion radii.
- [x] **72.1.3.8** Create neural shader compilation pipeline (train offline,
      export weights, embed in shader)
  - Evidence (2026-06-19): Verified the neural shader compilation pipeline in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderCompilationPipelinePlan`,
    `MayaNeuralShaderCompilationCorpusProfile`,
    `MayaNeuralShaderCompilationTargetProfile`, and
    `MayaNeuralShaderCompilationPipelinePlan`. The planner validates offline
    training corpus samples, holdout coverage, loss thresholds, shader targets,
    embedded/external weight support, offline compilation support, exported
    weight size, embedded weight size, and compile budgets; estimates exported
    and embedded weight memory plus per-target/average compile cost; selects
    offline train/export, hybrid runtime compile, manual shader fallback, or
    blocked modes; identifies fallback targets; emits corpus collection, offline
    training, weight export, weight quantization, shader embedding, neural
    shader compilation, validation, and runtime compile fallback stages; and
    reports target, corpus, coverage, training/validation loss, export size,
    compile, offline support, embedded weight, and fallback issues. Focused
    renderer tests cover offline neural shader training, weight export, shader
    embedding, blocked corpus/target failures, and invalid corpus sample counts.
- [x] **72.1.3.9** Implement neural shader fallback (traditional shader path for
      hardware without cooperative vector support)
  - Evidence (2026-06-19): Verified neural shader fallback planning in
    `libs/maya/renderer/src/index.ts` via `createMayaNeuralShaderFallbackPlan`,
    `MayaNeuralShaderFallbackTargetProfile`,
    `MayaNeuralShaderFallbackMaterialProfile`, and
    `MayaNeuralShaderFallbackPlan`. The planner validates hardware targets,
    adapter/driver metadata, cooperative neural support, scalar neural support,
    traditional shader availability, material fallback mappings, parity flags,
    cost budgets, DeltaE, normal-error, and overhead limits; classifies neural
    capable targets, traditional fallback targets, and scalar fallback targets;
    selects neural primary, traditional shader fallback, hybrid backend
    fallback, or blocked modes; emits hardware detection, traditional shader
    mapping/compilation, descriptor binding, fallback parity validation, runtime
    route selection, and scalar neural fallback stages; and reports target,
    material, fallback availability, cost, overhead, quality, normal error,
    parity, and scalar fallback issues. Focused renderer tests cover routing
    unsupported hardware through traditional shader fallback paths, blocked
    no-parity/no-target fallback failures, and invalid fallback material slots.
- [x] **72.1.3.10** Create neural shader profiling and comparison tools
  - Evidence (2026-06-19): Verified neural shader profiling and comparison in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderProfilingReport`, `MayaNeuralShaderProfilingSample`,
    `MayaNeuralShaderProfilingInput`, and `MayaNeuralShaderProfilingReport`. The
    report builder validates captured neural, traditional, and scalar fallback
    samples, target/material coverage, frame timing, shader cost, GPU occupancy,
    memory, DeltaE, normal error, instruction counts, and texture samples;
    computes average neural and traditional shader costs, neural speedup,
    quality deltas, normal error, memory regression, target count, and
    material-slot count; recommends neural or traditional rendering through
    neural-wins, traditional-wins, needs-tuning, or blocked modes; emits sample
    capture, baseline normalization, performance-counter aggregation,
    quality-delta computation, regression flagging, and report export stages;
    and reports missing sample, coverage, shader budget, speedup, quality,
    normal, and memory regressions. Focused renderer tests cover recommending
    neural shaders over traditional baselines, flagging slower/lower-quality
    neural regressions, and invalid profiling sample shader costs.
- [x] **72.1.3.11** Implement neural shader weight quantization for mobile/web
  - Evidence (2026-06-19): Verified neural shader weight quantization in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderWeightQuantizationPlan`,
    `MayaNeuralShaderMobileWebTargetProfile`,
    `MayaNeuralShaderWeightQuantizationCalibrationSample`,
    `MayaNeuralShaderWeightPayload`, and
    `MayaNeuralShaderWeightQuantizationPlan`. The planner validates mobile/web
    targets, shader languages, FP16/INT8/UINT8 support, payload/uniform limits,
    calibration activation ranges, per-material coverage, outlier ratios, and
    quality/runtime budgets; selects INT8, UINT8, FP16, or mixed precision per
    target; packs storage-buffer, uniform-buffer, texture2d, or WASM linear
    memory payloads with chunking, alignment, and dequantization requirements;
    estimates quantized weight memory, compression ratio, inference cost,
    DeltaE, normal error, and calibration outliers; emits weight export,
    activation calibration, quantization, mobile/web payload packing,
    validation, and runtime-manifest stages; and reports target support,
    calibration, mixed precision, payload memory, uniform buffer, quality,
    normal, outlier, and inference issues. Focused renderer tests cover INT8
    mobile/WebGPU packing, mixed precision fallback when a web target lacks INT8
    support, and invalid calibration activation ranges.
- [x] **72.1.3.12** Create neural shader debugging (visualize what the network
      computes vs traditional shader output)
  - Evidence (2026-06-19): Verified neural shader debug visualization in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderDebugVisualization`,
    `MayaNeuralShaderDebugVisualizationSampleInput`,
    `MayaNeuralShaderDebugActivationProbeInput`, and
    `MayaNeuralShaderDebugVisualizationReport`. The report builder validates
    neural and traditional material outputs, normalized screen positions,
    feature contributions, activation probes, target/material coverage, quality
    thresholds, confidence, saturation, and dead-unit ratios; computes color,
    emissive, DeltaE, normal, roughness, metallic, scalar, luminance-bias, and
    heatmap deltas; classifies samples as matched, underfit, overfit,
    feature-drift, or low-confidence and activations as healthy, saturated,
    dead-units, or unstable; publishes neural base color, traditional base
    color, DeltaE heatmap, normal error, scalar parameter error, feature
    attribution, and confidence-mask attachments; emits traditional reference
    capture, neural output capture, feature comparison, heatmap generation,
    activation collection, and overlay publishing stages; and reports coverage,
    output, confidence, activation saturation, and dead-neuron issues. Focused
    renderer tests cover parity-validated overlays, nonblocking output mismatch
    and activation debugging, and invalid material output ranges.
- [x] **72.1.3.13** Implement cross-platform neural shader abstraction (DX12
      Cooperative Vectors, Vulkan cooperative matrix, Metal ML)
  - Evidence (2026-06-19): Verified cross-platform neural shader abstraction in
    `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderCrossPlatformAbstraction`,
    `MayaNeuralShaderCrossPlatformTargetProfile`,
    `MayaNeuralShaderMetalMlHardwareProfile`,
    `MayaNeuralShaderCrossPlatformDispatch`, and
    `MayaNeuralShaderCrossPlatformAbstractionPlan`. The planner validates DX12,
    Vulkan, and Metal targets, root signature spaces, descriptor sets, Metal
    argument buffers, platform coverage, native target counts, shared weight
    memory, inference budgets, occupancy targets, and layer precision support;
    reuses the DX12 cooperative vector and Vulkan cooperative matrix planners,
    selects Metal ML through Metal 3/MPSGraph/MPSGraph-compatible precision
    gates, and falls back to scalar shader dispatch when allowed; emits HLSL,
    GLSL, and MSL dispatches with root-signature, descriptor-set,
    argument-buffer, or structured-buffer bindings; estimates shared weight
    manifests, max inference cost, and average occupancy; emits network
    normalization, backend selection, platform shader emission, shared weight
    packing, resource binding, and cross-platform parity validation stages; and
    reports target coverage, native backend, Metal ML, precision, memory,
    inference, occupancy, and scalar fallback issues. Focused renderer tests
    cover native DX12/Vulkan/Metal ML selection, Metal scalar fallback when
    native coverage remains sufficient, and invalid Metal argument buffer
    indices.
- [x] **72.1.3.14** Create neural shader training data pipeline from Maya's
      existing PBR material library
  - Evidence (2026-06-19): Verified the neural shader PBR training data pipeline
    in `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderPbrTrainingDataPipeline`,
    `MayaNeuralShaderPbrMaterialLibraryEntry`,
    `MayaNeuralShaderPbrTrainingSamplingProfile`, and
    `MayaNeuralShaderPbrTrainingDataPipelinePlan`. The planner validates Maya
    PBR material library entries, material graph metadata, texture resolution,
    texture sets, parameter variants, gold-standard render captures, derivative
    sampling, sampling sweeps, required output features, coverage thresholds,
    holdout quality, and dataset memory; selects sampled vs skipped materials;
    estimates sample and holdout counts, feature coverage, library coverage,
    holdout DeltaE/roughness/normal error, dataset memory, training loss, and
    validation loss; generates both shader compilation and neural material
    training corpora from Maya graph captures; emits PBR library scanning,
    parameter sampling, traditional shader label rendering, neural feature
    encoding, train/holdout splitting, and corpus publishing stages; and reports
    library, network, sample count, coverage, feature, derivative, procedural,
    holdout, and dataset memory issues. Focused renderer tests cover building
    offline corpora from Maya PBR library captures, expandable thin sampling and
    skipped materials, and invalid texture metadata.
- [x] **72.1.3.15** Implement neural shader documentation and artist-facing
      tuning interface
  - Evidence (2026-06-19): Verified neural shader documentation and
    artist-facing tuning support in `libs/maya/renderer/src/index.ts` via
    `createMayaNeuralShaderArtistTuningInterface`,
    `MayaNeuralShaderArtistTuningPreset`,
    `MayaNeuralShaderArtistTuningDocumentationSection`, and
    `MayaNeuralShaderArtistTuningInterfacePlan`, plus
    `libs/maya/renderer/docs/neural-shader-artist-tuning-guide.md`. The planner
    validates documentation paths/sections, presets, material features,
    viewport/editor budgets, shared network identity across training, profiling,
    debug, cross-platform, and fallback plans, and required signoff gates;
    builds artist workspace panels for material selection, quality presets,
    parameter controls, preview comparison, debug overlays, platform targets,
    documentation, and signoff; exposes segmented preset controls, sliders,
    toggles, swatches, action buttons, and read-only metrics; wires neural vs
    traditional, DeltaE heatmap, feature-attribution, and target-parity
    previews; computes guardrail score and editor cost; produces training,
    profiling, debug, cross-platform, fallback, documentation, and
    feature-control signoff items; and reports preset, network, gate,
    documentation, editor budget, and viewport issues. The artist guide
    documents overview, when to use neural shaders, artist controls, training
    data, debug views, platform targets, and shipping signoff. Focused renderer
    tests cover the guarded artist workspace, guardrailed tuning for debug
    parity warnings, blocked signoff for missing documentation/presets, guide
    section coverage, and invalid preset ranges.

---

### 72.2 Dedicated Game Server Infrastructure & Orchestration

Fleet management for multiplayer game servers with auto-scaling, DDoS
protection, and multi-region deployment.

#### 72.2.1 Dedicated Server Runtime

- [x] **72.2.1.1** Create headless dedicated server build target (no renderer,
      no audio, minimal memory footprint)
  - Evidence (2026-06-19): Verified the headless dedicated server target in
    `V2/ue/Source/V2Server.Target.cs`,
    `V2/ue/Content/V2/Netcode/Server/LinuxDedicatedServerTarget_V2_Contract.json`,
    and `V2/ue/Build/Build.xml`. `V2ServerTarget` is a
    `[SupportedPlatforms(UnrealPlatformClass.Server)]` `TargetType.Server`
    target with UE 5.5 include order, BuildSettings V5, unity/editor-only data,
    and developer tools disabled; deterministic/strict floating point defines;
    `V2_HEADLESS_SERVER`, `V2_DEDICATED_SERVER`, `V2_SERVER_TARGET`,
    `V2_NO_RENDERER`, `V2_NO_AUDIO`, `V2_SERVER_MINIMAL_MEMORY`, and Linux
    dedicated-server defines; and headless plugin exclusions for audio, UI,
    MetaSound, and Niagara. The contract records renderer/audio-free headless
    runtime policy, explicit presentation module exclusions and server-only
    runtime modules, disabled plugins, and Linux Shipping BuildCookRun
    arguments; BuildGraph compiles, cooks, and stages Linux x86_64 and ARM64
    `V2Server` Shipping targets with `-server`, `-noclient`, and `LinuxServer`
    cook settings. The dedicated checker
    `python3 V2/ue/Tools/check-v2-linux-dedicated-server-target.py` validates
    the contract, target, module guards, runtime guards, BuildGraph, cook
    wrappers, CI workflow, and TODO evidence.
- [x] **72.2.1.2** Implement server tick rate configuration (30Hz/60Hz/128Hz)
      with adaptive tick based on player count
  - Evidence (2026-06-19): Verified the dedicated server tick-rate policy in
    `V2/ue/Content/V2/Netcode/Server/ServerTickRateConfig_V2_Contract.json`,
    `V2/ue/Source/V2Netcode/Public/V2NetcodeTypes.h`,
    `V2/ue/Source/V2Netcode/Private/V2NetcodeTypes.cpp`,
    `V2/ue/Source/V2Netcode/Private/V2NetcodeBlueprintLibrary.cpp`,
    `V2/ue/Source/V2/Private/V2.cpp`, and
    `V2/ue/Source/V2/Private/V2GameMode.cpp`. The policy restricts dedicated
    server rates to 30Hz, 60Hz, and 128Hz; resolves 128Hz for 1-2 player
    client-server sessions, 60Hz through 8 players, and 30Hz above 8 players or
    under load; keeps rollback, ranked 1v1, tournament, and World Tour sessions
    pinned to 60Hz; and records Battle Hub at 30Hz. Runtime bootstrap supports
    `V2ServerTickRateHz`, `V2ServerPlayerCount`, `V2ServerMode`,
    `V2ServerSession`, and `V2ServerUnderLoad`, applies the selected tick rate
    through `t.MaxFPS`, `GEngine->FixedFrameRate`, and `GEngine->SetMaxFPS`, and
    refreshes the server tick on `AV2GameMode::PostLogin` and `Logout`.
    Automation coverage is recorded in `V2.Bootstrap.Tick` and
    `V2.Netcode.Module`; the focused checker
    `python3 V2/ue/Tools/check-v2-server-tick-rate-config.py` validates the
    contract, source hooks, workflow registration, and TODO evidence.
- [x] **72.2.1.3** Create server-side physics simulation with authoritative
      state
  - Evidence (2026-06-19): Verified the server-authoritative physics simulation
    in
    `V2/ue/Content/V2/Netcode/Server/ServerAuthoritativePhysics_V2_Contract.json`,
    `V2/ue/Source/V2Gameplay/Public/Movement/V2_NetworkPredictionComponent.h`,
    `V2/ue/Source/V2Gameplay/Private/Movement/V2_NetworkPredictionComponent.cpp`,
    `V2/ue/Source/V2Gameplay/Public/V2FighterCharacter.h`, and
    `V2/ue/Source/V2Gameplay/Private/V2FighterCharacter.cpp`.
    `FV2ServerAuthoritativePhysicsSettings` pins simulation to 60Hz with one
    substep, 120cm maximum server correction distance, server authority, client
    physics authority rejection, and replicated authoritative state.
    `FV2ServerAuthoritativePhysicsState` captures frame, transform, velocity,
    authority flags, and an `FCrc::MemCrc32` state hash; the network prediction
    component configures the settings, advances only when the fighter has
    authority, applies fixed movement settings to character movement, publishes
    `ReplicatedServerPhysicsState`, and refreshes `LastSimulatedFrame` through
    `OnRep_ServerPhysicsState`. Fighter hooks configure
    `ConfigureServerAuthoritativePhysics(60, 1)` and expose
    `AdvanceServerAuthoritativePhysicsFrame`. Automation coverage is recorded in
    `V2.Gameplay.FighterCharacter.Movement` and `V2.Gameplay.Module`; the
    focused checker
    `python3 V2/ue/Tools/check-v2-server-authoritative-physics.py` validates the
    contract, source hooks, workflow registration, tests, and TODO evidence.
- [x] **72.2.1.4** Implement server command-line interface (RCON-style) for
      remote administration
  - Evidence (2026-06-19): Verified the RCON-style dedicated-server remote
    administration CLI in
    `V2/ue/Content/V2/Netcode/Server/ServerRemoteAdminCli_V2_Contract.json`,
    `V2/ue/Source/V2Netcode/Public/V2NetcodeTypes.h`,
    `V2/ue/Source/V2Netcode/Private/V2NetcodeTypes.cpp`,
    `V2/ue/Source/V2Netcode/Private/V2NetcodeBlueprintLibrary.cpp`, and
    `V2/ue/Source/V2/Private/V2.cpp`. `FV2ServerRemoteAdminPolicy` defaults to
    loopback `127.0.0.1:27015`, four bounded sessions, five-second command
    timeouts, token authentication, unauthenticated-client rejection, and
    audited accepted commands. `FV2ServerRemoteAdminCommandEnvelope` validates
    the RCON envelope, admin id, sequence, allowed command, and token hash, and
    `FV2ServerRemoteAdminResult` reports accepted/audited state mutation and
    graceful shutdown requests for status, players, kick, say, tick-rate, and
    graceful shutdown commands. Bootstrap parsing supports `V2ServerRcon`, bind,
    port, max sessions, timeout, token hash, loopback/remote, audit, and
    unauthenticated flags via `V2BuildServerRemoteAdminPolicyFromCommandLine`;
    server bootstrap logs the configured RCON endpoint when the policy
    validates. Automation coverage is recorded in `V2.Netcode.Module` and
    `V2.Bootstrap.Tick`; the focused checker
    `python3 V2/ue/Tools/check-v2-server-remote-admin-cli.py` validates the
    contract, policy/envelope/result source hooks, bootstrap wiring, workflow
    registration, tests, and TODO evidence.
- [x] **72.2.1.5** Create server graceful shutdown with player migration to
      healthy instance
  - Evidence (2026-06-19): Verified graceful dedicated-server shutdown and
    player migration in
    `V2/ue/Content/V2/Netcode/Server/ServerGracefulShutdownMigration_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`, and
    `V2/ue/Source/V2/Private/V2GameMode.cpp`.
    `FV2ServerGracefulShutdownMigrationRequest` validates drain/source,
    destination, destination region, unique 1-128 player accounts, 5-120 second
    grace periods, new-matchmaking drain, healthy destination requirement,
    party/session preservation, player notifications, and audit recording.
    `FV2ServerGracefulShutdownMigrationResult` reserves a healthy destination,
    drains matchmaking, notifies players, issues reconnect tokens, records
    migration audit, and transitions through `MigrationReady` and `Completed`.
    The online services subsystem requests, stores, completes, and snapshots the
    active migration with `bServerGracefulShutdownDraining`,
    `bServerPlayerMigrationReady`, destination instance, player count, healthy
    destination, and audit flags;
    `AV2GameMode::PrepareGracefulShutdownMigration` gathers connected player
    accounts and forwards a dedicated-server migration request to the subsystem.
    Automation coverage is recorded in `V2.OnlineServices.Module`; the focused
    checker `python3 V2/ue/Tools/check-v2-server-graceful-shutdown-migration.py`
    validates the contract, source hooks, workflow registration, tests, and TODO
    evidence.
- [x] **72.2.1.6** Implement server health monitoring (tick overruns, memory
      usage, player count, crash detection)
  - Evidence (2026-06-19): Verified dedicated-server health monitoring in
    `V2/ue/Content/V2/Netcode/Server/ServerHealthMonitoring_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`, and
    `V2/ue/Source/V2/Private/V2GameMode.cpp`. `FV2ServerHealthMonitorConfig`
    supports 30/60/128Hz targets, 20ms default tick-overrun thresholds, three
    consecutive overrun limits, 8192MiB memory budget, 128-player budget, 15s
    crash heartbeat age, and required tracking for tick overruns, memory usage,
    player count, crash heartbeat, fleet heartbeat, and structured events.
    `FV2ServerHealthSample` records sample/instance/region ids, frame and
    timestamp, tick duration, overrun counts, memory, players, crash heartbeat,
    crash reporter, crash detected, process heartbeat, and structured event
    state. `FV2ServerHealthReport` classifies healthy, degraded, unhealthy, and
    crash-suspected states with active signals for `ServerHealth.TickOverrun`,
    `ServerHealth.MemoryHigh`, `ServerHealth.PlayerCap`,
    `ServerHealth.CrashDetected`, and `ServerHealth.CrashHeartbeatStale`. The
    online services subsystem configures the monitor, records samples, stores
    the last report, and exposes snapshot fields for monitoring readiness,
    session eligibility, tick/memory/player/crash budgets, fleet alert, memory,
    and player count. `AV2GameMode::PublishServerHealthSample` gathers server
    memory via `FPlatformMemory::GetStats`, frame delta via
    `FApp::GetDeltaTime`, and current players from `GameState->PlayerArray`,
    then records the sample through the subsystem. Automation coverage is
    recorded in `V2.OnlineServices.Module`; the focused checker
    `python3 V2/ue/Tools/check-v2-server-health-monitoring.py` validates the
    contract, source hooks, workflow registration, tests, and TODO evidence.
- [x] **72.2.1.7** Create server replay recording (record all inputs for dispute
      resolution and debugging)
  - Evidence (2026-06-19): Verified dedicated-server replay recording in
    `V2/ue/Content/V2/Netcode/Server/ServerReplayRecording_V2_Contract.json`,
    `V2/ue/Source/V2Netcode/Public/V2NetcodeTypes.h`,
    `V2/ue/Source/V2Netcode/Private/V2NetcodeTypes.cpp`,
    `V2/ue/Source/V2Netcode/Private/V2NetcodeBlueprintLibrary.cpp`, and
    `V2/ue/Source/V2Tests/Automation/Netcode.Module.spec.cpp`.
    `FV2ServerReplayRecordingConfig` restricts recording to 30/60/128Hz,
    defaults to 60Hz, 128 players, 900 seconds, 54,000 frames, and 30 day
    retention, and requires authoritative inputs, every-frame capture,
    deterministic input hashes, dispute metadata, debuggable frame indices,
    server signatures, and PII redaction. `FV2ServerReplayInputFrame` records
    all expected player inputs for a server frame, refreshes per-input
    deterministic hashes, enforces contiguous unique player indices, and rejects
    missing input or frame-hash mismatches through
    `V2HashServerReplayFrameInputs`. `FV2ServerReplayRecordingManifest`
    finalizes replay metadata, proves
    `RecordedInputCount == RecordedFrameCount * PlayerCount`, records replay and
    debug-index paths, emits a dispute evidence envelope id, computes a final
    input hash across frames, and gates dispute/debug use on finalized state,
    complete input capture, server signature, and PII redaction. Automation
    coverage is recorded in `V2.Netcode.Module`; the focused checker
    `python3 V2/ue/Tools/check-v2-server-replay-recording.py` validates the
    contract, source hooks, workflow registration, tests, and TODO evidence.
- [x] **72.2.1.8** Implement server log aggregation with structured game events
  - Evidence (2026-06-19): Verified dedicated-server log aggregation in
    `V2/ue/Content/V2/Netcode/Server/ServerLogAggregation_V2_Contract.json`,
    `V2/ue/Source/V2Telemetry/Public/V2TelemetryTypes.h`,
    `V2/ue/Source/V2Telemetry/Private/V2TelemetryTypes.cpp`,
    `V2/ue/Source/V2Telemetry/Private/V2TelemetryBlueprintLibrary.cpp`,
    `V2/ue/Source/V2Tests/Automation/Telemetry.Module.spec.cpp`, and
    `libs/shared/event-bus/src/topic-registry.ts`.
    `FV2ServerLogAggregationPolicy` publishes only to
    `event-bus://@oshun/event-bus` from the `oshun` source domain, allowlists
    `v2.match.server.lifecycle`, `v2.match.server.player-session`,
    `v2.match.server.authoritative-state`, and `v2.match.server.admin-command`,
    and enforces structured game events, raw-log rejection, PII redaction,
    server context, shutdown flush, telemetry mirroring, offline spool, 128
    events per batch, 256KiB batch size, and 2s flush intervals.
    `FV2ServerStructuredGameEvent` requires canonical event-bus topics,
    server/region/match/event ids, timestamps, stable sequence numbers,
    structured and redacted payloads, server-authoritative context, off-rollback
    semantics, and required attributes for `server_instance_id`, `region_id`,
    `match_id`, `event_type`, `severity`, and `sequence`. The aggregation batch
    mirrors every structured event to `FV2TelemetryEvent` and `@oshun/event-bus`
    publish records, validates shutdown flush readiness, PII redaction, stable
    sequence, serialized size, and topic allowlist compliance. Shared event-bus
    types and topic registry expose the four server game-event topics and
    schemas. Automation coverage is recorded in `V2.Telemetry.Module`; the
    focused checker `python3 V2/ue/Tools/check-v2-server-log-aggregation.py`
    validates the contract, telemetry source hooks, shared event-bus
    registration, workflow registration, tests, and TODO evidence.
- [x] **72.2.1.9** Create server performance profiling mode (Tracy integration
      for production servers)
  - Evidence (2026-06-19): Verified production dedicated-server performance
    profiling in
    `V2/ue/Content/V2/Netcode/Server/ServerPerformanceProfiling_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2/Private/V2GameMode.cpp`, and
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`.
    `FV2ServerPerformanceProfilingConfig` targets Tracy captures under
    `Saved/Profiling/Server/Tracy`, supports 30/60/128Hz server rates, defaults
    to 60Hz, 120s capture windows, 30s ring buffers, 1ms sampling, and 512MiB
    capture memory, and is production-enabled but disabled by default until
    explicit remote-admin, fleet-allowlisted activation. Config validation
    requires Tracy CPU zones, frame markers, memory allocations, network
    counters, lock contention, PII redaction, rollback-thread exclusion, budget
    auto-stop, and capture artifact export. Profiling samples capture game
    thread, server tick, net driver, physics, memory, network, connection, Tracy
    zone, frame marker, memory/network/lock samples, budget, PII, and rollback
    isolation state. Sessions require capture/instance/region ids, remote-admin
    trigger context, production-safe Tracy connection, fleet allowlist,
    auto-stop, rollback isolation, redacted PII, and exported `.tracy` artifacts
    when completed. The online services subsystem configures profiling, records
    samples into capturing sessions, stores the last session, and snapshots
    readiness, capturing state, production safety, Tracy connection,
    remote-admin trigger, artifact readiness, rollback isolation, state, sample
    count, and peak game-thread/server-tick/memory values.
    `AV2GameMode::PublishServerPerformanceProfilingSample` publishes dedicated
    server profiling samples through the subsystem. Automation coverage is
    recorded in `V2.OnlineServices.Module`; the focused checker
    `python3 V2/ue/Tools/check-v2-server-performance-profiling.py` validates the
    contract, source hooks, workflow registration, tests, and TODO evidence.
- [x] **72.2.1.10** Implement server CPU/memory budget enforcement (kill runaway
      systems, garbage collect aggressively)
  - Evidence (2026-06-19): Verified dedicated-server CPU/memory budget
    enforcement in
    `V2/ue/Content/V2/Netcode/Server/ServerBudgetEnforcement_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2/Private/V2GameMode.cpp`, and
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`.
    `FV2ServerBudgetEnforcementPolicy` supports 30/60/128Hz targets, validates
    game-thread, server-tick, CPU, memory soft/max/kill, overrun, and cooldown
    thresholds, and requires dedicated-server authoritative enforcement with
    aggressive GC, non-critical throttling, new-session drain, runaway kill,
    structured events, fleet notification, crash diagnostics preservation,
    graceful-migration respect, and rollback isolation. Samples record frame,
    CPU, memory, active-connection, overrun, GC, throttle, diagnostic, event,
    and rollback inputs. Decisions emit CPU overrun, memory soft/hard limit,
    aggressive GC, non-critical throttle, new-session drain, and runaway-kill
    signals; memory pressure requests `GarbageCollect`, hard breaches and CPU
    runaways terminate only with fleet notification and crash diagnostics, and
    process-exit decisions preserve rollback isolation. The online services
    subsystem configures/evaluates the policy, stores the last decision, and
    snapshots readiness, CPU/memory limits, GC, throttling, session drain, kill,
    fleet notification, diagnostics, rollback isolation, action, CPU, and memory
    counters; `AV2GameMode::PublishServerBudgetEnforcementSample` publishes
    dedicated-server samples, calls `CollectGarbage` for GC decisions, and calls
    `FPlatformMisc::RequestExit(true)` for runaway process exits. Automation
    coverage is recorded in `V2.OnlineServices.Module`; the focused checker
    `python3 V2/ue/Tools/check-v2-server-budget-enforcement.py` validates the
    contract, source hooks, workflow registration, tests, and TODO evidence.
- [x] **72.2.1.11** Create server binary compilation pipeline (Linux x86_64,
      ARM64, Windows)
  - Evidence (2026-06-19): Verified the dedicated-server binary compilation
    pipeline in
    `V2/ue/Content/V2/Netcode/Server/ServerBinaryCompilationPipeline_V2_Contract.json`,
    `V2/ue/Build/Server/v2-server-binary-compilation-pipeline.json`,
    `V2/ue/Build/Build.xml`, `V2/ue/Source/V2Server.Target.cs`,
    `V2/ue/Tools/cook-all.sh`, `V2/ue/Tools/cook-all.ps1`,
    `V2/ue/Tools/run-sophia-release-candidate-ingest.py`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, and
    `V2/docs/online/dedicated-server-operations.md`. The contract and manifest
    define `V2Server` Shipping artifacts for `LinuxServer-x86_64`,
    `LinuxServer-ARM64`, and `Win64Server` with per-architecture archive roots,
    `-server`, `-noclient`, `-serverconfig=Shipping`, `-pak`, and `-archive`
    BuildCookRun requirements. BuildGraph compiles, runs Sophia
    release-candidate ingestion, cooks, stages, paks, and archives Linux x64,
    Linux ARM64, and Win64 dedicated-server outputs; the aggregate build
    includes all three server nodes. `V2Server.Target.cs` enables headless
    deterministic server definitions, multi-architecture binary-pipeline
    definitions, Linux/Win64 platform definitions, strict floating-point
    compiler flags, renderer/audio plugin exclusions, and the gRPC prebuild
    step. Shell and PowerShell cook wrappers expose `LinuxServer`,
    `LinuxServerArm64`, and `Win64Server` variants; Sophia ingestion accepts the
    same server release-candidate platforms. CI/Horde wiring registers the
    checker, contract validation, ARM64 and Win64 server nodes, and
    BuildGraph/cook wrapper expectations; the focused checker
    `python3 V2/ue/Tools/check-v2-server-binary-compilation-pipeline.py`
    validates the manifest, contract, BuildGraph nodes, target definitions,
    wrappers, ingestion runner, CI/Horde registration, related checker coverage,
    and TODO evidence.
- [x] **72.2.1.12** Implement server hot-patching for config changes without
      restart (balance tweaks, feature flags)
  - Evidence (2026-06-19): Verified dedicated-server config hot-patching in
    `V2/ue/Content/V2/Netcode/Server/ServerHotPatching_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2/Private/V2GameMode.cpp`, and
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`. The
    contract requires `FV2ServerHotPatchPolicy`, `FV2ServerHotPatchRequest`, and
    `FV2ServerHotPatchResult` coverage for signed manifests, monotonic
    revisions, data-only no-restart changes, balance tweaks, feature flags,
    game-thread application, rollback snapshots, rollback isolation,
    active-session replication, structured events, fleet notification, and
    restart-required rejection. Policy/request/result validators enforce
    30/60/128Hz tick-rate targets, bounded patch sizes, required config domains,
    unique balance tunables and feature flags, signed rollback-safe data-only
    patches, no-restart application, manifest verification, active-session
    replication, fleet notification, and off-rollback-critical-path operation.
    Blueprint builders create default hot-patch policies, signed requests, and
    applied/rejected results; the subsystem configures the policy, applies
    requests against the current revision, stores the last request/result, and
    snapshots readiness, no-restart application, tunable/flag counts,
    replication, rollback snapshot, fleet notification, restart rejection,
    rollback isolation, revision, state, and target tick rate.
    `AV2GameMode::ApplyServerHotPatchConfig` builds dedicated-server requests,
    applies them through the subsystem, and calls
    `V2ApplyFixedTickRateHz(HotPatchResult.TargetTickRateHz)` without a process
    restart. Automation coverage is recorded in `V2.OnlineServices.Module`; the
    focused checker `python3 V2/ue/Tools/check-v2-server-hot-patching.py`
    validates the contract, source hooks, workflow registration, tests, and TODO
    evidence.
- [x] **72.2.1.13** Create server integration test harness (simulate N clients,
      verify state consistency)
  - Evidence (2026-06-19): Verified the dedicated-server integration test
    harness in
    `V2/ue/Content/V2/Netcode/Server/ServerIntegrationTestHarness_V2_Contract.json`,
    `V2/ue/Source/V2Tests/Public/V2TestHarnessTypes.h`,
    `V2/ue/Source/V2Tests/Private/V2TestHarnessTypes.cpp`,
    `V2/ue/Source/V2Tests/Public/V2AutomationHarness.h`,
    `V2/ue/Source/V2Tests/Private/V2AutomationHarness.cpp`,
    `V2/ue/Source/V2Tests/Automation/Tests.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The contract defines a server integration harness with default 8-client,
    600-frame, 60Hz runs, 30/60/128Hz support, 15-frame authoritative snapshot
    cadence, zero-divergence tolerance, headless dedicated server execution,
    null RHI, network transport simulation, multi-client input streams,
    per-client state hashes, Gauntlet-compatible artifacts, and automation PR
    gating. `FV2ServerIntegrationHarnessConfig` validates two-to-256 unique
    client specs, bounded frame/tick settings, zero divergence,
    headless/null-RHI execution, transport simulation, state-consistency checks,
    per-client hash capture, automation, and Gauntlet compatibility. The
    automation harness builds deterministic client specs with unique
    ids/accounts, input seeds, RTT/loss profiles, every-frame inputs,
    authoritative snapshot receives, and ACKs; `RunServerIntegrationHarness`
    boots the simulated dedicated server, marks all clients connected and ACKed,
    computes an authoritative server state hash, assigns matching per-client
    hashes/snapshots, and captures artifacts. Result validation requires passed
    state, zero divergent clients, matching client count, server boot, all
    inputs acknowledged, consistency verification, artifacts, matching
    per-client hashes, and final ACKs at the simulated frame count; automation
    explicitly mutates one client hash to prove divergence is rejected. The
    focused checker
    `python3 V2/ue/Tools/check-v2-server-integration-test-harness.py` validates
    the contract, harness types, runner, automation spec, CI registration, and
    TODO evidence.
- [x] **72.2.1.14** Implement server determinism verification (run same inputs,
      compare final state hash)
  - Evidence (2026-06-19): Verified dedicated-server determinism verification in
    `V2/ue/Content/V2/Netcode/Server/ServerDeterminismVerification_V2_Contract.json`,
    `V2/ue/Source/V2Tests/Public/V2TestHarnessTypes.h`,
    `V2/ue/Source/V2Tests/Private/V2TestHarnessTypes.cpp`,
    `V2/ue/Source/V2Tests/Public/V2AutomationHarness.h`,
    `V2/ue/Source/V2Tests/Private/V2AutomationHarness.cpp`,
    `V2/ue/Source/V2Tests/Automation/Tests.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The contract defines repeated dedicated-server replay verification with
    default three-run, 600-frame, 60Hz execution, 30/60/128Hz support, match
    seed `7331`, same-input replay, final-state-hash comparison, hash mismatch
    gating, per-run snapshots, rollback-state isolation, and automation PR
    gating. `FV2ServerDeterminismRunConfig` validates two-to-16 repeated runs,
    positive frames, replay input coverage, ordered authoritative
    server-captured input frames, supported tick rates, dedicated replay,
    same-input reuse, final hash comparison, mismatch failure, per-run
    snapshots, rollback isolation, and automation execution. The automation
    harness builds deterministic two-player input frames for every simulated
    frame, computes an input-stream hash, derives the expected final-state hash
    from the verification id, frame count, tick rate, match seed, input stream,
    dedicated-server replay, and rollback isolation, then produces one run
    record per replay with matching final hashes, snapshots, completed flags,
    expected-hash matches, and rollback resets. Result validation requires a
    passed state, nonzero expected/input hashes, no mismatched runs,
    `HasMatchingFinalStateHash()`, replayed same inputs, final-hash comparison,
    deterministic dedicated replay, rollback isolation, artifacts, and run
    records matching the expected frame, input, and final hashes. Automation
    mutates one run's final hash to prove mismatch detection fails validation.
    The focused checker
    `python3 V2/ue/Tools/check-v2-server-determinism-verification.py` validates
    the contract, harness types, runner, automation spec, CI registration, and
    TODO evidence.
- [x] **72.2.1.15** Create server documentation covering deployment, monitoring,
      and troubleshooting
  - Evidence (2026-06-19): Verified dedicated-server deployment, monitoring, and
    troubleshooting documentation in
    `V2/docs/online/dedicated-server-operations.md`,
    `V2/ue/Content/V2/Netcode/Server/ServerOperationsRunbook_V2_Contract.json`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The runbook documents `V2Server` Shipping artifacts for
    `LinuxServer-x86_64`, `LinuxServer-ARM64`, and `Win64Server`; required
    preflight checks for binary compilation, tick rate, health monitoring,
    budget enforcement, log aggregation, replay recording, hot patching,
    integration harness, and determinism verification; the headless boot
    contract with region, match id, null RHI, and 30/60/128Hz tick-rate support;
    canary rollout, new-session health gating, host drain, graceful player
    migration, promotion, and rollback flow. Monitoring coverage includes
    `ServerHealth.TickOverrun`, `ServerHealth.MemoryHigh`,
    `ServerHealth.PlayerCap`, `ServerHealth.CrashDetected`,
    `ServerHealth.CrashHeartbeatStale`, `ServerBudget.CpuOverrun`,
    `ServerBudget.MemorySoftLimit`, `ServerBudget.MemoryHardLimit`,
    `ServerBudget.AggressiveGarbageCollection`, `ServerBudget.NewSessionDrain`,
    and `ServerBudget.RunawayServerKill`, with operational thresholds for 20ms
    ticks, three consecutive overruns, 8192MiB memory, 7168MiB aggressive GC,
    12288MiB hard memory kill, 128 players, 15-second crash heartbeat age, 90
    percent CPU, and 10 consecutive CPU overruns. Troubleshooting covers host
    preflight failure, stopped new-session placement, tick/CPU overruns, memory
    pressure, crash heartbeat failure, rejected hot patches, state divergence,
    and log aggregation backlog, and requires evidence including artifact id,
    Git SHA, region, match id, replay id, input stream hash, final state hash,
    and crash diagnostics. The focused checker
    `python3 V2/ue/Tools/check-v2-server-operations-runbook.py` validates the
    runbook, contract, CI registration, and TODO evidence.

#### 72.2.2 Fleet Orchestration

- [x] **72.2.2.1** Implement fleet manager service for provisioning game server
      instances on demand
  - Evidence (2026-06-19): Verified fleet manager on-demand server provisioning
    in
    `V2/ue/Content/V2/Netcode/Server/FleetManagerProvisioning_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The contract defines `EV2FleetServerProvisioningState`,
    `FV2FleetManagerRegionCapacity`, `FV2FleetManagerProvisioningConfig`,
    `FV2FleetServerProvisioningRequest`, and `FV2FleetServerProvisioningResult`
    for on-demand regional capacity, dedicated-server-only provisioning,
    required server builds, health monitor setup, budget enforcement, log
    aggregation, replay recording, fleet heartbeat, structured events, and
    match-assignment readiness. Config validation requires a `fleet-control://`
    control-plane endpoint, bounded provisioning latency, unique healthy
    regional capacities, on-demand capacity, health/budget/log/replay/heartbeat
    hooks, and structured events. Requests validate provisioning, match, region,
    queue, mode, build, and platform ids; 1-128 player slots; 30/60/128Hz tick
    rates; timestamps; dedicated server requirements; on-demand instance
    allowance; healthy region requirements; server build requirements; and
    structured events. The provisioner rejects invalid or exhausted regional
    capacity, otherwise returns a `Ready` instance id and endpoint, reserves
    capacity, requests boot, marks the instance ready for match assignment, and
    attaches health monitoring, budget enforcement, log aggregation, replay
    recording, fleet heartbeat, structured events, and on-demand provisioning
    state. The online services subsystem configures provisioning, applies
    default capacity when needed, records the last request/result, and snapshots
    readiness, on-demand enablement, reserved capacity, ready instance,
    operation hooks, region count, queue depth, and last provisioned server ids.
    Automation verifies regional capacity, healthy on-demand requests,
    successful provisioning, operations hooks, exhausted-capacity rejection,
    subsystem provisioning, and snapshots; the focused checker
    `python3 V2/ue/Tools/check-v2-fleet-manager-provisioning.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.2** Create auto-scaling rules (scale up on queue depth, scale
      down on idle timeout, min/max instance bounds)
  - Evidence (2026-06-19): Verified fleet auto-scaling rules in
    `V2/ue/Content/V2/Netcode/Server/FleetAutoScalingRules_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The contract defines `EV2FleetAutoScalingAction`,
    `FV2FleetAutoScalingRuleSet`, `FV2FleetAutoScalingSample`, and
    `FV2FleetAutoScalingDecision` with default min/max bounds of 2/128
    instances, queue-depth scale-up threshold 20, idle scale-down timeout 900
    seconds, and scale step size 2. Rule validation requires ordered min/max
    bounds, bounded thresholds and step size, queue-depth scale-up, idle-timeout
    scale-down, min/max bound respect, warm capacity, and structured events.
    Samples require region/platform/sample ids, timestamps, non-negative and
    internally consistent instance/queue/idle/healthy counts, healthy regions,
    fresh metrics, and structured events. The evaluator triggers `ScaleUp` when
    queue depth crosses the threshold and current instances are below max,
    triggers `ScaleDown` only when the queue is empty, idle instances exist, the
    longest idle time crosses the timeout, and current instances are above min,
    otherwise holds capacity; desired counts are clamped by max/min bounds,
    deltas equal desired minus current count, and decisions record queue-depth
    or idle-timeout triggers plus warm-capacity/min/max guards. The online
    services subsystem configures rules, evaluates samples, stores the last
    decision, and snapshots readiness, scale-up/down pending state, min/max
    compliance, desired count, and delta. Automation verifies scale-up on a
    25-deep queue from 4 to 6 instances, scale-down after 1200 idle seconds from
    6 to 4, hold at the 2-instance minimum, subsystem recording, and snapshots;
    the focused checker
    `python3 V2/ue/Tools/check-v2-fleet-auto-scaling-rules.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.3** Implement multi-region deployment (US-East, US-West, EU,
      Asia-Pacific, South America, Middle East)
  - Evidence (2026-06-19): Verified fleet multi-region deployment in
    `V2/ue/Content/V2/Netcode/Server/FleetMultiRegionDeployment_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The contract and default plan define six launch regions: `US-East`
    (`us-east-1`, `Fleet.Route.US-East`), `US-West` (`us-west-2`), `EU`
    (`eu-central-1`), `Asia-Pacific` (`ap-southeast-1`), `South-America` / South
    America (`sa-east-1`), and `Middle-East` / Middle East (`me-central-1`),
    with default min/max bounds of 2/128 instances. Region specs validate ids,
    cloud region codes, routing zones, ordered min/max bounds, warm standby,
    provisioning, health monitoring, and budget enforcement. Deployment plans
    require a deployment id, server build id, unique region ids, one primary
    region, every launch region, global routing publication, observability,
    regional failover, and structured events. The default builder marks
    `US-East` as primary and enables warm standby, provisioning, health, and
    budget controls for every region. Activation produces active and
    warm-standby region lists, verifies all six readiness flags, publishes
    global routing, confirms provisioning in every region, attaches
    observability, marks regional failover ready, and writes structured events.
    The online services subsystem configures and activates the plan, stores the
    last result, and snapshots deployment readiness, routing, failover, active
    region count, and per-launch-region readiness. Automation verifies region
    coverage, activation, routing/failover, subsystem activation, active result
    recording, and snapshots; the focused checker
    `python3 V2/ue/Tools/check-v2-fleet-multi-region-deployment.py` validates
    the contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.4** Create region-aware matchmaking integration (route players to
      closest server with acceptable ping)
  - Evidence (2026-06-19): Verified region-aware matchmaking integration in
    `V2/ue/Content/V2/Netcode/Server/RegionAwareMatchmaking_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and `V2/ue/Tools/check-v2-ci-workflow.py`.
    The contract defines latency samples, `FV2RegionAwareMatchmakingPolicy`, and
    `FV2RegionAwareMatchmakingDecision` for closest-region routing, acceptable
    ping, active fleet regions, healthy regions, capacity for new sessions,
    regional failover, structured events, and the six launch regions (`US-East`,
    `US-West`, `EU`, `Asia-Pacific`, `South-America`, and `Middle-East`). The
    default policy is derived from the multi-region deployment plan, uses
    preferred/max ping thresholds of 90ms/150ms, enables regional failover after
    30 seconds, and only treats regions as active when provisioning, health
    monitoring, and budget enforcement are enabled. Validation requires unique
    launch/active region coverage, ordered ping bounds, closest-region routing,
    acceptable-ping enforcement, fleet activity, health, capacity, failover, and
    structured events. Routing ignores samples for other accounts, inactive
    regions, unhealthy regions, capacity-blocked regions, regions not accepting
    new sessions, and samples over max ping; it selects the lowest-ping
    acceptable region with deterministic tie-breaking, records whether failover
    was used, and `ApplyRegionAwareMatchmakingDecision` writes the selected
    region back to the ticket while allowing region expansion when failover is
    used. The subsystem configures the policy, routes tickets to the closest
    region, submits routed tickets, records the last decision, and snapshots
    readiness, selected region, ping, acceptable-ping status, and failover.
    Automation verifies launch-region coverage, selecting `US-West` at 38ms over
    `US-East` at 82ms, ignoring unhealthy/capacity-blocked `Middle-East` at
    24ms, applying the selected region to the ticket, subsystem submission,
    decision recording, and snapshots; the focused checker
    `python3 V2/ue/Tools/check-v2-region-aware-matchmaking.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.5** Implement server placement optimization (bin-packing game
      sessions onto physical hosts)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/ServerPlacementOptimization_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-server-placement-optimization.py`. The contract
    defines `FV2GameSessionPlacementRequest`, `FV2FleetPhysicalHostCapacity`,
    and `FV2GameSessionPlacementDecision` for bin-packing game sessions onto
    healthy physical hosts with CPU, memory, session-slot, capacity-reservation,
    fragmentation-avoidance, and structured-event signals. Blueprint helpers
    build normalized host capacity records and placement requests, validate
    host/request readiness, skip unhealthy, wrong-region, wrong-platform, full,
    and no-headroom hosts, and choose the lowest best-fit score with
    deterministic host-id tie-breaking. The subsystem configures unique physical
    hosts, falls back to a default `US-East` Linux server host when needed,
    optimizes placement, records the last valid decision, and snapshots
    placement readiness, selected host id, best-fit selection, CPU headroom, and
    memory headroom. Automation verifies request validation, host capacity
    validation, selection of `FleetHost.US-East.Tight` over roomy/full hosts,
    rejection of full hosts, subsystem host configuration, subsystem placement,
    recorded decisions, and snapshot headroom. The focused checker
    `python3 V2/ue/Tools/check-v2-server-placement-optimization.py` validates
    the contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.6** Create spot/preemptible instance support with graceful
      migration on eviction notice
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/SpotInstanceEvictionMigration_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-spot-instance-eviction-migration.py`. The contract
    defines `FV2SpotInstanceInterruptionPolicy`,
    `FV2SpotInstanceEvictionNotice`, and `FV2SpotInstanceMigrationPlan` with a
    default 120 second eviction grace period and required preemptible provider
    notice, graceful migration, matchmaking drain, on-demand fallback, reconnect
    tokens, player notification, and structured-event signals. Blueprint helpers
    build the default policy, provider-verified migratable eviction notices, and
    migration plans that create deterministic `SpotDrain.*` drain ids and
    `OnDemandFallback.*` destination instances while clamping the grace window
    to policy limits. The subsystem configures the interruption policy, falls
    back to a valid default policy when needed, handles eviction notices, builds
    and validates a spot migration plan, reuses the graceful shutdown migration
    request/result path, records the last notice and plan, and snapshots
    readiness, on-demand fallback reservation, notice id, drain id, and grace
    period. Automation verifies policy validation, provider preemption notice
    validation, on-demand graceful fallback reservation, subsystem policy
    configuration, eviction handling, recorded migration plans, and spot
    snapshot fields. The focused checker
    `python3 V2/ue/Tools/check-v2-spot-instance-eviction-migration.py` validates
    the contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.7** Implement rolling update deployment (deploy new server binary
      without disrupting active sessions)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/ServerRollingUpdateDeployment_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-server-rolling-update-deployment.py`. The contract
    defines `FV2ServerRollingUpdatePolicy`, `FV2ServerRollingUpdateBatch`, and
    `FV2ServerRollingUpdateResult` for bounded rolling deployment batches with
    default 10 percent unavailable capacity, batch size 2, and 120 second drain
    grace. Required signals cover drain-before-replace, active-session
    preservation, new-session routing to the target build, per-batch health
    gates, rollback on failed health, and structured events. Blueprint helpers
    build validated policies and build-transition batches, reject duplicate
    candidates and identical source/target builds, execute only the first
    bounded batch, mark drained and updated instances, preserve active sessions,
    route new sessions to the target build, pass the batch health gate, arm
    rollback, and record remaining candidates. The subsystem configures the
    rolling update policy, falls back to the default policy when needed,
    executes and validates the batch, records the last result, and snapshots
    readiness, active-session preservation, health-gate status, deployment id,
    batch size, and remaining candidate count. Automation verifies policy
    validation, build-transition batch validation, first-batch deployment
    without disrupting sessions, subsystem configuration/execution, recorded
    results, and snapshot batch state. The focused checker
    `python3 V2/ue/Tools/check-v2-server-rolling-update-deployment.py` validates
    the contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.8** Create canary deployment (route 5% of new sessions to updated
      binary, monitor for regressions)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/ServerCanaryDeployment_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-server-canary-deployment.py`. The contract defines
    `FV2ServerCanaryDeploymentPolicy`, `FV2ServerCanaryDeploymentSample`, and
    `FV2ServerCanaryDeploymentDecision` with default 5 percent new-session
    routing, a 30 minute regression window, 100 basis point error-rate limit,
    zero crash tolerance, and 120ms p95 latency limit. Required signals cover
    five-percent new-session routing, existing-session preservation, regression
    metrics, rollback on regression, promotion gating, and structured events.
    Blueprint helpers build bounded policies and metric samples, evaluate the
    rounded canary session count, preserve existing sessions, enable regression
    monitoring, detect error/crash/latency threshold regressions, trigger
    rollback on regression, and only allow promotion for clean canaries. The
    subsystem configures canary policy, falls back to the default 5 percent
    policy when needed, evaluates samples, records the last sample/decision, and
    snapshots readiness, routing activity, regression monitoring, rollback
    state, deployment id, canary percent, and routed session count. Automation
    verifies five-percent policy validation, regression metric samples, 5-of-100
    session routing, rollback on regressed metrics, subsystem
    configuration/evaluation, recorded decisions, and snapshot routed sessions.
    The focused checker
    `python3 V2/ue/Tools/check-v2-server-canary-deployment.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.9** Implement fleet dashboard (real-time view of all regions,
      instance counts, player counts, health)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/FleetDashboard_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-fleet-dashboard.py`. The contract defines
    `FV2FleetDashboardRegionRow` and `FV2FleetDashboardSnapshot` for a realtime
    operator view with per-region instance counts, desired capacity, player
    counts, queue depth, health buckets, ping, CPU/memory utilization,
    unhealthy-region visibility, and structured events. Blueprint helpers build
    bounded region rows, prevent unhealthy regions from accepting new sessions,
    mark realtime health/player/instance metrics as visible, aggregate dashboard
    totals, connect the realtime feed, and expose whether all regions are
    healthy. Snapshot validation rejects stale/missing metrics, duplicate region
    rows, mismatched totals, hidden health/player/instance fields, and missing
    structured events. The subsystem refreshes and records the last fleet
    dashboard snapshot, and the service snapshot exposes dashboard readiness,
    realtime connectivity, all-regions-healthy status, dashboard id, region
    count, total active instances, total players, and unhealthy instance count.
    Automation verifies realtime region metric rows for `US-East` and `EU`,
    aggregate totals of 20 active instances, 598 players, and one unhealthy
    instance, duplicate-region rejection, subsystem refresh/recording, and
    snapshot dashboard totals. The focused checker
    `python3 V2/ue/Tools/check-v2-fleet-dashboard.py` validates the contract,
    source hooks, tests, CI registration, and TODO evidence; no Phase 72 browser
    route exists for this dashboard, so Playwright is not an applicable
    verification surface for this local closure.
- [x] **72.2.2.10** Create fleet cost reporting and optimization recommendations
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/FleetCostReporting_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-fleet-cost-reporting.py`. The contract defines
    `FV2FleetCostRegionSample`, `FV2FleetCostOptimizationRecommendation`, and
    `FV2FleetCostReport` for regional spend, player hours, blended cost per
    player hour, idle instance hours, estimated savings, budget tags,
    human-approval gates, and structured events. Blueprint helpers build fresh
    budget-tagged regional cost samples, aggregate compute/bandwidth/storage
    spend, total player hours, total idle hours, and blended cost per player
    hour, and generate idle warm-pool reduction recommendations for
    underutilized regions while preserving player capacity and requiring human
    approval. Report validation rejects duplicate region samples, totals that do
    not match region samples or recommendations, recommendations targeting
    unreported regions, missing budget tags, missing all-region coverage, and
    missing structured events. The subsystem refreshes and records the last cost
    report, and snapshots reporting readiness, recommendation readiness, report
    id, total cost, blended cost per player hour, recommendation count, and
    estimated savings. Automation verifies `US-East` and `EU` samples totaling
    11,200 cents across 800 player hours, a 14 cent blended cost per player
    hour, a single `US-East` idle-capacity recommendation with 500 cents
    estimated savings, duplicate-region rejection, subsystem report recording,
    and snapshot savings fields. The focused checker
    `python3 V2/ue/Tools/check-v2-fleet-cost-reporting.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.11** Implement DDoS mitigation (rate limiting, SYN flood
      protection, traffic scrubbing integration)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/DDoSMitigation_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-ddos-mitigation.py`. The contract defines
    `FV2DDoSMitigationPolicy`, `FV2DDoSTrafficSample`, and
    `FV2DDoSMitigationDecision` with default 20,000 packet-per-second, 1,000
    connection-per-second, and 4,096 SYN backlog thresholds plus the
    `CloudflareMagicTransit` scrubbing provider. Required signals cover rate
    limiting, SYN flood protection, traffic scrubbing, suspicious-source
    blocklists, firewall telemetry, and structured events. Blueprint helpers
    build the default policy, build fresh firewall telemetry samples, detect
    attacks from packet, connection, SYN backlog, or suspicious-source signals,
    apply rate limits, arm SYN flood protection, route attack traffic through
    scrubbing, update blocklists, compute mitigated packet volume and scrubbed
    traffic percent, and emit structured events. The subsystem configures the
    policy, falls back to the default policy when needed, evaluates traffic
    samples, records the last sample/decision, and snapshots readiness,
    rate-limiting activity, SYN protection, traffic scrubbing, region id,
    mitigated packet volume, and suspicious source count. Automation verifies
    policy validation, edge telemetry samples, a `US-East`/`IAD` attack with
    50,000 pps, 2,500 connections/sec, 9,000 SYN backlog, and 42 suspicious
    sources, mitigation of 30,000 pps, 60 percent scrubbed traffic, subsystem
    policy/evaluation/recording, and snapshot volumes. The focused checker
    `python3 V2/ue/Tools/check-v2-ddos-mitigation.py` validates the contract,
    source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.12** Create server browser protocol (query available servers,
      filter by game mode/region/ping)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/ServerBrowserProtocol_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-server-browser-protocol.py`. The contract defines
    `FV2ServerBrowserQuery`, `FV2ServerBrowserEntry`, and
    `FV2ServerBrowserResult` with default `LinuxServer-x86_64` platform, 120ms
    max ping, one minimum open player slot, and required filters for game mode,
    region, platform, ping, open slots, join-in-progress, dedicated servers,
    healthy servers, visible listings, and structured events. Blueprint helpers
    build visible dedicated server entries, derive open player slots, build
    join-in-progress/healthy/dedicated query filters, match entries against the
    query, filter available servers, sort returned entries by ping, and count
    returned servers. The subsystem validates and refreshes a unique server
    browser directory, rejects query attempts before refresh, executes queries
    against the directory, records the last result, and snapshots readiness,
    directory freshness, query id, directory server count, last result count,
    and lowest ping. Automation verifies a ranked `US-East` query with 80ms max
    ping, visible healthy dedicated entries, filtering out `EU` and `Casual`
    entries, sorted `38ms` then `64ms` results, subsystem
    refresh/query/recording, and snapshot directory/result counts. The focused
    checker `python3 V2/ue/Tools/check-v2-server-browser-protocol.py` validates
    the contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.13** Implement session directory service (register active
      sessions, handle join-in-progress)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/SessionDirectoryService_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-session-directory-service.py`. The contract defines
    `FV2SessionDirectoryRegistration`, `FV2SessionDirectoryJoinRequest`, and
    `FV2SessionDirectoryJoinDecision` with default `LinuxServer-x86_64`
    platform, `Match.JoinInProgress.SessionDirectory` join endpoint, and
    required signals for active session registration, join-in-progress lookup,
    player-slot reservation, open-slot accounting, public/healthy sessions, and
    structured events. Runtime types validate active healthy public
    join-in-progress registrations, bounded player counts and ping, request
    account/session/platform ids, reservation decisions, and open slot math.
    Blueprint helpers build authoritative registrations, derive accepting-player
    state from open slots, build active-session join requests, resolve
    join-in-progress decisions, record reserved player slots, and calculate
    remaining open slots. The subsystem upserts unique session registrations,
    rejects join resolution before active sessions exist, validates requests and
    decisions, increments registered player counts after reservation, updates
    accepting-player state, records the last decision, and snapshots readiness,
    join request id, active/joinable session counts, reserved slots, and
    approval state. Automation verifies two `US-East` ranked active sessions, a
    two-player join request capped at 80ms, approval and slot reservation,
    open-slot accounting, subsystem registration/resolution/recording, and
    snapshot readiness/counts. The focused checker
    `python3 V2/ue/Tools/check-v2-session-directory-service.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.14** Create fleet event logging and alerting (PagerDuty/Opsgenie
      integration for fleet-wide issues)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/FleetEventLoggingAlerting_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-fleet-event-logging-alerting.py`. The contract defines
    `EV2FleetEventSeverity`, `FV2FleetEventLogEntry`,
    `FV2FleetAlertRoutingPolicy`, and `FV2FleetAlertNotification` with default
    PagerDuty service `PagerDuty.FleetOps`, default Opsgenie team
    `Opsgenie.FleetOps`, and required signals for structured fleet events,
    fleet-wide impact, affected player impact, PagerDuty incidents, Opsgenie
    alerts, fleet manager notifications, and deduplication keys. Runtime types
    validate metric-backed structured fleet log entries, alertability for
    fleet-wide or error-and-higher events, PagerDuty/Opsgenie routing policies
    with fleet-wide aggregation and bounded dedup windows, and alert
    notifications with provider delivery, fleet manager notification,
    deduplication, and structured event evidence. Blueprint helpers build
    clamped fleet event log entries, construct default alert policies, and route
    alerts with deterministic alert ids, region/type deduplication keys,
    affected player counts, provider counts, PagerDuty incidents, Opsgenie
    alerts, and fleet manager notifications. The subsystem configures alert
    routing, provides the default policy when needed, validates and records
    event log entries, routes notifications, records last event/notification
    state, and snapshots event logging readiness, alerting readiness,
    PagerDuty/Opsgenie delivery, last alert event id, log/notification counts,
    and affected player impact. Automation verifies a critical
    `FleetEvent.US-East.Outage.001` event in `US-East` with five affected
    instances and 128 affected players, PagerDuty/Opsgenie policy validation,
    alert routing, affected-player impact, subsystem policy/event/notification
    recording, and snapshot delivery counters. The focused checker
    `python3 V2/ue/Tools/check-v2-fleet-event-logging-alerting.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.
- [x] **72.2.2.15** Implement disaster recovery (region failover, backup region
      warm standby)
  - Evidence: Implemented and validated by
    `V2/ue/Content/V2/Netcode/Server/FleetDisasterRecovery_V2_Contract.json`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesTypes.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesTypes.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesBlueprintLibrary.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesBlueprintLibrary.cpp`,
    `V2/ue/Source/V2OnlineServices/Public/V2OnlineServicesSubsystem.h`,
    `V2/ue/Source/V2OnlineServices/Private/V2OnlineServicesSubsystem.cpp`,
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`,
    `.github/workflows/v2-build.yml`, and
    `V2/ue/Tools/check-v2-fleet-disaster-recovery.py`. The contract defines
    `FV2FleetDisasterRecoveryPlan`, `FV2FleetDisasterRecoveryDrill`, and
    `FV2FleetDisasterRecoveryResult` with default primary region `US-East`,
    backup region `US-West`, failover zone
    `Fleet.Route.Failover.US-East.US-West`, two warm standby instances, 60s RPO,
    300s RTO, and required signals for distinct primary/backup regions, warm
    standby provisioning, replicated session directory, global routing failover,
    backup-region health checks, linked runbooks, structured events, and
    post-failover health. Runtime types validate distinct regions, bounded
    standby/RPO/RTO values, drill outage/recovery/loss counts, warm standby
    promotion, routing updates, session-directory restoration, failed-region
    evacuation, data-loss within RPO, recovery within RTO, and structured
    evidence. Blueprint helpers build clamped disaster recovery plans, derive
    deterministic failover zone ids, build drills that activate the configured
    backup region, and execute failover results that promote the backup region,
    switch global routing, restore sessions, and compute RPO/RTO compliance. The
    subsystem configures recovery plans, supplies the default `US-East` to
    `US-West` plan when needed, rejects drills that do not target the configured
    primary and backup regions, executes and records validated drill results,
    and snapshots disaster recovery readiness, failover readiness, warm standby
    readiness, plan id, active/backup regions, recovered session count, and RTO.
    Automation verifies a `FleetDR.Plan.US-East.US-West.001` warm standby plan,
    a `FleetDR.Drill.US-East.Failover.001` four-minute failover drill, `US-East`
    evacuation to `US-West`, 126 recovered sessions, zero lost sessions, RPO/RTO
    compliance, subsystem plan/drill/result recording, and snapshot failover
    counters. The focused checker
    `python3 V2/ue/Tools/check-v2-fleet-disaster-recovery.py` validates the
    contract, source hooks, tests, CI registration, and TODO evidence.

---

### 72.3 Distributed Build System & Content Cooking Pipeline

FASTBuild/IncrediBuild-class distributed compilation for Rust and per-platform
content cooking pipeline for shipping game assets.

#### 72.3.1 Distributed Rust Compilation

- [x] **72.3.1.1** Implement sccache cluster deployment for distributed Rust
      compilation cache across build agents
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-sccache-cluster-deployment.json`,
    `V2/ue/Build/Rust/sccache-scheduler.conf`,
    `V2/ue/Build/Rust/sccache-server.conf`,
    `V2/ue/Build/Rust/sccache-client.toml`,
    `V2/ue/Build/Rust/sccache-client.env.example`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`, `V2/docs/ci/sccache-cluster.md`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-sccache-cluster-deployment.py`. The manifest defines
    the `sccache`/`sccache-dist` binaries with `dist-client` and `dist-server`
    features, a single Linux scheduler on port 10600, token-authenticated
    clients, JWT-authenticated servers, TLS ingress, three required connected
    build servers, and Linux worker scaling from 3 to 24 workers with 32 cores
    per worker. Worker config requires static public addresses, direct
    client-to-worker routing, worker-to-scheduler routing, root/bubblewrap,
    overlay builds under `/var/tmp/sccache-build`, and a 10 GiB toolchain cache
    under `/var/cache/sccache/toolchains`. The cache backend is S3-compatible,
    encrypted, Vault-backed, and scoped to bucket `oshun-v2-rust-sccache` in
    `us-east-1` with object prefix `v2/rust`, a local fallback cache, and a 75
    percent hit-rate gate. Client templates set `RUSTC_WRAPPER=sccache`,
    `SCCACHE_CONF`, bucket/region/SSL environment, distributed scheduler
    settings, token auth, status/stats commands, restart commands, and coverage
    for the Maya, Neith, V6, and V7 Rust workspaces. Horde and CI wiring require
    the `rust-sccache-dist-status` gate with at least three servers, the
    `rust-sccache-hit-rate` gate at 75 percent or better, JSON validation, and a
    daily `check-v2-sccache-cluster-deployment.py` health check. The runbook
    documents scheduler/server startup, client setup, health gates, evidence
    capture, worker troubleshooting, and the covered Rust workspaces. The
    focused checker validates the manifest, config templates, Horde job,
    runbook, CI registration, and TODO evidence.
- [x] **72.3.1.2** Create build farm provisioning (auto-scale build agents on CI
      trigger, scale to zero on idle)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Farm/v2-build-farm-provisioning.json`,
    `V2/ue/Build/Farm/linux-agent-cloud-init.yaml`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `V2/docs/ci/build-farm-provisioning.md`, `.github/workflows/v2-build.yml`,
    `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-build-farm-provisioning.py`. The manifest defines the
    `v2-build-farm-autoscaler` on Hetzner Cloud, scales on pull requests, main
    pushes, workflow dispatch, nightly, and weekly CI triggers, and enforces
    scale-to-zero after 1,800 idle seconds, provisioning latency at or below 600
    seconds, and stale-agent reaping after 7,200 seconds. Ephemeral workspaces
    are rooted at `/mnt/v2-build/workspace`, wiped before and after jobs, and
    preserve shared DDC, UBA, and sccache caches outside the workspace. Agent
    pools cover Linux Unreal/Rust, Linux ARM64 server, Windows Unreal, Mac
    editor, and console-cert jobs with `minIdleAgents: 0`, bounded max agent
    counts, queue-depth scaling, and per-pool scale-to-zero behavior. The
    cloud-init template creates the `v2build` runner, installs Git, Python,
    curl, jq, bubblewrap, and build tools, writes pool/workspace metadata,
    registers the Horde agent with a Vault-rendered token, enables the service,
    and starts the local sccache client. Horde and CI wiring publish required
    gates for provisioning latency, idle scale-to-zero success, and orphaned
    agent cleanup, plus a daily build farm idle sweep and
    `$(ArchiveRoot)/BuildFarm/provisioning-health.json` release evidence. The
    runbook documents trigger behavior, pool coverage, agent lifecycle, cache
    preservation, gates, and health evidence. The focused checker validates the
    manifest, cloud-init template, runbook, Horde wiring, CI registration, and
    TODO evidence.
- [x] **72.3.1.3** Implement parallel crate compilation scheduling (dependency
      graph analysis, maximize parallelism)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-crate-scheduling.json`,
    `V2/ue/Tools/plan-v2-rust-crate-schedule.py`,
    `V2/docs/ci/rust-crate-scheduling.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-crate-scheduling.py`. The manifest defines the
    scheduler/checker pair, a 24-worker default cap, dependency analysis for
    `dependencies`, `dev-dependencies`, and `build-dependencies`, local
    dependency detection via `path` entries and workspace package names, cycle
    detection, critical-path priority, stable name ordering, release evidence at
    `$(ArchiveRoot)/Rust/crate-schedule-plan.json`, and CI gates for generated
    plans, zero cycles, and at least 70 percent worker utilization. The planner
    uses `tomllib` to discover local `Cargo.toml` package manifests, builds
    dependency/dependent graphs, rejects duplicate crate names and dependency
    cycles, computes critical lengths, schedules ready crates by longest
    critical path with stable tie-breaking, emits bounded parallel waves, and
    attaches `cargo check --all-targets -p ...` invocations plus crate,
    dependency, dependent, critical path, edge count, wave count, and
    utilization evidence. Horde and CI wiring register the scheduler, checker,
    six Rust workspace roots, release evidence, JSON validation, and required
    gates. The runbook documents graph inputs, cycle rejection,
    critical-path-first scheduling, worker caps, evidence, and utilization
    gates. The focused checker validates the manifest, scheduler source hooks,
    runbook, Horde/CI registration, TODO evidence, and a fixture schedule with
    `core`, `renderer`, `tools`, and `game` crates producing waves `core`,
    `renderer/tools`, and `game` with 66.67 percent utilization.
- [x] **72.3.1.4** Create cross-compilation support (build Linux server binaries
      from macOS/Windows, WASM targets)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-cross-compilation.json`,
    `V2/ue/Build/Rust/cargo-cross-config.toml`,
    `V2/ue/Tools/plan-v2-rust-cross-compile.py`,
    `V2/docs/ci/rust-cross-compilation.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-cross-compilation.py`. The manifest defines
    required tools `rustup`, `cargo`, `cargo-zigbuild`, `zig`, `sccache`, and
    `wasm-bindgen`, host triples for Apple Silicon/macOS Intel and Windows
    x64/ARM64, Linux server targets `x86_64-unknown-linux-gnu` and
    `aarch64-unknown-linux-gnu`, and WASM targets `wasm32-unknown-unknown`,
    `wasm32-wasip1`, and `wasm32-wasip2`. Linux server coverage includes
    `egbe-world-server`, `egbe-realtime-gateway`, `egbe-pxstream-relay`,
    `moremi-realm-server`, and `danu-mesh-cluster`; WASM coverage includes
    `maya-plugin-api`, `neith-runtime`, and `v7-dev-hygiene`. Cargo config
    routes `RUSTC_WRAPPER` through `sccache`, uses `zig cc` linkers with LLD for
    Linux server targets, and sets WASM panic/feature rustflags. The planner
    emits release evidence at `$(ArchiveRoot)/Rust/cross-compilation-plan.json`
    with `CARGO_HOME`, `CARGO_TARGET_DIR`, `CARGO_CONFIG`,
    `RUSTC_WRAPPER=sccache`, `cargo zigbuild --release --locked` commands for
    Linux servers, and `cargo build --release --locked` commands for WASM. Horde
    and CI wiring register the planner, checker, cargo config, host triples,
    JSON validation, and gates for at least two Linux server targets and three
    WASM targets. The runbook documents Linux server, WASM, planner, and gate
    usage. The focused checker validates the manifest, cargo config, planner
    source, generated 19-command plan, runbook, Horde/CI registration, and TODO
    evidence.
- [x] **72.3.1.5** Implement incremental build optimization for 784K+ LOC Rust
      codebase (minimize recompilation surface)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-incremental-build.json`,
    `V2/ue/Tools/plan-v2-rust-incremental-build.py`,
    `V2/ue/Tools/plan-v2-rust-crate-schedule.py`,
    `V2/docs/ci/rust-incremental-build.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-incremental-build.py`. The manifest targets the
    784,000-line Rust baseline, uses the crate scheduler with a 24-worker
    default cap, tracks changed `*.rs`, `Cargo.toml`, `Cargo.lock`, and
    `build.rs` inputs, ignores docs, `target`, and `node_modules`, and forces
    full rebuilds for `rust-toolchain.toml` and
    `V2/ue/Build/Rust/cargo-cross-config.toml`. Impact analysis includes changed
    crates plus reverse local dependents while preserving topological and
    critical-path priority. The planner imports the crate scheduler, maps
    changed files to the longest matching Cargo package root, computes
    reverse-dependent closures, records unknown inputs and full rebuilds, emits
    impacted/skipped crates, bounded waves, and `recompileSurfacePct`, and
    writes release evidence as
    `$(ArchiveRoot)/Rust/incremental-build-plan.json`. Horde and CI wiring
    register the planner/checker, six Rust workspace roots, JSON validation, and
    gates for generated impact plans and recompile surface at or below 35
    percent. The runbook documents changed-file mapping, reverse dependents,
    full rebuild triggers, ignored paths, release evidence, and gates. The
    focused checker validates the manifest, planner source, runbook, Horde/CI
    registration, TODO evidence, and fixture behavior where a `core` source
    change rebuilds `core`, `renderer`, `tools`, and `game`, while a leaf
    `tools` change rebuilds only `tools` with a 25 percent surface.
- [x] **72.3.1.6** Create build artifact caching (store compiled crates, share
      across CI runs and developers)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-build-artifact-cache.json`,
    `V2/ue/Tools/plan-v2-rust-artifact-cache.py`,
    `V2/ue/Tools/plan-v2-rust-crate-schedule.py`,
    `V2/ue/Tools/plan-v2-rust-incremental-build.py`,
    `V2/docs/ci/rust-build-artifact-cache.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-build-artifact-cache.py`. The manifest defines a
    shared compiled-crate artifact cache for Maya, Neith, V6, and V7 Rust
    workspaces across `dev` and `release` profiles and
    `x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, and
    `wasm32-unknown-unknown` targets. Cache keys include Rust/Cargo versions,
    target triple, profile, package name, feature set, lockfile/manifests,
    `build.rs`, Rust source inputs, local dependency closure digests,
    `rust-toolchain.toml`, and `cargo-cross-config.toml`. The backend is an
    S3-compatible, Vault-backed, AES256-encrypted `oshun-v2-rust-artifacts`
    bucket in `us-east-1` under `v2/rust/artifacts`, with `zstd` compression and
    SHA-256 integrity. The local cache lives at
    `$(Workspace)/.cache/v2/rust-artifacts`, is capped at 200 GiB, and prunes
    entries older than 14 days. The planner reuses the crate scheduler, hashes
    crate inputs and dependency closures, emits one artifact per crate/target/
    profile, records restore/save/integrity commands, artifact globs, remote S3
    URIs, local `tar.zst` archives, integrity sidecars, duplicate key count,
    coverage, and release evidence at
    `$(ArchiveRoot)/Rust/build-artifact-cache-plan.json`. Horde and CI wiring
    register the planner/checker, JSON validation, the shared bucket/local
    cache, six workspace roots, and gates for plan generation, at least 80
    percent coverage, and zero integrity failures. The runbook documents key
    inputs, dependency invalidation, archive format, S3 storage, local reuse,
    release evidence, and gates. The focused checker validates the manifest,
    planner source, runbook, Horde/CI registration, TODO evidence, and fixture
    behavior where `core` and dependent `app` artifacts are generated with
    unique keys, `tar.zst` archives, `aws s3 cp`, SHA-256 sidecars, and key
    changes when a dependency source changes.
- [x] **72.3.1.7** Implement pre-merge build validation (compile-check PRs
      before merge, fail fast on errors)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-premerge-validation.json`,
    `V2/ue/Tools/plan-v2-rust-premerge-validation.py`,
    `V2/ue/Tools/run-v2-rust-premerge-validation.py`,
    `V2/ue/Tools/plan-v2-rust-crate-schedule.py`,
    `V2/ue/Tools/plan-v2-rust-incremental-build.py`,
    `.github/workflows/v2-rust-premerge.yml`,
    `V2/docs/ci/rust-premerge-validation.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-premerge-validation.py`. The manifest defines
    fail-fast Rust compile checks for `pull_request` and `merge_group`, gathers
    changes from `git diff --name-only`, uses the crate scheduler and
    incremental planner, routes through the artifact cache and sccache
    manifests, caps planning at 24 workers, and requires `RUSTC_WRAPPER=sccache`
    plus `CARGO_INCREMENTAL=0`. Full validation is forced for toolchain changes,
    Rust build manifests, Rust planner/checker tools, and the pre-merge
    workflow. The planner maps changed paths to impacted crates, groups
    scheduled crates by workspace manifest, emits
    `cargo check --locked --all-targets --manifest-path ... -p ...` commands,
    records changed/impacted/skipped crates, full-validation state, command
    counts, and metrics for plan generation, fail-fast enablement, and compile
    check failures. The runner executes commands in order, stops after the first
    failure, supports dry runs, records executed command count, per-crate build
    time metrics, and result evidence. The dedicated GitHub workflow runs on
    Rust-related PR paths and merge queue events, validates configuration,
    collects changed paths, plans fail-fast checks, runs the plan, compares
    build time regressions when a baseline is available, and uploads
    plan/results evidence. Horde and CI wiring register the planner, runner,
    workflow, JSON validation, release/result evidence, and required gates for
    generated plans, fail-fast enablement, and zero compile-check failures. The
    focused checker validates the manifest, sources, runbook, workflow, Horde/CI
    registration, TODO evidence, fixture planning for impacted `core`/`renderer`
    crates, full validation on Rust build config changes, and dry-run runner
    results.
- [x] **72.3.1.8** Create build time regression tracking (alert if any crate
      compilation time increases >10%)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-build-time-regression.json`,
    `V2/ue/Tools/compare-v2-rust-build-times.py`,
    `V2/ue/Tools/run-v2-rust-premerge-validation.py`,
    `.github/workflows/v2-rust-premerge.yml`,
    `V2/docs/ci/rust-build-time-regression.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-build-time-regression.py`. The manifest defines
    `v2.rust.buildTimeMetrics.v1` input metrics, a
    `v2.rust.buildTimeRegressionReport.v1` report, comparison by crate, target
    triple, and profile, `durationSeconds` as the measured metric, a strict
    `> 10` percent blocking alert policy, accepted baseline/current/report
    evidence paths, and CI gates for report generation, max regression at or
    below 10 percent, and zero regression count. The comparator accepts direct
    metrics or pre-merge results with embedded build-time metrics, validates
    non-negative durations, matches rows by crate/target/profile, reports new
    and missing-current crates, computes per-crate regression percentages,
    returns non-zero for regressions above threshold unless `--no-fail` is used,
    and emits metrics for report generation, max regression, and regression
    count. The pre-merge runner records per-crate `durationSeconds` for each
    compile-check command so the workflow can compare current timing evidence
    against `V2_RUST_BUILD_TIME_BASELINE` or the saved baseline. The pre-merge
    workflow validates the regression config, runs the comparator when baseline
    and current results exist, writes
    `/tmp/v2-rust-build-time-regression-report.json`, and uploads it with the
    pre-merge evidence. Horde and CI wiring register the comparator/checker,
    baseline/current/report evidence, threshold, JSON validation, and required
    gates. The runbook documents the schemas, strict threshold semantics,
    accepted evidence paths, and gates. The focused checker validates the
    manifest, comparator and runner hooks, runbook, workflow, Horde/CI
    registration, TODO evidence, and fixtures where an 11.05 percent regression
    fails while an exact 10 percent increase passes.
- [x] **72.3.1.9** Implement build dependency visualization (which crates block
      the critical path)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-dependency-visualization.json`,
    `V2/ue/Tools/visualize-v2-rust-dependencies.py`,
    `V2/ue/Tools/plan-v2-rust-crate-schedule.py`,
    `V2/docs/ci/rust-dependency-visualization.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-dependency-visualization.py`. The manifest
    defines JSON, Graphviz DOT, and Mermaid dependency visualization outputs for
    the Maya, Neith, V6, and V7 Rust workspaces, with critical-path blocking
    ranked by `criticalLength`, transitive dependent count, and stable crate
    name, capped to 20 blockers. The generator reuses the crate scheduler,
    computes local dependency/dependent graphs, transitive dependent closures,
    critical lengths, dependency-to-dependent edges, per-crate
    dependency/dependent counts, blocker flags, and metrics for generated
    reports, blocker count, and edge count. It emits
    `v2.rust.dependencyVisualizationReport.v1` JSON plus DOT and Mermaid graphs
    with critical blockers highlighted, and writes release evidence at
    `$(ArchiveRoot)/Rust/dependency-visualization.json`,
    `$(ArchiveRoot)/Rust/dependency-visualization.dot`, and
    `$(ArchiveRoot)/Rust/dependency-visualization.mmd`. Horde and CI wiring
    register the generator, checker, scheduler, JSON validation, six workspace
    roots, evidence paths, and gates for generated visualization, at least one
    critical blocker, and at least one dependency edge. The runbook documents
    graph formats, critical-length interpretation, transitive dependent counts,
    dependency-to-dependent edge direction, release evidence, and gates. The
    focused checker validates the manifest, generator source, runbook, Horde/CI
    registration, TODO evidence, and a fixture graph where `core` is the top
    critical blocker with four edges across `core`, `renderer`, `tools`, and
    `game`, plus DOT and Mermaid output verification.
- [x] **72.3.1.10** Create developer local build cache (share compiled crates
      between local branches via content-addressed store)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Rust/v2-rust-local-build-cache.json`,
    `V2/ue/Tools/manage-v2-rust-local-build-cache.py`,
    `V2/ue/Tools/plan-v2-rust-artifact-cache.py`,
    `V2/docs/ci/rust-local-build-cache.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-rust-local-build-cache.py`. The manifest defines a
    developer-local cache rooted at
    `$(Workspace)/.cache/v2/rust-local-build-cache`, with SHA-256
    content-addressed objects under `objects/sha256`, branch-scoped refs under
    `refs/{branch}`, branch-agnostic artifact objects, hardlink-preferred
    restore behavior, six default Rust workspace roots, dev/release profiles,
    the Linux target triple, 30-day/250 GB retention, and release evidence at
    `$(ArchiveRoot)/Rust/local-build-cache-plan.json`. The manager reuses the
    Rust artifact cache planner, hashes cache key inputs, crate input digests,
    dependency closure digests, features, target triples, profiles, and compiler
    versions into stable `sha256:` content addresses, emits per-crate object
    paths, branch ref paths, restore commands, save commands, and metrics for
    generated plans, content-addressed operation, and restore coverage. Horde
    and CI wiring register the manifest, manager, checker, JSON validation,
    store root, content-addressed mode, and required gates for plan generation,
    content addressing, and 100 percent restore coverage. The runbook documents
    branch-scoped refs pointing at branch-agnostic objects, cross-branch reuse
    semantics, save/restore plan contents, and required gates. The focused
    checker validates the manifest, manager source, runbook, Horde/CI
    registration, TODO evidence, and a two-crate fixture where identical crate
    inputs share object paths across branches while branch refs differ, then
    verifies object paths change when dependency inputs change.
- [x] **72.3.1.11** Implement shader compilation distribution (compile thousands
      of shader permutations across build farm)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Shaders/v2-shader-distribution.json`,
    `V2/ue/Tools/plan-v2-shader-distribution.py`, `V2/ue/Build/Build.xml`,
    `V2/ue/Config/DefaultEngine.ini`, `V2/docs/ci/shader-distribution.md`,
    `V2/ue/Build/Farm/v2-build-farm-provisioning.json`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-shader-distribution.py`. The manifest defines
    ShaderCompileWorker-backed DerivedDataCache fill shards with
    `$(UE_SHARED_DDC)/V2/DDC`, `r.ShaderCompiler.JobCacheDDC=1`, bounded
    512-permutation shards, fail-fast remote execution, local fallback, 48
    remote workers, and Win64, PS5, XSX, Switch2, Linux, and Mac platform pools.
    It tracks six permutation buckets across fighter materials, combat VFX,
    stage lighting, cinematics, UI, and online social spaces, covering more than
    31,000 estimated permutations before platform expansion. The planner expands
    those buckets deterministically into per-platform Horde shards with
    priorities, shader formats, package roots, response files, shared DDC
    namespaces, `-AllowShaderCompilingThroughWorkers`, `-SharedDataCachePath`,
    and `-V2ShaderShard` command lines, then emits
    `v2.shader.distributionPlan.v1` release evidence at
    `$(ArchiveRoot)/Shaders/shader-distribution-plan.json` with metrics for plan
    generation, permutation coverage, farm shard count, and shared DDC
    enablement. BuildGraph requires the Win64 ShaderCompileWorker before
    planning shader distribution, DefaultEngine enables asynchronous worker
    shader compilation and shared DDC job caching, and the farm manifest
    preserves shared DDC and UBA caches for distributed jobs. Horde and CI
    wiring register the manifest, planner, checker, daily plan schedule, JSON
    validation, required release evidence, and gates for generated plans, 100
    percent permutation coverage, at least 32 farm shards, and shared DDC
    enabled. The runbook documents shard generation, worker-backed DDC fill
    execution, shared cache outputs, evidence, gates, and the CI validator. The
    focused checker validates the manifest, planner source, deterministic
    planner output, BuildGraph, engine shader/DDC settings, Horde/farm/CI
    wiring, runbook, TODO evidence, shard size bounds, command tokens, six
    supported platforms, 100 percent coverage, and at least 32 farm shards.
- [x] **72.3.1.12** Create build report dashboard (compilation time per crate,
      cache hit rate, farm utilization)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Reports/v2-build-report-dashboard.json`, `V2/web/src/App.tsx`,
    `V2/web/src/data/buildReportData.ts`, `V2/web/src/styles.css`,
    `V2/web/src/App.test.tsx`, `V2/web/e2e/v2-web.spec.ts`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-build-report-dashboard.py`. The manifest binds the
    public web route `/#build-report` to dashboard data, styling, unit tests,
    Playwright tests, and required metrics for compilation time per crate, cache
    hit rate, and farm utilization, with controls for target filtering, crate
    detail selection, and evidence links. The data source provides five build
    report rows across Win64, Linux, WASM, and shader targets, with compile
    seconds, baselines, cache hit rates above 75 percent, farm utilization above
    65 percent, farm pools, worker counts, queue depths, critical path ranks,
    evidence JSON links, and summary helpers for average compile time, average
    cache hit rate, average farm utilization, and critical-path crate. The UI
    renders a `build-report` section with target filter buttons, KPI summaries,
    a responsive build target table, cache/farm meters, status badges, selected
    crate detail, and an `Open evidence JSON` link, with mobile CSS keeping the
    dashboard and detail panel inside the viewport. Unit tests validate
    dashboard rendering, target filtering, selected crate detail, Linux farm
    worker details, and farm utilization copy. Playwright coverage validates
    navigation to the dashboard, target filtering, crate detail selection,
    evidence link hrefs, and mobile viewport overflow checks. Horde and CI
    wiring register the manifest, checker, daily dashboard check schedule, JSON
    validation, route, app/data paths, and gates for rendered dashboard, 100
    percent metric coverage, and passing Playwright coverage. The focused
    checker validates the manifest, data source, UI tokens, responsive styles,
    unit and Playwright coverage, Horde/CI registration, TODO evidence, minimum
    row/target coverage, cache and farm thresholds, controls, and gate
    definitions.
- [x] **72.3.1.13** Implement reproducible builds (same source → identical
      binary, for security and debugging)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Reproducible/v2-reproducible-builds.json`,
    `V2/ue/Tools/plan-v2-reproducible-builds.py`,
    `V2/ue/Tools/compare-v2-reproducible-artifacts.py`,
    `V2/docs/ci/reproducible-builds.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-reproducible-builds.py`. The manifest defines a
    reproducible build contract with two isolated passes, fixed
    `SOURCE_DATE_EPOCH=1781740800`, UTC/C UTF-8 locale settings,
    `CARGO_INCREMENTAL=0`, workspace path remapping to `/workspace`, Rust
    `-Ccodegen-units=1`, stable SHA-1 linker build IDs, and normalized tar
    archive flags for sorted names, fixed mtimes, root ownership, and numeric
    owners. It covers release-critical Rust, Unreal, WASM, and generated-plan
    artifacts: V2 Linux server x86_64, V2 Linux server ARM64, Maya physics
    x86_64, V2 WASI runtime, Win64 shipping client, and shader distribution
    plan. The planner emits deterministic `v2.reproducibleBuilds.plan.v1`
    release evidence at
    `$(ArchiveRoot)/Reproducible/reproducible-build-plan.json`, expands every
    target into pass A/pass B build commands, normalized archive commands,
    SHA-256 manifest commands, and comparison commands, and publishes metrics
    for plan generation, digest mismatch count, target coverage, and
    source-date-epoch enforcement. The comparator writes
    `v2.reproducibleBuilds.artifactManifest.v1` SHA-256 file manifests, compares
    pass A/B manifests into `v2.reproducibleBuilds.compareReport.v1`, reports
    matched, missing, and mismatched entries, and exits nonzero on digest
    mismatches. Horde and CI wiring register the manifest, planner, comparator,
    checker, daily reproducible-build plan schedule, release evidence, JSON
    validation, and gates for generated plans, zero digest mismatches, 100
    percent target coverage, and source date epoch set. The runbook documents
    deterministic environment variables, path remapping, Rust/Unreal settings,
    generated-plan artifact hashing, normalized archives, SHA-256 comparison,
    gates, evidence, and CI validation. The focused checker validates the
    manifest, deterministic planner output, comparator behavior for matching and
    mismatching fixtures, runbook, Horde/CI registration, TODO evidence, all six
    target artifacts, A/B pass coverage, command counts, comparison counts,
    metrics, and required reproducibility tokens.
- [x] **72.3.1.14** Create CI pipeline for multi-platform builds (Linux, macOS,
      Windows, WASM in parallel)
  - Evidence: Implemented and validated by
    `V2/ue/Build/CI/v2-multiplatform-builds.json`,
    `.github/workflows/v2-multiplatform-build.yml`, `V2/ue/Build/Build.xml`,
    `V2/ue/Build/Rust/v2-rust-cross-compilation.json`,
    `V2/ue/Build/Reproducible/v2-reproducible-builds.json`,
    `V2/ue/Build/Farm/v2-build-farm-provisioning.json`,
    `V2/docs/ci/multiplatform-builds.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-multiplatform-ci.py`. The manifest defines a
    Linux/macOS/Windows/WASM CI matrix with `maxParallel: 4`, `failFast: false`,
    reproducible-build environment variables, cross-compilation and
    reproducible-build manifest dependencies, per-platform runner labels, Horde
    pools, shell selection, evidence artifact names, required commands, and
    release evidence under `$(ArchiveRoot)/MultiPlatform`. Linux runs BuildGraph
    targets for x86_64 and ARM64 dedicated server shipping builds plus the Rust
    cross-compile planner, macOS runs the V2Editor Mac Development BuildGraph
    target, Windows runs the Win64 shipping BuildGraph target, and WASM installs
    `wasm32-unknown-unknown`, `wasm32-wasip1`, and `wasm32-wasip2` before
    building `v7-dev-hygiene` with `cargo build --release --locked`. The
    workflow validates the contract first, fans out a four-entry
    `platform-build` matrix using self-hosted runner labels, enforces the same
    deterministic environment and Rust path-remapping flags, requires
    `UE_RUN_UAT` on Unreal lanes, uploads per-platform evidence artifacts with
    14-day retention, and keeps platform failures independent with
    `fail-fast: false`. The checker also proves the required BuildGraph targets,
    build farm label coverage, WASM target/package coverage in the Rust
    cross-compilation manifest, reproducible-build target dependencies, V2 build
    workflow registration, CI checker registration, Horde daily
    multi-platform-build schedule, and gates for Linux, macOS, Windows, WASM,
    and at least four parallel jobs. The runbook documents the matrix behavior,
    platform-specific commands, required gates, parallelism metric, evidence
    artifacts, and CI validator.
- [x] **72.3.1.15** Implement build notification system (Slack/Discord alerts on
      build success/failure)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Notifications/v2-build-notifications.json`,
    `.github/workflows/v2-build-notifications.yml`,
    `V2/ue/Tools/render-v2-build-notification.py`,
    `V2/docs/ci/build-notifications.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-build-notifications.py`. The manifest defines a
    Slack/Discord build notification contract for `workflow_run` completion and
    manual dispatch, watches `V2 Unreal Build`, `V2 Rust Pre-Merge Validation`,
    and `V2 Multi-Platform Build Matrix`, covers success, failure, cancellation,
    timeout, action-required, neutral, and skipped conclusions, declares Slack
    and Discord channels, and requires all webhook URLs to come from GitHub
    secrets rather than repository literals. The workflow validates the
    contract, renders payloads from workflow name, conclusion, branch, SHA, run
    URL, and actor, sends Slack and Discord notifications only when
    `V2_BUILD_SLACK_WEBHOOK_URL` or `V2_BUILD_DISCORD_WEBHOOK_URL` is
    configured, skips missing channels cleanly, and publishes a step summary for
    every run. The renderer normalizes conclusions, shortens commit SHAs, maps
    success, failure/attention, and neutral states to Slack attachment colors
    and Discord embed colors, writes Slack `text`/`attachments`, Discord
    `username`/`embeds`, and a summary JSON, and handles success and failure
    fixtures. Horde and CI wiring register the manifest, workflow, renderer,
    checker, watched workflows, Slack/Discord channels, JSON validation, and
    gates for workflow registration, Slack declaration, Discord declaration, and
    success/failure coverage. The runbook documents watched workflows, secret
    configuration, missing-secret behavior, gates, metrics, and the validator.
    The focused checker validates the manifest, workflow, renderer source and
    fixture behavior, watched workflow names, absence of literal webhook URLs,
    Horde/CI registration, runbook, TODO evidence, payload fields, required
    secrets, skip behavior, step summary, and gates.

#### 72.3.2 Content Cooking Pipeline

- [x] **72.3.2.1** Design content cooking architecture (source asset → cooked
      platform-optimized asset with dependency tracking)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/content-cooking-architecture.md`,
    `V2/ue/Build/Build.xml`, `V2/ue/Tools/cook-all.sh`,
    `V2/ue/Tools/cook-all.ps1`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-content-cooking-architecture.py`. The architecture
    manifest defines five source roots, existing BuildGraph and shell/PowerShell
    cook wrapper integration, and a six-stage pipeline from
    `discover-source-assets` through `normalize-and-fingerprint`,
    `build-dependency-graph`, `plan-platform-cook`, `execute-cook`, and
    `validate-and-report`. The stages emit canonical source asset manifests,
    stable fingerprints, dependency graph evidence, platform cook plans,
    deterministic cooked artifacts, validation reports, and cook reports under
    `$(ArchiveRoot)/Cooking` and shared cooked-content caches under
    `$(UE_SHARED_DDC)/V2/CookedContent`. Asset class coverage includes texture,
    mesh, audio, shader, animation, and level source extensions with dependency
    kinds and future task links. The dependency graph schema keys nodes by
    `canonicalSourceUri`, hashes content with SHA-256, accepts `*.v2deps.json`
    sidecars plus AssetRegistry input, records source/target/kind/platform
    scope/content hash edge fields, and requires transitive dependent
    invalidation. Platform profile coverage includes `PCUltra`, `PCLow`, `PS5`,
    `XSX`, `XSS`, `Switch2`, and `Mobile` profiles with texture, mesh, and audio
    tiers. The focused checker validates the manifest, existing BuildGraph cook
    targets, cook wrappers, Horde/CI registration, runbook, TODO evidence,
    pipeline order, source roots, asset class coverage, dependency tracking,
    cache policy, platform profile coverage, evidence paths, and gates for
    architecture definition, dependency tracking, platform profile count, and
    cache policy.
- [x] **72.3.2.2** Implement texture cooking (source PNG/EXR → BC7 for PC, ASTC
      for mobile, platform-specific mipmap chains)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-texture-cooking.json`,
    `V2/ue/Tools/plan-v2-texture-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/texture-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-texture-cooking.py`. The manifest covers PNG and EXR
    source formats, requires `texconv` and `astcenc`, declares full mip-chain
    generation, power-of-two inputs, linear normal-map preservation, alpha
    coverage preservation, 4K-capable 13-level mip chains, and dependency
    sidecars ending in `*.v2deps.json`. PCUltra, PCLow, PS5, XSX, and XSS use
    `texconv` with `BC7_UNORM_SRGB` color textures, `BC7_UNORM` normals, and
    `BC6H_UF16` HDR EXR output; Switch2 uses ASTC 6x6, and Mobile uses ASTC 8x8.
    Texture set coverage includes fighter skins, stage surfaces, UI HUD PNG
    atlases, and cinematic HDR EXR inputs with streaming groups, dependency
    kinds, and alpha/HDR requirements. The planner deterministically expands
    every profile and texture set into cook commands, output roots, dependency
    sidecar paths, cache keys, encoder formats, mip counts, mip bias, max
    texture sizes, ASTC `-cl`/`-ch` mode flags, and metrics for plan generation,
    BC7 profile count, ASTC profile count, and mip-chain count, with profile
    filters for targeted plans. Horde and CI wiring register the manifest,
    planner, checker, runbook, JSON validation, source formats, encoders,
    release evidence at `$(ArchiveRoot)/Cooking/texture-cook-plan.json`, and
    required gates for generated plans, at least five BC7 profiles, at least two
    ASTC profiles, and at least 20 mip chains. The focused checker validates the
    manifest, architecture texture class link, planner source, deterministic
    planner output, Mobile ASTC-only filtering, command cache keys, dependency
    sidecars, Horde/CI registration, runbook, TODO evidence, and gate metrics.
- [x] **72.3.2.3** Create mesh cooking (source glTF/FBX → engine-native format
      with Nanite cluster hierarchy, collision meshes, LODs)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-mesh-cooking.json`,
    `V2/ue/Tools/plan-v2-mesh-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/mesh-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-mesh-cooking.py`. The manifest covers FBX, glTF, and
    GLB source formats, requires `UnrealEditor-Cmd`, Interchange, NaniteBuilder,
    and Chaos, normalizes scale to centimeters and Unreal Z-up, triangulates
    deterministically, preserves sockets and skin weights, builds Nanite cluster
    hierarchies with fallback meshes, cooks Chaos collision, and generates
    platform-specific LOD chains while preserving LOD0. Platform profiles cover
    PCUltra, PCLow, PS5, XSX, XSS, Switch2, and Mobile, with NaniteHigh,
    NaniteFallback, NaniteConsole, NaniteReduced, ClusterReduced, and MobileLOD
    modes, per-profile cluster and fallback triangle budgets, collision cook
    policy, and LOD chain definitions. Mesh set coverage includes arena
    geometry, fighter costumes, destructible props, and gameplay collision,
    mapping to `UStaticMesh.Nanite`, `USkeletalMesh.Cooked`, clustered/mobile
    static meshes, and `UStaticMesh.CollisionProxy` `.uasset` packages with
    dependency sidecars under `$(ArchiveRoot)/Cooking/MeshDeps`. The planner
    deterministically expands every profile and mesh set into
    `V2MeshCookCommandlet` commands with engine format, mesh tier, Nanite flag,
    Nanite mode, collision policy, LOD chain, output package, dependency
    sidecar, SHA-256 cache key, and metrics for plan generation, Nanite profile
    count, collision set count, LOD chain count, and engine-native command
    count, with profile filters for targeted plans. Horde and CI wiring register
    the manifest, planner, checker, runbook, source formats, output package
    classes, release evidence at `$(ArchiveRoot)/Cooking/mesh-cook-plan.json`,
    JSON validation, and gates for generated plans, at least five Nanite
    profiles, four collision sets, at least 20 LOD chains, and 28 engine-native
    commands. The focused checker validates the manifest, architecture mesh
    class link, planner source, deterministic planner output, Mobile non-Nanite
    filtering, cache keys, dependency sidecars, `.uasset` output packages,
    Horde/CI registration, runbook, TODO evidence, and gate metrics.
- [x] **72.3.2.4** Implement audio cooking (source WAV/FLAC → Opus for
      streaming, platform-specific codec selection)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-audio-cooking.json`,
    `V2/ue/Tools/plan-v2-audio-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/audio-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-audio-cooking.py`. The manifest covers WAV and FLAC
    sources, requires `UnrealEditor-Cmd`, `ffmpeg`, `opusenc`, and Python,
    defines deterministic loudness normalization at -16 LUFS with -1 dB true
    peak and -18 LUFS dialogue, and uses Opus streaming with sample-accurate
    chunk alignment, seek tables, first-chunk preload, and gapless loops.
    Platform profiles cover PCUltra, PCLow, PS5, XSX, XSS, Switch2, and Mobile:
    all stream with Opus at 48 kHz, PC/Switch2/Mobile package as Opus, PS5
    packages as ATRAC9, and Xbox profiles package as XMA2. Audio set coverage
    includes streamed music stems, streamed localized voice dialogue with
    lip-sync dependencies, resident combat SFX, and streamed ambience loops with
    source globs, chunk durations, channel layouts, streaming groups, dependency
    kinds, and looping/localization flags. The planner deterministically expands
    every profile and audio set into `V2AudioCookCommandlet` commands with
    streaming codec, package codec, bitrate, sample rate, channel layout,
    streaming flag, chunk duration, seek table, loudness target, output
    `.opuspak` chunk, output `.uasset` package, dependency sidecar, SHA-256
    cache key, and metrics for plan generation, Opus streaming profile count,
    platform codec profile count, streaming chunk count, and dependency sidecar
    count, with profile filters for targeted plans. Horde and CI wiring register
    the manifest, planner, checker, runbook, source formats, Opus streaming
    codec, Opus/ATRAC9/XMA2 package codecs, release evidence at
    `$(ArchiveRoot)/Cooking/audio-cook-plan.json`, JSON validation, and gates
    for generated plans, seven Opus streaming profiles, at least three platform
    codec profiles, at least 20 streaming chunks, and 28 dependency sidecars.
    The focused checker validates the manifest, architecture audio class link,
    planner source, deterministic planner output, Mobile Opus-only filtering,
    cache keys, sidecars, `.opuspak` chunks, `.uasset` packages, Horde/CI
    registration, runbook, TODO evidence, and gate metrics.
- [x] **72.3.2.5** Create shader cooking (WGSL/GLSL source → SPIR-V for Vulkan,
      DXIL for DX12, MSL for Metal, WGSL for WebGPU)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-shader-cooking.json`,
    `V2/ue/Tools/plan-v2-shader-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/ue/Build/Shaders/v2-shader-distribution.json`,
    `V2/docs/asset-pipeline/shader-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-shader-cooking.py`. The manifest covers WGSL and GLSL
    sources, requires `UnrealEditor-Cmd`, `glslangValidator`, `dxc`,
    `spirv-cross`, `naga`, and Python, and defines deterministic compiler
    arguments, Shipping debug stripping, reflection output, pipeline state hash
    emission, source line mapping preservation, and dependency sidecars ending
    in `*.v2deps.json`. Compiler target coverage emits SPIR-V for Vulkan through
    `glslangValidator+naga`, DXIL for DX12 through `dxc`, MSL for Metal through
    `spirv-cross+naga`, and normalized WGSL for WebGPU through `naga`, with
    platform mappings for Linux/Switch2/Android, Win64/XSX/XSS, Mac/iOS, and
    WASM/Browser. Shader set coverage includes material-domain, combat-vfx,
    compute-kernels, and ui-compositing sources with entry points, permutation
    dimensions, dependency kinds, and cooked package roots. The planner
    deterministically expands every compiler target and shader set into
    `V2ShaderCookCommandlet` commands with graphics API, output format,
    compiler, entry points, permutation space, output artifact, reflection JSON,
    dependency sidecar, SHA-256 cache key, and metrics for plan generation,
    SPIR-V/DXIL/MSL/WGSL target counts, and permutation command count, with a
    target filter that emits only WebGPU/WGSL commands when requested. Horde and
    CI wiring register the manifest, planner, checker, runbook, source formats,
    output formats, release evidence at
    `$(ArchiveRoot)/Cooking/shader-cook-plan.json`, JSON validation, shader
    distribution linkage, and gates for generated plans, each output target
    family, and at least 16 permutation commands. The focused checker validates
    the manifest, architecture shader class link, ShaderCompileWorker
    distribution link, planner source, deterministic planner output, WebGPU-only
    filtering, cache keys, reflection paths, dependency sidecars, Horde/CI
    registration, runbook, TODO evidence, and gate metrics.
- [x] **72.3.2.6** Implement animation cooking (source FBX/glTF → compressed
      bone animation with ACL-style encoding)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-animation-cooking.json`,
    `V2/ue/Tools/plan-v2-animation-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/animation-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-animation-cooking.py`. The manifest covers `.fbx`,
    `.gltf`, and `.glb` source animation formats; requires `UnrealEditor-Cmd`,
    `acl_compressor`, and Python; and defines skeleton compatibility checks,
    root motion, notify tracks, curve tracks, editor-only curve stripping,
    deterministic ACL compression, variable rotation/translation/scale formats,
    and ACL error stat output. Platform profile coverage includes PCUltra,
    PCLow, PS5, XSX, XSS, Switch2, and Mobile profiles with ACLHigh, ACLMedium,
    ACLConsole, ACLReduced, and ACLLow compression tiers, positive error
    thresholds, 30/60 Hz sample rates, redundant key stripping, and target
    platform mappings. Animation set coverage includes fighter-combat,
    fighter-locomotion, cinematic-performances, and additive-overlays sources
    with skeleton roots, dependency kinds, cooked package roots, fighter root
    motion preservation, cinematic `level_sequence` dependencies, and additive
    overlay coverage. The planner deterministically expands every platform
    profile and animation set into `V2AnimationCookCommandlet` commands with
    codec, compression tier, error threshold, sample rate, root-motion and
    additive flags, skeleton root, output `.acl` clip, `.uasset` package,
    `.acl-stats.json` output, dependency sidecar, SHA-256 cache key, and metrics
    for plan generation, ACL profile count, bone compression command count,
    additive set count, and dependency sidecar count, with profile filtering for
    targeted Mobile plans. Horde and CI wiring register the manifest, planner,
    checker, runbook, source formats, `.acl`/`.uasset`/`.acl-stats.json`
    outputs, release evidence at
    `$(ArchiveRoot)/Cooking/animation-cook-plan.json`, JSON validation, ACL
    codec coverage, all seven profiles, all four animation sets, and gates for
    generated plans, seven ACL profiles, 28 bone compression commands, additive
    coverage, and 28 dependency sidecars. The focused checker validates the
    manifest, architecture animation class link, planner source, deterministic
    planner output, Mobile-only filtering, cache keys, `.acl` clips, stat
    outputs, dependency sidecars, Horde/CI registration, runbook, TODO evidence,
    and gate metrics.
- [x] **72.3.2.7** Create level/world cooking (collect all referenced assets,
      generate streaming chunks, build spatial indices)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-level-world-cooking.json`,
    `V2/ue/Tools/plan-v2-level-world-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/level-world-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-level-world-cooking.py`. The manifest covers `.umap`,
    `.worldpartition`, and JSON world descriptor sources; requires
    `UnrealEditor-Cmd` and Python; and defines transitive reference collection,
    soft object paths, asset registry dependencies, World Partition cells,
    missing-reference failure, streaming chunk generation, spatial index
    building, deterministic cell ordering, navmesh chunking, and lighting
    scenario chunking. Platform profile coverage includes PCUltra, PCLow, PS5,
    XSX, XSS, Switch2, and Mobile with chunk sizes from 48 to 128 meters,
    positive chunk and streaming budgets, and BVHGrid/GridQuadtree spatial index
    strategies. World set coverage includes arena-stages, story-worlds,
    battle-hub, and cinematic-levels sources with world roots, streaming cell
    dependencies, actor package dependencies, navmesh requirements, online spawn
    dependencies, quest graph dependencies, level sequence dependencies, and
    lighting scenario requirements. The planner deterministically expands every
    platform profile and world set into `V2LevelWorldCookCommandlet` commands
    with reference manifests, `.v2worldchunk` streaming chunks,
    `.v2spatial.json` spatial indices, dependency sidecars, output directories,
    chunk budgets, spatial index types, SHA-256 cache keys, and metrics for plan
    generation, reference closure command count, streaming chunk count, spatial
    index count, and dependency sidecar count, with profile filtering for
    targeted Mobile plans. Horde and CI wiring register the manifest, planner,
    checker, runbook, source formats, `.references.json`/`.v2worldchunk`/
    `.v2spatial.json` outputs, release evidence at
    `$(ArchiveRoot)/Cooking/level-world-cook-plan.json`, JSON validation, all
    seven profiles, all four world sets, and gates for generated plans, 28
    reference-closure commands, 28 streaming chunks, 28 spatial indices, and 28
    dependency sidecars. The focused checker validates the manifest,
    architecture level class link, planner source, deterministic planner output,
    Mobile-only filtering, cache keys, streaming chunk paths, spatial index
    paths, dependency sidecars, Horde/CI registration, runbook, TODO evidence,
    and gate metrics.
- [x] **72.3.2.8** Implement incremental cooking (only re-cook assets whose
      sources or dependencies changed since last cook)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-incremental-cooking.json`,
    `V2/ue/Tools/plan-v2-incremental-cooking.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/incremental-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-incremental-cooking.py`. The manifest defines source
    fingerprint storage, previous/current cook state files, changed-source path
    input, dependency graph input, source hash/import setting/platform
    profile/cooker version/dependency sidecar tracking, `*.v2deps.json`
    sidecars, ignored transient paths, and full-recook triggers for BuildGraph,
    the content cooking architecture manifest, and every domain cooking
    manifest. Impact analysis covers changed sources, changed dependencies,
    reverse dependents, deleted sources, transitive closure, deterministic
    ordering, skipped assets, cache-hit reasons, and stale output pruning.
    Domain coverage links texture, mesh, audio, shader, animation, and
    level-world groups to their cooking manifests, planners, source roots,
    source extensions, and dependency kinds, with seven platform profiles and
    cache namespaces for PCUltra, PCLow, PS5, XSX, XSS, Switch2, and Mobile. The
    fixture graph contains eight assets across every domain and proves
    dependency closure from arena-stone-texture through shader, mesh, and world
    assets, plus fighter texture, mesh, and animation dependencies, each with
    source/import/dependency hashes and dependency sidecars. The planner
    deterministically expands changed sources and dependency sidecar changes
    into `V2IncrementalCookCommandlet` actions with dependency graph,
    previous-state, per-domain `.incremental-cook.json` output plans, SHA-256
    cache keys, impacted assets, skipped assets, cache hits, stale outputs, and
    metrics for generated plans, changed sources, changed dependencies,
    dependent invalidations, skipped assets, cache hits, and stale outputs. The
    focused checker validates that a changed texture source recooks only the
    four-asset impacted closure while skipping four unchanged assets, Mobile
    filtering emits four actions, a changed mesh dependency sidecar recooks the
    mesh and dependent world, global manifest changes trigger a full 56-action
    recook, previous-state source hash changes are detected, deleted previous
    assets emit stale outputs, and skipped fighter assets receive no cook
    action. Horde and CI wiring register the manifest, planner, checker,
    runbook, previous cook state, dependency graph, release evidence at
    `$(ArchiveRoot)/Cooking/incremental-cook-plan.json`, JSON validation, all
    seven profiles, all six domain groups, full-recook triggers, and gates for
    changed-source detection, dependent invalidations, skipped unaffected
    assets, and cache reuse.
- [x] **72.3.2.9** Create cooking dependency graph (if texture changes, re-cook
      all materials referencing it, then all meshes using those materials)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-cooking-dependency-graph.json`,
    `V2/ue/Tools/plan-v2-cooking-dependency-graph.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/ue/Build/Cooking/v2-incremental-cooking.json`,
    `V2/docs/asset-pipeline/cooking-dependency-graph.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-cooking-dependency-graph.py`. The manifest defines the
    dependency graph builder inputs from Asset Registry dumps, all domain
    `*.v2deps.json` sidecar roots, material graph roots, level reference roots,
    canonical node schema keyed by `canonicalSourceUri`, and
    `sourceDependsOnTarget` edges with reverse-dependent invalidation. Asset
    type coverage includes texture, material, mesh, shader, audio, animation,
    and level-world sources, with explicit invalidation rules for texture to
    material, material to mesh and level-world, mesh to animation and
    level-world, shader to material, and audio/animation to level-world. The
    invalidation policy includes the changed asset, transitive closure,
    deterministic invalidation waves, deterministic ordering, cycle detection,
    and missing-reference failure. The fixture graph contains 12 canonical nodes
    and 12 hashed edges spanning arena textures, shaders, materials, meshes,
    audio, levels, fighter texture/material/mesh, and animation, including the
    required texture-parameter, material-shader, material-slot, level-package,
    and skeleton-mesh chains. The planner deterministically builds
    `v2.contentCooking.dependencyGraphPlan.v1` output, merges optional
    dependency sidecars, maps changed paths to assets, emits invalidated assets,
    reverse dependents, invalidation waves, cycle reports, missing-reference
    reports, graph metrics, and closure outputs, and proves that an arena stone
    texture change invalidates the texture, both referencing materials, both
    meshes using those materials, and the level packaging those meshes. The
    focused checker validates changed-asset and changed-path lookup equivalence,
    a material-only closure into its mesh and level, sidecar merge behavior,
    sidecar material-reference counts, cycle reporting, zero missing references,
    material edge counts, texture closure counts, architecture and incremental
    manifest links, Horde/CI registration, runbook coverage, TODO evidence, and
    gates for graph generation, material links, texture closure, cycle-free
    output, and missing-reference-free output.
- [x] **72.3.2.10** Implement parallel cooking across all available cores
      (thread pool with work stealing for asset independence)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-parallel-cooking.json`,
    `V2/ue/Tools/plan-v2-parallel-cooking.py`,
    `V2/ue/Build/Cooking/v2-cooking-dependency-graph.json`,
    `V2/ue/Build/Cooking/v2-incremental-cooking.json`,
    `V2/docs/asset-pipeline/parallel-cooking.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-parallel-cooking.py`. The manifest defines a
    dependency-aware scheduler with a thread pool, work stealing, all-available
    core selection, deterministic queue order, longest-queue stealing, worker
    count bounds from 1 to 64, and command templates for
    `V2ParallelCookWorkerCommandlet` workers and scheduler emission. Dependency
    policy consumes the cooking dependency graph with `sourceDependsOnTarget`
    edges, schedules dependencies before dependents, respects invalidation
    waves, fails on cycles and dependency violations, and proves that same-wave
    assets have no dependency path between them. The planner deterministically
    loads the dependency graph sample or an optional graph plan, builds
    topological waves, checks dependency violations and independent-wave
    violations, chooses available-core worker counts, simulates work stealing,
    emits worker assignments, steal traces, worker stats, utilization, wave
    width, and schedule metrics. The focused checker validates a four-worker
    schedule with 12 tasks, 12 edges, four dependency-safe waves, max wave width
    four, eight steal operations, zero dependency violations, zero
    independent-wave violations, zero cycles, 75% worker utilization, material
    and mesh wave ordering, 12 assignment records, four-worker assignment
    coverage, stolen task accounting, and a two-worker schedule that remains
    dependency-safe while still stealing work. Horde and CI wiring register the
    manifest, planner, checker, runbook, dependency graph, schedule output at
    `$(ArchiveRoot)/Cooking/parallel-cook-schedule.json`, release evidence at
    `$(ArchiveRoot)/Cooking/parallel-cook-plan.json`, JSON validation,
    all-available-core worker selection, thread pool/work stealing flags, and
    gates for generated plans, worker coverage, work stealing, dependency-safe
    schedules, and independent wave width.
- [x] **72.3.2.11** Create cook validation step (verify cooked assets load
      correctly, check for missing references)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-cook-validation.json`,
    `V2/ue/Tools/plan-v2-cook-validation.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/ue/Build/Cooking/v2-cooking-dependency-graph.json`,
    `V2/ue/Build/Cooking/v2-parallel-cooking.json`,
    `V2/docs/asset-pipeline/cook-validation.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-cook-validation.py`. The manifest defines the
    post-parallel-cook validation step with cooked root, per-platform asset
    registry input, dependency graph input, parallel schedule input, and
    `V2CookValidationCommandlet` load-check commands. Validation policy loads
    cooked packages, verifies missing references, validates asset registry
    coverage, shader maps, bulk data, and streaming chunks, fails on load errors
    and missing references, and preserves deterministic ordering. Profile
    coverage includes PCUltra, PCLow, PS5, XSX, XSS, Switch2, and Mobile, and
    validation asset coverage includes texture, shader, material, mesh, audio,
    animation, and level-world cooked packages with registry paths, validation
    suites, and expected material and level references. The planner
    deterministically emits one validation command per profile and asset, for 49
    commands total, including cooked package paths, registry paths, dependency
    graph arguments, per-asset reports, validation suite IDs, load-failure
    records, missing-reference records, 100% asset registry coverage, and
    metrics for plan generation, command count, suite count, load failure count,
    missing reference count, and asset registry coverage. The focused checker
    validates seven profiles, seven validation assets, seven suites, 49
    commands, zero baseline load failures, zero baseline missing references,
    Mobile-only filtering, injected load failures across all seven profiles,
    injected missing references across all seven profiles, dependency graph
    wiring, parallel schedule wiring, Horde/CI registration, runbook coverage,
    TODO evidence, and gates for load success, missing-reference-free output,
    suite coverage, and command coverage.
- [x] **72.3.2.12** Implement cook report (total cook time, per-asset breakdown,
      largest assets, cache hit rate)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-cook-report.json`,
    `V2/ue/Tools/plan-v2-cook-report.py`,
    `V2/ue/Build/Cooking/v2-cook-validation.json`,
    `V2/ue/Build/Cooking/v2-parallel-cooking.json`,
    `V2/ue/Build/Cooking/v2-incremental-cooking.json`,
    `V2/docs/asset-pipeline/cook-report.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-cook-report.py`. The manifest defines a
    post-validation cook report fed by the parallel schedule, validation report,
    incremental plan, and cooked root, with report policy for total cook time,
    per-asset breakdowns, largest assets, cache hit rate, profile breakdowns,
    deterministic ordering, and descending largest-asset sorting. The sample
    metrics cover seven cooked assets across texture, shader, material, mesh,
    audio, animation, and level-world work, including cook time, cooked size,
    profile ID, and cache-hit state, with six cache hits and a 512 MiB
    level-arena-main largest-asset sample. The planner deterministically emits
    `v2.contentCooking.cookReportPlan.v1` output with seven per-asset rows,
    total cook time, total cooked size, cache hit and miss counts, cache hit
    rate percentage, top largest assets, profile breakdown, release evidence at
    `$(ArchiveRoot)/Cooking/cook-report.json`, largest-assets report output,
    cache report output, and metrics for generated reports, total time,
    per-asset count, largest asset count, cache hit rate, and total cooked size.
    The focused checker validates 102.6 seconds total cook time, 1035.1 MiB
    total cooked size, seven per-asset rows, five largest assets, six cache
    hits, one cache miss, 85.71% cache hit rate, descending largest-asset
    ordering with level-arena-main first, deterministic output, custom metrics
    file ingestion, validation/parallel/incremental manifest links, Horde/CI
    registration, runbook coverage, TODO evidence, and gates for generated
    reports, total time recording, per-asset breakdowns, largest assets, and
    cache hit rate.
- [x] **72.3.2.13** Create platform cooking profiles (PC Ultra, PC Low, PS5,
      Xbox Series X, Xbox Series S, Switch, Mobile)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-platform-cooking-profiles.json`,
    `V2/ue/Tools/plan-v2-platform-cooking-profiles.py`,
    `V2/ue/Build/Cooking/v2-content-cooking-architecture.json`,
    `V2/docs/asset-pipeline/platform-cooking-profiles.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-platform-cooking-profiles.py`. The manifest defines
    the required platform cooking profile matrix in architecture order:
    PCUltra/PC Ultra, PCLow/PC Low, PS5, XSX/Xbox Series X, XSS/Xbox Series S,
    Switch2/Switch, and Mobile. Each profile includes target platforms, cache
    namespace, texture format, mesh tier, audio tier, shader targets, animation
    compression tier, world chunk size, and memory budget, covering Win64,
    Linux, PS5, XSX, XSS, Switch2, Android, and iOS outputs. The matrix captures
    BC7, ASTC, Nanite, reduced mesh, Opus, platform-native audio, DXIL, SPIR-V,
    PS5, MSL, ACL, console, reduced, Switch, and mobile profile variants, with
    release evidence at `$(ArchiveRoot)/Cooking/platform-cooking-profiles.json`.
    The planner deterministically normalizes the matrix, supports profile
    filtering, emits display names, cache namespaces, profile counts, console
    profile counts, Mobile profile counts, cache namespace counts, and coverage
    metrics. The focused checker validates all seven profiles, four console
    profiles, one Mobile profile, seven cache namespaces, exact display names
    for Xbox Series X, Xbox Series S, Switch, and Mobile, architecture profile
    ordering, Mobile filtering, Horde/CI registration, runbook coverage, TODO
    evidence, and gates for profile generation, profile coverage, console
    coverage, Mobile coverage, and cache namespace coverage.
- [x] **72.3.2.14** Implement cook server (headless daemon that watches source
      assets and cooks on change, serving hot assets to editor)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-cook-server.json`,
    `V2/ue/Tools/serve-v2-cook-server.py`,
    `V2/ue/Build/Cooking/v2-incremental-cooking.json`,
    `V2/ue/Build/Cooking/v2-parallel-cooking.json`,
    `V2/ue/Build/Cooking/v2-cook-validation.json`,
    `V2/ue/Build/Cooking/v2-cook-report.json`,
    `V2/docs/asset-pipeline/cook-server.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-cook-server.py`. The manifest defines a headless
    cook-on-change daemon requiring Python and `UnrealEditor-Cmd`, watching
    texture, mesh, audio, shader, animation, material, and level source roots,
    debouncing changes, queueing up to 1024 changes, using all available cores,
    and serving hot assets to editor clients from
    `$(ArchiveRoot)/Cooking/HotAssets`. The pipeline integrates source-change
    detection, incremental cook planning, dependency closure, parallel cook
    scheduling, cooked asset validation, hot asset publishing, and cook report
    updates. Editor endpoint coverage includes `/healthz`, `/cook/changed`,
    `/hot-assets/{assetId}`, `/invalidate`, and `/metrics`, with a dry-run plan
    plus `ThreadingHTTPServer` handler support for health, metrics, and hot
    asset metadata. The server planner deterministically emits
    `v2.contentCooking.cookServerPlan.v1` output with host, port, debounce,
    watch roots, editor endpoints, pipeline steps, queued changes, hot asset
    root, metrics output, and metrics for generated plans, watch root count,
    endpoint count, hot asset serving, and pipeline step count. The focused
    checker validates seven watch roots, five editor endpoints, seven pipeline
    steps, two sample queued changes, enabled hot asset serving, headless
    cook-on-change flags, deterministic dry-run output, host/port/event
    overrides, Horde/CI registration, runbook coverage, TODO evidence, and gates
    for plan generation, watch root coverage, endpoint coverage, hot asset
    serving, and pipeline coverage.
- [x] **72.3.2.15** Create cook CI integration (nightly full cook, per-commit
      incremental cook, cook size regression alerts)
  - Evidence: Implemented and validated by
    `V2/ue/Build/Cooking/v2-cook-ci-integration.json`,
    `V2/ue/Tools/plan-v2-cook-ci-integration.py`,
    `.github/workflows/v2-cook-ci.yml`,
    `V2/ue/Build/Cooking/v2-cook-server.json`,
    `V2/ue/Build/Cooking/v2-cook-report.json`,
    `V2/ue/Build/Cooking/v2-platform-cooking-profiles.json`,
    `V2/docs/asset-pipeline/cook-ci-integration.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-cook-ci-integration.py`. The manifest defines the CI
    contract for per-commit incremental cooks on push and pull request, nightly
    full cooks on cron `0 8 * * *` and manual dispatch, and cook size regression
    alert checks. Per-commit mode covers dependency graph, incremental plan,
    parallel schedule, validation, report, and size-regression-alert steps;
    nightly mode covers platform profiles, dependency graph, parallel schedule,
    validation, report, and artifact publishing; regression mode covers report,
    baseline comparison, GitHub annotation, and build notification steps. Size
    regression policy compares against
    `$(ArchiveRoot)/Cooking/baselines/cook-report-main.json`, caps total size
    growth at 10%, caps a single-asset regression at 250 MiB, emits
    GitHub-annotation and build-notification alerts, and fails critical
    regressions. Artifact policy retains nightly reports for 30 days, per-commit
    reports for 14 days, and uploads cook, largest-asset, and cache hit reports.
    The planner deterministically emits mode-specific
    `v2.contentCooking.ciIntegrationPlan.v1` evidence with enabled-mode flags,
    validation steps, retention days, size thresholds, alert channels, release
    evidence at `$(ArchiveRoot)/Cooking/cook-ci-integration-plan.json`, and
    metrics for nightly full cooks, per-commit incremental cooks, size
    regression alerts, validation step count, and artifact retention. The
    focused checker validates all three modes, selected-mode filtering, nightly,
    per-commit, and regression mode behavior, workflow triggers and mode
    invocations in `.github/workflows/v2-cook-ci.yml`, Horde/CI registration,
    runbook coverage, TODO evidence, and gates for nightly full cook, per-commit
    incremental cook, size regression alerts, validation-chain coverage, and
    artifact retention.

---

### 72.4 Game DRM & Anti-Tamper Protection

Executable protection for shipped standalone game binaries — distinct from
streaming DRM (Widevine/FairPlay) which already exists.

#### 72.4.1 Game Binary Protection

- [x] **72.4.1.1** Implement executable packing/encryption for game binary
      distribution
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-executable-packing.json`,
    `V2/ue/Tools/plan-v2-executable-packing.py`,
    `V2/docs/drm/executable-packing.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-executable-packing.py`. The manifest defines
    Win64-Shipping, Linux-Shipping, and Mac-Shipping protected binary profiles
    with archive-root input binaries, symbol inputs, protected outputs, signed
    packing manifests, encrypted chunk manifests, AES-256-GCM payload
    encryption, zstd compression, Ed25519 manifest signatures, release KMS
    envelope key wrapping, and protected payload lists. Policy coverage enables
    payload encryption, compression, manifest writing and signing, post-packing
    binary signing handoff, store-wrapping order, crash unwind preservation,
    deterministic simulation isolation, accessibility safe-mode bypass, rollback
    module exclusion, explicit non-anti-debugging scope, and security review.
    The planner deterministically emits `v2.drm.executablePackingPlan.v1` output
    with unique SHA-256 cache keys, package commands, release evidence at
    `$(ArchiveRoot)/DRM/executable-packing-plan.json`, profile filtering, and
    metrics for plan generation, profile count, encrypted profiles, signed
    manifests, crash unwind preservation, deterministic simulation isolation,
    and accessibility bypass. The focused checker validates the manifest,
    planner source, deterministic planner output, Win64 filtering, command
    flags, Horde/CI registration, runbook, DRM decision doc, TODO evidence, and
    gates for generated plans, profile coverage, encryption, signed manifests,
    and crash unwind preservation.
- [x] **72.4.1.2** Create runtime unpacker with integrity verification (detect
      patched bytes in executable memory)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-runtime-unpacker-integrity.json`,
    `V2/ue/Tools/plan-v2-runtime-unpacker-integrity.py`,
    `V2/ue/Build/DRM/v2-executable-packing.json`,
    `V2/docs/drm/runtime-unpacker-integrity.md`,
    `V2/docs/drm/executable-packing.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-runtime-unpacker-integrity.py`. The manifest defines
    Win64-Shipping, Linux-Shipping, and Mac-Shipping runtime unpacker profiles
    that verify signed packing manifests, unwrap release KMS envelopes, decrypt
    AES-256-GCM payloads, map executable pages read/execute, seal post-unpack
    baselines, and start integrity watchdog sampling. Integrity policy derives
    baselines from signed packing manifests, hashes executable text pages with
    SHA-256, detects patched bytes in executable memory, excludes writable data
    pages, performs startup full scans, samples every 45 seconds, enters
    safe-boot offline-only mode on mismatch, avoids crashing on mismatch, emits
    structured telemetry only, preserves crash unwind data, keeps deterministic
    simulation unaffected, preserves accessibility safe-mode bypass, and keeps
    anti-debugging out of this layer. The planner deterministically emits
    `v2.drm.runtimeUnpackerIntegrityPlan.v1` output with runtime modules,
    unpacked module maps, memory baseline manifests, integrity evidence paths,
    unique SHA-256 cache keys, installer commands, profile filtering, release
    evidence at `$(ArchiveRoot)/DRM/runtime-unpacker-integrity-plan.json`, and
    metrics for plan generation, profile count, integrity baselines,
    patched-byte detection, safe-boot response, no-crash response, and startup
    full scans. The focused checker validates the executable-packing dependency,
    manifest, planner source, deterministic planner output, Linux filtering,
    command flags, Horde/CI registration, runbooks, DRM decision doc, TODO
    evidence, and gates for generated plans, profile coverage, integrity
    baselines, patched-byte detection, and safe-boot response.
- [x] **72.4.1.3** Implement code virtualization for critical gameplay logic
      (transform native code into custom bytecode, raising reverse-engineering
      cost)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-code-virtualization.json`,
    `V2/ue/Tools/plan-v2-code-virtualization.py`,
    `V2/ue/Build/DRM/v2-runtime-unpacker-integrity.json`,
    `V2/docs/drm/code-virtualization.md`,
    `V2/docs/drm/runtime-unpacker-integrity.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-code-virtualization.py`. The manifest defines
    shipping-client code virtualization for Win64, Linux, and Mac protected
    builds with `V2CodeVM-BC-v1` custom bytecode and `V2CodeVM` runtime
    integration. Protected segment coverage includes drive gauge evaluation,
    super activation gates, finisher resolution, and match-state finisher
    routing, each mapping native gameplay symbols to bytecode outputs, source
    symbol maps, runtime allowlists, deterministic simulation fixtures, and
    rollback parity fixtures. Policy coverage restricts virtualization to
    critical gameplay logic, transforms native code to custom bytecode, excludes
    editor/debug builds, requires deterministic simulation and rollback parity,
    keeps server-authoritative revalidation, requires human-readable manifests,
    avoids anti-debugging and process/driver inspection in this layer, and
    requires security review. The planner deterministically emits
    `v2.drm.codeVirtualizationPlan.v1` output with protected segments, commands,
    unique SHA-256 cache keys, segment filtering, release evidence at
    `$(ArchiveRoot)/DRM/code-virtualization-plan.json`, and metrics for plan
    generation, segment count, bytecode outputs, determinism fixtures, rollback
    parity fixtures, runtime allowlists, and source symbol maps. The focused
    checker validates runtime unpacker dependencies, source-symbol coverage in
    the referenced C++ files, manifest policy, planner source, deterministic
    planner output, finisher segment filtering, command flags, Horde/CI
    registration, runbooks, DRM decision doc, TODO evidence, and gates for
    generated plans, segment coverage, bytecode output, determinism fixtures,
    and runtime allowlists.
- [x] **72.4.1.4** Create anti-debugging detection (IsDebuggerPresent,
      timing-based detection, hardware breakpoint scanning)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-anti-debugging-detection.json`,
    `V2/ue/Tools/plan-v2-anti-debugging-detection.py`,
    `V2/ue/Build/DRM/v2-code-virtualization.json`,
    `V2/docs/drm/anti-debugging-detection.md`,
    `V2/docs/drm/code-virtualization.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-anti-debugging-detection.py`. The manifest defines
    shipping-client anti-debugging detection for Win64-Shipping, Linux-Shipping,
    and Mac-Shipping protected binaries with platform debugger presence,
    timing-based detection, and hardware breakpoint scanning signal families.
    Win64 coverage includes the `IsDebuggerPresent` label, and every profile
    emits archive-root configuration and evidence outputs. Response policy
    enters safe-boot offline-only mode on detection, avoids crashing the
    process, emits structured telemetry only, requires manual review before
    penalty, allows support override, preserves accessibility safe-mode bypass,
    and sets a 0.1% false-positive budget. Layer policy excludes debug/editor
    builds, avoids process scanning, driver inspection, and kernel drivers in
    this layer, and requires privacy and security review. The planner
    deterministically emits `v2.drm.antiDebuggingDetectionPlan.v1` output with
    configuration commands, unique SHA-256 cache keys, profile filtering,
    release evidence at `$(ArchiveRoot)/DRM/anti-debugging-detection-plan.json`,
    and metrics for plan generation, platform coverage, signal family coverage,
    safe responses, no-crash responses, and false-positive guardrails. The
    focused checker validates the code-virtualization dependency, manifest
    policy, planner source, deterministic planner output, Win64 filtering,
    command flags, Horde/CI registration, runbooks, DRM decision doc, TODO
    evidence, and gates for generated plans, platform coverage, signal-family
    coverage, safe response, and false-positive guardrails.
- [x] **72.4.1.5** Implement license verification system (validate ownership via
      platform API — Steam, EGS, platform store)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-license-verification.json`,
    `V2/ue/Tools/plan-v2-license-verification.py`,
    `V2/ue/Build/DRM/v2-anti-debugging-detection.json`,
    `V2/docs/drm/license-verification.md`,
    `V2/docs/drm/anti-debugging-detection.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-license-verification.py`. The manifest defines the
    `v2.drm.licenseVerification.v1` release contract for Steam,
    EpicGamesStore/EGS, Microsoft Store, Mac App Store, PlayStation Store, Xbox
    Store, and Nintendo eShop providers. Every provider declares a platform API,
    launch-profile coverage, ownership checks, signed receipt requirements,
    server-side entitlement mirroring, platform-account binding, archive-root
    evidence output, and a handoff to `TODOS.phase-72.72.4.1.6` for offline
    caching rather than granting offline play directly. Failure policy enters
    safe-boot offline-only mode, avoids crashing, shows a repair prompt,
    disables ranked access, blocks progression grants until verification, and
    allows support override. The planner deterministically emits
    `v2.drm.licenseVerificationPlan.v1` output with unique SHA-256 cache keys,
    provider filtering, configuration commands, release evidence at
    `$(ArchiveRoot)/DRM/license-verification-plan.json`, and metrics for plan
    generation, provider coverage, platform API coverage, ownership checks,
    signed receipts, server mirrors, and safe failure. The focused checker
    validates the anti-debugging dependency, manifest policy, planner source,
    deterministic planner behavior, provider filtering, command flags, Horde/CI
    registration, runbooks, DRM decision doc, TODO evidence, and gates for plan
    generation, provider coverage, platform API coverage, signed receipts, and
    safe failure.
- [x] **72.4.1.6** Create offline license caching (allow play without internet
      for N days after last verification)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-offline-license-cache.json`,
    `V2/ue/Tools/plan-v2-offline-license-cache.py`,
    `V2/ue/Build/DRM/v2-license-verification.json`,
    `V2/docs/drm/offline-license-cache.md`,
    `V2/docs/drm/license-verification.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-offline-license-cache.py`. The manifest defines the
    `v2.drm.offlineLicenseCache.v1` contract for Steam, EpicGamesStore/EGS,
    Microsoft Store, Mac App Store, PlayStation Store, Xbox Store, and Nintendo
    eShop offline caches. Each provider allows play without internet only after
    successful online verification, caps the window at 7 days, writes an
    archive-root cache artifact, encrypts the cache at rest, binds it to the
    device and platform account, requires signed receipt fingerprints, enforces
    monotonic clock checks and server revocation floors, and refreshes only on
    reconnect. Expiry policy safe-boots to a repair prompt, disables offline
    play on expiry, disables ranked play while offline, queues progression
    grants until online verification, and does not crash on cache failure. The
    planner deterministically emits `v2.drm.offlineLicenseCachePlan.v1` output
    with unique SHA-256 cache keys, provider filtering, configuration commands,
    release evidence at `$(ArchiveRoot)/DRM/offline-license-cache-plan.json`,
    and metrics for plan generation, provider coverage, max offline window,
    encrypted device-bound caches, expiry guardrails, and reconnect refresh. The
    focused checker validates the license-verification dependency, manifest
    policy, planner source, deterministic planner behavior, provider filtering,
    command flags, Horde/CI registration, runbooks, TODO evidence, and gates for
    plan generation, provider coverage, max-window days, encrypted device-bound
    caches, and expiry guardrails.
- [x] **72.4.1.7** Implement integrity checking for game data files (hash
      verification on load, detect tampered assets)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-game-data-integrity.json`,
    `V2/ue/Tools/plan-v2-game-data-integrity.py`,
    `V2/ue/Build/DRM/v2-offline-license-cache.json`, `V2/ue/Build/Build.xml`,
    `V2/docs/drm/game-data-integrity.md`,
    `V2/docs/drm/offline-license-cache.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-game-data-integrity.py`. The manifest defines the
    `v2.drm.gameDataIntegrity.v1` contract for Win64, PS5, XSX, Switch2, and
    dedicated-server shipping profiles, using SHA-256 hash verification during
    the on-load phase. It covers Pak archives, IoStore containers, cooked asset
    registry files, shader code libraries, localization bundles, and server
    cooked data with source globs, signed manifests, per-chunk hashes, startup
    baseline verification, streaming chunk verification, tampered asset
    detection, and archive-root evidence outputs. Mismatch policy safe-boots to
    repair behavior, avoids crashing, disables online and ranked play, and
    blocks progression grants until verified repair. The planner
    deterministically emits `v2.drm.gameDataIntegrityPlan.v1` output with unique
    SHA-256 cache keys, surface filtering, configuration commands, release
    evidence at `$(ArchiveRoot)/DRM/game-data-integrity-plan.json`, and metrics
    for plan generation, surface coverage, on-load hash verification, tamper
    detection, signed manifests, per-chunk hashes, safe mismatch responses, and
    startup baselines. The focused checker validates the offline-license-cache
    dependency, BuildGraph package surfaces, manifest policy, planner source,
    deterministic planner behavior, surface filtering, command flags, Horde/CI
    registration, runbooks, DRM decision doc, TODO evidence, and gates for plan
    generation, surface coverage, on-load hash verification, tamper detection,
    and safe mismatch response.
- [x] **72.4.1.8** Create anti-tamper telemetry (report detected tampering
      attempts without crashing — gather intelligence)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-anti-tamper-telemetry.json`,
    `V2/ue/Tools/plan-v2-anti-tamper-telemetry.py`,
    `V2/ue/Build/DRM/v2-game-data-integrity.json`,
    `V2/ue/Build/DRM/v2-anti-debugging-detection.json`,
    `V2/ue/Build/DRM/v2-license-verification.json`,
    `V2/ue/Build/DRM/v2-offline-license-cache.json`,
    `V2/docs/drm/anti-tamper-telemetry.md`, `V2/docs/telemetry/README.md`,
    `V2/docs/legal/privacy-policy.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-anti-tamper-telemetry.py`. The manifest defines the
    `v2.drm.antiTamperTelemetry.v1` contract for structured telemetry on
    executable packing, runtime unpacker integrity, code virtualization,
    anti-debugging detection, license verification, offline license cache, and
    game data integrity sources. Each source reports detected tampering attempts
    to `v2.security.drm.anti_tamper` using event schema
    `v2.drm.anti_tamper_event.v1`, writes archive-root evidence, avoids crashes
    on report failure, gathers intelligence only, blocks automatic penalties,
    and requires manual review before penalty. Payload policy is privacy-safe,
    requires PII redaction, forbids raw account identifiers, uses canonical
    event bus delivery, rate-limits reports, retries with backoff, and encrypts
    the offline queue. The planner deterministically emits
    `v2.drm.antiTamperTelemetryPlan.v1` output with unique SHA-256 cache keys,
    source filtering, configuration commands, release evidence at
    `$(ArchiveRoot)/DRM/anti-tamper-telemetry-plan.json`, and metrics for plan
    generation, source coverage, detected-tamper reports, non-crashing
    reporting, privacy-safe payloads, delivery guardrails, and manual review.
    The focused checker validates game-data-integrity and anti-debugging
    dependencies, telemetry/privacy docs, manifest policy, planner source,
    deterministic planner behavior, source filtering, command flags, Horde/CI
    registration, runbooks, TODO evidence, and gates for plan generation, source
    coverage, non-crashing reporting, privacy redaction, and delivery
    guardrails.
- [x] **72.4.1.9** Implement game binary signing (code signing for Windows,
      macOS notarization, Linux AppImage signing)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-game-binary-signing.json`,
    `V2/ue/Tools/plan-v2-game-binary-signing.py`,
    `V2/ue/Build/DRM/v2-executable-packing.json`,
    `V2/ue/Build/DRM/v2-anti-tamper-telemetry.json`,
    `V2/docs/drm/game-binary-signing.md`, `V2/docs/drm/executable-packing.md`,
    `V2/docs/drm/anti-tamper-telemetry.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-game-binary-signing.py`. The manifest defines the
    `v2.drm.gameBinarySigning.v1` release contract to sign after DRM packing for
    Windows Authenticode, macOS Developer ID/notarytool/stapling, and Linux
    AppImage detached signature targets. Every target declares archive-root
    protected inputs, signed outputs, release evidence, certificate or key
    custody profile, signing tool, timestamp requirements, signature
    verification, unsigned-artifact blocking, and key-custody requirements. The
    Windows target requires RFC3161 timestamped Authenticode signing, the macOS
    target requires notarization and a stapled ticket, and the Linux target
    requires AppImage signature coverage with a release GPG key. The planner
    deterministically emits `v2.drm.gameBinarySigningPlan.v1` output with unique
    SHA-256 cache keys, target filtering, configuration commands, release
    evidence at `$(ArchiveRoot)/DRM/game-binary-signing-plan.json`, and metrics
    for plan generation, platform target coverage, signature verification, key
    custody, unsigned artifact blocking, platform-specific requirements, and
    timestamping. The focused checker validates executable-packing and
    anti-tamper-telemetry dependencies, manifest policy, planner source,
    deterministic planner behavior, target filtering, command flags, Horde/CI
    registration, runbooks, DRM decision doc, TODO evidence, and gates for plan
    generation, platform coverage, signature verification, key custody, and
    platform-specific signing requirements.
- [x] **72.4.1.10** Create DRM impact benchmarking (measure startup time and
      runtime overhead of protection, ensure <1% FPS impact)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-drm-impact-benchmarking.json`,
    `V2/ue/Tools/plan-v2-drm-impact-benchmarking.py`,
    `V2/ue/Tools/run-v2-drm-impact-benchmark.py`,
    `V2/ue/Build/DRM/v2-game-binary-signing.json`,
    `V2/docs/drm/drm-impact-benchmarking.md`,
    `V2/docs/drm/game-binary-signing.md`, `V2/docs/qa/README.md`,
    `V2/docs/drm-decision.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-drm-impact-benchmarking.py`. The manifest defines the
    `v2.drm.impactBenchmarking.v1` release contract for Win64, macOS, and Linux
    AppImage protected-vs-unprotected benchmarks using signed artifacts from the
    game binary signing stage. Each benchmark measures startup time and runtime
    overhead, compares protected and baseline artifacts, uses 30 samples after
    three warmup runs, caps FPS impact at 1.0%, gates 95th percentile frame time
    at 18 ms, caps startup overhead at 750 ms, and writes archive-root evidence.
    Policy fails release above the one-percent FPS-impact threshold and requires
    signed builds, release evidence, performance review, and security review.
    The planner deterministically emits `v2.drm.impactBenchmarkingPlan.v1`
    output with unique SHA-256 cache keys, benchmark filtering, run commands,
    release evidence at `$(ArchiveRoot)/DRM/drm-impact-benchmarking-plan.json`,
    and metrics for plan generation, platform coverage, startup measurement
    coverage, runtime overhead coverage, protected-vs-unprotected comparison
    coverage, and maximum allowed FPS impact. The focused checker validates the
    game-binary-signing dependency, QA performance documentation, manifest
    policy, planner source, deterministic planner behavior, benchmark filtering,
    command flags, Horde/CI registration, runbooks, DRM decision doc, TODO
    evidence, and gates for plan generation, platform coverage, startup
    coverage, runtime-overhead coverage, and FPS impact under one percent.
- [x] **72.4.1.11** Implement DRM removal pathway (strip protection for
      post-support-lifecycle or DRM-free store releases)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-drm-removal-pathway.json`,
    `V2/ue/Tools/plan-v2-drm-removal-pathway.py`,
    `V2/ue/Tools/run-v2-drm-removal.py`,
    `V2/ue/Build/DRM/v2-drm-impact-benchmarking.json`,
    `V2/ue/Build/DRM/v2-game-binary-signing.json`,
    `V2/ue/Build/DRM/v2-game-data-integrity.json`,
    `V2/docs/drm/drm-removal-pathway.md`,
    `V2/docs/drm/drm-impact-benchmarking.md`,
    `V2/docs/drm/game-binary-signing.md`, `V2/docs/drm/game-data-integrity.md`,
    `V2/docs/drm-decision.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-drm-removal-pathway.py`. The manifest defines the
    `v2.drm.removalPathway.v1` release contract for post-support-lifecycle
    DRM-free releases and DRM-free store releases across Win64, Mac, and Linux.
    Each pathway uses signed artifacts as source inputs, strips executable
    packing, disables the runtime unpacker, disables code virtualization hooks,
    removes anti-debugging signals, disables the boot license gate, preserves
    optional platform entitlements, preserves binary signing and game data
    integrity, verifies protected features are absent, benchmarks the DRM-free
    artifact, writes archive-root evidence, and requires release approval. The
    policy requires publishing, security, platform, legal, and fair-play
    sign-off plus a rollback plan. The planner deterministically emits
    `v2.drm.removalPathwayPlan.v1` output with unique SHA-256 cache keys,
    pathway filtering, removal commands, release evidence at
    `$(ArchiveRoot)/DRM/drm-removal-pathway-plan.json`, and metrics for plan
    generation, pathway coverage, platform coverage, strip-protection coverage,
    signing/integrity preservation, DRM-free validation, and approval
    guardrails. The focused checker validates impact-benchmarking,
    game-binary-signing, and game-data-integrity dependencies, manifest policy,
    planner source, deterministic planner behavior, pathway filtering, command
    flags, Horde/CI registration, runbooks, DRM decision doc, TODO evidence, and
    gates for plan generation, removal-pathway coverage, protection stripping,
    signing/integrity preservation, DRM-free validation, and approval
    guardrails.
- [x] **72.4.1.12** Create DRM A/B testing infrastructure (measure whether DRM
      affects sales/piracy rates)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-drm-ab-testing.json`,
    `V2/ue/Tools/plan-v2-drm-ab-testing.py`,
    `V2/ue/Tools/run-v2-drm-ab-test.py`,
    `V2/ue/Build/DRM/v2-drm-removal-pathway.json`,
    `V2/ue/Build/DRM/v2-drm-impact-benchmarking.json`,
    `V2/ue/Build/DRM/v2-anti-tamper-telemetry.json`,
    `V2/docs/drm/drm-ab-testing.md`, `V2/docs/drm/drm-removal-pathway.md`,
    `V2/docs/drm/drm-impact-benchmarking.md`,
    `V2/docs/drm/anti-tamper-telemetry.md`, `V2/docs/telemetry/README.md`,
    `V2/docs/legal/privacy-policy.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-drm-ab-testing.py`. The manifest defines the
    `v2.drm.abTesting.v1` contract for StorefrontDRMFreeCohort and
    PostSupportLifecycleRemovalCohort experiments that measure sales impact and
    piracy-rate proxy impact with protected-vs-DRM-free variants. Each
    experiment uses storefront-region-day assignment, 50/50 ProtectedDRM and
    DRMFree cohort weights, archive-root artifact sources, aggregate storefront
    sales metrics, anti-tamper piracy proxy metrics, minimum sample size 10000,
    28-day analysis windows, 95 percent confidence reporting, privacy-preserving
    aggregation, no raw PII export, pre-registration, anti-tamper telemetry
    proxying, impact-benchmarking confound checks, rollback runbooks, public
    result outputs, and archive-root evidence. Policy requires legal privacy
    review, publishing approval, security review, public summaries, rollback
    plans, and human review. The planner deterministically emits
    `v2.drm.abTestingPlan.v1` output with unique SHA-256 cache keys, experiment
    filtering, run commands, release evidence at
    `$(ArchiveRoot)/DRM/drm-ab-testing-plan.json`, and metrics for plan
    generation, experiment coverage, protected-vs-DRM-free variant coverage,
    sales metric coverage, piracy metric coverage, privacy guardrails,
    anti-tamper proxy coverage, and confound checks. The focused checker
    validates DRM-removal, impact-benchmarking, and anti-tamper-telemetry
    dependencies, telemetry/privacy docs, manifest policy, planner source,
    deterministic planner behavior, experiment filtering, command flags,
    Horde/CI registration, runbooks, DRM decision doc, TODO evidence, and gates
    for plan generation, experiment coverage, variant coverage, sales metrics,
    piracy metrics, and privacy guardrails.
- [x] **72.4.1.13** Implement third-party DRM integration API (Denuvo, custom)
      as pluggable module
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-third-party-drm-integration-api.json`,
    `V2/ue/Tools/plan-v2-third-party-drm-integration-api.py`,
    `V2/ue/Tools/configure-v2-third-party-drm-provider.py`,
    `V2/ue/Build/DRM/v2-executable-packing.json`,
    `V2/ue/Build/DRM/v2-license-verification.json`,
    `V2/ue/Build/DRM/v2-anti-tamper-telemetry.json`,
    `V2/ue/Build/DRM/v2-game-binary-signing.json`,
    `V2/ue/Build/DRM/v2-drm-impact-benchmarking.json`,
    `V2/ue/Build/DRM/v2-drm-removal-pathway.json`,
    `V2/ue/Build/DRM/v2-drm-ab-testing.json`,
    `V2/docs/drm/third-party-drm-integration-api.md`, `V2/docs/drm-decision.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-third-party-drm-integration-api.py`. The manifest
    defines the `v2.drm.thirdPartyIntegrationApi.v1` pluggable provider contract
    with `IV2ThirdPartyDrmProvider` and eight interface methods: initialize,
    prepare build, protect binary, bind license verification, verify runtime
    integrity, emit tamper telemetry, strip protection, and shutdown provider.
    It registers DenuvoAntiTamper through `V2DrmProviderDenuvo` and
    CustomAntiTamperProvider through `V2DrmProviderCustom` for Win64, Mac, and
    Linux targets. Both providers are pluggable modules that protect binaries,
    bind license verification, emit tamper telemetry, support removal pathways,
    impact benchmarking, and A/B testing, keep vendor SDK secrets out of the
    repository, load SDK inputs from secure CI secrets, isolate deterministic
    simulation, and require release evidence under the archive root. The planner
    deterministically emits `v2.drm.thirdPartyIntegrationPlan.v1` output with
    unique SHA-256 cache keys, provider filtering, configuration commands,
    release evidence at
    `$(ArchiveRoot)/DRM/third-party-drm-integration-api-plan.json`, and metrics
    for plan generation, provider coverage, interface method coverage, pluggable
    module coverage, secret isolation, and release guardrails. The focused
    checker validates the executable-packing, license-verification,
    anti-tamper-telemetry, game-binary-signing, impact-benchmarking,
    removal-pathway, and DRM A/B testing dependencies, manifest policy, planner
    source, deterministic planner behavior, provider filtering, command flags,
    Horde/CI registration, runbooks, DRM decision doc, TODO evidence, and gates
    for plan generation, provider coverage, interface coverage, pluggable module
    coverage, secret isolation, and release guardrails.
- [x] **72.4.1.14** Create DRM documentation covering threat model, protection
      scope, and known limitations
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-drm-documentation.json`,
    `V2/ue/Tools/plan-v2-drm-documentation.py`,
    `V2/ue/Tools/validate-v2-drm-documentation.py`,
    `V2/docs/drm/drm-documentation.md`, `V2/docs/drm-decision.md`,
    `V2/docs/drm/executable-packing.md`,
    `V2/docs/drm/runtime-unpacker-integrity.md`,
    `V2/docs/drm/code-virtualization.md`,
    `V2/docs/drm/anti-debugging-detection.md`,
    `V2/docs/drm/license-verification.md`,
    `V2/docs/drm/offline-license-cache.md`,
    `V2/docs/drm/game-data-integrity.md`,
    `V2/docs/drm/anti-tamper-telemetry.md`,
    `V2/docs/drm/game-binary-signing.md`,
    `V2/docs/drm/drm-impact-benchmarking.md`,
    `V2/docs/drm/drm-removal-pathway.md`, `V2/docs/drm/drm-ab-testing.md`,
    `V2/docs/drm/third-party-drm-integration-api.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-drm-documentation.py`. The manifest defines the
    `v2.drm.documentation.v1` contract for the complete DRM documentation
    inventory, including the decision doc and every protection runbook. It
    requires ThreatModel, ProtectionScope, KnownLimitations, and
    OperationalGuardrails sections with archive-root evidence outputs. Threat
    topics cover launch-window piracy, tampered executables, patched memory,
    tampered assets, ownership bypass, and debugging or reverse engineering.
    Scope topics cover executable packing, runtime unpacker integrity, code
    virtualization, anti-debugging detection, license verification, offline
    license cache, game data integrity, anti-tamper telemetry, game binary
    signing, and third-party provider adapters. Known limitations document that
    DRM is not anti-cheat, does not stop all piracy, can add startup overhead,
    compatibility risk, privacy constraints, and uses a removal pathway.
    Guardrails require security review, legal review, publishing approval, and
    privacy review, while policy requires the decision doc link, third-party
    provider documentation, removal-pathway documentation, impact-benchmarking
    documentation, anti-tamper telemetry privacy documentation, and no
    overstated protection claims. The planner deterministically emits
    `v2.drm.documentationPlan.v1` output with unique SHA-256 cache keys, section
    filtering, validation commands, release evidence at
    `$(ArchiveRoot)/DRM/drm-documentation-plan.json`, and metrics for plan
    generation, doc inventory, threat topics, protection scope topics,
    limitations, and review guardrails. The focused checker validates dependency
    manifest schemas, required docs, manifest policy, planner source,
    deterministic planner behavior, section filtering, Horde/CI registration,
    runbook content, TODO evidence, and gates for plan generation, doc
    inventory, threat model coverage, protection scope coverage, known
    limitations coverage, and review guardrails.
- [x] **72.4.1.15** Implement DRM automated testing (verify game functions
      correctly with and without protection enabled)
  - Evidence: Implemented and validated by
    `V2/ue/Build/DRM/v2-drm-automated-testing.json`,
    `V2/ue/Tools/plan-v2-drm-automated-testing.py`,
    `V2/ue/Tools/run-v2-drm-automation.py`,
    `V2/ue/Source/V2Tests/Private/Launch/DRMAutomatedTesting.spec.cpp`,
    `V2/ue/Build/DRM/v2-drm-documentation.json`,
    `V2/ue/Build/DRM/v2-third-party-drm-integration-api.json`,
    `V2/ue/Build/DRM/v2-drm-removal-pathway.json`,
    `V2/ue/Build/DRM/v2-drm-impact-benchmarking.json`,
    `V2/ue/Build/DRM/v2-game-binary-signing.json`,
    `V2/ue/Build/DRM/v2-game-data-integrity.json`,
    `V2/docs/drm/drm-automated-testing.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-drm-automated-testing.py`. The manifest defines the
    `v2.drm.automatedTesting.v1` release contract that verifies game functions
    correctly with and without protection enabled. It declares ProtectedDRM and
    UnprotectedDRMFree build modes with archive-root artifact roots, then runs
    BootAndStartupParity, GameplaySmokeParity, OnlineEntitlementParity,
    PersistenceTelemetryParity, and RemovalPathwayRegression suites in both
    modes through Gauntlet automation. Functional journeys cover BootToMainMenu,
    StartupProfileLoad, TrainingModeSmoke, ArcadeMatchSmoke, LocalVersusSmoke,
    OnlineEntitlementHandshake, OfflineLicenseBoot, SaveLoadRoundTrip,
    SettingsRoundTrip, TelemetryDelivery, DRMFreeArtifactBoot, and
    TamperSafeBoot. Policy requires protected and unprotected coverage, game
    function parity, Gauntlet automation, the automation spec, deterministic
    replay, offline boot, online entitlement checks, safe failure, no-crash
    behavior, release evidence, security review, and QA signoff. The planner
    deterministically emits `v2.drm.automatedTestingPlan.v1` output with unique
    SHA-256 cache keys, suite filtering, automation commands, release evidence
    at `$(ArchiveRoot)/DRM/drm-automated-testing-plan.json`, and metrics for
    plan generation, build-mode coverage, suite coverage, protected/unprotected
    matrix coverage, functional journey coverage, and evidence count. The
    focused checker validates documentation, third-party integration, removal
    pathway, impact benchmarking, game binary signing, and game data integrity
    dependencies, the automation spec, manifest policy, planner source,
    deterministic planner behavior, suite filtering, Horde/CI registration,
    runbook content, TODO evidence, and gates for plan generation, build-mode
    coverage, suite coverage, protected/unprotected matrix coverage,
    game-function coverage, and release evidence.

---

### 72.5 Game Telemetry & Analytics Pipeline

End-to-end player behavior analytics: event taxonomy, ingestion, warehousing,
dashboards, and ML-powered insights.

#### 72.5.1 Telemetry SDK & Ingestion

- [x] **72.5.1.1** Design game event taxonomy (standard event types: session
      start/end, level load, death, achievement, purchase, UI interaction,
      error)
  - Evidence: implemented by
    `V2/ue/Content/V2/Telemetry/GameEventTaxonomy_V2_Contract.json`,
    `V2/docs/telemetry/game-event-taxonomy.md`,
    `V2/ue/Source/V2Telemetry/Private/V2TelemetryBlueprintLibrary.cpp`,
    `V2/ue/Source/V2Tests/Automation/Telemetry.Module.spec.cpp`,
    `libs/shared/event-bus/src/types.ts`,
    `libs/shared/event-bus/src/types.d.ts`,
    `libs/shared/event-bus/src/topic-registry.ts`,
    `libs/shared/event-bus/src/topic-registry.spec.ts`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-game-event-taxonomy.py`. The contract defines the
    `v2.telemetry.gameEventTaxonomy.v1` task contract for
    `TODOS.phase-72.72.5.1.1`, publishes through `@oshun/event-bus`, fixes the
    canonical `v2.player.*`, `v2.match.*`, and `v2.cosmetic.*` namespace
    prefixes, requires past-tense topic names and `snake_case` payload fields,
    strips PII at ingest, rejects raw account identifiers, and standardizes on
    `account_id_hash`. The standard taxonomy covers the eight required event
    types: Session Start, Session End, Level Load, Death, Achievement, Purchase,
    UI Interaction, and Error with canonical topics, reliability classes, and
    required payload fields. The focused checker validates the contract, Unreal
    telemetry defaults, Unreal automation spec coverage, shared event-bus type
    and topic registration, documentation, CI workflow registration, and Horde
    gates for contract presence, standard event coverage, topic registration,
    PII-safe fields, and CI wiring.
- [x] **72.5.1.2** Implement client-side telemetry SDK in Rust (low-overhead
      event buffering, batched transmission, offline queueing)
  - Evidence: implemented by the `maya-telemetry-sdk` Rust crate at
    `libs/maya/engine-core/crates/maya-telemetry-sdk`, the crate workspace
    registration in `libs/maya/engine-core/Cargo.toml`,
    `V2/ue/Build/Telemetry/v2-client-telemetry-sdk-rust.json`,
    `V2/docs/telemetry/client-telemetry-sdk-rust.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-client-telemetry-sdk-rust.py`. The SDK exposes
    `TelemetrySdk`, `TelemetrySdkConfig`, `TelemetryEvent`, `TelemetryBatch`,
    and the caller-provided `TelemetryTransport`, keeps the hot buffer and
    offline queue bounded with `max_buffered_events` and `offline_queue_limit`,
    drains batches with `max_batch_events` and `max_batch_bytes`, and replays
    failed sends through `mark_batch_failed`, `drain_offline_batch`, and
    `flush_with` without creating background threads or sockets. It also exports
    the eight Phase 72 standard topics, validates their required fields when
    `validate_standard_topics` is enabled, and rejects forbidden raw identity
    fields before events enter live or offline queues. Verification:
    `cargo check --manifest-path libs/maya/engine-core/Cargo.toml -p maya-telemetry-sdk --all-targets`,
    `cargo test --manifest-path libs/maya/engine-core/Cargo.toml -p maya-telemetry-sdk`
    (11 unit tests),
    `python3 V2/ue/Tools/check-v2-client-telemetry-sdk-rust.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.3** Create telemetry event schema with versioning (protobuf or
      FlatBuffers for compact wire format)
  - Evidence: implemented by
    `V2/ue/Build/Telemetry/v2-telemetry-event-schema.json`,
    `V2/ue/Build/Telemetry/v2-telemetry-event-schema.proto`,
    `libs/maya/engine-core/crates/maya-telemetry-sdk/src/wire.rs`,
    `libs/maya/engine-core/crates/maya-telemetry-sdk/src/lib.rs`,
    `V2/docs/telemetry/telemetry-event-schema.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-event-schema.py`. The contract standardizes
    protobuf as the compact wire format under package `oshun.v2.telemetry.v1`
    with `TelemetryEventBatch`, `TelemetryEvent`, and `TelemetryField` messages.
    Each batch carries `wire_schema_major`, `wire_schema_minor`,
    `wire_schema_patch`, and `min_reader_schema_major`; the current version is
    `1.0.0` with additive field-number compatibility and reserved protobuf
    ranges for future schema passes. The Rust SDK exposes
    `encode_batch_protobuf`, `decode_batch_protobuf`,
    `TelemetryWireSchemaVersion`, protobuf schema constants, and
    `TelemetryBatch::to_protobuf_bytes`, while validating topic shape,
    standard-topic required fields, and forbidden PII payload keys. The wire
    tests prove compact protobuf round trips, a stable version header,
    unsupported-major rejection, unknown-field skipping for forward
    compatibility, and missing-standard-field rejection. Verification:
    `cargo check --manifest-path libs/maya/engine-core/Cargo.toml -p maya-telemetry-sdk --all-targets`,
    `cargo test --manifest-path libs/maya/engine-core/Cargo.toml -p maya-telemetry-sdk`
    (11 unit tests), `python3 V2/ue/Tools/check-v2-telemetry-event-schema.py`,
    and `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.4** Implement server-side telemetry ingestion endpoint (accept
      batched events, validate schema, write to queue)
  - Evidence: implemented by the `@v2/telemetry-ingestion` package in
    `V2/services/telemetry-ingestion`, the endpoint contract
    `V2/ue/Build/Telemetry/v2-telemetry-ingestion-endpoint.json`,
    `V2/docs/telemetry/telemetry-ingestion-endpoint.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-ingestion-endpoint.py`. The package exports
    `createTelemetryIngestionEndpoint` and `handleTelemetryIngestionRequest` for
    framework-neutral mounting of `POST /v2/telemetry/ingest`, accepts
    `application/json`, `application/x-protobuf`, `application/protobuf`, and
    `application/octet-stream`, decodes `TelemetryEventBatch` payloads,
    validates wire schema `1.0.0`, enforces standard-topic required fields,
    rejects forbidden payload keys, and writes accepted batches through the
    `TelemetryQueue` adapter to `v2-telemetry-firehose`. Unit coverage verifies
    JSON ingestion, protobuf ingestion with payload preservation, unknown-field
    skipping for additive protobuf compatibility, unsupported-schema rejection,
    forbidden-field rejection, missing-required-field rejection, and no queue
    writes on invalid batches. Verification:
    `pnpm --filter @v2/telemetry-ingestion run typecheck`,
    `pnpm --filter @v2/telemetry-ingestion run test` (6 tests),
    `pnpm --filter @v2/telemetry-ingestion run lint`,
    `pnpm --filter @v2/telemetry-ingestion run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-ingestion-endpoint.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.5** Create telemetry data pipeline (Kafka/Kinesis → transform →
      data warehouse — ClickHouse, BigQuery, or Redshift)
  - Evidence: implemented by the `@v2/telemetry-data-pipeline` package in
    `V2/services/telemetry-data-pipeline`, the pipeline contract
    `V2/ue/Build/Telemetry/v2-telemetry-data-pipeline.json`,
    `V2/docs/telemetry/telemetry-data-pipeline.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-data-pipeline.py`. The package consumes
    `TelemetryStreamEnvelope` messages from the `v2-telemetry-firehose` source
    queue through `TelemetryPipelineSource`, supports Kafka and Kinesis envelope
    construction, validates each `TelemetryEventBatch`, transforms events into
    deterministic `TelemetryWarehouseRow` records with transform schema version
    `1`, stable payload JSON, `payloadSha256`, source offsets, ingest and
    transform timestamps, and `accountIdHash`, strips forbidden raw identity
    fields, and writes through `TelemetryWarehouseSink` adapters targeting
    `warehouse.v2_telemetry.events` for ClickHouse, BigQuery, and Redshift. Unit
    coverage verifies Kafka transforms, Kinesis transforms, multi-target
    warehouse writes, source acknowledgements after successful writes,
    dead-lettering invalid batches before warehouse writes, dead-lettering
    unconfigured sink targets, and forbidden-field sanitization. Verification:
    `pnpm --filter @v2/telemetry-data-pipeline run typecheck`,
    `pnpm --filter @v2/telemetry-data-pipeline run test` (6 tests),
    `pnpm --filter @v2/telemetry-data-pipeline run lint`,
    `pnpm --filter @v2/telemetry-data-pipeline run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-data-pipeline.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.6** Implement player session reconstruction from events (timeline
      of all actions in a session)
  - Evidence: implemented by the `@v2/telemetry-session-reconstruction` package
    in `V2/services/telemetry-session-reconstruction`, the reconstruction
    contract `V2/ue/Build/Telemetry/v2-telemetry-session-reconstruction.json`,
    `V2/docs/telemetry/telemetry-session-reconstruction.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-session-reconstruction.py`. The service
    reads governed `TelemetryWarehouseRow` records from
    `warehouse.v2_telemetry.events`, groups by `sessionId`, orders timelines by
    `sequence`, `eventUnixSeconds`, and `eventId`, reconstructs
    `ReconstructedPlayerSession` documents for
    `warehouse.v2_telemetry.player_sessions`, records source event IDs,
    start/end boundaries, inferred times, duration, topic counts, platforms,
    build IDs, and the full player action timeline. It records anomalies for
    missing session start/end, duplicate starts/ends, sequence gaps, duplicate
    sequences, clock regressions, malformed payload JSON, payload session ID
    mismatches, and changing account hashes without dropping auditable timeline
    entries. Unit coverage verifies deterministic timeline reconstruction,
    multi-session grouping, reconstructed-document writes and checkpointing,
    boundary and ordering anomaly detection, malformed payload preservation,
    stable replay sorting, sink table validation, and sorted session batches.
    Verification:
    `pnpm --filter @v2/telemetry-session-reconstruction run typecheck`,
    `pnpm --filter @v2/telemetry-session-reconstruction run test` (7 tests),
    `pnpm --filter @v2/telemetry-session-reconstruction run lint`,
    `pnpm --filter @v2/telemetry-session-reconstruction run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-session-reconstruction.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.7** Create telemetry consent and privacy compliance (GDPR opt-in,
      CCPA opt-out, data retention policies, PII redaction)
  - Evidence: implemented by the `@v2/telemetry-privacy-compliance` package in
    `V2/services/telemetry-privacy-compliance`, the privacy contract
    `V2/ue/Build/Telemetry/v2-telemetry-privacy-compliance.json`,
    `V2/docs/telemetry/telemetry-privacy-compliance.md`,
    `V2/services/telemetry-privacy-compliance/README.md`,
    `V2/docs/telemetry/README.md`, `V2/docs/legal/privacy-policy.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-privacy-compliance.py`. The service composes
    the Aphrodite consent surface with telemetry ingestion payload rules,
    evaluates GDPR-region explicit opt-in for optional telemetry, applies
    CCPA/CPRA Do-Not-Sell/Share suppression for behavioral telemetry, persists
    `Privacy.TelemetryOptOut` behavior while preserving required operational
    telemetry, assigns the `v2-telemetry-privacy-retention-v1` retention policy
    with 7-day operational, 30-day optional, and 14-day behavioral windows, and
    redacts ingestion-forbidden plus telemetry-specific PII fields with the
    `drop-forbidden-fields` mode. Unit coverage verifies GDPR opt-in acceptance
    and rejection paths, CCPA opt-out suppression, persisted telemetry opt-out,
    required operational telemetry preservation when consent is denied, extended
    PII redaction, deterministic region/data-class resolution, and Aphrodite
    consent plus retention plan construction. Verification:
    `pnpm --filter @v2/telemetry-privacy-compliance run typecheck`,
    `pnpm --filter @v2/telemetry-privacy-compliance run test` (8 tests),
    `pnpm --filter @v2/telemetry-privacy-compliance run lint`,
    `pnpm --filter @v2/telemetry-privacy-compliance run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-privacy-compliance.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.8** Implement telemetry rate limiting and sampling (reduce volume
      for high-frequency events in production)
  - Evidence: implemented by the `@v2/telemetry-rate-limiting` package in
    `V2/services/telemetry-rate-limiting`, the rate limit contract
    `V2/ue/Build/Telemetry/v2-telemetry-rate-limiting.json`,
    `V2/docs/telemetry/telemetry-rate-limiting.md`,
    `V2/services/telemetry-rate-limiting/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-rate-limiting.py`. The service implements
    `filterTelemetryBatchByRateLimitAndSampling`,
    `InMemoryTelemetryRateLimiter`, deterministic per-session sample assignment
    with salt `v2-telemetry-session-sampling-v1`, deterministic event sampling
    from session/topic/event ID, per-session/topic token buckets, default
    300-events-per-minute and 60-event burst limits, and topic overrides for UI
    interactions, level loads, deaths, and achievements. Critical override
    topics `v2.match.crash.reported`, `v2.player.cheat-detection.detected`, and
    `v2.player.error.reported` bypass sampling and rate limits. Unit coverage
    verifies deterministic 1-100 percent session sample assignment,
    deterministic event sampling, token bucket limits, bucket refill, critical
    bypass behavior, sampled-out events not consuming tokens, topic override
    resolution, default fallback policies, and accepted-batch/drop-decision
    handoff records. Verification:
    `pnpm --filter @v2/telemetry-rate-limiting run typecheck`,
    `pnpm --filter @v2/telemetry-rate-limiting run test` (8 tests),
    `pnpm --filter @v2/telemetry-rate-limiting run lint`,
    `pnpm --filter @v2/telemetry-rate-limiting run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-rate-limiting.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.9** Create telemetry schema migration tooling (add new event
      types without breaking existing pipelines)
  - Evidence: implemented by the `@v2/telemetry-schema-migrations` package in
    `V2/services/telemetry-schema-migrations`, the migration contract
    `V2/ue/Build/Telemetry/v2-telemetry-schema-migrations.json`,
    `V2/docs/telemetry/telemetry-schema-migrations.md`,
    `V2/services/telemetry-schema-migrations/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-schema-migrations.py`. The tooling provides
    `TelemetrySchemaRegistry`, `createTelemetrySchemaMigrationPlan`,
    `validateTelemetrySchemaMigrationPlan`,
    `assertTelemetrySchemaMigrationPlan`,
    `applyTelemetrySchemaMigrationsToBatch`, and migration reports under the
    `v2-telemetry-schema-migrations-additive-v1` additive-only policy. It
    accepts add-event-type, add-optional-field, deprecate-field, and
    document-field operations, forbids `remove-required-field`, rejects wire
    major bumps in the V1 pipeline, enforces
    `minReaderSchemaMajor <= target wire major`, verifies
    reader/warehouse/ingestion release gates, preserves reader-compatible wire
    versions by default, and can emit the target minor version only when readers
    have rolled out. Unit coverage verifies additive plan creation,
    breaking-plan rejection, optional field default application, target minor
    emission, standard schema registry population, duplicate schema rejection,
    migration report generation, invalid-plan exceptions, and schema version
    comparison/formatting. Verification:
    `pnpm --filter @v2/telemetry-schema-migrations run typecheck`,
    `pnpm --filter @v2/telemetry-schema-migrations run test` (9 tests),
    `pnpm --filter @v2/telemetry-schema-migrations run lint`,
    `pnpm --filter @v2/telemetry-schema-migrations run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-schema-migrations.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.10** Implement telemetry debug mode (verbose logging of all
      events during development, disabled in release)
  - Evidence: implemented by the `@v2/telemetry-debug-mode` package in
    `V2/services/telemetry-debug-mode`, the debug-mode contract
    `V2/ue/Build/Telemetry/v2-telemetry-debug-mode.json`,
    `V2/docs/telemetry/telemetry-debug-mode.md`,
    `V2/services/telemetry-debug-mode/README.md`, `V2/docs/telemetry/README.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-debug-mode.py`. The package provides
    `debugTelemetryBatch`, `debugTelemetryEvent`, `MemoryTelemetryDebugSink`,
    `resolveTelemetryDebugModeConfig`, `createTelemetryDebugRecord`,
    `sanitizeTelemetryDebugPayload`, and `formatTelemetryDebugRecord` under the
    `v2-telemetry-debug-mode-dev-only-v1` policy. It logs every event in enabled
    development/test/QA/staging builds, hard-disables release, production, and
    shipping builds with `release-build-disabled`, returns `debug-mode-disabled`
    when not requested, supports metadata-only records via
    `includePayload: false`, redacts forbidden/sensitive payload fields, and
    truncates long string payload values before deterministic single-line log
    formatting. Unit coverage verifies verbose development logging,
    release-build hard disable, disabled development decisions, payload
    redaction and truncation, metadata-only records, production alias handling,
    deterministic line formatting, and custom sensitive-field detection.
    Verification: `pnpm --filter @v2/telemetry-debug-mode run typecheck`,
    `pnpm --filter @v2/telemetry-debug-mode run test` (8 tests),
    `pnpm --filter @v2/telemetry-debug-mode run lint`,
    `pnpm --filter @v2/telemetry-debug-mode run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-debug-mode.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.11** Create telemetry event replay (re-ingest historical events
      through updated pipeline)
  - Evidence: implemented by the `@v2/telemetry-event-replay` package in
    `V2/services/telemetry-event-replay`, the replay contract
    `V2/ue/Build/Telemetry/v2-telemetry-event-replay.json`,
    `V2/docs/telemetry/telemetry-event-replay.md`,
    `V2/services/telemetry-event-replay/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-event-replay.py`. The package provides
    `runTelemetryEventReplayOnce`, `buildTelemetryReplayBatchesFromRows`,
    `reconstructTelemetryEventFromWarehouseRow`,
    `TelemetryIngestionEndpointReplayTarget`, `MemoryTelemetryReplaySource`, and
    `MemoryTelemetryReplayTarget` under the
    `v2-telemetry-event-replay-reingest-v1` policy. It reads historical
    `TelemetryWarehouseRow` records from `warehouse.v2_telemetry.events`,
    verifies payload SHA-256 hashes, reconstructs `TelemetryEvent` records while
    preserving event IDs, builds deterministic offline replay batches with
    producer `v2-telemetry-event-replay`, chunks by `maxEventsPerReplayBatch`,
    re-ingests through `/v2/telemetry/ingest` and `v2-telemetry-firehose`,
    dead-letters invalid rows, and marks valid rows replayed. Unit coverage
    verifies historical event reconstruction, deterministic source-batch
    grouping, chunking, successful source-to-target replay, invalid-row
    dead-lettering, ingestion endpoint submission, payload hash validation, and
    scalar-only payload parsing. Verification:
    `pnpm --filter @v2/telemetry-event-replay run typecheck`,
    `pnpm --filter @v2/telemetry-event-replay run test` (7 tests),
    `pnpm --filter @v2/telemetry-event-replay run lint`,
    `pnpm --filter @v2/telemetry-event-replay run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-event-replay.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.12** Implement telemetry data export API (researchers/analysts
      can query raw events)
  - Evidence: implemented by the `@v2/telemetry-data-export-api` package in
    `V2/services/telemetry-data-export-api`, the governed export contract
    `V2/ue/Build/Telemetry/v2-telemetry-data-export-api.json`,
    `V2/docs/telemetry/telemetry-data-export-api.md`,
    `V2/services/telemetry-data-export-api/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-data-export-api.py`. The package provides
    `createTelemetryDataExportApi`, `handleTelemetryDataExportRequest`,
    `queryTelemetryDataExport`, `MemoryTelemetryDataExportSource`,
    `assertTelemetryDataExportAuthorized`,
    `applyTelemetryDataExportPrincipalConstraints`,
    `formatTelemetryDataExportJsonLines`, `encodeTelemetryDataExportCursor`, and
    `decodeTelemetryDataExportCursor` under the
    `v2-telemetry-data-export-governed-v1` policy. The API exposes
    `GET /v2/telemetry/export/events` over `warehouse.v2_telemetry.events`,
    requires researcher, analyst, or admin roles plus an approved purpose,
    applies topic and account-hash scopes, filters by topic, session ID, account
    hash, and event time, returns stable cursor-paginated raw events, supports
    JSON and JSON Lines output, preserves `payloadJson`, and blocks forbidden
    raw identifier payload fields before export. Unit coverage verifies approved
    researcher queries, stable opaque cursor pagination, unauthorized and
    missing-purpose rejection, principal scope enforcement, JSON Lines payload
    preservation, HTTP export handling, and forbidden raw identifier blocking.
    Verification: `pnpm --filter @v2/telemetry-data-export-api run typecheck`,
    `pnpm --filter @v2/telemetry-data-export-api run test` (7 tests),
    `pnpm --filter @v2/telemetry-data-export-api run lint`,
    `pnpm --filter @v2/telemetry-data-export-api run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-data-export-api.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.13** Create client-side performance telemetry (FPS, frame time
      histogram, GPU/CPU load, memory usage per session)
  - Evidence: implemented by the `@v2/client-performance-telemetry` package in
    `V2/services/client-performance-telemetry`, the client performance telemetry
    contract `V2/ue/Build/Telemetry/v2-client-performance-telemetry.json`,
    `V2/docs/telemetry/client-performance-telemetry.md`,
    `V2/services/client-performance-telemetry/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-client-performance-telemetry.py`. The package provides
    `ClientPerformanceTelemetryCollector`,
    `createClientPerformanceTelemetryEvent`,
    `createClientPerformanceTelemetryBatch`,
    `calculateClientPerformanceSummary`, `createFrameTimeHistogram`, and
    deterministic event IDs under the `v2-client-performance-telemetry-v1`
    policy. It buffers bounded per-session client samples, emits
    `v2.client.performance.sampled` telemetry events and normal
    `TelemetryEventBatch` records, and records `avg_fps`, `min_fps`, `max_fps`,
    `p50_frame_time_ms`, `p95_frame_time_ms`, `p99_frame_time_ms`,
    `max_frame_time_ms`, `frame_time_histogram_json`, `avg_cpu_load_percent`,
    `avg_gpu_load_percent`, `avg_memory_used_mib`, `peak_memory_used_mib`, and
    `memory_budget_mib`. Unit coverage verifies frame-time histograms and
    percentiles, validated event payload fields, bounded collector flushing,
    valid telemetry batch creation, invalid sample rejection, and session
    mismatch rejection. Verification:
    `pnpm --filter @v2/client-performance-telemetry run typecheck`,
    `pnpm --filter @v2/client-performance-telemetry run test` (5 tests),
    `pnpm --filter @v2/client-performance-telemetry run lint`,
    `pnpm --filter @v2/client-performance-telemetry run build`,
    `python3 V2/ue/Tools/check-v2-client-performance-telemetry.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.14** Implement telemetry integration tests (verify events flow
      from client → pipeline → warehouse)
  - Evidence: implemented by the `@v2/telemetry-integration-tests` package in
    `V2/services/telemetry-integration-tests`, the integration-test contract
    `V2/ue/Build/Telemetry/v2-telemetry-integration-tests.json`,
    `V2/docs/telemetry/telemetry-integration-tests.md`,
    `V2/services/telemetry-integration-tests/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-integration-tests.py`. The package provides
    `runTelemetryClientToWarehouseIntegration` under the
    `v2-telemetry-client-to-warehouse-integration-v1` policy. The harness posts
    client `TelemetryEventBatch` records to `createTelemetryIngestionEndpoint`,
    verifies accepted batches are queued through `MemoryTelemetryQueue` on
    `v2-telemetry-firehose`, wraps queued batches with
    `makeKafkaTelemetryEnvelope`, runs `runTelemetryDataPipelineOnce`, and
    inspects `MemoryTelemetryWarehouseSink` rows for
    `warehouse.v2_telemetry.events`. Integration coverage verifies standard
    client UI events flow through ingestion, firehose, transform, and warehouse,
    client performance telemetry (`v2.client.performance.sampled`) flows through
    the same path, and invalid client batches are rejected before reaching
    warehouse rows. Verification:
    `pnpm --filter @v2/telemetry-integration-tests run typecheck`,
    `pnpm --filter @v2/telemetry-integration-tests run test` (3 tests),
    `pnpm --filter @v2/telemetry-integration-tests run lint`,
    `pnpm --filter @v2/telemetry-integration-tests run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-integration-tests.py`, and
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`.
- [x] **72.5.1.15** Create telemetry SDK documentation and event catalog
  - Evidence: implemented by the SDK-facing event catalog contract
    `V2/ue/Build/Telemetry/v2-telemetry-sdk-event-catalog.json`,
    `V2/docs/telemetry/telemetry-sdk-event-catalog.md`,
    `V2/docs/telemetry/client-telemetry-sdk-rust.md`,
    `V2/docs/telemetry/game-event-taxonomy.md`, `V2/docs/telemetry/README.md`,
    `libs/maya/engine-core/crates/maya-telemetry-sdk/src/lib.rs`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-telemetry-sdk-event-catalog.py`. The catalog applies
    the `v2-telemetry-sdk-event-catalog-v1` policy, keeps
    `GameEventTaxonomy_V2_Contract.json` as the source vocabulary, maps all
    eight standard events to `maya-telemetry-sdk` topic constants, required
    payload fields, reliability modes, and minimal example payloads, and
    documents producer rules for `TelemetryEvent::new`, `with_value`,
    `TelemetrySdkConfig.validate_standard_topics`, `TelemetryTransport`, and
    `FORBIDDEN_PAYLOAD_FIELDS`. The SDK source exposes the matching constants,
    `STANDARD_TOPICS`, `STANDARD_TOPIC_REQUIRED_FIELDS`, forbidden field checks,
    and `validate_standard_event` so producer docs and runtime validation stay
    aligned. Verification:
    `python3 V2/ue/Tools/check-v2-telemetry-sdk-event-catalog.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-telemetry-sdk-event-catalog.json`,
    `cargo check --manifest-path libs/maya/engine-core/Cargo.toml -p maya-telemetry-sdk --all-targets`,
    and
    `cargo test --manifest-path libs/maya/engine-core/Cargo.toml -p maya-telemetry-sdk`
    (11 tests).

#### 72.5.2 Analytics Dashboards & Insights

- [x] **72.5.2.1** Create real-time player count dashboard (concurrent players
      by region, game mode, platform)
  - Evidence: implemented by the `@v2/realtime-player-count-dashboard` package
    in `V2/services/realtime-player-count-dashboard`, the dashboard contract
    `V2/ue/Build/Telemetry/v2-realtime-player-count-dashboard.json`,
    `V2/docs/telemetry/realtime-player-count-dashboard.md`,
    `V2/services/realtime-player-count-dashboard/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-realtime-player-count-dashboard.py`. The package
    builds an operational off-rollback dashboard surface with
    `buildV2RealtimePlayerCountDashboardSurface`, backed by
    `@iris/analytics-realtime` and the `v2-realtime-player-count-dashboard-v1`
    policy. It keeps the latest sample per region/game-mode/platform segment,
    reports total concurrent, matchmaking, and in-match players, emits region,
    game-mode, platform, segment, peak-segment, and realtime widget snapshots,
    labels feeds as `fresh`, `stale`, or `empty`, and emits spike alerts for
    high concurrency. Unit coverage verifies total and segmented player counts,
    latest-sample selection, stale-feed and spike-alert behavior, duplicate
    segment rejection, invalid count rejection, and empty-feed handling. The
    `@iris/analytics-realtime` project metadata now includes the repo-standard
    `type:lib` tag so the dashboard dependency passes Nx module-boundary lint.
    Verification:
    `pnpm --filter @v2/realtime-player-count-dashboard run typecheck`,
    `pnpm --filter @v2/realtime-player-count-dashboard run test` (6 tests),
    `pnpm --filter @v2/realtime-player-count-dashboard run lint`,
    `pnpm --filter @v2/realtime-player-count-dashboard run build`,
    `pnpm --filter @iris/analytics-realtime run lint`,
    `pnpm --filter @iris/analytics-realtime run test` (8 tests),
    `pnpm --filter @iris/analytics-realtime run build`,
    `python3 V2/ue/Tools/check-v2-realtime-player-count-dashboard.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-realtime-player-count-dashboard.json`.
- [x] **72.5.2.2** Implement player behavior heatmaps (positional data → 2D/3D
      density maps showing where players go, die, linger)
  - Evidence: implemented by the `@v2/player-behavior-heatmaps` package in
    `V2/services/player-behavior-heatmaps`, the heatmaps contract
    `V2/ue/Build/Telemetry/v2-player-behavior-heatmaps.json`,
    `V2/docs/telemetry/player-behavior-heatmaps.md`,
    `V2/services/player-behavior-heatmaps/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-player-behavior-heatmaps.py`. The package builds
    `buildV2PlayerBehaviorHeatmapsSurface` under the
    `v2-player-behavior-heatmaps-v1` policy, composes
    `@galatea/analytics/heatmap-engine` for 2D movement and dwell grids, and
    adds V2 death overlays, linger overlays, 3D voxel densities, top death and
    linger cells, movement/death/linger sample counts, map row/column/z-slice
    metadata, and operator modes for `movement`, `death`, and `linger`. Outputs
    use `playerIdHash` internally but expose no raw player IDs or raw trajectory
    points. Unit coverage verifies 2D/3D movement, death, and linger density
    maps, window filtering, out-of-bounds rejection, invalid linger rejection,
    and empty-window behavior without raw trajectory output. The dependent
    `@galatea/analytics` lint gate is clean after preserving caught JSON parse
    errors as `cause` in its Shopify/Square webhook parsers. Verification:
    `pnpm --filter @v2/player-behavior-heatmaps run typecheck`,
    `pnpm --filter @v2/player-behavior-heatmaps run test` (5 tests),
    `pnpm --filter @v2/player-behavior-heatmaps run lint`,
    `pnpm --filter @v2/player-behavior-heatmaps run build`,
    `pnpm exec nx lint @galatea/analytics`,
    `pnpm exec nx test @galatea/analytics`,
    `pnpm exec nx build @galatea/analytics`,
    `python3 V2/ue/Tools/check-v2-player-behavior-heatmaps.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-player-behavior-heatmaps.json`.
- [x] **72.5.2.3** Create session funnel analysis (new player flow: tutorial →
      first mission → open world → first purchase, with drop-off rates)
  - Evidence: implemented by the `@v2/session-funnel-analysis` package in
    `V2/services/session-funnel-analysis`, the funnel contract
    `V2/ue/Build/Telemetry/v2-session-funnel-analysis.json`,
    `V2/docs/telemetry/session-funnel-analysis.md`,
    `V2/services/session-funnel-analysis/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-session-funnel-analysis.py`. The package builds
    `buildV2SessionFunnelAnalysisSurface` and the canonical
    `createV2NewPlayerFunnelDefinition` under the
    `v2-session-funnel-analysis-v1` policy, composes `@iris/analytics-funnel`
    for ordered journey analysis, drop-off classification, and chart-ready
    visualization, and tracks the tutorial, first mission, open world, and first
    purchase event sequence for `v2-new-player-session-funnel`. Outputs include
    step entrants, conversions to the next step, conversion rates, drop-off
    counts, drop-off rates, drop-off reasons, and visualization bars while using
    `accountIdHash` and exposing no raw account IDs. Unit coverage verifies the
    full tutorial to first-purchase funnel, timeout and error drop-off
    classification, unsupported event rejection, empty-funnel behavior, and
    canonical funnel definition exposure. The `@iris/analytics-funnel` project
    metadata now includes the repo-standard `type:lib` tag so the V2 funnel
    dependency passes Nx module-boundary lint. Verification:
    `pnpm --filter @v2/session-funnel-analysis run typecheck`,
    `pnpm --filter @v2/session-funnel-analysis run test` (5 tests),
    `pnpm --filter @v2/session-funnel-analysis run lint`,
    `pnpm --filter @v2/session-funnel-analysis run build`,
    `pnpm --filter @iris/analytics-funnel run lint`,
    `pnpm --filter @iris/analytics-funnel run test` (8 tests),
    `pnpm --filter @iris/analytics-funnel run build`,
    `python3 V2/ue/Tools/check-v2-session-funnel-analysis.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-session-funnel-analysis.json`.
- [x] **72.5.2.4** Implement retention cohort analysis (day-1, day-7, day-30
      retention curves segmented by acquisition source)
  - Evidence: implemented by the `@v2/retention-cohort-analysis` package in
    `V2/services/retention-cohort-analysis`, the retention contract
    `V2/ue/Build/Telemetry/v2-retention-cohort-analysis.json`,
    `V2/docs/telemetry/retention-cohort-analysis.md`,
    `V2/services/retention-cohort-analysis/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-retention-cohort-analysis.py`. The package builds
    `buildV2RetentionCohortAnalysisSurface` under the
    `v2-retention-cohort-analysis-v1` policy, composes `@iris/analytics-cohort`
    for daily cohort construction, retention point calculation, behavior
    comparisons, and cohort reports, and segments day-1, day-7, and day-30
    retention curves by acquisition source. It uses the earliest
    `v2.player.account.created` event per `accountIdHash` as the cohort start
    and acquisition source, treats `v2.player.session.started`,
    `v2.player.session.activity`, and `v2.cosmetic.purchased` as retained
    activity, excludes immature cohorts from target summaries while preserving
    chart points marked as immature, and exposes aggregate curves without raw
    account IDs. Unit coverage verifies day-1/day-7/day-30 curves by acquisition
    source, immature cohort exclusion, earliest-signup source selection,
    unsupported event rejection, and empty-surface behavior. The
    `@iris/analytics-cohort` project metadata now includes the repo-standard
    `type:lib` tag so the V2 retention dependency passes Nx module-boundary
    lint. Verification:
    `pnpm --filter @v2/retention-cohort-analysis run typecheck`,
    `pnpm --filter @v2/retention-cohort-analysis run test` (5 tests),
    `pnpm --filter @v2/retention-cohort-analysis run lint`,
    `pnpm --filter @v2/retention-cohort-analysis run build`,
    `pnpm --filter @iris/analytics-cohort run lint`,
    `pnpm --filter @iris/analytics-cohort run test` (8 tests),
    `pnpm --filter @iris/analytics-cohort run build`,
    `python3 V2/ue/Tools/check-v2-retention-cohort-analysis.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-retention-cohort-analysis.json`.
- [x] **72.5.2.5** Create engagement metrics dashboard (session length
      distribution, sessions per week, time between sessions)
  - Evidence: implemented by the `@v2/engagement-metrics-dashboard` package in
    `V2/services/engagement-metrics-dashboard`, the dashboard contract
    `V2/ue/Build/Telemetry/v2-engagement-metrics-dashboard.json`,
    `V2/docs/telemetry/engagement-metrics-dashboard.md`,
    `V2/services/engagement-metrics-dashboard/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-engagement-metrics-dashboard.py`. The package builds
    `buildV2EngagementMetricsDashboardSurface` under the
    `v2-engagement-metrics-dashboard-v1` policy, consumes
    `v2.player.session.started`, `v2.player.session.ended`, and
    `v2.player.session.activity` telemetry, and emits hashed-account aggregate
    dashboard data for session length distribution, sessions per week, and time
    between sessions without exposing raw account IDs. Unit coverage verifies
    the three requested metric families, shared analysis-window filtering,
    completed-session inference from end-duration telemetry, negative-duration
    rejection, and empty-dashboard behavior. Verification:
    `pnpm --filter @v2/engagement-metrics-dashboard run typecheck`,
    `pnpm --filter @v2/engagement-metrics-dashboard run test` (5 tests),
    `pnpm --filter @v2/engagement-metrics-dashboard run lint`,
    `pnpm --filter @v2/engagement-metrics-dashboard run build`,
    `python3 V2/ue/Tools/check-v2-engagement-metrics-dashboard.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-engagement-metrics-dashboard.json`.
- [x] **72.5.2.6** Implement economy analytics (currency earn/spend rates,
      inflation tracking, item price effectiveness)
  - Evidence: implemented by the `@v2/economy-analytics` package in
    `V2/services/economy-analytics`, the economy telemetry contract
    `V2/ue/Build/Telemetry/v2-economy-analytics.json`,
    `V2/docs/telemetry/economy-analytics.md`,
    `V2/services/economy-analytics/README.md`, `V2/docs/telemetry/README.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-economy-analytics.py`. The package builds
    `buildV2EconomyAnalyticsSurface` under the `v2-economy-analytics-v1` policy,
    anchors to `@maat/finance`, consumes currency earned, currency spent, item
    price change, item impression, and `v2.cosmetic.purchased` telemetry, and
    emits operator-ready currency flow rates, inflation tracking, and item price
    effectiveness metrics without exposing raw account IDs. Unit coverage
    verifies earn/spend rates with net flow, price-index inflation, item
    conversion and revenue metrics, analysis-window filtering, deflation
    detection, negative-amount rejection, and empty-surface behavior.
    Verification: `pnpm --filter @v2/economy-analytics run typecheck`,
    `pnpm --filter @v2/economy-analytics run test` (5 tests),
    `pnpm --filter @v2/economy-analytics run lint`,
    `pnpm --filter @v2/economy-analytics run build`,
    `python3 V2/ue/Tools/check-v2-economy-analytics.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-economy-analytics.json`.
- [x] **72.5.2.7** Create difficulty analytics (per-encounter win/loss rates,
      retry counts, time-to-complete, difficulty spike detection)
  - Evidence: implemented by the `@v2/difficulty-analytics` package in
    `V2/services/difficulty-analytics`, the difficulty telemetry contract
    `V2/ue/Build/Telemetry/v2-difficulty-analytics.json`,
    `V2/docs/telemetry/difficulty-analytics.md`,
    `V2/services/difficulty-analytics/README.md`, `V2/docs/telemetry/README.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-difficulty-analytics.py`. The package builds
    `buildV2DifficultyAnalyticsSurface` under the `v2-difficulty-analytics-v1`
    policy, composes `@iris/analytics-realtime` for spike alert snapshots,
    consumes encounter started, completed, failed, retry, and abandoned
    telemetry, and emits chart-ready win/loss rates, retry counts,
    time-to-complete percentiles, and difficulty spike rows without exposing raw
    account IDs. Unit coverage verifies per-encounter win/loss rates, retry
    metrics, p95 time-to-complete and spike detection, analysis-window
    filtering, duration derivation from matching start events, negative-duration
    and unsupported-event rejection, and empty-surface behavior. Verification:
    `pnpm --filter @v2/difficulty-analytics run typecheck`,
    `pnpm --filter @v2/difficulty-analytics run test` (5 tests),
    `pnpm --filter @v2/difficulty-analytics run lint`,
    `pnpm --filter @v2/difficulty-analytics run build`,
    `python3 V2/ue/Tools/check-v2-difficulty-analytics.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-difficulty-analytics.json`.
- [x] **72.5.2.8** Implement crash analytics dashboard (crash rate by version,
      platform, hardware, top crash stacks)
  - Evidence: implemented by the `@v2/crash-analytics-dashboard` package in
    `V2/services/crash-analytics-dashboard`, the crash dashboard telemetry
    contract `V2/ue/Build/Telemetry/v2-crash-analytics-dashboard.json`,
    `V2/docs/telemetry/crash-analytics-dashboard.md`,
    `V2/services/crash-analytics-dashboard/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-crash-analytics-dashboard.py`. The package builds
    `buildV2CrashAnalyticsDashboardSurface` under the
    `v2-crash-analytics-dashboard-v1` policy, anchors to `@tara/monitoring`,
    consumes V2 session-start and crash-report telemetry, and emits chart-ready
    crash rates by version, platform, and hardware tier plus top crash-stack
    rows without exposing raw account IDs or raw stack traces. Unit coverage
    verifies crash-rate breakdowns, top crash stacks, crashed-session
    deduplication while retaining crash-event volume, analysis-window filtering,
    equivalent raw-stack grouping with path/line sanitization, invalid telemetry
    and unsupported-event rejection, and empty-dashboard behavior. Verification:
    `pnpm --filter @v2/crash-analytics-dashboard run typecheck`,
    `pnpm --filter @v2/crash-analytics-dashboard run test` (6 tests),
    `pnpm --filter @v2/crash-analytics-dashboard run lint`,
    `pnpm --filter @v2/crash-analytics-dashboard run build`,
    `python3 V2/ue/Tools/check-v2-crash-analytics-dashboard.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-crash-analytics-dashboard.json`.
- [x] **72.5.2.9** Create performance analytics (FPS distribution by hardware
      tier, settings preset adoption, hitching frequency)
  - Evidence: implemented by the `@v2/performance-analytics` package in
    `V2/services/performance-analytics`, the performance telemetry contract
    `V2/ue/Build/Telemetry/v2-performance-analytics.json`,
    `V2/docs/telemetry/performance-analytics.md`,
    `V2/services/performance-analytics/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-performance-analytics.py`. The package builds
    `buildV2PerformanceAnalyticsSurface` under the `v2-performance-analytics-v1`
    policy, composes `@v2/client-performance-telemetry`, consumes
    `v2.client.performance.sampled` windows, and emits chart-ready FPS
    distribution by hardware tier, settings preset adoption, and hitching
    frequency without exposing raw account IDs. Unit coverage verifies the three
    requested metric families, FPS derivation from client performance samples,
    analysis-window filtering, hitching frequency from frame-time histograms
    when raw samples are absent, invalid telemetry and unsupported-event
    rejection, and empty-surface behavior. Verification:
    `pnpm --filter @v2/performance-analytics run typecheck`,
    `pnpm --filter @v2/performance-analytics run test` (6 tests),
    `pnpm --filter @v2/performance-analytics run lint`,
    `pnpm --filter @v2/performance-analytics run build`,
    `python3 V2/ue/Tools/check-v2-performance-analytics.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-performance-analytics.json`.
- [x] **72.5.2.10** Implement A/B test analysis pipeline (statistical
      significance testing, effect size estimation, automatic winner detection)
  - Evidence: implemented by the `@v2/ab-test-analysis-pipeline` package in
    `V2/services/ab-test-analysis-pipeline`, the experiment analysis contract
    `V2/ue/Build/Telemetry/v2-ab-test-analysis-pipeline.json`,
    `V2/docs/telemetry/ab-test-analysis-pipeline.md`,
    `V2/services/ab-test-analysis-pipeline/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-ab-test-analysis-pipeline.py`. The package builds
    `buildV2ABTestAnalysisPipelineSurface` under the
    `v2-ab-test-analysis-pipeline-v1` policy, composes `@iris/analytics-ab`,
    consumes hashed-account experiment exposure, conversion, engagement, and
    revenue telemetry, and emits statistical-significance comparisons,
    effect-size estimates, and automatic winner-detection output without
    exposing raw account IDs. Unit coverage verifies statistically significant
    conversion winners, effect-size lift, engagement-score analysis,
    analysis-window filtering, minimum-sample hold behavior, unsupported-event
    and negative-metric rejection, and empty-experiment behavior. The
    `@iris/analytics-ab` project metadata now includes the repo-standard
    `type:lib` tag so the V2 A/B dependency passes Nx module-boundary lint.
    Verification: `pnpm --filter @v2/ab-test-analysis-pipeline run typecheck`,
    `pnpm --filter @v2/ab-test-analysis-pipeline run test` (6 tests),
    `pnpm --filter @v2/ab-test-analysis-pipeline run lint`,
    `pnpm --filter @v2/ab-test-analysis-pipeline run build`,
    `pnpm --filter @iris/analytics-ab run lint`,
    `pnpm --filter @iris/analytics-ab run test` (8 tests),
    `pnpm --filter @iris/analytics-ab run build`,
    `python3 V2/ue/Tools/check-v2-ab-test-analysis-pipeline.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-ab-test-analysis-pipeline.json`.
- [x] **72.5.2.11** Create churn prediction model (ML model predicting which
      players are likely to stop playing in next 7 days)
  - Evidence: implemented by the `@v2/churn-prediction-model` package in
    `V2/services/churn-prediction-model`, the churn model telemetry contract
    `V2/ue/Build/Telemetry/v2-churn-prediction-model.json`,
    `V2/docs/telemetry/churn-prediction-model.md`,
    `V2/services/churn-prediction-model/README.md`,
    `V2/docs/telemetry/README.md`, `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-churn-prediction-model.py`. The package builds
    `buildV2ChurnPredictionModelSurface` under the
    `v2-churn-prediction-model-v1` policy, composes `@iris/analytics` retention
    thresholds, consumes hashed-account account creation, session, activity, and
    cosmetic purchase telemetry, and emits an interpretable logistic-regression
    seven-day churn probability, risk banding, feature-driver attribution, and
    ethical re-engagement recommendations without exposing raw account IDs. The
    contract and docs explicitly forbid paywall-pressure interventions. Unit
    coverage verifies inactive/declining players are scored at risk, active
    stable players remain low risk, session frequency and session length decline
    are exposed as drivers, analysis-window filtering, unsupported-event and
    negative-metric rejection, and empty-surface behavior. Verification:
    `pnpm --filter @v2/churn-prediction-model run typecheck`,
    `pnpm --filter @v2/churn-prediction-model run test` (6 tests),
    `pnpm --filter @v2/churn-prediction-model run lint`,
    `pnpm --filter @v2/churn-prediction-model run build`,
    `python3 V2/ue/Tools/check-v2-churn-prediction-model.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-churn-prediction-model.json`.
- [x] **72.5.2.12** Implement player segmentation (whale/dolphin/minnow,
      explorer/achiever/socializer/killer, custom segments)
  - Evidence: implemented by the `@v2/player-segmentation` package in
    `V2/services/player-segmentation`, the segmentation telemetry contract
    `V2/ue/Build/Telemetry/v2-player-segmentation.json`,
    `V2/docs/telemetry/player-segmentation.md`,
    `V2/services/player-segmentation/README.md`, `V2/docs/telemetry/README.md`,
    `V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `.github/workflows/v2-build.yml`, `V2/ue/Tools/check-v2-ci-workflow.py`, and
    `V2/ue/Tools/check-v2-player-segmentation.py`. The package builds
    `buildV2PlayerSegmentationSurface` under the `v2-player-segmentation-v1`
    policy, composes `@iris/analytics` metric identifiers, consumes
    hashed-account gameplay, spend, progression, exploration, social, and PvP
    telemetry, and assigns spend tiers (`whale`, `dolphin`, `minnow`,
    `non_spender`), motivation segments (`explorer`, `achiever`, `socializer`,
    `killer`), and operator-defined custom rule segments without exposing raw
    account IDs. Unit coverage verifies whale/dolphin/minnow/non-spender spend
    tiers, explorer/achiever/socializer/killer motivations, custom segment
    rules, analysis-window filtering, unsupported-event and negative-value
    rejection, and empty-surface behavior. Verification:
    `pnpm --filter @v2/player-segmentation run typecheck`,
    `pnpm --filter @v2/player-segmentation run test` (6 tests),
    `pnpm --filter @v2/player-segmentation run lint`,
    `pnpm --filter @v2/player-segmentation run build`,
    `python3 V2/ue/Tools/check-v2-player-segmentation.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-player-segmentation.json`.
- [x] **72.5.2.13** Create alerting rules (crash rate spike >2x, player count
      drop >20%, matchmaking wait time >3min)
  - Completed via `@v2/telemetry-alerting-rules`,
    `V2/ue/Build/Telemetry/v2-telemetry-alerting-rules.json`,
    `V2/docs/telemetry/telemetry-alerting-rules.md`, Horde gates, the V2 CI
    workflow, and `check-v2-telemetry-alerting-rules.py`. The
    `buildV2TelemetryAlertingRulesSurface` service composes
    `@iris/analytics-realtime` alert types under
    `v2-telemetry-alerting-rules-v1`, evaluates aggregate crash rate, player
    count, and matchmaking wait samples, and emits deterministic rule
    definitions, evaluations, triggered alerts, summaries, and chart rows
    without raw account IDs. Covered rules are `crash-rate-spike-2x` at `>=2x`
    baseline crash rate, `player-count-drop-20pct` at `>=20%` player count drop,
    and `matchmaking-wait-time-3min` at `>=180s` p95 wait time, with
    latest-sample window filtering and below-threshold inactive behavior. Tests
    cover all three alerts, below-threshold suppression, analysis-window
    filtering, unsupported telemetry and invalid-value rejection, and empty
    surfaces. Verification:
    `pnpm --filter @v2/telemetry-alerting-rules run typecheck`,
    `pnpm --filter @v2/telemetry-alerting-rules run test` (7 tests),
    `pnpm --filter @v2/telemetry-alerting-rules run lint`,
    `pnpm --filter @v2/telemetry-alerting-rules run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-alerting-rules.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-telemetry-alerting-rules.json`.
- [x] **72.5.2.14** Implement data export for external BI tools (Grafana,
      Tableau, Looker connectors)
  - Completed via `@v2/telemetry-bi-export-connectors`,
    `V2/ue/Build/Telemetry/v2-telemetry-bi-export-connectors.json`,
    `V2/docs/telemetry/telemetry-bi-export-connectors.md`, Horde gates, the V2
    CI workflow, and `check-v2-telemetry-bi-export-connectors.py`. The
    `buildV2TelemetryBiExportConnectorsSurface` service composes
    `@v2/telemetry-data-export-api` under
    `v2-telemetry-bi-export-connectors-v1`, preserves the governed
    `v2-telemetry-data-export-governed-v1` export policy, and emits Grafana JSON
    data frames, Tableau Web Data Connector rows/schema, and Looker
    LookML/explore rows for approved aggregate telemetry exports. Connector IDs
    are `grafana-json-dataframe`, `tableau-web-data-connector`, and
    `looker-explore`; outputs expose account ID hashes only, never raw account
    IDs, and surface export audit metadata plus source event counts. Tests cover
    Grafana, Tableau, and Looker payload generation, connector subset selection,
    principal topic scoping, export policy error propagation, unsupported
    connector rejection, and empty export payloads. Verification:
    `pnpm --filter @v2/telemetry-bi-export-connectors run typecheck`,
    `pnpm --filter @v2/telemetry-bi-export-connectors run test` (6 tests),
    `pnpm --filter @v2/telemetry-bi-export-connectors run lint`,
    `pnpm --filter @v2/telemetry-bi-export-connectors run build`,
    `python3 V2/ue/Tools/check-v2-telemetry-bi-export-connectors.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-telemetry-bi-export-connectors.json`.
- [x] **72.5.2.15** Create analytics documentation and self-service query guide
  - Completed via `V2/docs/telemetry/analytics-self-service-query-guide.md`,
    `V2/ue/Build/Telemetry/v2-analytics-self-service-query-guide.json`,
    `V2/docs/telemetry/README.md`, Horde gates, the V2 CI workflow, and
    `check-v2-analytics-self-service-query-guide.py`. The
    `v2-analytics-self-service-query-guide-v1` guide defines the approved
    analyst/researcher access model, data map, privacy guardrails, query
    workflow, SQL templates, BI connector recipes, and review checklist for
    `warehouse.v2_telemetry.events`, `warehouse.v2_telemetry.player_sessions`,
    `@v2/telemetry-data-export-api`, and `@v2/telemetry-bi-export-connectors`.
    It includes recipes for Daily Active Sessions, New Player Funnel, Retention
    Cohort Sketch, Crash Rate By Version, and Matchmaking Wait P95, plus
    guardrails for approved purpose, cursor pagination, account ID hashes,
    forbidden payload fields, no raw account IDs, audit review, and
    Grafana/Tableau/Looker handoff. Verification:
    `python3 V2/ue/Tools/check-v2-analytics-self-service-query-guide.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Build/Telemetry/v2-analytics-self-service-query-guide.json`,
    `pnpm exec prettier --check V2/docs/telemetry/analytics-self-service-query-guide.md V2/docs/telemetry/README.md V2/ue/Build/Telemetry/v2-analytics-self-service-query-guide.json`,
    and `git diff --check`.

---

### 72.6 Profiler Integration (Tracy, RenderDoc, Platform Profilers)

Concrete integration of industry-standard profiling tools into Maya's Rust
engine crates — not abstract "implement profiler" but specific tool bindings.

#### 72.6.1 Tracy Profiler Integration

- [x] **72.6.1.1** Add tracy-client Rust crate dependency to maya-kernel and all
      performance-critical crates
  - Completed via `libs/maya/engine-core/Cargo.toml`,
    `libs/maya/engine-core/Cargo.lock`,
    `V2/ue/Build/Performance/v2-tracy-client-dependencies.json`, Horde gates,
    the V2 CI workflow, and `check-v2-tracy-client-dependencies.py`. The Maya
    engine workspace pins `tracy-client = "0.18.4"` with
    `default-features = false`, and the performance-critical crates
    `maya-kernel`, `maya-renderer`, `maya-physics`, `maya-audio`, `maya-ecs`,
    `maya-jobs`, `maya-world`, `maya-fibers`, `maya-nexus`, `maya-alloc`,
    `maya-math`, `maya-resource`, `maya-scene`, `maya-spatial`, and `maya-time`
    each declare an optional workspace `tracy-client` dependency plus a
    disabled-by-default `tracy` feature containing `dep:tracy-client` and
    `tracy-client/enable`. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-client-dependencies.py`,
    `cargo metadata --manifest-path libs/maya/engine-core/Cargo.toml --format-version 1 --no-deps`,
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-kernel -p maya-renderer -p maya-physics -p maya-audio -p maya-ecs -p maya-jobs -p maya-world -p maya-fibers -p maya-nexus -p maya-alloc -p maya-math -p maya-resource -p maya-scene -p maya-spatial -p maya-time --features maya-kernel/tracy,maya-renderer/tracy,maya-physics/tracy,maya-audio/tracy,maya-ecs/tracy,maya-jobs/tracy,maya-world/tracy,maya-fibers/tracy,maya-nexus/tracy,maya-alloc/tracy,maya-math/tracy,maya-resource/tracy,maya-scene/tracy,maya-spatial/tracy,maya-time/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-client-dependencies.json`.
- [x] **72.6.1.2** Implement Tracy zone macros for all major engine systems
      (renderer, physics, audio, ECS, jobs, world streaming)
  - Completed via the `profiling.rs` macro modules and hot-path call sites in
    `maya-kernel`, `maya-renderer`, `maya-physics`, `maya-audio`, `maya-ecs`,
    `maya-jobs`, and `maya-world`, plus
    `V2/ue/Build/Performance/v2-tracy-zone-macros.json`, Horde gates, the V2 CI
    workflow, and `check-v2-tracy-zone-macros.py`. The per-crate macros
    (`maya_kernel_tracy_zone!`, `maya_renderer_tracy_zone!`,
    `maya_physics_tracy_zone!`, `maya_audio_tracy_zone!`,
    `maya_ecs_tracy_zone!`, `maya_jobs_tracy_zone!`, and
    `maya_world_tracy_zone!`) compile to `tracy_client::span_location!` spans
    when the `tracy` feature is enabled and to no-op guards otherwise. The
    contract validates zones for kernel ticks/dispatch, renderer render-thread
    and render-graph paths, physics callbacks/cloth/SPH steps, audio voice/HRTF
    and granular blocks, ECS spawn/query/migration paths, jobs spawn/scope/wait
    and worker-loop paths, and world streaming pipeline/update queues.
    Verification: `python3 V2/ue/Tools/check-v2-tracy-zone-macros.py`,
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-kernel -p maya-renderer -p maya-physics -p maya-audio -p maya-ecs -p maya-jobs -p maya-world --features maya-kernel/tracy,maya-renderer/tracy,maya-physics/tracy,maya-audio/tracy,maya-ecs/tracy,maya-jobs/tracy,maya-world/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-zone-macros.json`.
- [x] **72.6.1.3** Create Tracy frame mark at main loop boundary (enables
      per-frame timing view)
  - Completed via `maya_kernel_tracy_frame_mark!` in
    `libs/maya/engine-core/crates/maya-kernel/src/profiling.rs`,
    `EngineKernel::tick` in
    `libs/maya/engine-core/crates/maya-kernel/src/lib.rs`,
    `V2/ue/Build/Performance/v2-tracy-frame-mark.json`, Horde gates, the V2 CI
    workflow, and `check-v2-tracy-frame-mark.py`. The macro calls
    `tracy_client::Client::running().frame_mark()` when the `tracy` feature is
    enabled and compiles to a no-op otherwise, and the frame mark is emitted
    inside `EngineKernel::tick` after `self.collect_messages();` and before
    returning `Ok(())`, giving Tracy a stable main-loop frame boundary.
    Verification: `python3 V2/ue/Tools/check-v2-tracy-frame-mark.py`,
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-kernel --features maya-kernel/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-frame-mark.json`.
- [x] **72.6.1.4** Implement Tracy GPU zone integration (correlate GPU work with
      CPU submission points)
  - Completed via `TracyGpuBridge` in
    `libs/maya/engine-core/crates/maya-renderer/src/gpu_profiler.rs`,
    `V2/ue/Build/Performance/v2-tracy-gpu-zone-integration.json`, Horde gates,
    the V2 CI workflow, and `check-v2-tracy-gpu-zone-integration.py`. The
    renderer creates a Tracy GPU context named `maya-renderer-gpu`, wraps frame
    and pass work with `begin_span_alloc`/`end_span`, uploads resolved GPU
    timestamps with `upload_gpu_timestamp`, sorts uploads by
    `TimestampQuery::pool_index`, and surrounds CPU submission points with
    `maya_renderer_tracy_zone!` labels for begin/end frame and begin/end pass
    submission. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-gpu-zone-integration.py`,
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer --features maya-renderer/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-gpu-zone-integration.json`.
- [x] **72.6.1.5** Create Tracy memory tracking for all custom allocators
      (arena, pool, slab — track alloc/free with callstacks)
  - Completed via `maya_alloc::profiling` and allocator integrations in
    `libs/maya/engine-core/crates/maya-alloc/src/profiling.rs`, `bump.rs`,
    `pool.rs`, and `stack.rs`, plus
    `V2/ue/Build/Performance/v2-tracy-memory-tracking.json`, Horde gates, the V2
    CI workflow, and `check-v2-tracy-memory-tracking.py`. The Tracy helper emits
    `___tracy_emit_memory_alloc_callstack_named` and
    `___tracy_emit_memory_free_callstack_named` with callstack depth `16`, while
    bump arenas, pool slabs, stack arenas, and double-ended stack top/bottom
    lanes track allocations under `maya_alloc.bump.arena`,
    `maya_alloc.pool.slab`, `maya_alloc.stack.arena`,
    `maya_alloc.double_stack.bottom`, and `maya_alloc.double_stack.top`.
    Allocation vectors are drained on reset, marker restore/pop, explicit free,
    and drop boundaries so Tracy sees matching frees. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-memory-tracking.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-alloc --features maya-alloc/tracy`
    (94 unit tests and 4 doc tests; rerun with `TRACY_NO_INVARIANT_CHECK=1`
    because this host reports no invariant TSC),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-memory-tracking.json`.
- [x] **72.6.1.6** Implement Tracy lock tracking for all mutexes and rwlocks
      (detect contention hotspots)
  - Completed via `TracyLockContext`, `TracyMutex`, `TracyRwLock`, and
    `TracyParkingMutex` in
    `libs/maya/engine-core/crates/maya-profiler/src/lib.rs`, plus production
    lock substitutions in `maya-plugin-api`, `maya-kernel`, `maya-renderer`,
    `maya-world`, `maya-fibers`, and `maya-events`.
    `V2/ue/Build/Performance/v2-tracy-lock-tracking.json`, Horde gates, the V2
    CI workflow, and `check-v2-tracy-lock-tracking.py` validate the Tracy
    lockable context API calls (`announce`, `before_lock`, `after_lock`,
    `after_unlock`, `after_try_lock`, `terminate`, and custom naming), the
    wrapper types, and production labels including `plugin_api.last_error`,
    `kernel.hot_reload.tracked_files`, `kernel.native_loader.loaded_libraries`,
    `renderer.cluster_stream.inner`, world async operation locks, fiber signal
    wakers, and event channel buffers. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-lock-tracking.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-profiler --features maya-profiler/tracy`
    (14 tests),
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-plugin-api -p maya-kernel -p maya-renderer -p maya-world -p maya-fibers -p maya-events --features maya-plugin-api/tracy,maya-kernel/tracy,maya-renderer/tracy,maya-world/tracy,maya-fibers/tracy,maya-events/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-lock-tracking.json`.
- [x] **72.6.1.7** Create Tracy message logging integration (engine log messages
      appear in Tracy timeline)
  - Completed via `emit_tracy_log_message`, `tracy_message_logging_enabled`, and
    the `maya_tracy_error!`, `maya_tracy_warn!`, `maya_tracy_info!`,
    `maya_tracy_debug!`, and `maya_tracy_trace!` macros in
    `libs/maya/engine-core/crates/maya-profiler/src/lib.rs`, plus engine log
    call-site adoption in `maya-kernel`, `maya-jobs`, and `maya-hot-reload`.
    `V2/ue/Build/Performance/v2-tracy-message-logging.json`, Horde gates, the V2
    CI workflow, and `check-v2-tracy-message-logging.py` validate
    `Client::color_message`, callstack depth `8`, severity colors for
    error/warn/info/debug/trace, direct `log::*` replacement at production
    sites, and Tracy feature propagation through instrumented crates.
    Verification: `python3 V2/ue/Tools/check-v2-tracy-message-logging.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-profiler --features maya-profiler/tracy`
    (14 tests),
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-kernel -p maya-jobs -p maya-hot-reload --features maya-kernel/tracy,maya-jobs/tracy,maya-hot-reload/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-message-logging.json`.
- [x] **72.6.1.8** Implement Tracy plot tracking for key metrics (entity count,
      draw calls, triangle count, physics bodies, audio voices)
  - Completed via `TracyPlotMetric`, `emit_tracy_plot_count`, and
    `emit_tracy_plot_value` in
    `libs/maya/engine-core/crates/maya-profiler/src/lib.rs`, plus metric
    call-sites in `maya-ecs`, `maya-renderer`, `maya-physics`, and `maya-audio`.
    `V2/ue/Build/Performance/v2-tracy-plot-tracking.json`, Horde gates, the V2
    CI workflow, and `check-v2-tracy-plot-tracking.py` validate one-time Tracy
    plot configuration with `Client::plot_config`, `PlotFormat::Number`,
    `PlotLineStyle::Stepped`, `fill(false)`, and `Client::plot` emissions for
    `maya.ecs.entity_count`, `maya.renderer.draw_calls`,
    `maya.renderer.triangle_count`, `maya.physics.body_count`, and
    `maya.audio.voice_count`. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-plot-tracking.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-profiler --features maya-profiler/tracy`
    (14 tests),
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-ecs -p maya-renderer -p maya-physics -p maya-audio --features maya-ecs/tracy,maya-renderer/tracy,maya-physics/tracy,maya-audio/tracy`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-plot-tracking.json`.
- [x] **72.6.1.9** Create Tracy fiber/coroutine tracking for maya-fibers
  - Completed via `maya-fibers` Tracy feature wiring, stable
    `FiberSlot::tracy_name` storage in
    `libs/maya/engine-core/crates/maya-fibers/src/fiber.rs`, and
    `TracyFiberScope::enter` around `FiberExecutor::tick` polling in
    `libs/maya/engine-core/crates/maya-fibers/src/executor.rs`.
    `V2/ue/Build/Performance/v2-tracy-fiber-tracking.json`, Horde gates, the V2
    CI workflow, and `check-v2-tracy-fiber-tracking.py` validate
    `tracy-client/fibers`, stable `maya-fibers`-prefixed `CString` labels,
    `___tracy_fiber_enter`/`___tracy_fiber_leave`, the `Client::running` guard,
    and RAII leave-on-drop behavior around coroutine polls. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-fiber-tracking.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-fibers --features maya-fibers/tracy`
    (31 unit tests and 2 doc tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-fiber-tracking.json`.
- [x] **72.6.1.10** Implement Tracy network profiling for maya-nexus (packet
      rate, bandwidth, RTT)
  - Completed via `maya-nexus` Tracy zones around envelope encode/decode,
    ingress, outbound delivery, and client receive paths; packet throughput
    sampling in `libs/maya/engine-core/crates/maya-nexus/src/profiling.rs`; and
    bandwidth-plan plots from
    `libs/maya/engine-core/crates/maya-nexus/src/bandwidth_adaptation.rs`.
    `V2/ue/Build/Performance/v2-tracy-network-profiling.json`, Horde gates, the
    V2 CI workflow, and `check-v2-tracy-network-profiling.py` validate
    `maya.nexus.packet_rate`, `maya.nexus.bandwidth_kbps`,
    `maya.nexus.planned_packet_rate`, `maya.nexus.planned_bandwidth_kbps`,
    `maya.nexus.available_bandwidth_kbps`, and `maya.nexus.rtt_ms`.
    Verification: `python3 V2/ue/Tools/check-v2-tracy-network-profiling.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-nexus --features maya-nexus/tracy`
    (314 unit tests and 1 doc test),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-network-profiling.json`.
- [x] **72.6.1.11** Create compile-time feature flag to strip all Tracy
      instrumentation in shipping builds (zero overhead)
  - Completed via `shipping` feature declarations, `default = []` Tracy strip
    defaults, dependency shipping-feature propagation, and `shipping+tracy`
    compile guards across the Tracy-capable Maya crates.
    `V2/ue/Build/Performance/v2-tracy-shipping-strip.json`, Horde gates, the V2
    CI workflow, and `check-v2-tracy-shipping-strip.py` validate the guarded
    crate set, guard expression, guard message, default feature stripping, and
    propagation rules. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-shipping-strip.py`,
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-alloc -p maya-audio -p maya-ecs -p maya-events -p maya-fibers -p maya-hot-reload -p maya-jobs -p maya-kernel -p maya-math -p maya-nexus -p maya-physics -p maya-plugin-api -p maya-profiler -p maya-renderer -p maya-resource -p maya-scene -p maya-souls -p maya-spatial -p maya-time -p maya-world --features maya-alloc/shipping,maya-audio/shipping,maya-ecs/shipping,maya-events/shipping,maya-fibers/shipping,maya-hot-reload/shipping,maya-jobs/shipping,maya-kernel/shipping,maya-math/shipping,maya-nexus/shipping,maya-physics/shipping,maya-plugin-api/shipping,maya-profiler/shipping,maya-renderer/shipping,maya-resource/shipping,maya-scene/shipping,maya-souls/shipping,maya-spatial/shipping,maya-time/shipping,maya-world/shipping`,
    intentional `shipping+tracy` guard check for `maya-alloc`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-shipping-strip.json`.
- [x] **72.6.1.12** Implement Tracy capture automation (start capture on
      specific trigger, save .tracy file for offline analysis)
  - Completed via `maya-profiler` capture automation in
    `libs/maya/engine-core/crates/maya-profiler/src/capture.rs`, covering
    manual, frame, and named triggers; `tracy-capture` command-line
    construction; output directory creation; polling with `Child::try_wait`;
    saved artifact and failure statuses; and Tracy timeline messages around
    capture lifecycle events.
    `V2/ue/Build/Performance/v2-tracy-capture-automation.json`, Horde gates, the
    V2 CI workflow, and `check-v2-tracy-capture-automation.py` validate the
    controller API, trigger state machine, CLI flags, artifact status model, and
    CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-capture-automation.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-profiler --features maya-profiler/tracy`
    (14 unit tests),
    `python3 V2/ue/Tools/run-v2-tracy-ci-capture.py --self-test`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-capture-automation.json`.
- [x] **72.6.1.13** Create Tracy CI integration (capture profile during
      automated test run, fail if frame time regresses >10%)
  - Completed via `V2/ue/Tools/run-v2-tracy-ci-capture.py`, which builds the
    `tracy-capture` command, wraps the configured test command, enforces
    required capture artifacts, reads baseline/current JSON or CSV frame-time
    samples, writes the `v2.performance.tracyCiReport.v1` report, and fails the
    gate when current p95 frame time exceeds baseline p95 by more than 10%. The
    V2 workflow, Horde gates, and
    `V2/ue/Build/Performance/v2-tracy-ci-integration.json` validate capture
    command flags, test-run wrapping, report artifact paths, and regression
    threshold wiring. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-ci-integration.py`,
    `python3 V2/ue/Tools/run-v2-tracy-ci-capture.py --self-test`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-ci-integration.json`.
- [x] **72.6.1.14** Implement Tracy custom zone colors for visual
      differentiation (renderer=blue, physics=green, AI=red)
  - Completed via Tracy zone color constants and `emit_color` calls in the
    renderer, physics, and AI profiling macros, with renderer zones colored blue
    (`0x0000ff`), physics zones green (`0x00ff00`), and Maya Souls AI zones red
    (`0xff0000`). The coverage includes render-thread and render-graph zones,
    physics callbacks/cloth/fluid zones, and behavior tree, utility AI, GOAP,
    social event, and adaptive combat AI zones.
    `V2/ue/Build/Performance/v2-tracy-zone-colors.json`, Horde gates, the V2 CI
    workflow, and `check-v2-tracy-zone-colors.py` validate color constants,
    macro exports, required labels, `maya-souls` shipping-strip coverage, and CI
    wiring. Verification: `python3 V2/ue/Tools/check-v2-tracy-zone-colors.py`,
    `CARGO_BUILD_JOBS=1 cargo check --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer -p maya-physics -p maya-souls --features maya-renderer/tracy,maya-physics/tracy,maya-souls/tracy`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-souls --lib --features maya-souls/tracy`
    (351 tests), `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-zone-colors.json`.
- [x] **72.6.1.15** Create Tracy integration documentation and profiling
      workflow guide
  - Completed via `V2/docs/engineering/tracy-profiling-workflow.md` and
    `V2/ue/Build/Performance/v2-tracy-profiling-workflow.json`, covering source
    contracts, local Tracy build/test commands, manual capture, CI capture and
    p95 regression gating, timeline triage signals, zone color conventions, the
    shipping policy, and verification commands. The V2 workflow, Horde gates,
    and `check-v2-tracy-profiling-workflow.py` validate required sections, all
    Phase 72 Tracy source contracts, local profiling commands, CI artifacts, the
    shipping guard message, and checklist completion. Verification:
    `python3 V2/ue/Tools/check-v2-tracy-profiling-workflow.py`,
    `for script in V2/ue/Tools/check-v2-tracy-*.py; do python3 "$script"; done`,
    `python3 V2/ue/Tools/run-v2-tracy-ci-capture.py --self-test`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-tracy-profiling-workflow.json`.

#### 72.6.2 GPU Debugging & Platform Profilers

- [x] **72.6.2.1** Implement RenderDoc capture API integration (trigger frame
      capture from engine hotkey or programmatic API)
  - Completed via `maya-renderer`'s `renderdoc_capture` module, including the
    `RENDERDOC_GetAPI` vtable wrapper, `RenderDocCaptureApi` trait,
    `RenderDocCaptureController`, programmatic capture requests, Ctrl+Shift+F12
    hotkey events, `TriggerCapture`, and frame lifecycle handling through
    `StartFrameCapture`/`EndFrameCapture`.
    `V2/ue/Build/Performance/v2-renderdoc-capture-api.json`, Horde gates, the V2
    CI workflow, and `check-v2-renderdoc-capture-api.py` validate the API
    symbol/version, required FFI entrypoints, controller entrypoints, capture
    lifecycle states, hotkey types, and CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-renderdoc-capture-api.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer renderdoc_capture --lib`
    (11 filtered RenderDoc tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-renderdoc-capture-api.json`.
- [x] **72.6.2.2** Create RenderDoc overlay suppression during capture (disable
      debug overlays that pollute captures)
  - Completed via `RenderDocOverlaySuppressionConfig`,
    `RenderDocOverlaySuppressionState`, and `RenderDocOverlaySuppression` in
    `maya-renderer`'s `renderdoc_capture` module. The policy suppresses GPU
    profiler, frame timing, render graph, GI debug, editor gizmo, and custom
    overlays during active RenderDoc frame captures, arms suppression for
    trigger-based captures, supports selected-overlay allow-list behavior, and
    exposes decision entrypoints for overlay render paths.
    `V2/ue/Build/Performance/v2-renderdoc-overlay-suppression.json`, Horde
    gates, the V2 CI workflow, and `check-v2-renderdoc-overlay-suppression.py`
    validate the suppression policy, active-frame hooks, trigger-capture hooks,
    selective overlay behavior, and CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-renderdoc-overlay-suppression.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer renderdoc_capture --lib`
    (11 filtered RenderDoc tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-renderdoc-overlay-suppression.json`.
- [x] **72.6.2.3** Implement GPU timing query system (per-render-pass timing
      using Vulkan/Metal/DX12 timestamp queries)
  - Completed via `TimestampQuery`, `TimestampPool`, `PassTimerToken`,
    `PassTiming`, `GpuTimestampBackend`, `GpuTimestampCommandKind`,
    `GpuTimestampCommand`, and `GpuTimestampCommandBuffer` in `maya-renderer`'s
    `gpu_profiler` module. The profiler now records frame/pass begin and end
    timestamp commands, maps timestamp APIs for Vulkan `vkCmdWriteTimestamp`,
    Metal `MTLBlitCommandEncoder::sampleCountersInBuffer`, and DX12
    `ID3D12GraphicsCommandList::EndQuery`, resolves query deltas through
    `TimestampPool::resolve_ns`, and exposes nanosecond, microsecond, and
    millisecond timing for frame snapshots and per-pass timings.
    `V2/ue/Build/Performance/v2-gpu-timing-query-system.json`, Horde gates, the
    V2 CI workflow, and `check-v2-gpu-timing-query-system.py` validate the query
    pool, pass lifecycle, platform backend mappings, readback resolution, and CI
    wiring. Verification:
    `python3 V2/ue/Tools/check-v2-gpu-timing-query-system.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer gpu_profiler --lib`
    (96 filtered GPU profiler tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-gpu-timing-query-system.json`.
- [x] **72.6.2.4** Create GPU timing overlay (on-screen per-pass timing bars,
      toggleable in dev builds)
  - Completed via `GpuTimingOverlayConfig`, `GpuTimingOverlay`,
    `GpuTimingOverlayOutput`, and `GpuTimingBar` in `maya-renderer`'s
    `gpu_profiler` module. The overlay converts `FrameSnapshot` pass timings
    into on-screen bar data with pass names, GPU milliseconds, nesting depth,
    normalized and pixel widths, timing colors, and compact labels; it also
    supports max-bar capping, minimum visible timing thresholds, nested-pass
    filtering, target-frame normalization, and a dev-build-only toggle gated by
    `cfg!(debug_assertions)`.
    `V2/ue/Build/Performance/v2-gpu-timing-overlay.json`, Horde gates, the V2 CI
    workflow, and `check-v2-gpu-timing-overlay.py` validate the bar model, dev
    toggle, filtering behavior, dependency on the timestamp query system, and CI
    wiring. Verification: `python3 V2/ue/Tools/check-v2-gpu-timing-overlay.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer gpu_timing_overlay --lib`
    (3 filtered overlay tests), `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    and
    `python3 -m json.tool V2/ue/Build/Performance/v2-gpu-timing-overlay.json`.
- [x] **72.6.2.5** Implement PIX event markers for DirectX 12 backend (named GPU
      regions visible in PIX)
  - Completed via the `pix_markers` module in `maya-renderer`, including
    `PixMarkerColor`, `PixMarkerConfig`, `PixMarkerCommandKind`,
    `PixMarkerCommandListTarget`, `PixMarkerCommand`, `PixMarkerCommandStream`,
    and `PixMarkerEncoder`. The encoder is DX12-only, targets
    `ID3D12GraphicsCommandList`, emits `PIXBeginEvent`, `PIXEndEvent`, and
    `PIXSetMarker`, maps `RenderCommand::BeginRenderPass`,
    `RenderCommand::EndRenderPass`, and `RenderCommand::DebugMarker` into PIX
    commands, converts renderer RGBA colors to PIX ARGB values, and rejects
    unsupported backends plus unbalanced event stacks.
    `V2/ue/Build/Performance/v2-pix-event-markers.json`, Horde gates, the V2 CI
    workflow, and `check-v2-pix-event-markers.py` validate the marker API,
    DX12-only behavior, render-pass lifecycle mapping, debug marker mapping, and
    CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-pix-event-markers.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer pix_markers --lib`
    (6 filtered PIX marker tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-pix-event-markers.json`.
- [x] **72.6.2.6** Create Metal GPU capture integration for Xcode GPU debugger
  - Completed via the `metal_capture` module in `maya-renderer`, including
    `MetalCaptureDestination`, `MetalCaptureConfig`, `MetalCaptureRequest`,
    `MetalCaptureDescriptor`, `MetalCaptureArtifact`, `MetalCaptureStats`,
    `MetalCaptureApi`, and `MetalCaptureController`. The controller gates
    capture to `BackendKind::Metal`, maps Xcode destinations to
    `MTLCaptureDestinationDeveloperTools` and
    `MTLCaptureDestinationGPUTraceDocument`, drives
    `MTLCaptureManager.sharedCaptureManager`, `supportsDestination:`,
    `startCaptureWithDescriptor:error:`, `stopCapture`,
    `makeCaptureScopeWithDevice:`, `beginScope`, and `endScope`, and records
    trace artifacts under
    `Saved/Profiling/Metal/maya-metal-capture-{frame}-{label}.gputrace`.
    `V2/ue/Build/Performance/v2-metal-gpu-capture.json`, Horde gates, the V2 CI
    workflow, and `check-v2-metal-gpu-capture.py` validate the capture API,
    Xcode destinations, trace-document flow, scope lifecycle, and CI wiring.
    Verification: `python3 V2/ue/Tools/check-v2-metal-gpu-capture.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer metal_capture --lib`
    (6 filtered Metal capture tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-metal-gpu-capture.json`.
- [x] **72.6.2.7** Implement Vulkan debug labels (vkCmdBeginDebugUtilsLabel) for
      all render passes and compute dispatches
  - Completed via the `vulkan_debug_labels` module in `maya-renderer`, including
    `VulkanDebugLabelColor`, `VulkanDebugLabelConfig`,
    `VulkanDebugLabelCommandKind`, `VulkanDebugLabelCommand`,
    `VulkanDebugLabelCommandStream`, and `VulkanDebugLabelEncoder`. The encoder
    gates labels to `BackendKind::Vulkan`, targets `VkCommandBuffer`, emits
    `vkCmdBeginDebugUtilsLabelEXT`, `vkCmdEndDebugUtilsLabelEXT`, and
    `vkCmdInsertDebugUtilsLabelEXT` using `VkDebugUtilsLabelEXT` from
    `VK_EXT_debug_utils`, maps render-pass begin/end commands to scoped labels,
    maps compute dispatches and debug markers to inserted labels, converts RGBA
    colors into Vulkan debug label color values, and rejects unsupported
    backends plus unbalanced label stacks.
    `V2/ue/Build/Performance/v2-vulkan-debug-labels.json`, Horde gates, the V2
    CI workflow, and `check-v2-vulkan-debug-labels.py` validate the API mapping,
    render-pass lifecycle, compute dispatch labels, backend gating, and CI
    wiring. Verification: `python3 V2/ue/Tools/check-v2-vulkan-debug-labels.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer vulkan_debug_labels --lib`
    (6 filtered Vulkan debug label tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-vulkan-debug-labels.json`.
- [x] **72.6.2.8** Create NVIDIA Nsight Graphics marker integration
  - Completed via the `nsight_markers` module in `maya-renderer`, including
    `NsightMarkerColor`, `NsightMarkerConfig`, `NsightMarkerCommandKind`,
    `NsightMarkerCommand`, `NsightMarkerCommandStream`, and
    `NsightMarkerEncoder`. The encoder supports Vulkan and DirectX 12 backends,
    emits NVTX `nvtxRangePushEx`, `nvtxRangePop`, and `nvtxMarkEx` commands with
    `nvtxEventAttributes_t`, `NVTX_VERSION`, `NVTX_EVENT_ATTRIB_STRUCT_SIZE`,
    `NVTX_COLOR_ARGB`, and `NVTX_MESSAGE_TYPE_ASCII`, maps render-pass begin/end
    commands to Nsight ranges, maps compute dispatches and debug markers to NVTX
    marks, converts renderer colors to ARGB, and rejects unsupported backends
    plus unbalanced ranges.
    `V2/ue/Build/Performance/v2-nsight-graphics-markers.json`, Horde gates, the
    V2 CI workflow, and `check-v2-nsight-graphics-markers.py` validate the API
    mapping, render-pass ranges, compute dispatch marks, backend gating, and CI
    wiring. Verification:
    `python3 V2/ue/Tools/check-v2-nsight-graphics-markers.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer nsight_markers --lib`
    (6 filtered Nsight marker tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-nsight-graphics-markers.json`.
- [x] **72.6.2.9** Implement GPU memory tracking dashboard (per-resource memory
      usage, texture memory breakdown, buffer memory breakdown)
  - Completed via the `gpu_memory_dashboard` module in `maya-renderer`,
    including `GpuMemoryResourceKind`, `GpuMemoryHeapKind`,
    `GpuMemoryPressureLevel`, `GpuMemoryDashboardWarningLevel`,
    `GpuMemoryDashboardConfig`, `GpuMemoryResourceRecord`, `GpuMemoryBreakdown`,
    `GpuMemoryDashboardRow`, `GpuMemoryDashboardWarning`,
    `GpuMemoryDashboardSnapshot`, and `GpuMemoryDashboard`. The dashboard
    records per-resource GPU memory, imports `MemoryBudget` snapshots, estimates
    resources from `TextureDesc`, `BufferDesc`, `ResourceDesc`, and
    `ResourceLifetime`, breaks memory down by texture, render target, depth
    stencil, buffer, staging, acceleration structure, transient, aliased, and
    other bytes, sorts and caps visible rows, filters transient/unused
    resources, and classifies budget pressure as normal, warning, critical, or
    over budget. `V2/ue/Build/Performance/v2-gpu-memory-dashboard.json`, Horde
    gates, the V2 CI workflow, and `check-v2-gpu-memory-dashboard.py` validate
    per-resource rows, memory breakdowns, budget pressure, row filtering,
    render-graph lifetime integration, and CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-gpu-memory-dashboard.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer gpu_memory_dashboard --lib`
    (7 filtered GPU memory dashboard tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-gpu-memory-dashboard.json`.
- [x] **72.6.2.10** Create shader statistics collection (register pressure,
      VGPR/SGPR usage, occupancy estimates per shader)
  - Completed via the `shader_statistics` module in `maya-renderer`, including
    `ShaderRegisterPressureLevel`, `ShaderOccupancyLimitKind`,
    `ShaderOccupancyTier`, `ShaderStatisticsWarningKind`,
    `ShaderStatisticsConfig`, `ShaderOccupancyLimits`, `ShaderRegisterUsage`,
    `ShaderOccupancyEstimate`, `ShaderCompilerStatisticsFields`,
    `ShaderCompilerStatsInput`, `ShaderStatisticsRecord`, `ShaderStatisticsRow`,
    `ShaderStatisticsGroup`, `ShaderStatisticsWarning`,
    `ShaderStatisticsReport`, and `ShaderStatisticsCollector`. The collector
    records compiler-reported `vgpr_count`, `sgpr_count`, `temporary_registers`,
    `total_registers`, instruction count, local/shared memory, thread-group
    size, wave size, and occupancy percentage; estimates occupancy limits by
    VGPR, SGPR, shared memory, and thread group; classifies pressure and
    occupancy tiers; parses compiler reports; and aggregates rows, stage/backend
    breakdowns, and warnings for shader regressions.
    `V2/ue/Build/Performance/v2-shader-statistics-collection.json`, Horde gates,
    the V2 CI workflow, and `check-v2-shader-statistics-collection.py` validate
    register pressure, VGPR/SGPR tracking, occupancy estimates, compiler report
    parsing, shader source/key integration, and CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-shader-statistics-collection.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer shader_statistics --lib`
    (6 filtered shader statistics tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-shader-statistics-collection.json`.
- [x] **72.6.2.11** Implement frame time histogram (rolling window showing frame
      time distribution, percentile markers)
  - Completed via `FrameTimeHistogramConfig`, `FrameTimeHistogramBucket`,
    `FrameTimePercentileMarker`, `FrameTimeHistogramSnapshot`, and
    `FrameTimeHistogram` in `maya-renderer`'s `frame_pacing` module. The
    histogram builds rolling-window frame-time buckets from `FrameTimer`
    samples, tracks min/max/average, p50/p95/p99, jitter, target frame budget,
    hitch thresholds and counts, over-budget buckets, and configurable p50/p90/
    p95/p99 percentile markers. It also exposes wrapper recording in
    microseconds or milliseconds, reset behavior, refresh-rate-based defaults,
    and integration points with `FrameTimer`, `FramePacer`, and `PacingStats`.
    `V2/ue/Build/Performance/v2-frame-time-histogram.json`, Horde gates, the V2
    CI workflow, and `check-v2-frame-time-histogram.py` validate rolling-window
    behavior, buckets, percentile markers, budget/hitch tracking, and CI wiring.
    Verification: `python3 V2/ue/Tools/check-v2-frame-time-histogram.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer frame_time_histogram --lib`
    (5 filtered frame-time histogram tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-frame-time-histogram.json`.
- [x] **72.6.2.12** Create automated GPU performance regression testing (render
      standardized scene, compare frame time against baseline)
  - Completed via `gpu_performance_regression` in `maya-renderer` plus
    `V2/ue/Tools/run-v2-gpu-performance-regression.py`. The Rust suite defines
    the standardized `/Game/V2/Performance/Maps/GPUBaseline_City` flythrough,
    pc-ultra-4k render preset, 30 warmup frames, 120 sample frames, required
    passes (`shadow_map`, `gbuffer`, `lighting`, `post_process`), automation
    args, baseline keys, frame-snapshot ingestion, warmup-filtered summaries,
    p50/p95/p99/max GPU timing, hitch rate, per-pass p95 metrics, and baseline
    comparison thresholds for average, p95, p99, pass p95, hitch rate, sample
    count, and required-pass coverage. The Python runner builds the Unreal
    standardized-scene command, ingests baseline/current JSON reports, produces
    `v2.performance.gpuPerformanceRegressionReport.v1`, and fails the gate for
    p95, pass-p95, missing-pass, or sample-count regressions.
    `V2/ue/Build/Performance/v2-gpu-performance-regression.json`, Horde gates,
    the V2 CI workflow, and `check-v2-gpu-performance-regression.py` validate
    the standard scene, baseline comparison, p95 gate, pass-p95 gate, runner
    self-test, and CI wiring. Verification:
    `python3 V2/ue/Tools/check-v2-gpu-performance-regression.py`,
    `python3 V2/ue/Tools/run-v2-gpu-performance-regression.py --self-test`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer gpu_performance_regression --lib`
    (6 filtered GPU performance regression tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-gpu-performance-regression.json`.
- [x] **72.6.2.13** Implement Superluminal performance API markers for CPU
      profiling on Windows
  - Completed via the `superluminal_markers` module in `maya-renderer`,
    including `SuperluminalMarkerColor`, `SuperluminalMarkerPlatform`,
    `SuperluminalPerformanceApiBinding`, `SuperluminalMarkerConfig`,
    `SuperluminalMarkerCommandKind`, `SuperluminalMarkerCommand`,
    `SuperluminalMarkerCommandStream`, and `SuperluminalMarkerEncoder`. The
    encoder targets Windows `PerformanceAPI.dll` API version 3.0 through
    `PerformanceAPI_GetAPI`, emits `PerformanceAPI_BeginEvent`,
    `PerformanceAPI_BeginEvent_N`, `PerformanceAPI_EndEvent`, and
    `PerformanceAPI_SetCurrentThreadName`, supports render-thread naming, maps
    render-pass begin/end commands to CPU event ranges, wraps compute dispatches
    and debug markers in scoped begin/end events, and rejects unsupported
    platforms plus unbalanced event stacks.
    `V2/ue/Build/Performance/v2-superluminal-markers.json`, Horde gates, the V2
    CI workflow, and `check-v2-superluminal-markers.py` validate the API
    binding, thread names, CPU event scopes, render-command mapping, and CI
    wiring. Verification:
    `python3 V2/ue/Tools/check-v2-superluminal-markers.py`,
    `CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer superluminal_markers --lib`
    (6 filtered Superluminal marker tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-superluminal-markers.json`.
- [x] **72.6.2.14** Create cross-platform profiling abstraction (single macro
      that expands to Tracy + platform-specific markers)
  - Completed via the `profiling_abstraction` module and
    `maya_renderer_profile_scope!` macro in `maya-renderer`. The abstraction
    exposes `CrossPlatformProfilerBackend`, `CrossPlatformProfilerEventKind`,
    `CrossPlatformProfilingConfig`, `CrossPlatformProfilingSession`,
    `CrossPlatformProfilingEvent`, `CrossPlatformOpenScope`,
    `CrossPlatformProfilingSnapshot`, and `CrossPlatformProfileScope`; selects
    Tracy, Superluminal, PIX, and Nsight backends for Vulkan/current-platform
    and Windows DX12 configurations; expands to `maya_renderer_tracy_zone!` plus
    platform marker streams; emits Superluminal `PerformanceAPI_BeginEvent`,
    `PerformanceAPI_EndEvent`, and `PerformanceAPI_SetCurrentThreadName`; emits
    PIX begin/end events (`PIXBeginEvent`, `PIXEndEvent`); emits Nsight
    `nvtxRangePushEx`/`nvtxRangePop`; tracks nested scopes; and keeps explicit
    scope end idempotent.
    `V2/ue/Build/Performance/v2-cross-platform-profiling-abstraction.json`,
    Horde gates, the V2 CI workflow, and
    `check-v2-cross-platform-profiling-abstraction.py` validate the macro, Tracy
    scope wiring, platform markers, balanced scopes, and CI wiring.
    Verification:
    `python3 V2/ue/Tools/check-v2-cross-platform-profiling-abstraction.py`,
    `TRACY_NO_INVARIANT_CHECK=1 CARGO_BUILD_JOBS=1 cargo test --locked --manifest-path libs/maya/engine-core/Cargo.toml -p maya-renderer profiling_abstraction --lib --features maya-renderer/tracy`
    (6 filtered profiling abstraction tests),
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, and
    `python3 -m json.tool V2/ue/Build/Performance/v2-cross-platform-profiling-abstraction.json`.
- [x] **72.6.2.15** Implement profiling documentation covering tool setup,
      common workflows, and performance budgets Completed via
      `V2/docs/engineering/profiling-tool-setup-workflows-budgets.md` and
      `V2/ue/Build/Performance/v2-profiling-documentation.json`, which tie the
      Phase 72 profiling stack into a single operator runbook. The documentation
      covers source contracts from the Tracy workflow through the cross-platform
      profiling abstraction, a setup matrix for Tracy, RenderDoc, GPU timing
      overlay, PIX, Xcode GPU capture, Vulkan debug labels, Nsight Graphics,
      Superluminal, GPU memory dashboard, and shader statistics, plus capture
      workflows, triage order, CI/release gates, required evidence, and
      performance budgets for 60/120/30Hz targets, frame histogram hitches, GPU
      regression deltas, GPU memory pressure, and shader register/occupancy
      thresholds. Verification:
      `python3 V2/ue/Tools/check-v2-profiling-documentation.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m json.tool V2/ue/Build/Performance/v2-profiling-documentation.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check TODOS/phase-72.md V2/docs/engineering/profiling-tool-setup-workflows-budgets.md V2/ue/Build/Performance/v2-profiling-documentation.json`.

---

### 72.7 In-Game Dialogue System & Conversation Engine

Branching dialogue trees, conversation runtime, dialogue cameras, and lip-sync
triggering for narrative-driven games.

#### 72.7.1 Dialogue Data & Runtime

- [x] **72.7.1.1** Design dialogue tree data format (nodes: text, choice,
      condition, action, random; edges: transitions with conditions) Completed
      via
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueTreeFormat_V2_Contract.json`,
      `V2/docs/modes/dialogue-tree-format.md`,
      `V2/balance/dialogue/trees/asha-storm-market-intro.v2dialogue.json`, and
      `V2/ue/Tools/check-v2-dialogue-tree-format.py`. The format defines
      `v2.dialogue.tree.v1` top-level fields, stable `dlg.`, `n.`, `e.`,
      `choice.`, and `loc.dialogue.` IDs, node kinds for text, choice,
      condition, action, and random nodes, edge-carried transition conditions,
      choice metadata, weighted random transitions, localization and voice cue
      requirements, graph validation rules, save/history keys, CI workflow
      checks, and Horde gates. The sample tree exercises all node kinds,
      conditional edges, localized choice line IDs, deterministic random edges,
      supported condition references, supported action references, and terminal
      traversal. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueTreeFormat_V2_Contract.json`,
      `python3 -m json.tool V2/balance/dialogue/trees/asha-storm-market-intro.v2dialogue.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/docs/modes/dialogue-tree-format.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueTreeFormat_V2_Contract.json V2/balance/dialogue/trees/asha-storm-market-intro.v2dialogue.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.2** Implement dialogue runtime engine (traverse dialogue graph,
      evaluate conditions against game state, present choices) Completed via
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueRuntimeEngine_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-runtime-engine.py`. The runtime defines
      Blueprint-callable `UV2DialogueRuntimeLibrary` entry points for tree
      validation, start, advance, and available-choice presentation, plus
      `FV2DialogueRuntimeState`, `FV2DialogueTree`, `FV2DialogueNode`,
      `FV2DialogueEdge`, `FV2DialogueCondition`, `FV2DialogueAction`,
      `FV2DialogueChoiceView`, and `FV2DialogueStepResult` data types. Traversal
      resolves text and choice presentation nodes, evaluates edge conditions
      against boolean, numeric, name, and choice-history state, accumulates
      action node and edge side effects, records selected choice IDs, chooses
      deterministic weighted random edges, handles terminal nodes, and validates
      malformed graphs. Automation coverage exercises validation, start/advance
      traversal, two-choice presentation, condition/action traversal,
      selected-choice history, terminal advancement, deterministic random
      selection recording, and invalid start-node rejection. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueRuntimeEngine_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueRuntimeEngine_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.3** Create dialogue condition system (check quest state,
      inventory, relationship values, time of day, player stats) Completed via
      typed condition support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueConditionSystem_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-condition-system.py`. The condition
      system adds `EV2DialogueConditionKind` entries and dedicated runtime state
      maps for quest states, inventory counts, relationship values, current
      time-of-day hours, and player stats, while keeping compatibility with the
      `quest_state`, `inventory_count`, `relationship_value`, `time_of_day`, and
      `player_stat` string refs from the tree format. Blueprint helpers
      construct each condition family and expose single/all condition
      evaluation. Automation coverage verifies quest-state matching, inventory
      threshold comparison, relationship threshold comparison, time-of-day
      comparison, player-stat threshold comparison, and continued runtime
      traversal through typed quest/player-stat conditions. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueConditionSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueConditionSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.4** Implement dialogue action system (trigger quest updates, give
      items, modify relationships, play animations, spawn entities) Completed
      via typed action support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueActionSystem_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-action-system.py`. The action system
      adds `EV2DialogueActionKind`, `EV2DialogueActionValueKind`, action history
      records, gameplay cue records, Blueprint helper constructors, and action
      application helpers. Runtime traversal now applies action node and edge
      side effects while preserving returned `TriggeredActions`: quest updates
      mutate `QuestStates`, item grants increment `InventoryCounts`,
      relationship deltas update `RelationshipValues`, and event, animation, and
      spawn requests are queued as gameplay cues. The tree format allowlist and
      sample fixture now include `spawn_entity` alongside the existing authored
      action refs. Automation coverage verifies quest updates, item grants,
      relationship deltas, animation gameplay cues, spawn gameplay cues, action
      history recording, traversal-applied quest updates, and traversal-queued
      events. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueActionSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/docs/modes/dialogue-tree-format.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueActionSystem_V2_Contract.json V2/ue/Content/V2/Gameplay/Dialogue/DialogueTreeFormat_V2_Contract.json V2/balance/dialogue/trees/asha-storm-market-intro.v2dialogue.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.5** Create dialogue variable system (local dialogue variables,
      persistent per-NPC variables, global story variables) Completed via scoped
      variable support in `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueVariableSystem_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-variable-system.py`. The variable
      system adds `EV2DialogueVariableScope`, `FV2DialogueVariableValue`, scoped
      local, persistent-NPC, and global-story boolean/numeric/name maps, scoped
      variable storage keys, Blueprint set/get/value helpers, scoped
      set-variable action helpers, and scoped variable condition helpers. Local
      variables reset when a new dialogue starts, while persistent NPC and
      global story variables survive conversation resets. Runtime conditions now
      evaluate `local_variable`, `persistent_variable`, and
      `global_story_variable` against scoped storage before falling back to
      legacy fact maps, and set-variable actions write through the scoped
      storage layer. Automation coverage verifies local storage, persistent NPC
      keying and condition evaluation, global story condition evaluation, local
      reset behavior, persistent/global survival across resets, and traversal
      applying a local set-variable action. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueVariableSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueVariableSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.6** Implement dialogue choice consequence tracking (record player
      choices, reference in future dialogues) Completed via persistent choice
      consequence support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueChoiceConsequenceTracking_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`. The
      consequence layer adds `FV2DialogueChoiceConsequence`,
      `PersistentChoiceHistory`, `ChoiceSelectionCounts`, dialogue-qualified
      choice keys, structured records containing dialogue, choice, source node,
      edge, tags, and selection count, plus Blueprint helpers for key creation,
      consequence lookup, selection counts, and future-dialogue `choice_history`
      conditions. Choice selections now record both the per-conversation choice
      id and persistent dialogue-qualified keys so later dialogues can reference
      earlier choices after conversation reset. Automation coverage verifies
      dialogue choice keys, selection counts, future-dialogue condition lookup,
      selected edge/source-node capture, and reset survival. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueChoiceConsequenceTracking_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueChoiceConsequenceTracking_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.7** Create dialogue localization integration (string IDs for all
      dialogue text, voice-over asset references per locale) Completed via
      runtime localization support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`, the
      authored localization table
      `V2/balance/dialogue/localization/asha-storm-market-intro.v2dialogueloc.json`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueLocalizationIntegration_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-localization-integration.py`. The
      localization layer adds `FV2DialogueLocalizedLine`,
      `FV2DialogueLocalizationTable`, `FV2DialogueResolvedLine`, locale-specific
      line lookup, source-locale fallback, voice-cue resolution, and
      localization table validation. The authored table uses schema
      `v2.dialogue.localization.v1`, covers every required `loc.dialogue.*` line
      id from the sample tree in `en-US` and `es-ES`, and records per-locale
      voice cue and subtitle timing references for every voiced line. Automation
      coverage verifies required line-id validation, locale-specific line
      resolution, source locale fallback, and per-locale voice cue lookup.
      Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-localization-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-localization-integration.py V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueLocalizationIntegration_V2_Contract.json`,
      `python3 -m json.tool V2/balance/dialogue/localization/asha-storm-market-intro.v2dialogueloc.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/docs/modes/dialogue-tree-format.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueLocalizationIntegration_V2_Contract.json V2/balance/dialogue/localization/asha-storm-market-intro.v2dialogueloc.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.8** Implement dialogue save/load (persist conversation state,
      mid-conversation saves, choice history) Completed via
      `FV2DialogueSaveState` and Blueprint helpers in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueSaveLoad_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-save-load.py`. The save/load layer
      snapshots the full `FV2DialogueRuntimeState` with save version and save id
      metadata, validates non-empty dialogue/current-node state before restore,
      and restores mid-conversation runtime state including current node,
      available choices, choice/consequence history, scoped variables, random
      selection state, action history, and gameplay cues. Automation coverage
      verifies mid-conversation snapshot validation, restoring a choice
      presentation node, restored available choices, restoring selected-choice
      state, persisted choice history, and persisted scoped variables.
      Verification: `python3 V2/ue/Tools/check-v2-dialogue-save-load.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-localization-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-save-load.py V2/ue/Tools/check-v2-dialogue-localization-integration.py V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueSaveLoad_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueSaveLoad_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.9** Create dialogue priority and interruption system (urgent
      dialogues interrupt casual conversation, queue management) Completed via
      priority queue support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialoguePriorityInterruptionSystem_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py`. The
      system adds `EV2DialoguePriority`, `FV2DialogueQueuedDialogue`,
      `FV2DialogueQueueState`, deterministic queue sorting by priority then
      enqueue order, interrupt checks that only allow higher-priority
      interruptible candidates to preempt active dialogue, queue popping, and
      active-dialogue promotion that removes the promoted entry from pending
      work. Automation coverage verifies urgent-before-ambient ordering, FIFO
      ordering within equal priority, urgent interruption over casual dialogue,
      lower-priority rejection, and promoted-entry removal. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-save-load.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-localization-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py V2/ue/Tools/check-v2-dialogue-save-load.py V2/ue/Tools/check-v2-dialogue-localization-integration.py V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialoguePriorityInterruptionSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialoguePriorityInterruptionSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.10** Implement dialogue bark system (context-triggered
      one-liners: combat barks, exploration comments, idle chatter) Completed
      via bark rule/runtime support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`, the
      authored bark table
      `V2/balance/dialogue/barks/asha-storm-barks.v2barks.json`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueBarkSystem_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-bark-system.py`. The bark system adds
      combat, exploration, and idle contexts, authored bark rules with line ids,
      speaker ids, priority, cooldowns, required tags, and blocked tags, plus
      runtime selection and recording helpers. Selection filters by context,
      required/blocked tags, and cooldown, then picks the highest-priority
      eligible bark deterministically. Automation coverage verifies combat
      context selection, cooldown rejection, exploration tag selection, and
      played-bark history recording. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-bark-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-save-load.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-localization-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-bark-system.py V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py V2/ue/Tools/check-v2-dialogue-save-load.py V2/ue/Tools/check-v2-dialogue-localization-integration.py V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueBarkSystem_V2_Contract.json`,
      `python3 -m json.tool V2/balance/dialogue/barks/asha-storm-barks.v2barks.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueBarkSystem_V2_Contract.json V2/balance/dialogue/barks/asha-storm-barks.v2barks.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.11** Create dialogue tag system for text effects (pause,
      emphasis, speed changes, inline expressions like [happy], [angry])
      Completed via inline text tag parsing in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueTextTagSystem_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-text-tag-system.py`. The tag system
      adds `EV2DialogueTextTagKind`, `FV2DialogueTextTag`,
      `FV2DialogueTaggedText`, `ParseDialogueTextTags`, and
      `StripDialogueTextTags`. The parser strips bracket tags from display text
      while preserving structured pause, emotion, emphasis, speed, and event
      metadata with text indices and numeric values for timed/speed effects.
      Automation coverage verifies plain text stripping, multiple tag capture,
      pause values, emotion tags such as `[happy]`, and speed-change tags.
      Verification: `python3 V2/ue/Tools/check-v2-dialogue-text-tag-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-bark-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-save-load.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-localization-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-text-tag-system.py V2/ue/Tools/check-v2-dialogue-bark-system.py V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py V2/ue/Tools/check-v2-dialogue-save-load.py V2/ue/Tools/check-v2-dialogue-localization-integration.py V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueTextTagSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueTextTagSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.12** Implement dialogue text typewriter display with skip/fast-
      forward Completed via typewriter runtime support in
      `V2/ue/Source/V2Gameplay/Public/V2DialogueRuntime.h`,
      `V2/ue/Source/V2Gameplay/Private/V2DialogueRuntime.cpp`,
      `V2/ue/Source/V2Tests/Private/Gameplay/DialogueRuntime.spec.cpp`,
      `V2/ue/Content/V2/Gameplay/Dialogue/DialogueTypewriterDisplay_V2_Contract.json`,
      and `V2/ue/Tools/check-v2-dialogue-typewriter-display.py`. The typewriter
      layer adds `FV2DialogueTypewriterSettings`, `FV2DialogueTypewriterState`,
      start, advance, fast-forward, and skip helpers. Typewriter display
      consumes tag-stripped plain text, reveals characters by elapsed time and
      configured characters-per-second, applies a fast-forward multiplier, and
      skips directly to the complete line. Automation coverage verifies hidden
      initial state, tag stripping, timed reveal, fast-forward acceleration, and
      skip-to-complete behavior. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-typewriter-display.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-text-tag-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-bark-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-save-load.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-localization-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-variable-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-action-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-condition-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-typewriter-display.py V2/ue/Tools/check-v2-dialogue-text-tag-system.py V2/ue/Tools/check-v2-dialogue-bark-system.py V2/ue/Tools/check-v2-dialogue-priority-interruption-system.py V2/ue/Tools/check-v2-dialogue-save-load.py V2/ue/Tools/check-v2-dialogue-localization-integration.py V2/ue/Tools/check-v2-dialogue-choice-consequence-tracking.py V2/ue/Tools/check-v2-dialogue-variable-system.py V2/ue/Tools/check-v2-dialogue-action-system.py V2/ue/Tools/check-v2-dialogue-condition-system.py V2/ue/Tools/check-v2-dialogue-runtime-engine.py V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueTypewriterDisplay_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueTypewriterDisplay_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.13** Create Ink/Yarn Spinner format importers (interop with
      industry-standard narrative scripting tools) — Added
      `FV2DialogueImportDiagnostic`, `FV2DialogueImportSettings`, and
      `FV2DialogueImportResult` plus Blueprint-callable `ImportInkDialogueTree`
      / `ImportYarnDialogueTree` helpers that convert line-based Ink and Yarn
      Spinner source subsets into `FV2DialogueTree` and
      `FV2DialogueLocalizationTable` assets. The importers preserve speaker and
      line IDs, choice IDs, choice tags, condition metadata, action metadata,
      Yarn `<<set>>` commands, explicit jumps/diverts, generated prompts, and
      validation diagnostics. Added Ink/Yarn source fixtures, automation
      assertions for valid imports and metadata preservation, a narrative
      importer contract, CI/Horde gates, and a focused checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-narrative-importers.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-typewriter-display.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-text-tag-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-narrative-importers.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueNarrativeImporters_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueNarrativeImporters_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.14** Implement dialogue unit tests (verify all dialogue trees are
      traversable, no dead ends, all conditions reachable) — Added
      `FV2DialogueGraphAuditResult` and `AuditDialogueTreeGraph` to audit
      dialogue graphs for start-node reachability, unreachable nodes,
      non-terminal dead ends, missing explicit-terminal paths, and unreachable
      condition nodes. Automation now verifies a clean traversable fixture and
      rejects reachable dead ends, unreachable condition nodes, and trees with
      no terminal path. Added a repository checker that audits every
      `*.v2dialogue.json` file under `V2/balance/dialogue/trees` for
      traversability, terminal reachability, dead ends, reachable condition
      nodes, and condition-bearing edge reachability, plus a unit-test contract
      and CI/Horde gates. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-unit-tests.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-narrative-importers.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-unit-tests.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueUnitTests_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueUnitTests_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.1.15** Create dialogue documentation and authoring guide — Added
      `V2/docs/modes/dialogue-authoring-guide.md` covering source-of-truth
      artifacts, authoring workflow, stable IDs, graph rules, conditions,
      actions, variables, choice consequences, localization/voice, text tags,
      typewriter display, bark/priority usage, Ink/Yarn imports, review
      checklist, and validation commands. Added
      `DialogueAuthoringGuide_V2_Contract.json`,
      `check-v2-dialogue-authoring-guide.py`, CI workflow wiring, Horde gates,
      and CI self-checker coverage. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-authoring-guide.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-unit-tests.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-narrative-importers.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-tree-format.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-authoring-guide.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueAuthoringGuide_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check V2/docs/modes/dialogue-authoring-guide.md .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueAuthoringGuide_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.

#### 72.7.2 Dialogue Presentation

- [x] **72.7.2.1** Implement dialogue camera system (over-the-shoulder, shot-
      reverse-shot, close-up, wide establishing shot) — Added
      `EV2DialogueCameraShotType`, dialogue camera participant/settings/request
      and shot structs, plus `BuildDialogueCameraShot` and
      `BuildDialogueShotReverseShotPair` helpers. The planner computes
      deterministic camera locations, rotations, look-at points, FOV, blend
      timing, shoulder offsets, close-up framing, and wide establishing shots
      from speaker/listener participant locations. Automation covers
      over-the-shoulder, shot-reverse-shot, close-up, and wide establishing shot
      generation. Added a camera-system contract, CI/Horde gates, and a focused
      checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-camera-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-authoring-guide.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-unit-tests.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-camera-system.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueCameraSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueCameraSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.2** Create dialogue camera cut selection based on dialogue tags
      (important line → close-up, choice → medium shot, emotion → ECU) — Added
      `FV2DialogueCameraCutRule`, `FV2DialogueCameraCutRequest`, and
      `FV2DialogueCameraCutSelection` plus default cut rules and
      `SelectDialogueCameraCut`. The selector maps emotion-style tags to
      `ExtremeCloseUp`, `important` to `CloseUp`, choice prompts to
      `MediumShot`, establishing/wide tags to `WideEstablishing`, and otherwise
      falls back to `OverTheShoulder`, using rule priority and stable rule IDs
      for deterministic cuts. Automation covers important-line close-up,
      choice-prompt medium shot, emotion ECU, and over-shoulder fallback. Added
      a cut-selection contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-camera-cut-selection.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-authoring-guide.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-camera-cut-selection.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueCameraCutSelection_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueCameraCutSelection_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.3** Implement dialogue character staging (position NPCs for
      conversation, idle animations, facing targets) — Added
      `FV2DialogueCharacterStagingSettings`,
      `FV2DialogueCharacterStagePlacement`, and `BuildDialogueCharacterStaging`
      to produce deterministic two-party staging plans from dialogue
      participants. The helper preserves or derives a conversation midpoint,
      spaces speaker/listener placements at the configured conversation
      distance, rotates both placements toward their facing target, assigns
      speaker/listener idle animation IDs, and handles coincident participants
      with a deterministic forward fallback. Automation covers conversation
      distance, face-to-face rotations, idle animation assignment, and
      coincident participant handling. Added a staging contract, CI/Horde gates,
      and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-character-staging.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-cut-selection.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-character-staging.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueCharacterStaging_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueCharacterStaging_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.4** Create dialogue lip-sync triggering (start phoneme animation
      synchronized with voice-over playback) — Added `FV2DialoguePhonemeCue`,
      `FV2DialogueLipSyncSettings`, `FV2DialogueLipSyncRequest`,
      `FV2DialogueLipSyncTrigger`, and `BuildDialogueLipSyncTriggers` to convert
      line-specific phoneme cues into deterministic animation triggers aligned
      to voice-over playback time. The helper validates speaker and voice cue
      inputs, sorts cues by phoneme start time, offsets trigger times from the
      voice playback start, clamps phoneme durations to the voice clip duration,
      builds stable phoneme animation IDs, and reports missing voice/phoneme
      data with failure tags. Automation covers voice-start offsets, phoneme
      sorting, duration clamping, phoneme animation IDs, and missing voice cue
      failure handling. Added a lip-sync triggering contract, CI/Horde gates,
      and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-lip-sync-triggering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-character-staging.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-cut-selection.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-lip-sync-triggering.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueLipSyncTriggering_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueLipSyncTriggering_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.5** Implement dialogue facial expression blending (apply emotion
      overlays from dialogue tags onto facial rig) — Added
      `FV2DialogueFacialExpressionRule`, `FV2DialogueFacialExpressionSettings`,
      `FV2DialogueFacialExpressionRequest`, `FV2DialogueFacialExpressionBlend`,
      `MakeDefaultDialogueFacialExpressionRules`, and
      `BuildDialogueFacialExpressionBlends` to map dialogue emotion tags to
      facial rig pose overlays. The planner validates speakers, filters rules by
      dialogue tags, sorts expression rules by priority, caps simultaneous
      active blends, applies blend-layer/timing defaults, clamps weights, and
      reports unmatched emotion tags with a failure tag. Automation covers
      emotion tag overlay mapping, priority order, active blend limits, blend
      timing, and unmatched-tag failure handling. Added a facial expression
      blending contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-facial-expression-blending.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-lip-sync-triggering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-character-staging.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-cut-selection.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-facial-expression-blending.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueFacialExpressionBlending_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueFacialExpressionBlending_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.6** Create dialogue gesture system (hand gestures, body shifts,
      head nods triggered by dialogue cues) — Added `EV2DialogueGestureType`,
      `FV2DialogueGestureRule`, `FV2DialogueGestureSettings`,
      `FV2DialogueGestureRequest`, `FV2DialogueGestureTrigger`,
      `MakeDefaultDialogueGestureRules`, and `BuildDialogueGestureTriggers` to
      map dialogue cue tags to deterministic body animation triggers. The
      planner validates speakers, filters cue-tagged rules, covers hand
      gestures, body shifts, and head nods, sorts by priority, caps active
      triggers, offsets gesture starts from the dialogue line start, clamps
      weights, and reports unmatched cues with a failure tag. Automation covers
      hand gesture cues, head-nod/body-shift cues, priority order, timing and
      weight output, and unmatched-cue failure handling. Added a gesture system
      contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-gesture-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-facial-expression-blending.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-lip-sync-triggering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-character-staging.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-gesture-system.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueGestureSystem_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueGestureSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.7** Implement dialogue ambient animation (characters fidget, look
      around, breathe during pauses) — Added `EV2DialogueAmbientAnimationType`,
      `FV2DialogueAmbientAnimationRule`, `FV2DialogueAmbientAnimationSettings`,
      `FV2DialogueAmbientAnimationRequest`,
      `FV2DialogueAmbientAnimationTrigger`,
      `MakeDefaultDialogueAmbientAnimationRules`, and
      `BuildDialogueAmbientAnimationTriggers` to schedule pause-aware ambient
      motion during dialogue. The scheduler validates participants and pause
      duration, covers breathing, fidget, and look-around ambient clips, gates
      fidgets/look-arounds by pause length and cooldown, keeps trigger duration
      inside the pause window, sorts by priority, caps active ambient clips, and
      reports missing pause/eligible-rule failures. Automation covers breathing
      during pauses, fidget/look-around scheduling, pause-window timing,
      cooldown filtering, and missing pause handling. Added an ambient animation
      contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-ambient-animation.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-gesture-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-facial-expression-blending.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-lip-sync-triggering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-ambient-animation.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueAmbientAnimation_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueAmbientAnimation_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.8** Create dialogue audio system integration (play voice-over
      clip, subtitle timing, ducking of music/ambient) — Added
      `FV2DialogueAudioSettings`, `FV2DialogueAudioPlaybackRequest`,
      `FV2DialogueAudioPlaybackPlan`, and `BuildDialogueAudioPlaybackPlan` to
      produce a deterministic dialogue audio playback plan from voice-over line
      metadata. The planner validates speaker, voice cue, and duration inputs,
      emits voice-over start/end timing, computes subtitle timing windows from
      subtitle timing IDs with lead/hold offsets, and applies configurable music
      and ambient ducking multipliers/fades with a no-ducking mode. Automation
      covers voice-over playback planning, subtitle timing, music/ambient
      ducking, disabled ducking, and missing voice cue failure handling. Added
      an audio integration contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-audio-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-ambient-animation.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-gesture-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-lip-sync-triggering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-audio-integration.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueAudioIntegration_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueAudioIntegration_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.9** Implement dialogue UI (text display, character portrait/name,
      choice buttons, continue indicator) — Using the frontend-skill UI
      direction, added `FV2DialogueUiChoiceButton`, `FV2DialogueUiRequest`,
      `FV2DialogueUiViewModel`, and `BuildDialogueUiViewModel` to produce a
      restrained dialogue overlay view model from resolved line and choice data.
      The builder carries speaker display name, portrait ID, active line text,
      prompt ID, deterministic choice button ordering/selection, choice/continue
      visibility flags, and missing-line failure state. Automation covers
      speaker name/portrait output, line text display, choice button creation,
      continue indicator visibility, and missing line text handling. Added a
      dialogue UI contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-ui.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-audio-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-typewriter-display.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-ui.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueUI_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueUI_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.10** Create dialogue subtitle rendering with speaker
      identification, non-verbal captions [sighs], and timing — Added
      `FV2DialogueSubtitleSettings`, `FV2DialogueSubtitleRequest`,
      `FV2DialogueSubtitleRenderModel`, and `BuildDialogueSubtitleRenderModel`
      to produce a timed subtitle render model for the dialogue overlay. The
      helper formats optional speaker identification, wraps non-verbal captions
      with configurable brackets, preserves subtitle timing IDs and start/end
      windows, falls back to a default duration when timing is incomplete, and
      reports missing subtitle text with a failure tag. Automation covers
      speaker identification, non-verbal captions, timing windows, default
      duration fallback, and missing text handling. Added a subtitle rendering
      contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-subtitle-rendering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-ui.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-audio-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-subtitle-rendering.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueSubtitleRendering_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueSubtitleRendering_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.11** Implement dialogue skip functionality (skip current line,
      skip to next choice, skip entire conversation) — Added
      `EV2DialogueSkipMode`, `FV2DialogueSkipRequest`, `FV2DialogueSkipResult`,
      and `BuildDialogueSkipResult` to convert skip input into deterministic
      runtime actions for completing an unrevealed line, advancing after a
      revealed line, seeking the next choice, or ending the conversation. The
      helper reports disabled skip modes and unknown requests with explicit
      failure tags. Automation covers current-line reveal and advance behavior,
      next-choice seek, conversation end, and disabled-mode failures. Added a
      skip functionality contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-skip-functionality.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-subtitle-rendering.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-ui.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-skip-functionality.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueSkipFunctionality_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueSkipFunctionality_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.12** Create dialogue history/log (scrollable log of past
      conversation text for reference) — Added `FV2DialogueHistoryEntry`,
      `FV2DialogueHistoryLineView`, `FV2DialogueHistoryLogRequest`,
      `FV2DialogueHistoryLogViewModel`, and `BuildDialogueHistoryLogViewModel`
      to produce a scroll-window dialogue history log from past speaker lines
      and player choices. The builder formats optional speaker labels, preserves
      line/choice IDs and timestamps, returns latest or older visible windows
      from `ScrollOffsetFromEnd`, and exposes up/down scroll affordances plus an
      empty-log failure tag. Automation covers speaker-line formatting,
      player-choice inclusion, latest-window scroll state, older-entry
      scrolling, and empty-log handling. Added a history log contract, CI/Horde
      gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-history-log.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-skip-functionality.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-ui.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-history-log.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueHistoryLog_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueHistoryLog_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.13** Implement dialogue editor integration (visual node graph for
      authoring dialogue trees with preview) — Using the frontend-skill
      authoring-surface direction, added a restrained `DialogueEditor` tool
      surface, `Tool.DialogueEditor` narrative tab, GraphEditor module
      dependency, `FV2DialogueEditorNodeSpec`, `FV2DialogueEditorLinkSpec`,
      `FV2DialogueEditorPreviewModel`, `FV2DialogueEditorGraphModel`,
      `FV2DialogueEditorWidgetSpec`, `BuildDialogueEditorWidgetSpec`, and
      `BuildDialogueEditorGraphModel`. The builder converts dialogue trees into
      deterministic visual node/link models with graph positions, localized node
      preview text, choice-link preview labels, validation warnings, and
      selected-node preview state for an authoring UI. Automation covers tab
      registration, widget surface controls, node graph generation, localized
      preview, choice-link preview, and empty-tree failure. Added a dialogue
      editor integration contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-editor-integration.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-history-log.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-editor-module.py`,
      `python3 V2/ue/Tools/check-v2-relationship-timeline.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-editor-integration.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueEditorIntegration_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueEditorIntegration_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.14** Create dialogue cinematic blend (smoothly transition from
      gameplay camera to dialogue camera and back) — Added
      `EV2DialogueCinematicBlendPhase`, `FV2DialogueCinematicBlendSettings`,
      `FV2DialogueCinematicBlendRequest`, `FV2DialogueCinematicBlendKeyframe`,
      `FV2DialogueCinematicBlendPlan`, and `BuildDialogueCinematicBlendPlan` to
      produce deterministic camera keyframes for entering a dialogue shot,
      optionally holding, and returning to the gameplay camera. The plan carries
      blend durations, curve token, input-lock and restore flags, total
      duration, and invalid-shot/gameplay-camera failure tags. Automation covers
      dialogue camera entry, gameplay camera return, staying on the dialogue
      camera, and invalid dialogue shot handling. Added a cinematic blend
      contract, CI/Horde gates, and checker. Verification:
      `python3 V2/ue/Tools/check-v2-dialogue-cinematic-blend.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-system.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-camera-cut-selection.py`,
      `python3 V2/ue/Tools/check-v2-dialogue-runtime-engine.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-cinematic-blend.py`,
      `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueCinematicBlend_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `python3 V2/tools/validate-v2-docs.py`, and
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueCinematicBlend_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.7.2.15** Implement dialogue accessibility (text size scaling,
      background opacity, auto-advance toggle, TTS for dialogue text)
  - Evidence: Added `FV2DialogueAccessibilitySettings`,
    `FV2DialogueAccessibilityRequest`, `FV2DialogueAccessibilityViewModel`, and
    `BuildDialogueAccessibilityViewModel` to expose deterministic dialogue text
    scaling, background opacity, auto-advance readiness/indicator state, TTS
    queue payloads, voice selection, and missing-text failure tags for Blueprint
    UI binding. Automation covers text size scaling, opacity, completed-line
    auto advance, disabled auto-advance toggle behavior, choice suppression, TTS
    utterance construction, and missing dialogue text handling. Added an
    accessibility contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-dialogue-accessibility.py`,
    `python3 V2/ue/Tools/check-v2-dialogue-cinematic-blend.py`,
    `python3 V2/ue/Tools/check-v2-dialogue-ui.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-dialogue-accessibility.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Dialogue/DialogueAccessibility_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Dialogue/DialogueAccessibility_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.

---

### 72.8 Quest / Mission System

Reusable quest framework with objectives, tracking, journal, map integration,
and branching outcomes.

#### 72.8.1 Quest Framework

- [x] **72.8.1.1** Design quest definition format (quest ID, title, description,
      objectives, prerequisites, rewards, branching paths)
  - Evidence: Added `FV2QuestDefinition` plus objective, prerequisite, reward,
    branch, validation issue, and validation result structs in `V2Gameplay`.
    `ValidateQuestDefinition` verifies stable quest IDs, title and description
    text IDs, at least one objective, unique objective and branch IDs, valid
    prerequisite/reward type tokens, non-negative counts and amounts, start
    branch references, and branch objective references without implementing
    later quest state or tracking behavior. Automation covers the full quest
    definition shape and failure cases for missing quest ID, missing text IDs,
    missing objectives, duplicate objective IDs, and invalid branch objective
    references. Added a quest definition contract, CI/Horde gates, and focused
    checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestDefinitionFormat_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestDefinitionFormat_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.2** Implement quest state machine (inactive → available → active
      → completed/failed/abandoned, with branch states)
  - Evidence: Added `EV2QuestLifecycleState`, `EV2QuestBranchLifecycleState`,
    `EV2QuestTransitionEvent`, `FV2QuestStateSnapshot`, `FV2QuestBranchState`,
    `FV2QuestTransitionRequest`, `FV2QuestTransitionResult`, and
    `UV2QuestStateMachineLibrary` in `V2Gameplay`. The state machine initializes
    inactive quest snapshots from quest definitions, transitions inactive to
    available to active, supports branch activation and branch switching with
    locked-branch rejection, routes active quests to completed/failed/abandoned
    terminal states, preserves transition sequence counters, and rejects
    mismatched, terminal, and invalid transitions with explicit failure tags.
    Automation covers inactive branch initialization, inactive/available/active
    lifecycle, branch switching, completion, failure, abandonment, invalid
    transitions, and legal next-state reporting. Added a state machine contract,
    CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-state-machine.py`,
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-state-machine.py V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestStateMachine_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestStateMachine_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.3** Create quest objective types (go-to location, collect items,
      defeat enemies, escort NPC, defend area, solve puzzle, talk to NPC, craft
      item, reach level, survive duration)
  - Evidence: Added `EV2QuestObjectiveType`, `FV2QuestObjectiveTypeSpec`,
    `FV2QuestObjectiveTypeResolution`, and `UV2QuestObjectiveTypesLibrary` in
    `V2Gameplay`. The catalog defines `GoToLocation`, `CollectItems`,
    `DefeatEnemies`, `EscortNpc`, `DefendArea`, `SolvePuzzle`, `TalkToNpc`,
    `CraftItem`, `ReachLevel`, and `SurviveDuration` with authored type names,
    target field metadata, progress counter IDs, target/count requirements, and
    world-objective flags. Blueprint helpers resolve authored `FName` type
    tokens, enumerate specs, return canonical names, and build
    `FV2QuestObjectiveDefinition` records for quest definitions. Automation
    covers the full catalog, authored-name resolution, objective definition
    building, unknown-type rejection, and target/progress metadata. Added an
    objective types contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-objective-types.py`,
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-objective-types.py V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestObjectiveTypes_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestObjectiveTypes_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.4** Implement quest objective tracking (listen to game events,
      update objective progress counters, trigger completion)
  - Evidence: Added `FV2QuestObjectiveProgress`,
    `FV2QuestObjectiveTrackingState`, `FV2QuestGameplayEvent`,
    `FV2QuestObjectiveTrackingResult`, and `UV2QuestObjectiveTrackingLibrary` in
    `V2Gameplay`. Tracking state builds per-objective counters from quest
    definitions and objective type specs, stores completion event tags, applies
    matching gameplay events by event type and target ID, updates additive
    counters, handles absolute player-level progress, marks objectives complete
    at target count, and reports when all quest objectives are complete.
    Unmatched events and malformed quest state return explicit failure tags
    without mutating state. Automation covers progress state construction,
    matching event counters, target-count completion, absolute level progress,
    all-objectives-complete reporting, and unrelated event rejection. Added an
    objective tracking contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-quest-objective-tracking.py`,
    `python3 V2/ue/Tools/check-v2-quest-objective-types.py`,
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-objective-tracking.py V2/ue/Tools/check-v2-quest-objective-types.py V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestObjectiveTracking_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestObjectiveTracking_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.5** Create quest prerequisite system (require other quests
      completed, player level, item possession, reputation threshold)
  - Evidence: Added `EV2QuestPrerequisiteType`,
    `FV2QuestPrerequisiteTypeResolution`,
    `FV2QuestPrerequisiteEvaluationContext`, `FV2QuestPrerequisiteEvaluation`,
    `FV2QuestPrerequisiteEvaluationResult`, and `UV2QuestPrerequisitesLibrary`
    in `V2Gameplay`. The prerequisite evaluator resolves authored prerequisite
    type tokens for completed quests, player level, item possession, and
    reputation threshold gates; evaluates completed quest IDs and quest-state
    maps; checks player level, inventory counts, and reputation values;
    aggregates required and optional prerequisite counts; and returns explicit
    failure tags for unmet or malformed requirements. Automation covers
    completed quest, player level, item possession, reputation threshold,
    required-gate aggregation, optional unmet gates, unmet requirement
    rejection, and unknown prerequisite type rejection. Added a prerequisite
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-prerequisites.py`,
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-prerequisites.py V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestPrerequisites_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestPrerequisites_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.6** Implement quest reward system (XP, currency, items,
      reputation, unlock abilities, unlock areas)
  - Evidence: Added `EV2QuestRewardType`, `FV2QuestRewardTypeResolution`,
    `FV2QuestRewardApplicationState`, `FV2QuestRewardApplication`,
    `FV2QuestRewardApplicationResult`, and `UV2QuestRewardsLibrary` in
    `V2Gameplay`. Reward application resolves authored reward type tokens for
    XP, currency, item, reputation, ability unlock, and area unlock rewards;
    applies XP totals, currency balances, inventory counts, reputation values,
    unique ability unlocks, unique area unlocks, and applied reward history; and
    returns explicit failure tags for unknown or malformed reward targets.
    Automation covers XP/currency, item grants, reputation rewards, ability/area
    unlocks, aggregate application, and malformed reward rejection. Added a
    reward system contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-rewards.py`,
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-rewards.py V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestRewards_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestRewards_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.7** Create quest chain system (completing quest A unlocks quest
      B, with optional branching paths)
  - Evidence: Added `FV2QuestChainLink`, `FV2QuestChainState`,
    `FV2QuestChainUnlockResult`, and `UV2QuestChainsLibrary` in `V2Gameplay`.
    Quest definitions now generate chain links from branch `NextQuestIds`, and
    completion application records completed quests, remembers completed branch
    IDs, unlocks newly available follow-up quests, preserves already-available
    quests, and supports branch-specific follow-up paths without implementing
    broader branching outcome selection. Automation covers link construction
    from branch definitions, quest-completion unlocks, branch-specific unlocks,
    already-available tracking, and missing chain link reporting. Added a quest
    chain contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-chains.py`,
    `python3 V2/ue/Tools/check-v2-quest-definition-format.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-chains.py V2/ue/Tools/check-v2-quest-definition-format.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestChains_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `python3 V2/tools/validate-v2-docs.py`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestChains_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.8.1.8** Implement quest branching (player choices in dialogue or
      gameplay affect quest outcome and future quest availability)
  - Evidence: Added `EV2QuestBranchDecisionSource`, `FV2QuestBranchChoiceRule`,
    `FV2QuestBranchingRequest`, `FV2QuestBranchingResult`, and
    `UV2QuestBranchingLibrary` in `V2Gameplay`. Quest branch definitions now
    produce dialogue-choice or gameplay-event decision rules, support
    multi-definition rule aggregation, fall back to branch IDs when no explicit
    condition tag is authored, and apply accepted decisions through the
    quest-chain unlock path so selected branch outcomes update completed branch
    history and future quest availability. Automation covers rule building,
    multi-definition aggregation, branch-ID fallback decisions, dialogue
    choices, gameplay events, future quest availability, and unknown-choice
    rejection. Added a quest branching contract, CI/Horde gates, and focused
    checker. Verification: `python3 V2/ue/Tools/check-v2-quest-branching.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-branching.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestBranching_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestBranching_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.9** Create quest failure conditions (timer expired, NPC died,
      wrong choice made) with consequence handling
  - Evidence: Added `EV2QuestFailureConditionType`,
    `FV2QuestFailureConditionTypeResolution`, `FV2QuestFailureConditionRule`,
    `FV2QuestFailureEvent`, `FV2QuestFailureEvaluationContext`,
    `FV2QuestFailureEvaluationResult`, and `UV2QuestFailureConditionsLibrary` in
    `V2Gameplay`. Authored failure rules now resolve timer-expired, NPC-death,
    and wrong-choice condition types; match runtime failure events by quest,
    branch, timer, NPC, or choice; apply accepted failures through the quest
    state machine; preserve the authored failure outcome tag on the failed quest
    state; apply reward consequences; and unlock consequence quest IDs without
    marking the failed quest completed. Automation covers type resolution, timer
    expiration, quest fail transitions, reward consequences, consequence quest
    availability, NPC death, wrong choices, and unmatched event rejection. Added
    a quest failure conditions contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-quest-failure-conditions.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-failure-conditions.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestFailureConditions_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestFailureConditions_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.10** Implement quest save/load (persist all quest states,
      objective progress, choice history)
  - Evidence: Added `FV2QuestChoiceHistoryEntry`, `FV2QuestPersistentState`,
    `FV2QuestSaveState`, and `UV2QuestSaveLoadLibrary` in `V2Gameplay`. Quest
    save snapshots now persist all quest lifecycle snapshots, objective
    tracking/progress states, quest chain availability, reward application
    state, and branching choice history entries with choice/event IDs, selected
    branches, outcomes, future quest IDs, and world time. The save/load helpers
    record accepted branching choices, build versioned save snapshots, validate
    required save metadata and quest state integrity, and restore the aggregate
    runtime quest state deterministically. Automation covers aggregate snapshot
    validation, quest lifecycle restore, objective progress restore, choice
    history persistence, chain availability restore, reward state restore, and
    invalid snapshot rejection. Added a quest save/load contract, CI/Horde
    gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-save-load.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-save-load.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestSaveLoad_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestSaveLoad_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.11** Create quest debugging tools (force-complete objectives,
      reset quest state, advance quest stage, list all quests and states)
  - Evidence: Added `FV2QuestDebugSummary`, `FV2QuestDebugObjectiveResult`,
    `FV2QuestDebugResetResult`, `FV2QuestDebugAdvanceResult`,
    `FV2QuestDebugListResult`, and `UV2QuestDebugToolsLibrary` in `V2Gameplay`.
    Debug helpers can force-complete one objective or every objective in a
    quest, reset quest lifecycle/objective state from a quest definition,
    advance quest lifecycle stages through the existing state machine, and build
    quest summaries that list quest IDs, lifecycle state, active branch,
    completed objective counts, total objective counts, objective completion,
    and failure tags. Automation covers objective force-completion,
    all-objective force-completion, state reset, stage advancement, listing all
    quests/states, and unknown-objective rejection. Added a quest debug tools
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-debug-tools.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-debug-tools.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestDebugTools_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestDebugTools_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.12** Implement quest event system (quest state changes emit
      events for UI, dialogue, world state to react to)
  - Evidence: Added `EV2QuestEventAudience`, `EV2QuestEventType`,
    `FV2QuestEvent`, `FV2QuestEventBuildResult`, and `UV2QuestEventsLibrary` in
    `V2Gameplay`. Quest transition results now build routed state-change events
    for UI, dialogue, and world-state consumers, including terminal completion
    and failure events. Objective tracking results build UI progress events and
    UI/world-state objective-completion events. Branching results build
    UI/dialogue/world-state branch outcome events plus UI/world-state future
    quest availability events. Event payloads include sequence, audience, type,
    quest ID, from/to lifecycle state, objective ID, branch ID, payload tag,
    related future quest IDs, and failure tags. Automation covers state-change
    events, terminal quest events, objective progress events, branch outcome
    events, UI/dialogue/world-state routing, and rejected source results. Added
    a quest event system contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-quest-events.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-events.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestEvents_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestEvents_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.13** Create quest validation tool (verify all quests are
      completable, no orphaned objectives, no circular prerequisites)
  - Evidence: Added `FV2QuestCatalogValidationIssue`,
    `FV2QuestCatalogValidationResult`, and `UV2QuestValidationLibrary` in
    `V2Gameplay`. The catalog validator composes the existing single-quest
    definition validator with cross-quest checks for empty catalogs, duplicate
    quest IDs, unknown quest-completed prerequisite references, unknown future
    quest unlock references, branch orphaned objectives, and circular
    quest-completed prerequisite graphs. Public helpers expose catalog cycle
    checks, per-quest completable-path checks, and full catalog validation with
    structured issue records. Automation covers completable catalogs, orphaned
    objectives, unknown prerequisite quests, unknown future quests, duplicate
    quest IDs, and circular prerequisites. Added a quest validation tool
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-validation-tool.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-validation-tool.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestValidationTool_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestValidationTool_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.14** Implement parallel quest tracking (multiple active quests,
      primary/secondary quest designation)
  - Evidence: Added `EV2QuestTrackingPriority`, `FV2TrackedQuestEntry`,
    `FV2QuestParallelTrackingState`, `FV2QuestParallelTrackingResult`, and
    `UV2QuestParallelTrackingLibrary` in `V2Gameplay`. The aggregate tracker
    builds active quest lists from existing persistent quest/objective state,
    preserves one primary quest plus secondary active quests, rejects duplicate
    active quest rows and inactive primary selection, routes a gameplay
    objective event across all active quests, records which quest objectives
    accepted the event, and syncs updated per-quest lifecycle/objective state
    back into `FV2QuestPersistentState`. Automation covers multiple active
    quests, primary/secondary designation, primary switching, cross-active event
    routing, persistent runtime sync, duplicate active quest rejection, and
    inactive primary rejection. Added a quest parallel tracking contract,
    CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-parallel-tracking.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-parallel-tracking.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestParallelTracking_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestParallelTracking_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.1.15** Create quest template system (predefined quest patterns for
      rapid authoring: fetch quest, bounty, escort, investigation)
  - Evidence: Added `EV2QuestTemplatePattern`, `FV2QuestTemplateAuthoringInput`,
    `FV2QuestTemplateBuildResult`, and `UV2QuestTemplatesLibrary` in
    `V2Gameplay`. The template system emits normal `FV2QuestDefinition` assets
    for fetch quests, bounties, escorts, and investigations by mapping authoring
    inputs onto existing objective types, rewards, default branches, follow-up
    quest links, category tags, and region/level metadata. Every generated
    definition is finalized through the existing quest definition validator so
    invalid authoring inputs or malformed generated definitions return
    structured failure tags. Automation covers all four template patterns,
    generated definition validation, reward/branch wiring, follow-up quest
    links, and invalid authoring input rejection. Added a quest template
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-templates.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-templates.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Quests/QuestTemplates_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Quests/QuestTemplates_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.

#### 72.8.2 Quest UI & Map Integration

- [x] **72.8.2.1** Implement quest journal UI (list active/completed/failed
      quests, expandable details, objective checklist)
  - Evidence: Added `UV2QuestJournalScreen`, `FV2QuestJournalScreenSpec`,
    `FV2QuestJournalViewState`, `FV2QuestJournalEntry`,
    `FV2QuestJournalObjectiveRow`, and `UV2QuestJournalViewModel` in `V2UI`. The
    journal consumes existing quest persistent state, quest definitions, and
    objective tracking rows to list active, completed, and failed quests, select
    the primary quest for detail context, filter by lifecycle state, expand and
    collapse quest detail rows, and expose objective checklist progress through
    Blueprint/MVVM-friendly structs. The existing `ModeSpecific.QuestLog` route
    now points at the dedicated quest journal widget class. Automation covers
    spec validation, active/completed/failed list counts, primary quest details,
    completed filtering, expandable checklist behavior, viewmodel mirroring, and
    route wiring. Added a quest journal UI contract, CI/Horde gates, and focused
    checker. Verification: `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-journal-ui.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestJournalUI_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestJournalUI_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.2** Create quest tracker HUD element (show current quest
      objectives on-screen with progress indicators)
  - Evidence: Added `UV2QuestTrackerHUDWidget`, `FV2QuestTrackerHUDSpec`,
    `FV2QuestTrackerHUDState`, `FV2QuestTrackerObjectiveRow`, and
    `UV2QuestTrackerHUDViewModel` in `V2UI`. The HUD tracker consumes existing
    quest persistent state, definitions, and objective tracking progress to
    choose the primary/current quest, expose visible objective rows, show
    per-objective progress fractions, compute overall completion progress,
    switch tracked quests, and keep stable reduced-motion HUD dimensions. Added
    `UV2UISubsystem` apply/get/clear hooks so the tracker enters the normal
    `FV2HUDSlotState` path as `HUD.QuestTracker.V2` in `Slot.TopRight`.
    Automation covers spec validation, HUD entry wiring, primary quest
    selection, current objective rows, progress indicators, quest switching,
    viewmodel mirroring, and subsystem apply/clear. Added a quest tracker HUD
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-tracker-hud.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-tracker-hud.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestTrackerHUD_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestTrackerHUD_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.3** Implement quest waypoint system (compass and screen-edge
      indicators pointing to current objective location)
  - Evidence: Added `UV2QuestWaypointHUDWidget`, `FV2QuestWaypointHUDSpec`,
    `FV2QuestWaypointTarget`, `FV2QuestWaypointProjectionContext`,
    `FV2QuestWaypointIndicator`, `FV2QuestWaypointHUDState`, and
    `UV2QuestWaypointHUDViewModel` in `V2UI`. The waypoint system accepts
    current objective world targets plus player/camera/viewport context, sorts
    the current objective first, computes compass bearings and offset
    percentages, converts Unreal world distance to meters, and projects
    off-screen objectives to safe-area-clamped screen-edge indicator positions.
    Added `UV2UISubsystem` apply/get/clear hooks so the waypoint overlay enters
    the normal `FV2HUDSlotState` path as `HUD.QuestWaypointSystem.V2` in
    `Slot.ScreenEffects`. Automation covers spec validation, HUD entry wiring,
    current objective selection, forward compass projection, right and rear
    screen-edge clamping, distance meters, viewmodel mirroring, and subsystem
    apply/clear in `QuestWaypointSystem.spec.cpp`. Added a quest waypoint system
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-waypoint-system.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-waypoint-system.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestWaypointSystem_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestWaypointSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.4** Create quest map markers (icons on world map for quest
      givers, objectives, turn-in locations with type differentiation)
  - Evidence: Added `UV2QuestMapMarkersScreen`, `FV2QuestMapMarkerScreenSpec`,
    `FV2QuestMapMarker`, `FV2QuestMapMarkerLayerState`, `EV2QuestMapMarkerType`,
    and `UV2QuestMapMarkersViewModel` in `V2UI`. The marker layer models quest
    giver, objective, and turn-in marker types with canonical differentiated
    icon/accent tags, normalized world-map positions, tracked-marker selection,
    visible/discovered filtering, per-type marker groups, and screen-reader
    marker summary state. Registered the `ModeSpecific.QuestMap` route under
    `ModeSpecificUI` with the dedicated quest map marker widget. Automation in
    `QuestMapMarkers.spec.cpp` covers spec validation, route wiring, type
    differentiation, normalized positions, tracked objective selection, type
    filtering, turn-in selection, and viewmodel mirroring. Added a quest map
    markers contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-map-markers.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-map-markers.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestMapMarkers_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestMapMarkers_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.5** Implement quest area highlighting (highlight region on map
      where objective can be completed)
  - Evidence: Added `UV2QuestAreaHighlightsScreen`,
    `FV2QuestAreaHighlightScreenSpec`, `FV2QuestAreaHighlight`,
    `FV2QuestAreaHighlightLayerState`, and `UV2QuestAreaHighlightsViewModel` in
    `V2UI`. The area layer models objective completion regions as normalized
    world-map polygons, validates visible uncompleted quest/objective areas,
    computes normalized bounds and centroid values for rendering, applies soft
    fill/outline style tags, clamps readable fill opacity, selects tracked areas
    first, and exposes screen-reader summary state. Registered the
    `ModeSpecific.QuestAreas` route as a child of `ModeSpecific.QuestMap`.
    Automation in `QuestAreaHighlights.spec.cpp` covers spec validation,
    objective-region support, valid polygon filtering, tracked selection,
    bounds/centroid computation, alternate selection, viewmodel mirroring, and
    route wiring. Added a quest area highlights contract, CI/Horde gates, and
    focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-area-highlights.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-area-highlights.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestAreaHighlights_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestAreaHighlights_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.6** Create quest notification system (toast notifications for
      quest accepted, objective completed, quest completed, quest failed)
  - Evidence: Added `V2QuestNotificationToasts` in `V2UI` with
    `EV2QuestNotificationToastType`, `FV2QuestNotificationToastContext`,
    `FV2QuestNotificationToastTemplate`, `FV2QuestNotificationToastBuildResult`,
    `FV2QuestNotificationToastCatalog`, `UV2QuestNotificationToastWidget`, and
    `UV2QuestNotificationToastViewModel`. The catalog maps UI-routed quest
    events to existing notification toast queue entries for quest accepted,
    objective completed, quest completed, and quest failed states, routes
    actions to `ModeSpecific.QuestLog`, reuses the existing
    `Frontend.NotificationToasts` surface, preserves priority/cooldown handling,
    and keeps the UI controller non-modal, screen-reader announced,
    reduced-motion safe, and cardless. Added Blueprint helpers and
    `UV2UISubsystem` registration/build/queue APIs including
    `QueueQuestNotificationEvent`. Automation in
    `QuestNotificationToasts.spec.cpp` covers default catalog validation, all
    four toast builders, quest-event mapping, non-UI event rejection, widget
    support, subsystem queueing, viewmodel filtering, and config exposure. Added
    a quest notification toast contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-quest-notification-toasts.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-notification-toasts.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestNotificationToasts_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestNotificationToasts_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.7** Implement quest breadcrumb trail (optional visual path in
      world leading to objective, togglable for difficulty)
  - Evidence: Added `V2QuestBreadcrumbTrailWidget` in `V2UI` with
    `EV2QuestBreadcrumbTrailDifficultyMode`, `FV2QuestBreadcrumbTrailRequest`,
    `FV2QuestBreadcrumbTrailPoint`, `FV2QuestBreadcrumbTrailState`,
    `FV2QuestBreadcrumbTrailSpec`, `UV2QuestBreadcrumbTrailWidget`, and
    `UV2QuestBreadcrumbTrailViewModel`. The trail builds optional,
    gameplay-inert world breadcrumbs from nav path points or a direct
    player-to-objective fallback, spaces markers in meters, includes an
    objective endpoint, marks turn points, fades with distance while preserving
    stable dimensions, and supports difficulty modes where `Guided` shows the
    path, `Minimal` only shows when the player requests guidance, and `Off`
    hides it. Added `UV2UISubsystem` apply/get/clear APIs via
    `ApplyQuestBreadcrumbTrail`, `GetActiveQuestBreadcrumbTrail`, and
    `ClearQuestBreadcrumbTrail` for the optional `Slot.ScreenEffects` HUD
    injection. Automation in `QuestBreadcrumbTrail.spec.cpp` covers spec
    validation, optional HUD entry routing, nav path sampling, stable
    world-space spacing, turn/objective markers, distance fading without
    animation dependence, difficulty toggling, viewmodel mirroring, and
    subsystem lifecycle. Added a quest breadcrumb trail contract, CI/Horde
    gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-quest-breadcrumb-trail.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-breadcrumb-trail.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestBreadcrumbTrail_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestBreadcrumbTrail_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.8** Create quest difficulty indicators (level recommendation,
      estimated duration, combat intensity)
  - Evidence: Added `V2QuestDifficultyIndicators` in `V2UI` with
    `EV2QuestDifficultyLevelBand`, `EV2QuestEstimatedDurationBand`,
    `EV2QuestCombatIntensity`, `FV2QuestDifficultyMetadata`,
    `FV2QuestDifficultyIndicatorInput`, `FV2QuestDifficultyIndicator`,
    `FV2QuestDifficultyIndicatorSet`, `FV2QuestDifficultyIndicatorSpec`,
    `UV2QuestDifficultyIndicatorWidget`, and
    `UV2QuestDifficultyIndicatorViewModel`. The resolver builds visible
    recommended-level, estimated-duration, and combat-intensity indicators from
    quest definitions plus explicit quest difficulty metadata; computes
    matched/challenging/dangerous and easy/trivial level bands against player
    level; maps duration into short/standard/long/extended bands; exposes combat
    intensity pips and label IDs; and keeps the UI screen-reader summarized,
    controller non-modal, reduced-motion safe, stable, and cardless. Added
    metadata-aware journal and tracker paths through
    `ApplyQuestJournalStateWithDifficulty` and
    `ApplyQuestTrackerStateWithDifficulty`, with difficulty indicators stored on
    journal entries and tracker HUD state. Automation in
    `QuestDifficultyIndicators.spec.cpp` covers spec validation, metadata
    resolution, recommended-level warning, duration banding, combat pips, widget
    support, focused indicator sets, viewmodel mirroring, journal entry
    integration, tracker HUD integration, and tracker viewmodel mirroring. Added
    a quest difficulty indicators contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-quest-difficulty-indicators.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-difficulty-indicators.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestDifficultyIndicators_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestDifficultyIndicators_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.9** Implement quest sorting and filtering in journal (by type,
      region, difficulty, completion status)
  - Evidence: Added `FV2QuestJournalQuery` with lifecycle, type/category,
    region, difficulty band, completion-status, sort-mode, sort-direction, and
    primary-first controls. `UV2QuestJournalScreen` now exposes
    `ApplyQuestJournalQuery`, `SetQuestJournalSort`, `ClearQuestJournalQuery`,
    and `SupportsQuestJournalSortingFiltering`; rebuilds the journal through
    `DoesEntryMatchQuery`, `DoesEntryMatchCompletionFilter`, and
    `SortQuestJournalEntriesByQuery`; preserves query state across journal
    refresh, selection, and expansion; and mirrors `ActiveQuery` plus
    `bSortingFilteringActive` through `UV2QuestJournalViewModel`. Automation in
    `QuestJournalSortingFiltering.spec.cpp` covers filtering by type/region,
    filtering by difficulty, filtering by completion status, sorting by
    difficulty, region, type, and completion, viewmodel query mirroring, and
    clearing the query back to primary-first defaults. Added
    `QuestJournalSortingFiltering_V2_Contract.json`,
    `check-v2-quest-journal-sorting-filtering.py`, CI workflow coverage, Horde
    gates, and `check-v2-ui-module.py` coverage for the new spec and Blueprint
    API. Verification:
    `python3 V2/ue/Tools/check-v2-quest-journal-sorting-filtering.py`,
    `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-journal-sorting-filtering.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestJournalSortingFiltering_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestJournalSortingFiltering_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.10** Create quest reward preview in journal (show rewards before
      accepting quest)
  - Evidence: Added `FV2QuestJournalRewardPreviewRow` to journal entries with
    reward ID/type, target IDs, quantity, amount, icon tag, and
    `bPreviewInJournal` metadata sourced from `FV2QuestRewardDefinition`.
    Journal entries now expose `RewardPreviews`, `RewardPreviewCount`,
    `bHasRewardPreview`, and `bAvailableForAcceptance`; all-state journal views
    include `EV2QuestLifecycleState::Available` quests so previewable rewards
    are visible before acceptance, and `EV2QuestJournalFilter::Available` can
    isolate those offers. `UV2QuestJournalScreen` now exposes
    `GetSelectedQuestRewardPreviews` and `SupportsQuestRewardPreview`; the
    viewmodel mirrors selected reward previews, available quest counts, selected
    preview counts, visible preview counts, and reward-preview availability.
    Automation in `QuestJournalRewardPreview.spec.cpp` covers available quest
    previews before acceptance, XP/currency preview rows, item/unlock preview
    rows, hidden `bPreviewInJournal = false` rewards, available filtering, and
    viewmodel mirroring. Added `QuestJournalRewardPreview_V2_Contract.json`,
    `check-v2-quest-journal-reward-preview.py`, CI workflow coverage, Horde
    gates, and `check-v2-ui-module.py` coverage for the reward preview UI API.
    Verification:
    `python3 V2/ue/Tools/check-v2-quest-journal-reward-preview.py`,
    `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
    `python3 V2/ue/Tools/check-v2-quest-journal-sorting-filtering.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-journal-reward-preview.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestJournalRewardPreview_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestJournalRewardPreview_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.11** Implement quest pin/unpin (choose which quest appears in
      tracker HUD)
  - Evidence: Added journal-side pin state with `PinnedQuestId`,
    `bPinnedToTracker`, `bHasPinnedQuest`, `PinQuestJournalEntry`,
    `UnpinQuestJournalEntry`, `GetPinnedQuestId`, and `SupportsQuestPinUnpin`,
    including rejection of unavailable quests that are not eligible for tracker
    display. Added tracker-side pin selection with `PinnedQuestId`,
    `bPinnedQuest`, `bCanUnpinQuest`, `bAllowQuestPinning`,
    `bAllowQuestUnpinning`, `PinTrackedQuest`, `UnpinTrackedQuest`, and
    `SupportsQuestPinning`; pinned quests now override primary quest fallback
    until unpinned, and unpinning clears the override so the tracker returns to
    primary/fallback behavior. Journal and tracker viewmodels mirror pinned
    quest IDs and pin flags. Automation in `QuestPinUnpin.spec.cpp` covers
    journal pinning, journal unavailable-quest rejection, journal unpinning,
    tracker pin precedence, tracker unpin fallback to primary, and both
    viewmodel mirrors. Added `QuestPinUnpin_V2_Contract.json`,
    `check-v2-quest-pin-unpin.py`, CI workflow coverage, Horde gates, and
    `check-v2-ui-module.py` coverage for the pin/unpin APIs. Verification:
    `python3 V2/ue/Tools/check-v2-quest-pin-unpin.py`,
    `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
    `python3 V2/ue/Tools/check-v2-quest-tracker-hud.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-quest-pin-unpin.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestPinUnpin_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestPinUnpin_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
    and `git diff --check`.
- [x] **72.8.2.12** Create quest UI accessibility (screen reader support for
      quest text, high-contrast markers) — Added
      `FV2QuestUIAccessibilityDescriptor` in `V2QuestUIAccessibility.h` plus
      journal/tracker integration for screen-reader quest summaries,
      objective-progress announcements, non-color-only `HighContrastMarkerTags`,
      selected/tracked accessibility descriptors,
      `GetSelectedQuestAccessibilityDescriptor`,
      `GetQuestTrackerAccessibilityDescriptor`, `SupportsQuestUIAccessibility`,
      and MVVM mirrors for `ScreenReaderSummary` and high-contrast marker tags.
      Added `QuestUIAccessibility.spec.cpp`,
      `QuestUIAccessibility_V2_Contract.json`,
      `check-v2-quest-ui-accessibility.py`, CI workflow coverage, Horde gates,
      and `check-v2-ui-module.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-quest-ui-accessibility.py`,
      `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
      `python3 V2/ue/Tools/check-v2-quest-tracker-hud.py`,
      `python3 V2/ue/Tools/check-v2-ui-module.py`,
      `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-quest-ui-accessibility.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
      `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestUIAccessibility_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestUIAccessibility_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
      and `git diff --check`.
- [x] **72.8.2.13** Implement quest completion statistics (track total quests
      completed, completion percentage, time spent) — Added persisted
      `FV2QuestCompletionRecord` data and aggregate
      `FV2QuestCompletionStatistics` with `RecordQuestCompletionTime` and
      `BuildQuestCompletionStatistics` helpers. The quest journal now exposes
      `CompletionStatistics`, `CompletionPercentage`, `TotalTimeSpentSeconds`,
      `AverageTimeSpentSeconds`, `GetQuestCompletionStatistics`, and
      `SupportsQuestCompletionStatistics`, with MVVM mirrors for total quests,
      completed quests, timed completions, completion percentage, total time,
      average time, and all-complete state. Added
      `QuestCompletionStatistics.spec.cpp`,
      `QuestCompletionStatistics_V2_Contract.json`,
      `check-v2-quest-completion-statistics.py`, CI workflow coverage, Horde
      gates, and `check-v2-ui-module.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-quest-completion-statistics.py`,
      `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
      `python3 V2/ue/Tools/check-v2-quest-save-load.py`,
      `python3 V2/ue/Tools/check-v2-ui-module.py`,
      `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-quest-completion-statistics.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
      `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestCompletionStatistics_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestCompletionStatistics_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
      and `git diff --check`.
- [x] **72.8.2.14** Create quest UI localization support (all quest text
      references string IDs, dynamic text insertion) — Added shared
      `FV2QuestUILocalizationArgument` and `FV2QuestUILocalizedTextBinding`
      runtime structs, with `DynamicTextArguments`, `SourceStringId`,
      `FormatStringId`, `bUsesStringId`, and `bDynamicTextInsertion` metadata
      for named dynamic insertion. The quest journal now exposes
      `LocalizationBindings`, `SelectedLocalizationBindings`,
      `bQuestTextUsesStringIds`, `bDynamicQuestTextInsertion`,
      `GetSelectedQuestLocalizationBindings`, and `SupportsQuestUILocalization`;
      the quest tracker mirrors `LocalizationBindings`,
      `GetQuestTrackerLocalizationBindings`, and `SupportsQuestUILocalization`.
      Added `QuestUILocalization.spec.cpp`,
      `QuestUILocalization_V2_Contract.json`,
      `check-v2-quest-ui-localization.py`, CI workflow coverage, Horde gates,
      and `check-v2-ui-module.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-quest-ui-localization.py`,
      `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
      `python3 V2/ue/Tools/check-v2-quest-tracker-hud.py`,
      `python3 V2/ue/Tools/check-v2-quest-ui-accessibility.py`,
      `python3 V2/ue/Tools/check-v2-ui-module.py`,
      `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-quest-ui-localization.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-ui-module.py`,
      `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestUILocalization_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestUILocalization_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
      and `git diff --check`.
- [x] **72.8.2.15** Implement quest UI documentation and styling guide — Added
      `quest-ui-documentation-and-styling-guide.md` with `Source Of Truth`,
      `Surface Inventory`, `Layout And Density`, `Quest Journal Styling`,
      `Tracker HUD Styling`, `Navigation And World Cues`,
      `Notifications And Feedback`, `Accessibility And Localization`,
      `Authoring Workflow`, `Review Checklist`, and `Validation Commands`
      sections covering quest journal, tracker HUD, map markers, area
      highlights, waypoints, breadcrumb trails, quest toasts, difficulty
      indicators, reward preview, pin/unpin, completion statistics,
      screen-reader summaries, string IDs, dynamic insertion, reduced-motion
      policy, and cardless layout policy. Added
      `QuestUIDocumentationStyleGuide_V2_Contract.json`,
      `check-v2-quest-ui-documentation-style-guide.py`, CI workflow coverage,
      and Horde gates. Verification:
      `python3 V2/ue/Tools/check-v2-quest-ui-documentation-style-guide.py`,
      `python3 V2/ue/Tools/check-v2-quest-journal-ui.py`,
      `python3 V2/ue/Tools/check-v2-quest-tracker-hud.py`,
      `python3 V2/ue/Tools/check-v2-quest-ui-accessibility.py`,
      `python3 V2/ue/Tools/check-v2-quest-ui-localization.py`,
      `python3 V2/ue/Tools/check-v2-ui-module.py`,
      `for checker in V2/ue/Tools/check-v2-quest-*.py; do python3 "$checker"; done`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-quest-ui-documentation-style-guide.py V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 -m json.tool V2/ue/Content/V2/UI/Quest/QuestUIDocumentationStyleGuide_V2_Contract.json`,
      `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
      `pnpm exec prettier --check V2/docs/modes/quest-ui-documentation-and-styling-guide.md .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/UI/Quest/QuestUIDocumentationStyleGuide_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`,
      and `git diff --check`.

---

### 72.9 Inventory / Item System

Item database, inventory containers, equipment, crafting, loot tables, and item
rarity.

#### 72.9.1 Item Framework

- [x] **72.9.1.1** Design item definition schema (item ID, name, description,
      icon, mesh, weight, value, max stack size, categories, tags, rarity)
  - Evidence: Added `FV2ItemDefinition` with stable item ID, localized name and
    description text IDs, icon and mesh soft object references, weight, value,
    max stack size, category list, tag list, and rarity fields. Added
    `EV2ItemCategory` and `EV2ItemRarity`, plus `ValidateItemDefinition`
    coverage for missing IDs/text, missing visual references, invalid
    economy/stack values, missing or duplicate categories/tags, invalid category
    entries, and unsupported rarity values. Automation covers the valid schema
    shape and all major failure modes, with a contract, CI/Horde gates, and
    focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemDefinitionSchema_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemDefinitionSchema_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.2** Implement item database (register all item definitions, query
      by ID/category/tag, runtime lookup)
  - Evidence: Added `UV2ItemDatabase` as a `UDataAsset`-backed registry for
    `FV2ItemDefinition` records. It validates definitions through
    `ValidateItemDefinition`, supports single and batch registration, duplicate
    rejection with opt-in replacement, unregistering, explicit lookup rebuilds,
    cached runtime maps for item ID/category/tag queries, and Blueprint-callable
    lookup helpers. Automation covers runtime registration, ID lookup, category
    lookup, tag lookup, duplicate/replacement behavior, invalid-definition
    rejection, unregister cleanup, and batch registration cache rebuilds. Added
    an item database contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemDatabase_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemDatabase_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.3** Create item instance system (unique instances with
      durability, enchantments, custom data distinct from definition template)
  - Evidence: Added `FV2ItemInstance` records that store unique instance IDs,
    definition `ItemId` references, stack counts, durability, max durability,
    per-instance enchantments, and custom data without copying the full
    definition template. Added `FV2ItemInstanceEnchantment`, validation issues
    and results, plus helpers for creating instances from definitions,
    validating stack/durability/template alignment, applying durability deltas,
    adding unique enchantments, setting custom data, and checking duplicate
    instance IDs across collections. Automation covers unique instance creation,
    stack validation against definition max stack size, durability independence,
    per-instance enchantments, per-instance custom data, duplicate ID rejection,
    and mismatched definition ID rejection. Added an item instance contract,
    CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemInstanceSystem_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemInstanceSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.4** Implement item rarity/quality tiers (common, uncommon, rare,
      epic, legendary — affects stats, visual, drop rate)
  - Evidence: Added `FV2ItemRarityTier` tuning records for common, uncommon,
    rare, epic, and legendary items with rarity tags, localized display text
    IDs, visual style tags, accent colors, stat multipliers, value multipliers,
    and drop weights. Added validation for missing/duplicate tiers, missing
    display or visual metadata, invalid multipliers, and invalid drop weights,
    plus helpers for default tier construction, tier lookup, stat/value scaling,
    total drop weight, and per-rarity drop chance. Automation covers the five
    required rarity values, stat/value scaling, visual styling, drop-weight
    calculations, item-definition rarity lookup, and invalid tier rejection.
    Added an item rarity tier contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemRarityTiers_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemRarityTiers_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.5** Create item categories (weapon, armor, consumable, material,
      key item, quest item, cosmetic, currency)
  - Evidence: Added `FV2ItemCategoryDefinition` records for weapon, armor,
    consumable, material, key item, quest item, cosmetic, and currency with
    stable category tags, localized display and description text IDs, icon tags,
    inventory sort groups, and default traits for equippable, stackable, and
    quest-critical behavior. Added helpers for default category construction,
    required category enumeration, category lookup, item-definition category
    membership checks, and validation for missing, duplicate, invalid, or
    incomplete categories. Automation covers all required category values,
    metadata, traits, category membership, and invalid category definitions.
    Added an item categories contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemCategories_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemCategories_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.6** Implement item stat modifiers (strength +5, fire resistance
      +10%, speed -5% — composable stat effects)
  - Evidence: Added `FV2ItemStatModifier` with stable modifier IDs, stat tags,
    flat/percent/multiply/override operations, magnitudes, source item IDs,
    source tags, and equipped-state metadata. Added deterministic composition
    helpers that filter modifiers by stat tag and apply flat deltas, percentage
    deltas from the base value, multiplicative factors, and overrides into an
    `FV2ItemStatModifierApplicationResult`. Validation catches missing or
    duplicate modifier IDs, missing stat tags, unsupported operations, invalid
    percent reductions, and invalid multipliers. Automation covers strength +5,
    fire resistance +10%, speed -5%, deterministic flat/percent/multiply
    composition, stat-tag filtering, and invalid modifier rejection. Added an
    item stat modifier contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemStatModifiers_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemStatModifiers_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.7** Create item set bonuses (equip 2/4/6 pieces of set for
      escalating bonuses)
  - Evidence: Added `FV2ItemSetDefinition` and `FV2ItemSetBonusThreshold` data
    for item sets with stable set IDs, localized set/bonus text IDs, set-piece
    item IDs, and stat modifier payloads. Added a default six-piece Storm
    Regalia set with escalating 2/4/6-piece bonuses for strength, fire
    resistance, and speed. Added Blueprint helpers to find set definitions,
    count unique equipped set pieces while ignoring duplicate/non-set items,
    evaluate active bonuses for one or all sets, collect active stat modifiers,
    and validate item set data. Validation catches missing or duplicate set IDs,
    missing metadata, too-few/duplicate set pieces, invalid or duplicate
    thresholds, unreachable thresholds, missing modifiers, and invalid modifier
    payloads. Automation covers inactive sub-threshold sets, 2-piece activation,
    combined 2/4-piece activation, full 6-piece activation, active stat modifier
    collection, duplicate equipped item handling, and invalid data rejection.
    Added an item set bonuses contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemSetBonuses_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemSetBonuses_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.8** Implement item durability and degradation (use reduces
      durability, broken items lose effectiveness, repair costs)
  - Evidence: Added `FV2ItemDurabilityProfile` data for durable item max
    durability, wear per use, low-durability threshold, broken effectiveness
    multiplier, repair cost per durability point, break-at-zero behavior, and
    repair eligibility. Added use and repair result structs that report
    previous/new durability, consumed/restored durability, broken-before/after
    state, break-on-use detection, effectiveness multipliers, and repair costs.
    Added default weapon, armor, and tool profiles plus Blueprint helpers to
    initialize item instance durability, apply use wear, calculate durability
    ratio, detect broken items, compute degraded effectiveness, calculate repair
    cost, repair durability, find profiles, and validate profile data.
    Automation covers use reducing durability, low-durability degradation,
    broken item effectiveness loss, repair cost calculation, partial repairs,
    and invalid profile/repair rejection. Added an item durability contract,
    CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemDurability_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemDurability_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.9** Create item enchantment/socket system (add modifiers to items
      via gems, runes, or enchanting)
  - Evidence: Added `FV2ItemSocketDefinition`, `FV2ItemSocketState`,
    `FV2ItemSocketOccupant`, and `FV2ItemEnchantmentRecipe` data for gem/rune
    sockets and enchantment recipes backed by composable item stat modifiers.
    Added default gem and rune sockets plus Flame Edge and Wind Step enchantment
    recipes. Added Blueprint helpers to initialize socket state, socket
    compatible gem/rune occupants, reject occupied or incompatible sockets,
    remove socket occupants, apply enchantment recipes to item instances,
    collect active socket modifiers, collect active enchantment modifiers from
    instance enchantment markers, combine socket and enchantment modifiers, and
    validate socket/recipe data. Validation catches missing or duplicate socket
    IDs, missing socket tags, missing accepted item tags, missing or duplicate
    recipe IDs, missing enchantment IDs, missing rune requirements, invalid rune
    counts, invalid crafting costs, missing recipe modifiers, and invalid
    modifier payloads. Automation covers gem/rune socket definitions, empty
    state initialization, allowed gem socketing, granted stat modifier
    application, occupied/incompatible socket rejection, recipe application to
    item instances, combined modifier collection, and invalid data rejection.
    Added an item enchantment sockets contract, CI/Horde gates, and focused
    checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-enchantment-sockets.py V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemEnchantmentSockets_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemEnchantmentSockets_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.10** Implement item comparison tooltip (show stat differences
      between equipped and inspected item)
  - Evidence: Added a Blueprint-friendly item comparison tooltip model with stat
    inputs, stat delta rows, tooltip surface metadata, inspected/equipped item
    identity, positive/negative/equal delta counts, stable dimension metadata,
    delta glyph tags, and accessibility summary metadata. Added helpers to
    compose equipped and inspected item stat values from the item stat modifier
    system, build deterministic tooltip rows, classify deltas as
    better/worse/equal, map directions to stable glyph tags, build complete
    comparison tooltip payloads, and validate tooltip integrity. Automation
    covers equipped-versus-inspected row generation, positive/negative/equal
    counts, lower-is-better stat handling, stable glyph/accessibility metadata,
    and rejection of missing IDs, missing row data, missing glyphs, or unstable
    layout metadata. Added an item comparison tooltip contract, CI/Horde gates,
    and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-comparison-tooltip.py V2/ue/Tools/check-v2-item-enchantment-sockets.py V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemComparisonTooltip_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemComparisonTooltip_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.11** Create item preview (3D model viewer for inspecting items
      before equip/purchase)
  - Evidence: Added a Blueprint-friendly item preview model for 3D item
    inspection before equip or purchase. The preview payload carries stable
    model viewer surface metadata, item identity, icon and mesh references from
    the item definition, rarity, inspect/equip/purchase context, camera bounds,
    orbit/zoom/turntable settings, lighting/background/rarity accent tags, equip
    and purchase action state, stable dimension metadata, and accessibility
    summary metadata. Added helpers to build default camera rigs from mesh
    bounds, build rarity-aware lighting rigs, map action text for
    inspect/equip/purchase flows, build complete item preview payloads, and
    validate preview integrity. Automation covers mesh viewer payloads from item
    definitions, orbit/zoom camera controls with stable bounds, rarity accent
    and lighting metadata, equip and purchase action states, and rejection of
    missing mesh, invalid camera, missing action, or unstable layout metadata.
    Added an item preview contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-item-preview.py`,
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-preview.py V2/ue/Tools/check-v2-item-comparison-tooltip.py V2/ue/Tools/check-v2-item-enchantment-sockets.py V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemPreview_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemPreview_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.12** Implement item serialization and save/load (persist full
      item state including instance data)
  - Evidence: Added versioned item serialization/save-load support for full item
    instance state. Serialized item payloads persist instance IDs, item
    definition IDs, stack counts, durability and max durability, per-instance
    enchantments, and deterministic custom data entries; item save states group
    serialized instances under a stable save ID. Added Blueprint helpers to
    serialize a single item instance, build item save states, restore serialized
    instances, restore save-state collections, validate individual serialized
    instances, and validate aggregate item save states. Validation rejects
    invalid versions, missing save IDs, missing or duplicate instance IDs,
    missing item IDs, invalid stack/durability values, incomplete or duplicate
    enchantments, and missing or duplicate custom data keys. Automation covers
    full instance persistence, instance round trips, versioned save-state
    creation, collection restore, enchantment/custom-data preservation, and
    corrupt-save rejection. Added an item serialization contract, CI/Horde
    gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-serialization.py`,
    `python3 V2/ue/Tools/check-v2-item-preview.py`,
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-serialization.py V2/ue/Tools/check-v2-item-preview.py V2/ue/Tools/check-v2-item-comparison-tooltip.py V2/ue/Tools/check-v2-item-enchantment-sockets.py V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemSerialization_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemSerialization_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.13** Create item validation tool (verify all items have valid
      references, meshes, icons, balanced stats)
  - Evidence: Added a Blueprint-friendly item catalog validation tool that
    audits item definitions, visual asset references, duplicate item IDs,
    equippable stat profiles, stat modifier payloads, and balance-rule ranges.
    The tool provides stat profile inputs, balance rule records, blocking issue
    rows, and aggregate reports with item, reference, visual, duplicate, stat
    profile, and balance counts. Added helpers for default balance rules,
    stat-profile lookup, icon/mesh reference checks, per-profile stat balance
    checks, and full catalog validation. Automation covers valid catalog
    acceptance, icon/mesh reference validation, duplicate and invalid reference
    detection, stat balance rule failures, invalid stat modifier payloads, and
    missing balance profiles for equippable items. Added an item validation tool
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-validation-tool.py`,
    `python3 V2/ue/Tools/check-v2-item-serialization.py`,
    `python3 V2/ue/Tools/check-v2-item-preview.py`,
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-validation-tool.py V2/ue/Tools/check-v2-item-serialization.py V2/ue/Tools/check-v2-item-preview.py V2/ue/Tools/check-v2-item-comparison-tooltip.py V2/ue/Tools/check-v2-item-enchantment-sockets.py V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemValidationTool_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemValidationTool_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.14** Implement item localization (name, description per locale)
  - Evidence: Added item localization tables for per-locale item names and
    descriptions. Localized entries are keyed by item ID and locale while
    preserving the item definition's name and description text IDs; item
    localization tables define a source locale and support required-locale
    coverage checks. Added helpers to build localized item rows from item
    definitions, find item-locale rows, resolve localized names/descriptions
    with source-locale fallback, calculate coverage across item definitions and
    required locales, and validate tables for duplicate rows, unknown items,
    mismatched text IDs, missing required locales, and empty localized text.
    Automation covers per-locale resolution, source-locale fallback, complete
    coverage reporting, text ID/string validation, missing locale and empty text
    rejection, and duplicate or mismatched text ID rejection. Added an item
    localization contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-localization.py`,
    `python3 V2/ue/Tools/check-v2-item-validation-tool.py`,
    `python3 V2/ue/Tools/check-v2-item-serialization.py`,
    `python3 V2/ue/Tools/check-v2-item-preview.py`,
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-localization.py V2/ue/Tools/check-v2-item-validation-tool.py V2/ue/Tools/check-v2-item-serialization.py V2/ue/Tools/check-v2-item-preview.py V2/ue/Tools/check-v2-item-comparison-tooltip.py V2/ue/Tools/check-v2-item-enchantment-sockets.py V2/ue/Tools/check-v2-item-durability.py V2/ue/Tools/check-v2-item-set-bonuses.py V2/ue/Tools/check-v2-item-stat-modifiers.py V2/ue/Tools/check-v2-item-categories.py V2/ue/Tools/check-v2-item-rarity-tiers.py V2/ue/Tools/check-v2-item-instance-system.py V2/ue/Tools/check-v2-item-database.py V2/ue/Tools/check-v2-item-definition-schema.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemLocalization_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemLocalization_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.1.15** Create item documentation and authoring guide
  - Evidence: Added the V2 item authoring guide covering item source-of-truth
    contracts, definition identity fields, category/rarity/tag usage, stat
    modifiers, set bonuses, durability profiles, socket definitions, enchantment
    recipes, runtime instances, serialization, preview and comparison text,
    localization coverage, catalog validation, authoring workflow, review
    checklist, and validation commands. Added an item authoring guide contract,
    CI/Horde gates, and focused checker that verifies the guide remains
    connected to every item subsystem contract from definition schema through
    localization. Verification:
    `python3 V2/ue/Tools/check-v2-item-authoring-guide.py`,
    `python3 V2/ue/Tools/check-v2-item-localization.py`,
    `python3 V2/ue/Tools/check-v2-item-validation-tool.py`,
    `python3 V2/ue/Tools/check-v2-item-serialization.py`,
    `python3 V2/ue/Tools/check-v2-item-preview.py`,
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-authoring-guide.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemAuthoringGuide_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/docs/modes/item-authoring-guide.md V2/ue/Content/V2/Gameplay/Items/ItemAuthoringGuide_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.

#### 72.9.2 Inventory & Equipment

- [x] **72.9.2.1** Implement inventory container system (player inventory,
      chest, vendor stock, loot corpse — configurable slot count and weight
      limit)
  - Evidence: Added a Blueprint-friendly inventory container system for player
    inventories, chests, vendor stock, and loot corpses. Containers now have
    stable IDs, type, configurable slot count, configurable weight limit, slot
    and weight enforcement flags, fixed slot state, occupied/empty slot counts,
    weight summaries, add/remove operations, slot lookup by instance ID, and
    validation against item definitions and item instances. Automation covers
    default player/chest/vendor/loot-corpse configs, configurable slot and
    weight limits, valid adds, slot lookup, overweight rejection, occupied and
    empty slot counts, full-container rejection, validation against item
    definitions, removal, duplicate instance IDs, and missing item definitions.
    Added an inventory container contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-item-authoring-guide.py`,
    `python3 V2/ue/Tools/check-v2-item-localization.py`,
    `python3 V2/ue/Tools/check-v2-item-validation-tool.py`,
    `python3 V2/ue/Tools/check-v2-item-serialization.py`,
    `python3 V2/ue/Tools/check-v2-item-preview.py`,
    `python3 V2/ue/Tools/check-v2-item-comparison-tooltip.py`,
    `python3 V2/ue/Tools/check-v2-item-enchantment-sockets.py`,
    `python3 V2/ue/Tools/check-v2-item-durability.py`,
    `python3 V2/ue/Tools/check-v2-item-set-bonuses.py`,
    `python3 V2/ue/Tools/check-v2-item-stat-modifiers.py`,
    `python3 V2/ue/Tools/check-v2-item-categories.py`,
    `python3 V2/ue/Tools/check-v2-item-rarity-tiers.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-database.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryContainerSystem_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryContainerSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.2** Create item stacking and splitting (stackable items combine,
      split stacks by quantity)
  - Evidence: Added item stack capacity and stack operation helpers for
    stackable item instances. Stack capacity resolves max stack size and
    available capacity from item definitions; compatibility checks require valid
    stackable definitions, matching item IDs, distinct instance IDs, and
    matching durability, enchantment, and custom-data payloads before stacks can
    combine. Combine operations move requested quantities into target capacity,
    report partial overflow and source consumption, and split operations create
    a new instance ID while preserving source metadata and keeping the source
    stack non-empty. Automation covers capacity, compatibility, requested
    combine quantities, partial combine caps, split results, non-stackable
    rejection, mismatched item rejection, mismatched custom-data rejection,
    split-empty rejection, and split ID reuse rejection. Added an item stacking
    contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-item-instance-system.py`,
    `python3 V2/ue/Tools/check-v2-item-definition-schema.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/ItemStacking_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/ItemStacking_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.3** Implement item drag-and-drop between containers (inventory →
      equipment, inventory → chest, inventory → world drop)
  - Evidence: Added blueprint-callable inventory drag/drop helpers for
    container-to-container moves, equipment-slot handoff results, and world-drop
    handoff results. Container moves validate occupied source slots, destination
    slot bounds, item definitions, item instance integrity, same-slot attempts,
    destination weight limits, stack merge compatibility, occupied destination
    behavior, and swap permissions. Stack merges reuse the item stacking helper
    so compatible stacks merge into the destination slot while preserving source
    overflow; swaps validate both containers' post-swap weight limits. Equipment
    and world-drop drags clear the source slot and return explicit equipped or
    dropped instance payloads for downstream UI/gameplay consumers. Automation
    covers chest moves, compatible stack merges, occupied-slot swaps, overweight
    rejection, occupied destination rejection, failed merge rejection, equipment
    handoff, world-drop handoff, empty source rejection, and missing equipment
    slot rejection. Added an inventory drag/drop contract, CI/Horde gates, and
    focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryDragDrop_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryDragDrop_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.4** Create equipment slot system (head, chest, legs, feet, hands,
      weapon main/off-hand, rings, amulet — configurable per game)
  - Evidence: Added a blueprint-callable equipment slot runtime system with
    configurable slot definitions, required slot types, slot states, equipment
    layouts, eligibility results, and layout validation. The default layout
    defines head, chest, legs, feet, hands, main-hand weapon, off-hand weapon,
    left ring, right ring, and amulet slots with stable IDs, display text IDs,
    grouping tags, allowed categories, and required item tags. Eligibility
    checks validate item definitions, item instances, allowed categories,
    blocked tags, required slot tags, and stack restrictions without taking over
    the later equip/unequip visual-update task. Layout validation detects
    duplicate slot definitions, missing required slot types, missing layout IDs,
    orphaned slot states, missing item definitions, and occupied states whose
    instances are not eligible for their slot. Automation covers default slot
    coverage, configurable layout construction, slot lookup,
    armor/weapon/ring/amulet eligibility, disallowed-category rejection, missing
    required tag rejection, stacked equipment rejection, duplicate slot IDs,
    occupied layout validation, and orphan state rejection. Added an equipment
    slot contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/EquipmentSlotSystem_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/EquipmentSlotSystem_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.5** Implement equip/unequip with visual update (changing armor
      updates character mesh, weapon appears in hand)
  - Evidence: Added equipment equip/unequip runtime helpers that bridge player
    inventory, equipment layouts, and fighter customization visuals. Equip
    operations validate source inventory slots, item definitions, item
    instances, slot definitions, equipment eligibility, replacement swaps, and
    inventory weight limits before moving the item into the equipment layout;
    replacing an occupied equipment slot moves the previous equipment back into
    the source inventory slot. Unequip operations validate target inventory
    slots, occupied equipment state, item definitions, item instances, visual
    mappings, and inventory weight limits before moving equipment back to
    inventory and clearing the layout state. Visual rules map armor slots to
    modular mesh components and weapon slots to `weapon_r`/`weapon_l` hand
    sockets, while visual changes carry mesh asset paths and cosmetic slots that
    can be applied to the existing fighter customization component. Automation
    covers default visual rules, armor mesh equip, weapon hand-socket equip,
    replacement swaps, ineligible item rejection, unequip clear changes, layout
    visual rebuilds, customization component apply, and customization component
    clear behavior. Added an equip/unequip visual contract, CI/Horde gates, and
    focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/EquipmentEquipUnequip_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/EquipmentEquipUnequip_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.6** Create inventory weight/encumbrance system (over-encumbered
      movement penalty, cannot pick up if over limit)
  - Evidence: Added a blueprint-callable inventory encumbrance layer on top of
    container weight summaries. The default config defines carrying capacity,
    burdened and over-encumbered thresholds, movement-speed scalars, pickup
    blocking over capacity, and scalar clamping. Encumbrance summaries expose
    current weight, remaining capacity, encumbrance ratio, burden state,
    movement scalar, burden/over-encumbered booleans, and pickup lockout. Pickup
    checks validate item definitions and item instances, compute added and
    projected weight, produce before/after summaries, allow pickups within
    remaining capacity, and reject pickups that would exceed capacity when the
    over-limit block is enabled. Automation covers default config, unencumbered
    state, burdened movement penalty, over-capacity pickup rejection, allowed
    pickup within capacity, over-encumbered state and pickup lockout, movement
    speed scalar application, and invalid config threshold validation. Added an
    inventory encumbrance contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryEncumbrance_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryEncumbrance_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.7** Implement auto-sort and organize (sort by type, rarity,
      value, name, recent)
  - Evidence: Added a blueprint-callable inventory auto-sort system with sort
    modes for type, rarity, value, name, and recent custom-data order. Sort
    requests define direction, recent-order custom-data key, empty-slot
    compaction, and stable original-slot tie breaking. Sorting validates request
    data, item definitions, and item instances before previewing or mutating the
    container; occupied items are reordered deterministically, slot indices are
    preserved, empty slots can be pushed to the end, and results expose moved
    counts, occupied/empty counts, sorted instance IDs, and the sorted
    container. Compaction organizes occupied slots without requiring item
    definitions, and preview order returns the deterministic instance sequence
    without mutation. Automation covers default request values, compaction and
    empty-slot placement, type sorting, rarity sorting, value sorting, name
    sorting, recent sorting, recent custom-data key validation, and
    missing-definition rejection. Added an inventory auto-sort contract,
    CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryAutoSort_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryAutoSort_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.8** Create inventory search and filter (text search, category
      filter, rarity filter)
  - Evidence: Added a blueprint-callable inventory search/filter system with
    normalized text tokenization, all-term, any-term, and exact-phrase search
    modes, optional case-sensitive matching, tag/custom-data search coverage,
    category filters with any/all matching, explicit rarity filters, and
    definition-required validation for occupied slots. Filtering returns
    deterministic matched slots without mutating the source container, exposes
    matched instance IDs, matched/filtered/empty counts, per-slot match
    metadata, and scoped failure tags for invalid requests, missing definitions,
    invalid item instances, duplicate category filters, duplicate rarity
    filters, and overlong search text. Automation covers default request values,
    normalized tokenization, text search across custom data and definitions,
    any-term text matching, category filtering, all-category matching, rarity
    filtering, combined text/category/rarity filtering, individual slot
    matching, duplicate category validation, and missing-definition rejection.
    Added an inventory search/filter contract, CI/Horde gates, and focused
    checker. Verification:
    `python3 V2/ue/Tools/check-v2-inventory-search-filter.py`,
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-search-filter.py V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventorySearchFilter_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventorySearchFilter_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.9** Implement item quick-use slots (hotbar binding for
      consumables and abilities)
  - Evidence: Added a blueprint-callable inventory quick-use slot system with
    hotbar config defaults, deterministic bar construction, per-slot binding
    state, validation issues, operation results, and activation results. Slots
    bind consumable item instances only when the item definition includes the
    consumable category and the instance validates against its definition; slots
    also bind ability IDs for gameplay activation handoff. Quick-use activation
    consumes one stack from bound consumables, clears the inventory slot and
    hotbar binding when the stack is depleted, reports remaining stack count,
    and returns ability activation requests for bound abilities. Validation and
    operation paths cover missing bar IDs, invalid slot counts, slot index
    mismatches, invalid binding types, disabled item/ability binding modes,
    missing instance IDs, missing ability IDs, missing inventory slots, missing
    definitions, invalid item instances, non-consumable items, empty quick-use
    slots, and disabled slots. Automation covers default hotbar construction,
    consumable binding, non-consumable rejection, ability binding, stack
    consumption, depleted binding cleanup, ability activation, manual clearing,
    invalid ability binding validation, and missing bound item rejection. Added
    an inventory quick-use contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-inventory-quick-use-slots.py`,
    `python3 V2/ue/Tools/check-v2-inventory-search-filter.py`,
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-quick-use-slots.py V2/ue/Tools/check-v2-inventory-search-filter.py V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryQuickUseSlots_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryQuickUseSlots_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.10** Create loot pickup system (interact to loot, auto-loot
      toggle, loot-all button, loot quality filter)
  - Evidence: Added a blueprint-callable inventory loot pickup system that
    supports manual interact pickup from a loot slot, auto-loot with an explicit
    enabled toggle and maximum pickup count, loot-all for every eligible item,
    and loot quality filters using a minimum rarity threshold plus optional
    allowed rarity list. Pickup validates loot containers, slot occupancy, item
    definitions, item instances, duplicate quality filters, and rarity values,
    then uses the existing inventory container add/remove operations so slot and
    weight limits stay authoritative. Single-slot pickup transfers an item to
    the destination inventory and removes it from the loot container
    transactionally, rolling back the destination add if source removal fails.
    Batch results expose attempted, picked-up, filtered-out, and failed counts,
    picked-up instance IDs, per-item outcomes, and post-operation source and
    destination containers. Automation covers default config values, interact
    pickup, quality filtering, filtered rejection, auto-loot toggle behavior,
    auto-loot limits, loot-all behavior, destination capacity failure, duplicate
    rarity validation, and non-loot-container rejection. Added an inventory loot
    pickup contract, CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-inventory-loot-pickup.py`,
    `python3 V2/ue/Tools/check-v2-inventory-quick-use-slots.py`,
    `python3 V2/ue/Tools/check-v2-inventory-search-filter.py`,
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-loot-pickup.py V2/ue/Tools/check-v2-inventory-quick-use-slots.py V2/ue/Tools/check-v2-inventory-search-filter.py V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryLootPickup_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryLootPickup_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.11** Implement item trading between players (propose trade,
      confirm, execute atomically)
  - Evidence: Added a blueprint-callable inventory trading runtime that creates
    stable trade proposals with initiator and recipient offer lists, validates
    participant IDs, duplicate/empty instance IDs, empty offers, and known trade
    states, and tracks proposed, partially confirmed, fully confirmed, executed,
    and cancelled states. Player confirmation is participant-scoped, unknown
    actors are rejected, cancellation clears confirmations, and execution is
    limited to fully confirmed trades. Execution uses working-copy inventories:
    it validates source item instances, removes all offered items from both
    sides before adding them to the opposite inventory, then commits the
    resulting containers only after every transfer succeeds. Failed execution
    returns the original inventories untouched, so missing source items, invalid
    definitions, invalid instances, weight limits, duplicate instance IDs, and
    slot-capacity failures cannot partially move items. Automation covers valid
    proposal creation, initiator and recipient confirmations, atomic swaps
    between full one-slot inventories, unconfirmed execution rejection,
    duplicate offer validation, cancellation, failed execution rollback, and
    unknown participant rejection. Added an inventory trading contract, CI/Horde
    gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-inventory-trading.py`,
    `python3 V2/ue/Tools/check-v2-inventory-loot-pickup.py`,
    `python3 V2/ue/Tools/check-v2-inventory-quick-use-slots.py`,
    `python3 V2/ue/Tools/check-v2-inventory-search-filter.py`,
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-inventory-trading.py V2/ue/Tools/check-v2-inventory-loot-pickup.py V2/ue/Tools/check-v2-inventory-quick-use-slots.py V2/ue/Tools/check-v2-inventory-search-filter.py V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/InventoryTrading_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/InventoryTrading_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.12** Create vendor/shop system (buy/sell items, haggling
      modifier, vendor refresh timers, limited stock)
  - Evidence: Added a blueprint-callable vendor/shop runtime on top of the
    existing inventory container and item definition systems. Vendor shops now
    have validated vendor stock containers, buy/sell enable flags, buy and sell
    price multipliers, per-listing price overrides, limited stock quantities,
    max-stock caps, per-listing refresh timers, and shop-wide refresh timers.
    Buy and sell quote helpers apply a bounded per-transaction haggling modifier
    so better haggling lowers buy prices and raises sell prices while invalid
    haggling values fail explicitly. Buying checks listing availability, limited
    stock, vendor inventory backing stock, player currency, item definitions,
    item instance validity, and player inventory capacity before committing the
    vendor inventory, player inventory, player currency, and listing stock
    decrement. Selling validates the player item, computes the haggled sell
    price, moves the item into vendor stock, increments compatible limited
    listing stock, and credits currency only after the whole operation succeeds.
    Refresh uses working-copy vendor state to restock limited listings up to max
    stock when the timer is due, generating deterministic stock instances and
    preserving the original shop if capacity or definition checks fail.
    Automation covers haggled buy/sell quotes, atomic limited-stock purchases,
    insufficient currency rollback, full buyer inventory rollback, selling into
    vendor stock, refresh-not-due behavior, timed limited-stock refresh, and
    duplicate listing plus haggling validation. Added a vendor/shop contract,
    CI/Horde gates, and focused checker. Verification:
    `python3 V2/ue/Tools/check-v2-vendor-shop.py`,
    `python3 V2/ue/Tools/check-v2-inventory-trading.py`,
    `python3 V2/ue/Tools/check-v2-inventory-loot-pickup.py`,
    `python3 V2/ue/Tools/check-v2-inventory-quick-use-slots.py`,
    `python3 V2/ue/Tools/check-v2-inventory-search-filter.py`,
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-vendor-shop.py V2/ue/Tools/check-v2-inventory-trading.py V2/ue/Tools/check-v2-inventory-loot-pickup.py V2/ue/Tools/check-v2-inventory-quick-use-slots.py V2/ue/Tools/check-v2-inventory-search-filter.py V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/VendorShop_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/VendorShop_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.13** Implement loot table system (define drop pools with weighted
      probabilities, guaranteed drops, pity counters)
  - Evidence: Added a blueprint-callable loot table runtime with explicit
    guaranteed drops, weighted drop pools, deterministic roll requests,
    generated item instances, and per-entry pity counters. Loot table validation
    enforces stable table/drop/pool/entry IDs, positive guaranteed quantities,
    positive entry weights, valid quantity ranges, valid roll counts, unique
    IDs, and non-negative pity thresholds. Roll request validation rejects
    missing table IDs, duplicate pity counters, and negative pity counts.
    Rolling first emits guaranteed drops, then uses a deterministic
    `FRandomStream` seed for weighted pool selection, forces entries whose pity
    counters meet their threshold, updates counters by resetting selected pity
    entries and incrementing unselected pity entries, and returns generated item
    instances with stable seed-derived instance IDs. Rolls fail cleanly when
    request/table IDs mismatch or an item definition is missing. Automation
    covers validated guaranteed drops and weighted pools, guaranteed plus
    weighted drop output, overdue pity trigger behavior, pity counter updates,
    deterministic instance generation from seeds, invalid weighted probability
    rejection, invalid pity request rejection, and missing item definition
    rejection. Added a loot table contract, CI/Horde gates, and focused checker.
    Verification: `python3 V2/ue/Tools/check-v2-loot-table.py`,
    `python3 V2/ue/Tools/check-v2-vendor-shop.py`,
    `python3 V2/ue/Tools/check-v2-inventory-trading.py`,
    `python3 V2/ue/Tools/check-v2-inventory-loot-pickup.py`,
    `python3 V2/ue/Tools/check-v2-inventory-quick-use-slots.py`,
    `python3 V2/ue/Tools/check-v2-inventory-search-filter.py`,
    `python3 V2/ue/Tools/check-v2-inventory-auto-sort.py`,
    `python3 V2/ue/Tools/check-v2-inventory-encumbrance.py`,
    `python3 V2/ue/Tools/check-v2-equipment-equip-unequip.py`,
    `python3 V2/ue/Tools/check-v2-equipment-slot-system.py`,
    `python3 V2/ue/Tools/check-v2-inventory-drag-drop.py`,
    `python3 V2/ue/Tools/check-v2-item-stacking.py`,
    `python3 V2/ue/Tools/check-v2-inventory-container-system.py`,
    `python3 V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-loot-table.py V2/ue/Tools/check-v2-vendor-shop.py V2/ue/Tools/check-v2-inventory-trading.py V2/ue/Tools/check-v2-inventory-loot-pickup.py V2/ue/Tools/check-v2-inventory-quick-use-slots.py V2/ue/Tools/check-v2-inventory-search-filter.py V2/ue/Tools/check-v2-inventory-auto-sort.py V2/ue/Tools/check-v2-inventory-encumbrance.py V2/ue/Tools/check-v2-equipment-equip-unequip.py V2/ue/Tools/check-v2-equipment-slot-system.py V2/ue/Tools/check-v2-inventory-drag-drop.py V2/ue/Tools/check-v2-item-stacking.py V2/ue/Tools/check-v2-inventory-container-system.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-gameplay-module.py`,
    `python3 -m json.tool V2/ue/Content/V2/Gameplay/Items/LootTable_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `pnpm exec prettier --check .github/workflows/v2-build.yml TODOS/phase-72.md V2/ue/Content/V2/Gameplay/Items/LootTable_V2_Contract.json V2/ue/Build/Horde/v2-buildgraph-job.json`.
- [x] **72.9.2.14** Create crafting system (recipe definitions, material
      requirements, crafting stations, skill requirements, quality variation)
- [x] **72.9.2.15** Implement inventory networking (server-authoritative
      inventory for multiplayer, prevent item duplication)

---

### 72.10 Anti-Cheat System (Comprehensive)

Full anti-cheat beyond the existing single-line stubs — memory scanning, speed
hack detection, input validation, hardware banning, and integration APIs.

#### 72.10.1 Client-Side Anti-Cheat

- [x] **72.10.1.1** Implement game memory integrity scanning (detect injected
      DLLs, modified game code pages, hooked functions)
- [x] **72.10.1.2** Create speed hack detection (compare client game time
      against server wall-clock time, flag divergence >5%)
- [x] **72.10.1.3** Implement aimbot detection heuristics (analyze input
      patterns: inhuman snap-to-target speed, perfect tracking, zero reaction
      time)
- [x] **72.10.1.4** Create wallhack mitigation (server-side: don't send entity
      data for players occluded by geometry; client-side: detect graphics driver
      hooks)
- [x] **72.10.1.5** Implement teleportation/fly hack detection (server validates
      movement against physics constraints, reject impossible positions)
- [x] **72.10.1.6** Create process scanner (detect known cheat tool processes,
      debuggers, memory editors running alongside game)
- [x] **72.10.1.7** Implement driver-level integrity check (verify graphics
      driver hasn't been modified to enable wallhacks)
- [x] **72.10.1.8** Create client heartbeat system (periodic signed heartbeat to
      server proving client hasn't been modified)
- [x] **72.10.1.9** Implement obfuscation for anti-cheat module (make it harder
      to reverse-engineer and bypass the anti-cheat itself)
- [x] **72.10.1.10** Create screenshot/video capture on suspicion (capture
      client screen when heuristics trigger, for manual review)
- [x] **72.10.1.11** Implement anti-cheat self-update mechanism (push new
      detection signatures without full game patch)
- [x] **72.10.1.12** Create client hardware fingerprinting (GPU, CPU, MAC
      address, disk serial — for hardware ban enforcement)
- [x] **72.10.1.13** Implement overlay/hook detection (detect third-party
      overlays injecting into render pipeline)
- [x] **72.10.1.14** Create anti-cheat opt-in/opt-out for non-competitive modes
      (allow mods in single-player, enforce in ranked)
- [x] **72.10.1.15** Implement anti-cheat minimal-footprint mode (reduce
      invasiveness for privacy-conscious players in non-ranked modes)

#### 72.10.2 Server-Side Anti-Cheat

- [x] **72.10.2.1** Implement server-authoritative movement validation (replay
      client inputs server-side, compare resulting positions)
- [x] **72.10.2.2** Create server-authoritative hit detection (verify shots
      against server-side player positions with lag compensation)
- [x] **72.10.2.3** Implement damage validation (verify reported damage matches
      weapon stats, fire rate, distance falloff)
- [x] **72.10.2.4** Create resource/economy validation (server tracks all
      currency/item transactions, reject impossible gains)
- [x] **72.10.2.5** Implement statistical anomaly detection (flag players whose
      K/D, headshot %, accuracy deviate >3σ from population)
- [x] **72.10.2.6** Create replay-based cheat review system (record match
      replays, flag suspicious plays for human review)
- [x] **72.10.2.7** Implement ban system (temporary/permanent bans, ban waves,
      hardware bans, IP range bans)
- [x] **72.10.2.8** Create ban appeal workflow (player submits appeal, reviewer
      dashboard, evidence presentation, unban if justified)
- [x] **72.10.2.9** Implement shadow ban (detected cheaters placed in cheater-
      only matchmaking pool without notification)
- [x] **72.10.2.10** Create anti-cheat report system (player-submitted reports
      with match ID, timestamp, description)
- [x] **72.10.2.11** Implement trusted player program (low-report-rate players
      get fast-track for manual reviews they submit)
- [x] **72.10.2.12** Create anti-cheat analytics dashboard (cheat detection
      rates, ban counts, appeal rates, new cheat emergence)
- [x] **72.10.2.13** Implement third-party anti-cheat integration API
      (EasyAntiCheat, BattlEye plugin interface — use if building custom is not
      viable)
- [x] **72.10.2.14** Create anti-cheat testing framework (simulate known cheat
      types, verify detection works)
- [x] **72.10.2.15** Implement anti-cheat documentation covering architecture,
      detection methods, and operational procedures

---

### 72.11 Game Localization Pipeline

Complete localization infrastructure for shipping games in 15+ languages —
string management, translation workflow, CJK/RTL support, and VO management.

#### 72.11.1 String Management & Translation Workflow

- [x] **72.11.1.1** Design string ID system for all player-facing text
      (hierarchical IDs: quest.main_01.title, ui.menu.options,
      npc.blacksmith.greeting)
- [x] **72.11.1.2** Implement string extraction tool (scan game data files and
      code for localizable strings, output to translation format)
- [x] **72.11.1.3** Create translation file format (JSON/XLIFF/PO with metadata:
      context description, max character length, screenshot reference)
- [x] **72.11.1.4** Implement translation management platform integration
      (Crowdin, Lokalise, or Phrase API — push source strings, pull
      translations)
- [x] **72.11.1.5** Create translation memory integration (reuse previously
      translated strings, fuzzy matching for similar strings)
- [x] **72.11.1.6** Implement plural forms handling (language-specific plural
      rules: English 2 forms, Russian 3 forms, Arabic 6 forms)
- [x] **72.11.1.7** Create gendered text support (select masculine/feminine/
      neutral form based on player character or NPC gender)
- [x] **72.11.1.8** Implement dynamic text insertion (variable substitution:
      "You found {count} {item_name}" with correct plural and grammar)
- [x] **72.11.1.9** Create context screenshots for translators (capture game
      screenshots showing where each string appears, auto-upload to TMS)
- [x] **72.11.1.10** Implement string length validation (warn when translation
      exceeds UI space budget, per-language character limits)
- [x] **72.11.1.11** Create translation QA automation (detect untranslated
      strings, placeholder text in builds, encoding errors, broken variables)
- [x] **72.11.1.12** Implement continuous localization CI (on commit: extract
      strings, push to TMS, pull completed translations, build localized assets)
- [x] **72.11.1.13** Create pseudo-localization mode (expand strings 30%, add
      accents, wrap in brackets — detect UI overflow without real translations)
- [x] **72.11.1.14** Implement locale fallback chain (missing translation → fall
      back to English → fall back to string ID)
- [x] **72.11.1.15** Create localization status dashboard (per-language
      completion percentage, strings needing review, recently changed source
      strings)

#### 72.11.2 CJK, RTL & Voice-Over Localization

- [x] **72.11.2.1** Implement CJK font coverage validation (verify all
      characters used in translated text are present in font file)
- [x] **72.11.2.2** Create CJK text layout support (line breaking rules for
      Chinese/Japanese/Korean — no break before punctuation, kinsoku shori)
- [x] **72.11.2.3** Implement CJK text density adaptation (CJK characters are
      wider — auto-adjust UI element sizes and text areas)
- [x] **72.11.2.4** Create RTL text rendering integration (Arabic, Hebrew —
      correct glyph shaping, mirrored punctuation, mixed LTR/RTL)
- [x] **72.11.2.5** Implement RTL UI mirroring (flip entire UI layout for RTL
      locales — HUD elements, menus, navigation)
- [x] **72.11.2.6** Create voice-over asset management (per-locale VO directory
      structure, naming conventions, file format requirements)
- [x] **72.11.2.7** Implement voice-over recording script export (generate
      scripts for voice actors from dialogue data with context and direction)
- [x] **72.11.2.8** Create voice-over integration pipeline (match VO audio files
      to dialogue IDs, validate coverage, detect missing recordings)
- [x] **72.11.2.9** Implement voice-over lip-sync per locale (generate phoneme
      data from each language's VO for accurate lip sync)
- [x] **72.11.2.10** Create subtitle timing from voice-over (auto-generate
      subtitle display duration based on VO clip length)
- [x] **72.11.2.11** Implement locale-specific number/date/currency formatting
      (1,000.00 vs 1.000,00 — use ICU/locale libraries)
- [x] **72.11.2.12** Create locale selection UI (language picker in options,
      auto-detect from OS locale, per-category override: text language vs VO
      language)
- [x] **72.11.2.13** Implement text-to-speech fallback for missing VO (use
      platform TTS for accessibility and incomplete localizations)
- [x] **72.11.2.14** Create localization testing mode (cycle through all locales
      rapidly, screenshot each screen in every language)
- [x] **72.11.2.15** Implement localization documentation covering workflow,
      vendor integration, and QA process

---

### 72.12 Game Live Operations Infrastructure

Remote config, feature flags, season pass, hotfixing, and live event management
specifically for shipped games.

#### 72.12.1 Remote Config & Feature Flags

- [x] **72.12.1.1** Implement remote config service for game parameters (enemy
      health, weapon damage, drop rates, XP curves — change without client
      patch)
- [x] **72.12.1.2** Create config versioning with rollback (if config change
      causes issues, instantly revert to previous version)
  - Evidence: Extended `@v2/remote-config-service` with immutable version
    history, parameter hashes, rollback target listing, rollback planning, and
    `rollbackV2RemoteConfigVersion` publishing a new active snapshot that
    restores a previous parameter map with `requiresClientPatch: false`. Added
    `RemoteConfigVersioning_V2_Contract.json`, CI/Horde gates, operator runbook
    coverage, and focused checker coverage. Verification:
    `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `python3 V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigVersioning_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.3** Implement player segment targeting (apply config differently
      by region, platform, player level, A/B test group)
  - Evidence: Extended `@v2/remote-config-service` with segment-targeting
    dimensions for region, platform, player level, and A/B test group.
    `buildV2RemoteConfigSegmentTargetingSurface` validates segment IDs,
    priorities, criteria, supported platforms, level ranges, parameter keys,
    duplicate overrides, and parameter bounds. `resolveV2RemoteConfigForPlayer`
    evaluates hashed player context, applies matched segments in deterministic
    priority order, preserves base values for unmatched parameters, and emits a
    segmented client payload with matched segment IDs, parameter source
    metadata, segmented ETag, and `requiresClientPatch: false`. Added
    `RemoteConfigSegmentTargeting_V2_Contract.json`, CI/Horde gates, runbook
    coverage, and focused checker coverage. Verification:
    `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `python3 V2/ue/Tools/check-v2-remote-config-segment-targeting.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-segment-targeting.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigSegmentTargeting_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.4** Create feature flag service for games (toggle features
      remotely: enable new game mode, disable broken feature, gradual rollout)
  - Evidence: Added `@v2/feature-flag-service` with validated feature flag
    definitions, remote states, client payloads, stable account-hash rollout
    buckets, remote game-mode enablement, emergency `forceDisabled` handling,
    and gradual rollout percentages from 0 to 100. The package exposes
    `buildV2FeatureFlagServiceSurface`, `evaluateV2FeatureFlag`,
    `updateV2FeatureFlag`, and `buildV2FeatureFlagClientPayload`, plus
    `FeatureFlagService_V2_Contract.json`, CI/Horde gates, a live-service
    runbook, and focused checker coverage. Verification:
    `pnpm --filter @v2/feature-flag-service test`,
    `pnpm --filter @v2/feature-flag-service typecheck`,
    `python3 V2/ue/Tools/check-v2-feature-flag-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-feature-flag-service.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/FeatureFlagService_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.5** Implement feature flag client SDK integration (check flag
      state at startup and periodically, cache for offline play)
  - Evidence: Extended `@v2/feature-flag-service` with client SDK cache and
    refresh planning APIs. `buildV2FeatureFlagClientCache` stores fetched flag
    payloads with `refreshAt` and `offlineExpiresAt`;
    `planV2FeatureFlagClientRefresh` returns startup fetch, periodic fetch,
    cache-use, offline-cache, or fail-closed actions; and
    `readV2FeatureFlagFromClientCache` reads cached flags, marks when a network
    refresh is needed, and disables flags after offline cache expiry. Added
    `FeatureFlagClientSdk_V2_Contract.json`, CI/Horde gates, runbook coverage,
    and focused checker coverage. Verification:
    `pnpm --filter @v2/feature-flag-service test`,
    `pnpm --filter @v2/feature-flag-service typecheck`,
    `python3 V2/ue/Tools/check-v2-feature-flag-client-sdk.py`,
    `python3 V2/ue/Tools/check-v2-feature-flag-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-feature-flag-client-sdk.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/FeatureFlagClientSdk_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.6** Create A/B testing framework for game mechanics (split
      players into groups, measure engagement/retention per variant, statistical
      significance testing)
  - Evidence: Added `@v2/game-mechanics-ab-testing` with deterministic weighted
    assignment via `assignV2GameMechanicsABVariant` and the analytics surface
    `buildV2GameMechanicsABTestingSurface`. The package records exposure,
    engagement, and retention telemetry per game-mechanic variant, builds
    per-variant measurements, and evaluates confidence/significance against the
    configured control variant and minimum sample size. Added
    `GameMechanicsABTesting_V2_Contract.json`, CI/Horde gates, a live-service
    runbook, and focused checker coverage. Verification:
    `pnpm --filter @v2/game-mechanics-ab-testing test`,
    `pnpm --filter @v2/game-mechanics-ab-testing typecheck`,
    `pnpm --filter @v2/game-mechanics-ab-testing lint`,
    `pnpm --filter @v2/game-mechanics-ab-testing build`,
    `python3 V2/ue/Tools/check-v2-game-mechanics-ab-testing.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-game-mechanics-ab-testing.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/GameMechanicsABTesting_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.7** Implement config change audit log (who changed what, when,
      why — full traceability)
  - Evidence: Extended `@v2/remote-config-service` with immutable config change
    audit log APIs. `buildV2RemoteConfigChangeAuditLogFromHistory` derives audit
    entries from published version history, recording `changedBy`, `changedAt`,
    `reason`, and before/after `parameterChanges` for each publish, parameter
    update, and rollback. `buildV2RemoteConfigChangeAuditLog` validates explicit
    entries, duplicate audit IDs, environment mismatches, missing reasons, and
    missing parameter diffs. Entries include `who`, `what`, `when`, `why`,
    `auditHash`, and `previousAuditHash` for a tamper-evident traceability
    chain. Added `RemoteConfigAuditLog_V2_Contract.json`, CI/Horde gates,
    runbook coverage, and focused checker coverage. Verification:
    `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `pnpm --filter @v2/remote-config-service lint`,
    `pnpm --filter @v2/remote-config-service build`,
    `python3 V2/ue/Tools/check-v2-remote-config-audit-log.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-segment-targeting.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-audit-log.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigAuditLog_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.8** Create config validation rules (prevent setting enemy health
      to 0, drop rate to 100%, or other obviously broken values)
  - Evidence: Extended `@v2/remote-config-service` with
    `buildV2RemoteConfigValidationRulesSurface`, an operator-facing validation
    report for proposed remote config changes. The rules surface publishes
    `known-parameter-key`, `enemy-health-positive`,
    `weapon-damage-non-negative`, `drop-rate-below-100-percent`,
    `xp-curve-non-decreasing`, and `numeric-bounds-enforced`; it blocks
    publishing when error issues are present and reports `requestedBy`,
    `reason`, and `rejectedValue`. Tests cover safe changes, enemy health `0`,
    drop rate `100%`, decreasing XP curves, and unknown keys. Added
    `RemoteConfigValidationRules_V2_Contract.json`, CI/Horde gates, runbook
    coverage, and focused checker coverage. Verification:
    `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `pnpm --filter @v2/remote-config-service lint`,
    `pnpm --filter @v2/remote-config-service build`,
    `python3 V2/ue/Tools/check-v2-remote-config-validation-rules.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-audit-log.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-segment-targeting.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-validation-rules.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigValidationRules_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.9** Implement config preview/staging (test config changes in
      staging environment before pushing to production)
  - Evidence: Extended `@v2/remote-config-service` with
    `buildV2RemoteConfigPreviewStagingSurface`, which starts from a production
    surface, runs validation rules, builds a staging-only snapshot and
    `stagingClientPayload` for safe changes, and keeps
    `productionUnchanged: true`. Invalid previews keep the production payload
    intact, omit staging payloads, and set `readyForProduction: false` before
    promotion. Added `RemoteConfigPreviewStaging_V2_Contract.json`, CI/Horde
    gates, runbook coverage, and focused checker coverage. Verification:
    `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `pnpm --filter @v2/remote-config-service lint`,
    `pnpm --filter @v2/remote-config-service build`,
    `python3 V2/ue/Tools/check-v2-remote-config-preview-staging.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-validation-rules.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-audit-log.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-segment-targeting.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-preview-staging.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigPreviewStaging_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.10** Create config delivery optimization (delta updates, client
      caching, minimal bandwidth usage)
  - Evidence: Extended `@v2/remote-config-service` with
    `buildV2RemoteConfigDeliveryOptimizationSurface`, which chooses `cache-hit`,
    `delta`, or `full` delivery from the current payload and optional previous
    client payload. The surface emits a client cache policy with ETag
    revalidation, `stale-while-revalidate`, offline cache seconds, delta
    operations, byte estimates, estimated bytes saved, compression guidance,
    `minimalBandwidth: true`, and `requiresClientPatch: false`. Tests cover
    delta delivery, current-ETag cache hits that skip payload download, full
    fallback with no previous payload, and previous-payload environment
    validation. Added `RemoteConfigDeliveryOptimization_V2_Contract.json`,
    CI/Horde gates, runbook coverage, and focused checker coverage.
    Verification: `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `pnpm --filter @v2/remote-config-service lint`,
    `pnpm --filter @v2/remote-config-service build`,
    `python3 V2/ue/Tools/check-v2-remote-config-delivery-optimization.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-preview-staging.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-validation-rules.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-audit-log.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-segment-targeting.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-versioning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-delivery-optimization.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigDeliveryOptimization_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.11** Implement kill switch (instantly disable a feature across
      all clients if critical bug discovered — no patch needed)
  - Evidence: Extended `@v2/feature-flag-service` with
    `buildV2FeatureFlagKillSwitchSurface`,
    `V2_FEATURE_FLAG_KILL_SWITCH_ENDPOINTS`, and
    `V2_FEATURE_FLAG_KILL_SWITCH_POLICY_ID`. The kill switch command publishes a
    new feature flag version that sets the target feature to `force-disabled`,
    rollout percentage 0, and `requiresClientPatch: false`; returns the
    force-disabled client payload; invalidates the previous ETag; emits a
    cache-bust token and forced client refresh plan with a bounded
    max-client-staleness window; and carries incident ID, severity, operator,
    activation time, reason, previous version, and new version audit metadata.
    Tests cover no-patch kill switch activation with forced client refresh,
    rollout-bucket override for all clients, unknown flag rejection, and invalid
    staleness rejection. Added `FeatureFlagKillSwitch_V2_Contract.json`,
    CI/Horde gates, runbook coverage, and focused checker coverage.
    Verification: `pnpm --filter @v2/feature-flag-service test`,
    `pnpm --filter @v2/feature-flag-service typecheck`,
    `pnpm --filter @v2/feature-flag-service lint`,
    `pnpm --filter @v2/feature-flag-service build`,
    `python3 V2/ue/Tools/check-v2-feature-flag-kill-switch.py`,
    `python3 V2/ue/Tools/check-v2-feature-flag-client-sdk.py`,
    `python3 V2/ue/Tools/check-v2-feature-flag-service.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-feature-flag-kill-switch.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/FeatureFlagKillSwitch_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.12** Create config dashboard (view all active configs, current
      values, segment targeting, flag states)
  - Evidence: Added the V2 live-ops config dashboard at
    `V2/web/live-service/config-dashboard/` with a static HTML/CSS/JS surface
    backed by `config-dashboard.json`. The dashboard shows production, staging,
    and development environments; active remote configs and feature flags;
    current values beside defaults; segment targeting chips and active audience
    rules; flag states including enabled, gradual rollout, and force-disabled;
    selected config detail with owner/source/operator/timestamp/reason audit
    metadata; environment, search, status, and targeted-only filters; empty
    filtered state; refresh SLA; and mobile viewport-safe layout. Added
    `V2/web/e2e/v2-web-config-dashboard.spec.ts`,
    `ConfigDashboard_V2_Contract.json`, CI/Horde gates, runbook coverage, and
    focused checker coverage. Verification:
    `pnpm --dir V2/web test:e2e -- e2e/v2-web-config-dashboard.spec.ts`,
    `pnpm --dir V2/web typecheck`, `pnpm --dir V2/web lint`,
    `pnpm --dir V2/web build`,
    `python3 V2/ue/Tools/check-v2-config-dashboard.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-config-dashboard.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/ConfigDashboard_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.13** Implement maintenance mode (redirect all clients to
      maintenance message during server updates)
  - Evidence: Extended `@v2/remote-config-service` with
    `buildV2RemoteConfigMaintenanceModeSurface` and
    `resolveV2RemoteConfigMaintenanceRedirect`. The maintenance surface
    publishes a refreshed remote-config version, caps client staleness, forces
    client refresh with ETag invalidation/cache-busting, returns a maintenance
    message with reason/resume/status/support metadata, redirects all active
    clients to `/maintenance`, clears the redirect when inactive, and keeps
    `requiresClientPatch: false`. Added focused service tests,
    `RemoteConfigMaintenanceMode_V2_Contract.json`, CI/Horde gates, runbook
    coverage, and checker coverage. Verification:
    `pnpm --filter @v2/remote-config-service test`,
    `pnpm --filter @v2/remote-config-service typecheck`,
    `pnpm --filter @v2/remote-config-service lint`,
    `pnpm --filter @v2/remote-config-service build`,
    `python3 V2/ue/Tools/check-v2-remote-config-maintenance-mode.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-remote-config-maintenance-mode.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/RemoteConfigMaintenanceMode_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.14** Create message-of-the-day system (push announcements to
      game client: events, downtime, patch notes)
  - Evidence: Added `@v2/message-of-the-day-service` with
    `buildV2MessageOfTheDayServiceSurface` and
    `resolveV2MessageOfTheDayForClient`. The service validates event, downtime,
    and patch-note messages; rejects duplicate IDs, invalid windows, and missing
    category metadata; filters active windows; applies region, platform,
    build-version, and account-level targeting; preserves per-account dismissal
    for dismissible notices; keeps non-dismissible downtime acknowledgements
    visible; emits ETagged client payloads with `pushAnnouncements: true`; and
    keeps `requiresClientPatch: false`. Added focused Vitest coverage,
    `MessageOfTheDay_V2_Contract.json`, CI/Horde gates, runbook coverage, and
    checker coverage. Verification:
    `pnpm --filter @v2/message-of-the-day-service test`,
    `pnpm --filter @v2/message-of-the-day-service typecheck`,
    `pnpm --filter @v2/message-of-the-day-service lint`,
    `pnpm --filter @v2/message-of-the-day-service build`,
    `python3 V2/ue/Tools/check-v2-message-of-the-day.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-message-of-the-day.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/MessageOfTheDay_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.1.15** Implement config documentation and operational runbook
  - Evidence: Added `V2/docs/live-service/config-documentation-runbook.md` as
    the operator-facing live config runbook covering change intake, risk
    classification, four-eyes approval, validation rules, preview/staging,
    production rollout, audit-log traceability, rollback, kill switch,
    maintenance mode, message-of-the-day communications, and post-incident
    review. Added `ConfigDocumentationRunbook_V2_Contract.json`,
    `check-v2-config-documentation-runbook.py`, and CI/Horde gates that require
    the runbook, source-runbook links, operator procedures, audit evidence, and
    workflow wiring. Verification:
    `python3 V2/ue/Tools/check-v2-config-documentation-runbook.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-config-documentation-runbook.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/ConfigDocumentationRunbook_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.

#### 72.12.2 Season Pass, Live Events & Hotfixing

- [x] **72.12.2.1** Implement season/battle pass progression system (XP-based
      track with free and premium tiers, rewards at each level)
  - Evidence: Added `@v2/season-pass-service` with
    `buildV2SeasonPassProgressionSurface`, `resolveV2SeasonPassTierProgress`,
    and `applyV2SeasonPassXpGrant`. The service publishes a 60-tier, 90-day
    XP-based season track with free and premium reward lanes, validates rewards
    at every level, caps progression at the final tier, gates premium rewards by
    entitlement, emits claimable and locked reward state, accepts
    server-authoritative XP grants, makes duplicate grant IDs idempotent, and
    keeps `requiresClientPatch: false`. Added focused Vitest coverage,
    `SeasonPassProgression_V2_Contract.json`, CI/Horde gates, runbook coverage,
    and checker coverage. Verification:
    `pnpm --filter @v2/season-pass-service test`,
    `pnpm --filter @v2/season-pass-service typecheck`,
    `pnpm --filter @v2/season-pass-service lint`,
    `pnpm --filter @v2/season-pass-service build`,
    `python3 V2/ue/Tools/check-v2-season-pass-progression.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-season-pass-progression.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/SeasonPassProgression_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.2** Create season pass reward definition format (cosmetics,
      currency, items, emotes, titles — per tier)
  - Evidence: Extended `@v2/season-pass-service` with
    `buildV2SeasonPassRewardDefinitionSurface` and
    `validateV2SeasonPassRewardDefinitionFormat`. The format flattens every free
    and premium tier reward into per-tier definitions covering cosmetics,
    currency, items, emotes, and titles; emits `catalogRef`, `entitlementRef`,
    `localizedNameKey`, and `grantPayload` metadata; validates rewards at every
    level and required reward-kind coverage; and keeps
    `requiresClientPatch: false`. Added focused Vitest coverage,
    `SeasonPassRewardDefinitions_V2_Contract.json`, CI/Horde gates, runbook
    coverage, and checker coverage. Verification:
    `pnpm --filter @v2/season-pass-service test`,
    `pnpm --filter @v2/season-pass-service typecheck`,
    `pnpm --filter @v2/season-pass-service lint`,
    `pnpm --filter @v2/season-pass-service build`,
    `python3 V2/ue/Tools/check-v2-season-pass-reward-definitions.py`,
    `python3 V2/ue/Tools/check-v2-season-pass-progression.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-season-pass-reward-definitions.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/SeasonPassRewardDefinitions_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.3** Implement season pass XP sources (match completion, daily
      challenges, weekly challenges, event bonuses)
  - Evidence: Extended `@v2/season-pass-service` with
    `buildV2SeasonPassXpSourceSurface` and
    `calculateV2SeasonPassXpGrantFromSource`. The source surface defines match
    completion, daily challenge, weekly challenge, and event-bonus XP sources
    with cadence, `baseXp`, `maxXpPerGrant`, replay-evidence, anti-cheat, and
    server-authoritative flags. The grant calculator validates source events,
    applies multipliers, caps awards, and returns the same `V2SeasonPassXpGrant`
    consumed by progression. Added focused Vitest coverage,
    `SeasonPassXpSources_V2_Contract.json`, CI/Horde gates, runbook coverage,
    and checker coverage. Verification:
    `pnpm --filter @v2/season-pass-service test`,
    `pnpm --filter @v2/season-pass-service typecheck`,
    `pnpm --filter @v2/season-pass-service lint`,
    `pnpm --filter @v2/season-pass-service build`,
    `python3 V2/ue/Tools/check-v2-season-pass-xp-sources.py`,
    `python3 V2/ue/Tools/check-v2-season-pass-reward-definitions.py`,
    `python3 V2/ue/Tools/check-v2-season-pass-progression.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-season-pass-xp-sources.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/SeasonPassXpSources_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.4** Create daily/weekly challenge system (randomly generated
      from challenge pool, reward XP/currency, auto-rotate)
  - Evidence: Extended `@v2/season-pass-service` with
    `buildV2SeasonPassChallengeSystemSurface` and
    `completeV2SeasonPassChallenge`. The challenge system validates a weighted
    challenge pool, generates deterministic daily and weekly UTC rotations,
    marks active challenges as randomly generated and auto-rotated, and grants
    server-authoritative XP plus `season-credits` currency rewards without a
    client patch. Added focused Vitest coverage,
    `SeasonPassChallengeSystem_V2_Contract.json`, CI/Horde gates, runbook
    coverage, and checker coverage. Verification:
    `pnpm --filter @v2/season-pass-service test`,
    `pnpm --filter @v2/season-pass-service typecheck`,
    `pnpm --filter @v2/season-pass-service lint`,
    `pnpm --filter @v2/season-pass-service build`,
    `python3 V2/ue/Tools/check-v2-season-pass-challenge-system.py`,
    `python3 V2/ue/Tools/check-v2-season-pass-xp-sources.py`,
    `python3 V2/ue/Tools/check-v2-season-pass-reward-definitions.py`,
    `python3 V2/ue/Tools/check-v2-season-pass-progression.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-season-pass-challenge-system.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/SeasonPassChallengeSystem_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.5** Implement live event scheduling system (define start/end
      times, enable event game modes, activate event rewards)
  - Evidence: Added `@v2/live-event-scheduling-service` with
    `buildV2LiveEventSchedulingSurface` and `resolveV2LiveEventScheduleState`.
    The scheduler validates live event start/end times, classifies
    upcoming/active/ended windows, enables event game modes only during active
    windows, activates event rewards against the same schedule, rejects
    overlapping game mode windows, and keeps `requiresClientPatch: false`. Added
    focused Vitest coverage, `LiveEventScheduling_V2_Contract.json`, CI/Horde
    gates, runbook coverage, and checker coverage. Verification:
    `pnpm --filter @v2/live-event-scheduling-service test`,
    `pnpm --filter @v2/live-event-scheduling-service typecheck`,
    `pnpm --filter @v2/live-event-scheduling-service lint`,
    `pnpm --filter @v2/live-event-scheduling-service build`,
    `python3 V2/ue/Tools/check-v2-live-event-scheduling.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-live-event-scheduling.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/LiveEventScheduling_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.6** Create live event content delivery (download event assets on
      demand — maps, cosmetics, NPC dialogue — without full patch)
  - Evidence: Added `@v2/live-event-content-delivery-service` with
    `buildV2LiveEventContentDeliverySurface` and
    `planV2LiveEventContentDownload` for server-authoritative on-demand delivery
    of event maps, cosmetics, and NPC dialogue while keeping
    `fullPatchRequired: false` and `requiresClientPatch: false`. Added focused
    Vitest coverage, `LiveEventContentDelivery_V2_Contract.json`, CI/Horde
    gates, runbook coverage, and checker coverage. Verification:
    `pnpm --filter @v2/live-event-content-delivery-service test`,
    `pnpm --filter @v2/live-event-content-delivery-service typecheck`,
    `pnpm --filter @v2/live-event-content-delivery-service lint`,
    `pnpm --filter @v2/live-event-content-delivery-service build`,
    `python3 V2/ue/Tools/check-v2-live-event-content-delivery.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-live-event-content-delivery.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/LiveEventContentDelivery_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.7** Implement limited-time game mode system (enable/disable game
      modes on schedule, event-exclusive modes)
  - Evidence: Added `@v2/limited-time-game-mode-service` with
    `buildV2LimitedTimeGameModeSurface` and `resolveV2LimitedTimeGameModeState`
    for server-authoritative scheduled enable/disable windows, active queue
    publication, and event-exclusive mode ownership while keeping
    `requiresClientPatch: false`. Added focused Vitest coverage,
    `LimitedTimeGameMode_V2_Contract.json`, CI/Horde gates, runbook coverage,
    and checker coverage. Verification:
    `pnpm --filter @v2/limited-time-game-mode-service test`,
    `pnpm --filter @v2/limited-time-game-mode-service typecheck`,
    `pnpm --filter @v2/limited-time-game-mode-service lint`,
    `pnpm --filter @v2/limited-time-game-mode-service build`,
    `python3 V2/ue/Tools/check-v2-limited-time-game-mode.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-limited-time-game-mode.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/LimitedTimeGameMode_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.8** Create hotfix delivery system (small data-only patches that
      modify game balance, fix exploits, or correct data errors without
      requiring platform certification)
  - Evidence: Added `@v2/hotfix-delivery-service` with
    `buildV2HotfixDeliverySurface` and `planV2HotfixDelivery` for signed small
    data-only hotfix manifests that cover balance changes, exploit fixes, and
    data-error corrections while keeping `requiresPlatformCertification: false`
    and `requiresClientPatch: false`. Added focused Vitest coverage,
    `HotfixDelivery_V2_Contract.json`, CI/Horde gates, runbook coverage, and
    checker coverage. Verification:
    `pnpm --filter @v2/hotfix-delivery-service test`,
    `pnpm --filter @v2/hotfix-delivery-service typecheck`,
    `pnpm --filter @v2/hotfix-delivery-service lint`,
    `pnpm --filter @v2/hotfix-delivery-service build`,
    `python3 V2/ue/Tools/check-v2-hotfix-delivery.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-hotfix-delivery.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/HotfixDelivery_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.9** Implement hotfix testing pipeline (automated regression
      tests run on hotfix before deployment)
  - Evidence: Added `@v2/hotfix-testing-pipeline-service` with
    `buildV2HotfixTestingPipelineSurface` and `evaluateV2HotfixTestingGate` for
    required automated regression results, before-deployment execution,
    deployment approval, and failure/missing-result blocking. Added focused
    Vitest coverage, `HotfixTestingPipeline_V2_Contract.json`, CI/Horde gates,
    runbook coverage, and checker coverage. Verification:
    `pnpm --filter @v2/hotfix-testing-pipeline-service test`,
    `pnpm --filter @v2/hotfix-testing-pipeline-service typecheck`,
    `pnpm --filter @v2/hotfix-testing-pipeline-service lint`,
    `pnpm --filter @v2/hotfix-testing-pipeline-service build`,
    `python3 V2/ue/Tools/check-v2-hotfix-testing-pipeline.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-hotfix-testing-pipeline.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/HotfixTestingPipeline_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.10** Create DLC/expansion content delivery (downloadable content
      packs, entitlement verification, content unlocking)
  - Evidence: Added `@v2/dlc-content-delivery-service` with
    `buildV2DlcContentDeliverySurface` and `planV2DlcContentDownload` for
    downloadable fighter, story expansion, and cosmetic DLC packs, entitlement
    verification, locked missing-entitlement responses, and content unlocking
    while keeping `requiresClientPatch: false`. Added focused Vitest coverage,
    `DlcContentDelivery_V2_Contract.json`, CI/Horde gates, runbook coverage, and
    checker coverage. Verification:
    `pnpm --filter @v2/dlc-content-delivery-service test`,
    `pnpm --filter @v2/dlc-content-delivery-service typecheck`,
    `pnpm --filter @v2/dlc-content-delivery-service lint`,
    `pnpm --filter @v2/dlc-content-delivery-service build`,
    `python3 V2/ue/Tools/check-v2-dlc-content-delivery.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-dlc-content-delivery.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/DlcContentDelivery_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.11** Implement patch notes system (structured patch notes with
      categories: balance, bug fixes, new content, displayed in-game)
  - Evidence: Added `@v2/patch-notes-service` with `buildV2PatchNotesSurface`
    and `buildV2PatchNotesInGamePayload` for structured patch notes grouped into
    balance, bug fixes, and new content categories, category coverage
    validation, in-game display cards, and `requiresClientPatch: false`. Added
    focused Vitest coverage, `PatchNotes_V2_Contract.json`, CI/Horde gates,
    runbook coverage, and checker coverage. Verification:
    `pnpm --filter @v2/patch-notes-service test`,
    `pnpm --filter @v2/patch-notes-service typecheck`,
    `pnpm --filter @v2/patch-notes-service lint`,
    `pnpm --filter @v2/patch-notes-service build`,
    `python3 V2/ue/Tools/check-v2-patch-notes.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-patch-notes.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/PatchNotes_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.12** Create player compensation system (grant items/currency to
      affected players after bugs or outages)
  - Evidence: Added `@v2/player-compensation-service` with
    `buildV2PlayerCompensationSurface`, `planV2PlayerCompensationGrants`, and
    `applyV2PlayerCompensationGrant` for bug/outage compensation campaigns,
    affected-player evidence, approval-gated item and currency grant bundles,
    idempotent grant planning, and idempotent per-account ledger application
    while keeping `requiresClientPatch: false`. Added focused Vitest coverage,
    `PlayerCompensation_V2_Contract.json`, CI/Horde gates, runbook coverage, and
    checker coverage. Verification:
    `pnpm --filter @v2/player-compensation-service test`,
    `pnpm --filter @v2/player-compensation-service typecheck`,
    `pnpm --filter @v2/player-compensation-service lint`,
    `pnpm --filter @v2/player-compensation-service build`,
    `python3 V2/ue/Tools/check-v2-player-compensation.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-player-compensation.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/PlayerCompensation_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.13** Implement content calendar management tool (plan and
      schedule seasons, events, patches months in advance)
  - Evidence: Added the V2 content calendar management tool at
    `V2/web/live-service/content-calendar/` with an eight-month planning
    manifest for seasons, events, and patches; type/readiness/search filters;
    conflicts-only mode; selected-plan detail; schedule risk review; and mobile
    viewport coverage. Added `v2-web-content-calendar.spec.ts`,
    `ContentCalendarManagement_V2_Contract.json`, CI/Horde gates, runbook
    coverage, and checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-content-calendar-management.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-content-calendar-management.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/ContentCalendarManagement_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `pnpm --dir V2/web exec playwright test e2e/v2-web-content-calendar.spec.ts`,
    and `npx --no-install prettier --check`.
- [x] **72.12.2.14** Create live ops analytics (event participation rates,
      season pass completion rates, hotfix effectiveness)
  - Evidence: Added `@v2/live-ops-analytics-service` with
    `buildV2LiveOpsAnalyticsSurface`, `summarizeV2EventParticipation`,
    `summarizeV2SeasonPassCompletion`, and `summarizeV2HotfixEffectiveness` for
    aggregate event participation rates, season pass completion rates, and
    hotfix effectiveness reductions/scores. The service validates impossible
    account-count relationships, hotfix before/after telemetry, crash rates,
    regression failure counts, duplicate metric ids, aggregate-only privacy, and
    `requiresClientPatch: false`. Added focused Vitest coverage,
    `LiveOpsAnalytics_V2_Contract.json`, CI/Horde gates, runbook coverage, and
    checker coverage. Verification:
    `pnpm --filter @v2/live-ops-analytics-service test`,
    `pnpm --filter @v2/live-ops-analytics-service typecheck`,
    `pnpm --filter @v2/live-ops-analytics-service lint`,
    `pnpm --filter @v2/live-ops-analytics-service build`,
    `python3 V2/ue/Tools/check-v2-live-ops-analytics.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-live-ops-analytics.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/LiveOpsAnalytics_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.12.2.15** Implement live ops documentation and playbook
  - Evidence: Added `V2/docs/live-service/live-ops-documentation-playbook.md` as
    the top-level operator playbook for season pass operations, reward-track
    approval, challenge rotation, live event scheduling, on-demand content
    delivery, limited-time mode activation, hotfix intake/testing, DLC
    entitlement release, patch-notes publication, player compensation, analytics
    review, rollback/kill-switch paths, audit evidence, and post-incident
    review. Added `LiveOpsDocumentationPlaybook_V2_Contract.json`,
    `check-v2-live-ops-documentation-playbook.py`, and CI/Horde gates requiring
    source-runbook links, operator procedures, incident controls, and workflow
    wiring. Verification:
    `python3 V2/ue/Tools/check-v2-live-ops-documentation-playbook.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-live-ops-documentation-playbook.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/LiveOps/LiveOpsDocumentationPlaybook_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.

---

### 72.13 Engine-Level Game Accessibility Framework

Accessibility built into the engine — not per-game, but as reusable engine
systems for colorblind support, input remapping, subtitles, and motor
accessibility.

#### 72.13.1 Visual & Audio Accessibility

- [x] **72.13.1.1** Implement engine-level colorblind simulation shader
      (protanopia, deuteranopia, tritanopia, achromatopsia filters as
      post-process)
  - Evidence: Added `V2ColorblindSimulation.usf` as the engine-level colorblind
    simulation post-process shader with protanopia, deuteranopia, tritanopia,
    and achromatopsia matrices plus runtime strength blending over scene color.
    Added `FV2ColorblindSimulationSettings`, `FV2ColorblindSimulationMatrix`,
    and `FV2ColorblindPostProcessPass` in V2UI, mapped `/V2/Accessibility`
    during module startup, added `ColorblindSimulationShader.spec.cpp`, the
    accessibility runbook, `ColorblindSimulationShader_V2_Contract.json`,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-colorblind-simulation-shader.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-colorblind-simulation-shader.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/ColorblindSimulationShader_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.2** Create colorblind-safe palette system (provide
      accessibility-verified color alternatives for all UI indicators)
  - Evidence: Added `FV2ColorblindSafePaletteEntry`,
    `FV2ColorblindSafePaletteCatalog`, and `FV2ColorblindSafePalette` in V2UI
    with Default, Protanope, Deuteranope, Tritanope, and Monochromacy
    alternatives for Health, Guard, Stamina, Super, Warning, Danger, Success,
    Objective, quest, interaction, focus, ping, and team UI indicators. Each
    catalog entry carries a stable `UI.Color.*` token, verified 4.5:1-or-better
    contrast metadata, a non-color shape token, and a text fallback token so no
    indicator relies on color alone. Added `ColorblindSafePalette.spec.cpp`,
    `ColorblindSafePalette_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-colorblind-safe-palette.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-colorblind-safe-palette.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/ColorblindSafePalette_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.3** Implement high-contrast mode (increase contrast of game
      elements, outline interactive objects, simplify backgrounds)
  - Evidence: Added `FV2HighContrastModeRule`, `FV2HighContrastModeProfile`, and
    `FV2HighContrastMode` in V2UI with the `Accessibility.HighContrastMode.V2`
    profile bound to `EV2UIContrastMode::High`, `HUD.Theme.HighContrast`, and
    `UI.Accessibility.HighContrast.PostProcess`. The profile requires
    7.0:1-or-better game-element contrast, HUD/gameplay target coverage,
    interactive-object, pickup, objective, focus, hit-zone, opponent, and
    fighter-silhouette outlines, plus background dimming/desaturation and
    decorative-background suppression. Added `HighContrastMode.spec.cpp`,
    `HighContrastMode_V2_Contract.json`, the accessibility runbook, CI/Horde
    gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-high-contrast-mode.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-high-contrast-mode.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/HighContrastMode_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.4** Create screen magnification system (zoom into portion of
      screen, moveable focus area)
  - Evidence: Added `FV2ScreenMagnificationFocusArea`,
    `FV2ScreenMagnificationSettings`, `FV2ScreenMagnificationViewport`, and
    `FV2ScreenMagnification` in V2UI. The system supports 1.5x, 2.0x, 3.0x, and
    4.0x zoom, builds a normalized magnified source rect from a moveable
    `UI.Accessibility.Magnifier.FocusArea`, clamps the focus area to viewport
    bounds, preserves aspect ratio and HUD safe zones, supports
    keyboard/controller panning, and requires screen-reader focus-area
    announcements. Added `ScreenMagnification.spec.cpp`,
    `ScreenMagnification_V2_Contract.json`, the accessibility runbook, CI/Horde
    gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-screen-magnification.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-screen-magnification.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/ScreenMagnification_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.5** Implement text scaling system (global UI text size
      multiplier 0.5x-3x, respecting layout constraints)
  - Evidence: Added `FV2TextScalingLayoutRule`, `FV2TextScalingResult`,
    `FV2TextScalingSettings`, and `FV2TextScaling` in V2UI with
    `Accessibility.TextScaling.V2`, supported global multipliers of 0.5x, 0.75x,
    1.0x, 1.25x, 1.5x, 2.0x, 2.5x, and 3.0x, and layout rules for HUD, menus,
    dialogue, subtitles, quest tracker, notifications, and buttons. Updated
    `FV2UIAccessibilitySettings::TextScale` metadata, normalization, and
    validation to accept the 0.5x-3.0x range while preserving the 1.5x
    large-text minimum. Layout rules require container reflow, text wrapping at
    scale, hit-target preservation, overlap prevention, and safe-zone respect.
    Added `TextScaling.spec.cpp`, `TextScaling_V2_Contract.json`, the
    accessibility runbook, CI/Horde gates, and focused checker coverage.
    Verification: `python3 V2/ue/Tools/check-v2-text-scaling.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-text-scaling.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/TextScaling_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.6** Create screen reader bridge (expose UI element tree to
      platform accessibility APIs — UIAutomation on Windows, NSAccessibility on
      macOS, TalkBack on Android)
  - Evidence: Added `EV2ScreenReaderPlatform`, `EV2ScreenReaderNodeRole`,
    `FV2ScreenReaderBridgeNode`, `FV2ScreenReaderPlatformBinding`,
    `FV2ScreenReaderBridgeTree`, and `FV2ScreenReaderBridge` in V2UI. The bridge
    exports `Accessibility.ScreenReaderBridge.V2` as a stable UI element tree
    with platform bindings for UIAutomation, NSAccessibility, and TalkBack, maps
    required Window/Button/Text/List/ListItem/LiveRegion roles, preserves focus
    order and stable node ids, supports focus/value-changed events, action
    hints, and live-region announcements, and converts
    `FV2QuestUIAccessibilityDescriptor` summaries into bridge nodes. Added
    `ScreenReaderBridge.spec.cpp`, `ScreenReaderBridge_V2_Contract.json`, the
    accessibility runbook, CI/Horde gates, and focused checker coverage.
    Verification: `python3 V2/ue/Tools/check-v2-screen-reader-bridge.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-screen-reader-bridge.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/ScreenReaderBridge_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.7** Implement visual sound indicators (display directional
      indicators for off-screen sounds — gunfire, footsteps, environmental
      hazards)
  - Evidence: Added `EV2VisualSoundIndicatorCueType`,
    `EV2VisualSoundIndicatorShape`, `FV2VisualSoundIndicatorRule`,
    `FV2VisualSoundIndicatorEvent`, `FV2VisualSoundIndicatorRenderItem`,
    `FV2VisualSoundIndicatorProfile`, and `FV2VisualSoundIndicators` in V2UI.
    The profile exports `Accessibility.VisualSoundIndicators.V2` for
    `HUD.Accessibility.VisualSoundIndicators`, covers Gunfire, Footstep, and
    EnvironmentalHazard cues with non-color-coded Chevron/Footprint/Warning
    Diamond shapes, clamps off-screen sound events to safe-area screen-edge
    anchors, preserves direction/scale/opacity/priority metadata, and remains
    valid when audio is muted. Added `VisualSoundIndicators.spec.cpp`,
    `VisualSoundIndicators_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-visual-sound-indicators.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-visual-sound-indicators.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/VisualSoundIndicators_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.8** Create subtitle rendering system (speaker identification,
      directional indicator, non-verbal sound captions [explosion], background
      color/opacity options, size scaling)
  - Evidence: Added `EV2SubtitleRenderingCueType`,
    `EV2SubtitleRenderingDirection`, `FV2SubtitleRenderingStyle`,
    `FV2SubtitleRenderingLine`, `FV2SubtitleRenderingItem`,
    `FV2SubtitleRenderingProfile`, and `FV2SubtitleRenderingSystem` in V2UI. The
    profile exports `Accessibility.SubtitleRendering.V2` for
    `HUD.Accessibility.Subtitles`, resolves Dialogue/NonVerbalSound/Commentary
    lines into render items, includes speaker labels and directional icon
    tokens, renders non-verbal captions in brackets such as `[explosion]`,
    exposes background color and opacity options, supports text size scaling up
    to 3.0x, and keeps subtitle anchors safe-area aware. Added
    `SubtitleRenderingSystem.spec.cpp`,
    `SubtitleRenderingSystem_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-subtitle-rendering-system.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-subtitle-rendering-system.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/SubtitleRenderingSystem_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.9** Implement closed caption authoring tool (tag non-verbal
      sounds in audio assets: [door creaks], [thunder], [enemy grunts])
  - Evidence: Added `EV2ClosedCaptionAuthoringSoundType`,
    `EV2ClosedCaptionAuthoringIssueType`, `FV2ClosedCaptionAuthoringTag`,
    `FV2ClosedCaptionAuthoringAssetRecord`, `FV2ClosedCaptionAuthoringPreview`,
    `FV2ClosedCaptionAuthoringProfile`, and `FV2ClosedCaptionAuthoringTool` in
    V2UI. The tool profile exports `Accessibility.ClosedCaptionAuthoring.V2` for
    `Tools.Accessibility.ClosedCaptionAuthoring`, links non-verbal caption tags
    to audio asset ids/source paths, validates bracketed captions, timing
    ranges, localization keys, batch validation, and subtitle-rendering export,
    and covers required examples `[door creaks]`, `[thunder]`, and
    `[enemy grunts]`. Added `ClosedCaptionAuthoringTool.spec.cpp`,
    `ClosedCaptionAuthoringTool_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-closed-caption-authoring-tool.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-closed-caption-authoring-tool.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/ClosedCaptionAuthoringTool_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.10** Create visual cue duplication for all audio-only feedback
      (screen flash for damage, controller vibration for events)
  - Evidence: Added `EV2AudioFeedbackCueType`,
    `EV2AudioFeedbackVisualDuplicate`, `EV2AudioFeedbackHapticDuplicate`,
    `FV2AudioFeedbackDuplicationRule`, `FV2AudioFeedbackDuplicateCue`,
    `FV2AudioFeedbackDuplicationProfile`, and `FV2AudioFeedbackDuplication` in
    V2UI. The profile exports `Accessibility.AudioFeedbackDuplication.V2` for
    `HUD.Accessibility.AudioFeedbackDuplication`, maps Damage/CombatTiming/
    SystemEvent/QuestEvent/EnvironmentalWarning audio-only cues to visual and
    haptic duplicates, requires screen flash plus controller vibration for
    damage, controller vibration for events, muted-audio behavior, no audio-only
    fallback state, and photosensitivity-safe thresholds. Added
    `AudioFeedbackDuplication.spec.cpp`,
    `AudioFeedbackDuplication_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-audio-feedback-duplication.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-audio-feedback-duplication.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/AudioFeedbackDuplication_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.11** Implement camera shake intensity slider (0-100%, default
      100%, for motion sensitivity)
  - Evidence: Added `FV2CameraShakeIntensitySliderSpec`,
    `FV2CameraShakeIntensityResolution`, `FV2CameraShakeIntensityProfile`, and
    `FV2CameraShakeIntensitySlider` in V2UI. The profile exports
    `Accessibility.CameraShakeIntensity.V2` for
    `Settings.Accessibility.CameraShakeIntensity`, normalizes the shared
    `FV2UIAccessibilitySettings::CameraShakeIntensityPercent` value to a 0-100%
    slider in 5% steps with default 100%, resolves authored camera-shake
    intensity without amplification, disables camera shake at 0%, covers
    CombatHit/EnvironmentalImpact/VehicleImpact/Cinematic/UIImpact sources, and
    remains frame-data inert for motion sensitivity. Wired the default settings
    screen row, settings contract, blueprint helpers, UI subsystem
    setter/getter, `CameraShakeIntensitySlider.spec.cpp`,
    `CameraShakeIntensitySlider_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-camera-shake-intensity-slider.py`,
    `python3 V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-camera-shake-intensity-slider.py V2/ue/Tools/check-v2-settings-ui.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/CameraShakeIntensitySlider_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Settings/SettingsScreen_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.12** Create reduced motion mode (disable screen shake, reduce
      particle effects, slow camera transitions)
  - Evidence: Added `EV2ReducedMotionTarget`, `FV2ReducedMotionModeRule`,
    `FV2ReducedMotionModeState`, `FV2ReducedMotionModeProfile`, and
    `FV2ReducedMotionMode` in V2UI. The profile exports
    `Accessibility.ReducedMotionMode.V2` for
    `Settings.Accessibility.ReducedMotion`, uses
    `FV2UIAccessibilitySettings::bReducedMotion` as the source setting, disables
    screen shake, reduces particle intensity to 50% or lower, slows camera
    transitions with duration/speed clamps, suppresses looping HUD motion,
    suppresses hard cinematic cuts, and remains deterministic/frame-data inert.
    Updated the default Settings Accessibility row description, added settings
    widget/subsystem accessors, `ReducedMotionMode.spec.cpp`,
    `ReducedMotionMode_V2_Contract.json`, the accessibility runbook, CI/Horde
    gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-reduced-motion-mode.py`,
    `python3 V2/ue/Tools/check-v2-hud-accessibility-presentation.py`,
    `python3 V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-reduced-motion-mode.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/ReducedMotionMode_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.13** Implement photosensitivity filter (reduce rapid flashing,
      strobe effects, high-contrast flickering)
  - Evidence: Added `EV2PhotosensitivityFilterTarget`,
    `FV2PhotosensitivityFilterRule`, `FV2PhotosensitivityFilterInput`,
    `FV2PhotosensitivityFilterResult`, `FV2PhotosensitivityFilterProfile`, and
    `FV2PhotosensitivityFilter` in V2UI. The profile exports
    `Accessibility.PhotosensitivityFilter.V2` for
    `PostProcess.Accessibility.PhotosensitivityFilter`, covers
    RapidFlashing/StrobeEffects/HighContrastFlicker/LightningVFX/KOXRay targets,
    clamps rapid flashing to 3 fps or lower, suppresses authored strobes,
    reduces luminance and high-contrast flicker deltas, applies before post
    process, requires content-review tags, and remains deterministic for
    gameplay/replay consistency. Added `PhotosensitivityFilter.spec.cpp`,
    `PhotosensitivityFilter_V2_Contract.json`, the accessibility runbook,
    CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-photosensitivity-filter.py`,
    `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-photosensitivity-filter.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/PhotosensitivityFilter_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.14** Create font accessibility options (dyslexia-friendly font
      option, letter spacing adjustment)
  - Evidence: Added `EV2UIReadableFontMode`, `FV2FontAccessibilityOption`,
    `FV2LetterSpacingAdjustmentSpec`, `FV2FontAccessibilityResolvedStyle`,
    `FV2FontAccessibilityProfile`, and `FV2FontAccessibilityOptions` in V2UI.
    The profile exports `Accessibility.FontAccessibilityOptions.V2` for
    `Settings.Accessibility.FontOptions`, exposes
    `Settings.Accessibility.ReadableFont` with Default, Atkinson Hyperlegible,
    and OpenDyslexic choices, marks OpenDyslexic as the dyslexia-friendly
    option, and exposes `Settings.Accessibility.LetterSpacing` from 0 to 50% in
    5% steps with a 0.12em maximum. It resolves HUD/menu/dialogue/subtitle/quest
    tracker/notification/button text surfaces, preserves localization fallbacks,
    requires layout reflow, prevents overlap, preserves hit targets, saves
    through `FV2UIAccessibilitySettings`, and remains frame-data inert. Added
    `FontAccessibilityOptions.spec.cpp`,
    `FontAccessibilityOptions_V2_Contract.json`, the accessibility runbook,
    settings screen row/helper coverage, CI/Horde gates, and focused checker
    coverage. Verification:
    `python3 V2/ue/Tools/check-v2-font-accessibility-options.py`,
    `python3 V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
    `python3 V2/ue/Tools/check-v2-text-scaling.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-font-accessibility-options.py V2/ue/Tools/check-v2-settings-ui.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/FontAccessibilityOptions_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Settings/SettingsScreen_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.1.15** Implement accessibility settings persistence (save per-
      player accessibility preferences, apply on startup before any gameplay)
  - Evidence: Added `FV2PersistedAccessibilitySettings` to V2Persistence with
    normalized per-player HUD scale, HUD opacity, reduced motion, camera shake
    intensity, screen reader announcement, large text, text scale, palette,
    contrast, readable font, and letter-spacing fields.
    `FV2PlayerSettingsSnapshot`, `UV2SaveGame`,
    `UV2PersistenceBlueprintLibrary`, and `UV2PersistenceSubsystem` now save
    accessibility settings, resolve startup accessibility settings, mark startup
    application, and expose runtime snapshot evidence.
    `UV2UISubsystem::ApplyStartupAccessibilitySettings` applies the normalized
    runtime `FV2UIAccessibilitySettings` before gameplay surfaces bind and
    records `WereAccessibilitySettingsAppliedBeforeGameplay`. Added
    `AccessibilitySettingsPersistence.spec.cpp`,
    `AccessibilitySettingsPersistence_V2_Contract.json`, the accessibility
    runbook, profile-save contract updates, CI/Horde gates, and focused checker
    coverage. Verification:
    `python3 V2/ue/Tools/check-v2-accessibility-settings-persistence.py`,
    `python3 V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 V2/ue/Tools/check-v2-persistence-module.py`,
    `python3 V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-accessibility-settings-persistence.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/AccessibilitySettingsPersistence_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/Persistence/Profile/ProfileSaveGame_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.

#### 72.13.2 Motor & Cognitive Accessibility

- [x] **72.13.2.1** Implement global input remapping system (remap any game
      action to any input on any device, persist per-player)
  - Evidence: Added `FV2GlobalInputRemapProfile`, `FV2InputRemapOverride`, and
    `FV2ResolvedInputRemapBinding` to V2Input. The profile validates
    player-authored overrides against the existing per-platform rebind slot
    tables, resolves effective bindings, rejects conflicting binding tokens
    without replacing the last valid profile, and allows cross-device stable
    binding tokens for any game action. Added Blueprint helpers for default
    profile creation, override upsert/removal, and effective binding resolution.
    `FV2PlayerSettingsSnapshot`, `UV2SaveGame`, and `UV2PersistenceSubsystem`
    now persist per-player remap profiles, resolve them on startup, reject
    cross-account profiles, and record before-gameplay apply evidence in runtime
    snapshots. Added `GlobalInputRemapping_V2_Contract.json`, the input
    remapping runbook, CI/Horde gates, and focused checker coverage.
    Verification: `python3 V2/ue/Tools/check-v2-global-input-remapping.py`,
    `python3 V2/ue/Tools/check-v2-input-mapping-contexts.py`,
    `python3 V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 V2/ue/Tools/check-v2-persistence-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-global-input-remapping.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 -m json.tool V2/ue/Content/V2/Input/Remapping/GlobalInputRemapping_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/Persistence/Profile/ProfileSaveGame_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.2.2** Create hold-to-toggle conversion (any hold action can be set
      to toggle: hold-to-aim → toggle-aim, hold-to-sprint → toggle-sprint)
  - Evidence: Added `FV2HoldToToggleConversionProfile`,
    `FV2HoldToToggleActionRule`, `FV2HoldToTogglePreference`, and
    `FV2ResolvedHoldToToggleAction` to V2Input with default rules for aim,
    sprint, block, grapple, Blazin, submission grid, pin press, and run. The
    profile validates against hold-action rules, resolves hold vs toggle action
    names, rejects unknown or non-hold action preferences without replacing the
    last valid profile, and exposes Blueprint helpers for default creation,
    upsert, reset, and resolution. `UV2InputConfigAsset` validates the profile,
    `FV2AccessibilityMotorAssistConfig` exposes action-level hold-to-toggle rows
    for aim/sprint, and `FV2PlayerSettingsSnapshot`, `UV2SaveGame`, and
    `UV2PersistenceSubsystem` persist per-player hold-to-toggle profiles,
    resolve them on startup, reject cross-account profiles, and record
    before-gameplay apply evidence. Added
    `HoldToToggleConversion_V2_Contract.json`, the input runbook, CI/Horde
    gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-hold-to-toggle-conversion.py`,
    `python3 V2/ue/Tools/check-v2-input-module.py`,
    `python3 V2/ue/Tools/check-v2-input-mapping-contexts.py`,
    `python3 V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 V2/ue/Tools/check-v2-persistence-module.py`,
    `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-hold-to-toggle-conversion.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 -m json.tool V2/ue/Content/V2/Input/Accessibility/HoldToToggleConversion_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/Persistence/Profile/ProfileSaveGame_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/AccessibilityFeatureSet_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.2.3** Implement auto-aim assist with configurable strength (off,
      low, medium, high, lock-on — separate for camera and aim)
  - Evidence: Added `EV2AutoAimAssistStrength`,
    `FV2AutoAimAssistStrengthTuning`, `FV2AutoAimAssistProfile`, and
    `FV2ResolvedAutoAimAssist` to V2Input. The default profile is per-player and
    off by default, validates against the five required strength tunings (`Off`,
    `Low`, `Medium`, `High`, `LockOn`), resolves aim and camera strengths
    independently, and exposes Blueprint helpers to build defaults, set separate
    strengths, and resolve effective assist state. Added `UV2InputConfigAsset`
    validation, `FV2AccessibilityMotorAssistConfig` metadata for separate
    camera/aim rows, explicit Settings > Accessibility rows for aim assist
    strength and camera assist strength, per-player persistence in
    `FV2PlayerSettingsSnapshot`, `UV2SaveGame`, and `UV2PersistenceSubsystem`,
    cross-account save rejection, startup restore, and before-gameplay apply
    evidence. Added `AutoAimAssist_V2_Contract.json`,
    SettingsScreen/ProfileSave/Accessibility contract updates, the input
    runbook, CI/Horde gates, and focused checker coverage. Verification:
    `python3 V2/ue/Tools/check-v2-auto-aim-assist.py`,
    `python3 V2/ue/Tools/check-v2-input-module.py`,
    `python3 V2/ue/Tools/check-v2-input-mapping-contexts.py`,
    `python3 V2/ue/Tools/check-v2-global-input-remapping.py`,
    `python3 V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 V2/ue/Tools/check-v2-persistence-module.py`,
    `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-auto-aim-assist.py V2/ue/Tools/check-v2-ci-workflow.py V2/ue/Tools/check-v2-profile-save-game.py V2/ue/Tools/check-v2-persistence-module.py V2/ue/Tools/check-v2-accessibility-feature-set.py V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 -m json.tool V2/ue/Content/V2/Input/Accessibility/AutoAimAssist_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/Persistence/Profile/ProfileSaveGame_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/AccessibilityFeatureSet_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Settings/SettingsScreen_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`, and
    `npx --no-install prettier --check`.
- [x] **72.13.2.4** Create one-handed control schemes (full gameplay possible
      with left-hand-only or right-hand-only controller use)
  - Evidence: Added `EV2OneHandedInputSide`, `FV2OneHandedInputActionMapping`,
    `FV2OneHandedInputScheme`, `FV2OneHandedInputProfile`, and
    `FV2ResolvedOneHandedInputScheme` to V2Input. The default input config now
    builds canonical `Controls.OneHanded.Off`, `Controls.OneHanded.Left`, and
    `Controls.OneHanded.Right` schemes; left and right presets each validate
    full 33-action gameplay coverage across movement, attacks, defense, grapple,
    team, presentation, environment, and ruleset-specific slots with
    single-hand-scoped stable binding tokens. Added Blueprint helpers to build,
    select, and resolve one-handed profiles; `UV2InputConfigAsset` validation;
    UI scheme linkage through `InputSchemeId`, full-gameplay coverage, and
    left/right parity flags; Settings and pause-flow contract coverage;
    per-player persistence in `FV2PlayerSettingsSnapshot`, `UV2SaveGame`, and
    `UV2PersistenceSubsystem`; cross-account save rejection; startup restore;
    and before-gameplay apply evidence. Added
    `OneHandedControlSchemes_V2_Contract.json`, the input runbook,
    ProfileSave/Accessibility/Pause/Settings contract updates, CI/Horde gates,
    focused checker coverage, and C++ automation assertions for V2Input,
    V2Persistence, ProfileSave, UI Module, SettingsScreen, and
    PausePracticeFlow. Verification:
    `python3 V2/ue/Tools/check-v2-one-handed-control-schemes.py`,
    `python3 V2/ue/Tools/check-v2-input-module.py`,
    `python3 V2/ue/Tools/check-v2-profile-save-game.py`,
    `python3 V2/ue/Tools/check-v2-persistence-module.py`,
    `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
    `python3 V2/ue/Tools/check-v2-settings-ui.py`,
    `python3 V2/ue/Tools/check-v2-pause-practice-flow.py`,
    `python3 V2/ue/Tools/check-v2-ui-module.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 V2/tools/validate-v2-docs.py`,
    `python3 -m py_compile V2/ue/Tools/check-v2-one-handed-control-schemes.py V2/ue/Tools/check-v2-input-module.py V2/ue/Tools/check-v2-profile-save-game.py V2/ue/Tools/check-v2-persistence-module.py V2/ue/Tools/check-v2-accessibility-feature-set.py V2/ue/Tools/check-v2-settings-ui.py V2/ue/Tools/check-v2-pause-practice-flow.py V2/ue/Tools/check-v2-ui-module.py V2/ue/Tools/check-v2-ci-workflow.py`,
    `python3 -m json.tool V2/ue/Content/V2/Input/Accessibility/OneHandedControlSchemes_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/Persistence/Profile/ProfileSaveGame_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Accessibility/AccessibilityFeatureSet_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Pause/PausePracticeFlow_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Content/V2/UI/Settings/SettingsScreen_V2_Contract.json`,
    `python3 -m json.tool V2/ue/Build/Horde/v2-buildgraph-job.json`,
    `git diff --check`, and `npx --no-install prettier --check`.
- [x] **72.13.2.5** Implement QTE alternatives (replace quick-time events with
      hold-button or auto-complete options) // Implemented QTE alternatives
      end-to-end. Added `EV2QTEAlternativeMode`, `FV2QTEAlternativeProfile`, and
      `FV2ResolvedQTEAlternative` in V2Input with Blueprint helpers to build,
      set, and resolve the saved `QTEAlternative.Off`,
      `QTEAlternative.HoldButton`, and `QTEAlternative.AutoComplete` choices.
      Story QTE prompts now require a 45-frame hold-button alternative, opt-in
      auto-complete that resolves to the authored success outcome, canonical
      settings/profile ids, and single-player story-only frame-data-inert
      policy. Settings and accessibility configs expose
      `Settings.Accessibility.QTEAlternative` with Off/Hold button/Auto-complete
      choices, and persistence stores the selected profile per player with
      startup restore/apply tracking plus cross-account rejection. Added
      `QTEAlternatives_V2_Contract.json`, the input runbook,
      ProfileSave/StoryMode/Accessibility/Settings contract updates, CI/Horde
      gates, focused checker coverage, and C++ automation assertions for
      V2Input, V2Modes, V2Persistence, ProfileSave, UI Module, and
      SettingsScreen. Verification: targeted QTE, input, story mode, modes,
      profile-save, persistence, accessibility feature-set, settings UI, UI
      module, CI workflow, and docs validators; Python bytecode compilation for
      the touched checkers; JSON syntax validation for the touched contracts;
      `npx --no-install prettier --check`; and `git diff --check`.
- [x] **72.13.2.6** Create timing adjustment system (extend time limits for
      timed puzzles, slow QTE windows, adjustable dodge timing). Implemented a
      per-player `FV2TimingAdjustmentProfile` and `FV2ResolvedTimingAdjustment`
      with authored defaults, timed puzzle limit scalars, story QTE window
      scalars, and dodge input-grace frames. Timed puzzle quest failure rules
      now opt into timing-aware limits, story QTE prompts carry canonical timing
      profile/row metadata, settings expose independent timed puzzle/QTE/dodge
      rows, and persistence stores, restores, applies, and cross-account
      validates the timing profile before gameplay. Added
      `TimingAdjustmentSystem_V2_Contract.json`, the input runbook,
      accessibility report coverage, ProfileSave/StoryMode/Settings/
      Accessibility/QuestFailure contract updates, CI/Horde gates, focused
      checker coverage, and C++ automation assertions for V2Input,
      QuestFailureConditions, V2Modes, V2Persistence, ProfileSave, UI Module,
      and SettingsScreen. Verification: targeted timing adjustment, QTE, input,
      quest failure, story mode, modes, profile-save, persistence, accessibility
      feature-set, settings UI, UI module, CI workflow, and docs validators;
      Python bytecode compilation for the touched checkers; JSON syntax
      validation for the touched contracts and Horde job; Prettier formatting;
      and `git diff --check`.
- [x] **72.13.2.7** Implement sequential input for combos (replace simultaneous
      button presses with sequential press alternatives)
  - Evidence (2026-06-21): Added `FV2SequentialComboInputProfile`,
    `FV2SequentialComboInputCatalog`, authored chord specs, sequential requests,
    resolver results, and Blueprint helpers in V2Input so opt-in two-button and
    all-combo sequential alternatives resolve to the same authored actions and
    command tags while default-off mode preserves simultaneous chords. Added the
    `Settings.Accessibility.SequentialComboInput` row, accessibility motor
    feature-set metadata, per-player profile persistence/startup restore,
    save-game/subsystem APIs, contracts, docs, Horde/CI gates, focused checker,
    and automation assertions across Input, UI, SettingsScreen, Persistence, and
    ProfileSave. Verification: targeted sequential-combo, input, accessibility
    feature-set, settings UI, UI module, profile-save, persistence, CI workflow,
    docs, JSON, Python bytecode, formatting, and diff checks.
- [x] **72.13.2.8** Create adaptive difficulty system (auto-adjust difficulty
      based on player performance — deaths, retries, completion time)
  - Evidence (2026-06-21): Added `FV2AdaptiveDifficultyProfile`,
    `FV2AdaptiveDifficultyPerformanceSample`, `FV2AdaptiveDifficultyDecision`,
    and `EV2AdaptiveDifficultyMode` in V2AdaptiveAI. The profile is per-player,
    opt-in, default-off, applied before gameplay, and exposed through
    `Settings.Accessibility.AdaptiveDifficulty` with Off, Assistive, and
    Balanced modes. The evaluator uses death count, retry count, consecutive
    failures, completion-time ratio, and perfect clears to adjust a bounded
    `-2..+2` difficulty step, while Assistive never exceeds authored difficulty
    and ranked/tournament play locks back to manual difficulty. Added incoming
    damage, CPU skill, and encounter pacing outputs without mutating frame data;
    UI/accessibility metadata; save-game/settings snapshot persistence with
    startup restore/apply timestamps and cross-account rejection; Adaptive
    Difficulty contracts/docs; AI Director/model-card linkage; Horde/CI gates;
    focused checker coverage; and automation assertions across AdaptiveAI, UI,
    SettingsScreen, Persistence, and ProfileSave. Verification: targeted
    `check-v2-adaptive-difficulty-system.py`, adaptive AI ladder, AI Director
    adaptive matchmaking, accessibility feature-set, settings UI, UI module,
    profile-save, persistence, CI workflow, docs, JSON, Python bytecode,
    formatting, and diff checks.
- [x] **72.13.2.9** Implement puzzle skip option (after N attempts or
      configurable time, offer to skip puzzle with narrative summary)
  - Evidence (2026-06-22): Added the per-player `FV2PuzzleSkipProfile`,
    `FV2ResolvedPuzzleSkipOption`, and `EV2PuzzleSkipOfferMode` in V2Input with
    default-off `PuzzleSkip.Off`, opt-in `PuzzleSkip.AttemptsOrElapsedTime`,
    2-10 attempt thresholds, 60-600 second elapsed-time thresholds, and
    Blueprint helpers to build, configure, and resolve the option. Added V2Modes
    puzzle-skip policies, requests, and offers that cover story, Krypt, and
    Konquest puzzle examples; offer after attempts or elapsed time; require
    player confirmation and narrative summaries; preserve rewards; avoid
    fail-state penalties; hide summaries/rewards when not offered; stay
    single-player story only; and lock out ranked/tournament contexts without
    altering frame data. Exposed settings rows
    `Settings.Accessibility.PuzzleSkip`,
    `Settings.Accessibility.PuzzleSkipAttempts`, and
    `Settings.Accessibility.PuzzleSkipElapsedTime`, plus accessibility metadata,
    save-game/settings snapshot persistence, startup restore/apply timestamps,
    cross-account rejection, JSON contracts, docs, Horde/CI gates, focused
    checker coverage, and automation assertions across Input, Modes, UI,
    SettingsScreen, Persistence, and ProfileSave. Verification: targeted
    `check-v2-puzzle-skip-option.py`, input module, modes module, accessibility
    feature-set, settings UI, UI module, profile-save, persistence, CI workflow,
    docs, JSON, Python bytecode, Prettier, and diff checks.
- [x] **72.13.2.10** Create objective clarity system (clear waypoints,
      highlighted interactables, simplified quest descriptions for cognitive
      accessibility)
  - Evidence (2026-06-22): Added the per-player `FV2ObjectiveClarityProfile`,
    `FV2ResolvedObjectiveClarityOption`, and `EV2ObjectiveClarityMode` in
    V2Input with default-off `ObjectiveClarity.Off`, opt-in
    `ObjectiveClarity.ClearWaypoints` and `ObjectiveClarity.Guided` modes,
    startup apply semantics, and Blueprint helpers to build, set, and resolve
    the profile. Added the V2UI `FV2ObjectiveClarityRequest` and
    `FV2ObjectiveClarityPresentation` composition layer through
    `UV2ObjectiveClaritySystemLibrary`, validating quest tracker, waypoint, and
    area-highlight specs before activating clear waypoints, highlighted
    interactables, simplified quest description text, current-objective focus,
    controller-first guided focus, and screen-reader objective summaries.
    Exposed `Settings.Accessibility.ObjectiveClarity`, accessibility feature
    metadata, save-game/settings snapshot persistence, startup restore/apply
    timestamps, cross-account rejection, the
    `ObjectiveClaritySystem_V2_Contract.json` contract, the
    `objective-clarity-system.md` runbook, Horde/CI gates, and focused checker
    coverage. Verification: targeted `check-v2-objective-clarity-system.py`,
    input module, accessibility feature-set, settings UI, UI module,
    profile-save, persistence, CI workflow, docs, JSON, Python bytecode,
    formatting, and diff checks.
- [x] **72.13.2.11** Implement tutorial replay system (access any tutorial from
      menu at any time, not just on first encounter)
  - Evidence (2026-06-22): Added `FV2TutorialReplayEntry`,
    `FV2TutorialReplayCatalog`, `FV2TutorialReplayRequest`, and
    `FV2TutorialReplayLaunchResult` in V2UI, generated
    `Tutorial.ReplayAnytime.V2` from every `Tutorial.Interactive.V2` launch
    lesson so all 64 launch tutorials are replayable from the main-menu
    tutorials path and single-player pause menu without first-encounter gates,
    before completion, and without resetting profile progress. Wired
    `Pause.Action.TutorialReplay`, `PauseMenu -> Tutorials`, main-menu Play
    child access, Blueprint helpers, `UV2InteractiveTutorialScreen` replay
    start/list APIs, MVVM replay entries, `UV2UISubsystem` registration and
    launch state, `TutorialReplaySystem_V2_Contract.json`, docs, Horde/CI gates,
    and focused `check-v2-tutorial-replay-system.py` coverage. Verification:
    targeted tutorial replay, interactive tutorial, pause practice flow, UI
    module, CI workflow, docs, JSON, Python bytecode, formatting, and diff
    checks.
- [x] **72.13.2.12** Create game speed adjustment (global game speed 0.5x-1.0x
      for players who need more reaction time)
  - Evidence (2026-06-22): Extended `FV2TimingAdjustmentProfile` and
    `FV2ResolvedTimingAdjustment` with `GlobalGameSpeedScalar`,
    `SetGlobalGameSpeedScalar`, `ResolveGlobalGameSpeedScalar`, and
    `ResolveGlobalGameSpeedDeltaSeconds`, enforcing a 0.5x-1.0x range in 0.05x
    steps, default 1.0x, player opt-in, single-player scope,
    ranked-disabled/tournament-restricted policy, frame-data inert handling, and
    world-time-dilation application. Added
    `Settings.Accessibility.GlobalGameSpeed` as a 50-100 percent accessibility
    slider, persisted the scalar through the existing timing adjustment startup
    path, updated contracts/docs/Horde/CI, and added focused
    `check-v2-game-speed-adjustment.py` coverage. Verification: targeted
    game-speed adjustment, timing adjustment, input module, settings UI,
    accessibility feature-set, profile-save, persistence, UI module, CI
    workflow, docs, JSON, Python bytecode, formatting, and diff checks.
- [x] **72.13.2.13** Implement Xbox Adaptive Controller support (full
      compatibility testing and input mapping). Added
      `XboxAdaptiveControllerSupport_V2_Contract.json`,
      `Input.Mapping.XboxAdaptiveController.V2`, and
      `Hardware.Compatibility.XboxAdaptiveController.V2`; expanded
      `FV2AdaptiveControllerAccessibilitySpec`,
      `HardwarePeripherals_V2_Contract.json`, and `hardware-peripherals.json`
      with Xbox Adaptive mapping/test-plan fields; verified external switch
      mapping, Copilot compatibility, `SOCDPreset.XboxAdaptive.Neutral`, and
      `Tutorial.Device.XboxAdaptive` adaptive-hub glyph coverage; added focused
      `check-v2-xbox-adaptive-controller-support.py` coverage plus CI/Horde/docs
      wiring. Verification: targeted Xbox Adaptive support, hardware
      peripherals, input module, SOCD presets, input-device tutorial overlay,
      accessibility feature-set, UI module, CI workflow, docs, JSON, Python
      bytecode, formatting, and diff checks.
- [x] **72.13.2.14** Create accessibility preset profiles (vision impaired,
      hearing impaired, motor impaired, cognitive — one-click application).
      Added `FV2AccessibilityPresetCatalog`, `FV2AccessibilityPresetProfile`,
      `FV2AccessibilityPresetSettingOverride`, and
      `FV2AccessibilityPresetApplicationResult` in V2UI with canonical
      `AccessibilityPreset.VisionImpaired`,
      `AccessibilityPreset.HearingImpaired`,
      `AccessibilityPreset.MotorImpaired`, and `AccessibilityPreset.Cognitive`
      profiles. The Settings Accessibility surface now exposes
      `Settings.Accessibility.PresetProfile` with Custom plus the four one-click
      choices, and each preset applies its own selector row plus the existing
      visual, hearing, motor, timing, objective clarity, puzzle skip, adaptive
      difficulty, readable-font, and spacing rows it owns. Persisted
      accessibility settings now store
      `FV2PersistedAccessibilitySettings.SelectedPresetId` with startup
      normalization and restore coverage. Added
      `AccessibilityPresetProfiles_V2_Contract.json`,
      `accessibility-preset-profiles.md`, CI/Horde gates, ProfileSave/Settings/
      Accessibility contract updates, and focused checker coverage.
      Verification:
      `python3 V2/ue/Tools/check-v2-accessibility-preset-profiles.py`,
      `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
      `python3 V2/ue/Tools/check-v2-settings-ui.py`,
      `python3 V2/ue/Tools/check-v2-ui-module.py`,
      `python3 V2/ue/Tools/check-v2-profile-save-game.py`,
      `python3 V2/ue/Tools/check-v2-persistence-module.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`,
      `python3 -m py_compile V2/ue/Tools/check-v2-accessibility-preset-profiles.py V2/ue/Tools/check-v2-accessibility-feature-set.py V2/ue/Tools/check-v2-settings-ui.py V2/ue/Tools/check-v2-profile-save-game.py V2/ue/Tools/check-v2-ci-workflow.py`,
      JSON syntax validation for the touched contracts and Horde job, Prettier,
      and `git diff --check`.
- [x] **72.13.2.15** Implement accessibility compliance testing tool (automated
      checker verifying Xbox Accessibility Guidelines and Game Accessibility
      Guidelines coverage). Added
      `AccessibilityComplianceTesting_V2_Contract.json`,
      `AccessibilityComplianceMatrix_V2.json`, and focused
      `check-v2-accessibility-compliance-testing.py` coverage for all `XAG-101`
      through `XAG-123` rows plus the Game Accessibility Guidelines Motor,
      Cognitive, Vision, Hearing, Speech, and General category/level matrix. The
      checker verifies existing evidence paths and snippets, escalates
      human-only claims to `Accessibility QA`, documents the gate as coverage
      readiness rather than legal certification, and wires the new contract,
      matrix, docs, CI workflow, Horde job, and aggregate
      `AccessibilityFeatureSet` release surface. Verification:
      `python3 V2/ue/Tools/check-v2-accessibility-compliance-testing.py`,
      `python3 V2/ue/Tools/check-v2-accessibility-feature-set.py`,
      `python3 V2/ue/Tools/check-v2-accessibility-preset-profiles.py`,
      `python3 V2/ue/Tools/check-v2-accessibility-settings-persistence.py`,
      `python3 V2/ue/Tools/check-v2-settings-ui.py`,
      `python3 V2/ue/Tools/check-v2-ui-module.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the touched contracts and
      Horde job, Prettier, and `git diff --check`.

---

### 72.14 Modding & User-Generated Content Pipeline

Mod SDK, sandboxed mod loading, Steam Workshop/mod.io integration, and UGC
review workflow.

#### 72.14.1 Mod SDK & Runtime

- [x] **72.14.1.1** Design mod file format specification (.mayamod — manifest,
      assets, scripts, metadata, version requirements). Added the canonical
      `.mayamod` package contract in `ModFileFormat_V2_Contract.json`, the
      `MayamodManifest_v1.schema.json` manifest schema, and a
      `CosmeticRecolor.mayamod/manifest.json` sample covering deterministic ZIP
      layout, manifest metadata, version requirements, asset entries, Lua/WASI
      script entries, permission defaults, and SHA-256 integrity hashes.
      Documented the format in `mayamod-file-format.md`, wired
      `check-v2-mod-file-format.py` into CI/Horde, and encoded ranked-disabled,
      offline-cosmetic, default-deny script, no-native-code, and
      originality-shield publishing policy for later loader/sandbox tasks.
      Verification: `python3 V2/ue/Tools/check-v2-mod-file-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the modding contract/schema/
      example manifest and Horde job, Prettier, and `git diff --check`.
- [x] **72.14.1.2** Implement mod loading system (discover mods in designated
      directories, validate manifests, load in dependency order). Added the
      `V2Modding` runtime module with `UV2ModLoadingSubsystem`,
      `UV2ModLoadingBlueprintLibrary`, `FV2ModDirectoryPolicy`,
      `FV2DiscoveredModPackage`, `FV2ModPackageManifest`, validation issue
      structs, dependency requirements, load plans, and load results. The loader
      discovers `.mayamod` files and loose development directories from saved,
      user, and content mod roots; parses `manifest.json`; validates identity,
      version ranges, asset hashes, script limits, integrity hashes, and
      network-denied defaults; and builds a deterministic topological load order
      that rejects duplicate IDs, missing required dependencies, and dependency
      cycles. Added `ModLoadingSystem_V2_Contract.json`,
      `mod-loading-system.md`, `ModLoadingSystem.spec.cpp`, CI/Horde gates,
      optional manifest dependency schema support, and focused
      `check-v2-mod-loading-system.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-mod-file-format.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the modding contract/schema/
      examples/Horde/uProject, Prettier, and `git diff --check`. Local Unreal
      automation execution for `V2.Modding.LoadingSystem` was not run because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-loading-system.py` verifies
      the spec registration and assertions.
- [x] **72.14.1.3** Create mod sandboxing (mods run in restricted environment:
      no filesystem access outside mod directory, no network unless allowed,
      memory limits). Extended `V2Modding` with `FV2ModSandboxPolicy`,
      `FV2ModSandboxRequest`, `FV2ModSandboxDecision`, sandbox issue types, and
      `BuildDefaultModSandboxPolicy`, `IsPathInsideModRoot`, and
      `EvaluateModSandboxRequest` helpers. The default sandbox denies filesystem
      access outside the canonicalized mod root, denies network and native code
      by default, caps script memory at 256 MiB, caps storage at 104,857,600
      bytes, caps script timeout at 100 ms, and records explicit decision issues
      for filesystem escape, network denial, native-code denial, memory,
      storage, and timeout violations. Expanded `ModLoadingSystem.spec.cpp` with
      contained-path, escape-path, network, native-code, and resource-limit
      assertions, and added `ModSandboxing_V2_Contract.json`,
      `mod-sandboxing.md`, CI/Horde gates, and focused
      `check-v2-mod-sandboxing.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-sandboxing.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod sandboxing contract
      and Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-sandboxing.py` verifies the
      spec registration and assertions.
- [x] **72.14.1.4** Implement mod API surface (expose engine systems to modders:
      entity spawning, component modification, event listening, UI creation —
      curated safe subset). Extended `V2Modding` with `EV2ModApiCapability`,
      `EV2ModApiIssueType`, `FV2ModApiCapabilityDescriptor`, `FV2ModApiPolicy`,
      `FV2ModApiRequest`, `FV2ModApiIssue`, and `FV2ModApiResult`. Added the
      default curated capability catalog for public state reads, cosmetic actor
      spawning, cosmetic component mutation, public event listeners, constrained
      UI screen creation, and mod-scoped storage. API requests now require
      sandbox approval, deny networked/ranked-unsafe calls, enforce
      cosmetic-only world mutation, restrict event listeners to `Mod.`,
      `Gameplay.Public.`, and `UI.Public.` namespaces, and restrict UI creation
      to `HUD.ModOverlay`, `Menu.ModPanel`, and `Settings.ModPanel` roots. Added
      request builders, evaluation/execution helpers, subsystem forwarding, API
      automation assertions, `ModApiSurface_V2_Contract.json`,
      `mod-api-surface.md`, CI/Horde gates, and focused
      `check-v2-mod-api-surface.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-api-surface.py`,
      `python3 V2/ue/Tools/check-v2-mod-sandboxing.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod API contract and
      Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-api-surface.py` verifies the
      spec registration and assertions.
- [x] **72.14.1.5** Create mod scripting integration (Lua and/or WASM scripts
      with access to mod API, hot-reloadable during development). Extended
      `V2Modding` with `EV2ModScriptRuntime`, `EV2ModScriptIssueType`,
      `FV2ModScriptRuntimePolicy`, `FV2ModScriptRuntimeBinding`,
      `FV2ModScriptInvocation`, `FV2ModScriptHotReloadRequest`,
      `FV2ModScriptIssue`, and `FV2ModScriptResult`. Added Lua 5.4 and WASI 0.2
      runtime binding from manifest script entries, scripts-only entrypoint and
      runtime-extension validation, sandbox approval, network denial,
      integrity/resource-limit checks, manifest permission mapping to curated
      mod API capabilities, script invocation routing through
      `ExecuteModApiRequest`, and development hot reload requiring a
      hot-reloadable binding, development session, valid replacement hash, and
      advanced revision. Added automation assertions for Lua/WASI binding,
      unsupported runtime rejection, API permission enforcement, API-policy
      execution, and stale/accepted hot reload, plus
      `ModScriptingIntegration_V2_Contract.json`,
      `mod-scripting-integration.md`, CI/Horde gates, and focused
      `check-v2-mod-scripting-integration.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-scripting-integration.py`,
      `python3 V2/ue/Tools/check-v2-mod-api-surface.py`,
      `python3 V2/ue/Tools/check-v2-mod-sandboxing.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod scripting contract
      and Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-scripting-integration.py`
      verifies the spec registration and assertions.
- [x] **72.14.1.6** Implement mod asset loading (mods can add textures, meshes,
      sounds, levels that integrate with engine asset system). Extended
      `FV2ModManifestAssetEntry` with `LoadPhase` and `Tags`, added `Level` to
      the `.mayamod` asset type allowlist, and added `EV2ModAssetKind`,
      `EV2ModAssetLoadPhase`, `EV2ModAssetIssueType`,
      `FV2ModAssetLoadingPolicy`, `FV2ModAssetLoadRequest`, `FV2ModAssetMount`,
      `FV2ModAssetIssue`, and `FV2ModAssetLoadPlan`. Implemented default asset
      loading policy, manifest-to-request binding, sandbox-gated asset
      evaluation, `/V2/Mods/` mount validation, SHA-256 and size enforcement,
      deterministic registry/soft object path generation, level load-phase
      restrictions, combined load-plan construction, subsystem forwarding, and
      execution marking for engine asset system registration. Added automation
      assertions for texture, mesh, audio, and level load plans, accepted engine
      registry mounts, invalid mount rejection, level startup rejection, and
      missing sandbox rejection. Added `ModAssetLoading_V2_Contract.json`,
      `mod-asset-loading.md`, CI/Horde gates, and focused
      `check-v2-mod-asset-loading.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-asset-loading.py`,
      `python3 V2/ue/Tools/check-v2-mod-file-format.py`,
      `python3 V2/ue/Tools/check-v2-mod-scripting-integration.py`,
      `python3 V2/ue/Tools/check-v2-mod-api-surface.py`,
      `python3 V2/ue/Tools/check-v2-mod-sandboxing.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod asset loading
      contract, file-format contract/schema, and Horde job, Prettier, and
      `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-asset-loading.py` verifies
      the spec registration and assertions.
- [x] **72.14.1.7** Create mod dependency resolution (mod A requires mod B
      version >=2.0, detect conflicts, provide resolution UI). Added
      `EV2ModDependencyConflictType`, `EV2ModDependencyResolutionSeverity`,
      `EV2ModDependencyResolutionActionType`,
      `FV2ModDependencyResolutionPolicy`, `FV2ModDependencyConflict`,
      `FV2ModDependencyResolutionAction`, `FV2ModDependencyResolutionUiRow`,
      `FV2ModDependencyResolutionViewModel`, and
      `FV2ModDependencyResolutionResult` to `V2Modding`. Implemented simple
      semantic version parsing/range checks for manifest ranges such as
      `>=2.0.0 <3.0.0`, required/optional dependency detection, duplicate mod id
      conflicts, load-cycle conflict surfacing, recommended install/upgrade,
      disable, remove-duplicate, review-cycle, and apply actions, a cardless
      operational resolution UI view model targeting
      `/Script/V2UI.V2ModDependencyResolutionScreen`, native
      `UV2ModDependencyResolutionScreen` configuration/selection support in
      `V2UI`, subsystem forwarding, and apply gating for clean
      dependency-ordered load plans. Added automation assertions for unsatisfied
      version ranges, missing required dependencies, optional dependency
      warnings, duplicate package removal actions, blocking UI rows, native
      screen configuration, and clean plan application. Added
      `ModDependencyResolution_V2_Contract.json`,
      `mod-dependency-resolution.md`, CI/Horde gates, and focused
      `check-v2-mod-dependency-resolution.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-dependency-resolution.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod dependency contract
      and Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-dependency-resolution.py`
      verifies the spec registration and assertions.
- [x] **72.14.1.8** Implement mod load order management (user-configurable load
      order, drag-and-drop reordering, save/load order presets). Added
      `EV2ModLoadOrderIssueType`, `EV2ModLoadOrderMoveMode`,
      `FV2ModLoadOrderPolicy`, `FV2ModLoadOrderEntry`, `FV2ModLoadOrderIssue`,
      `FV2ModLoadOrderPreset`, `FV2ModLoadOrderMoveRequest`,
      `FV2ModLoadOrderViewModel`, and `FV2ModLoadOrderResult` to `V2Modding`.
      Implemented dependency-aware user order evaluation with unknown/duplicate
      mod detection, required dependency order blocking, dependency-locked rows,
      drag-and-drop before/after/index movement with immediate re-evaluation,
      load order preset build/apply helpers, subsystem forwarding, and a
      cardless operational management view model targeting
      `/Script/V2UI.V2ModLoadOrderScreen`. Added native `UV2ModLoadOrderScreen`
      configuration/selection support in `V2UI` plus automation assertions for
      dependency-safe orders, dependency-locked rows, unknown/duplicate
      requested mod blocking, dependency-neutral drag moves, invalid
      dependency-violating moves, preset save/apply behavior, and native screen
      configuration. Added `ModLoadOrderManagement_V2_Contract.json`,
      `mod-load-order-management.md`, CI/Horde gates, and focused
      `check-v2-mod-load-order-management.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-load-order-management.py`,
      `python3 V2/ue/Tools/check-v2-mod-dependency-resolution.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod load order contract
      and Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-load-order-management.py`
      verifies the spec registration and assertions.
- [x] **72.14.1.9** Create mod hot-reload for development (modder changes script
      or asset, mod reloads without restarting game). Added
      `EV2ModHotReloadChangeType`, `EV2ModHotReloadIssueType`,
      `FV2ModHotReloadPolicy`, `FV2ModHotReloadChange`, `FV2ModHotReloadIssue`,
      and `FV2ModHotReloadPlan` to `V2Modding`. Implemented development-session
      gated hot reload for changed scripts and changed assets, with sandbox
      approval requirements, per-change revision advancement, script reload
      validation through `EvaluateModScriptHotReload`, asset reload validation
      through `EvaluateModAssetLoadRequest`, accepted plan execution that marks
      reloaded asset mounts as mounted/registered, and
      `bRequiresGameRestart == false` for accepted reloads. Added helper
      builders for script and asset reload changes, subsystem forwarding via
      `EvaluateDevelopmentHotReload`, automation assertions for mixed
      script/asset reloads, no-restart execution, non-development rejection,
      stale asset revision rejection, and unsafe asset reload rejection. Added
      `ModHotReload_V2_Contract.json`, `mod-hot-reload.md`, CI/Horde gates, and
      focused `check-v2-mod-hot-reload.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-hot-reload.py`,
      `python3 V2/ue/Tools/check-v2-mod-scripting-integration.py`,
      `python3 V2/ue/Tools/check-v2-mod-asset-loading.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod hot reload contract
      and Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-hot-reload.py` verifies the
      spec registration and assertions.
- [x] **72.14.1.10** Implement mod compatibility across game versions (mod
      specifies compatible game versions, warn on mismatch, migration helpers).
      Added `EV2ModCompatibilityIssueType`, `EV2ModMigrationActionType`,
      `FV2ModCompatibilityPolicy`, `FV2ModMigrationStep`,
      `FV2ModCompatibilityIssue`, and `FV2ModCompatibilityResult` to
      `V2Modding`. Implemented current game version evaluation against manifest
      `GameVersionRange` using the existing semantic range parser, default
      warning behavior for out-of-range mods, strict blocking policy support,
      explicit migration helper matching, migration application state, and
      subsystem forwarding via `EvaluateGameVersionCompatibility`. Added
      automation assertions for compatible manifests, mismatch warnings with
      migration helpers, migration application, and strict incompatible-mod
      blocking when no helper is available. Added
      `ModCompatibility_V2_Contract.json`, `mod-compatibility.md`, CI/Horde
      gates, and focused `check-v2-mod-compatibility.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-compatibility.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-mod-hot-reload.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod compatibility
      contract and Horde job, Prettier, and `git diff --check`. Local Unreal
      automation execution for `V2.Modding.LoadingSystem` remains unavailable
      because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-compatibility.py` verifies
      the spec registration and assertions.
- [x] **72.14.1.11** Create mod performance profiling (per-mod CPU/memory usage
      tracking, identify poorly performing mods). Added
      `EV2ModPerformanceIssueType`, `FV2ModPerformanceBudget`,
      `FV2ModPerformanceSample`, `FV2ModPerformanceIssue`,
      `FV2ModPerformanceProfile`, and `FV2ModPerformanceReport` to `V2Modding`.
      Implemented per-mod performance samples for CPU time, memory usage, script
      invocation count, asset streaming bytes, frame number, and timestamp;
      default profiling budgets; deterministic profile aggregation by mod id;
      average/peak CPU and memory tracking; invocation and streaming budget
      checks; insufficient sample-window reporting; poor performer
      identification through `PoorPerformerModIds`; and subsystem forwarding via
      `EvaluatePerformanceProfiles`. Added automation assertions for healthy and
      poor-performing mods, CPU/memory/invocation/streaming issue detection,
      poor performer id extraction, and insufficient sample windows that do not
      incorrectly flag poor performers. Added
      `ModPerformanceProfiling_V2_Contract.json`,
      `mod-performance-profiling.md`, CI/Horde gates, and focused
      `check-v2-mod-performance-profiling.py` coverage. Verification:
      `python3 V2/ue/Tools/check-v2-mod-performance-profiling.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-mod-compatibility.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod performance profiling
      contract and Horde job, Prettier, and `git diff --check`. Local Unreal
      automation execution for `V2.Modding.LoadingSystem` remains unavailable
      because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-performance-profiling.py`
      verifies the spec registration and assertions.
- [x] **72.14.1.12** Implement mod error isolation (one mod crashing doesn't
      take down the game — catch panics, disable broken mod, notify player).
      Added `EV2ModErrorIsolationIssueType`, `EV2ModErrorIsolationActionType`,
      `FV2ModErrorIsolationPolicy`, `FV2ModRuntimeError`,
      `FV2ModErrorIsolationIssue`, `FV2ModErrorIsolationAction`, and
      `FV2ModErrorIsolationResult` to `V2Modding`. Implemented
      panic/crash/timeout capture, recoverable error budget enforcement,
      game-protected continuation, broken mod disablement, optional quarantine,
      concise player notification text, apply-time protection preservation, and
      subsystem forwarding through `EvaluateErrorIsolation`. Added automation
      assertions for catching panics and crashes without taking down the game,
      disable/quarantine/notify actions, apply behavior, recoverable errors
      below budget, and disabling mods that exceed the recoverable error budget.
      Added `ModErrorIsolation_V2_Contract.json`, `mod-error-isolation.md`,
      CI/Horde gates, and focused `check-v2-mod-error-isolation.py` coverage.
      Verification: `python3 V2/ue/Tools/check-v2-mod-error-isolation.py`,
      `python3 V2/ue/Tools/check-v2-mod-loading-system.py`,
      `python3 V2/ue/Tools/check-v2-mod-performance-profiling.py`,
      `python3 V2/ue/Tools/check-v2-ci-workflow.py`,
      `python3 V2/tools/validate-v2-docs.py`, Python bytecode validation for the
      touched checkers, JSON syntax validation for the mod error isolation
      contract and Horde job, Prettier, and `git diff --check`. Local Unreal
      automation execution for `V2.Modding.LoadingSystem` remains unavailable
      because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-error-isolation.py` verifies
      the spec registration and assertions.
- [x] **72.14.1.13** Create mod creation toolkit (project template, build
      script, local testing server, packaging tool). Added a default `.mayamod`
      project template at `V2/ue/Tools/modding/templates/basic-mayamod` with a
      starter manifest, Lua bootstrap, preview placeholder, and authoring
      folders. Added `create-v2-mayamod-project.py`, `build-v2-mayamod.py`,
      `package-v2-mayamod.py`, `serve-v2-mayamod.py`, and shared
      `mayamod_toolkit.py` helpers for scaffolding, manifest hash refresh,
      deterministic ZIP packaging, build output, and local `/healthz`,
      `/catalog.json`, and `/manifest.json` testing. Added
      `EV2ModCreationToolkitArtifactType`, `EV2ModCreationToolkitIssueType`,
      `FV2ModCreationToolkitArtifact`, `FV2ModCreationToolkitTemplate`,
      `FV2ModCreationToolkitRequest`, `FV2ModCreationToolkitIssue`, and
      `FV2ModCreationToolkitPlan` to `V2Modding`, plus blueprint/subsystem
      helpers for default toolkit artifacts, request creation, plan validation,
      command generation, and local testing URLs. Automation asserts the
      complete toolkit surface and blocks builds when the deterministic
      packaging tool is missing. Added `ModCreationToolkit_V2_Contract.json`,
      `mod-creation-toolkit.md`, CI/Horde gates, and focused
      `check-v2-mod-creation-toolkit.py` coverage that scaffolds a temporary
      mod, builds/packages it, verifies deterministic package bytes, inspects
      archive contents, and self-tests the local server. Verification covered
      `check-v2-mod-creation-toolkit.py`, `check-v2-mod-loading-system.py`,
      `check-v2-mod-error-isolation.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the touched
      toolkit/checker scripts, JSON syntax validation for the toolkit contract,
      template manifest, and Horde job, Prettier, and `git diff --check`. Local
      Unreal automation execution for `V2.Modding.LoadingSystem` remains
      unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-creation-toolkit.py` verifies
      the spec registration and assertions.
- [x] **72.14.1.14** Implement mod documentation generator (auto-generate API
      docs from mod API surface with examples). Added
      `generate-v2-mod-api-docs.py`, which reads
      `ModApiSurface_V2_Contract.json` plus the `BuildDefaultModApiCatalog`
      source descriptors and writes deterministic generated API reference docs
      at `V2/docs/modding/generated/mod-api-reference.md`. The generated
      reference covers every curated mod API capability, enum mapping, source
      description, cosmetic mutation flag, policy allowlists, safety notes, and
      Lua examples. Added `EV2ModDocumentationGeneratorIssueType`,
      `FV2ModDocumentationGeneratorPolicy`, `FV2ModApiDocumentationExample`,
      `FV2ModDocumentationGeneratorIssue`, and
      `FV2ModDocumentationGeneratorResult` to `V2Modding`, plus
      blueprint/subsystem helpers for generator policy, example registration,
      generated path lookup, and API documentation plan validation. Automation
      asserts generated API docs with examples/policy notes and blocks
      generation when examples are missing. Added
      `ModDocumentationGenerator_V2_Contract.json`,
      `mod-documentation-generator.md`, CI/Horde gates, and focused
      `check-v2-mod-documentation-generator.py` coverage that validates the
      committed generated reference and runs the generator in `--check` mode.
      Verification covered `check-v2-mod-documentation-generator.py`,
      `generate-v2-mod-api-docs.py --check`, `check-v2-mod-api-surface.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the touched
      generator/checker scripts, JSON syntax validation for the documentation
      generator contract and Horde job, Prettier, and `git diff --check`. Local
      Unreal automation execution for `V2.Modding.LoadingSystem` remains
      unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-documentation-generator.py`
      verifies the spec registration and assertions.
- [x] **72.14.1.15** Create mod development tutorials and example mods. Added
      the tutorial learning path under `V2/docs/modding/tutorials/` covering
      getting started, public event scripting, safe UI overlays, and
      deterministic packaging/local testing. Added `HelloWorld.mayamod`,
      `PublicEventLogger.mayamod`, and `ModPanelOverlay.mayamod` example mod
      directories with manifests, Lua scripts, and preview thumbnails that
      demonstrate `ReadPublicGameState`, `RegisterEventListener`,
      `ReadModStorage`, `WriteModStorage`, `CreateUIScreen`, and
      `ModifyCosmeticComponent` while keeping network access denied. Added
      `EV2ModDevelopmentTutorialTrack`, `FV2ModDevelopmentTutorialLesson`,
      `FV2ModExampleModDescriptor`, `FV2ModDevelopmentTutorialCatalog`, and
      `FV2ModDevelopmentTutorialValidationResult` to `V2Modding`, plus
      blueprint/subsystem helpers for building and validating the default
      tutorial catalog. Automation asserts catalog coverage for project
      creation, scripting, UI, packaging, and local testing, and reports
      tutorials pointing at missing example mods. Added
      `ModDevelopmentTutorials_V2_Contract.json`,
      `mod-development-tutorials.md`, CI/Horde gates, and focused
      `check-v2-mod-development-tutorials.py` coverage for docs, manifests,
      scripts, previews, runtime catalog snippets, and TODO evidence.
      Verification covered `check-v2-mod-development-tutorials.py`,
      `check-v2-mod-documentation-generator.py`,
      `check-v2-mod-creation-toolkit.py`, `check-v2-mod-loading-system.py`,
      `check-v2-ci-workflow.py`, `validate-v2-docs.py`, Python bytecode
      validation for the touched checker, JSON syntax validation for the
      tutorial contract, example manifests, and Horde job, Prettier, and
      `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-development-tutorials.py`
      verifies the spec registration and assertions.

#### 72.14.2 Mod Distribution & Review

- [x] **72.14.2.1** Implement Steam Workshop integration (upload, download,
      subscribe, update, rate mods via Steam API). Added the Steam Workshop
      distribution surface to `V2Modding` with
      `EV2ModSteamWorkshopOperationType`, `EV2ModSteamWorkshopVisibility`,
      `EV2ModSteamWorkshopIssueType`, `FV2ModSteamWorkshopPolicy`,
      `FV2ModSteamWorkshopRequest`, `FV2ModSteamWorkshopOperation`,
      `FV2ModSteamWorkshopResult`, and `FV2ModSteamWorkshopItemState`. The
      Blueprint library now builds upload, download, subscribe, update, and rate
      requests; validates the `ISteamUGC`/`V2SteamWorkshopBridge` policy; maps
      each request to concrete Steam API calls such as `CreateItem`,
      `SubmitItemUpdate`, `DownloadItem`, `SubscribeItem`, and
      `SetUserItemVote`; and projects successful callbacks into local
      subscription, install, update, and rating state. Automation asserts full
      operation coverage, API call mapping, state projection, and blockers for
      updates without changelogs and ratings without subscription state. Added
      `SteamWorkshopIntegration_V2_Contract.json`,
      `steam-workshop-integration.md`, CI/Horde gates, and focused
      `check-v2-steam-workshop-integration.py` coverage for runtime snippets,
      documentation, automation assertions, release wiring, and TODO evidence.
      Verification covered `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-development-tutorials.py`, `check-v2-mod-loading-system.py`,
      `check-v2-ci-workflow.py`, `validate-v2-docs.py`, Python bytecode
      validation for the new checker, JSON syntax validation for the Steam
      Workshop contract and Horde job, and `git diff --check`. Local Unreal
      automation execution for `V2.Modding.LoadingSystem` remains unavailable
      because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-steam-workshop-integration.py`
      verifies the spec registration and assertions.
- [x] **72.14.2.2** Create mod.io integration (cross-platform mod distribution
      for non-Steam platforms). Added the mod.io distribution surface to
      `V2Modding` with `EV2ModIoOperationType`, `EV2ModIoPortal`,
      `EV2ModIoIssueType`, `FV2ModIoPolicy`, `FV2ModIoRequest`,
      `FV2ModIoRestCall`, `FV2ModIoOperation`, `FV2ModIoResult`, and
      `FV2ModIoItemState`. The Blueprint library now builds create, upload,
      download, subscribe, update, and rate requests; validates configured game
      id, API key, OAuth write access, mod.io terms disclosure, direct upload
      limits, and explicit non-Steam platform targets; maps requests to mod.io
      REST endpoints under `https://api.mod.io/v1`; and projects successful
      callbacks into local subscription, install, rating, and platform approval
      state. Automation asserts full REST endpoint coverage for mod creation,
      modfile upload, modfile download, subscription, metadata/file updates,
      ratings, and cross-platform targets, plus blockers for missing non-Steam
      targets and oversized direct uploads. Added
      `ModIoIntegration_V2_Contract.json`, `modio-integration.md`, CI/Horde
      gates, and focused `check-v2-modio-integration.py` coverage for runtime
      snippets, docs, automation assertions, release wiring, and TODO evidence.
      Verification covered `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the mod.io contract and Horde job, and
      `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-modio-integration.py` verifies
      the spec registration and assertions.
- [x] **72.14.2.3** Implement in-game mod browser (search, filter, sort,
      preview, install, update mods without leaving game). Added the in-game mod
      browser model to `V2Modding` with `EV2ModBrowserProvider`,
      `EV2ModBrowserSortMode`, `EV2ModBrowserInstallState`,
      `EV2ModBrowserActionType`, `FV2ModBrowserFilter`, `FV2ModBrowserEntry`,
      `FV2ModBrowserAction`, `FV2ModBrowserPreview`, and
      `FV2ModBrowserViewModel`. The Blueprint library now builds
      searchable/filterable/sortable browser rows, applies
      provider/category/tag/installed/update/compatibility filters, sorts by
      relevance, name, downloads, rating, and last updated, builds preview
      panes, and emits primary install/update actions without leaving the game.
      Added native `UV2ModBrowserScreen` in `V2UI` for configuring from the view
      model, applying filters, selecting rows, exposing preview/actions, and
      reporting cardless operational layout plus keyboard/gamepad support.
      Automation asserts search, filter, sort, preview, install, and update
      paths, preview media, install/update actions, update counts, and native
      screen selection/filter behavior. Added `ModBrowser_V2_Contract.json`,
      `mod-browser.md`, CI/Horde gates, and focused `check-v2-mod-browser.py`
      coverage for runtime snippets, native UI source, docs, automation
      assertions, release wiring, and TODO evidence. Verification covered
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the browser contract and Horde job, Prettier,
      and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-browser.py` verifies the spec
      registration and assertions.
- [x] **72.14.2.4** Create mod auto-update system (check for mod updates on game
      launch, download, and apply without user intervention). Added launch-time
      mod auto-update planning in `V2Modding` with `EV2ModAutoUpdateSource`,
      `EV2ModAutoUpdateOperationType`, `EV2ModAutoUpdateIssueType`,
      `FV2ModAutoUpdatePolicy`, `FV2ModAutoUpdateCandidate`,
      `FV2ModAutoUpdateIssue`, `FV2ModAutoUpdateOperation`, and
      `FV2ModAutoUpdatePlan`. The Blueprint library now builds default policy
      and provider-neutral candidates, compares semantic installed/remote
      versions, queues check/download/apply/refresh operations, stages downloads
      under `Saved/Mods/AutoUpdate`, applies valid plans without user
      intervention, and blocks disabled launch checks, metered networks,
      incompatible updates, oversized downloads, missing versions, and policies
      requiring confirmation. Automation asserts game launch checks, background
      download, silent apply, mod refresh, non-blocking already-current
      evidence, metered-network blocking, and incompatible update blocking
      before download. Added `ModAutoUpdate_V2_Contract.json`,
      `mod-auto-update.md`, CI/Horde gates, and focused
      `check-v2-mod-auto-update.py` coverage for runtime snippets, docs,
      automation assertions, release wiring, and TODO evidence. Verification
      covered `check-v2-mod-auto-update.py`, `check-v2-mod-browser.py`,
      `check-v2-modio-integration.py`, `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the auto-update contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-auto-update.py` verifies the
      spec registration and assertions.
- [x] **72.14.2.5** Implement mod review pipeline (submitted mods queued for
      automated scanning — malware, prohibited content, and performance impact).
      Added provider-neutral mod review planning in `V2Modding` with
      `EV2ModReviewProvider`, `EV2ModReviewStage`, `EV2ModReviewScanType`,
      `EV2ModReviewDecision`, `EV2ModReviewIssueType`, `FV2ModReviewPolicy`,
      `FV2ModReviewSubmission`, `FV2ModReviewScanJob`, `FV2ModReviewScanResult`,
      `FV2ModReviewIssue`, `FV2ModReviewCase`, and `FV2ModReviewPlan`. The
      Blueprint library now builds default review policy, submitted-mod records,
      and scan results, queues submitted mods for malware, prohibited-content,
      and performance-impact automated scans, blocks public release until clean
      approval, rejects detected malware before release, and escalates
      prohibited content or performance-budget failures to human review.
      Automation asserts submitted-mod queueing, malware scan jobs,
      prohibited-content scan jobs, performance-impact scan jobs, clean
      approval, malware rejection, human-review escalation, and public release
      gating. Added `ModReviewPipeline_V2_Contract.json`,
      `mod-review-pipeline.md`, CI/Horde gates, and focused
      `check-v2-mod-review-pipeline.py` coverage for runtime snippets, docs,
      automation assertions, release wiring, and TODO evidence. Verification
      covered `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the review contract and Horde job, Prettier,
      and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-review-pipeline.py` verifies
      the spec registration and assertions.
- [x] **72.14.2.6** Create mod content policy enforcement (automated scanning
      for prohibited textures, text, or scripts). Added automated mod content
      policy enforcement in `V2Modding` with `EV2ModContentPolicyAssetType`,
      `EV2ModContentPolicySeverity`, `EV2ModContentPolicyAction`,
      `EV2ModContentPolicyIssueType`, `FV2ModContentPolicy`,
      `FV2ModContentPolicyRule`, `FV2ModContentPolicyScanTarget`,
      `FV2ModContentPolicyFinding`, and `FV2ModContentPolicyReport`. The
      Blueprint library now builds default enforcement policy, default texture,
      text, and script rule catalogs, scan targets, and reports that match
      prohibited texture tags or paths, prohibited text patterns, blocked script
      APIs, and excessive script instruction budgets. Enforcement fails closed
      when mandatory scanners are disabled or hashes are missing, blocks release
      for prohibited content, quarantines blocked assets when enabled, and
      routes findings to human review. Automation asserts texture/text/script
      scanning, prohibited texture/text/script release blocking, quarantine
      action, script-budget human-review routing, and required-script-scanner
      disabled blocking. Added `ModContentPolicy_V2_Contract.json`,
      `mod-content-policy.md`, CI/Horde gates, and focused
      `check-v2-mod-content-policy.py` coverage for runtime snippets, docs,
      automation assertions, release wiring, and TODO evidence. Verification
      covered `check-v2-mod-content-policy.py`,
      `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the content-policy contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-content-policy.py` verifies
      the spec registration and assertions.
- [x] **72.14.2.7** Implement mod rating and review system (5-star ratings, text
      reviews, and helpfulness votes). Added provider-neutral mod rating and
      review aggregation in `V2Modding` with `EV2ModRatingReviewState`,
      `EV2ModHelpfulnessVoteType`, `EV2ModRatingIssueType`,
      `FV2ModRatingPolicy`, `FV2ModRatingReviewSubmission`,
      `FV2ModHelpfulnessVote`, `FV2ModRatingReviewEntry`, `FV2ModRatingIssue`,
      and `FV2ModRatingSummary`. The Blueprint library now builds default rating
      policy, 5-star text review submissions, helpfulness votes, and summaries
      that validate the 1-to-5 star range, require non-empty review text, queue
      text reviews for moderation, reject duplicate reviewer submissions, block
      author self reviews, and aggregate helpful/not helpful votes while
      rejecting self and duplicate helpfulness votes. Automation asserts
      five-star text reviews, pending moderation state, average star
      aggregation, helpfulness vote counts, invalid rating blocking, empty
      review blocking, author self-review blocking, duplicate reviewer blocking,
      and self/duplicate helpfulness vote handling. Added
      `ModRatingReview_V2_Contract.json`, `mod-rating-review.md`, CI/Horde
      gates, and focused `check-v2-mod-rating-review.py` coverage for runtime
      snippets, docs, automation assertions, release wiring, and TODO evidence.
      Verification covered `check-v2-mod-rating-review.py`,
      `check-v2-mod-content-policy.py`, `check-v2-mod-review-pipeline.py`,
      `check-v2-mod-auto-update.py`, `check-v2-mod-browser.py`,
      `check-v2-modio-integration.py`, `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the rating/review contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-rating-review.py` verifies
      the spec registration and assertions.
- [x] **72.14.2.8** Create mod collections/modpacks (curated sets of compatible
      mods installable as a group). Added curated mod collection and modpack
      install planning in `V2Modding` with `EV2ModCollectionVisibility`,
      `EV2ModCollectionInstallActionType`, `EV2ModCollectionIssueType`,
      `FV2ModCollectionPolicy`, `FV2ModCollectionMember`,
      `FV2ModCollectionDefinition`, `FV2ModCollectionIssue`,
      `FV2ModCollectionInstallAction`, and `FV2ModCollectionInstallPlan`. The
      Blueprint library now builds default collection policy, required and
      optional collection members, curated collection definitions, and group
      install plans that enforce curated status, group-install enablement,
      pinned versions, current-game compatibility, dependency inclusion,
      conflict detection, optional-member skips, and collection size limits.
      Automation asserts curated compatible modpacks install as a group,
      optional incompatible mods are skipped without blocking the modpack,
      required incompatible mods block group install, and missing dependencies
      plus conflicting mods block install. Added
      `ModCollections_V2_Contract.json`, `mod-collections.md`, CI/Horde gates,
      and focused `check-v2-mod-collections.py` coverage for runtime snippets,
      docs, automation assertions, release wiring, and TODO evidence.
      Verification covered `check-v2-mod-collections.py`,
      `check-v2-mod-rating-review.py`, `check-v2-mod-content-policy.py`,
      `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the collections contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-collections.py` verifies the
      spec registration and assertions.
- [x] **72.14.2.9** Implement mod download statistics and analytics (popular
      mods, trending, and new releases). Added provider-neutral mod download
      analytics in `V2Modding` with `EV2ModDownloadAnalyticsRankType`,
      `EV2ModDownloadAnalyticsIssueType`, `FV2ModDownloadAnalyticsPolicy`,
      `FV2ModDownloadAnalyticsSample`, `FV2ModDownloadAnalyticsRow`,
      `FV2ModDownloadAnalyticsIssue`, and `FV2ModDownloadAnalyticsSnapshot`. The
      Blueprint library now builds default analytics policy, download samples,
      and snapshots that rank popular mods by all-time downloads, trending mods
      by seven-day downloads plus growth delta, and new releases inside the
      configured launch window. Analytics filters disabled mods by default and
      blocks snapshots with missing mod ids, negative download counts, or
      missing release timestamps. Automation asserts popular, trending, and
      new-release ranking, rank assignment, disabled-mod filtering, trending
      delta evidence, and invalid sample blockers. Added
      `ModDownloadAnalytics_V2_Contract.json`, `mod-download-analytics.md`,
      CI/Horde gates, and focused `check-v2-mod-download-analytics.py` coverage
      for runtime snippets, docs, automation assertions, release wiring, and
      TODO evidence. Verification covered `check-v2-mod-download-analytics.py`,
      `check-v2-mod-collections.py`, `check-v2-mod-rating-review.py`,
      `check-v2-mod-content-policy.py`, `check-v2-mod-review-pipeline.py`,
      `check-v2-mod-auto-update.py`, `check-v2-mod-browser.py`,
      `check-v2-modio-integration.py`, `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the analytics contract and Horde job, Prettier,
      and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-download-analytics.py`
      verifies the spec registration and assertions.
- [x] **72.14.2.10** Create mod author dashboard (upload management, download
      stats, user feedback, and update publishing). Added native, cardless mod
      author dashboard support in `V2Modding` and `V2UI` with
      `EV2ModAuthorDashboardPanel`, `EV2ModAuthorDashboardActionType`,
      `EV2ModAuthorDashboardIssueType`, `FV2ModAuthorDashboardPolicy`,
      `FV2ModAuthorDashboardUpload`, `FV2ModAuthorDashboardFeedback`,
      `FV2ModAuthorDashboardUpdateDraft`, `FV2ModAuthorDashboardSummary`,
      `FV2ModAuthorDashboardIssue`, `FV2ModAuthorDashboardAction`,
      `FV2ModAuthorDashboardRow`, `FV2ModAuthorDashboardViewModel`, and
      `UV2ModAuthorDashboardScreen`. The Blueprint library now builds default
      dashboard policy, upload rows, feedback threads, update drafts, actions,
      and view models for `Mods.AuthorDashboard` with upload management,
      download stats, feedback review, update publishing, summary metrics,
      selected row state, keyboard/gamepad navigation, and cardless operational
      layout flags. Update publishing now blocks missing target versions,
      missing changelogs, and target versions that are not newer than the
      current upload. Automation asserts upload management, download stats, user
      feedback, update publishing actions, summary aggregation, global upload
      action, native screen configuration, primary actions, panel switching, row
      selection, and invalid update-draft blockers. Added
      `ModAuthorDashboard_V2_Contract.json`, `mod-author-dashboard.md`, CI/Horde
      gates, and focused `check-v2-mod-author-dashboard.py` coverage for runtime
      snippets, native UI snippets, docs, automation assertions, release wiring,
      and TODO evidence. Verification covered
      `check-v2-mod-author-dashboard.py`, `check-v2-mod-download-analytics.py`,
      `check-v2-mod-collections.py`, `check-v2-mod-rating-review.py`,
      `check-v2-mod-content-policy.py`, `check-v2-mod-review-pipeline.py`,
      `check-v2-mod-auto-update.py`, `check-v2-mod-browser.py`,
      `check-v2-modio-integration.py`, `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the author-dashboard contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-author-dashboard.py` verifies
      the spec registration and assertions. Playwright verification is not
      applicable because this dashboard is a native Unreal UI screen rather than
      a browser-rendered surface.
- [x] **72.14.2.11** Implement mod conflict detection (two mods modify same
      entity/asset — warn user, suggest resolution). Added provider-neutral mod
      conflict detection runtime support with `FV2ModConflictDetectionPolicy`,
      `FV2ModConflictMutation`, `FV2ModConflictReport`, conflict issues, and
      suggested resolution actions. `EvaluateModConflicts` now detects when two
      mods modify same entity or asset targets, blocks destructive or required
      conflicts, warns for optional same-target edits, validates missing targets
      before resolution, and suggests keep-first, keep-second, reorder, manual
      patch, and disable actions so flows can warn user and suggest resolution.
      Automation asserts destructive asset blockers, optional entity warnings,
      missing-target blockers, and resolution actions. Added
      `ModConflictDetection_V2_Contract.json`, `mod-conflict-detection.md`,
      CI/Horde gates, and focused `check-v2-mod-conflict-detection.py` coverage
      for runtime snippets, docs, automation assertions, release wiring, and
      TODO evidence. Verification covered `check-v2-mod-conflict-detection.py`,
      `check-v2-mod-author-dashboard.py`, `check-v2-mod-download-analytics.py`,
      `check-v2-mod-collections.py`, `check-v2-mod-rating-review.py`,
      `check-v2-mod-content-policy.py`, `check-v2-mod-review-pipeline.py`,
      `check-v2-mod-auto-update.py`, `check-v2-mod-browser.py`,
      `check-v2-modio-integration.py`, `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the conflict-detection contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-conflict-detection.py`
      verifies the spec registration and assertions.
- [x] **72.14.2.12** Create mod save game compatibility (detect if disabling mod
      would break save, warn before disable). Added mod save game compatibility
      runtime support with `FV2ModSaveGameCompatibilityPolicy`,
      `FV2ModSaveGameReference`, `FV2ModSaveGameCompatibilityReport`,
      compatibility issues, and disable actions.
      `EvaluateModSaveGameCompatibility` now detects if disabling mod would
      break save loading, blocks required save references that lack fallback or
      migration paths, warns before disable when migration or vanilla fallback
      can preserve the save, requires backup actions before risky disables, and
      validates disable mod ids plus save slots. Automation asserts
      save-breaking blockers, missing fallback or migration blockers, migration
      warnings, fallback warnings, backup actions, and invalid input blockers.
      Added `ModSaveGameCompatibility_V2_Contract.json`,
      `mod-save-game-compatibility.md`, CI/Horde gates, and focused
      `check-v2-mod-save-game-compatibility.py` coverage for runtime snippets,
      docs, automation assertions, release wiring, and TODO evidence.
      Verification covered `check-v2-mod-save-game-compatibility.py`,
      `check-v2-mod-conflict-detection.py`, `check-v2-mod-author-dashboard.py`,
      `check-v2-mod-download-analytics.py`, `check-v2-mod-collections.py`,
      `check-v2-mod-rating-review.py`, `check-v2-mod-content-policy.py`,
      `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the save-game compatibility contract and Horde
      job, Prettier, and `git diff --check`. Local Unreal automation execution
      for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-save-game-compatibility.py`
      verifies the spec registration and assertions.
- [x] **72.14.2.13** Implement mod multiplayer compatibility (host specifies
      required mods, clients auto-download on join). Added mod multiplayer
      compatibility runtime support with `FV2ModMultiplayerCompatibilityPolicy`,
      `FV2ModMultiplayerRequiredMod`, `FV2ModMultiplayerClientMod`,
      `FV2ModMultiplayerCompatibilityReport`, compatibility issues, and join
      actions. `EvaluateModMultiplayerCompatibility` now lets the host specify
      required mods, compares them with client installed/enabled versions, plans
      clients auto-download on join for missing provider-backed mods, plans
      auto-updates for mismatched versions, enables installed disabled required
      mods, and blocks join when session metadata is invalid or required mods
      cannot be auto-downloaded. Automation asserts ready joins, auto-download
      planning, version update planning, enablement planning, unavailable
      provider blockers, and invalid host session/required mod blockers. Added
      `ModMultiplayerCompatibility_V2_Contract.json`,
      `mod-multiplayer-compatibility.md`, CI/Horde gates, and focused
      `check-v2-mod-multiplayer-compatibility.py` coverage for runtime snippets,
      docs, automation assertions, release wiring, and TODO evidence.
      Verification covered `check-v2-mod-multiplayer-compatibility.py`,
      `check-v2-mod-save-game-compatibility.py`,
      `check-v2-mod-conflict-detection.py`, `check-v2-mod-author-dashboard.py`,
      `check-v2-mod-download-analytics.py`, `check-v2-mod-collections.py`,
      `check-v2-mod-rating-review.py`, `check-v2-mod-content-policy.py`,
      `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the multiplayer compatibility contract and
      Horde job, Prettier, and `git diff --check`. Local Unreal automation
      execution for `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-multiplayer-compatibility.py`
      verifies the spec registration and assertions.
- [x] **72.14.2.14** Create mod legal framework (EULA for modders, license
      terms, content ownership policy). Added V2 mod legal framework runtime
      support with `FV2ModLegalFrameworkPolicy`, `FV2ModLegalDocument`,
      `FV2ModLegalAcceptance`, `FV2ModLegalSubmissionDisclosure`,
      `FV2ModLegalFrameworkReport`, legal issues, and legal actions.
      `EvaluateModLegalFramework` now requires the EULA for modders, license
      terms, content ownership policy, modder acceptance, counsel approval,
      ownership disclosures, third-party attribution when third-party content is
      declared, and explicit commercial-use grants before distribution can pass.
      Added `ModLegalFramework_V2_Contract.json`, `mod-legal-framework.md`,
      CI/Horde gates, and focused `check-v2-mod-legal-framework.py` coverage for
      runtime snippets, docs, automation assertions, release wiring, and TODO
      evidence. Verification covered `check-v2-mod-legal-framework.py`,
      `check-v2-mod-multiplayer-compatibility.py`,
      `check-v2-mod-save-game-compatibility.py`,
      `check-v2-mod-conflict-detection.py`, `check-v2-mod-author-dashboard.py`,
      `check-v2-mod-download-analytics.py`, `check-v2-mod-collections.py`,
      `check-v2-mod-rating-review.py`, `check-v2-mod-content-policy.py`,
      `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the legal framework contract and Horde job,
      Prettier, and `git diff --check`. Local Unreal automation execution for
      `V2.Modding.LoadingSystem` remains unavailable because
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      is absent in this environment; `check-v2-mod-legal-framework.py` verifies
      the spec registration and assertions.
- [x] **72.14.2.15** Implement mod distribution documentation and publisher
      guide. Added `mod-distribution-publisher-guide.md` as the publisher-facing
      release path for V2 `.mayamod` distribution, tying together Steam
      Workshop, mod.io, the legal framework, review pipeline, content policy,
      auto-update, save-game compatibility, multiplayer compatibility, author
      dashboard, and download analytics documentation. Added
      `ModDistributionPublisherGuide_V2_Contract.json`, CI/Horde gates, and
      focused `check-v2-mod-distribution-publisher-guide.py` coverage for the
      documentation inventory, provider matrix, release checklist, legal/review
      references, rollback/takedown guidance, release wiring, and TODO evidence.
      Verification covered `check-v2-mod-distribution-publisher-guide.py`,
      `check-v2-mod-legal-framework.py`,
      `check-v2-mod-multiplayer-compatibility.py`,
      `check-v2-mod-save-game-compatibility.py`,
      `check-v2-mod-conflict-detection.py`, `check-v2-mod-author-dashboard.py`,
      `check-v2-mod-download-analytics.py`, `check-v2-mod-collections.py`,
      `check-v2-mod-rating-review.py`, `check-v2-mod-content-policy.py`,
      `check-v2-mod-review-pipeline.py`, `check-v2-mod-auto-update.py`,
      `check-v2-mod-browser.py`, `check-v2-modio-integration.py`,
      `check-v2-steam-workshop-integration.py`,
      `check-v2-mod-loading-system.py`, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the publisher guide contract and Horde job,
      Prettier, and `git diff --check`.

---

### 72.15 Cinematic Sequencer & Timeline Editor

UE5 Sequencer–class cinematic authoring: keyframe tracks, camera system, actor
binding, and gameplay blending.

#### 72.15.1 Sequencer Core

- [x] **72.15.1.1** Design sequencer data model (sequence contains tracks;
      tracks contain keyframes; tracks bind to entities/properties). Added
      `FV2SequencerSequenceSpec`, `FV2SequencerTrackSpec`,
      `FV2SequencerKeyframe`, `FV2SequencerBindingSpec`, issue/result structs,
      and sequencer data model enums to `V2Cinematics`, plus Blueprint builders
      and `ValidateSequencerDataModel` coverage for missing ids, invalid timing,
      missing/duplicate bindings and tracks, missing property paths, empty
      tracks, malformed keyframes, duplicate frame numbers, and unsorted
      keyframes. Added `V2.Cinematics.Sequencer.DataModel` automation,
      `SequencerDataModel_V2_Contract.json`, `sequencer-data-model.md`,
      `check-v2-sequencer-data-model.py`, CI/Horde wiring, and module-checker
      coverage. Verification covers `check-v2-sequencer-data-model.py`,
      `check-v2-cinematics-module.py`, adjacent cinematic checkers,
      `check-v2-ci-workflow.py`, `validate-v2-docs.py`, Python bytecode
      validation for the new checker, JSON syntax validation for the contract
      and Horde job, Prettier, and `git diff --check`.
- [x] **72.15.1.2** Implement timeline playback engine (play, pause, scrub,
      loop, reverse, variable speed). Added `FV2SequencerPlaybackSettings`,
      `FV2SequencerPlaybackCursor`, `FV2SequencerPlaybackEvaluation`, playback
      issue structs, playback status/direction/issue enums, and pure Blueprint
      helpers for play, pause, scrub, loop wrapping, reverse playback,
      variable-speed playback-rate changes, completion clamping, and tick
      evaluation. Added `V2.Cinematics.Sequencer.TimelinePlayback` automation,
      `SequencerTimelinePlayback_V2_Contract.json`,
      `sequencer-timeline-playback.md`,
      `check-v2-sequencer-timeline-playback.py`, CI/Horde wiring, and
      module-checker coverage. Verification covers
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.3** Create keyframe interpolation system (linear, cubic bezier,
      step, custom curves — per-property per-keyframe). Added
      `EV2SequencerInterpolationMode`, interpolation issue types,
      `FV2SequencerInterpolationSpec`, `FV2SequencerInterpolatedValue`, typed
      interpolation issues, and Blueprint helpers for default interpolation
      specs, per-keyframe/per-property spec resolution, and typed keyframe
      evaluation. The runtime now supports linear float/vector/rotator blending,
      cubic-bezier easing, step interpolation for discrete event values, custom
      curve ids, discrete step fallback, and validation for empty tracks,
      untyped values, mismatched source/target types, missing custom curves, and
      invalid cubic-bezier control points. Added
      `V2.Cinematics.Sequencer.KeyframeInterpolation` automation,
      `SequencerKeyframeInterpolation_V2_Contract.json`,
      `sequencer-keyframe-interpolation.md`,
      `check-v2-sequencer-keyframe-interpolation.py`, CI/Horde wiring, and
      module-checker coverage. Verification covers
      `check-v2-sequencer-keyframe-interpolation.py`,
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.4** Implement property tracks (animate any reflected property:
      transform, color, float, bool, enum). Added explicit color and enum
      keyframe payloads, `EV2SequencerPropertyValueType`,
      `FV2SequencerReflectedPropertySpec`,
      `FV2SequencerPropertyTrackEvaluation`, property-track issues, and
      Blueprint helpers for reflected property specs, property keyframes,
      default property-track fixtures, and `EvaluateSequencerPropertyTrack`. The
      runtime now evaluates reflected transform, color, float, bool, and enum
      properties through interpolation, validates reflected/writable/ animatable
      metadata, enforces enum type/value names, and reports missing reflection
      metadata, missing property paths, unsupported keyframe value types, empty
      tracks, and interpolation failures. Added
      `V2.Cinematics.Sequencer.PropertyTracks` automation,
      `SequencerPropertyTracks_V2_Contract.json`,
      `sequencer-property-tracks.md`, `check-v2-sequencer-property-tracks.py`,
      CI/Horde wiring, and module-checker coverage. Verification covers
      `check-v2-sequencer-property-tracks.py`,
      `check-v2-sequencer-keyframe-interpolation.py`,
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.5** Create animation clip tracks (trigger skeletal animations on
      timeline with blend in/out). Added `EV2SequencerAnimationClipIssueType`,
      `FV2SequencerAnimationClipSpec`, `FV2SequencerAnimationClipPlayback`,
      `FV2SequencerAnimationClipTrackEvaluation`, animation-clip validation, and
      Blueprint helpers for clip specs, skeletal animation track specs, a
      default Cassia skeletal animation fixture, and
      `EvaluateSequencerAnimationClipTrack`. The runtime now binds animation
      tracks to a skeletal mesh component id, references animation assets,
      triggers clips as the timeline crosses clip start frames, evaluates
      blend-in and blend-out weights, supports overlapping active clips, carries
      looping/root-motion flags, and reports non-animation tracks, missing clip
      ids, missing animation assets, invalid frame ranges, invalid blend frames,
      missing bindings, missing skeletal mesh components, and empty clip tracks.
      Added `V2.Cinematics.Sequencer.AnimationClipTracks` automation,
      `SequencerAnimationClipTracks_V2_Contract.json`,
      `sequencer-animation-clip-tracks.md`,
      `check-v2-sequencer-animation-clip-tracks.py`, CI/Horde wiring, and
      module-checker coverage. Verification covers
      `check-v2-sequencer-animation-clip-tracks.py`,
      `check-v2-sequencer-property-tracks.py`,
      `check-v2-sequencer-keyframe-interpolation.py`,
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.6** Implement audio tracks (trigger sound cues at timeline
      positions, volume/pitch automation). Added
      `EV2SequencerAudioTrackIssueType`, `FV2SequencerAudioCueSpec`,
      `FV2SequencerAudioCuePlayback`, `FV2SequencerAudioTrackEvaluation`, audio
      cue validation, and Blueprint helpers for audio automation keyframes,
      sound cue specs, audio track specs, a default Council Trial audio fixture,
      and `EvaluateSequencerAudioTrack`. The runtime now routes audio tracks
      through `AudioBusId`, references sound cue assets, triggers cues as the
      timeline crosses cue start frames, evaluates volume and pitch automation
      through the shared keyframe interpolation system, supports
      looping/spatialization flags, and reports non-audio tracks, missing cue
      ids, missing sound assets, invalid frame ranges, invalid volume
      automation, invalid pitch automation, missing bindings, missing audio
      buses, empty cue tracks, and automation evaluation failures. Added
      `V2.Cinematics.Sequencer.AudioTracks` automation,
      `SequencerAudioTracks_V2_Contract.json`, `sequencer-audio-tracks.md`,
      `check-v2-sequencer-audio-tracks.py`, CI/Horde wiring, and module-checker
      coverage. Verification covers `check-v2-sequencer-audio-tracks.py`,
      `check-v2-sequencer-animation-clip-tracks.py`,
      `check-v2-sequencer-property-tracks.py`,
      `check-v2-sequencer-keyframe-interpolation.py`,
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.7** Create event tracks (fire gameplay events at specific
      timestamps: trigger explosion, open door, start rain). Added
      `EV2SequencerEventTrackIssueType`, `FV2SequencerEventTriggerSpec`,
      `FV2SequencerEventInvocation`, `FV2SequencerEventTrackEvaluation`, event
      trigger validation, and Blueprint helpers for gameplay event trigger
      specs, event track specs, a default Council Trial stage-control fixture,
      and `EvaluateSequencerEventTrack`. The runtime now stores dedicated
      `EventTriggers`, fires events when the timeline lands on or crosses event
      frames, propagates gameplay event names and payload tag/text/float values,
      carries fire-once and authority flags, rejects duplicate event ids, and
      reports non-event tracks, missing event ids, missing gameplay event names,
      invalid timestamps, missing bindings, and empty event tracks. Added
      `V2.Cinematics.Sequencer.EventTracks` automation,
      `SequencerEventTracks_V2_Contract.json`, `sequencer-event-tracks.md`,
      `check-v2-sequencer-event-tracks.py`, CI/Horde wiring, and module-checker
      coverage. Verification covers `check-v2-sequencer-event-tracks.py`,
      `check-v2-sequencer-audio-tracks.py`,
      `check-v2-sequencer-animation-clip-tracks.py`,
      `check-v2-sequencer-property-tracks.py`,
      `check-v2-sequencer-keyframe-interpolation.py`,
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.8** Implement camera tracks (camera position/rotation/FOV
      keyframes, camera cuts between cameras, rail cameras). Added
      `EV2SequencerCameraTrackIssueType`, `FV2SequencerCameraKeyframeSpec`,
      `FV2SequencerCameraCutSpec`, `FV2SequencerRailCameraSpec`,
      `FV2SequencerCameraTrackEvaluation`, camera validation, and Blueprint
      helpers for camera keyframes, camera cuts, rail cameras, camera track
      specs, a default Council Trial hero camera fixture, and
      `EvaluateSequencerCameraTrack`. The runtime now stores dedicated
      `CameraKeyframes`, `CameraCuts`, and `CameraRails`, interpolates camera
      position/rotation/FOV, fires camera cuts when the timeline lands on or
      crosses cut frames, resolves active camera bindings, evaluates rail alpha
      and rail distance, and reports non-camera tracks, missing camera bindings,
      missing camera keyframes, invalid camera keyframes, duplicate camera
      keyframe frames, missing cut ids, missing target camera bindings, invalid
      cut frames, missing rail ids, and invalid rail ranges. Added
      `V2.Cinematics.Sequencer.CameraTracks` automation,
      `SequencerCameraTracks_V2_Contract.json`, `sequencer-camera-tracks.md`,
      `check-v2-sequencer-camera-tracks.py`, CI/Horde wiring, and module-checker
      coverage. Verification covers `check-v2-sequencer-camera-tracks.py`,
      `check-v2-sequencer-event-tracks.py`,
      `check-v2-sequencer-audio-tracks.py`,
      `check-v2-sequencer-animation-clip-tracks.py`,
      `check-v2-sequencer-property-tracks.py`,
      `check-v2-sequencer-keyframe-interpolation.py`,
      `check-v2-sequencer-timeline-playback.py`,
      `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
      adjacent cinematic checkers, `check-v2-ci-workflow.py`,
      `validate-v2-docs.py`, Python bytecode validation for the new checker,
      JSON syntax validation for the contract and Horde job, Prettier, and
      `git diff --check`.
- [x] **72.15.1.9** Create actor binding system (bind sequencer tracks to
      entities in scene, rebindable for reuse)
  - Implemented reusable sequencer actor binding overrides with
    `FV2SequencerBindingOverrideSpec`, `FV2SequencerResolvedBinding`,
    `FV2SequencerActorBindingEvaluation`, default Cassia/player-two and
    hero-camera/replay-camera overrides, validation for missing/duplicate
    overrides, invalid targets, non-rebindable bindings/tracks, and missing
    track bindings.
  - Added `V2.Cinematics.Sequencer.ActorBindings` automation coverage,
    `SequencerActorBindings_V2_Contract.json`, `sequencer-actor-bindings.md`,
    `check-v2-sequencer-actor-bindings.py`, CI/Horde wiring, and module-checker
    coverage. Verification covers `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.
- [x] **72.15.1.10** Implement sub-sequence composition (nest sequences within
      sequences, parameterized sub-sequences)
  - Implemented nested sequencer sub-sequence composition with
    `FV2SequencerSubSequenceSpec`, `FV2SequencerSubSequenceParameterSpec`,
    `FV2SequencerResolvedSubSequence`, `FV2SequencerSubSequenceEvaluation`,
    parent-to-child frame mapping, half-rate replay retiming, inherited binding
    overrides, parameterized child instances, and recursive-cycle validation.
  - Added `V2.Cinematics.Sequencer.SubSequenceComposition` automation coverage,
    `SequencerSubSequenceComposition_V2_Contract.json`,
    `sequencer-sub-sequence-composition.md`,
    `check-v2-sequencer-sub-sequence-composition.py`, CI/Horde wiring, and
    module-checker coverage. Verification covers
    `check-v2-sequencer-sub-sequence-composition.py`,
    `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.
- [x] **72.15.1.11** Create sequence blending with gameplay (fade from gameplay
      camera to cinematic camera and back, maintain player control state)
  - Implemented gameplay/cinematic camera blending with
    `FV2SequencerGameplayBlendSpec`, `FV2SequencerGameplayControlStateSpec`,
    `FV2SequencerGameplayBlendEvaluation`, blend-in and blend-out alpha
    evaluation, gameplay camera restore, explicit player/camera/movement input
    windows, and validation for blend and control-state authoring errors.
  - Added `V2.Cinematics.Sequencer.GameplayBlend` automation coverage,
    `SequencerGameplayBlend_V2_Contract.json`, `sequencer-gameplay-blend.md`,
    `check-v2-sequencer-gameplay-blend.py`, CI/Horde wiring, and module-checker
    coverage. Verification covers `check-v2-sequencer-gameplay-blend.py`,
    `check-v2-sequencer-sub-sequence-composition.py`,
    `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.
- [x] **72.15.1.12** Implement sequence save/load serialization
  - Implemented deterministic sequencer sequence snapshots with
    `FV2SequencerSequenceSnapshotSpec`, `FV2SequencerSerializationResult`,
    embedded sequence data, schema version validation, storage path validation,
    stable payload checksums, and save/load helpers that restore validated
    sequence data.
  - Added `V2.Cinematics.Sequencer.Serialization` automation coverage,
    `SequencerSerialization_V2_Contract.json`, `sequencer-serialization.md`,
    `check-v2-sequencer-serialization.py`, CI/Horde wiring, and module-checker
    coverage. Verification covers `check-v2-sequencer-serialization.py`,
    `check-v2-sequencer-gameplay-blend.py`,
    `check-v2-sequencer-sub-sequence-composition.py`,
    `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.
- [x] **72.15.1.13** Create sequence LOD (skip cinematic in gameplay if
      configured, play abbreviated version on repeat viewing)
  - Implemented sequencer LOD profile/request/evaluation support with
    `FV2SequencerLODProfileSpec`, `FV2SequencerLODRequest`,
    `FV2SequencerLODEvaluation`, active-gameplay skip decisions, repeat-view
    abbreviated sequence selection, critical-story full playback protection, and
    validation for profile authoring errors.
  - Added `V2.Cinematics.Sequencer.LOD` automation coverage,
    `SequencerLOD_V2_Contract.json`, `sequencer-lod.md`,
    `check-v2-sequencer-lod.py`, CI/Horde wiring, and module-checker coverage.
    Verification covers `check-v2-sequencer-lod.py`,
    `check-v2-sequencer-serialization.py`,
    `check-v2-sequencer-gameplay-blend.py`,
    `check-v2-sequencer-sub-sequence-composition.py`,
    `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.
- [x] **72.15.1.14** Implement sequence triggers (enter area → play sequence,
      interact with object → play sequence)
  - Implemented sequencer sequence trigger specs, requests, and evaluation with
    `FV2SequencerSequenceTriggerSpec`, `FV2SequencerSequenceTriggerRequest`,
    `FV2SequencerSequenceTriggerEvaluation`, area-enter triggers,
    object-interaction triggers, gameplay-event triggers, required tag matching,
    replay-safety rejection, consume-on-trigger flags, and priority selection.
  - Added `V2.Cinematics.Sequencer.Triggers` automation coverage,
    `SequencerTriggers_V2_Contract.json`, `sequencer-triggers.md`,
    `check-v2-sequencer-triggers.py`, CI/Horde wiring, and module-checker
    coverage. Verification covers `check-v2-sequencer-triggers.py`,
    `check-v2-sequencer-lod.py`, `check-v2-sequencer-serialization.py`,
    `check-v2-sequencer-gameplay-blend.py`,
    `check-v2-sequencer-sub-sequence-composition.py`,
    `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.
- [x] **72.15.1.15** Create sequence networking (synchronize cinematic playback
      across multiplayer clients)
  - Implemented authoritative sequencer networking state and client sync
    evaluation with `FV2SequencerNetworkAuthorityState`,
    `FV2SequencerNetworkClientState`, `FV2SequencerNetworkSyncSettings`,
    `FV2SequencerNetworkSyncEvaluation`, latency-capped frame prediction,
    start/maintain/blend/snap/pause/stop actions, looped playback wrapping, and
    validation for session, sequence, revision, time, latency, and stale
    authority-state failures.
  - Added `V2.Cinematics.Sequencer.Networking` automation coverage,
    `SequencerNetworking_V2_Contract.json`, `sequencer-networking.md`,
    `check-v2-sequencer-networking.py`, CI/Horde wiring, and module-checker
    coverage. Verification covers `check-v2-sequencer-networking.py`,
    `check-v2-sequencer-triggers.py`, `check-v2-sequencer-lod.py`,
    `check-v2-sequencer-serialization.py`,
    `check-v2-sequencer-gameplay-blend.py`,
    `check-v2-sequencer-sub-sequence-composition.py`,
    `check-v2-sequencer-actor-bindings.py`,
    `check-v2-sequencer-camera-tracks.py`, `check-v2-sequencer-event-tracks.py`,
    `check-v2-sequencer-audio-tracks.py`,
    `check-v2-sequencer-animation-clip-tracks.py`,
    `check-v2-sequencer-property-tracks.py`,
    `check-v2-sequencer-keyframe-interpolation.py`,
    `check-v2-sequencer-timeline-playback.py`,
    `check-v2-sequencer-data-model.py`, `check-v2-cinematics-module.py`,
    adjacent cinematic checkers, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`.

#### 72.15.2 Sequencer Editor UI

- [x] **72.15.2.1** Implement timeline editor UI (horizontal timeline with
      playhead, zoom, scroll, track headers)
  - Implemented the V2Editor TimelineVisualizer data surface with
    `FV2SequencerTimelineEditorWidgetSpec`,
    `FV2SequencerTimelineEditorViewportSpec`,
    `FV2SequencerTimelineTrackHeaderSpec`, `FV2SequencerTimelineTrackRowModel`,
    and `FV2SequencerTimelineEditorModel`. The model computes horizontal
    timeline windows, playhead X coordinates, zoomed frame spacing, scroll
    offsets, track headers, row positions, visible keyframes, and validation
    issues from `FV2SequencerSequenceSpec`.
  - Added `V2.Editor.Sequencer.TimelineEditor` automation coverage,
    `SequencerTimelineEditor_V2_Contract.json`, `sequencer-timeline-editor.md`,
    `check-v2-sequencer-timeline-editor.py`, CI/Horde wiring, and editor-module
    checker coverage. Verification covers
    `check-v2-sequencer-timeline-editor.py`, `check-v2-editor-module.py`,
    `check-v2-cinematics-module.py`, `check-v2-sequencer-data-model.py`,
    `check-v2-sequencer-timeline-playback.py`, `check-v2-ci-workflow.py`,
    `validate-v2-docs.py`, Python bytecode validation for the new checker, JSON
    syntax validation for the contract and Horde job, Prettier, and
    `git diff --check`. `js_repl` Playwright was unavailable and this is an
    Unreal editor model surface, so browser Playwright coverage is not
    applicable.
- [x] **72.15.2.2** Create track management (add/remove/reorder tracks,
      expand/collapse groups, mute/solo tracks)
  - Implemented the V2Editor TimelineVisualizer track-management surface with
    `FV2SequencerTrackManagementPanelSpec`,
    `FV2SequencerTrackManagementRequest`, `FV2SequencerManagedTrackRow`,
    `FV2SequencerTrackManagementIssue`, and `FV2SequencerTrackManagementResult`.
    The request model applies add, remove, reorder, expand/collapse, mute, and
    solo operations to `FV2SequencerSequenceSpec`, returns an updated sequence,
    and keeps editor-only expanded and solo state for deterministic row
    rendering.
  - Added `V2.Editor.Sequencer.TrackManagement` automation coverage,
    `SequencerTrackManagement_V2_Contract.json`,
    `sequencer-track-management.md`, `check-v2-sequencer-track-management.py`,
    CI/Horde wiring, and editor-module checker coverage. Verification covers
    add/remove paths, duplicate/missing ids, locked-track removal rejection,
    reorder and invalid index handling, collapsed group ids, muted rows,
    solo-muted rows, and missing target tracks. `js_repl` Playwright was
    unavailable and this is an Unreal editor model surface, so browser
    Playwright coverage is not applicable.
- [x] **72.15.2.3** Implement keyframe editing (add/delete/move keyframes,
      multi-select, copy/paste, curve editor)
  - Implemented the V2Editor TimelineVisualizer keyframe-editing surface with
    `FV2SequencerKeyframeEditPanelSpec`, `FV2SequencerKeyframeEditRequest`,
    `FV2SequencerEditableKeyframe`, `FV2SequencerKeyframeEditIssue`, and
    `FV2SequencerKeyframeEditResult`. The request model applies add, delete,
    move, multi-select, copy, paste, and curve interpolation operations to
    `FV2SequencerTrackSpec::Keyframes`, returns an updated sequence, and keeps
    editor-only selected keyframe, clipboard, and curve-handle state for
    deterministic timeline rendering.
  - Added `V2.Editor.Sequencer.KeyframeEditing` automation coverage,
    `SequencerKeyframeEditing_V2_Contract.json`,
    `sequencer-keyframe-editing.md`, `check-v2-sequencer-keyframe-editing.py`,
    CI/Horde wiring, and editor-module checker coverage. Verification covers
    add/delete/move, duplicate ids, invalid move frames, multi-select,
    copy/paste, selected pasted rows, custom curve interpolation handles,
    invalid clipboard paste, and missing tracks. `js_repl` Playwright was
    unavailable and this is an Unreal editor model surface, so browser
    Playwright coverage is not applicable.
- [x] **72.15.2.4** Create curve editor (visualize and edit interpolation
      curves, tangent handles, preset curves)
  - Implemented the V2Editor TimelineVisualizer curve-editor surface with
    `FV2SequencerCurveEditorPanelSpec`, `FV2SequencerCurveEditorViewportSpec`,
    `FV2SequencerCurvePoint`, `FV2SequencerCurveHandleSpec`,
    `FV2SequencerCurvePresetSpec`, `FV2SequencerCurveEditorIssue`, and
    `FV2SequencerCurveEditorModel`. The model samples
    `EvaluateSequencerKeyframeInterpolation` into graph points, maps values to
    viewport coordinates, exposes tangent handle positions, and provides linear,
    step, cubic ease-in-out, and custom camera-ease preset curves.
  - Added `V2.Editor.Sequencer.CurveEditor` automation coverage,
    `SequencerCurveEditor_V2_Contract.json`, `sequencer-curve-editor.md`,
    `check-v2-sequencer-curve-editor.py`, CI/Horde wiring, and editor-module
    checker coverage. Verification covers curve visualization, sampled points,
    midpoint values, tangent handles, preset lookup, invalid sample counts,
    missing tracks, missing keyframes, and unsupported event/name curves.
    `js_repl` Playwright was unavailable and this is an Unreal editor model
    surface, so browser Playwright coverage is not applicable.
- [x] **72.15.2.5** Implement real-time preview in viewport (see cinematic play
      in 3D viewport while editing timeline)
  - Implemented the V2Editor TimelineVisualizer viewport-preview surface with
    `FV2SequencerViewportPreviewPanelSpec`,
    `FV2SequencerViewportPreviewRequest`,
    `FV2SequencerViewportPreviewCameraState`,
    `FV2SequencerViewportPreviewTrackState`,
    `FV2SequencerViewportPreviewAudioCueState`,
    `FV2SequencerViewportPreviewEventState`, `FV2SequencerViewportPreviewIssue`,
    and `FV2SequencerViewportPreviewModel`. The model evaluates the current
    timeline frame into active camera/FOV state, keyframed object and property
    state, audio cue overlays, crossed event markers, playback timing, and
    validation issues for 3D viewport preview while playing or scrubbing.
  - Added `V2.Editor.Sequencer.ViewportPreview` automation coverage,
    `SequencerViewportPreview_V2_Contract.json`,
    `sequencer-viewport-preview.md`, `check-v2-sequencer-viewport-preview.py`,
    CI/Horde wiring, and editor-module checker coverage. Verification covers
    timeline sync, active camera binding and FOV, transform interpolation, audio
    cue overlays, event marker overlays, invalid frames, invalid playback rates,
    and missing camera tracks. `js_repl` Playwright was unavailable and this is
    an Unreal editor model surface, so browser Playwright coverage is not
    applicable.
- [x] **72.15.2.6** Create camera preview window (picture-in-picture showing
      cinematic camera output while editing)
  - Implemented the V2Editor TimelineVisualizer camera preview window with
    `FV2SequencerCameraPreviewWindowPanelSpec`,
    `FV2SequencerCameraPreviewWindowRequest`,
    `FV2SequencerCameraPreviewSafeFrameRect`,
    `FV2SequencerCameraPreviewMetadataRow`,
    `FV2SequencerCameraPreviewWindowIssue`, and
    `FV2SequencerCameraPreviewWindowModel`. The model reuses viewport preview
    camera evaluation, routes output through a picture-in-picture render target,
    and exposes pinned/docked window state, letterboxing, action/title
    safe-frame guides, and camera metadata while editing.
  - Added `V2.Editor.Sequencer.CameraPreviewWindow` automation coverage,
    `SequencerCameraPreviewWindow_V2_Contract.json`,
    `sequencer-camera-preview-window.md`,
    `check-v2-sequencer-camera-preview-window.py`, CI/Horde wiring, and
    editor-module checker coverage. Verification covers PiP visibility, render
    target routing, active camera binding and FOV, preview dimensions/aspect
    ratio, safe-frame guides, metadata lookup, invalid preview sizes, invalid
    frames, and missing camera state. `js_repl` Playwright was unavailable and
    this is an Unreal editor model surface, so browser Playwright coverage is
    not applicable.
- [x] **72.15.2.7** Implement undo/redo for all sequencer operations
  - Implemented the V2Editor TimelineVisualizer undo/redo history surface with
    `FV2SequencerUndoRedoPanelSpec`, `FV2SequencerUndoRedoSnapshot`,
    `FV2SequencerUndoRedoRequest`, `FV2SequencerUndoRedoState`, and
    `FV2SequencerUndoRedoResult`. The model stores before/after sequence
    snapshots for mutating track, keyframe, curve, and recording operations,
    applies undo and redo through deterministic stack transitions, preserves
    selected track/keyframe state, clears stale redo history on new pushes, and
    enforces max history capacity with validation issues for invalid requests.
  - Added `V2.Editor.Sequencer.UndoRedo` automation coverage,
    `SequencerUndoRedo_V2_Contract.json`, `sequencer-undo-redo.md`,
    `check-v2-sequencer-undo-redo.py`, CI/Horde wiring, and editor-module
    checker coverage. Verification covers push, undo, redo, redo invalidation,
    selection preservation, history trimming, clear history, empty undo
    rejection, empty redo rejection, missing operation id rejection, and
    adjacent sequencer editor gates. `js_repl` Playwright was unavailable and
    this is an Unreal editor model surface, so browser Playwright coverage is
    not applicable.
- [x] **72.15.2.8** Create sequencer hotkeys (play/pause, next/prev keyframe,
      set keyframe, delete keyframe, split track)
  - Implemented the V2Editor TimelineVisualizer hotkey command surface with
    `FV2SequencerHotkeyBindingSpec`, `FV2SequencerHotkeyPanelSpec`,
    `FV2SequencerHotkeyRequest`, and `FV2SequencerHotkeyResult`. The default
    binding table maps `Space`, `Period`, `Comma`, `S`, `Delete`, and `Ctrl+K`
    to play/pause, next/previous keyframe navigation, set keyframe, delete
    keyframe, and split track, with chord conflict validation, locked-track
    protection, selected-track scoping, selected-keyframe deletion,
    deterministic hotkey-created keyframe ids, and split-track selection state.
  - Added `V2.Editor.Sequencer.Hotkeys` automation coverage,
    `SequencerHotkeys_V2_Contract.json`, `sequencer-hotkeys.md`,
    `check-v2-sequencer-hotkeys.py`, CI/Horde wiring, and editor-module checker
    coverage. Verification covers binding lookup, play/pause toggle, next and
    previous keyframe navigation, set/delete keyframe mutation, `Ctrl+K` track
    split, unknown chord rejection, duplicate set-keyframe rejection, missing
    track rejection, locked-track delete rejection, and adjacent sequencer
    editor gates. `js_repl` Playwright was unavailable and this is an Unreal
    editor model surface, so browser Playwright coverage is not applicable.
- [x] **72.15.2.9** Implement recording mode (move objects in viewport,
      automatically create keyframes at current time)
  - Implemented the V2Editor TimelineVisualizer recording-mode surface with
    `FV2SequencerRecordingModePanelSpec`, `FV2SequencerRecordingModeState`,
    `FV2SequencerRecordingModeRequest`, and `FV2SequencerRecordingModeResult`.
    The model starts/stops/toggles recording takes, arms selected tracks,
    captures viewport transform movement and property values, auto-creates
    deterministic keyframes at the current frame, replaces existing keys when
    requested, preserves recorded keyframe ids for selection/undo, and rejects
    inactive recording, disabled auto-key, duplicate non-replace captures,
    mismatched bindings, and locked tracks.
  - Added `V2.Editor.Sequencer.RecordingMode` automation coverage,
    `SequencerRecordingMode_V2_Contract.json`, `sequencer-recording-mode.md`,
    `check-v2-sequencer-recording-mode.py`, CI/Horde wiring, and editor-module
    checker coverage. Verification covers recording state, viewport transform
    capture, property capture, existing-key replacement, duplicate rejection,
    inactive recording rejection, disabled auto-key rejection, locked-track
    rejection, and adjacent sequencer editor gates. `js_repl` Playwright was
    unavailable and this is an Unreal editor model surface, so browser
    Playwright coverage is not applicable.
- [x] **72.15.2.10** Create sequence template library (pre-made sequences for
      common patterns: dialogue scene, explosion, camera fly-through)
  - Implemented the V2Editor TimelineVisualizer sequence template library with
    `FV2SequencerTemplateSpec`, `FV2SequencerTemplateLibraryPanelSpec`,
    `FV2SequencerTemplateInstantiationRequest`, and
    `FV2SequencerTemplateLibraryResult`. The library provides validated built-in
    dialogue scene, explosion, and camera fly-through sequences with searchable
    tags, thumbnail metadata, preview track badges, camera/event/audio/property
    tracks, and stable template ids.
  - Added instantiation support that copies a selected template into a requested
    sequence id, applies optional display-name overrides, preserves or forces
    rebindable bindings/tracks, supports open-after-create state, and rejects
    missing template ids, missing sequence ids, unknown templates, invalid
    templates, and empty generated sequences.
  - Added `V2.Editor.Sequencer.TemplateLibrary` automation coverage,
    `SequencerTemplateLibrary_V2_Contract.json`,
    `sequencer-template-library.md`, `check-v2-sequencer-template-library.py`,
    CI/Horde wiring, and editor-module checker coverage. Verification covers
    panel metadata, all three built-ins, sequencer data-model validation,
    dialogue/explosion/camera-fly-through instantiation, optional rebinding,
    missing-template rejection, and missing-sequence rejection. `js_repl`
    Playwright was unavailable and this is an Unreal editor model surface, so
    browser Playwright coverage is not applicable.
- [x] **72.15.2.11** Implement render to video (export sequence as MP4/MOV at
      configurable resolution and framerate)
  - Implemented the V2Editor TimelineVisualizer render-to-video export surface
    with `FV2SequencerRenderVideoPanelSpec`,
    `FV2SequencerRenderVideoPresetSpec`, `FV2SequencerRenderVideoRequest`,
    `FV2SequencerRenderVideoJob`, and `FV2SequencerRenderVideoResult`. The model
    supports MP4 and MOV presets, configurable resolution and framerate,
    frame-range export, output path generation, warmup frames, audio mixdown,
    overwrite state, and queued Movie Render Pipeline job metadata.
  - Added validation for panel support, preset codecs/extensions, sequence id
    and camera-track requirements, output directory/file name, resolution
    bounds, 24-120 fps framerates, frame ranges inside sequence duration,
    unsupported formats, and invalid render queue output.
  - Added `V2.Editor.Sequencer.RenderVideo` automation coverage,
    `SequencerRenderVideo_V2_Contract.json`, `sequencer-render-video.md`,
    `check-v2-sequencer-render-video.py`, CI/Horde wiring, and editor-module
    checker coverage. Verification covers MP4 export, MOV export, configurable
    1080p/4K output, frame-rate overrides, output paths, Movie Render Pipeline
    queue state, audio mixdown/overwrite options, missing-camera rejection,
    unsupported-format rejection, invalid-resolution rejection,
    invalid-framerate rejection, missing-output rejection, and
    invalid-frame-range rejection. `js_repl` Playwright was unavailable and this
    is an Unreal editor model surface, so browser Playwright coverage is not
    applicable.
- [x] **72.15.2.12** Create sequence thumbnail preview (auto-generate thumbnail
      from first frame for asset browser)
  - Implemented the V2Editor TimelineVisualizer thumbnail preview surface with
    `FV2SequencerThumbnailPreviewPanelSpec`,
    `FV2SequencerThumbnailPreviewRequest`, `FV2SequencerThumbnailPreviewSpec`,
    and `FV2SequencerThumbnailPreviewResult`. The model captures first-frame
    thumbnails through a dedicated render target, writes PNG output paths,
    resolves the sequence camera binding, estimates thumbnail size, and marks
    generated thumbnails as asset-browser ready.
  - Added validation for panel render-target metadata, first-frame-only
    requests, output directory/file name, positive dimensions, panel dimension
    limits, valid sequence duration/framerate, in-range frames, camera-track
    availability, PNG-written state, and asset-browser registration state.
  - Added `V2.Editor.Sequencer.ThumbnailPreview` automation coverage,
    `SequencerThumbnailPreview_V2_Contract.json`,
    `sequencer-thumbnail-preview.md`, `check-v2-sequencer-thumbnail-preview.py`,
    CI/Horde wiring, and editor-module checker coverage. Verification covers
    panel metadata, first-frame thumbnail generation, PNG output path creation,
    camera binding resolution, asset-browser registration, missing-camera
    rejection, invalid-frame rejection, oversize-thumbnail rejection,
    missing-output rejection, and non-first-frame rejection. `js_repl`
    Playwright was unavailable and this is an Unreal editor model surface, so
    browser Playwright coverage is not applicable.
- [x] **72.15.2.13** Implement multi-user sequencer editing (lock tracks per
      user, merge changes)
  - Implemented the V2Editor TimelineVisualizer multi-user editing surface with
    `FV2SequencerMultiUserPanelSpec`, `FV2SequencerMultiUserPresence`,
    `FV2SequencerMultiUserTrackLock`, `FV2SequencerMultiUserTrackMerge`,
    `FV2SequencerMultiUserConflict`, `FV2SequencerMultiUserState`,
    `FV2SequencerMultiUserRequest`, and `FV2SequencerMultiUserResult`. The model
    supports remote user presence, exclusive per-track locks, owner-only
    release, base/local/incoming track-level merge evaluation, conflict rows,
    revision validation, and explicit prefer-incoming conflict resolution.
  - Added `V2.Editor.Sequencer.MultiUserEditing` automation coverage,
    `SequencerMultiUserEditing_V2_Contract.json`,
    `sequencer-multi-user-editing.md`,
    `check-v2-sequencer-multi-user-editing.py`, CI/Horde wiring, and
    editor-module checker coverage. Verification covers panel metadata, local
    and remote presence, local track lock grant, remote lock rejection,
    non-owner release rejection, owner lock release, incoming-only merge,
    local-only merge, blocking conflict detection, prefer-incoming conflict
    resolution, stale revision rejection, and missing lock-target rejection.
    `js_repl` Playwright was unavailable and this is an Unreal editor model
    surface, so browser Playwright coverage is not applicable.
- [x] **72.15.2.14** Create sequence documentation and cinematic authoring guide
  - Added the V2 Sequencer Authoring Guide covering sequence source-of-truth
    contracts, stable `SequenceId`/`BindingId`/`TrackId`/`KeyframeId` usage,
    track types, bindings, cameras, keyframes, curves, audio, events, animation
    clips, sub-sequences, templates, LOD, editor workflow, multi-user review,
    thumbnail generation, render-to-video output, playback signoff, and review
    checklist expectations.
  - Added `SequencerAuthoringGuide_V2_Contract.json`,
    `check-v2-sequencer-authoring-guide.py`, CI/Horde wiring, and TODO evidence.
    Verification covers guide sections, required topics, linked runtime/editor
    dependency contracts, validation command inventory, workflow registration,
    Horde registration, and documentation validation.
- [x] **72.15.2.15** Implement sequence performance profiling (identify heavy
      tracks, optimize playback)
  - Implemented the V2Editor TimelineVisualizer performance profiling surface
    with `FV2SequencerPerformanceProfilingPanelSpec`,
    `FV2SequencerPerformanceProfilingRequest`,
    `FV2SequencerPerformanceTrackProfile`,
    `FV2SequencerPerformanceOptimization`, `FV2SequencerPerformanceIssue`, and
    `FV2SequencerPerformanceProfilingResult`. The model estimates per-track
    playback cost and memory, identifies heavy tracks, evaluates frame-budget
    pressure, filters muted tracks, recommends optimizations, and auto-applies
    safe keyframe downsampling to an optimized sequence.
  - Added `V2.Editor.Sequencer.PerformanceProfiling` automation coverage,
    `SequencerPerformanceProfiling_V2_Contract.json`,
    `sequencer-performance-profiling.md`,
    `check-v2-sequencer-performance-profiling.py`, CI/Horde wiring, and
    editor-module checker coverage. Verification covers profiler panel metadata,
    default sequence cost profiles, heavy-track detection, playback-budget
    warnings, downsample recommendations, auto-applied safe optimization,
    muted-track filtering, invalid budget rejection, and empty profile
    rejection. `js_repl` Playwright was unavailable and this is an Unreal editor
    model surface, so browser Playwright coverage is not applicable.

---

### 72.16 Gameplay Camera System

Third-person, first-person, cinematic cameras with collision, spring arm, and
debug visualization.

#### 72.16.1 Camera Framework

- [x] **72.16.1.1** Implement camera manager system (stack of camera modes,
      blend between modes, priority-based activation)
- [x] **72.16.1.2** Create third-person orbit camera (orbit around character,
      configurable distance/pitch/yaw limits, input sensitivity)
- [x] **72.16.1.3** Implement camera spring arm with collision (arm traces
      against geometry, pull camera forward on collision, smooth recovery)
- [x] **72.16.1.4** Create first-person camera (attached to character head bone,
      head bob, weapon sway, FOV configuration)
- [x] **72.16.1.5** Implement camera soft lock-on (camera biases toward lock-on
      target without full lock, adjustable strength)
- [x] **72.16.1.6** Create camera collision avoidance (prevent camera clipping
      through walls, transparent near-clip rendering)
- [x] **72.16.1.7** Implement camera interpolation between modes (smooth
      position/rotation/FOV blend over configurable duration)
- [x] **72.16.1.8** Create camera shake system (Perlin noise shake, spring
      shake, directional impact shake — configurable amplitude, frequency,
      duration, falloff)
- [x] **72.16.1.9** Implement camera rail system (predefined camera paths for
      scripted sequences, spline-based)
- [x] **72.16.1.10** Create camera zoom system (aim-down-sights FOV reduction,
      scope zoom, binocular zoom)
- [x] **72.16.1.11** Implement dead zone and look-ahead (camera doesn't move for
      small input, look-ahead in movement direction)
- [x] **72.16.1.12** Create split-screen camera management (2-4 player split,
      configurable split direction, per-player camera settings)
- [x] **72.16.1.13** Implement VR camera rig (head-tracked camera, comfort
      vignette on fast movement, snap/smooth turn options)
- [x] **72.16.1.14** Create camera post-process zone triggers (enter area →
      apply post-process settings: fog, color grade, depth of field)
- [x] **72.16.1.15** Implement camera debug visualization (draw camera frustum,
      spring arm, collision traces, look-at targets)

---

### 72.17 NPC Scheduling & Daily Routine System

Bethesda Radiant AI–class NPC routines with schedule definitions, location
binding, interruption, and debugging.

#### 72.17.1 NPC Schedule Framework

- [x] **72.17.1.1** Design NPC schedule data format (time blocks: 6AM-8AM eat
      breakfast at home, 8AM-5PM work at shop, 5PM-8PM visit tavern, etc.)
  - Added `V2NPCScheduleData` with authored time-of-day blocks, activity type
    tokens, location/behavior/interaction binding ids, priority, interruption
    and reservation policy, full-day coverage validation, overnight block
    support, sorting helpers, and an example daily routine covering breakfast,
    work, tavern, and sleep.
  - Added `NPCScheduleDataFormat_V2_Contract.json`,
    `npc-schedule-data-format.md`, `check-v2-npc-schedule-data-format.py`,
    automation coverage, CI/Horde wiring, and TODO evidence. Verification covers
    stable ids, invalid/missing fields, duplicate blocks, overlapping minutes,
    coverage gaps, and midnight wrapping.
- [x] **72.17.1.2** Implement schedule execution engine (evaluate current time,
      select active schedule block, issue behavior to AI system)
  - Added `V2NPCScheduleExecution` with request/result structs, active block
    lookup by current time, midnight-wrapping block support, elapsed/transition
    minute calculations, optional command suppression, idle fallback for allowed
    coverage gaps, and data-driven AI behavior commands carrying schedule, NPC,
    block, activity, location, behavior, interaction, priority, interruption,
    reservation, and tag payloads.
  - Added `NPCScheduleExecutionEngine_V2_Contract.json`,
    `npc-schedule-execution-engine.md`,
    `check-v2-npc-schedule-execution-engine.py`, automation coverage, CI/Horde
    wiring, and TODO evidence. Verification covers active work/tavern/sleep
    selection, behavior command emission, midnight execution, suppressed
    commands, idle fallback, missing active block handling, and invalid schedule
    or time rejection.
- [x] **72.17.1.3** Create schedule-driven pathfinding (NPC navigates to
      schedule location at transition time, waits if too early)
  - Added `V2NPCSchedulePathfinding` with pathfinding requests, deterministic
    navigation command payloads, current-location checks, active block routing,
    next-transition routing, travel-window lead checks, planned
    departure/arrival minutes, midnight wrapping, early-arrival wait minutes,
    and command suppression for prediction/debug-only planning.
  - Added `NPCSchedulePathfinding_V2_Contract.json`,
    `npc-schedule-pathfinding.md`, `check-v2-npc-schedule-pathfinding.py`,
    automation coverage, CI/Horde wiring, and TODO evidence. Verification covers
    already-at-destination handling, active schedule destination routing,
    transition-window targeting, waiting before block start, suppressed
    navigation commands, and invalid execution/location/travel input rejection.
- [x] **72.17.1.4** Implement schedule activity behaviors (work: play work
      animation at workstation; eat: sit at table, play eating animation; sleep:
      go to bed, play sleep animation)
  - Added `V2NPCScheduleActivityBehavior` with activity behavior requests,
    activity steps, issued/suppressed activity commands, execution/pathfinding
    gating, interaction-tag validation, workstation work loops, sit/eat steps,
    bed/sleep steps, and deterministic fallback mappings for visit/social, idle,
    travel, and custom activities.
  - Added `NPCScheduleActivityBehavior_V2_Contract.json`,
    `npc-schedule-activity-behavior.md`,
    `check-v2-npc-schedule-activity-behavior.py`, automation coverage, CI/Horde
    wiring, and TODO evidence. Verification covers work animation at
    workstation, sit/eating animation, go-to-bed/sleep animation, navigation
    gating before performance, command suppression, invalid execution,
    missing-location, and missing-interaction rejection.
- [x] **72.17.1.5** Create schedule location binding (NPC owns a home, a
      workplace, a tavern seat — registered locations for schedule activities)
  - Added `V2NPCScheduleLocationBinding` with registered location definitions,
    per-NPC registries, bound block locations, ownership/exclusivity checks,
    activity compatibility, availability checks, interaction-tag matching,
    duplicate location rejection, and an example registry for home kitchen, home
    bed, shop counter, and tavern seat bindings.
  - Added `NPCScheduleLocationBinding_V2_Contract.json`,
    `npc-schedule-location-binding.md`,
    `check-v2-npc-schedule-location-binding.py`, automation coverage, CI/Horde
    wiring, and TODO evidence. Verification covers home/workplace/tavern-seat
    binding, missing workplace, owner mismatch, unavailable tavern seat,
    unsupported activity, interaction mismatch, and duplicate registered
    location ids.
- [x] **72.17.1.6** Implement schedule interruption system (combat interrupts
      schedule, NPC returns to schedule after threat resolved; player
      interaction pauses schedule; weather drives NPCs indoors)
  - Added `V2NPCScheduleInterruption` with prioritized active interruption
    selection, combat schedule pauses, player-interaction pauses with optional
    command suppression, weather shelter/home routing, resolved-threat resume
    commands, issued-command validation, and blocking guardrails for invalid
    execution, missing current location, missing interruption ids, missing
    shelter targets, and invalid interruption commands.
  - Added `NPCScheduleInterruption_V2_Contract.json`,
    `npc-schedule-interruption.md`, `check-v2-npc-schedule-interruption.py`,
    automation coverage, CI/Horde wiring, and TODO evidence. Verification covers
    combat interruption, player-interaction pause, weather indoor routing,
    resume after resolved threats, highest-priority selection, command
    suppression, and missing shelter/current-location/id rejection.
- [x] **72.17.1.7** Create schedule variation and randomization (not every day
      identical: 30% chance NPC visits market instead of tavern, random walk
      paths, varied arrival times)
  - Added `V2NPCScheduleVariation` with deterministic rule rolls from schedule
    id, NPC id, variation id, target block, day seed, and NPC seed; a 30% market
    substitution for the tavern visit; seeded random walk path selection;
    bounded arrival-time offsets; variation suppression; and blocking guardrails
    for invalid schedules, ids, chance ranges, target blocks, replacement
    payloads, path pools, arrival offsets, and invalid variation output.
  - Added `NPCScheduleVariation_V2_Contract.json`, `npc-schedule-variation.md`,
    `check-v2-npc-schedule-variation.py`, automation coverage, CI/Horde wiring,
    and TODO evidence. Verification covers market selection, tavern retention,
    deterministic random-walk path choice, bounded arrival offsets,
    deterministic roll calculation, suppression, and invalid rule rejection.
- [x] **72.17.1.8** Implement schedule day-of-week variation (weekday schedule
      vs weekend schedule, holiday overrides)
  - Added `V2NPCScheduleDayOfWeek` with calendar dates, weekday/weekend/specific
    day/holiday override patterns, priority-based selection, example weekday
    merchant, weekend market, and harvest festival schedules, suppression
    support, and blocking guardrails for invalid base schedules, calendar dates,
    pattern ids, replacement schedules, holiday ids, and invalid selection
    results.
  - Added `NPCScheduleDayOfWeek_V2_Contract.json`,
    `npc-schedule-day-of-week.md`, `check-v2-npc-schedule-day-of-week.py`,
    automation coverage, CI/Horde wiring, and TODO evidence. Verification covers
    weekday selection, weekend market selection, holiday override precedence
    over weekend, suppression, and invalid calendar/pattern rejection.
- [x] **72.17.1.9** Create schedule weather response (rain → NPCs seek shelter,
      extreme cold → NPCs stay indoors, sunny → NPCs go outside)
  - Added `V2NPCScheduleWeatherResponse` with weather state/rule data, schedule
    execution and location-binding evaluation, rain shelter selection,
    extreme-cold indoor routing, sunny outdoor routing, weather interruption
    event output, command suppression, and blocking guardrails for missing
    current locations, weather ids, target shelter/indoor/outdoor locations, and
    invalid weather commands.
  - Added `NPCScheduleWeatherResponse_V2_Contract.json`,
    `npc-schedule-weather-response.md`,
    `check-v2-npc-schedule-weather-response.py`, automation coverage, CI/Horde
    wiring, and TODO evidence. Verification covers rainy shelter routing,
    extreme-cold indoor routing, sunny outdoor routing, command suppression, and
    missing shelter/weather/current-location rejection.
- [x] **72.17.1.10** Implement schedule social interaction (NPCs recognize
      friends in the same location, play conversation animations, form groups)
  - Added `V2NPCScheduleSocialInteraction` with nearby participant data,
    relationship-aware social rules, same-location friend recognition,
    conversation animation tag selection, deterministic participant/rule
    priority, group conversation formation, command suppression, and blocking
    guardrails for invalid schedule execution, missing current locations,
    participant ids, participant locations, and invalid social commands.
  - Added `NPCScheduleSocialInteraction_V2_Contract.json`,
    `npc-schedule-social-interaction.md`,
    `check-v2-npc-schedule-social-interaction.py`, automation coverage, CI/Horde
    wiring, and TODO evidence. Verification covers friend recognition,
    conversation animation selection, group formation, command suppression,
    friends in other locations, missing social rules, and missing
    location/participant rejection.
- [x] **72.17.1.11** Create schedule persistence across save/load (resume exact
      schedule state, NPC at correct location for time of day)
  - Added `V2NPCSchedulePersistence` with versioned schedule snapshots,
    save/schedule/NPC identifiers, saved time, exact active block, restored
    schedule-correct location, interruption metadata, day seed, weather id,
    command suppression, and blocking guardrails for invalid snapshots,
    mismatched schedule/NPC ids, invalid saved times, unresolved locations, and
    invalid restore commands.
  - Added `NPCSchedulePersistence_V2_Contract.json`,
    `npc-schedule-persistence.md`, `check-v2-npc-schedule-persistence.py`,
    automation coverage, CI/Horde wiring, and TODO evidence. Verification covers
    snapshot capture, serialization/deserialization, exact block resume, correct
    location restore, paused interaction persistence, interruption state
    restore, command suppression, and invalid snapshot rejection.
- [x] **72.17.1.12** Implement schedule debugging visualization (show NPC
      schedule timeline, current block, planned path, next transition)
  - Added `V2NPCScheduleDebugVisualization` with deterministic timeline segment
    primitives, current-time/current-block markers, planned path lines from
    schedule pathfinding, next-transition markers, layer draw toggles, and
    blocking guardrails for invalid config, viewport, schedule execution,
    pathfinding, and debug primitives.
  - Added `NPCScheduleDebugVisualization_V2_Contract.json`,
    `npc-schedule-debug-visualization.md`,
    `check-v2-npc-schedule-debug-visualization.py`, automation coverage,
    CI/Horde wiring, and TODO evidence. Verification covers timeline/current
    block rendering, planned path diagnostics, next-transition markers, draw
    toggles, and invalid input rejection.
- [x] **72.17.1.13** Create schedule editor tool (visual timeline per NPC,
      drag-drop activity blocks, assign locations)
  - Added a V2Editor NPC schedule editor `TimelineVisualizer` surface with
    visual timeline rows per NPC, NPC selector/location palette widget metadata,
    viewport layout modeling, drag-drop block move requests, location assignment
    requests, overlap/invalid-input validation, and stable offscreen row
    clamping for dense schedules.
  - Added `NPCScheduleEditor_V2_Contract.json`, `npc-schedule-editor.md`,
    `check-v2-npc-schedule-editor.py`, automation coverage, editor-module
    checker coverage, CI/Horde wiring, and TODO evidence. Verification covers
    widget spec validation, viewport/model validity, per-NPC timeline rows,
    drag-drop activity moves, location assignment, overlap rejection, and
    invalid viewport/location reporting.
- [x] **72.17.1.14** Implement schedule LOD (distant NPCs use simplified
      schedule — teleport to location instead of walking, skip complex
      animations)
  - Added `V2NPCScheduleLOD` with distance-based full/simplified mode selection,
    schedule pathfinding reuse for deterministic target selection,
    full-simulation navigation/activity retention for nearby NPCs, distant
    teleport-to-schedule-location commands, complex animation suppression, and
    blocking guardrails for invalid configs, negative distances, missing current
    locations, invalid pathfinding, invalid nearby activity behavior, and
    malformed LOD commands.
  - Added `NPCScheduleLOD_V2_Contract.json`, `npc-schedule-lod.md`,
    `check-v2-npc-schedule-lod.py`, automation coverage, CI/Horde wiring, and
    TODO evidence. Verification covers config bounds, nearby full simulation,
    retained nearby navigation/activity commands, distant teleport instead of
    walking, distant animation suppression, and invalid config/location/distance
    rejection.
- [x] **72.17.1.15** Create schedule documentation and NPC authoring guide
  - Added `npc-schedule-authoring-guide.md` with source-of-truth contract links,
    stable schedule/NPC/block/location/activity/behavior/interaction id
    guidance, block coverage and transition rules, location binding,
    pathfinding, activity behavior, variations, day/weather/social rules,
    interruption, persistence, debug visualization, editor, and LOD authoring
    expectations.
  - Added `NPCScheduleAuthoringGuide_V2_Contract.json`,
    `check-v2-npc-schedule-authoring-guide.py`, CI/Horde wiring, and TODO
    evidence. Verification covers guide sections, required schedule topics,
    source-of-truth links, authoring workflow, review checklist, validation
    commands, and CI/Horde gate wiring.

---

### 72.18 Game Economy & Virtual Economy System

Engine-level currency, shop, auction house, loot tables, economy balancing and
analytics for in-game economies.

#### 72.18.1 Economy Framework

- [x] **72.18.1.1** Implement currency definition system (gold, gems, tokens,
      reputation — multiple currencies with display formatting)
  - Added `V2CurrencyDefinition` with currency kind/display-style enums,
    definition/catalog/amount/display result structs, default gold, gem,
    festival token, and lotus reputation definitions, premium/reputation flags,
    cap validation, duplicate id/code detection, signed reputation formatting,
    symbol/unit display strings, and negative-amount guardrails.
  - Added `CurrencyDefinition_V2_Contract.json`, `currency-definition.md`,
    `check-v2-currency-definition.py`, automation coverage, CI/Horde wiring, and
    TODO evidence. Verification covers default catalog validation, multiple
    currency lookup, premium/reputation metadata, gold separators and symbol
    formatting, gem/token formatting, signed reputation formatting, invalid
    identifier/fraction/cap rejection, duplicate rejection, and invalid negative
    amount rejection.
- [x] **72.18.1.2** Create currency transaction ledger (all currency changes
      logged: source, amount, timestamp, reason — auditable)
  - Added `V2CurrencyTransactionLedger` with account-scoped ledger requests,
    transaction records, balance snapshots, result/audit/validation structs,
    transaction type and issue enums, and Blueprint helpers for building
    requests, applying transactions, reading balances, building audit trails,
    and validating immutable balance chains.
  - Every applied record stores source, amount, timestamp, and reason alongside
    balance-before and balance-after values. Validation rejects missing audit
    fields, unknown currencies, duplicate transaction ids, zero or wrong-signed
    amounts, insufficient funds for non-negative currencies, hard-cap overflow,
    and inconsistent balance snapshots.
  - Added `CurrencyLedger_V2_Contract.json`, `currency-ledger.md`,
    `check-v2-currency-ledger.py`, automation coverage, CI/Horde wiring, and
    TODO evidence. Verification covers grant and spend recording, deterministic
    balance application, duplicate rejection, insufficient-funds rejection,
    negative reputation adjustments, audit trail summaries, ledger validation,
    and missing source/reason/timestamp/amount/unknown-currency rejection.
- [x] **72.18.1.3** Implement server-authoritative currency management (prevent
      client-side currency manipulation)
  - Added `V2ServerCurrencyAuthority` with a strict server-authority policy,
    server mutation wrapper, authority issue/result structs, trusted source
    allow-list checks, server request id replay protection, client-authored
    mutation rejection, client-reported balance mismatch rejection, and atomic
    batch fail-closed behavior.
  - Accepted mutations flow through `V2CurrencyTransactionLedger`, preserving
    currency definition validation, ledger balance rules, server-authoritative
    audit records, source/reason/timestamp fields, and immutable balance chains.
    Rejected client-side currency manipulation preserves the pre-request ledger
    and marks rejection evidence for review.
  - Added `ServerCurrencyAuthority_V2_Contract.json`,
    `server-currency-authority.md`, `check-v2-server-currency-authority.py`,
    automation coverage, CI/Horde wiring, and TODO evidence. Verification covers
    strict policy validation, server-authored grant/spend application,
    client-authored rejection, non-server-authoritative rejection, untrusted
    source rejection, client balance mismatch rejection, duplicate server
    request id rejection, ledger rejection surfacing, atomic fail-closed
    behavior, and permissive policy rejection.
- [x] **72.18.1.4** Create price table system (items have buy/sell prices per
      currency, dynamic pricing support, regional price variations)
  - Added `V2PriceTable` with buy and sell prices per item/currency, premium
    currency support, quote requests/results, validation issues, regional
    override rows, dynamic demand/supply/event multipliers, min/max price
    clamps, quantity totals, and Blueprint helpers for table construction, entry
    lookup, validation, and deterministic quoting.
  - Price table validation checks stable table/entry ids, item ids, currency ids
    against `CurrencyDefinition.V2`, duplicate item/currency pairs, buy and sell
    price sanity, dynamic modifier bounds, regional override references,
    duplicate regional overrides, and region-specific override prices.
  - Added `PriceTable_V2_Contract.json`, `price-table.md`,
    `check-v2-price-table.py`, automation coverage, CI/Horde wiring, and TODO
    evidence. Verification covers buy/sell prices per item/currency, premium gem
    prices, regional fixed-price and multiplier variations, dynamic pricing with
    min/max clamps, disabled sell rejection, duplicate/unknown-currency
    validation, and missing quote/invalid quantity rejection.
- [x] **72.18.1.5** Implement shop/vendor system (vendor inventory, buy/sell
      interface, limited stock with refresh timers, reputation-based pricing)
  - Added `V2EconomyVendorShop`, a currency-aware economy vendor layer that
    composes existing inventory containers with `V2PriceTable`,
    `V2CurrencyTransactionLedger`, and `V2ServerCurrencyAuthority` while leaving
    the legacy single-currency `VendorShop.V2` contract intact.
  - Implemented vendor inventory-backed listings, a buy/sell interface,
    price-table regional quotes, reputation-based pricing discounts and sell
    bonuses, server-authoritative currency spend/grant mutations, atomic
    inventory and ledger application, limited stock decrement/increment, and
    limited stock with refresh timers.
  - Added `EconomyVendorShop_V2_Contract.json`, `economy-vendor-shop.md`,
    `check-v2-economy-vendor-shop.py`, automation coverage, CI/Horde wiring, and
    TODO evidence. Verification covers vendor inventory validation,
    price-table/reputation quotes, server-authoritative buys, unaffordable buy
    fail-closed behavior, selling to vendor stock with reputation bonus, stock
    refresh timers, duplicate listing validation, and reputation bound
    validation.
- [x] **72.18.1.6** Create auction house framework (player-to-player item
      trading via listing, bidding, buyout, expiration, transaction fees)
  - Added `V2AuctionHouse`, an economy-layer auction framework that composes
    inventory escrow, `V2CurrencyTransactionLedger`, and
    `V2ServerCurrencyAuthority` for player-to-player item auctions.
  - Implemented escrow-backed listing creation, server-authoritative bid holds,
    same-bidder bid deltas, outbid refunds, seller self-bid rejection, buyout
    settlement, expired winning-bid settlement, unsold item return, and
    transaction fee accounting through a fee ledger.
  - Added `AuctionHouse_V2_Contract.json`, `auction-house.md`,
    `check-v2-auction-house.py`, automation coverage, CI/Horde wiring, and TODO
    evidence. Verification covers player-to-player item listing, bidding,
    buyout, expiration, transaction fees, duplicate listing validation, bid
    increment validation, and fee-rate bound validation.
- [x] **72.18.1.7** Implement direct player trading (propose trade, both players
      add items/currency, confirm, execute atomically on server)
  - Added `V2EconomyDirectTrade`, an economy-layer direct player trading runtime
    that composes inventory item exchange, `V2CurrencyTransactionLedger`, and
    `V2ServerCurrencyAuthority` while leaving the earlier item-only
    `InventoryTrading.V2` contract intact.
  - Implemented player-to-player trade proposals, both-player item and currency
    offers, offer-change confirmation resets, initiator/recipient confirmations,
    cancellation, server-authoritative currency `TransferOut`/`TransferIn`
    batches, and working-copy inventory/currency execution that commits only
    after the whole trade succeeds.
  - Added `EconomyDirectTrade_V2_Contract.json`, `economy-direct-trade.md`,
    `check-v2-economy-direct-trade.py`, automation coverage, CI/Horde wiring,
    and TODO evidence. Verification covers both players add items/currency,
    confirmation flow, execute atomically on server, early execution rejection,
    failed execution rollback, duplicate item/currency validation, unknown
    participant rejection, and cancellation.
- [x] **72.18.1.8** Create loot table system (define drop pools with weighted
      probabilities, guaranteed drops, pity counters, context-sensitive drops)
  - Extended the existing `V2LootTable` runtime used by the inventory framework
    into an economy-ready loot table system rather than duplicating reward roll
    logic. Tables now support weighted pools, guaranteed drops, pity counters,
    deterministic seed-derived item instances, context-sensitive guaranteed
    drops, context-gated pools and entries, context weight modifiers, and rarity
    weight curves based on resolved item definitions.
  - Added `loot-table-system.md`, expanded the `LootTable_V2_Contract.json`
    contract to name `TODOS.phase-72.72.18.1.8`, updated the focused checker,
    gameplay-module checker, CI workflow, and Horde gates for context-sensitive
    drops and rarity curves. Verification covers context eligibility,
    context/rarity effective weights, invalid context and rarity modifier
    rejection, legacy weighted/guaranteed/pity behavior, deterministic rolls,
    and missing item definition failure.
- [x] **72.18.1.9** Implement loot table debugging tool (simulate N drops, show
      distribution, verify against expected rates)
  - Added `V2LootTableDebugger`, a Blueprint-callable economy debugging surface
    that runs N deterministic loot table simulations, advances seed ranges,
    carries pity counters between rolls, records sample drops, aggregates
    observed distribution rows by pool/entry/item, and formats a compact
    distribution summary for designers and CI logs.
  - Added expected-rate verification with per-row tolerance, fail-closed
    mismatch issues, context-sensitive debug requests, validation for simulation
    counts/tolerances/expected rows, `LootTableDebugger_V2_Contract.json`,
    `loot-table-debugger.md`, focused checker, automation coverage, CI workflow
    wiring, and Horde gates. Verification covers N-drop simulation, distribution
    rows, expected-rate pass/fail, context-sensitive drops, pity carryover,
    summary formatting, and invalid config rejection.
- [x] **72.18.1.10** Create economy simulation tool (model currency
      sources/sinks at scale — does economy inflate, deflate, or stabilize after
      N hours of play?)
  - Added `V2EconomySimulation`, a Blueprint-callable source/sink modeling tool
    that projects currency supply across a configured player population and
    duration, applies per-hour source and sink rules, records periodic supply
    snapshots, reports unfunded sink demand, and classifies each currency as
    inflating, deflating, or stable against a configurable threshold.
  - Added `EconomySimulation_V2_Contract.json`, `economy-simulation.md`, focused
    checker, automation coverage, CI workflow wiring, gameplay-module
    validation, and Horde gates. Verification covers currency source/sink model
    validation, inflation after N hours, stable source/sink balance, deflation,
    unfunded sink demand, supply snapshots, trend summaries, and invalid
    flow-rule rejection.
- [x] **72.18.1.11** Implement economy analytics dashboard (currency supply
      velocity, average player wealth by level, item price trends, sink/source
      ratios)
  - Added `@v2/economy-analytics-dashboard`, an operational economy dashboard
    surface that aggregates currency supply snapshots, source/sink flows, player
    wealth snapshots, and item price telemetry into chart-ready currency supply
    velocity, average player wealth by level, item price trends, and sink/source
    ratios.
  - Added `v2-economy-analytics-dashboard.json`,
    `economy-analytics-dashboard.md`, focused checker coverage, CI workflow
    wiring, telemetry README coverage, and Horde gates. Verification covers
    supply velocity with turnover, level wealth percentiles, price trend
    direction, sink/source balance classification, window filtering, invalid
    dashboard telemetry rejection, and empty-surface behavior.
- [x] **72.18.1.12** Create economy balance tuning interface (adjust drop rates,
      prices, rewards in real-time via remote config without patch)
  - Added `@v2/economy-balance-tuning-interface`, a live-ops tuning surface that
    composes `@v2/remote-config-service` validation and staging preview APIs for
    drop rates, economy prices, and economy rewards while keeping
    `requiresClientPatch: false` and `publishesRemoteConfigOnly: true`.
  - Extended the shared remote-config service with `economy-price` and
    `economy-reward` parameter kinds, default price/reward parameters, and
    validation rules that block negative economy values before publish.
  - Added the static V2 web surface at
    `V2/web/live-service/economy-balance-tuning/`, Playwright coverage in
    `V2/web/e2e/v2-web-economy-balance-tuning.spec.ts`,
    `EconomyBalanceTuning_V2_Contract.json`, `economy-balance-tuning.md`,
    focused checker coverage, CI workflow wiring, and Horde gates. Verification:
    `pnpm --filter @v2/economy-balance-tuning-interface run typecheck`,
    `pnpm --filter @v2/economy-balance-tuning-interface run test`,
    `pnpm --filter @v2/economy-balance-tuning-interface run lint`,
    `pnpm --filter @v2/economy-balance-tuning-interface run build`,
    `pnpm --filter @v2/remote-config-service run typecheck`,
    `pnpm --filter @v2/remote-config-service run test`,
    `pnpm --filter @v2/remote-config-service run lint`,
    `pnpm --filter @v2/remote-config-service run build`,
    `pnpm --dir V2/web run typecheck`, `pnpm --dir V2/web run lint`,
    `pnpm --dir V2/web run build`,
    `pnpm --dir V2/web test:e2e -- e2e/v2-web-economy-balance-tuning.spec.ts`,
    `python3 V2/ue/Tools/check-v2-economy-balance-tuning.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-service.py`,
    `python3 V2/ue/Tools/check-v2-remote-config-validation-rules.py`,
    `python3 V2/ue/Tools/check-v2-ci-workflow.py`, JSON validation, and checker
    `py_compile`.
- [x] **72.18.1.13** Implement premium currency system (real-money purchasable
      currency, IAP store integration, receipt validation)
  - Added `V2PremiumCurrencySystem`, a gameplay-side premium currency purchase
    surface with product catalog, Apple App Store and Google Play IAP store
    endpoint metadata, real-money purchasable currency grants, server-verified
    receipt records, amount matching, account/environment checks, refund/expiry
    rejection, and ledger-backed receipt replay protection.
  - Fulfillment grants real-money purchasable `currency.gems` only after receipt
    validation and routes every accepted purchase through
    `ServerCurrencyAuthority.V2` with `SourceId = platform.iap`, immutable
    currency ledger audit tags, and no direct balance writes.
  - Added `PremiumCurrencySystem_V2_Contract.json`,
    `premium-currency-system.md`, `PremiumCurrencySystem.spec.cpp`, focused
    checker coverage in `check-v2-premium-currency-system.py`, CI workflow
    wiring, and Horde gates for store catalog, receipt validation, replay/refund
    rejection, server authority fulfillment, and CI coverage.
- [x] **72.18.1.14** Create economy exploit detection (flag impossible currency
      gains, item duplication, exploit velocity)
  - Added `V2EconomyExploitDetection`, a gameplay-side economy state detector
    that analyzes currency ledgers and inventory containers for impossible
    currency gains, duplicate currency transaction ids, untrusted currency
    sources, item duplication across occupied slots, exploit velocity via
    currency gain velocity, and transaction velocity over a bounded analysis
    window.
  - The detector produces deterministic economy exploit evidence ids, persists
    forensic evidence, queues fair-play review, and fails closed for ranked or
    tournament requests when exploit signals are present.
  - This explicitly covers impossible currency gains, item duplication, and
    exploit velocity.
  - Added `EconomyExploitDetection_V2_Contract.json`,
    `economy-exploit-detection.md`, `EconomyExploitDetection.spec.cpp`, focused
    checker coverage in `check-v2-economy-exploit-detection.py`, CI workflow
    wiring, and Horde gates for currency gains, item duplication, velocity,
    fair-play review, and CI coverage.
- [x] **72.18.1.15** Implement economy documentation covering design principles,
      balancing methodology, and monitoring
  - Added `economy-design-balancing-monitoring.md` as the economy operating
    guide for design principles, balancing methodology, and monitoring across
    `CurrencyDefinition.V2`, `CurrencyLedger.V2`, `ServerCurrencyAuthority.V2`,
    premium currency fulfillment, price tables, loot-table debugging, economy
    simulation, remote-config balance tuning, analytics dashboards, and exploit
    detection.
  - Documented the balance workflow from source/sink hypotheses through
    `V2EconomySimulation`, `V2LootTableDebugger`, `PriceTable.V2`,
    `EconomyBalanceTuning.V2`, canary remote config, rollback criteria, and live
    monitoring of currency supply velocity, average player wealth by level, item
    price trends, sink/source ratios, earn/spend rates, and fair-play review
    signals.
  - Added `EconomyDocumentation_V2_Contract.json`,
    `check-v2-economy-documentation.py`, CI workflow wiring, and Horde gates for
    source coverage, design principles, balancing methodology, monitoring,
    validation commands, and CI coverage.

---

### 72.19 Automated Playtesting & AI Bot Framework

RL-agent exploration bots, soak testing, coverage mapping, and automated
difficulty analysis.

#### 72.19.1 Playtesting Bot Framework

- [x] **72.19.1.1** Implement bot harness (headless game client controlled by
      script/ML model, can execute any player action)
  - Added `V2BotHarness` to the `V2Tests` developer-tool module with typed
    player action kinds, script/ML model policy binding, headless game client
    config, per-frame action budgets, deterministic observation hashes, action
    transcript capture, and rejected-action failure semantics.
  - The default harness is a headless game client controlled by script/ML model
    inputs and proves it can execute any player action, including movement,
    look, jump, crouch, sprint, interact, primary/secondary attack, ability,
    item, menu, pause, wait, and custom command actions.
  - Added `BotHarness.spec.cpp`, `BotHarness_V2_Contract.json`,
    `bot-harness.md`, `check-v2-bot-harness.py`, V2Tests module checker
    coverage, CI workflow wiring, and Horde gates for source, headless client,
    script control, ML policy control, player action surface, transcript
    results, and CI coverage.
- [x] **72.19.1.2** Create random exploration bot (move randomly, interact with
      nearby objects, open doors, collect items — finds crashes and stuck spots)
  - Added `V2RandomExplorationBot`, a deterministic seeded bot built on
    `V2BotHarness` that can move randomly, look around, interact with nearby
    objects, open doors, collect items, and execute the generated script through
    the headless harness transcript path.
  - This directly covers move randomly, interact with nearby objects, open
    doors, collect items, and finds crashes and stuck spots.
  - The result surface reports movement actions, nearby-object interactions,
    door-open attempts, item-collection attempts, crash counters, stuck-spot
    counters, detected stuck-spot ids, and harness rejection status, so the bot
    finds crashes and stuck spots through repeatable QA runs.
  - Added `RandomExplorationBot.spec.cpp`,
    `RandomExplorationBot_V2_Contract.json`, `random-exploration-bot.md`,
    `check-v2-random-exploration-bot.py`, V2Tests module checker coverage, CI
    workflow wiring, and Horde gates for random movement, interactions,
    doors/items, crash/stuck reporting, and CI coverage.
- [x] **72.19.1.3** Implement coverage mapping (track which world positions bots
      have visited, generate coverage heatmap, identify unexplored areas)
  - Added `V2BotCoverageMapping`, a V2Tests coverage analyzer that converts bot
    result movement samples into visited world positions, projects them into
    heatmap cells, tracks visited cells, computes heatmap intensity, and returns
    unexplored cells.
  - The result surface explicitly proves it can track which world positions bots
    have visited, generate coverage heatmap data, and identify unexplored areas
    without requiring a rendered image in automation.
  - This directly covers track which world positions bots have visited, generate
    coverage heatmap, and identify unexplored areas.
  - Added `BotCoverageMapping.spec.cpp`, `BotCoverageMapping_V2_Contract.json`,
    `bot-coverage-mapping.md`, `check-v2-bot-coverage-mapping.py`, V2Tests
    module checker coverage, CI workflow wiring, and Horde gates for position
    tracking, heatmap generation, unexplored-area detection, validation, and CI
    coverage.
- [x] **72.19.1.4** Create navigation stress-test bot (attempt to navigate
      between all known locations, report failures — pathfinding holes,
      unreachable areas)
  - Added `V2NavigationStressTestBot`, a V2Tests navigation stress bot that
    builds deterministic known-location route attempts, runs them through the
    headless bot harness route script, records successful routes, and emits
    per-route failure tags.
  - The bot directly covers attempt to navigate between all known locations,
    report failures, pathfinding holes, and unreachable areas with distinct
    result counters and formatted operator reports.
  - Added `NavigationStressTestBot.spec.cpp`,
    `NavigationStressTestBot_V2_Contract.json`, `navigation-stress-test-bot.md`,
    `check-v2-navigation-stress-test-bot.py`, V2Tests module checker coverage,
    CI workflow wiring, and Horde gates for known locations, route attempts,
    pathfinding-hole detection, unreachable-area detection, and CI coverage.
- [x] **72.19.1.5** Implement combat bot (engage enemies using weapon/ability
      combos, verify enemies are defeatable, measure difficulty)
  - Added `V2CombatBot`, a deterministic V2Tests combat bot that builds enemy
    profiles, weapon/ability combo plans, headless harness combat actions, and
    encounter results for automated playtesting.
  - The bot directly covers engage enemies using weapon/ability combos, verify
    enemies are defeatable, and measure difficulty through defeat-rate counters,
    combo coverage, per-encounter difficulty scores, and formatted QA reports.
  - Added `CombatBot.spec.cpp`, `CombatBot_V2_Contract.json`, `combat-bot.md`,
    `check-v2-combat-bot.py`, V2Tests module checker coverage, CI workflow
    wiring, and Horde gates for combo engagement, defeatable verification,
    difficulty measurement, and CI coverage.
- [x] **72.19.1.6** Create puzzle-solving bot (attempt interactive puzzles using
      brute-force and heuristic approaches, detect unsolvable puzzles)
  - Added `V2PuzzleSolvingBot`, a deterministic V2Tests puzzle bot that builds
    interactive puzzle profiles, brute-force and heuristic attempt plans,
    headless harness puzzle actions, solved puzzle results, and unsolvable
    detection outcomes.
  - The bot directly covers attempt interactive puzzles, brute-force approaches,
    heuristic approaches, and detect unsolvable puzzles through per-puzzle
    attempt counts, solved counters, unsolvable detection counters, and
    formatted QA reports.
  - Added `PuzzleSolvingBot.spec.cpp`, `PuzzleSolvingBot_V2_Contract.json`,
    `puzzle-solving-bot.md`, `check-v2-puzzle-solving-bot.py`, V2Tests module
    checker coverage, CI workflow wiring, and Horde gates for interactive
    attempts, brute-force, heuristic, unsolvable detection, and CI coverage.
- [x] **72.19.1.7** Implement soak test bot (run game for 48+ continuous hours,
      monitor memory usage trend, detect leaks, track FPS degradation)
  - Added `V2SoakTestBot`, a deterministic V2Tests soak bot that models a 48+
    continuous-hour game run, records hourly memory/FPS samples, evaluates
    memory trend, detects leaks, and tracks FPS degradation through the headless
    harness soak script.
  - The bot directly covers run game for 48+ continuous hours, monitor memory
    usage trend, detect leaks, and track FPS degradation with explicit issue
    tags and formatted QA anomaly reports.
  - Added `SoakTestBot.spec.cpp`, `SoakTestBot_V2_Contract.json`,
    `soak-test-bot.md`, `check-v2-soak-test-bot.py`, V2Tests module checker
    coverage, CI workflow wiring, and Horde gates for 48-hour run coverage,
    memory trend monitoring, leak detection, FPS degradation, and CI coverage.
- [x] **72.19.1.8** Create load test bot army (spawn N simultaneous bot clients
      connecting to multiplayer server, measure server performance under load)
  - Added `V2LoadTestBotArmy`, a deterministic V2Tests load bot army that spawns
    N simultaneous bot clients, connects them to the multiplayer server through
    the server integration harness, and records server performance samples under
    load.
  - The bot directly covers spawn N simultaneous bot clients, connecting to
    multiplayer server, and measure server performance under load through
    connected-client counts, server frame time, server FPS, and network
    throughput samples.
  - Added `LoadTestBotArmy.spec.cpp`, `LoadTestBotArmy_V2_Contract.json`,
    `load-test-bot-army.md`, `check-v2-load-test-bot-army.py`, V2Tests module
    checker coverage, CI workflow wiring, and Horde gates for client spawning,
    server connection, performance measurement, and CI coverage.
- [x] **72.19.1.9** Implement RL-trained exploration agent (reinforcement
      learning agent maximizing world state coverage, finds novel bugs faster
      than random)
  - Added `V2RLTrainedExplorationAgent`, a deterministic V2Tests RL-trained
    exploration agent that replays trained policy decisions through the headless
    bot harness, scores world-state novelty, and maximizes world state coverage
    through coverage heatmap samples.
  - The agent directly covers reinforcement learning agent behavior, maximizing
    world state coverage, random baseline comparison, coverage lift over random,
    trained policy Q-values, and finds novel bugs faster than random using
    explicit discovery-frame lead evidence.
  - Added `RLTrainedExplorationAgent.spec.cpp`,
    `RLTrainedExplorationAgent_V2_Contract.json`,
    `rl-trained-exploration-agent.md`,
    `check-v2-rl-trained-exploration-agent.py`, V2Tests module checker coverage,
    CI workflow wiring, and Horde gates for trained policy, coverage, random
    baseline comparison, novel bugs, and CI coverage.
- [x] **72.19.1.10** Create quest completion bot (attempt to complete all quests
      following objective markers, verify all quests are completable)
  - Added `V2QuestCompletionBot`, a deterministic V2Tests bot that builds a
    completable quest catalog, emits visible objective markers, follows those
    markers through the headless bot harness, and applies matching quest
    objective progress events.
  - The bot directly covers attempt to complete all quests, following objective
    markers, verify all quests are completable, quest objective progress events,
    completed quest lifecycle transitions, and per-quest completion reports.
  - Added `QuestCompletionBot.spec.cpp`, `QuestCompletionBot_V2_Contract.json`,
    `quest-completion-bot.md`, `check-v2-quest-completion-bot.py`, V2Tests
    module checker coverage, CI workflow wiring, and Horde gates for objective
    markers, progress events, all-quest completion, completable verification,
    and CI coverage.
- [x] **72.19.1.11** Implement economy bot (simulate player economy behavior at
      accelerated rate, detect inflation/exploits)
  - Added `V2EconomyBot`, a deterministic V2Tests economy bot that simulates
    player economy behavior at accelerated rate through the headless bot harness
    and translates quest rewards, vendor purchases, vendor sales, and trades
    into source/sink flow rules.
  - The bot directly covers detect inflation with accelerated supply snapshots,
    detect exploits with impossible-currency-gain and item duplication probes,
    inflation issue counts, exploit issue counts, and compact report output.
  - Added `EconomyBot.spec.cpp`, `EconomyBot_V2_Contract.json`,
    `economy-bot.md`, `check-v2-economy-bot.py`, V2Tests module checker
    coverage, CI workflow wiring, and Horde gates for accelerated behavior,
    inflation detection, exploit detection, reporting, and CI coverage.
- [x] **72.19.1.12** Create performance profiling bot (run standardized paths
      through performance-intensive areas, capture frame time data for
      regression comparison)
  - Added `V2PerformanceProfilingBot`, a deterministic V2Tests bot that can run
    standardized paths through performance-intensive areas using headless bot
    harness actions with frame-time capture markers.
  - The bot directly covers capture frame time data, p95 frame time summaries,
    hitch counts, baseline frame-time budgets, regression comparison, and
    explicit frame time regression detection over the configured threshold.
  - Added `PerformanceProfilingBot.spec.cpp`,
    `PerformanceProfilingBot_V2_Contract.json`, `performance-profiling-bot.md`,
    `check-v2-performance-profiling-bot.py`, V2Tests module checker coverage, CI
    workflow wiring, and Horde gates for standardized paths, frame-time capture,
    regression comparison, reporting, and CI coverage.
- [x] **72.19.1.13** Implement bot result reporting (generate reports: areas
      visited, crashes found, stuck spots, performance anomalies, with
      screenshots)
  - Added `V2BotResultReporting`, a deterministic V2Tests reporting layer that
    generates reports for areas visited, crashes found, stuck spots, and
    performance anomalies by aggregating random exploration, bot coverage
    mapping, and performance profiling bot outputs.
  - The report includes screenshot artifact references for area rows and finding
    rows, plus dashboard-ready counts for areas visited, crashes found, stuck
    spots, performance anomalies, and screenshots.
  - Added `BotResultReporting.spec.cpp`, `BotResultReporting_V2_Contract.json`,
    `bot-result-reporting.md`, `check-v2-bot-result-reporting.py`, V2Tests
    module checker coverage, CI workflow wiring, and Horde gates for areas
    visited, crash/stuck reporting, performance anomalies, screenshots, and CI
    coverage.
- [x] **72.19.1.14** Create CI integration for bot runs (run bot suite nightly,
      alert on new crashes or regressions)
  - Added `v2-bot-run-ci.json`, a deterministic CI manifest that defines the
    nightly bot suite schedule, required V2 playtesting automation filters,
    required checker coverage, and bot result report artifact root.
  - Wired `.github/workflows/v2-build.yml` with a nightly UTC schedule and
    `check-v2-bot-run-ci.py` validation, including an alert policy for new
    crashes, stuck spots, harness rejections, and performance regressions.
  - Added `bot-run-ci.md`, `check-v2-bot-run-ci.py`, CI workflow checker
    coverage, and Horde gates for the manifest, nightly schedule, bot suite,
    crash alerts, regression alerts, and CI wiring.
- [x] **72.19.1.15** Implement bot documentation and authoring guide for custom
      test scenarios
  - Added `bot-authoring-guide.md`, a custom test scenario authoring guide for
    scenario contracts, required fields, bot profile selection, harness actions,
    observation schemas, assertions, artifacts, review workflow, and validation
    commands.
  - Added `BotAuthoringGuide_V2_Contract.json` and
    `check-v2-bot-authoring-guide.py` to validate source-of-truth dependencies,
    the custom scenario contract, example scenario ids, required guide sections,
    CI workflow wiring, and TODO evidence.
  - Wired `.github/workflows/v2-build.yml`, `check-v2-ci-workflow.py`, and Horde
    gates for the authoring guide contract, source of truth, scenario schema,
    authoring workflow, validation commands, and CI coverage.

---

### 72.20 Binary Asset Version Control Strategy

Ecosystem-wide strategy for large binary game assets — Git LFS, Perforce, and
asset locking workflow.

#### 72.20.1 Binary Asset Version Control

- [x] **72.20.1.1** Implement Git LFS configuration for Maya engine assets
      (track _.png, _.jpg, _.exr, _.fbx, _.glb, _.wav, _.ogg, _.hdr by default)
  - Added V2 Maya engine asset Git LFS patterns in root `.gitattributes` and
    `V2/ue/.gitattributes` for `.png`, `.jpg`, `.exr`, `.fbx`, `.glb`, `.wav`,
    `.ogg`, and `.hdr` with writable binary Perforce mapping.
  - Added `v2-maya-engine-lfs.json` and `check-v2-maya-engine-lfs.py` to verify
    Git LFS availability, required root/local attributes, effective
    `git check-attr` results, CI workflow wiring, and TODO evidence.
  - Updated the V2 source-control LFS and asset-pipeline source-control
    validators plus Horde gates for manifest, root attributes, local attributes,
    required extensions, effective attributes, and CI coverage.
- [x] **72.20.1.2** Create .gitattributes configuration for all binary asset
      types (LFS tracking, diff drivers, merge strategies)
  - Expanded V2 `.gitattributes` coverage for Unreal packages, texture, HDR,
    compressed texture, source image, mesh, scene, audio, video, and font binary
    asset types with Git LFS tracking, `merge=lfs`, `assetdiff`, `assetkind`,
    and Perforce typemap metadata.
  - Added `v2-binary-asset-attributes.json` and
    `check-v2-binary-asset-attributes.py` to validate root/local attributes,
    effective `git check-attr` output, LFS tracking, diff drivers, merge
    strategies, CI workflow wiring, Horde gates, and TODO evidence.
  - Updated the V2 source-control LFS and asset-pipeline validators so the
    broader binary asset type set is enforced by existing gates as well as the
    new focused checker.
- [x] **72.20.1.3** Implement asset file locking workflow (lock binary file
      before editing, prevent concurrent modification, unlock on commit)
  - Added `v2_asset_locking_workflow.py`, a Git LFS locking helper with pre-edit
    `lock`, pre-commit staged binary asset lock verification, and post-commit
    unlock behavior for V2 binary assets.
  - Added `.husky/pre-commit` asset lock enforcement and `.husky/post-commit`
    unlock automation so binary assets must be locked by the current user before
    commit, locks held by another user block commits, and current-user locks are
    released after commit.
  - Added `v2-asset-locking-workflow.json`,
    `check-v2-asset-locking-workflow.py`, CI workflow wiring, and Horde gates
    for pre-edit locking, pre-commit validation, concurrent modification
    prevention, post-commit unlock, and TODO evidence.
- [x] **72.20.1.4** Create LFS storage backend configuration (S3-compatible
      storage, lifecycle policies for old versions, bandwidth optimization)
  - Added `v2-lfs-storage-backend.json`, a Vault-backed S3-compatible Git LFS
    backend configuration for `oshun-v2-lfs-assets` with object/lock prefixes,
    server-side encryption, object versioning, and object lock enabled.
  - Defined lifecycle policies for hot-to-infrequent-access transition, archive
    transition, old noncurrent version expiration while retaining locked
    objects, and incomplete multipart upload cleanup.
  - Added bandwidth optimization settings for Git LFS batch API, TUS transfers,
    recent fetches, CI skip-smudge, edge cache usage, concurrent transfer
    limits, plus `check-v2-lfs-storage-backend.py`, CI workflow wiring, and
    Horde gates.
- [x] **72.20.1.5** Implement Perforce integration guide (for studios preferring
      Perforce: P4 workspace setup, stream depot configuration, P4 Git Connector
      for hybrid workflow)
  - Added `perforce-integration-guide.md`, a studio-facing Perforce guide for P4
    workspace setup, stream depot configuration, typemap/locking, daily sync,
    and P4 Git Connector hybrid workflow.
  - Added `v2-perforce-integration-guide.json` and
    `check-v2-perforce-integration-guide.py` to validate source-of-truth
    dependencies, required streams, workspace environment, P4 commands, P4 Git
    Connector details, CI workflow wiring, and TODO evidence.
  - Wired the V2 build workflow and Horde gates for document presence, workspace
    setup, stream configuration, typemap coverage, Git connector coverage, and
    CI validation.
- [x] **72.20.1.6** Create asset size budget enforcement (CI check: warn if
      single asset exceeds 100MB, fail if exceeds 500MB, configurable limits)
  - Added `v2-asset-size-budget.json` with the V2 asset scope, binary asset
    extension coverage, 100 MiB warning threshold, 500 MiB failure threshold,
    environment/CLI configurable limits, and CI/Horde gate declarations.
  - Added `check-v2-asset-size-budget.py`, a tracked asset scanner that enforces
    per-asset size budgets from working-tree sizes, Git object sizes, and Git
    LFS pointer `size` metadata so skip-smudge CI still evaluates real payload
    size.
  - Wired the V2 build workflow, global CI workflow checker, and Horde gates for
    asset size budget enforcement, warning reporting, LFS pointer parsing,
    threshold validation, and TODO evidence.
- [x] **72.20.1.7** Implement asset deduplication (content-addressed storage to
      avoid storing identical textures/meshes multiple times)
  - Added `v2_asset_deduplication.py`, a tracked V2 binary asset scanner and
    packer that computes `sha256:` content addresses, groups identical
    textures/meshes by hash and byte size, selects a canonical asset path, and
    can materialize each unique payload once under `objects/sha256`.
  - Added `v2-asset-deduplication.json` and `check-v2-asset-deduplication.py` to
    validate content-addressed storage configuration, duplicate reporting, LFS
    pointer hash handling, pack self-tests, CI workflow wiring, and TODO
    evidence.
  - Wired the V2 build workflow, global CI workflow checker, and Horde gates for
    asset deduplication manifest validation, tool execution, content-addressed
    reports, duplicate group reporting, pack self-tests, and CI coverage.
- [x] **72.20.1.8** Create asset pruning tool (identify unused assets not
      referenced by any level/material, report for cleanup)
  - Added `v2_asset_pruning.py`, a report-only pruning scanner that inventories
    tracked V2 binary assets, checks level packages, material packages, optional
    AssetRegistry JSON, mod manifests, and tracked text sidecars for reference
    evidence, then emits unused asset cleanup candidates without deleting in CI.
  - Added `v2-asset-pruning.json` and `check-v2-asset-pruning.py` to validate
    reference sources, Unreal `/Game` and plugin soft-object tokens,
    text-file-relative references, report schema, cleanup safety, tool
    self-tests, CI workflow wiring, and TODO evidence.
  - Wired the V2 build workflow, global CI workflow checker, and Horde gates for
    asset pruning manifest validation, reference scans, unused asset reports,
    cleanup safety, and CI coverage.
- [x] **72.20.1.9** Implement shallow clone support for artists (clone only
      latest version of LFS files, not full history — faster onboarding)
  - Added `v2_artist_shallow_clone.py`, an artist onboarding plan tool that
    emits
    `GIT_LFS_SKIP_SMUDGE=1 git clone --depth 1 --single-branch --filter=blob:none`,
    sparse checkout setup, local LFS recent-ref configuration,
    `git lfs fetch --recent`, and `git lfs checkout V2/ue` commands while
    rejecting full-history `git lfs fetch --all` plans.
  - Added `artist-shallow-clone.md`, `v2-artist-shallow-clone.json`, and
    `check-v2-artist-shallow-clone.py` to validate the shallow clone policy,
    latest version of LFS files only, no full history fetch, sparse roots, guide
    content, tool self-tests, CI workflow wiring, and TODO evidence.
  - Wired the V2 build workflow, global CI workflow checker, and Horde gates for
    artist shallow clone manifest validation, depth-one clone plans, recent LFS
    fetches, sparse checkout, documentation, and CI coverage.
- [x] **72.20.1.10** Create binary diff visualization for assets (side-by-side
      image diff for textures, mesh wireframe diff for models)
  - Added `v2_binary_diff_visualization.py`, a binary asset comparison tool that
    generates side-by-side HTML reports for textures, creates 8-bit PNG
    `diff.png` pixel-difference images with a standard-library PNG reader and
    writer, and emits compact image metrics for review.
  - Added OBJ mesh wireframe diff support with `left-wireframe.svg`,
    `right-wireframe.svg`, and `wireframe-overlay.svg` outputs so model changes
    can be reviewed side-by-side and overlaid without launching Unreal.
  - Added `binary-diff-visualization.md`, `v2-binary-diff-visualization.json`,
    and `check-v2-binary-diff-visualization.py` to validate texture image diff,
    mesh wireframe diff, HTML report UI output, self-test fixtures, CI workflow
    wiring, Horde gates, and TODO evidence.
- [x] **72.20.1.11** Implement asset change notification (alert relevant team
      members when assets they use are modified)
  - Added `v2_asset_change_notification.py`, a dry-run notification planner that
    detects changed V2 binary assets from Git diffs or deterministic
    changed-list fixtures, filters through the binary asset attributes manifest,
    and routes alerts through direct asset ownership plus dependency evidence
    for content that uses the modified asset.
  - Added Slack, Microsoft Teams, email, and generic webhook JSON payload
    generation under `V2/ue/Saved/CI/AssetChangeNotifications`, while keeping CI
    in no-send dry-run mode with no webhook URLs stored in the repository and a
    fallback route to `@v2-asset-pipeline` for unmatched binary assets.
  - Added `asset-change-notification.md`, `v2-asset-change-notification.json`,
    and `check-v2-asset-change-notification.py` to validate routing rules,
    dependency scans, dry-run payloads, fallback coverage, CI workflow wiring,
    Horde gates, and TODO evidence.
- [x] **72.20.1.12** Create asset backup and disaster recovery (scheduled
      snapshots of LFS storage, geographic replication)
  - Added `v2_asset_backup_dr.py`, a Git LFS asset backup and disaster recovery
    planner that emits six-hour scheduled snapshot plans, versioned object
    backup commands, LFS lock and pointer inventory capture, SHA-256 checksum
    evidence, and replica restore-drill commands.
  - Added geographic replication policy for `us-west-2` and `eu-central-1`
    backup buckets, 6-hour RPO, 4-hour RTO, 30/180/365-day retention tiers,
    monthly restore drills, and manual approval before any replica promotion.
  - Added `asset-backup-disaster-recovery.md`, `v2-asset-backup-dr.json`,
    `.github/workflows/v2-asset-backup-dr.yml`, and
    `check-v2-asset-backup-dr.py` to validate snapshot scheduling, cross-region
    replication, restore-drill validation, CI workflow wiring, Horde gates, and
    TODO evidence.
- [x] **72.20.1.13** Implement large repository performance optimization (sparse
      checkout, partial clone, LFS batch API tuning)
  - Added `v2_large_repo_performance.py`, a profile and audit tool that emits
    artist, CI, and release command plans using `GIT_LFS_SKIP_SMUDGE=1`,
    `--filter=blob:none`, cone-mode sparse checkout roots, recent LFS fetches,
    and explicit rejection of full-history `git lfs fetch --all` in artist and
    CI profiles.
  - Added LFS batch API tuning for batch mode, TUS transfers, eight concurrent
    transfers, 60-second activity/keepalive timeouts, 7-day artist recent refs,
    and 30-day CI recent refs, plus Git maintenance commands for many-files
    mode, untracked cache, commit-graph changed paths, and multi-pack-index
    bitmaps.
  - Added `large-repo-performance.md`, `v2-large-repo-performance.json`, and
    `check-v2-large-repo-performance.py` to validate sparse checkout, partial
    clone, LFS batch tuning, Git maintenance, CI workflow wiring, Horde gates,
    and TODO evidence.
- [x] **72.20.1.14** Create asset version control documentation and artist
      workflow guide
  - Added `asset-version-control-artist-workflow.md`, an end-to-end artist
    runbook covering onboarding, daily sync, sparse checkout, partial clone, LFS
    batch tuning, binary asset locking, new asset intake, size budgets, binary
    diff review, change notification, cleanup and recovery, disaster recovery,
    Perforce studio operation, validation, and troubleshooting.
  - Added `v2-asset-version-control-artist-workflow.json` to bind the guide to
    the completed V2 asset version-control manifests and declare required artist
    commands, workflow sections, lock-before-edit policy, no
    `git lfs fetch --all` onboarding policy, sparse profile usage, binary diff
    review, and backup/DR expectations.
  - Added `check-v2-asset-version-control-artist-workflow.py` plus CI workflow
    and Horde wiring to validate the documentation, onboarding flow,
    lock/edit/submit path, review and recovery sections, dependencies, and TODO
    evidence.
- [x] **72.20.1.15** Implement asset version control CI validation (verify LFS
      pointers are valid, no accidental binary commits to Git)
  - Added `check-v2-asset-version-control-ci-validation.py`, a scoped V2 binary
    asset CI validator that scans tracked `V2/ue` binary asset paths from
    `v2-binary-asset-attributes.json`, checks effective `filter=lfs`,
    `diff=lfs`, `merge=lfs`, and `-text` attributes, and validates Git LFS
    pointer `version`, `oid sha256`, and positive `size` fields.
  - Added `v2-asset-version-control-ci-validation.json` and
    `asset-version-control-ci-validation.md` to define the no-inline-Git-blob
    policy, malformed-pointer rejection, JSON report output, and
    `git add --renormalize <asset>` remediation.
  - Renormalized existing V2 thumbnail PNG assets into Git LFS pointers so the
    new gate proves there are no accidental binary commits to Git under the V2
    asset scope, then wired the checker into the V2 build workflow, global CI
    checker, Horde gates, and TODO evidence.

---

### 72.21 Platform Store & SDK Integration

Abstract platform APIs (Steam, EGS, PlayStation, Xbox, GOG) behind a unified
interface for achievements, presence, social, and store overlay.

#### 72.21.1 Platform SDK Abstraction

- [x] **72.21.1.1** Design platform abstraction layer API (unified interface for
      achievements, friends, presence, overlay, cloud saves, voice chat, store —
      implemented per platform) — Platform SDK abstraction implemented with
      `FV2PlatformSdkAbstractionSpec`, provider bindings for Steamworks, EOS,
      GOG Galaxy, PlayStation SDK, Xbox GDK, and Nintendo SDK, request/result
      routing helpers, contract
      `V2/ue/Content/V2/Online/PlatformSdkAbstraction_V2_Contract.json`, doc
      `V2/docs/online/platform-sdk-abstraction.md`, checker
      `V2/ue/Tools/check-v2-platform-sdk-abstraction.py`, automation spec
      `V2.Online.PlatformSdkAbstraction.AssetContract`, CI workflow wiring, and
      Horde gate `platformSdkAbstraction`.
- [x] **72.21.1.2** Implement Steam SDK integration (Steamworks: achievements,
      friends, rich presence, overlay, cloud saves, matchmaking, workshop) —
      Steamworks SDK integration implemented with
      `FV2SteamworksSdkIntegrationConfig`, feature bindings for
      `ISteamUserStats`, `ISteamFriends`, `ISteamRemoteStorage`,
      `ISteamMatchmaking`, and `ISteamUGC`, request/operation planning through
      `V2SteamworksSdkBridge`, Workshop delegation to `V2SteamWorkshopBridge`,
      contract
      `V2/ue/Content/V2/Online/SteamworksSdkIntegration_V2_Contract.json`, doc
      `V2/docs/online/steamworks-sdk-integration.md`, checker
      `V2/ue/Tools/check-v2-steamworks-sdk-integration.py`, automation spec
      `V2.Online.SteamworksSdkIntegration.AssetContract`, CI workflow wiring,
      and Horde gate `steamworksSdkIntegration`.
- [x] **72.21.1.3** Create Epic Online Services integration (EOS: achievements,
      friends, presence, matchmaking, voice, anti-cheat — free and cross-engine)
      — EOS SDK integration implemented with `FV2EosSdkIntegrationConfig`,
      feature bindings for `EOS_Achievements`, `EOS_Friends`, `EOS_Presence`,
      `EOS_Lobby`/`EOS_Sessions`, `EOS_RTC`/`EOS_RTCAudio`, and
      `EOS_AntiCheatClient`/`EOS_AntiCheatServer`, request/operation planning
      through `V2EosSdkBridge`, contract
      `V2/ue/Content/V2/Online/EosSdkIntegration_V2_Contract.json`, doc
      `V2/docs/online/eos-sdk-integration.md`, checker
      `V2/ue/Tools/check-v2-eos-sdk-integration.py`, automation spec
      `V2.Online.EosSdkIntegration.AssetContract`, CI workflow wiring, and Horde
      gate `eosSdkIntegration`.
- [x] **72.21.1.4** Implement GOG Galaxy SDK integration (achievements, friends,
      cloud saves, leaderboards, multiplayer) — GOG Galaxy SDK integration
      implemented with `FV2GogGalaxySdkIntegrationConfig`, feature bindings for
      `galaxy::api::IStats`, `galaxy::api::IFriends`, `galaxy::api::IStorage`,
      and `galaxy::api::IMatchmaking`, request/operation planning through
      `V2GogGalaxySdkBridge`, contract
      `V2/ue/Content/V2/Online/GogGalaxySdkIntegration_V2_Contract.json`, doc
      `V2/docs/online/gog-galaxy-sdk-integration.md`, checker
      `V2/ue/Tools/check-v2-gog-galaxy-sdk-integration.py`, automation spec
      `V2.Online.GogGalaxySdkIntegration.AssetContract`, CI workflow wiring, and
      Horde gate `gogGalaxySdkIntegration`.
- [x] **72.21.1.5** Create PlayStation SDK integration stub (requires NDA —
      define interface for: trophies, activities, DualSense haptics, PSN
      friends, PS Plus) — PlayStation SDK stub implemented with
      `FV2PlayStationSdkStubConfig`, public stub interfaces for trophies,
      activities, DualSense haptics, PSN friends, and PS Plus, NDA-isolated
      restricted adapter targets under
      `Restricted/NotForLicensees/Online/PlatformSDK/PlayStation`,
      request/operation planning through `V2PlayStationSdkStubBridge`, contract
      `V2/ue/Content/V2/Online/PlayStationSdkStub_V2_Contract.json`, doc
      `V2/docs/online/playstation-sdk-stub.md`, checker
      `V2/ue/Tools/check-v2-playstation-sdk-stub.py`, automation spec
      `V2.Online.PlayStationSdkStub.AssetContract`, CI workflow wiring, and
      Horde gate `playStationSdkStub`.
- [x] **72.21.1.6** Implement Xbox GDK integration stub (requires NDA — define
      interface for: achievements, Xbox Live friends, Quick Resume, Smart
      Delivery, Game Pass) — Xbox GDK SDK stub implemented with
      `FV2XboxGdkSdkStubConfig`, public stub interfaces for achievements, Xbox
      Live friends, Quick Resume, Smart Delivery, and Game Pass, NDA-isolated
      restricted adapter targets under
      `Restricted/NotForLicensees/Online/PlatformSDK/XboxGDK`, request/operation
      planning through `V2XboxGdkSdkStubBridge`, contract
      `V2/ue/Content/V2/Online/XboxGdkSdkStub_V2_Contract.json`, doc
      `V2/docs/online/xbox-gdk-sdk-stub.md`, checker
      `V2/ue/Tools/check-v2-xbox-gdk-sdk-stub.py`, automation spec
      `V2.Online.XboxGdkSdkStub.AssetContract`, CI workflow wiring, and Horde
      gate `xboxGdkSdkStub`.
- [x] **72.21.1.7** Create achievement/trophy system (define achievements in
      platform-agnostic format, auto-unlock on correct platform API) -
      achievement/trophy platform routing implemented with
      `FV2AchievementTrophyPlatformRoutingPolicy`,
      `FV2AchievementTrophyUnlockEvent`, and
      `FV2AchievementTrophyPlatformUnlockPlan`, source linkage to
      `V2/ue/Content/V2/Persistence/Profile/AchievementTrophies_V2_Contract.json`,
      provider routes for Steamworks, EOS, GOG Galaxy, PlayStation SDK, and Xbox
      GDK, committed-progress-only auto-unlock planning through
      `EV2PlatformSdkRequestType::UnlockAchievement`, duplicate suppression,
      fail-closed platform API guards, contract
      `V2/ue/Content/V2/Online/AchievementTrophyPlatformRouting_V2_Contract.json`,
      doc `V2/docs/online/achievement-trophy-platform-routing.md`, checker
      `V2/ue/Tools/check-v2-achievement-trophy-platform-routing.py`, automation
      spec `V2.Online.AchievementTrophyPlatformRouting.AssetContract`, CI
      workflow wiring, and Horde gate `achievementTrophyPlatformRouting`.
- [x] **72.21.1.8** Implement rich presence system (show current activity in
      platform friends list: "Playing Level 5 — Boss Fight") - rich presence
      routing implemented with `FV2RichPresenceRoutingPolicy`,
      `FV2RichPresenceActivity`, and `FV2RichPresencePlatformPayload`, provider
      routes for Steamworks, EOS, GOG Galaxy, PlayStation SDK, and Xbox GDK,
      platform friends-list display text such as `Playing Level 5 - Boss Fight`,
      streamer-mode redaction, platform-account/link validation, sanitized
      payload JSON through `EV2PlatformSdkRequestType::SetPresence`, contract
      `V2/ue/Content/V2/Online/RichPresenceRouting_V2_Contract.json`, doc
      `V2/docs/online/rich-presence-routing.md`, checker
      `V2/ue/Tools/check-v2-rich-presence-routing.py`, automation spec
      `V2.Online.RichPresenceRouting.AssetContract`, CI workflow wiring, and
      Horde gate `richPresenceRouting`.
- [x] **72.21.1.9** Create platform friend list integration (show friends
      playing same game, invite to session, join friend's game) - platform
      friend-list integration implemented with
      `FV2PlatformFriendListIntegrationPolicy`, `FV2PlatformFriendEntry`,
      `FV2PlatformFriendListRequest`, and `FV2PlatformFriendListPlan`, provider
      routes for Steamworks, EOS, GOG Galaxy, PlayStation SDK, and Xbox GDK,
      same-game filtering for `Oshun.V2`, native platform invite and join
      command routing through `EV2PlatformSdkRequestType::ReadFriends`, missing
      target/session and joinability fail-closed guards, contract
      `V2/ue/Content/V2/Online/PlatformFriendListIntegration_V2_Contract.json`,
      doc `V2/docs/online/platform-friend-list-integration.md`, checker
      `V2/ue/Tools/check-v2-platform-friend-list-integration.py`, automation
      spec `V2.Online.PlatformFriendListIntegration.AssetContract`, CI workflow
      wiring, and Horde gate `platformFriendListIntegration`.
- [x] **72.21.1.10** Implement platform cloud save integration (auto-sync save
      files to platform cloud, conflict resolution) - platform cloud-save sync
      implemented with `FV2PlatformCloudSaveSyncPolicy`,
      `FV2PlatformCloudSaveProviderRoute`, `FV2PlatformCloudSaveFileState`,
      `FV2PlatformCloudSaveSyncRequest`, and `FV2PlatformCloudSaveSyncPlan`,
      provider routes for Steamworks, EOS Player Data Storage, GOG Galaxy,
      PlayStation saved data, and Xbox connected storage, auto-sync write/read
      routing through `EV2PlatformSdkRequestType::ReadCloudSave` and
      `EV2PlatformSdkRequestType::WriteCloudSave`, persistence conflict
      delegation to `Save.CloudConflictResolution`, contract
      `V2/ue/Content/V2/Online/PlatformCloudSaveSync_V2_Contract.json`, doc
      `V2/docs/online/platform-cloud-save-sync.md`, checker
      `V2/ue/Tools/check-v2-platform-cloud-save-sync.py`, automation spec
      `V2.Online.PlatformCloudSaveSync.AssetContract`, CI workflow wiring, and
      Horde gate `platformCloudSaveSync`.
- [x] **72.21.1.11** Create platform overlay integration (detect when platform
      overlay is active, pause game, handle focus changes) - platform overlay
      integration implemented with `FV2PlatformOverlayIntegrationPolicy`,
      `FV2PlatformOverlayProviderRoute`, `FV2PlatformOverlayRuntimeState`,
      `FV2PlatformOverlayRequest`, and `FV2PlatformOverlayPlan`, provider routes
      for Steamworks, EOS UI, GOG Galaxy overlay, PlayStation system UI, and
      Xbox Game Bar, active overlay/focus callback handling, gameplay
      pause/resume and input focus suppress/restore actions, user-gesture guard
      for `EV2PlatformSdkRequestType::ShowOverlay`, contract
      `V2/ue/Content/V2/Online/PlatformOverlayIntegration_V2_Contract.json`, doc
      `V2/docs/online/platform-overlay-integration.md`, checker
      `V2/ue/Tools/check-v2-platform-overlay-integration.py`, automation spec
      `V2.Online.PlatformOverlayIntegration.AssetContract`, CI workflow wiring,
      and Horde gate `platformOverlayIntegration`.
- [x] **72.21.1.12** Implement platform entitlement verification (check player
      owns game/DLC on current platform before loading content) — platform
      entitlement verification implemented with
      `FV2PlatformEntitlementVerificationPolicy`,
      `FV2PlatformEntitlementProviderRoute`,
      `FV2PlatformEntitlementContentRequirement`,
      `FV2PlatformEntitlementReceipt`,
      `FV2PlatformEntitlementVerificationRequest`, and
      `FV2PlatformEntitlementVerificationPlan`; Steamworks, EOS, GOG Galaxy,
      PlayStation SDK stub, and Xbox GDK stub route coverage; signed
      current-platform receipt validation; fail-closed content load gate
      `ContentLoad.PlatformEntitlementGate`; contract
      `V2/ue/Content/V2/Online/PlatformEntitlementVerification_V2_Contract.json`;
      doc `V2/docs/online/platform-entitlement-verification.md`; checker
      `V2/ue/Tools/check-v2-platform-entitlement-verification.py`; automation
      spec `V2.Online.PlatformEntitlementVerification.AssetContract`; CI
      workflow wiring; and Horde gate `platformEntitlementVerification`.
- [x] **72.21.1.13** Create platform-specific input prompt icons (show
      PlayStation button icons on PS, Xbox on Xbox, keyboard on PC — auto-detect
      active input device) — platform input prompt icons implemented with
      `FV2PlatformInputPromptIconPolicy`, `FV2PlatformInputPromptIconRoute`,
      `FV2PlatformInputPromptIconRequest`, and
      `FV2ResolvedPlatformInputPromptIcon`; default route coverage for
      keyboard/mouse, generic PC gamepad, PC DualSense, PC Xbox, PS5 DualSense,
      Xbox Series, and Switch2; active-device tag matching for DualSense/XInput;
      native PlayStation, Xbox, Switch, generic, and keyboard glyph set
      resolution; keyboard/mouse fallback for unknown platforms or missing
      glyphs; Blueprint helpers on `UV2UIBlueprintLibrary`; contract
      `V2/ue/Content/V2/UI/Input/PlatformInputPromptIcons_V2_Contract.json`; doc
      `V2/docs/input/platform-input-prompt-icons.md`; checker
      `V2/ue/Tools/check-v2-platform-input-prompt-icons.py`; automation spec
      `V2.UI.PlatformInputPromptIcons.AssetContract`; CI workflow wiring; and
      Horde gate `platformInputPromptIcons`.
- [x] **72.21.1.14** Implement platform compliance testing checklist automation
      (generate checklist status for TRC/XR/LotCheck requirements) — platform
      compliance checklist automation implemented with
      `FV2PlatformComplianceChecklistPolicy`,
      `FV2PlatformComplianceChecklistRequirement`,
      `FV2PlatformComplianceChecklistEvidence`,
      `FV2PlatformComplianceChecklistRequest`,
      `FV2PlatformComplianceChecklistItemStatus`, and
      `FV2PlatformComplianceChecklistReport`; public, non-proprietary checklist
      coverage for PlayStation TRC, Xbox XR, and Nintendo LotCheck; fresh
      evidence-tag matching; manual cert signoff enforcement; fail-closed
      blocking on missing, stale, or failed evidence; Blueprint helpers on
      `UV2OnlineServicesBlueprintLibrary`; contract
      `V2/ue/Content/V2/Online/PlatformComplianceChecklist_V2_Contract.json`;
      doc `V2/docs/online/platform-compliance-checklist.md`; checker
      `V2/ue/Tools/check-v2-platform-compliance-checklist.py`; automation spec
      `V2.Online.PlatformComplianceChecklist.AssetContract`; CI workflow wiring;
      and Horde gate `platformComplianceChecklist`.
- [x] **72.21.1.15** Create platform SDK documentation and per-platform
      integration guide — platform SDK documentation and per-platform
      integration guide implemented with shared runtime boundary guidance for
      `FV2PlatformSdkAbstractionSpec`, `FV2PlatformSdkRequest`, and
      `FV2PlatformSdkResult`; provider setup matrix for Steamworks, Epic Online
      Services, GOG Galaxy, PlayStation SDK, Xbox GDK, and Nintendo SDK; PC and
      console integration notes that keep SDK headers out of gameplay modules
      and NDA code behind platform modules; feature routing links for
      achievements/trophies, rich presence, friends, cloud saves, overlays,
      entitlements, and compliance; compliance evidence policy for PlayStation
      TRC, Xbox XR, and Nintendo LotCheck; doc
      `V2/docs/online/platform-sdk-integration-guide.md`; contract
      `V2/ue/Content/V2/Online/PlatformSdkIntegrationGuide_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-platform-sdk-integration-guide.py`; CI
      workflow wiring; and Horde gate `platformSdkIntegrationGuide`.

---

### 72.22 Adaptive Music System (Maya Engine)

Horizontal re-sequencing, vertical layering, beat-synchronized transitions, and
combat/exploration intensity curves — specifically for Maya.

#### 72.22.1 Adaptive Music Engine

- [x] **72.22.1.1** Implement music state machine (exploration, tension, combat,
      victory, defeat, menu — with substates and transitions) — adaptive music
      state machine implemented in `V2Audio` with `EV2AdaptiveMusicState`,
      `FV2AdaptiveMusicSubstate`, `FV2AdaptiveMusicStateDefinition`,
      `FV2AdaptiveMusicTransitionRule`, `FV2AdaptiveMusicStateRequest`,
      `FV2ResolvedAdaptiveMusicState`, and `FV2AdaptiveMusicStateMachine`;
      default states for exploration, tension, combat, victory, defeat, and menu
      with two substates each; explicit transition graph for MenuToExploration,
      ExplorationToTension, TensionToCombat, CombatToVictory, CombatToDefeat,
      VictoryToMenu, DefeatToMenu, CombatToTension, and TensionToExploration;
      dynamic music resolver output; config asset and `UV2AudioSubsystem`
      registration/evaluation; snapshot evidence; automation spec
      `V2.Audio.AdaptiveMusicStateMachine.AssetContract`; contract
      `V2/ue/Content/V2/Audio/AdaptiveMusicStateMachine_V2_Contract.json`; doc
      `V2/docs/audio/adaptive-music-state-machine.md`; checker
      `V2/ue/Tools/check-v2-adaptive-music-state-machine.py`; CI workflow
      wiring; and Horde gate `adaptiveMusicStateMachine`.
- [x] **72.22.1.2** Create horizontal re-sequencing (swap music sections based
      on game state: verse → chorus → bridge selected by intensity level) —
      horizontal music re-sequencing implemented in `V2Audio` with
      `EV2HorizontalMusicSectionRole`, `FV2HorizontalMusicSection`,
      `FV2HorizontalMusicResequenceRule`, `FV2HorizontalMusicResequenceRequest`,
      `FV2ResolvedHorizontalMusicSection`, and
      `FV2HorizontalMusicResequencingArrangement`; default verse, chorus, and
      bridge section coverage for exploration, tension, and combat; explicit
      intensity-selected rules for ExplorationVerseToChorus,
      ExplorationChorusToBridge, TensionVerseToChorus, TensionChorusToBridge,
      CombatVerseToChorus, and CombatChorusToBridge; config asset registration;
      `UV2AudioSubsystem::EvaluateHorizontalMusicSection`; runtime snapshot
      evidence; automation spec
      `V2.Audio.HorizontalMusicResequencing.AssetContract`; contract
      `V2/ue/Content/V2/Audio/HorizontalMusicResequencing_V2_Contract.json`; doc
      `V2/docs/audio/horizontal-music-resequencing.md`; checker
      `V2/ue/Tools/check-v2-horizontal-music-resequencing.py`; CI workflow
      wiring; and Horde gate `horizontalMusicResequencing`.
- [x] **72.22.1.3** Implement vertical layering (add/remove instrument layers
      based on game state: drums enter during combat, strings swell at sunset) —
      vertical music layering implemented in `V2Audio` with
      `EV2VerticalMusicInstrumentLayer`, `FV2VerticalMusicLayerSpec`,
      `FV2VerticalMusicLayerRequest`, `FV2ResolvedVerticalMusicLayers`, and
      `FV2VerticalMusicLayeringArrangement`; default AmbientPad, Bass, Drums,
      and Strings instrument coverage; exploration, tension, and combat state
      coverage; explicit combat drums through `Music.Layer.Combat.Drums`; sunset
      strings through `Context.Sunset`; add/remove active and removed layer
      results; config asset registration; `UV2AudioSubsystem`
      `EvaluateVerticalMusicLayers`; runtime snapshot evidence; automation spec
      `V2.Audio.VerticalMusicLayering.AssetContract`; contract
      `V2/ue/Content/V2/Audio/VerticalMusicLayering_V2_Contract.json`; doc
      `V2/docs/audio/vertical-music-layering.md`; checker
      `V2/ue/Tools/check-v2-vertical-music-layering.py`; CI workflow wiring; and
      Horde gate `verticalMusicLayering`.
- [x] **72.22.1.4** Create beat-synchronized transitions (wait for next musical
      beat/bar/phrase boundary before switching music segments) —
      beat-synchronized transitions implemented in `V2Audio` with
      `EV2MusicSyncBoundary`, `FV2BeatSynchronizedTransitionRule`,
      `FV2BeatSynchronizedTransitionRequest`,
      `FV2ResolvedBeatSynchronizedTransition`, and
      `FV2BeatSynchronizedTransitionPlan`; default Beat, Bar, and Phrase
      boundary coverage; BPM-based wait calculation for next boundary;
      horizontal section transitions and combat KO beat transitions; config
      asset registration; `UV2AudioSubsystem`
      `ScheduleBeatSynchronizedTransition`; runtime snapshot evidence;
      automation spec `V2.Audio.BeatSynchronizedTransitions.AssetContract`;
      contract
      `V2/ue/Content/V2/Audio/BeatSynchronizedTransitions_V2_Contract.json`; doc
      `V2/docs/audio/beat-synchronized-transitions.md`; checker
      `V2/ue/Tools/check-v2-beat-synchronized-transitions.py`; CI workflow
      wiring; and Horde gate `beatSynchronizedTransitions`.
- [x] **72.22.1.5** Implement tempo detection and beat tracking (analyze music
      clips for BPM, detect beat positions for synchronization) — tempo beat
      tracking implemented in `V2Audio` with `FV2TempoDetectionSourceClip`,
      `FV2DetectedBeatMarker`, `FV2TempoDetectionRequest`,
      `FV2TempoDetectionResult`, and `FV2TempoBeatTrackingCatalog`; default
      exploration and combat music clip coverage; deterministic BPM analysis;
      ordered beat markers and downbeat positions for synchronization; beat-sync
      integration flagging; config asset registration; `UV2AudioSubsystem`
      `AnalyzeTempoBeatTrackingClip`; runtime snapshot evidence; automation spec
      `V2.Audio.TempoBeatTracking.AssetContract`; contract
      `V2/ue/Content/V2/Audio/TempoBeatTracking_V2_Contract.json`; doc
      `V2/docs/audio/tempo-beat-tracking.md`; checker
      `V2/ue/Tools/check-v2-tempo-beat-tracking.py`; CI workflow wiring; and
      Horde gate `tempoBeatTracking`.
- [x] **72.22.1.6** Create music intensity curves (map game intensity metric
      0.0-1.0 to music layers and sections: low → ambient, high → full
      orchestra) — music intensity curves implemented in `V2Audio` with
      `FV2MusicIntensityCurveBand`, `FV2MusicIntensityCurveRequest`,
      `FV2ResolvedMusicIntensityCurve`, and `FV2MusicIntensityCurveCatalog`;
      default low ambient, mid tension, and high full-orchestra bands;
      normalized game intensity mapping; horizontal section targets; vertical
      layer targets; config asset registration; `UV2AudioSubsystem`
      `EvaluateMusicIntensityCurve`; runtime snapshot evidence; automation spec
      `V2.Audio.MusicIntensityCurves.AssetContract`; contract
      `V2/ue/Content/V2/Audio/MusicIntensityCurves_V2_Contract.json`; doc
      `V2/docs/audio/music-intensity-curves.md`; checker
      `V2/ue/Tools/check-v2-music-intensity-curves.py`; CI workflow wiring; and
      Horde gate `musicIntensityCurves`.
- [x] **72.22.1.7** Implement music stinger system (short one-shot musical
      phrases triggered by events: item pickup, achievement, danger spotted) —
      music stinger system implemented in `V2Audio` with
      `EV2MusicStingerTriggerKind`, `FV2MusicStingerBinding`,
      `FV2MusicStingerRequest`, `FV2ResolvedMusicStinger`, and
      `FV2MusicStingerCatalog`; item pickup, achievement unlocked, and danger
      spotted trigger coverage; short one-shot phrase bindings; cooldown guard;
      config asset registration; `UV2AudioSubsystem` `TriggerMusicStinger`;
      runtime snapshot evidence; automation spec
      `V2.Audio.MusicStingers.AssetContract`; contract
      `V2/ue/Content/V2/Audio/MusicStingers_V2_Contract.json`; doc
      `V2/docs/audio/music-stingers.md`; checker
      `V2/ue/Tools/check-v2-music-stingers.py`; CI workflow wiring; and Horde
      gate `musicStingers`.
- [x] **72.22.1.8** Create cross-fade and transition effects (configurable fade
      duration, fade curves, overlap for smooth transitions) — cross-fade
      transition effects implemented in `V2Audio` with `EV2CrossFadeCurve`,
      `FV2CrossFadeTransitionEffectRule`, `FV2CrossFadeTransitionEffectRequest`,
      `FV2ResolvedCrossFadeTransitionEffect`, and
      `FV2CrossFadeTransitionEffectCatalog`; configurable fade duration
      overrides; linear, equal-power, and ease-in-out fade curve coverage;
      overlap windows for smooth transitions; config asset registration;
      `UV2AudioSubsystem` `ScheduleCrossFadeTransitionEffect`; runtime snapshot
      evidence; automation spec
      `V2.Audio.CrossFadeTransitionEffects.AssetContract`; contract
      `V2/ue/Content/V2/Audio/CrossFadeTransitionEffects_V2_Contract.json`; doc
      `V2/docs/audio/cross-fade-transition-effects.md`; checker
      `V2/ue/Tools/check-v2-cross-fade-transition-effects.py`; CI workflow
      wiring; and Horde gate `crossFadeTransitionEffects`.
- [x] **72.22.1.9** Implement music memory management (stream large music files
      from disk, preload upcoming sections based on predicted state) — music
      memory management implemented in `V2Audio` with
      `FV2MusicStreamingSectionSpec`, `FV2MusicMemoryManagementRequest`,
      `FV2ResolvedMusicMemoryManagementPlan`, and
      `FV2MusicMemoryManagementCatalog`; large music file streaming from disk;
      first-chunk resident memory budgeting; predicted-state preloads for
      tension, combat, and defeat sections; config asset registration;
      `UV2AudioSubsystem` `ScheduleMusicMemoryManagement`; runtime snapshot
      evidence; automation spec `V2.Audio.MusicMemoryManagement.AssetContract`;
      contract `V2/ue/Content/V2/Audio/MusicMemoryManagement_V2_Contract.json`;
      doc `V2/docs/audio/music-memory-management.md`; checker
      `V2/ue/Tools/check-v2-music-memory-management.py`; CI workflow wiring; and
      Horde gate `musicMemoryManagement`.
- [x] **72.22.1.10** Create music ducking system (reduce music volume during
      dialogue, explosions, important sound effects — sidechain compression) —
      music ducking system implemented in `V2Audio` with
      `EV2MusicDuckingTriggerKind`, `FV2MusicDuckingRule`,
      `FV2MusicDuckingRequest`, `FV2ResolvedMusicDucking`, and
      `FV2MusicDuckingCatalog`; dialogue, explosion, and important SFX trigger
      coverage; sidechain compression rules for `V2.DynamicMusic`; config asset
      registration; `UV2AudioSubsystem` `RegisterMusicDuckingCatalog`,
      `ApplyMusicDucking`, and `ClearMusicDucking`; active-mix attenuation and
      runtime snapshot evidence; automation spec
      `V2.Audio.MusicDucking.AssetContract`; contract
      `V2/ue/Content/V2/Audio/MusicDucking_V2_Contract.json`; doc
      `V2/docs/audio/music-ducking.md`; checker
      `V2/ue/Tools/check-v2-music-ducking.py`; CI workflow wiring; and Horde
      gate `musicDucking`.
- [x] **72.22.1.11** Implement music playlist system (multiple tracks per state,
      shuffle/sequential ordering, avoid repeats) — music playlist system
      implemented in `V2Audio` with `EV2MusicPlaylistOrderMode`,
      `FV2MusicPlaylistTrack`, `FV2MusicPlaylist`, `FV2MusicPlaylistRequest`,
      `FV2ResolvedMusicPlaylistTrack`, and `FV2MusicPlaylistCatalog`; multiple
      exploration, tension, and combat tracks; sequential and shuffle playlist
      ordering; immediate-repeat avoidance through recent-track filtering;
      config asset registration; `UV2AudioSubsystem`
      `RegisterMusicPlaylistCatalog` and `SelectMusicPlaylistTrack`; runtime
      snapshot evidence; automation spec `V2.Audio.MusicPlaylist.AssetContract`;
      contract `V2/ue/Content/V2/Audio/MusicPlaylist_V2_Contract.json`; doc
      `V2/docs/audio/music-playlist.md`; checker
      `V2/ue/Tools/check-v2-music-playlist.py`; CI workflow wiring; and Horde
      gate `musicPlaylist`.
- [x] **72.22.1.12** Create music authoring interface (define music states,
      transitions, layer assignments, test in-engine with game state simulation)
      — music authoring interface implemented in `V2Editor` with
      `EV2EditorToolSurface::MusicAuthoring`, `Tool.MusicAuthoring`,
      `FV2MusicAuthoringWidgetSpec`, `FV2MusicAuthoringStateRow`,
      `FV2MusicAuthoringTransitionRow`, `FV2MusicAuthoringLayerAssignmentRow`,
      `FV2MusicAuthoringSimulationRequest`, `FV2MusicAuthoringSimulationResult`,
      and `FV2MusicAuthoringInterfaceModel`; `V2Audio`-backed adaptive state
      graph, transition editor, layer assignment matrix, and game state
      simulation preview; focused automation spec
      `V2.Editor.Music.AuthoringInterface`; contract
      `V2/ue/Content/V2/Audio/MusicAuthoringInterface_V2_Contract.json`; doc
      `V2/docs/audio/music-authoring-interface.md`; checker
      `V2/ue/Tools/check-v2-music-authoring-interface.py`; CI workflow wiring;
      and Horde gate `musicAuthoringInterface`.
- [x] **72.22.1.13** Implement Wwise/FMOD integration as alternative backend
      (for studios preferring middleware over custom adaptive music) — audio
      middleware backend implemented in `V2Audio` with
      `EV2AudioMiddlewareBackend`, `EV2AudioMiddlewareEventKind`,
      `FV2AudioMiddlewareBankSpec`, `FV2AudioMiddlewareEventMapping`,
      `FV2AudioMiddlewareEventRequest`, `FV2ResolvedAudioMiddlewareEvent`,
      `FV2AudioMiddlewareBackendProfile`, and
      `FV2AudioMiddlewareBackendCatalog`; optional Wwise and FMOD profiles;
      native runtime fallback; disabled-by-default ADR/licensing gates; adaptive
      music state, transition, and layer assignment mappings; config and
      `UV2AudioSubsystem` registration/resolution; runtime snapshot evidence;
      automation spec `V2.Audio.MiddlewareBackend.AssetContract`; contract
      `V2/ue/Content/V2/Audio/AudioMiddlewareBackend_V2_Contract.json`; doc
      `V2/docs/audio/audio-middleware-backend.md`; checker
      `V2/ue/Tools/check-v2-audio-middleware-backend.py`; CI workflow wiring;
      and Horde gate `audioMiddlewareBackend`.
- [x] **72.22.1.14** Create music debugging overlay (show current state, active
      layers, upcoming transition, beat counter) — music debugging overlay
      implemented in `V2Editor` with `EV2EditorToolSurface::MusicDebugOverlay`,
      `Tool.MusicDebugOverlay`, `FV2MusicDebugOverlayWidgetSpec`,
      `FV2MusicDebugOverlayRequest`, `FV2MusicDebugOverlayActiveLayerRow`,
      `FV2MusicDebugOverlayTransitionPreview`,
      `FV2MusicDebugOverlayBeatCounter`, and `FV2MusicDebugOverlayFrame`;
      current state panel, active layer rows, upcoming beat-synchronized
      transition preview, and beat counter evidence; focused automation spec
      `V2.Editor.Music.DebugOverlay`; contract
      `V2/ue/Content/V2/Audio/MusicDebugOverlay_V2_Contract.json`; doc
      `V2/docs/audio/music-debug-overlay.md`; checker
      `V2/ue/Tools/check-v2-music-debug-overlay.py`; CI workflow wiring; and
      Horde gate `musicDebugOverlay`.
- [x] **72.22.1.15** Implement music system documentation and composer
      integration guide — music system composer integration guide implemented
      with source-of-truth links for adaptive music state machine, horizontal
      re-sequencing, vertical layering, beat sync, tempo tracking, intensity
      curves, stingers, cross-fades, memory, ducking, playlists, music authoring
      interface, optional middleware, and music debugging overlay; composer
      deliverables, authoring workflow, runtime integration, and debug signoff
      checklist in `V2/docs/audio/music-system-composer-integration-guide.md`;
      contract
      `V2/ue/Content/V2/Audio/MusicSystemComposerGuide_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-music-system-composer-guide.py`; CI workflow
      wiring; and Horde gate `musicSystemComposerGuide`.

---

### 72.23 Gameplay Camera for Maya Engine

(See 72.16 — this section is merged with 72.16 above to avoid duplication.)

---

### 72.24 Character Controller (Maya Engine)

Character controller specifically for Maya — capsule movement, slope handling,
and ground detection independent of Neith.

#### 72.24.1 Maya Character Controller

- [x] **72.24.1.1** Implement capsule character controller in maya-physics
      (swept capsule movement with depenetration) - 2026-06-23: capsule
      character controller implemented in `maya-physics` via
      `CapsuleCharacterController`, `CapsuleCharacterControllerConfig`,
      `CapsuleCharacterMoveRequest`, `CapsuleCharacterMoveResult`,
      `CapsuleCharacterContact`, and `CharacterControllerError`; supports swept
      capsule movement through `CollisionDetectionWorld::sweep_shape`, iterative
      initial overlap depenetration, skin width preservation, contact normal
      orientation, slide clipping of remaining displacement, query layer and
      `QueryFilter` support, and deterministic result reporting. Added focused
      Rust tests for swept wall blocking, initial overlap depenetration, wall
      sliding, and ignored obstacle filters; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaCapsuleCharacterController_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-capsule-character-controller.py`; CI
      workflow wiring; and Horde gate `mayaCapsuleCharacterController`.
- [x] **72.24.1.2** Create ground detection system (raycast-based ground check,
      ground normal tracking, slope angle calculation) - 2026-06-23: ground
      detection system implemented in `maya-physics` via
      `CapsuleGroundProbeConfig`, `CapsuleGroundProbeRequest`,
      `CapsuleGroundProbeResult`, `CapsuleGroundHit`, and
      `CapsuleCharacterController::probe_ground`; supports raycast-based ground
      check, capsule-bottom clearance reporting, ground normal tracking, slope
      angle calculation, walkable slope classification, query layer and
      `QueryFilter` support, and missing-ground results. Added focused Rust
      tests for flat floor clearance, hover distance, sloped surface
      angle/walkability, and ignored ground filters; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaGroundDetection_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-ground-detection.py`; CI workflow
      wiring; and Horde gate `mayaGroundDetection`.
- [x] **72.24.1.3** Implement slope handling (slide on steep slopes, walk on
      gentle slopes, configurable max walkable angle) - 2026-06-23: slope
      handling implemented in `maya-physics` via `CapsuleSlopeHandlingConfig`,
      `CapsuleSlopeHandlingRequest`, `CapsuleSlopeHandlingResult`,
      `CapsuleSlopeMode`, and
      `CapsuleCharacterController::resolve_slope_movement`; supports walkable
      slope projection, steep slope downhill slide, configurable max walkable
      angle, airborne passthrough, ground normal reuse, slope slide displacement
      reporting, and deterministic slope mode selection. Added focused Rust
      tests for walkable ground-plane projection, steep downhill sliding,
      airborne passthrough, and configurable walkable-angle behavior; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaSlopeHandling_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-slope-handling.py`; CI workflow wiring;
      and Horde gate `mayaSlopeHandling`.
- [x] **72.24.1.4** Create step climbing (detect steps shorter than step height,
      smoothly elevate character over step) - 2026-06-23: step climbing
      implemented in `maya-physics` via `CapsuleStepClimbConfig`,
      `CapsuleStepClimbRequest`, `CapsuleStepClimbResult`,
      `CapsuleStepClimbMode`, and `CapsuleCharacterController::plan_step_climb`;
      supports low sweep obstacle detection, raised clearance sweep, landing
      ground probe, max step height rejection, smooth elevation timing and
      velocity, query layer and `QueryFilter` support, and deterministic step
      climb mode selection. Added focused Rust tests for clear paths, short step
      elevation, tall step blocking, smooth elevation velocity, and ignored
      obstacle filters; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaStepClimbing_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-step-climbing.py`; CI workflow wiring;
      and Horde gate `mayaStepClimbing`.
- [x] **72.24.1.5** Implement ledge detection (detect ground edge, prevent
      walking off, optional auto-grab) - 2026-06-23: ledge detection implemented
      in `maya-physics` via `CapsuleLedgeDetectionConfig`,
      `CapsuleLedgeDetectionRequest`, `CapsuleLedgeDetectionResult`,
      `CapsuleLedgeMode`, `CapsuleLedgeGrabTarget`, and
      `CapsuleCharacterController::detect_ledge`; supports forward ground probe,
      ground edge detection, prevent walking off displacement clamping, optional
      auto-grab target generation, drop distance reporting, query layer and
      `QueryFilter` support, and deterministic ledge mode selection. Added
      focused Rust tests for stable forward ground, blocked ground-edge
      walk-off, auto-grab target construction, and ignored ground filters;
      contract
      `V2/ue/Content/V2/Gameplay/Character/MayaLedgeDetection_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-ledge-detection.py`; CI workflow
      wiring; and Horde gate `mayaLedgeDetection`.
- [x] **72.24.1.6** Create moving platform support (character rides moving
      platforms, inherits platform velocity, stays attached) - 2026-06-23:
      moving platform support implemented in `maya-physics` via
      `CapsuleMovingPlatformConfig`, `CapsuleMovingPlatformRequest`,
      `CapsuleMovingPlatformResult`, `CapsuleMovingPlatformMode`, and
      `CapsuleCharacterController::resolve_moving_platform`; supports
      ground-contact platform detection, inherited linear velocity, inherited
      angular velocity at the character contact point, platform displacement
      integration, stay-attached previous platform fallback, query layer and
      `QueryFilter` support, and deterministic moving platform mode selection.
      Added focused Rust tests for linear platform velocity inheritance, angular
      velocity at contact points, previous-platform attachment, detached
      fallback, and ignored platform filters; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaMovingPlatformSupport_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-moving-platform-support.py`; CI
      workflow wiring; and Horde gate `mayaMovingPlatformSupport`.
- [x] **72.24.1.7** Implement swimming/floating (detect water volume, switch to
      swim mode, buoyancy-based vertical movement) - 2026-06-23: swimming and
      floating implemented in `maya-physics` via `CapsuleSwimmingConfig`,
      `CapsuleSwimmingRequest`, `CapsuleSwimmingResult`, `CapsuleSwimmingMode`,
      and `CapsuleCharacterController::resolve_swimming`; supports water trigger
      volume detection with capsule overlap sweeps, dry mode passthrough, swim
      mode water drag, floating mode buoyancy, vertical speed clamping, query
      layer and `QueryFilter` support, and deterministic swimming mode
      selection. Added focused Rust tests for dry mode, trigger water floating,
      swim-mode drag, buoyancy speed clamping, and ignored water filters;
      contract
      `V2/ue/Content/V2/Gameplay/Character/MayaSwimmingFloating_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-swimming-floating.py`; CI workflow
      wiring; and Horde gate `mayaSwimmingFloating`.
- [x] **72.24.1.8** Create ladder/climbable surface system (detect climbable
      surfaces, switch to climb mode, directional climb movement) - 2026-06-23:
      ladder and climbable surface system implemented in `maya-physics` via
      `CapsuleClimbableSurfaceConfig`, `CapsuleClimbableSurfaceRequest`,
      `CapsuleClimbableSurfaceResult`, `CapsuleClimbMode`, and
      `CapsuleCharacterController::resolve_climbable_surface`; supports forward
      climbable surface raycast detection, trigger surface requirement, climb
      mode selection, vertical climb movement, lateral climb movement, query
      layer and `QueryFilter` support, and deterministic climb mode selection.
      Added focused Rust tests for missed probes, upward ladder climbing,
      lateral surface movement, non-trigger rejection, and ignored surface
      filters; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaClimbableSurfaceSystem_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-climbable-surface-system.py`; CI
      workflow wiring; and Horde gate `mayaClimbableSurfaceSystem`.
- [x] **72.24.1.9** Implement crouch and prone (reduce collision capsule height,
      check if space exists before standing up) - 2026-06-23: crouch and prone
      stance planning implemented in `maya-physics` via `CapsuleStanceConfig`,
      `CapsuleStanceRequest`, `CapsuleStanceResult`, `CapsuleStance`,
      `CapsuleStanceTransitionMode`, and
      `CapsuleCharacterController::plan_stance_transition`; supports crouch
      capsule height reduction, prone capsule height reduction,
      foot-position-preserving stance center offsets, standing clearance query,
      blocked stand-up preservation, query layer and `QueryFilter` support, and
      deterministic stance transition selection. Added focused Rust tests for
      crouch/prone height reduction, blocked stand-up under a low ceiling, clear
      stand-up expansion, ignored ceiling filters, and unchanged stance
      reporting; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaCrouchProne_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-crouch-prone.py`; CI workflow wiring;
      and Horde gate `mayaCrouchProne`.
- [x] **72.24.1.10** Create character-character collision (push characters
      apart, prevent overlap, configurable push force) - 2026-06-23:
      character-character collision implemented in `maya-physics` via
      `CapsuleCharacterCollider`, `CapsuleCharacterCollisionConfig`,
      `CapsuleCharacterCollisionRequest`, `CapsuleCharacterCollisionResult`,
      `CapsuleCharacterCollisionContact`, `CapsuleCharacterCollisionMode`, and
      `CapsuleCharacterController::resolve_character_collisions`; supports
      character capsule overlap detection, push-apart displacement resolution,
      overlap prevention with full push force, configurable push force, max push
      distance clamping, ignored character filtering, and deterministic
      character collision mode selection. Added focused Rust tests for
      overlapping capsule push-apart, separated characters, configurable push
      force, max push distance clamping, and ignored character filters; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaCharacterCharacterCollision_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-character-character-collision.py`; CI
      workflow wiring; and Horde gate `mayaCharacterCharacterCollision`.
- [x] **72.24.1.11** Implement gravity modes (normal, low gravity, zero gravity,
      variable gravity — affect jump height and fall speed) - 2026-06-23:
      gravity modes implemented in `maya-physics` via `CapsuleGravityMode`,
      `CapsuleGravityConfig`, `CapsuleGravityRequest`, `CapsuleGravityResult`,
      and `CapsuleCharacterController::resolve_gravity`; supports normal gravity
      acceleration, low gravity jump and fall scaling, zero gravity velocity
      preservation, variable gravity request scaling, jump height based impulse
      calculation, fall speed clamping, gravity delta velocity reporting, and
      deterministic gravity mode selection. Added focused Rust tests for normal
      jump-height impulse, low-gravity jump/fall reduction, zero-gravity
      velocity preservation, variable gravity scale, and max fall speed
      clamping; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaGravityModes_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-gravity-modes.py`; CI workflow wiring;
      and Horde gate `mayaGravityModes`.
- [x] **72.24.1.12** Create movement prediction for networking (send movement
      inputs to server, predict locally, reconcile with server state) -
      2026-06-23: movement prediction for networking implemented in
      `maya-physics` via `CapsuleMovementInput`, `CapsulePredictedState`,
      `CapsuleAuthoritativeState`, `CapsuleMovementPredictionConfig`,
      `CapsuleMovementPredictionRequest`, `CapsuleMovementPredictionResult`,
      `CapsuleMovementReconciliationRequest`,
      `CapsuleMovementReconciliationResult`,
      `CapsuleMovementReconciliationMode`, and
      `CapsuleCharacterController::predict_movement` /
      `CapsuleCharacterController::reconcile_movement_prediction`; supports
      sequenced movement input output, local swept movement prediction,
      authoritative acknowledged input dropping, unacknowledged input replay,
      tolerance based in-sync reconciliation, correction displacement and
      smoothing velocity, max replay input cap, and deterministic reconciliation
      mode selection. Added focused Rust tests for local prediction/outbound
      input, authority replay/correction, in-sync tolerance, replay cap
      truncation, and collision-sweep-backed prediction; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaMovementPrediction_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-movement-prediction.py`; CI workflow
      wiring; and Horde gate `mayaMovementPrediction`.
- [x] **72.24.1.13** Implement character controller debugging (visualize
      capsule, ground normal, step detection, slope angle, collision contacts) -
      2026-06-23: character controller debugging implemented in `maya-physics`
      via `CapsuleCharacterDebugConfig`, `CapsuleCharacterDebugRequest`,
      `CapsuleCharacterDebugSnapshot`, `CapsuleCharacterDebugMetrics`,
      `CapsuleDebugCapsule`, `CapsuleDebugLine`, `CapsuleDebugLineKind`,
      `CapsuleDebugPoint`, `CapsuleDebugPointKind`, `CapsuleDebugContact`, and
      `CapsuleCharacterController::build_debug_snapshot`; supports renderer
      agnostic debug snapshot generation, capsule geometry visualization, ground
      normal debug line output, step detection debug markers, slope angle metric
      reporting, collision contact markers and normals, and finite debug input
      validation. Added focused Rust tests for capsule geometry, ground/slope
      visualization, step detection markers, contact markers, and invalid debug
      input handling; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaCharacterControllerDebugging_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-character-controller-debugging.py`; CI
      workflow wiring; and Horde gate `mayaCharacterControllerDebugging`.
- [x] **72.24.1.14** Create character controller configuration presets
      (platformer, realistic FPS, arcade, VR — different tuning) - 2026-06-23:
      character controller configuration presets implemented in `maya-physics`
      via `CapsuleCharacterControllerPresetKind`,
      `CapsuleCharacterControllerPreset`,
      `CapsuleCharacterControllerPreset::for_kind`, and
      `CapsuleCharacterController::from_preset`; supports platformer tuning
      preset, realistic FPS tuning preset, arcade tuning preset, VR tuning
      preset, all preset configs validate, preset controller construction, and
      inspectable subsystem config bundles for controller shape, ground probing,
      slope handling, step climbing, ledge detection, moving platforms,
      swimming, climbable surfaces, stance, gravity, and movement prediction.
      Added focused Rust tests for all-bundle validation, platformer assist
      tuning, realistic FPS grounded limits, arcade high-assist tuning, and VR
      reduced-motion tuning; contract
      `V2/ue/Content/V2/Gameplay/Character/MayaCharacterControllerPresets_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-character-controller-presets.py`; CI
      workflow wiring; and Horde gate `mayaCharacterControllerPresets`.
- [x] **72.24.1.15** Implement character controller documentation and tuning
      guide - 2026-06-23: character controller documentation and tuning guide
      implemented in `V2/docs/physics/maya-character-controller-tuning-guide.md`
      with sections for Source Of Truth, Runtime Surface, Preset Selection,
      Tuning Workflow, Capsule And Grounding, Slope Step Ledge Tuning, Platforms
      Swimming And Climbing, Stance Gravity Prediction Debugging, Validation
      Commands, and Release Checklist. The guide covers
      `CapsuleCharacterController` runtime entry points, preset selection for
      platformer/realistic FPS/arcade/VR, subsystem config tuning, debug
      snapshot evidence, network prediction review, VR comfort review, and
      validation commands. Added contract
      `V2/ue/Content/V2/Gameplay/Character/MayaCharacterControllerTuningGuide_V2_Contract.json`;
      checker `V2/ue/Tools/check-v2-maya-character-controller-tuning-guide.py`;
      CI workflow wiring; and Horde gate `mayaCharacterControllerTuningGuide`.

---

### 72.25 HUD / Heads-Up Display System

Game-specific HUD patterns: health bars, minimap, compass, damage indicators,
interaction prompts, and ammo counters.

#### 72.25.1 HUD Framework

- [x] **72.25.1.1** Implement HUD manager (register/unregister HUD elements,
      visibility states, layering, anchor points) - 2026-06-23: Added the V2 HUD
      manager surface in `V2UI` with `EV2HUDAnchorPoint`,
      `EV2HUDElementVisibilityState`, layer/z-order metadata on
      `FV2HUDSlotDefinition` and `FV2HUDWidgetEntry`, manager request/snapshot
      structs, deterministic slot ordering, visible-entry filtering, explicit
      `RegisterHUDElement`, `RegisterHUDElementRequest`, `UnregisterHUDElement`,
      `SetHUDElementVisibility`, `SetHUDElementLayer`, `SetHUDElementAnchor`,
      `GetVisibleHUDEntries`, and `CaptureHUDManagerSnapshot` subsystem APIs.
      Default HUD slots now carry anchor/layer defaults for top-left, top-right,
      center, profile-card, screen-effects, bottom, modal, and notification
      surfaces. Added focused Unreal automation coverage in
      `V2/ue/Source/V2Tests/Private/UI/HUDManager.spec.cpp`, module-level
      coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, the
      contract `V2/ue/Content/V2/UI/HUD/HUDManager_V2_Contract.json`, static
      validator `V2/ue/Tools/check-v2-hud-manager.py`, CI workflow/validator
      wiring, and Horde `hudManager` gates.
- [x] **72.25.1.2** Create health/resource bar widget (configurable bar shape,
      colors, segments, fill direction, animation on change) - 2026-06-23: Added
      `EV2HUDResourceBarKind`, `EV2HUDResourceBarShape`,
      `EV2HUDResourceBarFillDirection`, `FV2HUDResourceBarSegmentSpec`,
      `FV2HUDResourceBarStyle`, `FV2HUDResourceBarState`, and
      `FV2HUDResourceBarSpec` with validation, segment resolution, clamped fill
      state, delta/critical/empty/full flags, and HUD entry conversion. Added
      `UV2HealthResourceBarWidget` with spec configuration, value application,
      segment/color/fill-direction getters, and reduced-motion-aware change
      animation gating. Wired the default health bar through `UV2UIConfigAsset`
      and `UV2UIBlueprintLibrary`, added focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/HealthResourceBar.spec.cpp`, module
      coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, the
      contract `V2/ue/Content/V2/UI/HUD/HealthResourceBar_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-health-resource-bar.py`, CI
      workflow/validator wiring, and Horde `healthResourceBar` gates.
- [x] **72.25.1.3** Implement minimap system (top-down camera rendering to
      texture, player arrow, enemy blips, objective markers, zoom levels) -
      2026-06-23: Added the HUD minimap runtime surface with
      `EV2HUDMinimapMarkerType`, `EV2HUDMinimapRotationMode`,
      `FV2HUDMinimapZoomLevelSpec`, `FV2HUDMinimapRenderCaptureSpec`,
      `FV2HUDMinimapMarkerSpec`, `FV2HUDMinimapState`, and `FV2HUDMinimapSpec`.
      The default `HUD.Minimap.Match` spec defines a top-down `SceneCapture2D`
      render target, close/standard/wide zoom levels, player arrow, enemy blips,
      objective marker, POI marker, heading normalization, marker counts, and
      HUD entry conversion. Added `UV2MinimapHUDWidget`, `UV2UIConfigAsset`
      defaults, `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/MinimapHUD.spec.cpp`, module coverage in
      `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/MinimapHUD_V2_Contract.json`, static validator
      `V2/ue/Tools/check-v2-minimap-hud.py`, CI workflow/validator wiring, and
      Horde `minimapHUD` gates.
- [x] **72.25.1.4** Create compass/bearing indicator (world-space compass bar at
      screen top showing cardinal directions, POI icons, quest markers) -
      2026-06-24: Added the HUD compass/bearing runtime surface with
      `EV2HUDCompassMarkerType`, `FV2HUDCompassCardinalSpec`,
      `FV2HUDCompassMarkerSpec`, `FV2HUDCompassState`, and `FV2HUDCompassSpec`.
      The default `HUD.Compass.Match` spec uses a new top-center HUD slot,
      N/E/S/W cardinal ticks, POI icons, quest markers, tracked objective
      markers, normalized camera yaw, relative bearing and offset projection,
      distance/count state, and gameplay-inert cardless layout policy. Added
      `UV2CompassBearingWidget`, `UV2UIConfigAsset` defaults,
      `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/CompassBearing.spec.cpp`, module coverage
      in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/CompassBearing_V2_Contract.json`, static
      validator `V2/ue/Tools/check-v2-compass-bearing.py`, CI workflow/validator
      wiring, and Horde `compassBearing` gates.
- [x] **72.25.1.5** Implement damage direction indicator (screen-edge red flash
      showing direction of incoming damage, fade over time) - 2026-06-24: Added
      the HUD damage direction indicator runtime surface with
      `EV2HUDDamageDirectionZone`, `FV2HUDDamageDirectionEvent`,
      `FV2HUDDamageDirectionState`, and `FV2HUDDamageDirectionIndicatorSpec`.
      The default `HUD.DamageDirection.Match` spec renders through
      `Slot.ScreenEffects`, resolves world-space incoming damage into eight
      screen-edge zones, normalizes camera yaw and relative bearings, computes
      edge vectors, severity-scaled red flash opacity, critical-hit opacity,
      fade alpha, and deterministic expiry after the fade duration. Added
      `UV2DamageDirectionIndicatorWidget`, `UV2UIConfigAsset` defaults,
      `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/DamageDirectionIndicator.spec.cpp`,
      module coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`,
      contract
      `V2/ue/Content/V2/UI/HUD/DamageDirectionIndicator_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-damage-direction-indicator.py`, CI
      workflow/validator wiring, and Horde `damageDirectionIndicator` gates.
- [x] **72.25.1.6** Create hit marker (crosshair feedback on successful hit —
      visual and optional audio confirmation) - 2026-06-24: Added the HUD hit
      marker runtime surface with `EV2HUDHitMarkerResult`,
      `FV2HUDHitMarkerEvent`, `FV2HUDHitMarkerState`, and `FV2HUDHitMarkerSpec`.
      The default `HUD.HitMarker.Match` spec renders through `Slot.Center`,
      anchors to `HUD.Anchor.Crosshair.Center`, filters unsuccessful hits, fades
      crosshair feedback after a successful hit, escalates
      critical/headshot/kill-confirm color and scale, and requests optional
      audio confirmation only on the initial successful-hit frame. Added
      `UV2HitMarkerWidget`, `UV2UIConfigAsset` defaults, `UV2UIBlueprintLibrary`
      helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/HitMarker.spec.cpp`, module coverage in
      `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/HitMarker_V2_Contract.json`, static validator
      `V2/ue/Tools/check-v2-hit-marker.py`, CI workflow/validator wiring, and
      Horde `hitMarker` gates.
- [x] **72.25.1.7** Implement ammo/resource counter (current/max display,
      low-ammo warning, reload indicator) - 2026-06-24: Added the HUD
      ammo/resource counter runtime surface with
      `EV2HUDAmmoResourceCounterKind`, `EV2HUDReloadState`,
      `FV2HUDAmmoResourceCounterState`, and `FV2HUDAmmoResourceCounterSpec`. The
      default `HUD.AmmoResourceCounter.Match` spec renders through
      `Slot.Bottom`, binds current/max text, reserve count text, low-ammo
      thresholding, reload progress, empty state, and infinite-ammo state while
      staying gameplay-inert, reduced-motion safe, stable-dimensioned, and
      cardless. Added `UV2AmmoResourceCounterWidget`, `UV2UIConfigAsset`
      defaults, `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/AmmoResourceCounter.spec.cpp`, module
      coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/AmmoResourceCounter_V2_Contract.json`, static
      validator `V2/ue/Tools/check-v2-ammo-resource-counter.py`, CI
      workflow/validator wiring, and Horde `ammoResourceCounter` gates.
- [x] **72.25.1.8** Create interaction prompt system (context-sensitive "Press E
      to Open" prompts near interactable objects, auto-hide on distance) -
      2026-06-24: Added the HUD interaction prompt runtime surface with
      `EV2HUDInteractionPromptKind`, `FV2HUDInteractionPromptState`, and
      `FV2HUDInteractionPromptSpec`. The default `HUD.InteractionPrompt.Match`
      spec renders through `Slot.Center`, binds
      `Input.Environment.StageInteraction` and `Glyph.Button.StageInteraction`,
      builds context-sensitive `Press E to Open`/Talk/PickUp style prompt text,
      tracks focused interactable id, target text, world/screen position, player
      distance, and auto-hides when the player exceeds the configured
      interaction range while staying gameplay-inert, reduced-motion safe,
      stable-dimensioned, screen-reader summarized, and cardless. Added
      `UV2InteractionPromptWidget`, `UV2UIConfigAsset` defaults,
      `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/InteractionPrompt.spec.cpp`, module
      coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/InteractionPrompt_V2_Contract.json`, static
      validator `V2/ue/Tools/check-v2-interaction-prompt.py`, CI
      workflow/validator wiring, and Horde `interactionPrompt` gates.
- [x] **72.25.1.9** Implement objective tracker (display current quest objective
      text on HUD, progress bar, optional compass waypoint) - 2026-06-24: Added
      the HUD objective tracker runtime surface with
      `EV2HUDObjectiveTrackerWaypointMode`, `FV2HUDObjectiveTrackerState`, and
      `FV2HUDObjectiveTrackerSpec`. The default `HUD.ObjectiveTracker.Match`
      spec renders through `Slot.TopRight`, binds current quest/objective IDs,
      current objective text, progress counts, completion state, progress text,
      optional compass waypoint distance, and normalized compass bearings while
      staying gameplay-inert, reduced-motion safe, stable-dimensioned,
      screen-reader summarized, and cardless. Added `UV2ObjectiveTrackerWidget`,
      `UV2UIConfigAsset` defaults, `UV2UIBlueprintLibrary` helpers, focused
      coverage in `V2/ue/Source/V2Tests/Private/UI/ObjectiveTracker.spec.cpp`,
      module coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`,
      contract `V2/ue/Content/V2/UI/HUD/ObjectiveTracker_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-objective-tracker.py`, CI
      workflow/validator wiring, and Horde `objectiveTracker` gates.
- [x] **72.25.1.10** Create notification toast system (achievement unlocked,
      item acquired, save completed — queue, stack, auto-dismiss) - 2026-06-24:
      Added the HUD notification toast runtime surface with
      `EV2HUDNotificationToastKind`, `FV2HUDNotificationToastTemplate`,
      `FV2HUDNotificationToast`, `FV2HUDNotificationToastQueueSpec`,
      `FV2HUDNotificationToastQueueSnapshot`, and `FV2HUDNotificationToastSpec`.
      The default `HUD.NotificationToasts.Match` spec renders through
      `Slot.TopRight`, covers achievement unlocked, item acquired, and save
      completed templates, queues pending toasts, stacks matching item-acquired
      events with visible stack text, suppresses duplicate cooldowns,
      auto-dismisses expired toasts, and tracks active, pending, and total stack
      counts while staying gameplay-inert, reduced-motion safe,
      stable-dimensioned, screen-reader summarized, and cardless. Added
      `UV2HUDNotificationToastWidget`, `UV2UIConfigAsset` defaults,
      `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/HUDNotificationToast.spec.cpp`, module
      coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/HUDNotificationToasts_V2_Contract.json`, static
      validator `V2/ue/Tools/check-v2-hud-notification-toasts.py`, CI
      workflow/validator wiring, and Horde `hudNotificationToasts` gates.
- [x] **72.25.1.11** Implement crosshair system (configurable crosshair shapes,
      spread indicator for weapon accuracy, dynamic sizing) - 2026-06-24: Added
      the HUD crosshair runtime surface with `EV2HUDCrosshairShape`,
      `EV2HUDCrosshairSpreadMode`, `FV2HUDCrosshairStyle`,
      `FV2HUDCrosshairState`, and `FV2HUDCrosshairSpec`. The default
      `HUD.Crosshair.Match` spec renders through `Slot.Center`, anchors to
      `HUD.Anchor.Crosshair.Center`, supports configurable dot/cross/circle/T
      shapes, computes weapon-accuracy and movement-penalty spread radius,
      scales the dynamic reticle size from spread, supports hidden no-weapon
      state, and stays gameplay-inert, reduced-motion safe, stable-dimensioned,
      screen-reader summarized, and cardless. Added `UV2CrosshairWidget`,
      `UV2UIConfigAsset` defaults, `UV2UIBlueprintLibrary` helpers, focused
      coverage in `V2/ue/Source/V2Tests/Private/UI/Crosshair.spec.cpp`, module
      coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/Crosshair_V2_Contract.json`, static validator
      `V2/ue/Tools/check-v2-crosshair.py`, CI workflow/validator wiring, and
      Horde `crosshair` gates.
- [x] **72.25.1.12** Create buff/debuff status icon bar (show active effects
      with icons, duration timers, stack counts) - 2026-06-24: Added the HUD
      status icon bar runtime surface with `EV2HUDStatusEffectKind`,
      `FV2HUDStatusEffectDefinition`, `FV2HUDStatusEffectState`,
      `FV2HUDStatusIconBarSnapshot`, and `FV2HUDStatusIconBarSpec`. The default
      `HUD.StatusIconBar.Match` spec renders through `Slot.TopLeft`, uses native
      `UV2StatusIconBarWidget`, ships buff/debuff definitions, shows active
      effect icons with timer text/rings, stack badges, priority ordering,
      expiring-soon state, overflow counts, active/buff/debuff snapshot counts,
      and remains gameplay-inert, reduced-motion safe, stable-dimensioned,
      screen-reader summarized, and cardless. Added `UV2UIConfigAsset` defaults,
      `UV2UIBlueprintLibrary` helpers, focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/StatusIconBar.spec.cpp`, module coverage
      in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`, contract
      `V2/ue/Content/V2/UI/HUD/StatusIconBar_V2_Contract.json`, static validator
      `V2/ue/Tools/check-v2-status-icon-bar.py`, CI workflow/validator wiring,
      and Horde `statusIconBar` gates.
- [x] **72.25.1.13** Implement HUD opacity and visibility customization (player
      controls which HUD elements are visible, global opacity slider) -
      2026-06-24: Added player-profile HUD customization with
      `FV2HUDVisibilityElementPreference`,
      `FV2HUDVisibilityCustomizationProfile`, and per-entry `FV2HUDWidgetEntry`
      opacity. The default `HUD.Visibility.Profile.Default` exposes a global
      opacity slider, clamps opacity from 0.35-1.0 in 0.05 steps, stores
      per-element visibility controls for health, ammo, objective tracker,
      notifications, crosshair, and status effects, protects required HUD
      elements from disabled state, applies to mode HUD injections, rebuilds
      customized HUD manager snapshots, and applies live through
      `UV2UISubsystem`. Added `UV2UIConfigAsset` defaults,
      `UV2UIBlueprintLibrary` helpers, subsystem apply/opacity/preference APIs,
      focused coverage in
      `V2/ue/Source/V2Tests/Private/UI/HUDVisibilityCustomization.spec.cpp`,
      module coverage in `V2/ue/Source/V2Tests/Automation/UI.Module.spec.cpp`,
      contract
      `V2/ue/Content/V2/UI/HUD/HUDVisibilityCustomization_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-hud-visibility-customization.py`,
      CI workflow/validator wiring, and Horde `hudVisibilityCustomization`
      gates.
- [x] **72.25.1.14** Create HUD safe zone configuration (respect TV safe zones,
      configurable HUD margins for overscan)
  - Added `FV2HUDSafeZoneConfig`, `FV2HUDSafeZoneMargins`, `FV2HUDSafeZoneRect`,
    and slot-level safe-zone margin fields for TV-safe HUD placement and
    overscan clamping.
  - Wired default config asset data, Blueprint helpers, subsystem
    registration/edit/query APIs, focused spec
    `V2/ue/Source/V2Tests/Private/UI/HUDSafeZone.spec.cpp`, module coverage,
    contract `V2/ue/Content/V2/UI/HUD/HUDSafeZone_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-hud-safe-zone.py`, CI workflow/validator
    wiring, and Horde `hudSafeZone` gates.
- [x] **72.25.1.15** Implement HUD accessibility (screen reader descriptions for
      HUD elements, high-contrast mode, scalable elements)
  - Added `FV2HUDAccessibilityProfile` and
    `FV2HUDAccessibilityElementDescriptor` coverage for per-HUD-element
    screen-reader descriptions, high-contrast style tokens, and scalable HUD
    element metadata.
  - Wired default config asset data, Blueprint helpers, subsystem
    apply/toggle/scale/snapshot APIs, focused coverage in
    `V2/ue/Source/V2Tests/Private/UI/HUDAccessibility.spec.cpp`, module
    coverage, contract
    `V2/ue/Content/V2/UI/HUD/HUDAccessibility_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-hud-accessibility.py`, CI workflow/validator
    wiring, and Horde `hudAccessibility` gates.

---

### 72.26 Replay / Demo Recording System

Match replay recording, viewer with timeline scrub, free camera, and highlight
detection.

#### 72.26.1 Replay System

- [x] **72.26.1.1** Design replay file format (header with match metadata,
      stream of timestamped input events and state snapshots, compressed)
  - Added the versioned `V2RF` replay container with `FV2ReplayFileHeader`,
    `FV2ReplayInputEventRecord`, `FV2ReplayStateSnapshotRecord`,
    `FV2ReplayFileChunkIndexEntry`, and `FV2ReplayFile` validation in V2Input.
  - Wired deterministic encode/decode through `FV2InputReplayEncoder`, Blueprint
    helpers on `UV2InputBlueprintLibrary`, module coverage in
    `V2/ue/Source/V2Tests/Automation/Input.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Input/Replays/ReplayFileFormat_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-replay-file-format.py`, CI
    workflow/validator wiring, and Horde `replayFileFormat` gates.
- [x] **72.26.1.2** Implement replay recording (capture all player inputs and
      server state snapshots during gameplay, write to replay file)
  - Added `FV2ReplayRecordingPlayer`, `FV2ReplayRecordingConfig`,
    `FV2ReplayRecordingSession`, and `FV2ReplayRecordingFinalizeResult` in
    V2Input for live match recording sessions.
  - Wired Blueprint helpers to begin recording, capture per-player input
    samples, capture authoritative server state snapshots, enforce complete
    player-frame coverage, and write validated encoded `V2RF` replay bytes.
  - Added module coverage in
    `V2/ue/Source/V2Tests/Automation/Input.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Input/Replays/ReplayRecording_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-replay-recording.py`, CI workflow/validator
    wiring, and Horde `replayRecording` gates.
- [x] **72.26.1.3** Create replay playback engine (feed recorded inputs into
      deterministic simulation, reconstruct game state at any point)
  - Added `FV2ReplayPlaybackInputFrame`, `FV2ReplayPlaybackReconstruction`, and
    `FV2ReplayPlaybackSession` in V2Input for deterministic replay playback
    sessions.
  - Wired Blueprint helpers to build playback sessions from validated `V2RF`
    files, group recorded player inputs by frame, expose deterministic
    simulation input feeds, and reconstruct frame/timestamp targets from the
    nearest state snapshot plus resimulation frames.
  - Added module coverage in
    `V2/ue/Source/V2Tests/Automation/Input.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Input/Replays/ReplayPlaybackEngine_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-playback-engine.py`, CI
    workflow/validator wiring, and Horde `replayPlaybackEngine` gates.
- [x] **72.26.1.4** Implement replay timeline UI (scrub bar, play/pause, speed
      control 0.25x-4x, jump to timestamp)
  - Added `FV2ReplayTimelineUISpec`, `FV2ReplayTimelineControlState`, timeline
    speed options, snapshot markers, and `UV2ReplayTimelineWidget` in V2UI for
    scrub/play-pause/speed/timestamp-jump UMG binding.
  - Wired Blueprint helpers for default timeline specs, validated control state
    construction from `FV2ReplayPlaybackSession`, play state transitions,
    0.25x-4x speed selection, frame scrubbing, timestamp jumps, and HUD entry
    injection.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/UI/ReplayTimelineUI.spec.cpp`, contract
    `V2/ue/Content/V2/UI/Replays/ReplayTimelineUI_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-replay-timeline-ui.py`, CI
    workflow/validator wiring, V2UI module checker wiring, and Horde
    `replayTimelineUI` gates.
- [x] **72.26.1.5** Create replay free camera (detach camera from player, fly
      freely through replay scene, orbit around entities)
  - Added `FV2ReplayFreeCameraRigSpec`, `FV2ReplayFreeCameraInput`,
    `FV2ReplayFreeCameraEntityTarget`, and `FV2ReplayFreeCameraState` in
    V2Cinematics, with validated detached fly mode, entity orbit mode, bounds,
    and keyframe stamping.
  - Wired replay viewer sessions and Blueprint/subsystem helpers for default
    free-camera state, fly input, `OrbitReplayFreeCameraAroundEntity` entity
    orbit locking, and camera keyframe capture.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Cinematics/ReplayFreeCamera.spec.cpp`,
    contract
    `V2/ue/Content/V2/Cinematics/Replays/ReplayFreeCamera_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-free-camera.py`, CI
    workflow/validator wiring, V2Cinematics module checker wiring, and Horde
    `replayFreeCamera` gates.
- [x] **72.26.1.6** Implement replay entity tracking camera (lock camera to
      follow any player/entity in the replay)
  - Added `FV2ReplayEntityTrackingCameraSpec`, `FV2ReplayEntityTrackingTarget`,
    and `FV2ReplayEntityTrackingCameraState` in V2Cinematics, with validated
    player and non-player target locks, smooth follow updates, camera keyframe
    stamping, and release back to detached free camera.
  - Wired replay viewer sessions and Blueprint/subsystem helpers for
    `LockReplayEntityTrackingCamera`, `UpdateReplayEntityTrackingCameraTarget`,
    `ReleaseReplayEntityTrackingCameraToFreeCamera`, and
    `BuildReplayEntityTrackingCameraKeyframe`.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Cinematics/ReplayEntityTrackingCamera.spec.cpp`,
    contract
    `V2/ue/Content/V2/Cinematics/Replays/ReplayEntityTrackingCamera_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-entity-tracking-camera.py`, CI
    workflow/validator wiring, V2Cinematics module checker wiring, and Horde
    `replayEntityTrackingCamera` gates.
- [x] **72.26.1.7** Create replay overlay information (show player names,
      health, position markers, wireframe outlines)
  - Added `FV2ReplayOverlayEntitySnapshot`, `FV2ReplayOverlayEntityRow`,
    `FV2ReplayOverlayInformationSpec`, and `FV2ReplayOverlayFrame` in V2UI, with
    validated player names, health bars, world-to-screen position markers,
    tracked-entity rows, and high-contrast wireframe outline metadata.
  - Wired Blueprint/widget helpers through
    `BuildDefaultReplayOverlayInformationSpec`,
    `BuildReplayOverlayEntitySnapshot`, `BuildReplayOverlayFrame`,
    `BuildReplayOverlayHUDEntry`, and `UV2ReplayOverlayInformationWidget`.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/UI/ReplayOverlayInformation.spec.cpp`,
    contract
    `V2/ue/Content/V2/UI/Replays/ReplayOverlayInformation_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-overlay-information.py`, CI
    workflow/validator wiring, V2UI module checker wiring, and Horde
    `replayOverlayInformation` gates.
- [x] **72.26.1.8** Implement kill cam system (on death, play short replay of
      killing blow from attacker's perspective)
  - Added `EV2ReplayKillCamPlaybackState`, `FV2ReplayKillCamSpec`,
    `FV2ReplayKillCamDeathEvent`, and `FV2ReplayKillCamState` in V2Cinematics,
    with validated death-trigger payloads, bounded pre/post-death clip windows,
    attacker-perspective camera state, and start/impact/end camera keyframes.
  - Wired Blueprint and subsystem APIs through `BuildDefaultReplayKillCamSpec`,
    `ValidateReplayKillCamSpec`, `BuildReplayKillCamDeathEvent`,
    `StartReplayKillCam`, `AdvanceReplayKillCam`, `CancelReplayKillCam`, and
    `BuildReplayKillCamCameraKeyframe`, with replay viewer session timeline and
    camera-track mutation for active kill cam playback.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Cinematics/ReplayKillCam.spec.cpp`, module
    smoke coverage in
    `V2/ue/Source/V2Tests/Automation/Cinematics.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Cinematics/Replays/ReplayKillCam_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-replay-kill-cam.py`, CI workflow/validator
    wiring, V2Cinematics module checker wiring, and Horde `replayKillCam` gates.
- [x] **72.26.1.9** Create highlight detection (automatically identify notable
      moments: multi-kills, clutch plays, near-death survivals)
  - Added `EV2ReplayHighlightEventKind`, `EV2ReplayHighlightMomentKind`,
    `FV2ReplayHighlightDetectionSpec`, `FV2ReplayHighlightEvent`,
    `FV2ReplayHighlightMoment`, and `FV2ReplayHighlightTimeline` in
    V2Cinematics, with validated event inputs, multi-kill windows, low-health
    clutch detection, near-death survival detection, score-ranked moments, and
    deterministic replay clip ranges.
  - Wired Blueprint and subsystem APIs through
    `BuildDefaultReplayHighlightDetectionSpec`,
    `ValidateReplayHighlightDetectionSpec`, `BuildReplayHighlightEvent`,
    `DetectReplayHighlights`, `FindReplayHighlightsByKind`,
    `GetBestReplayHighlight`, and `GetReplayHighlightsByKind`, with detected
    timelines persisted on `FV2ReplayViewerSession`.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Cinematics/ReplayHighlightDetection.spec.cpp`,
    module smoke coverage in
    `V2/ue/Source/V2Tests/Automation/Cinematics.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Cinematics/Replays/ReplayHighlightDetection_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-highlight-detection.py`, CI
    workflow/validator wiring, V2Cinematics module checker wiring, and Horde
    `replayHighlightDetection` gates.
- [x] **72.26.1.10** Implement replay clip export (select time range, export to
      MP4/WebM with chosen camera angle)
  - Added `EV2ReplayClipExportFormat`, `EV2ReplayClipCameraAngle`,
    `FV2ReplayClipExportSpec`, `FV2ReplayClipExportRequest`, and
    `FV2ReplayClipExportJob` in V2Cinematics, with validated selected time
    ranges, MP4/WebM output extension and encoder matching, Movie Pipeline
    queueing, and chosen camera angle tracks for edited, free-camera,
    entity-tracking, kill-cam, and best-highlight exports.
  - Wired Blueprint and subsystem APIs through
    `BuildDefaultReplayClipExportSpec`, `ValidateReplayClipExportSpec`,
    `BuildReplayClipExportRequest`, `BuildReplayClipExportJob`, and
    `QueueReplayClipExport`, with queued clip jobs reported in runtime snapshots
    while preserving the existing whole-replay MP4 export path.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Cinematics/ReplayClipExport.spec.cpp`, module
    smoke coverage in
    `V2/ue/Source/V2Tests/Automation/Cinematics.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Cinematics/Replays/ReplayClipExport_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-clip-export.py`, CI workflow
    and V2Cinematics module checker wiring, and Horde `replayClipExport` gates.
- [x] **72.26.1.11** Create replay sharing (upload replay files to cloud, share
      via link, download and view in game)
  - Added the V2OnlineServices replay sharing workflow with
    `FV2ReplaySharingWorkflowSpec`, `FV2ReplayCloudUploadRequest`,
    `FV2ReplayShareLink`, `FV2ReplaySharedReplayDownloadRequest`, and
    `FV2ReplaySharedReplayViewRequest`, including owner-consented `.v2replay`
    cloud uploads, HTTPS share links, shared replay downloads, and in-game
    replay viewer launch requests.
  - Wired Blueprint and subsystem APIs through
    `BuildDefaultReplaySharingWorkflowSpec`,
    `ValidateReplaySharingWorkflowSpec`, `BuildReplayCloudUploadRequest`,
    `BuildReplayShareLink`, `BuildReplaySharedReplayDownloadRequest`,
    `BuildReplaySharedReplayViewRequest`, `UploadReplayFileToCloud`,
    `PublishReplayShareLink`, `QueueSharedReplayDownload`, and
    `OpenDownloadedReplayInGame`, reusing the existing cloud replay descriptor,
    share-code, and local download queues.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Online/ReplaySharing.spec.cpp`, module smoke
    coverage in
    `V2/ue/Source/V2Tests/Automation/OnlineServices.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Online/ReplaySharing_V2_Contract.json`, static validator
    `V2/ue/Tools/check-v2-replay-sharing.py`, CI workflow/validator wiring,
    V2OnlineServices module checker wiring, and Horde `replaySharing` gates.
- [x] **72.26.1.12** Implement replay file compression (delta-encode state
      snapshots, compress input streams, target <1MB per minute of gameplay)
  - Added `FV2ReplayFileCompressionProfile` and `FV2ReplayFileCompressionReport`
    in V2Input, with the default Oodle-backed profile enforcing compressed input
    chunks, delta-encoded state snapshots, and a 1,048,576 bytes-per-minute
    ceiling.
  - Wired Blueprint helpers through `BuildDefaultReplayFileCompressionProfile`,
    `ValidateReplayFileCompressionProfile`, `BuildCompressedReplayFile`,
    `BuildReplayFileCompressionReport`, and
    `ValidateReplayFileCompressionReport`; replay file construction and
    recording finalization now apply the compression profile and record the
    budget report on `FV2ReplayRecordingFinalizeResult`.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Input/ReplayFileCompression.spec.cpp`, module
    smoke coverage in `V2/ue/Source/V2Tests/Automation/Input.Module.spec.cpp`,
    contract
    `V2/ue/Content/V2/Input/Replays/ReplayFileCompression_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-file-compression.py`, CI
    workflow/validator wiring, V2Input module checker wiring, and Horde
    `replayFileCompression` gates.
- [x] **72.26.1.13** Create replay compatibility versioning (detect replay file
      from older game version, migration or graceful failure)
  - Added replay compatibility versioning in V2Input with
    `EV2ReplayCompatibilityStatus`, `EV2ReplayCompatibilityIssueType`,
    `EV2ReplayMigrationActionType`, `FV2ReplayCompatibilityPolicy`,
    `FV2ReplayCompatibilityMigrationStep`, `FV2ReplayCompatibilityIssue`, and
    `FV2ReplayCompatibilityResult`.
  - Wired Blueprint helpers through `BuildDefaultReplayCompatibilityPolicy`,
    `ValidateReplayCompatibilityPolicy`,
    `BuildReplayCompatibilityMigrationStep`, `EvaluateReplayFileCompatibility`,
    and `ApplyReplayCompatibilityMigration`; the evaluator detects current,
    older, newer, build-mismatched, and content-mismatched replay files, exposes
    explicit migration steps for older versions, and returns structured graceful
    failures for unsafe loads.
  - Added coverage in
    `V2/ue/Source/V2Tests/Private/Input/ReplayCompatibilityVersioning.spec.cpp`,
    module smoke coverage in
    `V2/ue/Source/V2Tests/Automation/Input.Module.spec.cpp`, contract
    `V2/ue/Content/V2/Input/Replays/ReplayCompatibilityVersioning_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-replay-compatibility-versioning.py`,
    CI workflow/validator wiring, V2Input module checker wiring, and Horde
    `replayCompatibilityVersioning` gates.
- [x] **72.26.1.14** Implement replay anti-cheat integration (flag suspicious
      plays in replay for review)
  - Added the phase-specific replay anti-cheat integration contract
    `V2/ue/Content/V2/Online/ReplayAntiCheatIntegration_V2_Contract.json`, which
    binds `72.26.1.14` to the existing replay cheat review evidence chain for
    server-side replay artifacts, input timelines, network telemetry,
    server-validation diffs, suspicious replay segments, encrypted ops-only
    evidence, FairPlay signals, ranked fail-closed behavior, and human review
    queueing.
  - Added static validator
    `V2/ue/Tools/check-v2-replay-anti-cheat-integration.py` to prove the
    existing `ReplayCheatReview.spec.cpp` coverage,
    `QueueReplayCheatInvestigation` subsystem API, Blueprint helpers, legacy
    replay cheat review contract, CI workflow entries, and Horde
    `replayAntiCheatIntegration` gates stay wired.
  - Wired the new replay anti-cheat integration checker and contract into
    `.github/workflows/v2-build.yml`, `check-v2-ci-workflow.py`, and
    `V2/ue/Build/Horde/v2-buildgraph-job.json` alongside the older
    `replayCheatReview` implementation gates.
- [x] **72.26.1.15** Create replay documentation and viewer controls guide
  - Added `V2/docs/cinematics/replay-documentation-viewer-controls-guide.md`
    with replay source-of-truth links, `Viewer Session And Playback`,
    `Timeline Controls`, `Camera Controls`, `Overlay Controls`, highlights, kill
    cam, clip export, `Sharing Compatibility And Review`, accessibility,
    localization, troubleshooting, review checklist, anti-cheat review, and
    `Validation Commands`.
  - Added contract
    `V2/ue/Content/V2/Cinematics/Replays/ReplayDocumentationViewerControlsGuide_V2_Contract.json`
    and static validator
    `V2/ue/Tools/check-v2-replay-documentation-viewer-controls-guide.py` to
    enforce dependency contracts, viewer command coverage, validation commands,
    and checklist evidence for the replay documentation guide.
  - Wired the guide through `.github/workflows/v2-build.yml`,
    `check-v2-ci-workflow.py`, and Horde
    `replayDocumentationViewerControlsGuide` gates.

---

### 72.27 Input Action Mapping & Binding System

Game-level input action binding with context switching, combo detection, and
platform-specific button prompts.

#### 72.27.1 Input Action System

- [x] **72.27.1.1** Implement input action registry (define named actions:
      "Jump", "Attack", "Interact", "Sprint" — independent of physical input)
  - Added `FV2GameInputActionDefinition` and `FV2GameInputActionRegistry` to
    V2Input with required core named actions `Jump`, `Attack`, `Interact`, and
    `Sprint`, boolean value types, player-facing categories, unique action-name
    validation, and physical-input-agnostic policy flags.
  - Wired Blueprint helpers through `BuildDefaultInputActionRegistry`,
    `ValidateInputActionRegistry`, and `FindInputActionDefinition`; the default
    `UV2InputConfigAsset` now carries and validates the registry alongside the
    older Enhanced Input action catalog.
  - Added module automation assertions, contract
    `V2/ue/Content/V2/Input/Actions/InputActionRegistry_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-input-action-registry.py`, V2Input
    module checker coverage, CI workflow wiring, and Horde `inputActionRegistry`
    gates.
- [x] **72.27.1.2** Create input binding system (map actions to physical inputs:
      Jump → Spacebar, Jump → A Button, Jump → Screen Tap — multiple bindings
      per action)
  - Added `FV2GameInputPhysicalBinding` and `FV2GameInputBindingSet` to map
    physical-input-agnostic actions onto default keyboard, gamepad, and touch
    inputs while validating against the `FV2GameInputActionRegistry`; the
    default binding set includes Jump on `Spacebar`, `A Button`, and
    `Screen Tap`, plus multi-device defaults for Attack, Interact, and Sprint.
  - Wired Blueprint helpers through `BuildDefaultInputBindingSet`,
    `ValidateInputBindingSet`, and `FindInputBindingsForAction`; the default
    `UV2InputConfigAsset` now carries and validates `ActionBindingSet`.
  - Added module automation assertions, contract
    `V2/ue/Content/V2/Input/Actions/InputBindingSystem_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-input-binding-system.py`, V2Input module
    checker coverage, CI workflow wiring, and Horde `inputBindingSystem` gates.
- [x] **72.27.1.3** Implement input context system (different action sets for
      different modes: on-foot, driving, swimming, menu, dialogue — auto- switch
      on mode change)
  - Added `EV2GameInputContextMode`, `FV2GameInputContextDefinition`,
    `FV2GameInputContextSet`, and `FV2GameInputContextSwitchResult` so V2Input
    can define on-foot, driving, swimming, menu, and dialogue contexts with
    distinct registered action subsets and validate them against the gameplay
    action registry.
  - Wired Blueprint helpers through `BuildDefaultInputContextSet`,
    `ValidateInputContextSet`, `FindInputContextByMode`, and
    `ResolveInputContextForMode`; mode changes now resolve an
    `Input.Context.AutoSwitchedOnModeChange` result and the default
    `UV2InputConfigAsset` carries `ActionContextSet`.
  - Added module automation assertions, contract
    `V2/ue/Content/V2/Input/Actions/InputContextSystem_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-input-context-system.py`, V2Input module
    checker coverage, CI workflow wiring, and Horde `inputContextSystem` gates.
- [x] **72.27.1.4** Create input binding UI (in-game menu for rebinding all
      actions, conflict detection, reset to defaults)
  - Added `FV2InputBindingUIScreenContract`, `FV2InputBindingUIActionRow`,
    `FV2InputBindingUIConflict`, and `FV2InputBindingUIResetResult` for the
    in-game `Settings.Controls.BindingUI` menu backed by the named action
    registry and default binding set.
  - Wired Blueprint helpers through `BuildDefaultInputBindingUIContract`,
    `ValidateInputBindingUIContract`, `DetectInputBindingUIConflicts`, and
    `ResetInputBindingUIToDefaults`, with conflict detection, overwrite
    confirmation, controller-first focus, and reset to defaults covered by
    module automation assertions.
  - Added contract
    `V2/ue/Content/V2/UI/Settings/InputBindingUI_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-input-binding-ui.py`, broad V2UI checker
    coverage, CI workflow wiring, and Horde `inputBindingUI` gates.
- [x] **72.27.1.5** Implement input binding persistence (save custom bindings
      per player, load on startup, export/import)
  - Added `FV2GameInputBindingPersistenceProfile` for per-player custom
    named-action binding sets, with startup-load validation, conflict-free
    checks, default slot fallback preservation, and deterministic
    `V2INPUTBINDINGS:` export/import payloads.
  - Threaded the profile through `FV2PlayerSettingsSnapshot`, `UV2SaveGame`,
    `UV2PersistenceBlueprintLibrary`, and `UV2PersistenceSubsystem` via
    `SaveInputBindingPersistenceProfile`,
    `GetStartupInputBindingPersistenceProfile`,
    `MarkInputBindingsAppliedOnStartup`, `ExportInputBindingPersistenceProfile`,
    and `ImportInputBindingPersistenceProfile`.
  - Added input and persistence automation assertions for custom `Keyboard.F`
    rebinding round trips, account-mismatch rejection, startup readiness, and
    runtime snapshot visibility, plus contract
    `V2/ue/Content/V2/Input/Actions/InputBindingPersistence_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-input-binding-persistence.py`, CI
    wiring, and Horde `inputBindingPersistence` gates.
- [x] **72.27.1.6** Create combo input detection (detect input sequences:
      forward-forward-attack = dash attack, configurable combo windows)
  - Added `EV2GameInputComboStepKind`, `FV2GameInputComboStep`,
    `FV2GameInputComboDefinition`, `FV2GameInputComboCatalog`,
    `FV2GameInputComboDetectionRequest`, and `FV2GameInputComboDetectionResult`
    to V2Input for designer-authored direction/button combo sequences with
    configurable per-step and total frame windows.
  - Wired Blueprint helpers through `BuildDefaultInputComboCatalog`,
    `ValidateInputComboCatalog`, `FindInputComboDefinition`, and
    `DetectInputComboSequence`; the default `Input.Combo.DashAttack` catalog
    maps forward, neutral-reset forward, and light attack to
    `Command.Combo.DashAttack`, consumes the trigger button, and supports
    facing-normalized detection from the existing `FV2InputBufferRing`.
  - Added module automation assertions for dash-attack detection, neutral-reset
    rejection, tight-window rejection, facing-left normalization, and
    `UV2InputConfigAsset` catalog validation, plus contract
    `V2/ue/Content/V2/Input/Actions/InputComboDetection_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-input-combo-detection.py`, CI
    workflow wiring, and Horde `inputComboDetection` gates.
- [x] **72.27.1.7** Implement input buffering (queue inputs during animations or
      lag, execute when possible — critical for responsive combat)
  - Added `EV2BufferedInputBlockReason`, `FV2InputBufferQueuePolicy`,
    `FV2BufferedInputCommand`, `FV2BufferedInputQueue`,
    `FV2BufferedInputExecutionRequest`, and `FV2BufferedInputExecutionResult`
    for a deterministic runtime command queue layered over the existing frame
    input buffer windows.
  - Wired Blueprint helpers through `BuildDefaultInputBufferQueuePolicy`,
    `BuildBufferedInputQueue`, `MakeBufferedInputCommand`,
    `EnqueueBufferedInputCommand`, and `ResolveBufferedInputExecution`; the
    default `Input.Buffer.QueuePolicy.V2` queues during animation lock and
    network lag, drops expired commands, consumes executed commands, and drains
    the highest-priority oldest command once execution is possible.
  - Added module automation assertions for animation-lock deferral, network-lag
    deferral, execute-when-possible behavior, expiry, and `UV2InputConfigAsset`
    policy validation, plus contract
    `V2/ue/Content/V2/Input/Actions/InputBuffering_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-input-buffering.py`, CI workflow wiring, and
    Horde `inputBuffering` gates.
- [x] **72.27.1.8** Create input axis processing (dead zones, response curves,
      sensitivity, inversion — per-axis per-device configurable)
  - Added `EV2InputAxisResponseCurve`, `FV2InputAxisProcessingRule`,
    `FV2InputAxisProcessingProfile`, `FV2InputAxisProcessingRequest`, and
    `FV2InputAxisProcessingResult` for per-device/per-axis scalar processing
    with configurable dead zones, outer dead zones, response curves,
    sensitivity, inversion, normalization, and output clamping.
  - Wired Blueprint helpers through `BuildDefaultInputAxisProcessingProfile`,
    `ValidateInputAxisProcessingProfile`, `FindInputAxisProcessingRule`, and
    `ProcessInputAxisValue`; the default `Input.AxisProcessing.Profile.V2`
    covers PC gamepad movement, PS5 camera look with inverted Y, XSX trigger
    sensitivity, and mobile touch look axes.
  - Added module automation assertions for dead-zone suppression, response curve
    and sensitivity shaping, camera Y inversion, trigger clamping, missing-rule
    failure, and `UV2InputConfigAsset` profile validation, plus contract
    `V2/ue/Content/V2/Input/Actions/InputAxisProcessing_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-input-axis-processing.py`, CI
    workflow wiring, and Horde `inputAxisProcessing` gates.
- [x] **72.27.1.9** Implement platform-specific button prompt icons (detect
      active input device, show correct platform icons: PlayStation glyphs for
      DualSense, Xbox glyphs for Xbox controller, keyboard icons for K+M)
  - Verified the existing V2UI prompt icon routing covers this input-system
    requirement through `FV2PlatformInputPromptIconPolicy`,
    `FV2PlatformInputPromptIconRoute`, `FV2PlatformInputPromptIconRequest`, and
    `FV2ResolvedPlatformInputPromptIcon`, with route coverage for
    keyboard/mouse, PC DualSense, PC Xbox/XInput, generic PC gamepad, native PS5
    DualSense, native XSX gamepad, and Switch2.
  - Reused `ResolvePlatformInputPromptIcon` and the
    `PlatformInputPromptIcons.V2` policy so prompts show PlayStation glyphs for
    DualSense, Xbox glyphs for Xbox controllers, keyboard icons for K+M, and
    deterministic keyboard fallback for unresolved platforms.
  - Extended `PlatformInputPromptIcons_V2_Contract.json`,
    `check-v2-platform-input-prompt-icons.py`, docs, automation assertion
    labels, and Horde `platformInputPromptIcons` gates to explicitly cover both
    Section 72.21.1.13 and input-system item 72.27.1.9.
- [x] **72.27.1.10** Create touch input gesture detection (tap, double-tap,
      swipe, pinch, rotate — mapped to actions for mobile)
  - Added `EV2TouchGestureKind`, `FV2TouchGestureSample`, `FV2TouchGestureRule`,
    `FV2TouchGestureCatalog`, `FV2TouchGestureDetectionRequest`, and
    `FV2TouchGestureDetectionResult` to V2Input for deterministic mobile touch
    gesture samples, authored thresholds, action/command mapping, and detection
    results.
  - Wired Blueprint helpers through `BuildDefaultTouchGestureCatalog`,
    `ValidateTouchGestureCatalog`, `FindTouchGestureRule`, and
    `DetectTouchInputGesture`; the default `Input.TouchGesture.Catalog.V2` maps
    tap to `Jump`, double-tap to `Attack`, swipe to `Sprint`, pinch to
    `Touch.Zoom`, and rotate to `Touch.RotateCamera`.
  - Added module automation assertions for tap, double-tap, swipe, pinch,
    rotate, threshold no-match, and `UV2InputConfigAsset` catalog validation,
    plus contract
    `V2/ue/Content/V2/Input/Actions/TouchGestureDetection_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-touch-gesture-detection.py`, CI
    workflow wiring, and Horde `touchGestureDetection` gates.
- [x] **72.27.1.11** Implement simultaneous multi-device support (K+M and
      controller connected — seamlessly switch prompt icons based on last input
      used)
  - Added `FV2SimultaneousInputDevicePolicy`, `FV2SimultaneousInputDeviceState`,
    `FV2SimultaneousInputDeviceUpdateRequest`, and
    `FV2SimultaneousInputDeviceUpdateResult` to keep K+M and controller devices
    connected while tracking the active prompt source from the latest accepted
    input.
  - Wired Blueprint helpers through `BuildDefaultSimultaneousInputDevicePolicy`,
    `ValidateSimultaneousInputDevicePolicy`,
    `BuildSimultaneousInputDeviceState`, and
    `ResolveSimultaneousInputDeviceUpdate`; results expose
    `bPromptIconRefreshRequired`, active platform/device tags compatible with
    `PlatformInputPromptIcons.V2`, same-device no-refresh behavior, and stale
    input rejection.
  - Added module automation assertions for K+M/gamepad coexistence,
    controller-to-keyboard prompt switching, stable same-device input, stale
    controller rejection, and `UV2InputConfigAsset` policy validation, plus
    contract
    `V2/ue/Content/V2/Input/Actions/SimultaneousInputDevices_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-simultaneous-input-devices.py`, CI
    workflow wiring, and Horde `simultaneousInputDevices` gates.
- [x] **72.27.1.12** Create input recording for testing (record input stream,
      replay for automated testing, deterministic input playback)
  - Evidence (2026-06-24): Added the testing-focused input recording layer in
    V2Input with `FV2TestInputRecordingSettings`, `FV2TestInputRecordedFrame`,
    `FV2TestInputRecordingStream`, `FV2TestInputPlaybackCursor`, and
    `FV2TestInputPlaybackStep`. `UV2InputBlueprintLibrary` now exposes
    `BuildDefaultTestInputRecordingSettings`, `BeginTestInputRecording`,
    `RecordTestInputFrame`, `FinalizeTestInputRecording`,
    `BuildTestInputPlaybackCursor`, `ReplayTestInputFrame`, and
    `AdvanceTestInputPlaybackCursor` so automation can capture a recorded input
    stream, reject duplicate/out-of-order frames, finalize a deterministic
    stream hash, replay exact frames, and advance to deterministic
    end-of-stream. `UV2InputConfigAsset` exposes and validates the default test
    recording settings. Added module automation assertions for recorded input
    stream capture, duplicate frame rejection, deterministic input playback,
    replay-marked samples, and cursor end-of-stream handling, plus contract
    `V2/ue/Content/V2/Input/Actions/InputRecordingForTesting_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-input-recording-for-testing.py`, CI
    workflow wiring, and Horde `inputRecordingForTesting` gates.
- [x] **72.27.1.13** Implement haptic feedback binding (actions trigger haptic
      effects: weapon fire → rumble, landing → impact, DualSense adaptive
      triggers)
  - Evidence (2026-06-24): Added `EV2HapticFeedbackEffectKind`,
    `FV2HapticFeedbackBinding`, `FV2HapticFeedbackBindingCatalog`,
    `FV2HapticFeedbackResolveRequest`, and `FV2HapticFeedbackResolveResult` in
    V2Input. `UV2InputBlueprintLibrary` now exposes
    `BuildDefaultHapticFeedbackBindingCatalog`,
    `ValidateHapticFeedbackBindingCatalog`, `FindHapticFeedbackBinding`, and
    `ResolveHapticFeedbackBinding` with defaults for weapon-fire rumble, landing
    impact, Xbox/PC gamepad rumble, and DualSense adaptive trigger resistance on
    `DualSense.R2`. `UV2InputConfigAsset` exposes and validates the catalog.
    Added module automation assertions for weapon-fire rumble, landing impact,
    DualSense adaptive trigger resolution, unsupported haptic device rejection,
    unsupported adaptive-trigger rejection, plus contract
    `V2/ue/Content/V2/Input/Actions/HapticFeedbackBinding_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-haptic-feedback-binding.py`, CI
    workflow wiring, and Horde `hapticFeedbackBinding` gates.
- [x] **72.27.1.14** Create input debugging overlay (show raw input, processed
      input, active context, current bindings, combo state)
  - Evidence (2026-06-24): Added the V2UI input debugging overlay request/spec
    layer, `UV2InputDebuggingOverlay`, and Blueprint builders that generate
    stable top-left HUD rows for raw input, processed input, active context,
    current bindings, and combo state. Added UI automation assertions for the
    explicit raw input, processed input, active context, current bindings, and
    combo state fixture, the toggleable gameplay-inert HUD entry, and widget
    handoff, plus contract
    `V2/ue/Content/V2/UI/HUD/InputDebuggingOverlay_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-input-debugging-overlay.py`, CI workflow
    wiring, and Horde `inputDebuggingOverlay` gates.
- [x] **72.27.1.15** Implement input system documentation and binding
      configuration guide
  - Evidence (2026-06-24): Added
    `V2/docs/input/input-system-binding-configuration-guide.md` as the canonical
    guide for action registry, mapping contexts, binding slots, binding UI,
    per-player remaps, persistence, testing, and debugging. Added contract
    `V2/ue/Content/V2/Input/Documentation/InputSystemBindingConfigurationGuide_V2_Contract.json`,
    focused validator `V2/ue/Tools/check-v2-input-system-documentation.py`, CI
    workflow wiring, and Horde `inputSystemDocumentation` gates.

---

### 72.28 Audio Middleware Integration (Wwise/FMOD) for Maya Engine

Engine-level binding to Wwise and FMOD, separate from Project Obsidian–specific
tasks.

#### 72.28.1 Audio Middleware Binding

- [x] **72.28.1.1** Implement Wwise SDK integration (initialize Wwise sound
      engine, load soundbanks, post events, set RTPCs, set switches/states)
  - Evidence (2026-06-24): Added a cook-safe Wwise SDK integration bridge in
    V2Audio with `FV2WwiseSDKIntegrationPlan`, `FV2WwiseSDKSoundBankSpec`,
    `FV2WwiseSDKEventSpec`, `FV2WwiseSDKCommandRequest`, and
    `FV2WwiseSDKCommandResult`. `UV2AudioBlueprintLibrary` and
    `UV2AudioSubsystem` now expose commands to initialize sound engine, load
    soundbanks, post events, set RTPCs, switches, and states while requiring
    ADR/licensing approval, optional SDK binaries, native fallback, and
    rollback-inert behavior. Added module automation assertions, default config
    validation, contract
    `V2/ue/Content/V2/Audio/WwiseSDKIntegration_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-wwise-sdk-integration.py`, CI workflow
    wiring, and Horde `wwiseSDKIntegration` gates.
- [x] **72.28.1.2** Create FMOD Studio integration (initialize FMOD system, load
      banks, create event instances, set parameters)
  - Evidence (2026-06-24): Added a cook-safe FMOD Studio integration bridge in
    V2Audio with `FV2FMODStudioIntegrationPlan`, `FV2FMODStudioBankSpec`,
    `FV2FMODStudioEventSpec`, `FV2FMODStudioParameterSpec`,
    `FV2FMODStudioCommandRequest`, and `FV2FMODStudioCommandResult`.
    `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose commands to
    initialize FMOD system, load banks, create event instances, and set
    parameters while keeping FMOD Studio binaries optional in source,
    ADR/licensing gated, native-fallback safe, and rollback inert. Added module
    automation assertions, default config validation, contract
    `V2/ue/Content/V2/Audio/FMODStudioIntegration_V2_Contract.json`, static
    validator `V2/ue/Tools/check-v2-fmod-studio-integration.py`, CI workflow
    wiring, and Horde `fmodStudioIntegration` gates.
- [x] **72.28.1.3** Implement audio middleware abstraction layer (unified API
      over Wwise/FMOD/custom — switch middleware without changing game code)
  - Evidence (2026-06-24): Added the V2Audio audio middleware abstraction layer
    with `EV2AudioMiddlewareProvider`, `EV2AudioMiddlewareUnifiedCommandKind`,
    `FV2AudioMiddlewareUnifiedRoute`, `FV2AudioMiddlewareUnifiedRequest`,
    `FV2ResolvedAudioMiddlewareCommand`, and
    `FV2AudioMiddlewareAbstractionLayer`. `UV2AudioBlueprintLibrary` and
    `UV2AudioSubsystem` now expose a unified API over Wwise, FMOD, and custom
    providers for gameplay event triggers and control values, with active
    provider switching through config/subsystem state so gameplay code can
    switch middleware without changing game code. Added module automation,
    default config validation, runtime snapshot evidence, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareAbstractionLayer_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-abstraction-layer.py`, CI workflow
    wiring, and Horde `audioMiddlewareAbstractionLayer` gates.
- [x] **72.28.1.4** Create spatial audio source management via middleware
      (register game objects with middleware, update 3D positions per frame)
  - Evidence (2026-06-24): Added the V2Audio audio middleware spatial source
    manager with `FV2AudioMiddlewareSpatialSourceSpec`,
    `FV2AudioMiddlewareSpatialSourceCommandRequest`,
    `FV2AudioMiddlewareSpatialSourceCommandResult`, and
    `FV2AudioMiddlewareSpatialSourceManager` so Wwise, FMOD, and custom
    providers can register game objects with middleware and update 3D positions
    per frame in Unreal centimeters. `UV2AudioBlueprintLibrary` and
    `UV2AudioSubsystem` now expose source registration and transform update
    helpers, runtime snapshots record manager/game-object/update readiness, and
    default config validation keeps the manager rollback inert with native
    fallback allowed. Added module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareSpatialSourceManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-spatial-source-manager.py`, CI
    workflow wiring, and Horde `audioMiddlewareSpatialSourceManager` gates.
- [x] **72.28.1.5** Implement listener management (register camera as listener,
      update position/orientation, multi-listener for split-screen)
  - Evidence (2026-06-24): Added the V2Audio audio middleware listener manager
    with `FV2AudioMiddlewareListenerSpec`,
    `FV2AudioMiddlewareListenerCommandRequest`,
    `FV2AudioMiddlewareListenerCommandResult`, and
    `FV2AudioMiddlewareListenerManager` so Wwise, FMOD, and custom providers can
    register camera as listener, update position/orientation per frame in Unreal
    centimeters, and support multi-listener for split-screen player cameras.
    `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose
    listener-manager registration, camera-listener registration, and listener
    transform update helpers; runtime snapshots record camera listener,
    transform/orientation, and split-screen multi-listener readiness. Added
    module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareListenerManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-listener-manager.py`, CI workflow
    wiring, and Horde `audioMiddlewareListenerManager` gates.
- [x] **72.28.1.6** Create environment/reverb zone integration (define acoustic
      zones in world, send zone info to middleware for reverb/occlusion)
  - Evidence (2026-06-24): Added the V2Audio audio middleware environment zone
    manager with `FV2AudioMiddlewareEnvironmentZoneSpec`,
    `FV2AudioMiddlewareEnvironmentZoneCommandRequest`,
    `FV2AudioMiddlewareEnvironmentZoneCommandResult`, and
    `FV2AudioMiddlewareEnvironmentZoneManager` so Wwise, FMOD, and custom
    providers can define acoustic zones in world and send zone info to
    middleware for reverb/occlusion. `UV2AudioBlueprintLibrary` and
    `UV2AudioSubsystem` now expose environment-zone manager registration,
    acoustic zone registration, and per-listener reverb/occlusion zone-info
    sends; runtime snapshots record acoustic-zone definition, reverb send, and
    occlusion send readiness. Added module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareEnvironmentZoneManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-environment-zone-manager.py`, CI
    workflow wiring, and Horde `audioMiddlewareEnvironmentZoneManager` gates.
- [x] **72.28.1.7** Implement audio occlusion/obstruction raycasting (cast rays
      from listener to sources, report occlusion to middleware)
  - Evidence (2026-06-24): Added the V2Audio audio middleware occlusion raycast
    manager with `FV2AudioMiddlewareOcclusionRaycastProfile`,
    `FV2AudioMiddlewareOcclusionRaycastRequest`,
    `FV2AudioMiddlewareOcclusionRaycastResult`, and
    `FV2AudioMiddlewareOcclusionRaycastManager` so Wwise, FMOD, and custom
    providers can cast rays from listener to sources, compute obstruction from
    geometry hits, report occlusion to middleware, and report obstruction to
    middleware. `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose
    raycast-manager registration, listener-source ray evaluation, and middleware
    occlusion/obstruction reporting; runtime snapshots record raycast,
    occlusion-report, and obstruction-report readiness. Added module automation,
    contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareOcclusionRaycastManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-occlusion-raycast-manager.py`, CI
    workflow wiring, and Horde `audioMiddlewareOcclusionRaycastManager` gates.
- [x] **72.28.1.8** Create soundbank streaming management (load/unload
      soundbanks based on world streaming, memory budget)
  - Evidence (2026-06-24): Added the V2Audio audio middleware soundbank
    streaming manager with `FV2AudioMiddlewareSoundbankStreamingBankSpec`,
    `FV2AudioMiddlewareSoundbankStreamingRequest`,
    `FV2AudioMiddlewareSoundbankStreamingResult`, and
    `FV2AudioMiddlewareSoundbankStreamingManager` so Wwise, FMOD, and custom
    providers can load soundbanks for visible world streaming chunks, unload
    soundbanks for hidden chunks, preload pending world chunks, and reject
    over-budget streaming requests against a memory budget.
    `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose
    soundbank-streaming manager registration plus load, unload, and preload
    helpers; runtime snapshots record streaming manager registration, world
    load/unload/preload readiness, and memory-budget readiness. Added module
    automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareSoundbankStreamingManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-soundbank-streaming-manager.py`, CI
    workflow wiring, and Horde `audioMiddlewareSoundbankStreamingManager` gates.
- [x] **72.28.1.9** Implement audio middleware profiling integration (show
      middleware CPU usage, voice count, memory in engine profiler)
  - Evidence (2026-06-24): Added the V2Audio audio middleware profiling
    integration with `FV2AudioMiddlewareProfilingProviderProfile`,
    `FV2AudioMiddlewareProfilingRequest`, `FV2AudioMiddlewareProfilingResult`,
    and `FV2AudioMiddlewareProfilingIntegration` so Wwise, FMOD, and custom
    providers expose middleware CPU usage, active voice count, and memory usage
    samples for engine-profiler publishing. `UV2AudioBlueprintLibrary` and
    `UV2AudioSubsystem` now expose profiling integration registration, frame
    metric capture, and engine-profiler publishing helpers; runtime snapshots
    record CPU, voice-count, memory, and engine-profiler readiness plus the last
    published profiling sample. Added module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareProfilingIntegration_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-profiling-integration.py`, CI
    workflow wiring, and Horde `audioMiddlewareProfilingIntegration` gates.
- [x] **72.28.1.10** Create audio event triggering from gameplay (footstep
      surface detection → post Wwise event with surface switch, weapon fire →
      post event with weapon RTPC)
  - Evidence (2026-06-24): Added the V2Audio audio middleware gameplay event
    trigger manager with `FV2AudioMiddlewareGameplayEventTriggerRule`,
    `FV2AudioMiddlewareGameplayEventTriggerRequest`,
    `FV2AudioMiddlewareGameplayEventTriggerResult`, and
    `FV2AudioMiddlewareGameplayEventTriggerManager` so gameplay footstep surface
    detection posts middleware footstep events with provider surface switches
    and weapon fire posts middleware weapon events with weapon fire RTPC values.
    `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose gameplay
    trigger manager registration plus footstep-from-surface and weapon-fire
    helpers routed through the existing Wwise/FMOD/custom abstraction layer;
    runtime snapshots record footstep surface detection, surface switch, weapon
    fire, and weapon RTPC readiness plus the last gameplay trigger result. Added
    module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareGameplayEventTriggerManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-gameplay-event-trigger-manager.py`,
    CI workflow wiring, and Horde `audioMiddlewareGameplayEventTriggerManager`
    gates.
- [x] **72.28.1.11** Implement audio middleware project auto-generation
      (generate Wwise/FMOD project structure matching game's audio events)
  - Evidence (2026-06-24): Added the V2Audio audio middleware project
    auto-generation manager with `FV2AudioMiddlewareProjectGeneratedEvent`,
    `FV2AudioMiddlewareProjectGenerationRequest`,
    `FV2AudioMiddlewareProjectGenerationResult`, and
    `FV2AudioMiddlewareProjectGenerationManager` so Wwise/FMOD project structure
    generation mirrors gameplay audio events for player footsteps and weapon
    fire. `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose project
    generation manager registration plus Wwise and FMOD generation helpers that
    validate generated banks/work units/events/parameters against the gameplay
    abstraction layer while preserving native fallback and rollback-inert
    behavior; runtime snapshots record project generation readiness,
    gameplay-event matching, generated event count, and the last generated
    project path. Added module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareProjectGenerationManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-project-generation-manager.py`, CI
    workflow wiring, and Horde `audioMiddlewareProjectGenerationManager` gates.
- [x] **72.28.1.12** Create audio middleware hot-reload for development (reload
      soundbanks without restarting game)
  - Evidence (2026-06-24): Added the V2Audio audio middleware hot-reload manager
    with `FV2AudioMiddlewareHotReloadBankSpec`,
    `FV2AudioMiddlewareHotReloadRequest`, `FV2AudioMiddlewareHotReloadResult`,
    and `FV2AudioMiddlewareHotReloadManager` so Wwise, FMOD, and custom
    development-only soundbanks can reload soundbanks without restarting game
    while rejecting non-development sessions and stale revision changes.
    `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose hot-reload
    manager registration plus Wwise, FMOD, and custom soundbank reload helpers
    that flush loaded banks, repost registered events, preserve native fallback,
    and remain rollback inert; runtime snapshots record hot-reload readiness,
    provider coverage, bank count, last hot-reloaded bank, revision, and
    no-restart status. Added module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareHotReloadManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-hot-reload-manager.py`, CI workflow
    wiring, and Horde `audioMiddlewareHotReloadManager` gates.
- [x] **72.28.1.13** Implement audio middleware fallback (if middleware not
      available, fall back to maya-audio built-in system)
  - Evidence (2026-06-24): Added the V2Audio audio middleware fallback manager
    with `FV2AudioMiddlewareFallbackRoute`, `FV2AudioMiddlewareFallbackRequest`,
    `FV2AudioMiddlewareFallbackResult`, and `FV2AudioMiddlewareFallbackManager`
    so Wwise, FMOD, and custom middleware routes fall back to the maya-audio
    built-in system when middleware unavailable states are detected.
    `UV2AudioBlueprintLibrary` and `UV2AudioSubsystem` now expose fallback
    manager registration plus Wwise, FMOD, and custom fallback helpers that
    mirror gameplay audio events, reject available middleware and missing
    maya-audio runtime states, preserve native runtime fallback, and remain
    rollback inert; runtime snapshots record fallback manager registration,
    maya-audio readiness, unavailable-middleware fallback readiness, gameplay
    event mirroring, route count, and the last fallback runtime. Added module
    automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareFallbackManager_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-fallback-manager.py`, CI workflow
    wiring, and Horde `audioMiddlewareFallbackManager` gates.
- [x] **72.28.1.14** Create audio middleware build pipeline integration (cook
      soundbanks per platform during content cook)
  - Evidence (2026-06-24): Added the V2Audio audio middleware build pipeline
    integration with `FV2AudioMiddlewareBuildPipelinePlatformSpec`,
    `FV2AudioMiddlewareBuildPipelineRequest`,
    `FV2AudioMiddlewareBuildPipelineResult`, and
    `FV2AudioMiddlewareBuildPipelineIntegration` so Wwise, FMOD, and custom
    provider soundbanks cook during content cook as deterministic per-platform
    soundbanks for Win64, PS5, and XSX. `UV2AudioBlueprintLibrary` and
    `UV2AudioSubsystem` now expose build pipeline registration plus Wwise, FMOD,
    and custom per-platform cook helpers that consume generated middleware
    projects, emit cooked bank outputs, write dependency sidecars, reject
    missing content cook, reject missing generated middleware projects, preserve
    native fallback, and remain rollback inert; runtime snapshots record build
    pipeline registration, content-cook readiness, per-platform cook readiness,
    dependency sidecar readiness, provider coverage, platform soundbank count,
    and the last cooked output path. Added module automation, contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareBuildPipelineIntegration_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-build-pipeline-integration.py`, CI
    workflow wiring, and Horde `audioMiddlewareBuildPipelineIntegration` gates.
- [x] **72.28.1.15** Implement audio middleware documentation and sound designer
      workflow guide
  - Evidence (2026-06-24): Added the audio middleware sound designer workflow
    guide in `V2/docs/audio/audio-middleware-sound-designer-workflow.md`,
    covering the MetaSounds plus AudioModulation launch runtime, optional
    Wwise/FMOD/custom provider handoff, gameplay event ids, generated middleware
    projects, hot reload development sessions, per-platform soundbanks,
    dependency sidecars, content cook build pipeline requirements, maya-audio
    built-in fallback, and runtime fallback QA signoff. Added contract
    `V2/ue/Content/V2/Audio/AudioMiddlewareSoundDesignerWorkflow_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-audio-middleware-sound-designer-workflow.py`, CI
    workflow wiring, and Horde `audioMiddlewareSoundDesignerWorkflow` gates.

---

### 72.29 Cross-Platform Multiplayer Account System

Link Steam, PSN, Xbox Live, and Epic accounts to a single player identity with
cross-platform progression.

#### 72.29.1 Cross-Platform Identity

- [x] **72.29.1.1** Implement unified player identity service (internal player
      ID that links to multiple platform accounts)
  - Evidence (2026-06-24): Added the V2OnlineServices unified player identity
    service with `FV2UnifiedPlayerIdentityRecord`,
    `FV2UnifiedPlayerIdentityService`,
    `FV2UnifiedPlayerIdentityResolutionRequest`, and
    `FV2UnifiedPlayerIdentityResolutionResult` so one internal player ID maps to
    multiple `@oshun/identity` platform account bindings across Steam, PSN, Xbox
    Live, and Epic Games. `UV2OnlineServicesBlueprintLibrary` and
    `UV2OnlineServicesSubsystem` now expose identity record construction,
    default service registration, platform-account resolution, conflict
    rejection, last-result accessors, and runtime snapshot fields for service
    validity, internal-ID mapping, linked platform-account count, and last
    resolved internal player. Added module automation for four-provider
    resolution, duplicate platform-account rejection, unknown platform-account
    reporting, expected Oshun-account conflict rejection, subsystem resolution,
    and snapshot evidence, plus contract
    `V2/ue/Content/V2/Online/CrossPlatformIdentity/UnifiedPlayerIdentityService_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-unified-player-identity-service.py`,
    CI workflow wiring, and Horde `unifiedPlayerIdentityService` gates.
- [x] **72.29.1.2** Create platform account linking flow (player logs into
      platform A, then links platform B account, verify ownership via OAuth)
  - Evidence (2026-06-24): Added the V2OnlineServices platform account linking
    flow with `FV2PlatformAccountOAuthOwnershipProof`,
    `FV2PlatformAccountLinkingRequest`, `FV2PlatformAccountLinkingResult`, and
    `FV2PlatformAccountLinkingFlow` so an authenticated source platform session
    can link a target platform account only after OAuth ownership proof
    validates PKCE, state nonce, token exchange, provider signature,
    `openid`/`platform.account`/`ownership.verify` scopes, and target subject
    matching. `UV2OnlineServicesBlueprintLibrary` and
    `UV2OnlineServicesSubsystem` now expose OAuth proof builders, link request
    builders, flow validation, OAuth-backed link execution, last-link result
    accessors, and runtime snapshot fields for linking-flow validity, OAuth
    verification, linked target account, and internal player id. Added module
    automation for Steam-to-PSN linking, missing-PKCE rejection, OAuth subject
    mismatch rejection, already-linked target rejection, subsystem linking, and
    snapshot evidence, plus contract
    `V2/ue/Content/V2/Online/CrossPlatformIdentity/PlatformAccountLinkingFlow_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-platform-account-linking-flow.py`, CI
    workflow wiring, and Horde `platformAccountLinkingFlow` gates.
- [x] **72.29.1.3** Implement account merge strategy (when linking, merge
      progression, inventory, achievements — handle conflicts)
  - Evidence (2026-06-24): Added the V2OnlineServices cross-platform account
    merge strategy with `FV2CrossPlatformAccountMergeStrategy`,
    `FV2CrossPlatformAccountMergeRequest`, `FV2CrossPlatformAccountMergeResult`,
    progression, inventory, achievement, and conflict payload structs so a
    completed platform account link can merge account level/XP, summed currency,
    unlocked-content union, per-account vault inventory de-duplicated by item
    id, and achievement progress/unlock state with deterministic conflict
    records. `UV2OnlineServicesBlueprintLibrary` and
    `UV2OnlineServicesSubsystem` now expose merge payload builders, default
    strategy validation, linked-account merge execution, last-result accessors,
    and runtime snapshot fields for configured strategy, completed merge, merged
    progression, inventory de-duplication, achievement merge, conflict
    resolution, internal player id, conflict count, inventory count, and
    achievement count. Added module automation for successful progression,
    inventory, achievement, and cross-progression snapshot merge, explicit
    consent rejection, unresolved-conflict manual review rejection, subsystem
    execution, and snapshot evidence, plus contract
    `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformAccountMergeStrategy_V2_Contract.json`,
    static validator
    `V2/ue/Tools/check-v2-cross-platform-account-merge-strategy.py`, CI workflow
    wiring, and Horde `crossPlatformAccountMergeStrategy` gates.
- [x] **72.29.1.4** Create cross-platform friend system (show friends from all
      linked platforms in unified friends list)
  - Evidence (2026-06-24): Added the V2OnlineServices cross-platform friend
    system with `FV2CrossPlatformFriendSystem`,
    `FV2CrossPlatformUnifiedFriendsListRequest`,
    `FV2CrossPlatformUnifiedFriendsList`, `FV2CrossPlatformUnifiedFriend`, and
    `FV2CrossPlatformUnifiedFriendSource` so friend entries imported from linked
    Steamworks, EOS/Epic, GOG Galaxy, PlayStation SDK, and Xbox GDK providers
    resolve through `FV2UnifiedPlayerIdentityService` into one
    publisher-identity-backed friends list. The resolver de-duplicates native
    platform aliases by internal player id, preserves native platform sources,
    platform display names, icons, session/lobby joinability, presence, and
    streamer-mode redaction evidence, and fails closed when a platform friend
    cannot be resolved to a linked identity. `UV2OnlineServicesBlueprintLibrary`
    and `UV2OnlineServicesSubsystem` now expose default system validation,
    request building, unified-list construction, last-list accessors, and
    runtime snapshot fields for configured system validity, resolved identity
    coverage, native platform/icon display, duplicate alias merges, unified
    friend count, and platform source count. Added automation covering provider
    coverage, linked Steam/PSN/Xbox/Epic friends in one list, duplicate alias
    merging, unresolved-identity rejection, subsystem execution, and snapshot
    evidence, plus contract
    `V2/ue/Content/V2/Online/Social/CrossPlatformFriendSystem_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-cross-platform-friend-system.py`, CI
    workflow wiring, and Horde `crossPlatformFriendSystem` gates.
- [x] **72.29.1.5** Implement cross-platform party/lobby (invite friends across
      platforms to same party, matchmake together)
  - Evidence (2026-06-24): Added the V2OnlineServices cross-platform party/lobby
    system with `FV2CrossPlatformPartyLobbySystem`,
    `FV2CrossPlatformPartyLobbyRequest`, `FV2CrossPlatformPartyLobbyResult`,
    `FV2CrossPlatformPartyLobbyInvite`, and `FV2CrossPlatformPartyLobbyMember`
    so selected unified friends can be invited from linked native platform
    sources into a shared cloud lobby and carried forward as one
    party-preserving `FV2MatchmakingTicket`. The resolver consumes
    `FV2CrossPlatformUnifiedFriendsList`, prefers a non-local linked platform
    invite source when present, routes PlatformDM deep-link invites, requires
    accepted invites before joining the lobby, preserves EOS voice bridge
    evidence, rejects invalid friend selections fail-closed, and writes all
    Oshun account ids into the matchmaking ticket party roster. Added Blueprint
    helpers and subsystem APIs for default system validation, request building,
    party/lobby construction, last-result access, and runtime snapshot fields
    for configured system validity, lobby build state, invite delivery,
    accepted-friend joins, matchmaking preservation, ticket readiness, member
    count, invite count, and matchmaking party size. Added module automation for
    system validation, PSN/Xbox platform invite routing from unified friends,
    deep-link/EOS voice evidence, full-party matchmaking ticket preservation,
    invalid selected-friend rejection, subsystem execution, and snapshot
    evidence, plus contract
    `V2/ue/Content/V2/Online/Social/CrossPlatformPartyLobby_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-cross-platform-party-lobby.py`, CI
    workflow wiring, and Horde `crossPlatformPartyLobby` gates.
- [x] **72.29.1.6** Create cross-platform progression sync (save game state to
      central server, accessible from any platform the player owns the game on)
  - Evidence (2026-06-24): Added the V2OnlineServices cross-platform progression
    sync system with `FV2CrossPlatformProgressionSyncSystem`,
    `FV2CrossPlatformProgressionSyncPayload`,
    `FV2CrossPlatformProgressionSyncRequest`, and
    `FV2CrossPlatformProgressionSyncResult` so a signed central save-game
    payload can update the publisher-account cross-progression snapshot and fan
    out per-platform cloud-save write plans for every linked platform account.
    The resolver validates `FV2CrossProgressionAccountSnapshot`, reuses
    `FV2PlatformCloudSaveSyncPolicy` as the native transport layer, writes a
    central revision id, emits ready `FV2PlatformCloudSaveSyncPlan` payloads for
    linked Steamworks, PlayStation SDK, Xbox GDK, and EOS/Epic accounts, records
    central-server authority, delegates conflicts back to persistence, and fails
    closed when any linked platform lacks a cloud-save route. Added Blueprint
    helpers and subsystem APIs for payload/request building, default system
    validation, sync execution, last-result access, and runtime snapshot fields
    for configured sync validity, central-server sync, all-platform
    accessibility, queued platform plans, linked platform count, and plan count.
    Added automation for central authority, complete profile/currency/unlock/
    achievement payloads, four-platform fanout, platform cloud-save writes,
    missing-route rejection, subsystem execution, and snapshot evidence, plus
    contract
    `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformProgressionSync_V2_Contract.json`,
    static validator `V2/ue/Tools/check-v2-cross-platform-progression-sync.py`,
    CI workflow wiring, and Horde `crossPlatformProgressionSync` gates.
- [x] **72.29.1.7** Implement platform-specific entitlement verification (check
      player owns game on current platform, check DLC ownership per platform) —
      Added `FV2PlatformSpecificEntitlementVerifier`,
      `FV2PlatformSpecificEntitlementVerificationRequest`, and
      `FV2PlatformSpecificEntitlementVerificationResult` to compose the unified
      `@oshun/identity` service with the existing platform entitlement policy.
      The verifier resolves the current platform account before entitlement
      checks, creates current-platform base-game and DLC verification plans,
      allows content loads only after both ownership paths are verified, queues
      provider entitlement API work for missing DLC receipts, and fails closed
      for unlinked current-platform accounts. Added Blueprint and subsystem APIs
      for request building, verifier validation, verification execution,
      last-result access, and runtime snapshot evidence for linked platform,
      base-game ownership, DLC ownership, content-load allow, queued provider
      checks, and plan count. Added automation for current-platform identity,
      base-game ownership, DLC ownership, missing-DLC fail-closed behavior,
      unlinked-account rejection, subsystem execution, and snapshot evidence,
      plus contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/PlatformSpecificEntitlementVerification_V2_Contract.json`,
      static validator
      `V2/ue/Tools/check-v2-platform-specific-entitlement-verification.py`, CI
      workflow wiring, and Horde `platformSpecificEntitlementVerification` gate.
- [x] **72.29.1.8** Create cross-platform ban synchronization (ban on one
      platform applies to all linked platforms) — Added
      `FV2CrossPlatformBanSynchronizationSystem`,
      `FV2CrossPlatformBanSynchronizationRequest`, and
      `FV2CrossPlatformBanSynchronizationResult` to compose unified
      `@oshun/identity` records with the existing FairPlay ban system. The sync
      flow resolves the source platform account, enumerates every linked
      platform account for that internal player, generates one FairPlay account
      ban target per linked platform, requires the source platform to be
      included, applies the ban only when all linked platform accounts are
      enforced, and fails closed for unlinked source platform accounts. Added
      Blueprint and subsystem APIs for request building, system validation,
      synchronization execution, last-result access, and runtime snapshot
      evidence for source linkage, all-platform fanout, FairPlay enforcement,
      linked-platform count, synced-ban count, and source platform id. Added
      automation for identity fanout, FairPlay enforcement, unlinked-source
      fail-closed behavior, subsystem execution, and snapshot evidence, plus
      contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformBanSynchronization_V2_Contract.json`,
      static validator
      `V2/ue/Tools/check-v2-cross-platform-ban-synchronization.py`, CI workflow
      wiring, and Horde `crossPlatformBanSynchronization` gates.
- [x] **72.29.1.9** Implement account unlinking (safely disconnect a platform
      account, preserve progression on remaining linked accounts) — Added
      `FV2PlatformAccountUnlinkingFlow`, `FV2PlatformAccountUnlinkingRequest`,
      and `FV2PlatformAccountUnlinkingResult` to safely remove exactly one
      linked platform account from an `@oshun/identity` binding while carrying
      the cross-progression profile, shared wallet, currency balance, and
      unlocked content forward to every remaining linked platform account. The
      unlinking flow requires a linked target account, verifies the identity and
      progression snapshots describe the same accounts, fails closed for missing
      targets, rejects unlinking that would leave fewer than two linked accounts
      under the current cross-progression invariant, and records audit and
      runtime snapshot evidence for target removal, progression preservation,
      retained-account counts, removed-account count, and last unlinked platform
      id. Added Blueprint and subsystem APIs for request building, flow
      validation, unlink execution, last-result access, and snapshot updates,
      plus automation for safe unlinking, shared progression preservation,
      unlinked-target rejection, remaining-account minimum fail-closed behavior,
      subsystem execution, and snapshot evidence, plus contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/PlatformAccountUnlinking_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-platform-account-unlinking.py`, CI
      workflow wiring, and Horde `platformAccountUnlinking` gate.
- [x] **72.29.1.10** Create cross-platform voice chat (route voice through
      central server, not platform-specific voice, so cross-platform parties can
      voice chat) — Added `FV2CrossPlatformVoiceChatSystem`,
      `FV2CrossPlatformVoiceChatRequest`, `FV2CrossPlatformVoiceChatResult`, and
      `FV2CrossPlatformVoiceMemberRoute` to compose a built cross-platform party
      lobby into a central `OshunVoiceRelay` voice session. The voice system
      creates one encrypted Opus central-server route per party member, disables
      platform-native voice, requires moderation capture and speech-to-text,
      caps party voice rooms at eight members, and fails closed when
      platform-native voice fallback is detected. Added Blueprint and subsystem
      APIs for system validation, request building, voice-session construction,
      last-result access, and runtime snapshot evidence for central routing,
      native voice disablement, moderation readiness, member count, route count,
      and last voice session id. Added automation for central-server route
      fanout, platform-native voice rejection, subsystem execution, and snapshot
      evidence, plus contract
      `V2/ue/Content/V2/Online/Social/CrossPlatformVoiceChat_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-cross-platform-voice-chat.py`, CI
      workflow wiring, and Horde `crossPlatformVoiceChat` gate.
- [x] **72.29.1.11** Implement display name system (player chooses one display
      name shown cross-platform, distinct from platform usernames) — Added
      `FV2CrossPlatformDisplayNameSystem`, `FV2CrossPlatformDisplayNameRequest`,
      `FV2CrossPlatformDisplayNameResult`, and
      `FV2CrossPlatformDisplayNameProjection` to make `@oshun/identity` the
      source of truth for one publisher display name while preserving each
      linked platform username for native surfaces. The display-name system
      normalizes candidates for uniqueness, rejects reserved names and
      collisions with linked platform usernames, applies reserved-word
      moderation, propagates accepted names back to the Oshun identity binding
      and unified identity record, and emits one cross-platform social
      projection per linked account. Added Blueprint and subsystem APIs for
      default system validation, request building, display-name updates,
      last-result access, and runtime snapshot evidence for update state,
      platform-username separation, social projection, projection count, and
      Oshun account id. Added automation for successful publisher display-name
      updates, per-platform projection, platform username collision rejection,
      reserved-name rejection, subsystem execution, and snapshot evidence, plus
      contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformDisplayName_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-cross-platform-display-name.py`, CI
      workflow wiring, and Horde `crossPlatformDisplayName` gate.
- [x] **72.29.1.12** Create cross-platform matchmaking (match players regardless
      of platform, optional platform filter for opt-out) — Added
      `FV2CrossPlatformMatchmakingSystem`, `FV2CrossPlatformMatchmakingRequest`,
      and `FV2CrossPlatformMatchmakingResult` to wrap the existing
      `FV2MatchmakingTicket`/queue/candidate scorer with explicit cross-platform
      behavior. The system matches across platforms by default when mutual
      crossplay is enabled, reuses the existing search expansion and quality
      scoring, records matched candidate platform evidence, and applies an
      opt-out platform filter that keeps a player on their own platform when
      requested. Added Blueprint and subsystem APIs for default system
      validation, request building, match execution, last-result access, and
      runtime snapshot evidence for matched state, cross-platform pairing,
      platform-filter use, opt-out respect, eligible candidate count, and
      matched candidate id. Added automation for default cross-platform
      matching, optional platform-filter opt-out, subsystem execution, and
      snapshot evidence, plus contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformMatchmaking_V2_Contract.json`,
      static validator `V2/ue/Tools/check-v2-cross-platform-matchmaking.py`, CI
      workflow wiring, and Horde `crossPlatformMatchmaking` gate.
- [x] **72.29.1.13** Implement GDPR/CCPA compliance for account data (data
      export, account deletion propagated across all linked platforms) — Added
      `FV2AccountDataPrivacyComplianceSystem`, `FV2AccountDataPrivacyRequest`,
      `FV2AccountDataPrivacyResult`, `FV2AccountDataExportBundle`, and
      `FV2LinkedPlatformAccountDeletionPlan` to make `@oshun/identity` the
      source of truth for verified GDPR/CCPA data-subject requests. The system
      exports machine-readable JSON account bundles containing the Oshun
      identity profile and every linked platform account, requires explicit
      deletion confirmation, tombstones the publisher identity, disables unified
      identity lookup, and queues one deletion propagation plan per linked
      platform account. Added Blueprint and subsystem APIs for system
      validation, export request building, deletion request building, export
      execution, deletion propagation, last-result access, and runtime snapshot
      evidence for privacy system validity, linked-platform fanout,
      deletion-plan count, request id, and Oshun account id. Added automation
      for GDPR/CCPA export, all-platform deletion propagation, missing
      confirmation rejection, subsystem export/deletion, and snapshot evidence,
      plus contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/AccountDataPrivacyCompliance_V2_Contract.json`,
      static validator
      `V2/ue/Tools/check-v2-account-data-privacy-compliance.py`, CI workflow
      wiring, and Horde `accountDataPrivacyCompliance` gate.
- [x] **72.29.1.14** Create cross-platform identity admin tools (customer
      support dashboard: view linked accounts, merge/split, ban management) —
      Added `FV2CrossPlatformIdentityAdminToolset`,
      `FV2CrossPlatformIdentityAdminDashboardRequest`,
      `FV2CrossPlatformIdentityAdminDashboardResult`,
      `FV2CrossPlatformIdentityAdminLinkedAccountRow`, and
      `EV2CrossPlatformIdentityAdminActionType` to compose the `@oshun/identity`
      unified identity service with the existing account merge, platform
      split/unlinking, and cross-platform ban synchronization contracts. The
      support dashboard builder renders one linked-account row per platform
      account, exposes merge/split/ban management affordances, requires
      authenticated identity-support agents and audit trail capture, and records
      dense table-first operational workspace evidence without a marketing hero.
      Added Blueprint and subsystem APIs for toolset validation, dashboard
      request construction, dashboard building, last-result access, and runtime
      snapshot evidence for toolset validity, dashboard build state,
      merge/split/ban tool visibility, linked-account row count, and target
      Oshun account id. Added direct automation for the linked-account viewer,
      merge/split/ban controls, unauthenticated support rejection, subsystem
      dashboard build, and snapshot evidence, plus contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformIdentityAdminTools_V2_Contract.json`,
      static validator
      `V2/ue/Tools/check-v2-cross-platform-identity-admin-tools.py`, CI workflow
      wiring, and Horde `crossPlatformIdentityAdminTools` gate.
- [x] **72.29.1.15** Implement cross-platform identity documentation and
      integration guide — Added
      `V2/docs/online/cross-platform-identity-integration-guide.md` as the
      consolidated integration handoff for V2 cross-platform identity. The guide
      documents `@oshun/identity` as the source of truth, the
      `FV2UnifiedPlayerIdentityService` runtime surface, linked platform account
      lifecycle sequencing, account merge/split invariants, cross-progression
      and entitlement routing, display-name and matchmaking behavior, unified
      friend/party/voice identity consumption, ban synchronization, GDPR/CCPA
      data handling, identity support dashboard operations, runtime snapshot
      evidence, and the validation command set for every related identity/social
      gate. Added contract
      `V2/ue/Content/V2/Online/CrossPlatformIdentity/CrossPlatformIdentityIntegrationGuide_V2_Contract.json`,
      static validator
      `V2/ue/Tools/check-v2-cross-platform-identity-integration-guide.py`, CI
      workflow wiring, and Horde `crossPlatformIdentityIntegrationGuide` gate.

---

### 72.30 Shader Compilation & Variant Management (Maya Engine)

Shader permutation management, PSO caching, platform compilation, and debugging
for the Maya renderer specifically.

#### 72.30.1 Shader Pipeline

- [x] **72.30.1.1** Implement shader source management (WGSL as primary shading
      language, organized by feature: lighting, shadows, materials, post-
      process)
  - Completed via `shader_source_management` in `maya-renderer`, with WGSL as
    the primary shader-source language, checked-in feature directories under
    `shaders/maya/lighting`, `shaders/maya/shadows`, `shaders/maya/materials`,
    and `shaders/maya/post_process`, and typed descriptors for source id,
    feature, language, stage, entry point, relative path, and source code.
    `ShaderSourceLibrary::with_core_wgsl_sources` registers the built-in
    lighting, shadow-depth, material, and tonemap WGSL sources; validation
    rejects non-WGSL sources, escaped paths, wrong feature directories, wrong id
    prefixes, missing entry points, missing WGSL stage attributes, duplicate
    ids, duplicate paths, and incomplete feature coverage. The library exports
    validated `ShaderSource` records for the existing shader cache and
    statistics integrations.
    `V2/ue/Build/Shaders/v2-maya-shader-source-management.json`, Horde gates,
    the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-source-management.py` validate WGSL
    primacy, feature layout, descriptor validation, cache integration, checked
    source files, and TODO evidence.
- [x] **72.30.1.2** Create shader permutation system (define feature toggles:
      HAS_NORMAL_MAP, HAS_EMISSIVE, SHADOW_QUALITY_HIGH — generate variants from
      combinations)
  - Completed via `shader_permutation_system` in `maya-renderer`, which defines
    the required `HAS_NORMAL_MAP`, `HAS_EMISSIVE`, and `SHADOW_QUALITY_HIGH`
    toggles, represents combinations with deterministic `ShaderPermutationKey`
    bitsets, and generates all eight combinations per managed shader source.
    `ShaderPermutationGenerator::with_default_toggles` expands the four core
    WGSL sources from `ShaderSourceLibrary` into 32 variants, each carrying
    stable variant ids, `ShaderDefine` lists, `ShaderKey` cache keys,
    compile-request conversion, and warmup-manifest conversion for the existing
    shader cache pipeline.
    `V2/ue/Build/Shaders/v2-maya-shader-permutation-system.json`, Horde gates,
    the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-permutation-system.py` validate the
    required toggles, eight combinations per source, cache-key integration,
    warmup-manifest export, CI wiring, and TODO evidence.
- [x] **72.30.1.3** Implement permutation explosion management (prune unused
      combinations, lazy compilation, shader warm-up prioritization)
  - Completed via `shader_permutation_explosion_management` in `maya-renderer`,
    which analyzes generated permutation manifests against runtime usage samples
    and produces explicit warmup, lazy-compile, or prune decisions. The default
    policy keeps base variants, prunes unused combinations, marks low-use
    variants for lazy compilation, promotes hot variants into priority-sorted
    warmup manifests, and enforces a per-source warmup budget so
    high-cardinality shader sources do not precompile every possible
    permutation. Management plans expose warmup/lazy/pruned counts, pruned
    variant ids, lazy compile request creation, and `WarmupManifest` export for
    the existing shader cache pipeline.
    `V2/ue/Build/Shaders/v2-maya-shader-permutation-explosion-management.json`,
    Horde gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-permutation-explosion-management.py`
    validate pruning, lazy compilation, warmup prioritization, budget
    enforcement, cache/warmup integration, CI wiring, and TODO evidence.
- [x] **72.30.1.4** Create shader cross-compilation pipeline (WGSL → SPIR-V for
      Vulkan, WGSL → DXIL for DX12, WGSL → MSL for Metal via naga/tint)
  - Completed via `shader_cross_compilation_pipeline` in `maya-renderer`, which
    converts generated shader permutation variants into deterministic
    cross-compilation jobs for Vulkan SPIR-V, DX12 DXIL, and Metal MSL. The
    pipeline models Naga validation/emission for WGSL→SPIR-V and WGSL→MSL, Tint
    WGSL→HLSL lowering plus DXC DXIL compilation for DX12, target-specific
    `ShaderBackend` cache keys, output artifact naming, debug-symbol and WGSL
    line-map preservation flags, and callback-based job execution so build or
    runtime hosts can plug in actual compiler processes. The four core WGSL
    sources and eight default permutations produce 96 cross-compilation jobs
    across the three targets.
    `V2/ue/Build/Shaders/v2-maya-shader-cross-compilation-pipeline.json`, Horde
    gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-cross-compilation-pipeline.py` validate
    target coverage, Naga/Tint/DXC stage routing, SPIR-V/DXIL/MSL output
    mapping, manifest job expansion, CI wiring, and TODO evidence.
- [x] **72.30.1.5** Implement Pipeline State Object (PSO) caching (cache
      compiled PSOs to disk, load on next launch to eliminate shader compilation
      stutter)
  - Completed via `pipeline_state_object_cache` in `maya-renderer`, which wraps
    the existing `PipelineCache` with a real disk-backed PSO cache. Compiled
    `PipelineBlob` artifacts are written under a stable artifact directory and
    indexed by a JSON manifest containing `PipelineKey`, backend, renderer
    engine version, driver fingerprint, blob hash, size, and access metadata.
    Startup can warm known `PipelineStateObjectDescriptor` records back into
    memory from disk before gameplay, while stale driver/engine entries, missing
    files, corrupt hashes, backend mismatches, empty blobs, and cache budget
    overflows are rejected so invalid PSOs are rebuilt instead of reused.
    `V2/ue/Build/Shaders/v2-maya-shader-pso-caching.json`, Horde gates, the V2
    CI workflow, and `V2/ue/Tools/check-v2-maya-shader-pso-caching.py` validate
    disk persistence, next-launch loading, driver invalidation, corrupt-artifact
    rebuild behavior, warm-start reporting, CI wiring, and TODO evidence.
- [x] **72.30.1.6** Create shader pre-compilation during content cook (compile
      all required shader variants per platform during build, not at runtime)
  - Completed via `shader_precompilation_cook` in `maya-renderer`, which expands
    generated shader permutation manifests across Linux, Win64, Mac, XSX, and
    Switch2 cook platforms and routes each job through the existing WGSL
    cross-compilation targets for Vulkan SPIR-V, DX12 DXIL, and Metal MSL. The
    default cook plan emits 160 deterministic cooked shader jobs from the 32
    core variants, with shader binary output paths, reflection artifacts,
    dependency sidecars, and PSO seed descriptors so shipping startup can load
    cooked binaries and PSO cache metadata instead of compiling required
    variants at runtime. Managed cook plans exclude pruned variants while still
    precompiling required warmup/lazy variants. Runtime compilation, missing
    reflection data, missing dependency sidecars, missing PSO cache seeding,
    duplicate platforms, and empty platform sets are rejected.
    `V2/ue/Build/Shaders/v2-maya-shader-precompilation-cook.json`, Horde gates,
    the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-precompilation-cook.py` validate platform
    expansion, all-variant cook coverage, no-runtime-compilation policy,
    PSO-cache seeding, CI wiring, and TODO evidence.
- [x] **72.30.1.7** Implement shader hot-reload for development (edit shader
      source, see changes in running engine without restart)
  - Completed via `shader_hot_reload` in `maya-renderer`, an event-driven
    development hot-reload manager that tracks the core WGSL shader source
    catalog, accepts changed source text from editor/file-watcher tooling,
    validates revisions and watched paths, regenerates the affected
    permutations, queues SPIR-V/DXIL/MSL cross-compilation jobs, and reports old
    shader/PSO cache keys to invalidate so the running engine can swap rebuilt
    shaders without restart. The manager rejects disabled or non-development
    sessions, stale revisions, unknown sources, unwatched paths, and invalid
    shader edits before any cache mutation. Valid source edits produce eight
    replacement variants and 24 cross-compilation jobs for the changed core
    source. `V2/ue/Build/Shaders/v2-maya-shader-hot-reload.json`, Horde gates,
    the V2 CI workflow, and `V2/ue/Tools/check-v2-maya-shader-hot-reload.py`
    validate watch-root coverage, development-only guards, no-restart reloads,
    cross-compilation job queuing, cache invalidation, CI wiring, and TODO
    evidence.
- [x] **72.30.1.8** Create shader include/module system (reusable shader
      functions: BRDF library, noise functions, math utilities)
  - Completed via `shader_include_module_system` in `maya-renderer`, a
    WGSL-first include/module registry and composer for reusable shader
    functions. The system registers checked-in math utilities, noise functions,
    and BRDF helper modules under `shaders/maya/include`, validates module IDs,
    WGSL paths, exports, duplicate paths, missing dependencies, and dependency
    cycles, then resolves requested modules in deterministic topological order.
    Core Maya shader sources now have a composition plan that prepends resolved
    include modules before the original source, emits module/source line-span
    metadata for diagnostics, and feeds composed sources into the existing
    shader permutation/cache-key path through `generate_for_composed_source`.
    `V2/ue/Build/Shaders/v2-maya-shader-include-module-system.json`, Horde
    gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-include-module-system.py` validate
    built-in module coverage, dependency resolution, cycle detection, source
    composition, permutation integration, CI wiring, and TODO evidence.
- [x] **72.30.1.9** Implement shader debugging symbols (source-level shader
      debugging in RenderDoc/PIX/Nsight with original WGSL line numbers)
  - Completed via `shader_debugging_symbols` in `maya-renderer`, which builds
    deterministic source-level debug symbol manifests from cross-compile jobs
    and composed WGSL source line spans. The builder emits RenderDoc SPIR-V
    debug-info artifacts for Vulkan jobs, PIX DXIL PDB artifacts for DirectX 12
    jobs, and Nsight-compatible SPIR-V/DXIL debug artifacts while preserving
    original WGSL file paths and line numbers through include-module
    composition. Debug manifests embed WGSL source file records, aggregate
    source maps across the 32 core variants, and reject jobs that disabled debug
    emission, disabled WGSL line-map preservation, or lack composed-source line
    maps before artifact emission. The default core plan produces 128 debug
    artifacts: 32 RenderDoc, 32 PIX, and 64 Nsight.
    `V2/ue/Build/Shaders/v2-maya-shader-debugging-symbols.json`, Horde gates,
    the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-debugging-symbols.py` validate
    RenderDoc/PIX/Nsight coverage, original WGSL line preservation, source
    embedding, CI wiring, and TODO evidence.
- [x] **72.30.1.10** Create shader complexity analysis tool (estimate ALU ops,
      texture fetches, register pressure per shader variant — flag expensive
      shaders)
  - Completed via `shader_complexity_analysis` in `maya-renderer`, a
    source-level WGSL complexity estimator that consumes shader permutation
    variants and reports estimated ALU operations, texture fetches, branch and
    function-call cost, and register pressure using the existing shader
    statistics register classifier. The analyzer scores every variant, sorts
    expensive variants first, groups results by source shader, and emits
    warnings for ALU, texture-fetch, register-pressure, and combined-score
    threshold breaches so costly shader variants can be flagged before shipping
    cook. Core composed shader coverage analyzes all 32 generated variants.
    `V2/ue/Build/Shaders/v2-maya-shader-complexity-analysis.json`, Horde gates,
    the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-complexity-analysis.py` validate ALU
    estimation, texture-fetch counting, register-pressure estimation,
    core-variant coverage, expensive-warning policy, CI wiring, and TODO
    evidence.
- [x] **72.30.1.11** Implement shader variant usage tracking (at runtime, log
      which shader variants are actually used — prune unused in next build)
  - Completed via `shader_variant_usage_tracking` in `maya-renderer`, a runtime
    usage tracker initialized from the shader permutation manifest. It records
    shader variant draw and pipeline-bind events, deduplicates frames while
    accumulating draw calls, exports full `ShaderPermutationUsageProfile`
    samples for used and unused variants, and writes deterministic runtime log
    summaries to `$(SavedDir)/Profiling/MayaShaders/shader-variant-usage.json`.
    The tracker feeds its exported profile into
    `ShaderPermutationExplosionManager` to build the next build's warmup,
    lazy-compile, and prune plan, and rejects disabled tracking, unknown
    variants, zero-draw events, and frame event budget overflows.
    `V2/ue/Build/Shaders/v2-maya-shader-variant-usage-tracking.json`, Horde
    gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-variant-usage-tracking.py` validate
    runtime recording, log summaries, profile export, next-build pruning, event
    validation, CI wiring, and TODO evidence.
- [x] **72.30.1.12** Create shader compilation error reporting (human-readable
      errors with source location, suggestion for fix)
  - Completed via `shader_compilation_error_reporting` in `maya-renderer`, a
    diagnostic reporter that normalizes Naga, Tint, and DXC-style compiler
    output into human-readable shader compilation reports. It parses generated
    line and column locations, maps those lines through include-composed WGSL
    spans back to original shader or include module files, emits highlighted
    source excerpts, classifies syntax, type, missing-symbol, entry-point,
    binding, unsupported-feature, and include-module failures, and attaches
    actionable fix suggestions. The reporter wraps
    `ShaderCrossCompilationError::CompilerFailure` for CI/build logs and rejects
    empty diagnostics, missing source maps, and unmapped generated lines.
    `V2/ue/Build/Shaders/v2-maya-shader-compilation-error-reporting.json`, Horde
    gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-compilation-error-reporting.py` validate
    source-location mapping, include-module diagnostics, suggestions,
    cross-compilation error wrapping, input validation, CI wiring, and TODO
    evidence.
- [x] **72.30.1.13** Implement shader compilation parallelization (compile
      shader variants across all CPU cores, distribute across build farm)
  - Completed via `shader_compilation_parallelization` in `maya-renderer`, a
    scheduler and local executor for `ShaderCrossCompileJob` batches. The
    scheduler chooses local workers from available CPU parallelism, balances
    shader cross-compile jobs across CPU workers by estimated compile cost,
    preserves deterministic job and output ordering, and provides a
    scoped-thread executor for local compiler functions. It also emits
    build-farm shards by cross-compile target and Horde pool, validates farm
    pool coverage, duplicate jobs, empty job sets, shard sizing, and queue
    depth, and integrates `ShaderPermutationManifest` plus
    `ShaderCrossCompilationPipeline` to plan the 32 core variants as 96 target
    jobs. `V2/ue/Build/Shaders/v2-maya-shader-compilation-parallelization.json`,
    Horde gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-compilation-parallelization.py` validate
    local CPU worker scheduling, farm sharding, manifest integration, local
    execution, deterministic plans, input validation, CI wiring, and TODO
    evidence.
- [x] **72.30.1.14** Create shader binary size tracking (per-platform shader
      cache size, alert on regression)
  - Completed via `shader_binary_size_tracking` in `maya-renderer`, a
    cross-compile artifact reporter that converts `ShaderCrossCompilationBatch`
    outputs into deterministic `ShaderBinarySizeRecord` rows, aggregates
    per-platform shader cache totals for Vulkan, DX12, and Metal targets, and
    exports reusable `ShaderBinarySizeBaseline` snapshots. The tracker compares
    current reports with baselines, emits blocking alerts for total and
    per-platform cache regressions over the configured 10% threshold, emits
    artifact-level byte-growth warnings, reports CI metrics, and rejects empty
    inputs, duplicate jobs, duplicate outputs, duplicate artifacts, missing
    outputs, mismatched targets, and empty binary blobs.
    `V2/ue/Build/Shaders/v2-maya-shader-binary-size-tracking.json`, Horde gates,
    the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-binary-size-tracking.py` validate report
    generation, platform cache aggregation, baseline comparison, regression
    alerts, input validation, CI wiring, and TODO evidence.
- [x] **72.30.1.15** Implement shader pipeline documentation and artist-facing
      material-to-shader guide
  - Completed with `V2/docs/rendering/maya-shader-pipeline.md` as the
    engineering source of truth for WGSL source ownership, include mapping,
    permutation planning, cross-compilation, local and Horde compilation,
    diagnostics, debugging symbols, shader complexity, binary-size regression
    gates, PSO/cache behavior, CI gates, and release evidence. Added
    `V2/docs/rendering/material-to-shader-artist-guide.md` for material intent
    handoff, graph-to-shader mapping, parameter naming, texture and sampler
    rules, permutation budgets, complexity and binary-size budgets, debugging
    artist reports, and review checklists. The contract
    `V2/ue/Build/Shaders/v2-maya-shader-pipeline-documentation.json`, Horde
    gates, the V2 CI workflow, and
    `V2/ue/Tools/check-v2-maya-shader-pipeline-documentation.py` validate both
    documents, source contract coverage, required topics, validation commands,
    CI wiring, and TODO evidence.

---

### 72.31 @neith/sound-propagation — Procedural Sound Propagation & Acoustic Simulation

> Reference: Schissler & Manocha "Interactive Sound Propagation and Rendering
> for Large Multi-Source Scenes" (2017), Valve Source 2 Steam Audio, Project
> Acoustics (Microsoft). Procedural environments need sound propagation that
> matches the generated geometry — reverb from cave walls, occlusion from
> buildings, diffraction around corners. Currently sounds are generated
> procedurally but not propagated through procedurally generated environments.

#### 72.31.1 Acoustic Simulation

- [x] **72.31.1.1** Create
      `libs/neith/sound-propagation/crates/neith-acoustics/` Rust crate with
      geometry-aware acoustic simulation — precompute impulse response (IR) from
      listener position by ray-tracing against scene geometry
  - Completed with the `neith-acoustics` crate in
    `libs/neith/sound-propagation`, including deterministic `Vec3`,
    `AcousticScene`, `AcousticTriangle`, `RayTraceSettings`, and
    `AcousticImpulseResponse` types. `trace_impulse_response` builds
    geometry-aware IR bins and paths from source/listener positions, and the V2
    contract/checker validates the crate scaffold, source file, project target,
    CI wiring, Horde gates, and TODO evidence.
- [x] **72.31.1.2** Implement acoustic ray tracing — cast N rays from source,
      reflect off surfaces (specular + diffuse scattering based on material
      roughness), accumulate energy at listener position to build impulse
      response
  - Completed through `trace_impulse_response`, Fibonacci-sphere ray emission,
    deterministic diffuse hemisphere scattering, specular reflection, bounce
    limits, listener capture radius, path delays, and octave-band energy
    accumulation. The focused test
    `ray_tracing_builds_direct_and_reflected_impulse_response` covers direct and
    reflected IR energy.
- [x] **72.31.1.3** Create material acoustic properties — per-material
      absorption coefficients across frequency bands (125Hz-8kHz), scattering
      coefficients, and transmission loss (e.g., stone=low absorption,
      carpet=high absorption)
  - Completed with `AcousticMaterial` and seven-band `FrequencyBands` for
    absorption, scattering, and transmission loss across 125 Hz, 250 Hz, 500 Hz,
    1 kHz, 2 kHz, 4 kHz, and 8 kHz. Built-in stone, carpet, glass, and grass
    profiles are covered by
    `material_bands_cover_absorption_scattering_and_transmission`.
- [x] **72.31.1.4** Implement acoustic probe grid — precompute impulse responses
      at probe positions throughout environment, interpolate at runtime for
      real-time spatialized audio without per-frame ray tracing
  - Completed with `AcousticProbeGrid`, `AcousticProbe`, baked responses, reverb
    summaries, nearest-probe weighted interpolation, and sample-rate preserving
    `interpolate_response` behavior. Coverage is included in
    `probe_grid_bakes_interpolates_and_incrementally_rebakes_changed_region`.
- [x] **72.31.1.5** Create acoustic probe baking for procedural environments —
      after terrain/urban/cave generation completes, automatically place
      acoustic probes and bake propagation data matching the generated geometry
  - Completed with `ProceduralProbeBakeConfig` and
    `bake_probes_for_procedural_environment`, which derives probe dimensions
    from scene bounds, spacing, and listener height, then bakes probe responses
    against the generated scene geometry.
- [x] **72.31.1.6** Implement occlusion and diffraction — when line-of-sight
      between source and listener is blocked by geometry, compute diffracted
      path around edges with frequency-dependent attenuation
  - Completed with `estimate_occlusion`, `compute_diffraction`,
    `DiffractionEdge`, blocked line-of-sight checks, edge path construction, and
    frequency-dependent attenuation. The test
    `occlusion_uses_diffraction_with_frequency_dependent_loss` validates blocked
    paths and stronger high-frequency loss.
- [x] **72.31.1.7** Create reverb parameter estimation — from impulse response,
      extract RT60 (reverberation time), early reflection pattern, late reverb
      density → feed to real-time convolution reverb
  - Completed with `estimate_reverb_parameters`, which extracts RT60, early
    reflection timings, and late reverb density from `AcousticImpulseResponse`.
    The test `reverb_estimation_extracts_early_pattern_and_late_density`
    validates early/late separation and positive RT60.
- [x] **72.31.1.8** Implement portal-based propagation — define acoustic portals
      at doorways/openings → sound travels through portal graph with per-portal
      filtering, enabling room-to-room propagation in procedural buildings
  - Completed with `AcousticPortal`, portal graph traversal, per-portal filters,
    room path reconstruction, path delay, and energy attenuation in
    `propagate_through_portals`. The test
    `portal_graph_routes_room_to_room_with_filters` validates multi-room routing
    and filtering.
- [x] **72.31.1.9** Create outdoor propagation model — distance attenuation,
      wind effects on sound direction, ground reflection with terrain material,
      and atmospheric absorption for open-world procedural environments
  - Completed with `OutdoorPropagationConfig` and
    `evaluate_outdoor_propagation`, including distance attenuation, atmospheric
    absorption, ground reflection, and wind-shifted apparent direction. The test
    `outdoor_model_applies_air_ground_and_wind_effects` validates air, ground,
    and wind behavior.
- [x] **72.31.1.10** Implement dynamic acoustic updates — when procedural
      environment changes at runtime (destruction, door opening, cave collapse),
      incrementally update affected acoustic probes without full rebake
  - Completed with scene revision tracking, dirty probe state, and
    `AcousticProbeGrid::update_changed_region`, which rebakes probes in an
    affected `Aabb` or after scene revision changes without full-grid rebake.
    The probe grid test covers incremental rebake behavior.
- [x] **72.31.1.11** Create acoustic visualization — render sound ray paths,
      reverb zones, occlusion volumes overlaid on 3D scene for debugging and
      level design
  - Completed with `AcousticVisualization`, `DebugRayPath`, `ReverbZoneDebug`,
    occlusion volume export, and `build_acoustic_visualization`. The test
    `visualization_exports_ray_paths_zones_and_occlusion_volumes` validates
    ray-path, reverb-zone, and occlusion-volume output.
- [x] **72.31.1.12** Implement acoustic quality benchmark — compare against
      measured impulse responses from real environments for validation (RT60
      accuracy, early reflection timing, frequency response shape)
  - Completed with `MeasuredImpulseReference` and
    `benchmark_against_measured_ir`, reporting RT60 error percent, early
    reflection timing error, frequency-response RMSE, and pass/fail state. The
    test `benchmark_scores_rt60_early_reflections_and_frequency_shape` validates
    benchmark scoring against a measured-reference fixture.

---

### 72.32 @neith/topology-opt — Topology Optimization for Procedural Structures

> Reference: Bendsøe & Sigmund "Topology Optimization" (2003), Aage et al.
> "Giga-voxel topology optimization" (2017). Topology optimization finds the
> optimal material distribution within a design domain that minimizes compliance
> (maximizes stiffness) subject to volume constraints. Critical for generating
> structurally sound bridges, buildings, mechanical parts, and organic
> structures in the Athena CAD domain and Maya world generation.

#### 72.32.1 Topology Optimization Engine

- [x] **72.32.1.1** Create `libs/neith/topology-opt/crates/neith-topopt/` Rust
      crate with SIMP (Solid Isotropic Material with Penalization) method —
      voxel grid with per-element density variable, penalized Young's modulus
      E(ρ) = ρ^p × E0
  - Completed with the `neith-topopt` crate, `TopologyGrid`, `TopologyProblem`,
    per-element density storage, and `MaterialModel::penalized_stiffness`. The
    test `simp_problem_initializes_density_grid_and_penalized_modulus` validates
    density initialization and penalized modulus behavior.
- [x] **72.32.1.2** Implement finite element solver — 8-node hexahedral elements
      with stiffness matrix assembly, sparse Cholesky factorization (or
      conjugate gradient with preconditioner) for displacement field computation
  - Completed with `assemble_stiffness_matrix`, `assemble_hexahedral_element`,
    diagonal-preconditioned `conjugate_gradient`, and `solve_load_case`. The
    tests `hexahedral_assembly_builds_sparse_stiffness_for_eight_node_elements`
    and `conjugate_gradient_solves_displacement_field` validate assembly,
    positive diagonals, displacement output, and finite compliance.
- [x] **72.32.1.3** Create sensitivity analysis — compute compliance gradient
      ∂c/∂ρ for each element via adjoint method, apply density filter (cone
      radius) to avoid checkerboard patterns
  - Completed with `compute_sensitivity`, element strain energy accumulation
    across load solutions, raw compliance gradients, and `apply_density_filter`.
    The test `sensitivity_filter_reduces_checkerboard_spikes` validates
    gradient/filter sizing and negative compliance sensitivities.
- [x] **72.32.1.4** Implement optimality criteria (OC) update — iterative
      density update using OC method with volume constraint enforcement via
      bisection on Lagrange multiplier
  - Completed with `optimality_criteria_update`, move limits, min density, and
    bisection over the Lagrange multiplier. The test
    `optimality_criteria_enforces_volume_constraint` validates volume target
    convergence and maximum density-change limits.
- [x] **72.32.1.5** Create GPU-accelerated topology optimization — implement FE
      assembly and solve on GPU via matrix-free conjugate gradient with
      geometric multigrid preconditioner for million-voxel problems
  - Completed with `GpuAccelerationPlan`, matrix-free matvec dispatches,
    multigrid hierarchy/buffers, indirect dispatch metadata, and
    `prepare_gpu_matrix_free_solve` for million-voxel submissions. The tests
    `gpu_plan_describes_matrix_free_multigrid_resources` and
    `gpu_submission_scales_to_million_voxel_matrix_free_solve` validate kernel
    coverage, geometric multigrid resources, and million-voxel readiness.
- [x] **72.32.1.6** Implement multi-load-case optimization — optimize for
      multiple load conditions simultaneously (gravity + wind + live load) with
      weighted compliance objective
  - Completed with `LoadCase`, `solve_multi_load_cases`, weighted compliance,
    and `optimize` feeding sensitivity/OC updates across all load cases. The
    test `multi_load_case_solution_weights_compliance` validates simultaneous
    gravity and wind load solving.
- [x] **72.32.1.7** Create topology optimization for procedural bridges — given
      terrain gap (two anchor points), optimize bridge structure topology
      minimizing material while supporting specified load
  - Completed with `BridgeSpec` and `generate_bridge_problem`, which derives a
    voxel design domain from span/width/height, anchors both ends, and applies
    deck live loads. The test
    `procedural_bridge_problem_places_anchor_supports_and_deck_loads` validates
    supports and distributed bridge loads.
- [x] **72.32.1.8** Implement topology optimization for building frames — given
      floor plan and load requirements, generate optimal structural frame
      (columns, beams, bracing) topology
  - Completed with `BuildingFrameSpec` and `generate_building_frame_problem`,
    including base supports, floor-gravity loads, wind loads, and perimeter
    density seeding for columns/bracing. The procedural frame test validates
    wind load coverage and seeded structural density.
- [x] **72.32.1.9** Create organic structure generation — use topology
      optimization with biologically inspired constraints (branching patterns,
      minimum member size) for tree-like support structures, coral frameworks,
      bone-like lattices
  - Completed with `OrganicStructureSpec` and
    `generate_organic_structure_problem`, including trunk/base supports,
    tip-load bias, minimum member filter radius, tapering, and branch-density
    bias. The procedural organic test validates organic load naming and minimum
    member sizing.
- [x] **72.32.1.10** Implement topology-to-mesh conversion — extract isosurface
      from optimized density field via marching cubes, smooth with Laplacian
      filter, remesh for clean quad-dominant topology
  - Completed with `extract_isosurface_mesh`, padded scalar-field marching cube
    sampling, cube-edge interpolation, shared edge vertices, quad capture for
    four-edge cells, exposed-face fallback, and `laplacian_smooth`. The tests
    `topology_to_mesh_extracts_marching_cubes_quad_dominant_surface` and
    `topology_to_mesh_rejects_invalid_thresholds` validate mesh extraction, quad
    metadata, finite vertices, and invalid-threshold rejection.
- [x] **72.32.1.11** Create topology optimization visualization — render
      optimization convergence animation showing material removal, stress
      distribution heatmap, displacement field
  - Completed with `OptimizationFrame` and `build_visualization_frame`,
    exporting per-iteration density, normalized stress heatmaps from element
    energy, weighted displacement vectors, and compliance. The test
    `visualization_frame_contains_density_stress_and_displacement` validates
    density, stress, and displacement output sizing.
- [x] **72.32.1.12** Implement topology optimization presets — pre-tuned
      settings for common structural types: cantilever, simply supported, arch,
      truss, shell, with appropriate boundary conditions and load patterns
  - Completed with `TopologyPresetKind` and `preset_problem` presets for
    cantilever, simply supported, arch, truss, and shell domains. The test
    `all_structural_presets_define_boundary_conditions_and_loads` validates
    boundary conditions and load patterns for every preset.

---

### 72.33 @neith/fabric-gen — Procedural Fabric & Weave Pattern Generation

> Reference: Zhao et al. "Fitting Procedural Yarn Models for Realistic Cloth
> Rendering" (SIGGRAPH 2016), Leaf et al. "Interactive Design of Periodic Yarn-
> Level Cloth Patterns" (SIGGRAPH Asia 2018). Thread-level weave pattern
> generation produces cloth with authentic structure — twill, satin, jacquard,
> knit — where the visual appearance emerges from the actual weave structure
> rather than flat textures.

#### 72.33.1 Weave Pattern Generation

- [x] **72.33.1.1** Create `libs/neith/fabric-gen/crates/neith-fabric/` Rust
      crate with weave pattern specification — binary weave matrix (warp
      over/under weft) defining fundamental weave unit for plain, twill, satin,
      basket, herringbone, houndstooth patterns
  - Completed with `neith-fabric`, `WeavePattern`, `WeaveCell`, and built-in
    plain, twill, satin, basket, herringbone, and houndstooth drafts. The test
    `built_in_weaves_cover_required_pattern_families` validates the required
    pattern families and non-empty binary weave matrices.
- [x] **72.33.1.2** Implement procedural yarn path generation — from weave
      matrix, compute 3D spline paths for each yarn (warp and weft) with
      realistic cross-section (elliptical), twist, and inter-yarn spacing
  - Completed with `FabricDraft`, `YarnSpec`, `YarnPoint`, `YarnPath`, and
    `generate_yarn_paths`, including warp/weft crossings, elliptical radii,
    twist phase, spacing, yarn sliding, and flyaway fibers. The test
    `yarn_paths_include_warp_weft_crossings_twist_and_flyaways` validates warp,
    weft, twist, and flyaway path output.
- [x] **72.33.1.3** Create yarn-level cloth rendering — render individual yarn
      fibers with anisotropic BSDF (Marschner fiber model), self-shadowing
      between yarns, and per-yarn color assignment for pattern visualization
  - Completed with `FiberBsdf` and `render_yarn_preview`, which emit per-yarn
    color, roughness, self-shadowing, tangent/normal, and anisotropic response
    samples. The test
    `yarn_preview_evaluates_anisotropic_response_and_self_shadowing` validates
    bounded anisotropic response and shadowing.
- [x] **72.33.1.4** Implement jacquard pattern generation — define complex woven
      imagery (damask, brocade, tapestry) via per-pixel weave structure
      variation — different weave types in different regions create light/dark
      patterns
  - Completed with `JacquardDraft` and `generate_jacquard_from_luma`, selecting
    dark/light source weave structures per input pixel. The test
    `jacquard_generation_switches_weaves_from_luma` validates per-pixel
    switching between satin and twill regions.
- [x] **72.33.1.5** Create knit pattern generation — knit stitch topology (knit,
      purl, cable, lace, rib) with inter-loop yarn paths for sweater, sock,
      scarf geometry generation
  - Completed with `KnitPattern`, `StitchType`, and `generate_knit_paths` for
    knit, purl, cable-left, cable-right, lace, and rib loop geometry. The test
    `knit_generation_creates_inter_loop_paths_for_stitch_types` validates loop
    path generation for every required stitch type.
- [x] **72.33.1.6** Implement weave-to-texture baking — bake high-detail yarn-
      level rendering to standard PBR textures (albedo, normal, roughness, AO)
      for real-time use at any tiling resolution
  - Completed with `PbrTextureSet` and `bake_weave_to_pbr_textures`, baking yarn
    preview samples into albedo, normal, roughness, and ambient-occlusion maps
    at arbitrary resolution. The test
    `weave_preview_bakes_tileable_pbr_texture_maps` validates all map sizes and
    non-default roughness/AO output.
- [x] **72.33.1.7** Create fabric drape preview — combine weave structure with
      mechanical properties (stiffness from yarn count and weave density) → feed
      to cloth simulation for realistic drape visualization
  - Completed with `MechanicalProperties`, `estimate_mechanics`, and
    `generate_drape_preview`, deriving stiffness, mass, damping, and sag nodes
    from yarn count, weave lock, and density. The test
    `drape_preview_estimates_mechanics_from_yarn_count_and_density` validates
    positive mechanics and sag output.
- [x] **72.33.1.8** Implement procedural fabric aging — yarn-level wear
      simulation: friction causes fiber breakage at contact points, UV exposure
      fades dye, washing causes shrinkage and pilling
  - Completed with `AgingConditions` and `age_fabric`, modeling UV fading, wash
    shrinkage, friction pilling, broken fiber ratio, and increased flyaway
    fibers. The test `aging_fades_shrinks_pills_and_breaks_fibers` validates all
    aging outputs.
- [x] **72.33.1.9** Create loom pattern editor — visual editor for designing
      weave patterns: drag-and-drop threading, tie-up, and treadling sequences
      with instant weave preview
  - Completed with `LoomDraft`, `LoomEditorAction`, `apply_loom_editor_action`,
    and `create_loom_editor_model`, including draggable threading, tie-up,
    treadling, drawdown preview, stats, and float warnings. The test
    `loom_editor_updates_threading_tie_up_treadling_and_preview` validates edit
    actions and preview state.
- [x] **72.33.1.10** Implement fabric metadata library — database of real-world
      fabric types (cotton broadcloth, silk charmeuse, wool tweed, denim,
      organza) with accurate weave, yarn, and material parameters
  - Completed with `FabricMetadataLibrary::standard`, covering cotton
    broadcloth, silk charmeuse, wool tweed, denim, and organza with weave, yarn,
    thread count, mass, and use-case metadata. The test
    `metadata_library_contains_real_world_fabric_parameters` validates every
    required fabric entry.
- [x] **72.33.1.11** Integrate FabricGen (March 2026) — end-to-end framework
      with WeavingLLM (domain-specific LLM) guiding procedural geometry model
      for yarn-level microstructures with natural irregularities, generating
      woven fabric materials from text descriptions
  - Completed with `WeavingLlmAdapter`, `RuleBasedWeavingLlm`,
    `FabricGenRequest`, `generate_fabricgen_material`, and
    `query_fabricgen_microstructure`, producing yarn geometry, PBR textures, ply
    microstructure, natural irregularities, and queryable microstructure
    samples. The test
    `fabricgen_pipeline_uses_weaving_llm_draft_and_queries_microstructure`
    validates the end-to-end FabricGen pipeline.
- [x] **72.33.1.12** Implement text-to-weave generation — "navy herringbone
      tweed" → WeavingLLM predicts weave pattern + yarn parameters → procedural
      geometry model generates yarn-level 3D structure → render to PBR textures
  - Completed with `generate_weave_from_text`, prompt-to-metadata selection,
    color/material modifiers, yarn path generation, and PBR texture baking. The
    test `text_to_weave_generates_draft_geometry_and_pbr_textures` validates the
    "navy herringbone tweed" path through draft, geometry, and textures.

---

### 72.34 @neith/pbr-material-synth — Physically-Based Material Synthesis

> Reference: Shi et al. "MATch" (CVPR 2023), Vecchio et al. "MatFuse" (2024).
> Current PBR material generation uses artist-tuned parameters. Physically-based
> material synthesis derives material properties from physical microstructure —
> refractive index, absorption spectrum, surface roughness distribution,
> subsurface scattering profile — producing materials that are correct by
> construction.

#### 72.34.1 Physical Material Modeling

- [x] **72.34.1.1** Create
      `libs/neith/pbr-material-synth/crates/neith-mat-phys/` Rust crate with
      physical material database — store refractive index spectra (n, k) for
      metals and dielectrics, absorption coefficients, scattering parameters
      from measured data (MERL BRDF, RGL)
  - Completed with `neith-mat-phys`, `PhysicalMaterialDatabase`,
    `ComplexIorSpectrum`, `SpectralCurve`, and standard measured entries for
    gold, copper, aluminum, water, and skin sourced from MERL/RGL/manual
    spectral fits. The test
    `physical_database_contains_spectral_ior_and_measured_sources` validates
    spectral IOR, absorption, scattering, and measured-source metadata.
- [x] **72.34.1.2** Implement Fresnel computation from refractive index — given
      complex IOR (n + ik), compute exact Fresnel reflectance at any angle for
      metals and dielectrics, replacing artist-tuned F0 values
  - Completed with `fresnel_from_ior` and dielectric/conductor handling for
    complex IOR samples at arbitrary incident angle. The test
    `fresnel_handles_dielectrics_and_conductors_from_complex_ior` validates
    water F0, grazing-angle behavior, and gold conductor reflectance.
- [x] **72.34.1.3** Create microstructure-driven roughness — from surface
      microstructure description (grain size, scratch pattern, polish level),
      compute GGX roughness parameter α and anisotropy ratio via microfacet
      statistics
  - Completed with `SurfaceMicrostructure` and `roughness_from_microstructure`,
    deriving GGX alpha, anisotropy, and normal variance from grain size, scratch
    depth/density, polish, and directional bias. The test
    `microstructure_generates_ggx_roughness_and_anisotropy` validates
    roughness/anisotropy response for polished versus brushed surfaces.
- [x] **72.34.1.4** Implement subsurface scattering from composition — given
      material composition (e.g., skin: melanin concentration, hemoglobin
      concentration, epidermal thickness), compute dipole/multipole SSS
      parameters from first principles
  - Completed with `SkinComposition` and `subsurface_from_skin_composition`,
    computing spectral absorption, reduced scattering, diffusion radii, and
    subsurface color from melanin, hemoglobin, water, fat, and epidermal
    thickness. The test `skin_composition_produces_spectral_sss_parameters`
    validates spectral SSS behavior and diffusion radius output.
- [x] **72.34.1.5** Create thin-film interference materials — from film
      thickness and refractive index, compute wavelength-dependent reflectance
      producing iridescent colors (oil slick, soap bubble, beetle shell)
  - Completed with `ThinFilmLayer` and `thin_film_reflectance`, computing
    wavelength-dependent reflectance from film thickness, film IOR, substrate
    IOR, and incident angle. The test
    `thin_film_reflectance_is_wavelength_dependent` validates visible-spectrum
    variation and bounded reflectance.
- [x] **72.34.1.6** Implement weathered material generation — from base material
      properties + exposure conditions (rain, UV, salt, pollution, time),
      compute aged material parameters using corrosion/oxidation/UV degradation
      models
  - Completed with `WeatherExposure` and `weather_material`, modeling rain
    pitting, UV fading, salt corrosion, pollution grime, oxidation, roughness
    increase, metallic loss, F0 degradation, and transmission reduction. The
    test `weathering_oxidizes_metals_and_raises_roughness` validates aged metal
    color, roughness, and metallic changes.
- [x] **72.34.1.7** Create procedural material composition — define material as
      layered stack (clear coat + metallic base, varnish + wood, glaze +
      ceramic) with per-layer physical properties → compute combined BSDF
  - Completed with `MaterialLayer` and `compose_layered_bsdf`, combining
    per-layer PBR parameters, thickness attenuation, coverage, clear-coat
    transmission, metallic/base blend, F0, roughness, and subsurface. The test
    `layered_stack_combines_clearcoat_and_base_materials` validates clearcoat
    and metallic-base blending.
- [x] **72.34.1.8** Implement material from spectral data — import measured
      spectral reflectance data → fit to PBR parameters (albedo, metallic,
      roughness) with minimal perceptual error across illuminants
  - Completed with `SpectralReflectanceData` and
    `fit_pbr_from_spectral_reflectance`, fitting albedo/base color, metallic,
    roughness, F0, and fitted spectral curve while reporting perceptual error.
    The test `spectral_reflectance_fits_renderer_pbr_parameters` validates
    spectral-to-PBR fitting and finite error reporting.
- [x] **72.34.1.9** Create AI material parameter predictor — from photograph of
      real material under known lighting, predict physical composition (IOR,
      absorption, roughness distribution) via trained neural network
  - Completed with `MaterialPhotoCapture`, `MaterialAiModelCard`,
    `extract_photo_material_features`, and `predict_material_from_photo`,
    predicting material class, IOR, absorption, roughness distribution, optional
    SSS composition, PBR parameters, confidence, and evidence from calibrated
    photo captures. The tests
    `material_photo_predictor_rejects_incomplete_capture`,
    `material_photo_predictor_recovers_metal_ior_absorption_and_roughness`, and
    `material_photo_predictor_recovers_subsurface_skin_composition` validate
    capture validation plus metal and subsurface predictions.
- [x] **72.34.1.10** Implement physical material validation — render material
      under multiple illuminants → compare against measured BRDF data (MERL,
      RGL) → report angular reflectance error and perceptual difference (ΔE)
  - Completed with `MeasuredBrdfSample` and `validate_material_against_brdf`,
    rendering the internal PBR BRDF against measured angular samples and
    reporting angular reflectance RMSE, perceptual delta E, sample count, and
    pass/fail. The test `material_validation_reports_angular_rmse_and_delta_e`
    validates BRDF comparison and pass/fail reporting.

---

### Phase 72 Summary — Game Engine Industrial SOTA Gap Closure

| Section                                             | Number | Tasks   |
| --------------------------------------------------- | ------ | ------- |
| 72.1 Neural Rendering Pipeline (NRC/Neural Shaders) | 72.1   | 45      |
| 72.2 Dedicated Game Server Infrastructure           | 72.2   | 30      |
| 72.3 Distributed Build & Content Cooking            | 72.3   | 30      |
| 72.4 Game DRM & Anti-Tamper                         | 72.4   | 15      |
| 72.5 Game Telemetry & Analytics Pipeline            | 72.5   | 30      |
| 72.6 Profiler Integration (Tracy/RenderDoc)         | 72.6   | 30      |
| 72.7 In-Game Dialogue System                        | 72.7   | 30      |
| 72.8 Quest / Mission System                         | 72.8   | 30      |
| 72.9 Inventory / Item System                        | 72.9   | 30      |
| 72.10 Anti-Cheat System (Comprehensive)             | 72.10  | 30      |
| 72.11 Game Localization Pipeline                    | 72.11  | 30      |
| 72.12 Game Live Operations Infrastructure           | 72.12  | 30      |
| 72.13 Engine-Level Game Accessibility               | 72.13  | 30      |
| 72.14 Modding & UGC Pipeline                        | 72.14  | 30      |
| 72.15 Cinematic Sequencer & Timeline Editor         | 72.15  | 30      |
| 72.16 Gameplay Camera System                        | 72.16  | 15      |
| 72.17 NPC Scheduling & Daily Routines               | 72.17  | 15      |
| 72.18 Game Economy & Virtual Economy                | 72.18  | 15      |
| 72.19 Automated Playtesting & AI Bots               | 72.19  | 15      |
| 72.20 Binary Asset Version Control                  | 72.20  | 15      |
| 72.21 Platform Store & SDK Integration              | 72.21  | 15      |
| 72.22 Adaptive Music System (Maya)                  | 72.22  | 15      |
| 72.24 Character Controller (Maya)                   | 72.24  | 15      |
| 72.25 HUD / Heads-Up Display System                 | 72.25  | 15      |
| 72.26 Replay / Demo Recording System                | 72.26  | 15      |
| 72.27 Input Action Mapping & Binding                | 72.27  | 15      |
| 72.28 Audio Middleware Integration (Wwise/FMOD)     | 72.28  | 15      |
| 72.29 Cross-Platform Account System                 | 72.29  | 15      |
| 72.30 Shader Compilation & Variant Management       | 72.30  | 15      |
| 72.31 Procedural Sound Propagation                  | 72.31  | 12      |
| 72.32 Topology Optimization                         | 72.32  | 12      |
| 72.33 Procedural Fabric & Weave Patterns            | 72.33  | 12      |
| 72.34 Physically-Based Material Synthesis           | 72.34  | 10      |
| **TOTAL Phase 72**                                  |        | **706** |

---

**Phase 72 closes 34 identified gaps between the Oshun ecosystem and AAA game
studio industrial state-of-the-art, adding 706 fully specified tasks across
engine systems, production tools, platform support, and live service
infrastructure.**

---
