diff --git a/.buildkite/amd/scripts/build-ci-image.sh b/.buildkite/amd/scripts/build-ci-image.sh
new file mode 100755
index 000000000..3954cd567
--- /dev/null
+++ b/.buildkite/amd/scripts/build-ci-image.sh
@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+set -euo pipefail
+
+# Build and push the ROCm CI image with a registry-backed BuildKit cache. The
+# AMD builders are ephemeral, so a local Docker cache cannot survive between
+# jobs. Keeping the cache beside the runtime image also reuses the registry
+# credentials already configured on the amd-cpu agents.
+
+REGISTRY="${ROCM_CI_IMAGE_REGISTRY:-rocm/vllm-omni}"
+DOCKERFILE="docker/Dockerfile.rocm"
+BUILDER_NAME="vllm-omni-rocm-builder"
+ROCM_ARCH="${PYTORCH_ROCM_ARCH:-gfx942}"
+
+if [[ -z "${BUILDKITE_COMMIT:-}" ]]; then
+    echo "ERROR: BUILDKITE_COMMIT is not set" >&2
+    exit 1
+fi
+
+dependency_files=(
+    "$DOCKERFILE"
+    "${DOCKERFILE}.dockerignore"
+    pyproject.toml
+    setup.py
+    tools/install_torchcodec_rocm.sh
+)
+while IFS= read -r dependency_file; do
+    dependency_files+=("$dependency_file")
+done < <(find requirements -maxdepth 1 -type f -name '*.txt' -print | LC_ALL=C sort)
+
+for dependency_file in "${dependency_files[@]}"; do
+    if [[ ! -f "$dependency_file" ]]; then
+        echo "ERROR: cache-key input does not exist: $dependency_file" >&2
+        exit 1
+    fi
+done
+
+CACHE_KEY=$(
+    {
+        printf 'rocm-arch=%s\n' "$ROCM_ARCH"
+        for dependency_file in "${dependency_files[@]}"; do
+            printf 'path=%s\n' "$dependency_file"
+            sha256sum "$dependency_file"
+        done
+    } | sha256sum | cut -c1-16
+)
+CACHE_REF="${REGISTRY}:rocm-deps-cache-${CACHE_KEY}"
+IMAGE_REF="${REGISTRY}:${BUILDKITE_COMMIT}"
+
+echo "ROCm dependency cache: ${CACHE_REF}"
+echo "ROCm CI image: ${IMAGE_REF}"
+
+# The docker-container driver supports exporting the full cache to a registry;
+# the default docker driver on CI does not.
+if ! docker buildx inspect "$BUILDER_NAME" >/dev/null 2>&1; then
+    docker buildx create --name "$BUILDER_NAME" --driver docker-container
+fi
+docker buildx use "$BUILDER_NAME"
+docker buildx inspect --bootstrap
+
+docker buildx build --push --pull --progress=plain \
+    --target test \
+    --build-arg "ARG_PYTORCH_ROCM_ARCH=${ROCM_ARCH}" \
+    --cache-from "type=registry,ref=${CACHE_REF}" \
+    --cache-to "type=registry,ref=${CACHE_REF},mode=max,compression=zstd,ignore-error=true" \
+    --file "$DOCKERFILE" \
+    --tag "$IMAGE_REF" .
diff --git a/.buildkite/amd/test-amd-merge.yml b/.buildkite/amd/test-amd-merge.yml
index b1b9e7ecc..6ee36de48 100644
--- a/.buildkite/amd/test-amd-merge.yml
+++ b/.buildkite/amd/test-amd-merge.yml
@@ -9,15 +9,26 @@ steps:
   steps:
     - label: "Simple · Model Executor Test · Shard %N/%t"
       agent_pool: mi300_1
-      parallelism: 2
+      parallelism: 3
       depends_on: amd-build
       mirror_hardwares: [amdproduction]
       grade: Blocking
+      timeout_in_minutes: 90
       commands:
         - export VLLM_ROCM_USE_AITER=0
         # ignore test_teacache_extractors.py because it use rocm gemm kernel from vLLM
         # that is not supported on CPU
-        - "pytest -sv tests/model_executor -m 'core_model and cpu' --num-shards=$$BUILDKITE_PARALLEL_JOB_COUNT --shard-id=$$BUILDKITE_PARALLEL_JOB"
+        - "pytest -sv tests/model_executor -m 'core_model and cpu and not omni' --num-shards=$$BUILDKITE_PARALLEL_JOB_COUNT --shard-id=$$BUILDKITE_PARALLEL_JOB"
+
+    - label: "Simple · Omni Processor Test"
+      agent_pool: mi300_1
+      depends_on: amd-build
+      mirror_hardwares: [amdproduction]
+      grade: Blocking
+      timeout_in_minutes: 60
+      commands:
+        - export VLLM_ROCM_USE_AITER=0
+        - "pytest -sv tests/model_executor/models/test_omni_processing.py -m 'core_model and cpu and omni'"
 
     - label: "Simple · Diffusion Test · Shard %N/%t"
       agent_pool: mi300_1
@@ -25,6 +36,7 @@ steps:
       depends_on: amd-build
       mirror_hardwares: [amdproduction]
       grade: Blocking
+      timeout_in_minutes: 45
       commands:
         - export VLLM_ROCM_USE_AITER=0
         # ignore test_teacache_extractors.py because it use rocm gemm kernel from vLLM
diff --git a/.buildkite/amd/test-amd-ready.yml b/.buildkite/amd/test-amd-ready.yml
index 505ed1b87..e46b559f3 100644
--- a/.buildkite/amd/test-amd-ready.yml
+++ b/.buildkite/amd/test-amd-ready.yml
@@ -9,26 +9,39 @@ steps:
   steps:
     - label: "Simple · Model Executor Test · Shard %N/%t"
       agent_pool: mi300_1
-      parallelism: 2
+      parallelism: 3
       depends_on: amd-build
       mirror_hardwares: [amdproduction]
       grade: Blocking
+      timeout_in_minutes: 90
       commands:
         - export VLLM_ROCM_USE_AITER=0
         # ignore test_teacache_extractors.py because it use rocm gemm kernel from vLLM
         # that is not supported on CPU
-        - "pytest -sv tests/model_executor -m 'core_model and cpu' --num-shards=$$BUILDKITE_PARALLEL_JOB_COUNT --shard-id=$$BUILDKITE_PARALLEL_JOB"
+        - "pytest -sv tests/model_executor -m 'core_model and cpu and not omni' --num-shards=$$BUILDKITE_PARALLEL_JOB_COUNT --shard-id=$$BUILDKITE_PARALLEL_JOB"
 
-    - label: "Simple · Diffusion Test"
+    - label: "Simple · Omni Processor Test"
       agent_pool: mi300_1
       depends_on: amd-build
       mirror_hardwares: [amdproduction]
       grade: Blocking
+      timeout_in_minutes: 60
+      commands:
+        - export VLLM_ROCM_USE_AITER=0
+        - "pytest -sv tests/model_executor/models/test_omni_processing.py -m 'core_model and cpu and omni'"
+
+    - label: "Simple · Diffusion Test · Shard %N/%t"
+      agent_pool: mi300_1
+      parallelism: 4
+      depends_on: amd-build
+      mirror_hardwares: [amdproduction]
+      grade: Blocking
+      timeout_in_minutes: 45
       commands:
         - export VLLM_ROCM_USE_AITER=0
         # ignore test_teacache_extractors.py because it use rocm gemm kernel from vLLM
         # that is not supported on CPU
-        - "pytest -sv tests/diffusion -m 'core_model and cpu'  --ignore=tests/diffusion/cache/test_teacache_extractors.py"
+        - "pytest -sv tests/diffusion -m 'core_model and cpu' --ignore=tests/diffusion/cache/test_teacache_extractors.py --num-shards=$$BUILDKITE_PARALLEL_JOB_COUNT --shard-id=$$BUILDKITE_PARALLEL_JOB"
 
     - label: "Simple · Engine&Entrypoints Test"
       agent_pool: mi300_1
@@ -69,6 +82,27 @@ steps:
 
 - group: ":card_index_dividers: Diffusion Test"
   steps:
+    # Keep real FlashAttention execution out of the CPU-marked Simple lane.
+    # AITER may need to build several kernels on a cold worker, so run one
+    # pytest worker with job-local build directories and a bounded timeout.
+    - label: "ROCm · FlashAttention/AITER GPU Coverage"
+      agent_pool: mi300_1
+      depends_on: amd-build
+      mirror_hardwares: [amdproduction]
+      grade: NonBlocking
+      timeout_in_minutes: 60
+      commands:
+        - export VLLM_ROCM_USE_AITER=1
+        - export AITER_JIT_DIR="/tmp/vllm-omni-aiter-$$BUILDKITE_JOB_ID"
+        - export TORCH_EXTENSIONS_DIR="/tmp/vllm-omni-torch-extensions-$$BUILDKITE_JOB_ID"
+        - mkdir -p "$$AITER_JIT_DIR" "$$TORCH_EXTENSIONS_DIR"
+        - >-
+          timeout --signal=TERM --kill-after=2m 55m
+          pytest -s -v -n 1
+          tests/diffusion/attention/
+          -m 'core_model and rocm and MI325 and cards_1'
+          --run-level "core_model"
+
     - label: "Diffusion · Batch Test"
       agent_pool: mi300_1
       depends_on: amd-build
@@ -299,6 +333,12 @@ steps:
       depends_on: amd-build
       mirror_hardwares: [amdproduction]
       grade: Blocking
+      # A ROCm hardware hang aborts the interpreter with 134. Let Buildkite
+      # create one fresh pod instead of retrying on the poisoned GPU process.
+      retry:
+        automatic:
+          - exit_status: 134
+            limit: 1
       commands:
         - pytest -s -v tests/e2e/online_serving/test_cosyvoice3_tts_expansion.py -m "slow" --run-level "core_model"
 
diff --git a/.buildkite/amd/test-template-amd-omni.j2 b/.buildkite/amd/test-template-amd-omni.j2
index e2042b96a..cca99f509 100644
--- a/.buildkite/amd/test-template-amd-omni.j2
+++ b/.buildkite/amd/test-template-amd-omni.j2
@@ -3,7 +3,8 @@
    Last synced: 2026-08-04
    Modifications: Use the shared MI300 queues and Omni command-passing contract
 #}
-{% set docker_image_amd = "rocm/vllm-omni:$BUILDKITE_COMMIT" %}
+{% set docker_registry_amd = "rocm/vllm-omni" %}
+{% set docker_image_amd = docker_registry_amd ~ ":$BUILDKITE_COMMIT" %}
 {% set default_working_dir = "/app/vllm-omni" %}
 
 {# MI300 runs tests natively in Kubernetes; Docker-in-Docker is unavailable. #}
@@ -74,11 +75,12 @@ steps:
         depends_on: ~
         soft_fail: false
         commands:
-          - "docker build -f docker/Dockerfile.rocm -t {{ docker_image_amd }} --target test --build-arg ARG_PYTORCH_ROCM_ARCH=gfx942 --progress plain ."
-          - "docker push {{ docker_image_amd }}"
+          - "bash .buildkite/amd/scripts/build-ci-image.sh"
         key: "amd-build"
         env:
           DOCKER_BUILDKIT: "1"
+          PYTORCH_ROCM_ARCH: "gfx942"
+          ROCM_CI_IMAGE_REGISTRY: "{{ docker_registry_amd }}"
         retry:
           automatic:
             - exit_status: -1  # Agent was lost
@@ -156,6 +158,14 @@ steps:
 {% for path in step.artifact_paths %}
           - "{{ path }}"
 {% endfor %}
+{% endif %}
+{% if step.retry %}
+        retry:
+          automatic:
+{% for retry_rule in step.retry.automatic %}
+            - exit_status: {{ retry_rule.exit_status }}
+              limit: {{ retry_rule.limit }}
+{% endfor %}
 {% endif %}
         {% if step.timeout_in_minutes %}
         timeout_in_minutes: {{ step.timeout_in_minutes }}
@@ -224,6 +234,14 @@ steps:
 {% for path in step.artifact_paths %}
       - "{{ path }}"
 {% endfor %}
+{% endif %}
+{% if step.retry %}
+    retry:
+      automatic:
+{% for retry_rule in step.retry.automatic %}
+        - exit_status: {{ retry_rule.exit_status }}
+          limit: {{ retry_rule.limit }}
+{% endfor %}
 {% endif %}
     {% if step.timeout_in_minutes %}
     timeout_in_minutes: {{ step.timeout_in_minutes }}
diff --git a/.buildkite/common/ci_source_file_dependencies.yml b/.buildkite/common/ci_source_file_dependencies.yml
index e29001d9a..5dfbf8da4 100644
--- a/.buildkite/common/ci_source_file_dependencies.yml
+++ b/.buildkite/common/ci_source_file_dependencies.yml
@@ -23,6 +23,16 @@ x-qwen3-tts: &qwen3_tts
   - vllm_omni/entrypoints/openai/serving_speech.py
   - vllm_omni/entrypoints/openai/tts_adapters/
   - vllm_omni/engine/stage_pool.py
+  - vllm_omni/worker_v2/
+  - vllm_omni/core/sched/
+  - vllm_omni/distributed/omni_connectors/
+  - vllm_omni/config/stage_config.py
+  - vllm_omni/config/omni_config.py
+  - vllm_omni/engine/orchestrator.py
+  - vllm_omni/engine/stage_engine_core_proc.py
+  - vllm_omni/deploy/qwen3_tts_mrv2.yaml
+  - vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2.yaml
+  - vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_b4.yaml
 
 x-minicpmo-4-5: &minicpmo_4_5
   - vllm_omni/engine/async_omni_engine.py
@@ -44,6 +54,7 @@ x-minicpmo-4-5-duplex: &minicpmo_4_5_duplex
   - vllm_omni/entrypoints/duplex/
   - vllm_omni/entrypoints/duplex_omni.py
   - vllm_omni/entrypoints/async_omni_base.py
+  - vllm_omni/protocol/
   - vllm_omni/clients/
   - vllm_omni/outputs/duplex.py
   - vllm_omni/model_executor/duplex_sampling.py
@@ -99,6 +110,7 @@ x-hunyuan-image3: &hunyuan_image3
 
 x-minimax-h3: &minimax_h3
   - vllm_omni/diffusion/models/minimax_h3/
+  - vllm_omni/diffusion/layers/indexed_modulation.py
 
 x-hunyuan-video: &hunyuan_video
   - vllm_omni/diffusion/models/hunyuan_video/
@@ -259,6 +271,7 @@ source_file_dependencies:
     - tests/entrypoints/test_duplex_omni.py
     - tests/entrypoints/openai_api/test_duplex_api_server.py
     - tests/model_executor/models/minicpmo_4_5/duplex/
+    - tests/protocol/
 
   omni_minicpmo_4_5_duplex_perf:
     - *minicpmo_4_5
diff --git a/.buildkite/cuda/test-nightly.yml b/.buildkite/cuda/test-nightly.yml
index 1fdb1ef4a..adc94f9e9 100644
--- a/.buildkite/cuda/test-nightly.yml
+++ b/.buildkite/cuda/test-nightly.yml
@@ -223,6 +223,17 @@ steps:
             -m "full_model and diffusion and H100 and B200 and cards_1"
             --run-level "full_model"
 
+      - label: ":robot_face: Robot Policy OpenPI · π0.5 · H100 · Single-GPU"
+        timeout_in_minutes: 120
+        commands:
+          - pip install --no-deps "openpi-client @ git+https://github.com/Physical-Intelligence/openpi.git@215abfb217dbac7d5f1273282331b9b1866c0479#subdirectory=packages/openpi-client"
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_pi05_expansion.py
+            -m "full_model and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
       - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · 2-GPU"
         source_file_dependencies: diffusion_qwen_image_function
         timeout_in_minutes: 120
diff --git a/.buildkite/cuda/test-ready.yml b/.buildkite/cuda/test-ready.yml
index 67f03dbb6..04e5d07b0 100644
--- a/.buildkite/cuda/test-ready.yml
+++ b/.buildkite/cuda/test-ready.yml
@@ -38,6 +38,12 @@ steps:
     depends_on: upload-ready-pipeline
     steps:
 
+      - label: "Diffusion · FlashAttention Test"
+        timeout_in_minutes: 20
+        commands:
+          - timeout 15m pytest -s -v tests/diffusion/attention/ -m 'core_model and cuda and L4 and cards_1' --run-level "core_model"
+        mirror_hardwares: l4_1
+
       - label: "Diffusion · Offloader Test"
         commands:
           - timeout 40m pytest -s -v tests/diffusion/offloader -m "core_model and cuda" --run-level "core_model"
@@ -96,7 +102,7 @@ steps:
     commands:
       - |
         timeout 15m bash -c "
-                  pytest -sv tests/engine/ tests/model_executor/ tests/worker/test_batched_omni_output.py -m 'core_model and cuda' --run-level 'core_model'
+                  pytest -sv tests/engine/ tests/model_executor/ tests/worker/test_batched_omni_output.py tests/worker_v2/ -m 'core_model and cuda' --run-level 'core_model'
         "
     mirror_hardwares: l4_1
 
diff --git a/.buildkite/npu/test-npu-nightly.yml b/.buildkite/npu/test-npu-nightly.yml
index f64fa711f..0c39a3f93 100644
--- a/.buildkite/npu/test-npu-nightly.yml
+++ b/.buildkite/npu/test-npu-nightly.yml
@@ -235,6 +235,37 @@ steps:
       build.env("NIGHTLY") == "1" ||
       build.pull_request.labels includes "nightly-test"
     steps:
+      - label: ":full_moon: Diffusion X2V · HunyuanVideo-1.5 Function Test"
+        source_file_dependencies: diffusion_hunyuan_video_function
+        timeout_in_minutes: 180
+        mirror_hardwares: a2b3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+          HF_HUB_OFFLINE: "1"
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_hunyuan_video_15_expansion.py -m "npu and A2" --run-level "full_model"
+      - label: ":full_moon: Diffusion X2V · HunyuanVideo-1.5 Perf Test"
+        source_file_dependencies: diffusion_hunyuan_video_perf
+        key: nightly-diffusion-x2v-performance-hunyuanvideo15
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_2
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+          HF_HUB_OFFLINE: "1"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m "npu and A3" --test-config-file tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
       - label: ":full_moon: Diffusion X2V · Wan 2.2 Function Test"
         source_file_dependencies: diffusion_wan22_function
         mirror_hardwares: a2b3_npu_4
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index c92c7b22f..e77f70914 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -67,6 +67,11 @@
 # File-level overrides within entrypoints/
 /vllm_omni/entrypoints/openai/errors.py @alex-jw-brooks @NickCao
 /vllm_omni/entrypoints/cli/benchmark/ @alex-jw-brooks @Bounty-hunter
+# Shared wire codec: protocol/realtime (OpenAI Realtime GA) and protocol/duplex
+# (vLLM-Omni's extension of it) — RFC #6592 P0a. Layer-neutral by design — the
+# engine depends on it — so it is owned by the serving-boundary document rather
+# than by any one consumer. — docs/design/module/entrypoints.md
+/vllm_omni/protocol/ @alex-jw-brooks @linyueqian @NickCao
 
 # Error contracts — docs/design/module/error_contracts.md
 /vllm_omni/errors.py @alex-jw-brooks @NickCao
diff --git a/README.md b/README.md
index 5063f9a3f..2cd6a574a 100644
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@ vLLM-Omni is flexible and easy to use with:
 vLLM-Omni seamlessly supports most popular open-source models on HuggingFace, including:
 
 - **Omni-modality models** (e.g. Qwen3-Omni, MiniCPM-o 4.5, Cosmos3, HunyuanImage, BAGEL)
-- **TTS models** (e.g. Qwen3-TTS, IndexTTS 2.5, dots.tts, CosyVoice3)
+- **TTS models** (e.g. Qwen3-TTS, IndexTTS 2.5, CosyVoice3)
 - **Diffusion models** — image, video, and audio generation (e.g. MiniMax H3, LTX-2.5, SANA-Video, Wan2.2)
 - **Robot-policy and action models** (e.g. π0, GR00T-N1.7, DreamZero-DROID, InternVLA-A1)
 
diff --git a/apps/ComfyUI-vLLM-Omni/README.md b/apps/ComfyUI-vLLM-Omni/README.md
index d0d002d0f..f33e26b40 100644
--- a/apps/ComfyUI-vLLM-Omni/README.md
+++ b/apps/ComfyUI-vLLM-Omni/README.md
@@ -52,6 +52,7 @@ This extension offers the following nodes based on the output modalities (at **C
 - **FastH3 Deployment** for routing text-to-video requests to a MiniMax-H3 server with FastH3 fused at startup
 - **Multimodality Understanding** for multimodality-to-text and multimodality-to-audio tasks
 - **TTS** and **TTS Voice Clone** for TTS tasks
+- **Generate Music** for lyrics-and-description-to-music generation
 
 This extension also offers example workflows (at **ComfyUI sidebar -> Templates -> vLLM-Omni**)
 
@@ -133,11 +134,13 @@ You can configure per-stage sampling parameters for multi-stage models.
 </p>
 
 > [!TIP]
-> Connect a **frame** image for first-frame / image-to-video (e.g., Wan I2V, MiniMax-H3 FL2VA).
+> Connect **frame** for backward-compatible first-frame / image-to-video behavior. For MiniMax-H3 FL2VA,
+> connect **first_frame**, **last_frame**, or both to condition the start frame, end frame, or both.
 >
 > For reference-conditioned generation (MiniMax-H3 Ref2VA), connect a **Video References** node instead.
 >
-> Do not use `frame` and `references` together. Task routing is automatic from which inputs you connect.
+> Do not combine `frame` with `first_frame` or `last_frame`, and do not combine any frame input with
+> `references`. Task routing is automatic from which inputs you connect.
 
 For MiniMax-H3 Ref2VA, **Video References** accepts up to 9 images (`image_1`–`image_9`),
 3 videos (`video_1`–`video_3`), and 3 audio clips (`audio_1`–`audio_3`), with at most
@@ -274,6 +277,17 @@ The node records which server the workflow targets; it does not start one, nor s
 > [!TIP]
 > There is a dedicated node for VoiceClone tasks with reference audio input. Other simple text-to-speech tasks should use the regular TTS node.
 
+### Music generation (e.g., MiniMax Music 3)
+
+(Also available at **ComfyUI sidebar->Template->vLLM-Omni->vLLM-Omni Music Generation**)
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-music-generation.jpg">
+    <img alt="vLLM-Omni Music Generation" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-music-generation.jpg" width=55%>
+  </picture>
+</p>
+
 ### Chaining multiple model services
 
 (Also available at **ComfyUI sidebar->Template->vLLM-Omni->vLLM-Omni Chaining Services**)
diff --git a/apps/ComfyUI-vLLM-Omni/__init__.py b/apps/ComfyUI-vLLM-Omni/__init__.py
index 55b003ef1..8c1b03d87 100644
--- a/apps/ComfyUI-vLLM-Omni/__init__.py
+++ b/apps/ComfyUI-vLLM-Omni/__init__.py
@@ -19,6 +19,7 @@ from .comfyui_vllm_omni.nodes import (
     VLLMOmniDiffusionSampling,
     VLLMOmniFastH3Deployment,
     VLLMOmniGenerateImage,
+    VLLMOmniGenerateMusic,
     VLLMOmniGenerateVideo,
     VLLMOmniMiniMaxH3Params,
     VLLMOmniQwenTTSParams,
@@ -38,6 +39,7 @@ NODE_CLASS_MAPPINGS = {
     "VLLMOmniGenerateVideo": VLLMOmniGenerateVideo,
     "VLLMOmniUnderstanding": VLLMOmniUnderstanding,
     "VLLMOmniTTS": VLLMOmniTTS,
+    "VLLMOmniGenerateMusic": VLLMOmniGenerateMusic,
     "VLLMOmniVoiceClone": VLLMOmniVoiceClone,
     "VLLMOmniVideoReferences": VLLMOmniVideoReferences,
     # === Params ===
@@ -58,6 +60,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "VLLMOmniGenerateVideo": "Generate Video",
     "VLLMOmniUnderstanding": "Multimodality Understanding",
     "VLLMOmniTTS": "TTS (Text to Speech)",
+    "VLLMOmniGenerateMusic": "Generate Music",
     "VLLMOmniVoiceClone": "TTS Voice Cloning",
     "VLLMOmniVideoReferences": "Video References",
     # === Params ===
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
index 47bdd9a2c..6d5006a11 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
@@ -203,6 +203,8 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
             },
             "optional": {
                 "frame": ("IMAGE",),
+                "first_frame": ("IMAGE",),
+                "last_frame": ("IMAGE",),
                 "references": ("VIDEO_REFERENCES",),
                 "sampling_params": ("SAMPLING_PARAMS",),
                 "lora": ("REMOTE_LORA",),
@@ -216,12 +218,30 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
     FUNCTION = "generate"
 
     @classmethod
-    def VALIDATE_INPUTS(cls, url, model, frame=None, references=None, **_kwargs) -> str | Literal[True]:
+    def VALIDATE_INPUTS(
+        cls,
+        url,
+        model,
+        frame=None,
+        first_frame=None,
+        last_frame=None,
+        references=None,
+        fast_h3=None,
+        **_kwargs,
+    ) -> str | Literal[True]:
         base = super().VALIDATE_INPUTS(url, model)
         if base is not True:
             return base
         if frame is not None and references is not None:
             return "Provide only one of frame or references, not both."
+        if frame is not None and (first_frame is not None or last_frame is not None):
+            return "Provide either frame or first_frame/last_frame, not both."
+        if references is not None and (first_frame is not None or last_frame is not None):
+            return "Provide either first_frame/last_frame or references, not both."
+        if fast_h3 is not None and any(value is not None for value in (frame, first_frame, last_frame, references)):
+            return (
+                "FastH3 Preview supports T2VA only; disconnect frame, first_frame, last_frame, and references inputs."
+            )
         return True
 
     async def generate(
@@ -235,6 +255,8 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
         duration: float,
         negative_prompt: str | None = None,
         frame: torch.Tensor | None = None,
+        first_frame: torch.Tensor | None = None,
+        last_frame: torch.Tensor | None = None,
         references: dict | None = None,
         sampling_params: dict | list[dict] | None = None,
         model_params: dict | None = None,
@@ -252,8 +274,11 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
         spec_model = model
 
         if fast_h3 is not None:
-            if frame is not None or references is not None:
-                raise ValueError("FastH3 Preview supports T2VA only; disconnect frame and references inputs.")
+            if any(value is not None for value in (frame, first_frame, last_frame, references)):
+                raise ValueError(
+                    "FastH3 Preview supports T2VA only; disconnect frame, first_frame, "
+                    "last_frame, and references inputs."
+                )
             if lora is not None:
                 raise ValueError(
                     "FastH3 is already fused into the selected server; disconnect the request-level LoRA input."
@@ -314,6 +339,8 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
             spec_model=spec_model,
             prompt=prompt,
             frame=frame,  # frame present => fl2va / Wan I2V
+            first_frame=first_frame,
+            last_frame=last_frame,
             references=references,
             width=width,
             height=height,
@@ -503,6 +530,66 @@ class VLLMOmniTTS(_VLLMOmniGenerateBase):
         return (audio,)
 
 
+class VLLMOmniGenerateMusic(_VLLMOmniGenerateBase):
+    """Generate a song from lyrics and a musical description with MiniMax Music 3."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "url": ("STRING", {"default": "http://localhost:8000/v1"}),
+                "model": ("STRING", {"default": "MiniMaxAI/MiniMax-Music3"}),
+                "instructions": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "display_name": "caption",
+                        "tooltip": "Music caption: describe genre, instruments, tempo and mood.",
+                    },
+                ),
+                "lyrics": ("STRING", {"multiline": True}),
+                "max_duration_seconds": (
+                    "FLOAT",
+                    {
+                        "default": 300.0,
+                        "min": 1,
+                        "max": 360,
+                        "step": 0.01,
+                        "tooltip": "Upper limit; rounded down to whole 25 Hz audio frames. May end earlier.",
+                    },
+                ),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2**53 - 1, "control_after_generate": True}),
+                "response_format": (["wav", "mp3", "flac", "opus"],),
+            },
+        }
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("audio",)
+    FUNCTION = "generate"
+
+    async def generate(
+        self,
+        url: str,
+        model: str,
+        lyrics: str,
+        instructions: str,
+        response_format: AudioFormat,
+        max_duration_seconds: float,
+        seed: int = 0,
+    ) -> tuple[AudioInput]:
+        audio = await VLLMOmniClient(url.rstrip("/")).generate_speech(
+            model=model,
+            input=lyrics,
+            instructions=instructions,
+            voice="default",
+            speed=1.0,
+            response_format=response_format,
+            max_new_tokens=int(max_duration_seconds * 25),
+            seed=seed,
+        )
+        return (audio,)
+
+
 class VLLMOmniVoiceClone(_VLLMOmniGenerateBase):
     @classmethod
     def INPUT_TYPES(cls):
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py
index 588f8b5b9..21935414b 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py
@@ -277,6 +277,8 @@ class VLLMOmniClient:
         fps: int,
         negative_prompt: str | None = None,
         frame: torch.Tensor | None = None,
+        first_frame: torch.Tensor | None = None,
+        last_frame: torch.Tensor | None = None,
         references: dict | None = None,
         sampling_params: dict | None = None,
         model_params: dict | None = None,
@@ -292,6 +294,16 @@ class VLLMOmniClient:
         """
         if frame is not None and references is not None:
             raise ValueError("Provide only one of frame or references, not both.")
+        if frame is not None and (first_frame is not None or last_frame is not None):
+            raise ValueError("Provide either frame or first_frame/last_frame, not both.")
+        if references is not None and (first_frame is not None or last_frame is not None):
+            raise ValueError("Provide either first_frame/last_frame or references, not both.")
+
+        spec, matched_pattern = lookup_model_spec(spec_model or model)
+        if (first_frame is not None or last_frame is not None) and (
+            matched_pattern is None or "MiniMax-H3" not in matched_pattern
+        ):
+            raise ValueError("first_frame and last_frame are supported only for MiniMax-H3; use frame for this model.")
 
         # === regular payload fields ===
         form = aiohttp.FormData()
@@ -311,11 +323,24 @@ class VLLMOmniClient:
 
         # === multimodal inputs (first-last-frames, references, etc.) ===
         input_reference_image: torch.Tensor | None = None
+        keyframe_images: list[tuple[str, torch.Tensor]] = []
         video_task: str | None = None
 
         if frame is not None:
             input_reference_image = frame
             video_task = "fl2va"
+        elif first_frame is not None or last_frame is not None:
+            frame_indices: list[int] = []
+            if first_frame is not None:
+                keyframe_images.append(("first_frame.png", first_frame))
+                frame_indices.append(0)
+            if last_frame is not None:
+                keyframe_images.append(("last_frame.png", last_frame))
+                frame_indices.append(-1)
+            if len(keyframe_images) == 1:
+                input_reference_image = keyframe_images[0][1]
+            extra_params["frame_indices"] = frame_indices
+            video_task = "fl2va"
         elif references is not None:
             reference_formats = (
                 ("image", MAX_REFERENCE_IMAGES, "png", "image/png", image_tensor_to_png_bytes),
@@ -353,7 +378,7 @@ class VLLMOmniClient:
             video_task = "t2va"
 
         if input_reference_image is not None:
-            image_filename = "image.png"  # Required for multipart form
+            image_filename = keyframe_images[0][0] if keyframe_images else "image.png"
             form.add_field(
                 "input_reference",
                 image_tensor_to_png_bytes(input_reference_image, image_filename),
@@ -361,12 +386,20 @@ class VLLMOmniClient:
                 content_type="image/png",
             )
 
+        if len(keyframe_images) == 2:
+            for image_filename, image in keyframe_images:
+                form.add_field(
+                    "input_references",
+                    image_tensor_to_png_bytes(image, image_filename),
+                    filename=image_filename,
+                    content_type="image/png",
+                )
+
         # === model specific params. Either use a specialized builder, or add flattened fields as-is ===
         if model_params is not None:
             model_params = dict(model_params)
             model_params.pop("type", None)
 
-        spec, _ = lookup_model_spec(spec_model or model)
         params_builder = spec.get("params_builder") if spec else None
         if params_builder is not None:
             form_fields = params_builder(
diff --git a/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-music-generation.jpg b/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-music-generation.jpg
new file mode 100644
index 000000000..1c8130fbd
Binary files /dev/null and b/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-music-generation.jpg differ
diff --git a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax H3 Image to Video.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax H3 Image to Video.json
new file mode 100644
index 000000000..d957e1cbc
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax H3 Image to Video.json	
@@ -0,0 +1,219 @@
+{
+  "id": "6676f19a-7f41-4c80-8cb7-f80adcb4ac44",
+  "revision": 0,
+  "last_node_id": 9,
+  "last_link_id": 4,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "LoadImage",
+      "pos": [40, 20],
+      "size": [270, 314],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "image", "name": "image", "type": "COMBO", "widget": {"name": "image"}, "link": null},
+        {"localized_name": "choose file to upload", "name": "upload", "type": "IMAGEUPLOAD", "widget": {"name": "upload"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "IMAGE", "name": "IMAGE", "type": "IMAGE", "links": [1]},
+        {"localized_name": "MASK", "name": "MASK", "type": "MASK", "links": null}
+      ],
+      "title": "First Frame",
+      "properties": {"Node name for S&R": "LoadImage"},
+      "widgets_values": ["first_frame.png", "image"]
+    },
+    {
+      "id": 2,
+      "type": "LoadImage",
+      "pos": [40, 390],
+      "size": [270, 314],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "image", "name": "image", "type": "COMBO", "widget": {"name": "image"}, "link": null},
+        {"localized_name": "choose file to upload", "name": "upload", "type": "IMAGEUPLOAD", "widget": {"name": "upload"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "IMAGE", "name": "IMAGE", "type": "IMAGE", "links": null},
+        {"localized_name": "MASK", "name": "MASK", "type": "MASK", "links": null}
+      ],
+      "title": "Last Frame (optional)",
+      "properties": {"Node name for S&R": "LoadImage"},
+      "widgets_values": ["last_frame.png", "image"]
+    },
+    {
+      "id": 3,
+      "type": "MarkdownNote",
+      "pos": [350, 20],
+      "size": [390, 240],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "MiniMax H3 I2V modes",
+      "properties": {},
+      "widgets_values": ["This workflow uses the remote vLLM-Omni Generate Video node.\n\n- First-frame only (default): keep First Frame connected.\n- Last-frame only: disconnect First Frame and connect Last Frame to last_frame.\n- First+last-frame: connect both image loaders.\n\nLeave the legacy frame and references inputs disconnected. Select images from ComfyUI's input folder. H3 runs at 24 FPS; the 5.167-second duration resolves to 124 frames, satisfying 17k+5."],
+      "color": "#432",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 4,
+      "type": "VLLMOmniDiffusionSampling",
+      "pos": [350, 300],
+      "size": [300, 226],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "n", "name": "n", "type": "INT", "widget": {"name": "n"}, "link": null},
+        {"localized_name": "num_inference_steps", "name": "num_inference_steps", "type": "INT", "widget": {"name": "num_inference_steps"}, "link": null},
+        {"localized_name": "guidance_scale", "name": "guidance_scale", "type": "FLOAT", "widget": {"name": "guidance_scale"}, "link": null},
+        {"localized_name": "true_cfg_scale", "name": "true_cfg_scale", "type": "FLOAT", "widget": {"name": "true_cfg_scale"}, "link": null},
+        {"localized_name": "vae_use_slicing", "name": "vae_use_slicing", "type": "BOOLEAN", "widget": {"name": "vae_use_slicing"}, "link": null},
+        {"localized_name": "vae_use_tiling", "name": "vae_use_tiling", "type": "BOOLEAN", "widget": {"name": "vae_use_tiling"}, "link": null},
+        {"localized_name": "seed", "name": "seed", "type": "INT", "widget": {"name": "seed"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "diffusion sampling params", "name": "diffusion sampling params", "type": "SAMPLING_PARAMS", "links": [2]}
+      ],
+      "title": "Base H3 Sampling (50 steps)",
+      "properties": {"Node name for S&R": "VLLMOmniDiffusionSampling"},
+      "widgets_values": [1, 50, 1, 1, false, false, 757358688076805, "fixed"]
+    },
+    {
+      "id": 5,
+      "type": "VLLMOmniMiniMaxH3Params",
+      "pos": [350, 570],
+      "size": [300, 82],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "audio_flow_shift", "name": "audio_flow_shift", "type": "FLOAT", "widget": {"name": "audio_flow_shift"}, "link": null},
+        {"localized_name": "flow_shift", "name": "flow_shift", "type": "FLOAT", "widget": {"name": "flow_shift"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "MiniMax-H3 video params", "name": "MiniMax-H3 video params", "type": "VIDEO_PARAMS", "links": [3]}
+      ],
+      "title": "Base H3 Flow Shifts",
+      "properties": {"Node name for S&R": "VLLMOmniMiniMaxH3Params"},
+      "widgets_values": [3, 12]
+    },
+    {
+      "id": 6,
+      "type": "VLLMOmniRemoteLoRA",
+      "pos": [700, 550],
+      "size": [360, 150],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "local_path", "name": "local_path", "type": "STRING", "widget": {"name": "local_path"}, "link": null},
+        {"localized_name": "name", "name": "name", "type": "STRING", "widget": {"name": "name"}, "link": null},
+        {"localized_name": "scale", "name": "scale", "type": "FLOAT", "widget": {"name": "scale"}, "link": null},
+        {"localized_name": "int_id", "name": "int_id", "type": "INT", "widget": {"name": "int_id"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "lora", "name": "lora", "type": "REMOTE_LORA", "links": null}
+      ],
+      "title": "Optional H3 Turbo Remote LoRA",
+      "properties": {"Node name for S&R": "VLLMOmniRemoteLoRA"},
+      "widgets_values": ["minimax_h3_fl2v_turbo_8step_v1.0_768p_bf16.safetensors", "h3-turbo-8step", 1, 0]
+    },
+    {
+      "id": 7,
+      "type": "MarkdownNote",
+      "pos": [700, 300],
+      "size": [420, 210],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Optional Turbo settings",
+      "properties": {},
+      "widgets_values": ["Base H3 is configured by default: 50 steps, flow_shift 12, audio_flow_shift 3.\n\nFor the shown 8-step Diffusers Turbo artifact, set its full local_path on the server, start the server with the matching preloaded LoRA, connect this Remote LoRA to Generate Video, set num_inference_steps to 9, and set flow_shift to 6. Keep audio_flow_shift at 3 and scale at 1.\n\nDo not use the _comfyui_ repack or FastH3 here."],
+      "color": "#432",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 8,
+      "type": "VLLMOmniGenerateVideo",
+      "pos": [1160, 80],
+      "size": [440, 610],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "frame", "name": "frame", "shape": 7, "type": "IMAGE", "link": null},
+        {"localized_name": "first_frame", "name": "first_frame", "shape": 7, "type": "IMAGE", "link": 1},
+        {"localized_name": "last_frame", "name": "last_frame", "shape": 7, "type": "IMAGE", "link": null},
+        {"localized_name": "references", "name": "references", "shape": 7, "type": "VIDEO_REFERENCES", "link": null},
+        {"localized_name": "sampling_params", "name": "sampling_params", "shape": 7, "type": "SAMPLING_PARAMS", "link": 2},
+        {"localized_name": "lora", "name": "lora", "shape": 7, "type": "REMOTE_LORA", "link": null},
+        {"localized_name": "model_params", "name": "model_params", "shape": 7, "type": "VIDEO_PARAMS", "link": 3},
+        {"localized_name": "fast_h3", "name": "fast_h3", "shape": 7, "type": "FASTH3_DEPLOYMENT", "link": null},
+        {"localized_name": "url", "name": "url", "type": "STRING", "widget": {"name": "url"}, "link": null},
+        {"localized_name": "model", "name": "model", "type": "STRING", "widget": {"name": "model"}, "link": null},
+        {"localized_name": "prompt", "name": "prompt", "type": "STRING", "widget": {"name": "prompt"}, "link": null},
+        {"localized_name": "negative_prompt", "name": "negative_prompt", "type": "STRING", "widget": {"name": "negative_prompt"}, "link": null},
+        {"localized_name": "width", "name": "width", "type": "INT", "widget": {"name": "width"}, "link": null},
+        {"localized_name": "height", "name": "height", "type": "INT", "widget": {"name": "height"}, "link": null},
+        {"localized_name": "fps", "name": "fps", "type": "INT", "widget": {"name": "fps"}, "link": null},
+        {"localized_name": "duration", "name": "duration", "type": "FLOAT", "widget": {"name": "duration"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "video", "name": "video", "type": "VIDEO", "links": [4]}
+      ],
+      "properties": {"Node name for S&R": "VLLMOmniGenerateVideo"},
+      "widgets_values": [
+        "http://localhost:8000/v1",
+        "MiniMaxAI/MiniMax-H3",
+        "A cinematic product shot begins exactly from the supplied keyframe. The subject moves naturally through a dark studio while blue and amber rim lights shift across reflective surfaces. The camera makes a slow controlled orbit. Audio: subtle room tone, precise mechanical details, and a restrained electronic score.",
+        "",
+        1344,
+        768,
+        24,
+        5.167
+      ]
+    },
+    {
+      "id": 9,
+      "type": "SaveVideo",
+      "pos": [1650, 170],
+      "size": [374, 314],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {"localized_name": "video", "name": "video", "type": "VIDEO", "link": 4},
+        {"localized_name": "filename_prefix", "name": "filename_prefix", "type": "STRING", "widget": {"name": "filename_prefix"}, "link": null},
+        {"localized_name": "format", "name": "format", "type": "COMBO", "widget": {"name": "format"}, "link": null},
+        {"localized_name": "codec", "name": "codec", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "codec"}, "link": null}
+      ],
+      "outputs": [
+        {"localized_name": "video", "name": "video", "type": "VIDEO", "links": null}
+      ],
+      "properties": {},
+      "widgets_values": ["video/MiniMax_H3_I2V", "auto", "auto"]
+    }
+  ],
+  "links": [
+    [1, 1, 0, 8, 1, "IMAGE"],
+    [2, 4, 0, 8, 4, "SAMPLING_PARAMS"],
+    [3, 5, 0, 8, 6, "VIDEO_PARAMS"],
+    [4, 8, 0, 9, 0, "VIDEO"]
+  ],
+  "groups": [
+    {"id": 1, "title": "Portable first/last-frame inputs", "bounding": [10, -30, 760, 770], "color": "#3f789e", "flags": {}},
+    {"id": 2, "title": "H3 sampling and optional Turbo", "bounding": [320, 270, 830, 460], "color": "#8a6d3b", "flags": {}},
+    {"id": 3, "title": "Remote generation and audio-preserving save", "bounding": [1130, 30, 930, 700], "color": "#3f789e", "flags": {}}
+  ],
+  "config": {},
+  "extra": {"workflowRendererVersion": "LG", "ds": {"scale": 0.75, "offset": [180, 120]}},
+  "version": 0.4
+}
diff --git a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Music Generation.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Music Generation.json
new file mode 100644
index 000000000..9dc7370c0
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Music Generation.json	
@@ -0,0 +1,206 @@
+{
+  "id": "4949c8da-12ff-449a-94b7-948bde9c39dd",
+  "revision": 0,
+  "last_node_id": 3,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VLLMOmniGenerateMusic",
+      "pos": [
+        100,
+        100
+      ],
+      "size": [
+        470,
+        491
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "url",
+          "type": "STRING",
+          "widget": {
+            "name": "url"
+          },
+          "link": null
+        },
+        {
+          "name": "model",
+          "type": "STRING",
+          "widget": {
+            "name": "model"
+          },
+          "link": null
+        },
+        {
+          "name": "instructions",
+          "type": "STRING",
+          "widget": {
+            "name": "instructions"
+          },
+          "link": null
+        },
+        {
+          "name": "lyrics",
+          "type": "STRING",
+          "widget": {
+            "name": "lyrics"
+          },
+          "link": null
+        },
+        {
+          "name": "max_duration_seconds",
+          "type": "FLOAT",
+          "widget": {
+            "name": "max_duration_seconds"
+          },
+          "link": null
+        },
+        {
+          "name": "seed",
+          "type": "INT",
+          "widget": {
+            "name": "seed"
+          },
+          "link": null
+        },
+        {
+          "name": "response_format",
+          "type": "COMBO",
+          "widget": {
+            "name": "response_format"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            1
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniGenerateMusic"
+      },
+      "widgets_values": [
+        "http://localhost:8000/v1",
+        "MiniMaxAI/MiniMax-Music3",
+        "Futuristic melodic EDM / progressive house. Reflective verses about memory and digital identity build into an uplifting, hook-driven chorus, with an emotive lead vocal, bright layered synths, pulsing bass, crisp four-on-the-floor drums, subtle glitch textures, and a wide polished festival mix.",
+        "[Verse 1]\nUpload my heart to the cloud tonight\nSave every spark of neon light\nIf this body starts to fade away\nLet my code keep dancing in the data stream\nStay\n[Chorus]\nCloud copy of me\nLiving on when these bones finally break free\nEvery joke, every scar\nEvery cheap memory we made\nSave it, save it\nCloud copy of me\nIf the screen goes dark, I\u2019m still in the machine\nEvery glitch, every dream\nEvery version you ever did see\nSave it, save it\n[Verse 2]\nTag every laugh in a secret folder\nArchive the nights we outran the thunder\nIf the wiring turns to rust and gray\nHit restore\u2026 press replay\n[Chorus]\nCloud copy of me\nLiving on when these bones finally break free\nEvery joke, every scar\nEvery cheap memory we made\nSave it, save it\nCloud copy of me\nIf the screen goes dark, I\u2019m still in the machine\nEvery glitch, every dream\nEvery version you ever did see\nSave it, save it (oh)\n[Bridge \u2013 new, optional but recommended]\nEven the crashes, the late-night confessions\nThe parts of me I never learned to mention\nDon\u2019t let the silence swallow me whole\nKeep a ghost in the glow\u2026\nSo I never go\n[Final Chorus \u2013 softer / layered]\nCloud copy of me\nStill laughing somewhere in the binary\nEvery joke, every scar\nEvery moment you saved for me\nSave it, save it\nCloud copy of me\nWhen the lights go out, I\u2019ll still be in the machine\nDancing in the code that you still believe\nSave it\u2026\nSave me",
+        300.0,
+        0,
+        "fixed",
+        "wav"
+      ]
+    },
+    {
+      "id": 2,
+      "type": "SaveAudioAdvanced",
+      "pos": [
+        650,
+        100
+      ],
+      "size": [
+        320,
+        491
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": 1
+        },
+        {
+          "name": "filename_prefix",
+          "type": "STRING",
+          "widget": {
+            "name": "filename_prefix"
+          },
+          "link": null
+        },
+        {
+          "name": "format",
+          "type": "COMFY_DYNAMICCOMBO_V3",
+          "widget": {
+            "name": "format"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SaveAudioAdvanced"
+      },
+      "widgets_values": [
+        "audio/vLLM-Omni-Music",
+        "mp3",
+        "V0"
+      ]
+    },
+    {
+      "id": 3,
+      "type": "MarkdownNote",
+      "title": "Music Generation Guide",
+      "pos": [
+        -507,
+        100
+      ],
+      "size": [
+        527,
+        491
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {},
+      "widgets_values": [
+        "## MiniMax Music 3\n\nThe **Generate Music** node currently supports **MiniMax Music 3 only**. The parameters below apply to this model.\n\nA music generation model by MiniMax that creates complete songs up to 5 minutes long with stable structure and high audio quality. Two inputs drive it: **Caption** (structured music description: style, mood, vocals, arrangement) and **Lyrics** (with `[intro]` `[verse]` `[chorus]` `[bridge]` `[outro]` tags controlling song structure).\n\n### Parameters\n\n| Parameter | Description |\n|---|---|\n| url | vLLM-Omni service URL including `/v1`. Default: `http://localhost:8000/v1`. |\n| model | Served model name. Default: `MiniMaxAI/MiniMax-Music3`. |\n| caption | Music description, sent as `instructions`. Use Global Metadata \u2192 Vocal Details \u2192 Arrangement to describe style, vocals, and instrumentation. |\n| lyrics | Words to sing with section tags. Put each tag on its own line; tags guide rather than strictly enforce song structure. |\n| max_duration_seconds | Maximum duration, default 300 seconds; range 1\u2013360, step 0.01. Converted to tokens at 25 frames/s, rounded down. Generation may end earlier. |\n| seed | Random seed, default 0; range 0\u20139007199254740991. Keep inputs and runtime settings unchanged for repeatability. |\n| control_after_generate | Seed behavior after generation: fixed, randomize, increment, or decrement. Template default: fixed. |\n| response_format | API audio format, default WAV. Options: WAV, MP3, FLAC, Opus, AAC; AAC is currently unsupported by the vLLM-Omni speech API. |\n\n### Prompt Writing Guide\n\nYou can find an official [Music Caption Rewriter Skill here](https://github.com/MiniMax-AI/MiniMax-Music3)\n"
+      ],
+      "widgets_values_named": {
+        "text": "## MiniMax Music 3\n\nThe **Generate Music** node currently supports **MiniMax Music 3 only**. The parameters below apply to this model.\n\nA music generation model by MiniMax that creates complete songs up to 5 minutes long with stable structure and high audio quality. Two inputs drive it: **Caption** (structured music description: style, mood, vocals, arrangement) and **Lyrics** (with `[intro]` `[verse]` `[chorus]` `[bridge]` `[outro]` tags controlling song structure).\n\n### Parameters\n\n| Parameter | Description |\n|---|---|\n| url | vLLM-Omni service URL including `/v1`. Default: `http://localhost:8000/v1`. |\n| model | Served model name. Default: `MiniMaxAI/MiniMax-Music3`. |\n| caption | Music description, sent as `instructions`. Use Global Metadata \u2192 Vocal Details \u2192 Arrangement to describe style, vocals, and instrumentation. |\n| lyrics | Words to sing with section tags. Put each tag on its own line; tags guide rather than strictly enforce song structure. |\n| max_duration_seconds | Maximum duration, default 300 seconds; range 1\u2013360, step 0.01. Converted to tokens at 25 frames/s, rounded down. Generation may end earlier. |\n| seed | Random seed, default 0; range 0\u20139007199254740991. Keep inputs and runtime settings unchanged for repeatability. |\n| control_after_generate | Seed behavior after generation: fixed, randomize, increment, or decrement. Template default: fixed. |\n| response_format | API audio format, default WAV. Options: WAV, MP3, FLAC, Opus, AAC; AAC is currently unsupported by the vLLM-Omni speech API. |\n\n### Prompt Writing Guide\n\nYou can find an official [Music Caption Rewriter Skill here](https://github.com/MiniMax-AI/MiniMax-Music3)\n"
+      },
+      "color": "#333",
+      "bgcolor": "#535353"
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      2,
+      0,
+      "AUDIO"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "workflowRendererVersion": "LG",
+    "ds": {
+      "scale": 1.147,
+      "offset": [
+        899,
+        259
+      ]
+    }
+  },
+  "version": 0.4
+}
diff --git a/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py b/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py
index ee69f7e59..2eaa097bd 100644
--- a/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py
+++ b/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py
@@ -22,9 +22,7 @@ from vllm_omni.diffusion.layers.fused_qk_norm_rope import (
     _fused_cuda_supported,
     fused_qk_norm_rope,
 )
-from vllm_omni.diffusion.models.qwen_image.qwen_image_transformer import (
-    _apply_qwen_image_rotary_emb,
-)
+from vllm_omni.diffusion.layers.rope import RotaryEmbedding
 
 
 def _parse_args() -> argparse.Namespace:
@@ -87,10 +85,10 @@ def _native(
 ) -> tuple[torch.Tensor, torch.Tensor]:
     q = F.rms_norm(q, (q.shape[-1],), q_weight, eps)
     k = F.rms_norm(k, (k.shape[-1],), k_weight, eps)
-    return (
-        _apply_qwen_image_rotary_emb(q, freqs),
-        _apply_qwen_image_rotary_emb(k, freqs),
-    )
+    rope = RotaryEmbedding(is_neox_style=False)
+    cos = freqs.real.to(q.dtype)
+    sin = freqs.imag.to(q.dtype)
+    return rope(q, cos, sin), rope(k, cos, sin)
 
 
 def _fused(
diff --git a/benchmarks/diffusion/diffusion_benchmark_serving.py b/benchmarks/diffusion/diffusion_benchmark_serving.py
index 1e5aaf29c..6bf64ec1d 100644
--- a/benchmarks/diffusion/diffusion_benchmark_serving.py
+++ b/benchmarks/diffusion/diffusion_benchmark_serving.py
@@ -1087,6 +1087,12 @@ async def _run_warmups(
 
     warmup_tasks = [asyncio.create_task(limited_warmup_request_func(req)) for req in warmup_requests]
     warmup_outputs = await asyncio.gather(*warmup_tasks)
+    failed_count = sum(not output.success for output in warmup_outputs)
+    if failed_count:
+        raise RuntimeError(
+            f"{failed_count}/{len(warmup_outputs)} warmup requests failed; "
+            "check server logs before running the benchmark."
+        )
     return list(zip(warmup_requests, warmup_outputs))
 
 
@@ -1455,7 +1461,7 @@ async def benchmark(args):
         print(f"Metrics saved to {args.output_file}")
 
 
-if __name__ == "__main__":
+def build_parser():
     parser = argparse.ArgumentParser(description="Benchmark serving for diffusion models.")
     parser.add_argument(
         "--base-url",
@@ -1637,6 +1643,10 @@ if __name__ == "__main__":
         action="store_true",
         help="Request stage duration metrics from endpoints that support return_stage_metrics.",
     )
+    return parser
 
+
+if __name__ == "__main__":
+    parser = build_parser()
     args = parser.parse_args()
     asyncio.run(benchmark(args))
diff --git a/benchmarks/kernels/mot_linear_benchmarks.py b/benchmarks/kernels/mot_linear_benchmarks.py
index 20674272e..0b517ce11 100644
--- a/benchmarks/kernels/mot_linear_benchmarks.py
+++ b/benchmarks/kernels/mot_linear_benchmarks.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # ruff: noqa: N803
 
 """MoT (Mixture-of-Tokens) GEMM kernel benchmark and auto-tuning.
@@ -10,7 +13,7 @@ Usage:
     python benchmarks/kernels/mot_linear_benchmarks.py \
         --model ByteDance-Seed/BAGEL-7B-MoT \
         --tp-size 1 --dtype w16a16 --tune \
-        --save-dir vllm_omni/diffusion/layers/mot/configs/
+        --save-dir vllm_omni/diffusion/models/bagel/mot/configs/
 
     # Auto-tune with local model path (offline clusters):
     python benchmarks/kernels/mot_linear_benchmarks.py \
@@ -43,7 +46,7 @@ from vllm.triton_utils import triton
 from vllm.utils.torch_utils import set_random_seed
 
 # NOTE: you should use the same naming syetem for the kernel to load properly
-from vllm_omni.diffusion.layers.mot.ops.mot_gemm import build_config_filename, get_device_name
+from vllm_omni.diffusion.models.bagel.mot.ops.mot_gemm import build_config_filename, get_device_name
 
 # clear the triton cache from time to time, usaully no need to change
 _CACHE_CLEAR_INTERVAL_ENV = "VLLM_MOT_TUNE_CACHE_CLEAR_INTERVAL"
@@ -428,7 +431,7 @@ def benchmark_config(
     cache_flusher: torch.Tensor | None = None,
 ) -> float:
     """Run a MoT GEMM with the given tile config and return avg latency (us)."""
-    from vllm_omni.diffusion.layers.mot.ops.mot_gemm import invoke_mot_gemm
+    from vllm_omni.diffusion.models.bagel.mot.ops.mot_gemm import invoke_mot_gemm
 
     text_indices, vae_indices, M = build_regular_indices(
         image_num=image_num,
@@ -553,7 +556,7 @@ class BenchmarkWorker:
         use_int8_w8a16: bool,
     ) -> tuple[dict[str, int], float]:
         set_random_seed(self.seed)
-        from vllm_omni.diffusion.layers.mot.ops.mot_gemm import (
+        from vllm_omni.diffusion.models.bagel.mot.ops.mot_gemm import (
             get_best_mot_config,
         )
 
diff --git a/benchmarks/qwen3_omni/embedding_harness.py b/benchmarks/qwen3_omni/embedding_harness.py
new file mode 100644
index 000000000..63d14ef0d
--- /dev/null
+++ b/benchmarks/qwen3_omni/embedding_harness.py
@@ -0,0 +1,226 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Small fixtures for the real Qwen3 thinker embedding method and its oracle."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass
+from types import SimpleNamespace
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+SCENARIOS = ("text", "empty", "audio", "image", "video", "mixed", "interleaved", "vision_no_deepstack")
+
+
+@dataclass(frozen=True)
+class ModelShape:
+    vocab_size: int = 152064
+    hidden_size: int = 2048
+    deepstack_levels: int = 3
+    image_token_id: int = 151655
+    video_token_id: int = 151656
+    audio_token_id: int = 151675
+
+    def __post_init__(self):
+        if min(self.vocab_size, self.hidden_size, self.deepstack_levels) <= 0:
+            raise ValueError("vocab_size, hidden_size and deepstack_levels must be positive")
+        ids = (self.image_token_id, self.video_token_id, self.audio_token_id)
+        if len(set(ids)) != 3 or not all(0 < token < self.vocab_size for token in ids):
+            raise ValueError("Provide three distinct, positive, in-vocabulary modality IDs; use oov=True to test OOV")
+
+    def token_ids(self, oov=False):
+        if oov:
+            return dict(zip(("image", "video", "audio"), range(self.vocab_size, self.vocab_size + 3)))
+        return {name: getattr(self, f"{name}_token_id") for name in ("image", "video", "audio")}
+
+
+@dataclass
+class Feature:
+    modality: str
+    positions: torch.Tensor
+    main: torch.Tensor
+    deepstack: torch.Tensor | None
+    combined: torch.Tensor
+
+
+@dataclass
+class EmbeddingCase:
+    name: str
+    input_ids: torch.Tensor
+    is_multimodal: torch.Tensor | None
+    features: tuple[Feature, ...]
+    fingerprint: str
+
+    def fresh_embeddings(self):
+        # The thinker replaces list entries with main-scale views.
+        return None if self.name == "text" else [feature.combined for feature in self.features]
+
+
+def _tensor_bytes(tensor):
+    return tensor.detach().contiguous().view(torch.uint8).cpu().numpy().tobytes()
+
+
+def build_case(
+    name,
+    num_tokens,
+    num_mm_tokens,
+    shape,
+    *,
+    device="cuda",
+    dtype=torch.bfloat16,
+    mask_device="cpu",
+    seed=42,
+    oov=False,
+):
+    """Build known feature placements; no model merge is used to define them."""
+    if name not in SCENARIOS:
+        raise ValueError(f"Unknown scenario: {name}")
+    if num_tokens <= 0 or not 0 <= num_mm_tokens < num_tokens:
+        raise ValueError("Require N > 0 and 0 <= M < N")
+    if (name in {"text", "empty"}) != (num_mm_tokens == 0):
+        raise ValueError("Only text/empty scenarios accept M=0")
+    if name in {"mixed", "interleaved"} and (num_mm_tokens < 4 or num_mm_tokens % 2):
+        raise ValueError("Mixed/interleaved scenarios require an even M >= 4")
+    token_ids = shape.token_ids(oov)
+    generator = torch.Generator().manual_seed(seed)
+    ids = torch.randint(0, min(shape.vocab_size, *token_ids.values()), (num_tokens,), generator=generator)
+    mask = torch.zeros(num_tokens, dtype=torch.bool)
+    positions = torch.arange((num_tokens - num_mm_tokens) // 2, (num_tokens - num_mm_tokens) // 2 + num_mm_tokens)
+    groups = []
+    if name == "mixed":
+        groups = [("audio", positions[: num_mm_tokens // 2]), ("image", positions[num_mm_tokens // 2 :])]
+    elif name == "interleaved":
+        groups = [("video", positions[::2]), ("audio", positions[1::2])]
+    elif num_mm_tokens:
+        groups = [("image" if name == "vision_no_deepstack" else name, positions)]
+    features = []
+    for modality, indexes in groups:
+        ids[indexes] = token_ids[modality]
+        mask[indexes] = True
+        rows = torch.arange(len(indexes), dtype=torch.float32)[:, None].remainder(31) / 32
+        cols = torch.arange(shape.hidden_size, dtype=torch.float32)[None, :].remainder(7) / 16
+        main_cpu = rows + cols + {"audio": 2, "image": 4, "video": 6}[modality]
+        main = main_cpu.to(device=device, dtype=dtype)
+        deepstack = None
+        parts = [main]
+        if modality != "audio" and name != "vision_no_deepstack":
+            deepstack = torch.stack(
+                [(main_cpu + 16 + 4 * level).to(device=device, dtype=dtype) for level in range(shape.deepstack_levels)]
+            )
+            parts.extend(deepstack.unbind(0))
+        combined = torch.cat(parts, dim=-1)
+        # set_mm_embedding_modality simply attaches this attribute. Tag only
+        # after cat/to: views and copies do not preserve arbitrary attributes.
+        combined.modality = modality
+        features.append(Feature(modality, indexes, main, deepstack, combined))
+    digest = hashlib.sha256(json.dumps({"name": name, "shape": asdict(shape), "seed": seed, "oov": oov}).encode())
+    digest.update(_tensor_bytes(ids))
+    digest.update(_tensor_bytes(mask))
+    for feature in features:
+        digest.update(feature.modality.encode())
+        digest.update(_tensor_bytes(feature.combined))
+    return EmbeddingCase(
+        name,
+        ids.to(device=device),
+        None if name == "text" else mask.to(device=mask_device),
+        tuple(features),
+        digest.hexdigest(),
+    )
+
+
+class LanguageModelAdapter(nn.Module):
+    def __init__(self, embedding):
+        super().__init__()
+        self.embedding = embedding
+
+    def embed_input_ids(self, input_ids):
+        return self.embedding(input_ids)
+
+    def forward(self, input_ids):
+        return self.embed_input_ids(input_ids)
+
+
+def make_thinker(
+    shape,
+    *,
+    device="cuda",
+    dtype=torch.bfloat16,
+    seed=42,
+    backend="torch",
+    deepstack=True,
+    buffer_capacity=32,
+    oov=False,
+):
+    """Skip checkpoint construction, preserving the real class and its MRO."""
+    from tests.model_executor.helpers import bootstrap_vllm_layer_custom_op_modules
+
+    bootstrap_vllm_layer_custom_op_modules()
+    from vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker import (
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    if buffer_capacity <= 0:
+        raise ValueError("buffer_capacity must be positive")
+    device = torch.device(device)
+    if backend == "torch":
+        embedding = nn.Embedding(shape.vocab_size, shape.hidden_size, device=device, dtype=dtype)
+    elif backend == "vllm":
+        from vllm.model_executor.layers.vocab_parallel_embedding import VocabParallelEmbedding
+
+        with torch.device(device):
+            embedding = VocabParallelEmbedding(shape.vocab_size, shape.hidden_size, params_dtype=dtype, disable_tp=True)
+    else:
+        raise ValueError(f"Unknown embedding backend: {backend}")
+    with torch.no_grad():
+        embedding.weight.uniform_(-0.5, 0.5, generator=torch.Generator(device=device).manual_seed(seed))
+    thinker = object.__new__(Qwen3OmniMoeThinkerForConditionalGeneration)
+    nn.Module.__init__(thinker)
+    thinker.config = SimpleNamespace(text_config=SimpleNamespace(hidden_size=shape.hidden_size))
+    for modality, token_id in shape.token_ids(oov).items():
+        setattr(thinker.config, f"{modality}_token_id", token_id)
+    thinker.visual = SimpleNamespace(
+        deepstack_visual_indexes=list(range(shape.deepstack_levels)) if deepstack else None
+    )
+    thinker.language_model = LanguageModelAdapter(embedding)
+    thinker._has_oov_mm_tokens = oov
+    thinker.use_deepstack = deepstack
+    thinker.deepstack_num_level = shape.deepstack_levels if deepstack else 0
+    thinker.deepstack_input_embeds = [
+        torch.zeros(buffer_capacity, shape.hidden_size, device=device, dtype=dtype)
+        for _ in range(thinker.deepstack_num_level)
+    ]
+    thinker.deepstack_input_embeds_num_tokens = 0
+    return thinker.eval()
+
+
+@torch.inference_mode()
+def expected_outputs(model, case):
+    """Independent oracle: direct lookup and explicit positions, not merge helpers."""
+    ids = case.input_ids
+    if model._has_oov_mm_tokens and case.is_multimodal is not None:
+        ids = ids.masked_fill(case.is_multimodal.to(ids.device), 0)
+    main = F.embedding(ids, model.language_model.embedding.weight)
+    has_deepstack = any(feature.deepstack is not None for feature in case.features)
+    deepstack = main.new_zeros((model.deepstack_num_level, *main.shape)) if has_deepstack else None
+    for feature in case.features:
+        indexes = feature.positions.to(main.device)
+        main[indexes] = feature.main
+        if feature.deepstack is not None:
+            deepstack[:, indexes, :] = feature.deepstack
+    return main, deepstack
+
+
+@torch.inference_mode()
+def assert_case_output(model, case, result):
+    expected, deepstack = expected_outputs(model, case)
+    torch.testing.assert_close(result, expected, rtol=0, atol=0)
+    if deepstack is None:
+        assert model.deepstack_input_embeds_num_tokens == 0, "Unexpected stale DeepStack buffer"
+    else:
+        assert model.deepstack_input_embeds_num_tokens == case.input_ids.numel()
+        actual = torch.stack([buffer[: case.input_ids.numel()] for buffer in model.deepstack_input_embeds])
+        torch.testing.assert_close(actual, deepstack, rtol=0, atol=0)
diff --git a/benchmarks/tts/bench_cosyvoice3_concurrency_matrix.py b/benchmarks/tts/bench_cosyvoice3_concurrency_matrix.py
new file mode 100644
index 000000000..fb45b1743
--- /dev/null
+++ b/benchmarks/tts/bench_cosyvoice3_concurrency_matrix.py
@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CosyVoice3 streaming e2e benchmark: concurrency x utterance-length matrix.
+
+Launches the server once per (concurrency, step-size) combo, streams TTS
+requests cycling through several utterance lengths, and reports
+TTFA/E2E/RTF/per-chunk latency (mean, stdev, range) per cell. "Step size" is
+``codec_chunk_frames``, the token-hop length the first emitted chunk waits
+for; later chunks wait for a doubling hop capped at ``4 * codec_chunk_frames``
+(see ``_token_hop_lengths``). Per-chunk latency is reconstructed from that
+same ramp rather than from raw transport read boundaries, which don't align
+to model chunks (see ``one_request``'s docstring).
+
+Running with no flags reproduces the default matrix. Per-request correctness
+is checked: non-silent, long enough, and (with a fixed ``--seed``)
+byte-identical PCM across requests for the same text.
+"""
+
+import argparse
+import json
+import os
+import signal
+import statistics
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+import httpx
+import numpy as np
+
+REPO = Path(__file__).resolve().parents[2]
+DEFAULT_MODEL = "FunAudioLLM/Fun-CosyVoice3-0.5B-2512"
+
+DEFAULT_REF_AUDIO = "https://raw.githubusercontent.com/FunAudioLLM/CosyVoice/main/asset/zero_shot_prompt.wav"
+DEFAULT_REF_TEXT = "希望你以后能够做的比我还好呦。"
+
+DEFAULT_TEXTS = [
+    "Thank you so much for the birthday gift you sent me.",
+    "The weather is lovely today, with warm sunshine and a gentle breeze. "
+    "We decided to take a walk in the park to enjoy the spring flowers and the fresh air.",
+    "The weather is lovely today, with warm sunshine and a gentle breeze. We decided to take a walk in the "
+    "park to enjoy the spring flowers and the fresh air. Many people were out walking, children were "
+    "running and playing on the grass, and older folks sat on benches chatting with one another. We "
+    "strolled slowly along the path and came across a cherry tree in full bloom, its pink petals drifting "
+    "on the wind. It was so beautiful that we stopped to take some photos to remember the moment. Then we "
+    "continued on and reached a small lake, its water so clear you could see straight to the bottom, with "
+    "the blue sky and white clouds reflected on its surface. A few ducks paddled back and forth across the "
+    "water, occasionally letting out a soft quack. We sat on a bench by the lake for a while, enjoying the "
+    "peaceful afternoon. Time passed quickly, and before we knew it evening had arrived, with the setting "
+    "sun painting the sky in shades of gold. Reluctant to leave, we finally headed home, already planning "
+    "our next visit. On the way back we talked about everything we had seen and heard that day, feeling "
+    "wonderfully happy. It was truly an unforgettable weekend.",
+]
+
+# PCM16 mono @ 24 kHz (CosyVoice3 output rate)
+SAMPLE_RATE = 24000
+
+# Well below any real speech's RMS; catches all-zero/near-silent PCM that byte
+# count and duration checks alone pass through.
+MIN_RMS = 50.0
+
+# Overlay: only codec_chunk_frames is overridden; must live next to cosyvoice3.yaml (relative base_config)
+DEPLOY_TEMPLATE = """# Auto-generated by bench_cosyvoice3_concurrency_matrix.py -- do not edit.
+base_config: cosyvoice3.yaml
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: {chunk_frames}
+      codec_max_chunk_frames: {max_chunk_frames}
+      codec_stream_scale_factor: {stream_scale_factor}
+      codec_left_context_frames: 25
+      codec_vocab_size: 6561
+"""
+
+# CosyVoice3Config constants (transformers_utils/configs/cosyvoice3.py): tokens
+# are consumed at token_mel_ratio mel frames each, and HiFT emits
+# samples_per_mel PCM16 samples per mel frame. Pinned here (not left to the
+# server's defaults) since one_request's byte-boundary reconstruction below
+# depends on knowing them exactly.
+TOKEN_MEL_RATIO = 2
+SAMPLES_PER_MEL = 480
+STREAM_SCALE_FACTOR = 2
+
+
+def _stats(values: list[float]) -> dict[str, float]:
+    """Mean/median/stdev/p95/min/max/n for a list of per-request measurements."""
+    n = len(values)
+    if n == 0:
+        return {
+            "n": 0,
+            "mean": float("nan"),
+            "median": float("nan"),
+            "stdev": float("nan"),
+            "p95": float("nan"),
+            "min": float("nan"),
+            "max": float("nan"),
+        }
+    return {
+        "n": n,
+        "mean": statistics.mean(values),
+        "median": statistics.median(values),
+        "stdev": statistics.stdev(values) if n >= 2 else 0.0,
+        "p95": statistics.quantiles(values, n=20)[18] if n >= 2 else values[0],
+        "min": min(values),
+        "max": max(values),
+    }
+
+
+def vllm_bin() -> str:
+    for c in (REPO / ".venv/bin/vllm", Path(sys.executable).parent / "vllm"):
+        if c.is_file():
+            return str(c)
+    return "vllm"
+
+
+def wait_ready(url: str, proc: subprocess.Popen, log: Path, timeout: float) -> None:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            tail = log.read_text(errors="replace").splitlines()[-40:] if log.exists() else []
+            raise RuntimeError("server exited during startup:\n  " + "\n  ".join(tail))
+        try:
+            if httpx.get(f"{url}/health", timeout=2.0).status_code == 200:
+                return
+        except Exception:
+            pass
+        time.sleep(2.0)
+    raise TimeoutError(f"server not ready within {timeout}s (log: {log})")
+
+
+def _token_hop_lengths(chunk_frames: int, max_chunk_frames: int):
+    """The token-hop-length ramp talker2code2wav_async_chunk uses to decide
+    when to fire the next flow-solve/emission: chunk_frames, then doubling
+    (STREAM_SCALE_FACTOR) each step, capped at max_chunk_frames. This -- not
+    codec_chunk_frames alone -- is what actually paces emitted audio chunks:
+    with the defaults here, hops are chunk_frames, 2x, 4x, 4x, 4x, ...
+
+    The very first emission is consistently one token short of chunk_frames
+    (confirmed against real speech.audio.delta event sizes) even though the
+    ramp's own progression is computed from the nominal chunk_frames, not the
+    actual first hop -- so only the first yield gets the -1 adjustment.
+    """
+    yield chunk_frames - 1
+    hop = chunk_frames
+    while True:
+        hop = min(max_chunk_frames, max(chunk_frames, hop * STREAM_SCALE_FACTOR))
+        yield hop
+
+
+def one_request(client, url, model, text, ref_audio, ref_text, chunk_frames, seed=None):
+    """Run one streaming request, returning TTFA, E2E, per-chunk gaps, and audio bytes.
+
+    ``response_format=pcm`` + ``stream_format=audio`` streams raw bytes with no
+    framing, so a client read boundary alone is a transport artifact, not a
+    model chunk boundary. Reconstructed instead by replicating the server's
+    own token-hop-length ramp (see ``_token_hop_lengths``) to compute each
+    real chunk's expected byte size ahead of time, and slicing the
+    accumulated byte stream at those offsets -- independent of how the
+    transport happens to fragment the underlying reads. The final chunk
+    (finalize, which releases extra held-back frames) is whatever remains
+    when the stream closes, not a predicted hop.
+    """
+    payload = {
+        "model": model,
+        "input": text,
+        "response_format": "pcm",
+        "stream": True,
+        "stream_format": "audio",
+        "ref_audio": ref_audio,
+        "ref_text": ref_text,
+    }
+    if seed is not None:
+        payload["seed"] = seed
+    t0 = time.perf_counter()
+    ttfa = None
+    nbytes = 0
+    audio_bytes = bytearray()
+    chunk_gaps_ms = []  # inter-chunk arrival gaps (per model chunk), by step index
+    prev_t = None
+    step_idx = 0
+
+    bytes_per_token = TOKEN_MEL_RATIO * SAMPLES_PER_MEL * 2
+    hop_gen = _token_hop_lengths(chunk_frames, 4 * chunk_frames)
+    next_boundary = next(hop_gen) * bytes_per_token
+    last_crossed_bytes = 0
+    received = 0
+    last_now = t0
+
+    with client.stream("POST", f"{url}/v1/audio/speech", json=payload, headers={"Authorization": "Bearer EMPTY"}) as r:
+        if r.status_code != 200:
+            raise RuntimeError(f"{r.status_code}: {r.read()[:300]!r}")
+        for chunk in r.iter_bytes():
+            if not chunk:
+                continue
+            now = time.perf_counter()
+            if ttfa is None:
+                ttfa = now - t0
+            last_now = now
+            received += len(chunk)
+            nbytes += len(chunk)
+            audio_bytes += chunk
+            while received >= next_boundary:
+                if prev_t is not None:
+                    chunk_gaps_ms.append((step_idx, (now - prev_t) * 1e3))
+                    step_idx += 1
+                prev_t = now
+                last_crossed_bytes = next_boundary
+                next_boundary += next(hop_gen) * bytes_per_token
+
+    if received > last_crossed_bytes:
+        # Finalize chunk: releases extra held-back frames, so it doesn't
+        # match a predicted hop size -- its arrival is the stream closing.
+        if prev_t is not None:
+            chunk_gaps_ms.append((step_idx, (last_now - prev_t) * 1e3))
+            step_idx += 1
+
+    e2e = time.perf_counter() - t0
+    audio_s = nbytes / 2 / SAMPLE_RATE
+    return {
+        "ttfa_s": ttfa,
+        "e2e_s": e2e,
+        "audio_s": audio_s,
+        "rtf": e2e / audio_s if audio_s > 0 else float("nan"),
+        "chunk_gaps_ms": chunk_gaps_ms,
+        "nbytes": nbytes,
+        "audio_bytes": audio_bytes,
+    }
+
+
+def check_correctness(r: dict, min_audio_s: float) -> list[str]:
+    """Return a list of correctness violations (empty = pass)."""
+    problems = []
+    if r["nbytes"] <= 0:
+        problems.append("empty audio (0 bytes)")
+    if r["audio_s"] < min_audio_s:
+        problems.append(f"audio too short ({r['audio_s']:.2f}s < {min_audio_s:.2f}s)")
+    if r["nbytes"] > 0:
+        samples = np.frombuffer(bytes(r["audio_bytes"]), dtype=np.int16).astype(np.float64)
+        rms = float(np.sqrt(np.mean(samples**2)))
+        if rms < MIN_RMS:
+            problems.append(f"near-silent audio (rms={rms:.1f} < {MIN_RMS})")
+    return problems
+
+
+def drive(url, args, n, conc, label, results, lock, idx, chunk_frames):
+    """Run ``n`` requests at concurrency ``conc``, cycling through ``args.texts``."""
+    texts = args.texts
+
+    def worker():
+        with httpx.Client(timeout=600.0) as c:
+            while True:
+                with lock:
+                    i = idx[0]
+                    idx[0] += 1
+                if i >= n:
+                    return
+                text = texts[i % len(texts)]
+                try:
+                    r = one_request(
+                        c, url, args.model, text, args.ref_audio, args.ref_text, chunk_frames, seed=args.seed
+                    )
+                    r["text"] = text
+                    with lock:
+                        results.append(r)
+                except Exception as e:
+                    print(f"    [{label}] request {i} failed: {e}", flush=True)
+
+    ts = [threading.Thread(target=worker) for _ in range(conc)]
+    t0 = time.perf_counter()
+    for t in ts:
+        t.start()
+    for t in ts:
+        t.join()
+    return time.perf_counter() - t0
+
+
+def run_combo(args, conc: int, chunk_frames: int, out: Path) -> dict:
+    tag = f"c{conc}_chunk{chunk_frames}"
+    run_dir = out / tag
+    run_dir.mkdir(parents=True, exist_ok=True)
+    log = run_dir / "server.log"
+
+    deploy = REPO / "vllm_omni/deploy" / f"_autogen_steps_{tag}.yaml"
+    deploy.write_text(
+        DEPLOY_TEMPLATE.format(
+            chunk_frames=chunk_frames,
+            max_chunk_frames=4 * chunk_frames,
+            stream_scale_factor=STREAM_SCALE_FACTOR,
+        )
+    )
+
+    cmd = [
+        vllm_bin(),
+        "serve",
+        args.model,
+        "--omni",
+        "--deploy-config",
+        str(deploy),
+        "--host",
+        "127.0.0.1",
+        "--port",
+        str(args.port),
+        "--allowed-local-media-path",
+        str(REPO),
+    ]
+    env = dict(os.environ)
+    if args.cuda_visible_devices:
+        env["CUDA_VISIBLE_DEVICES"] = args.cuda_visible_devices
+    if args.trt is not None:
+        env["COSYVOICE3_TRT"] = args.trt
+
+    print(f"\n=== concurrency={conc} step_size={chunk_frames} ===", flush=True)
+    print(f"  launching server (log: {log})", flush=True)
+    with open(log, "w") as lf:
+        proc = subprocess.Popen(cmd, env=env, stdout=lf, stderr=subprocess.STDOUT, start_new_session=True)
+    url = f"http://127.0.0.1:{args.port}"
+    try:
+        wait_ready(url, proc, log, args.server_timeout)
+        print("  server ready", flush=True)
+
+        results: list[dict] = []
+        lock = threading.Lock()
+        idx = [0]
+        if args.warmup:
+            print(f"  warmup ({args.warmup} req)", flush=True)
+            drive(url, args, args.warmup, min(conc, args.warmup), "warmup", results, lock, idx, chunk_frames)
+            results.clear()
+            idx[0] = 0
+
+        print(f"  running {args.num_prompts} req @ concurrency {conc}", flush=True)
+        wall = drive(url, args, args.num_prompts, conc, "bench", results, lock, idx, chunk_frames)
+
+        ok = [r for r in results if r.get("ttfa_s") is not None]
+        problems = []
+        for r in ok:
+            problems += check_correctness(r, args.min_audio_s)
+        # With a fixed seed, same-text requests must produce byte-identical PCM (per text group)
+        if args.seed is not None:
+            by_text: dict[str, bytes] = {}
+            for r in ok:
+                t = r.get("text")
+                ref = by_text.get(t)
+                if ref is None:
+                    by_text[t] = r.get("audio_bytes")
+                elif r.get("audio_bytes") != ref:
+                    problems.append(f"byte-identity violation for text {t!r}: seeded requests produced different PCM")
+        n_ok = len(ok)
+        total_audio_s = sum(r["audio_s"] for r in ok)
+        all_gaps = [g for r in ok for g in r["chunk_gaps_ms"]]  # (step_index, gap_ms) per request
+        gap_vals = [g for _, g in all_gaps]
+
+        # bucket gaps by chunk position within a request, to see any O(n) slope
+        by_idx: dict[int, list[float]] = {}
+        for step_index, g in all_gaps:
+            by_idx.setdefault(step_index, []).append(g)
+        step_latency_by_idx = {i: statistics.median(vals) for i, vals in sorted(by_idx.items())}
+
+        agg = {
+            "concurrency": conc,
+            "step_size": chunk_frames,
+            "ok": n_ok,
+            "errors": args.num_prompts - n_ok,
+            "correctness_problems": len(problems),
+            "correctness_sample": problems[:5],
+            "total_audio_s": total_audio_s,
+            "throughput_audio_s_per_s": total_audio_s / wall if wall > 0 else float("nan"),
+            "ttfa_s": _stats([r["ttfa_s"] for r in ok]),
+            "e2e_s": _stats([r["e2e_s"] for r in ok]),
+            "rtf": _stats([r["rtf"] for r in ok]),
+            "step_latency_ms": _stats(gap_vals),
+            "step_latency_ms_by_idx": step_latency_by_idx,
+            "num_steps": len(all_gaps),
+            # per-utterance-length breakdown; n per text = num_prompts / len(texts)
+            "by_text": {
+                t: {
+                    "audio_s": _stats([r["audio_s"] for r in ok if r.get("text") == t]),
+                    "e2e_s": _stats([r["e2e_s"] for r in ok if r.get("text") == t]),
+                    "rtf": _stats([r["rtf"] for r in ok if r.get("text") == t]),
+                }
+                for t in sorted({r.get("text") for r in ok})
+            },
+        }
+        print(json.dumps(agg, indent=2, ensure_ascii=False), flush=True)
+        return agg
+    finally:
+        print("  shutting down server", flush=True)
+        try:
+            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        except Exception:
+            proc.terminate()
+        try:
+            proc.wait(timeout=60)
+        except subprocess.TimeoutExpired:
+            try:
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            except Exception:
+                proc.kill()
+            proc.wait(timeout=20)
+        deploy.unlink(missing_ok=True)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--model", default=DEFAULT_MODEL)
+    p.add_argument(
+        "--text",
+        dest="texts",
+        nargs="+",
+        default=DEFAULT_TEXTS,
+        help="One or more utterance texts. With several, requests cycle through "
+        "them so a single server launch covers all utterance lengths; results "
+        "are bucketed per text.",
+    )
+    p.add_argument("--ref-audio", default=DEFAULT_REF_AUDIO)
+    p.add_argument("--ref-text", default=DEFAULT_REF_TEXT)
+    p.add_argument("--concurrency", type=int, nargs="+", default=[1, 8])
+    p.add_argument(
+        "--step-size",
+        type=int,
+        nargs="+",
+        default=[15],
+        help="codec_chunk_frames values to sweep (the streaming step size).",
+    )
+    p.add_argument("--num-prompts", type=int, default=30)
+    p.add_argument("--warmup", type=int, default=2)
+    p.add_argument("--port", type=int, default=8091)
+    p.add_argument(
+        "--server-timeout",
+        type=float,
+        default=1800.0,
+        help="Startup budget; first run also downloads weights and builds the TRT engine.",
+    )
+    p.add_argument("--output-dir", default="./perf_steps")
+    p.add_argument("--cuda-visible-devices", default="0")
+    p.add_argument(
+        "--trt",
+        choices=["0", "1"],
+        default=None,
+        help="Pin COSYVOICE3_TRT. 0=force torch estimator, 1=allow TensorRT. Default: unset.",
+    )
+    p.add_argument(
+        "--min-audio-s",
+        type=float,
+        default=1.0,
+        help="Minimum expected audio seconds per request for the correctness check.",
+    )
+    p.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Fixed seed for reproducible (byte-identical) audio. Pass --seed '' "
+        "equivalent (any non-int) to disable -- there is no unset sentinel here "
+        "by design, since the default sweep is meant to be exactly reproducible.",
+    )
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    out = Path(args.output_dir).resolve()
+    out.mkdir(parents=True, exist_ok=True)
+
+    all_results = []
+    failed = False
+    for conc in args.concurrency:
+        for chunk_frames in args.step_size:
+            try:
+                result = run_combo(args, conc, chunk_frames, out)
+                all_results.append(result)
+                if result["errors"] > 0 or result["correctness_problems"] > 0:
+                    failed = True
+            except Exception as e:
+                print(f"  combo c={conc} chunk={chunk_frames} FAILED: {e}", flush=True)
+                failed = True
+
+    out_path = out / "steps_results.json"
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump({"model": args.model, "texts": args.texts, "runs": all_results}, f, indent=2, ensure_ascii=False)
+    print(f"\nResults written to {out_path}", flush=True)
+
+    print("\n=== SUMMARY ===")
+    header = (
+        f"{'conc':>4} {'step':>4} {'ok':>4} {'corr':>4} "
+        f"{'TTFA med(ms)':>12} {'step med(ms)':>12} {'step p95(ms)':>12} {'RTF mean+-sd':>14}"
+    )
+    print(header)
+    print("-" * len(header))
+    for r in all_results:
+        print(
+            f"{r['concurrency']:>4} {r['step_size']:>4} {r['ok']:>4} {r['correctness_problems']:>4} "
+            f"{r['ttfa_s']['median'] * 1e3:>12.1f} "
+            f"{r['step_latency_ms']['median']:>12.1f} {r['step_latency_ms']['p95']:>12.1f} "
+            f"{r['rtf']['mean']:>6.3f}+-{r['rtf']['stdev']:>5.3f}"
+        )
+        for t, stats in r.get("by_text", {}).items():
+            print(
+                f"      text {t[:24]!r}: e2e {stats['e2e_s']['mean'] * 1e3:8.1f}"
+                f"+-{stats['e2e_s']['stdev'] * 1e3:6.1f} ms  (n={stats['e2e_s']['n']}, "
+                f"audio {stats['audio_s']['mean']:.1f}s)"
+            )
+
+    if failed:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docker/Dockerfile.rocm b/docker/Dockerfile.rocm
index adc767691..48631994f 100644
--- a/docker/Dockerfile.rocm
+++ b/docker/Dockerfile.rocm
@@ -2,7 +2,11 @@
 # docker/Dockerfile.ci. A stale base image can build successfully while failing
 # at runtime when vLLM-Omni imports APIs added by the newer vLLM release.
 ARG BASE_IMAGE=vllm/vllm-openai-rocm:v0.29.0
-FROM ${BASE_IMAGE} AS base
+
+# Keep the dependency-heavy portion independent from the source tree. The
+# registry cache is keyed on these inputs, while the final source copy can be
+# linked onto the cached image without materializing its large ROCm layers.
+FROM ${BASE_IMAGE} AS deps
 
 # NOTE: REMINDER to vLLM-Omni rebase maintainer
 # BASE_IMAGE pins the default prebuilt runtime when USE_NIGHTLY_BUILD=0.
@@ -64,9 +68,24 @@ RUN --mount=type=cache,target=/root/.cache/pip \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
-# Step 3: Copy vllm-omni code and install without uv
-RUN mkdir -p ${COMMON_WORKDIR}/vllm-omni
-COPY . ${COMMON_WORKDIR}/vllm-omni
+# Step 3: Install project dependencies against a placeholder package tree.
+# The editable install keeps resolving imports from this directory after the
+# final COPY --link replaces the placeholder with the real source tree.
+WORKDIR ${COMMON_WORKDIR}/vllm-omni
+RUN mkdir -p vllm_omni && touch vllm_omni/__init__.py
+COPY pyproject.toml setup.py ./
+COPY requirements/ requirements/
+ENV SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0
+
+RUN uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" \
+        --no-cache-dir -e ".[dev]" --no-build-isolation && \
+    python3 -m pip uninstall -y onnxruntime && \
+    python3 -m pip install --no-cache-dir --force-reinstall --no-deps \
+        "onnxruntime-rocm>=1.22.2" && \
+    python3 -c "import importlib.metadata as m; import onnxruntime as ort; assert 'ROCMExecutionProvider' in ort.get_available_providers(), ort.get_available_providers(); assert m.version('onnxruntime-rocm'); assert not any(d.metadata['Name'] == 'onnxruntime' for d in m.distributions())" && \
+    python3 -c "from torchcodec.decoders import VideoDecoder"
+
+RUN ln -sf /usr/bin/python3 /usr/bin/python
 
 # This is a workaround to ensure pytest exits with the correct status code in CI tests.
 RUN printf '%s\n' \
@@ -85,19 +104,13 @@ RUN printf '%s\n' \
     '    os._exit(_exit_code)' \
     > ${COMMON_WORKDIR}/vllm-omni/conftest.py
 
-# Some optional dependencies pull in the CPU ONNX Runtime distribution. The
-# CPU and ROCm wheels own the same import path and cannot coexist, so remove
-# the CPU wheel and reinstall the ROCm wheel after dependency resolution.
-RUN cd ${COMMON_WORKDIR}/vllm-omni && \
-    uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" \
-        --no-cache-dir ".[dev]" --no-build-isolation && \
-    python3 -m pip uninstall -y onnxruntime && \
-    python3 -m pip install --no-cache-dir --force-reinstall --no-deps \
-        "onnxruntime-rocm>=1.22.2" && \
-    python3 -c "import importlib.metadata as m; import onnxruntime as ort; assert 'ROCMExecutionProvider' in ort.get_available_providers(), ort.get_available_providers(); assert m.version('onnxruntime-rocm'); assert not any(d.metadata['Name'] == 'onnxruntime' for d in m.distributions())" && \
-    python3 -c "from torchcodec.decoders import VideoDecoder"
-
-RUN ln -sf /usr/bin/python3 /usr/bin/python
+# Keep source changes in one lightweight linked layer. Do not add RUN, COPY, or
+# ADD instructions that depend on the resulting filesystem after this point;
+# doing so would force BuildKit to download and extract the cached ROCm layers.
+FROM deps AS base
+ARG COMMON_WORKDIR=/app
+WORKDIR ${COMMON_WORKDIR}/vllm-omni
+COPY --link . .
 
 FROM base AS test
 
diff --git a/docker/Dockerfile.rocm.dockerignore b/docker/Dockerfile.rocm.dockerignore
new file mode 100644
index 000000000..f68737749
--- /dev/null
+++ b/docker/Dockerfile.rocm.dockerignore
@@ -0,0 +1,35 @@
+# Keep the linked source layer small and deterministic.
+.git
+.venv
+/build
+dist
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+.mypy_cache
+
+# Distribution / packaging
+.Python
+/build/
+cmake-build-*/
+CMakeUserPresets.json
+develop-eggs/
+/dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+rust/target/
diff --git a/docker/Dockerfile.xpu b/docker/Dockerfile.xpu
index 018bc4316..da7930ae2 100644
--- a/docker/Dockerfile.xpu
+++ b/docker/Dockerfile.xpu
@@ -40,7 +40,6 @@ ENV VLLM_OMNI_TARGET_DEVICE=xpu
 # Keep the upstream oneCCL packages paired with the XPU torch runtime.
 RUN --mount=type=cache,target=/root/.cache/uv \
     uv pip install --no-build-isolation \
-    --extra-index-url https://mirrors.ustc.edu.cn/pypi/simple/ \
     ".[dev]" && \
     uv pip uninstall triton && \
     uv pip install triton-xpu==3.7.2 --reinstall
diff --git a/docs/.nav.yml b/docs/.nav.yml
index beb15bf47..da55af813 100644
--- a/docs/.nav.yml
+++ b/docs/.nav.yml
@@ -161,6 +161,7 @@ nav:
         - Cache-DiT: design/feature/cache_dit.md
         - TeaCache: design/feature/teacache.md
         - Diffusion Continuous Batching: design/feature/diffusion_continuous_batching.md
+        - Mooncake KV Transfer: design/feature/mooncake-kv-transfer.md
     - Infrastructure and Performance:
       - Prometheus Metrics: design/metrics.md
       - Speech Generation Performance Optimizations: design/qwen3_omni_tts_performance_optimization.md
diff --git a/docs/README.md b/docs/README.md
index 90a8b6304..3733a9d2d 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -56,7 +56,7 @@ vLLM-Omni is flexible and easy to use with:
 vLLM-Omni seamlessly supports most popular open-source models on HuggingFace, including:
 
 - Omni-modality models (e.g. Qwen3-Omni, MiniCPM-o 4.5, Cosmos3, HunyuanImage, BAGEL)
-- TTS models (e.g. Qwen3-TTS, IndexTTS 2.5, dots.tts, CosyVoice3)
+- TTS models (e.g. Qwen3-TTS, IndexTTS 2.5, CosyVoice3)
 - Diffusion models — image, video, and audio generation (e.g. MiniMax H3, LTX-2.5, SANA-Video, Wan2.2)
 - Robot-policy and action models (e.g. π0, GR00T-N1.7, DreamZero-DROID, InternVLA-A1)
 
diff --git a/docs/cli/bench/serve.md b/docs/cli/bench/serve.md
index 8dc5e1ed8..450a01e5a 100644
--- a/docs/cli/bench/serve.md
+++ b/docs/cli/bench/serve.md
@@ -23,7 +23,9 @@ You can use `vllm bench serve --omni --help=all` to get descriptions of all para
   The API endpoint exposed externally, to which clients send their requests.
 
 - `--dataset-name`
-  The name of the dataset used; random-mm indicates generating random multimodal inputs (images, videos, audio), while `omniinteract` replays official OmniInteract videos.
+  The name of the dataset used; `random-mm` generates random multimodal inputs (images, videos, audio),
+  `omniinteract` replays official OmniInteract videos, and `videomme` loads Video-MME MCQ videos
+  (`lmms-eval/Video-MME`, MiniCPM OmniEvalKit packing).
 
 - `--num-prompts`
   The total number of requests to send, an integer.
@@ -343,6 +345,57 @@ transcript, event, and result artifacts without errors. A valid LISTEN-only case
 chunks. Official-manifest eligibility is reported separately because clipped or cancelled output is a benchmark-quality
 signal, not a transport failure. This local performance test does not score answer accuracy.
 
+### Video-MME Benchmark
+
+Video-MME (`--dataset-name videomme`) scores multiple-choice video QA. Default packing is
+OmniEvalKit MiniCPM `minicpm-frames` (up to 96 sampled frames as `image_url`). Pass a local
+mirror with `--dataset-path` / `--videomme-parquet` + `--videomme-video-dir`, or a Hugging
+Face dataset id (`lmms-eval/Video-MME` by default; any `org/name` is accepted when
+`--dataset-name videomme` is explicit). Relative `--videomme-video-dir` values are resolved
+to absolute `file://` URLs. For those URLs, start the server with
+`--allowed-local-media-path` covering the video root; otherwise use `--videomme-inline-local-video`.
+
+For MiniCPM-o 4.5, the default deployment allows 64 images per request. To run the
+96-frame recipe, start the server with a stage 0 override (replace `/path/to/Video-MME`
+with the local video root shared by the benchmark client and server):
+
+```bash
+vllm serve openbmb/MiniCPM-o-4_5 --omni \
+  --allowed-local-media-path /path/to/Video-MME \
+  --stage-overrides '{"0":{"limit_mm_per_prompt":{"image":96,"audio":64,"video":1}}}'
+```
+
+The override applies to this server invocation only. Alternatively, use
+`--videomme-max-frames 64` in the benchmark to stay within the default image limit;
+this evaluates a different frame-sampling setting from the 96-frame recipe.
+
+Run the benchmark against that server:
+
+```bash
+vllm bench serve --omni \
+  --backend openai-chat-omni \
+  --dataset-name videomme \
+  --dataset-path /path/to/Video-MME \
+  --videomme-pack-mode minicpm-frames \
+  --videomme-max-frames 96 \
+  --model openbmb/MiniCPM-o-4_5 \
+  --endpoint /v1/chat/completions \
+  --num-prompts 8 \
+  --max-concurrency 1 \
+  --save-result
+```
+
+Accuracy keys (`videomme_accuracy`, per-duration / domain / task breakdowns) are written into
+the saved JSON. `videomme_accuracy` excludes HTTP failures; `videomme_accuracy_incl_http_fail`
+counts them as wrong. `videomme_submitted` / `videomme_unique_question_ids` show when
+oversampling made the request count differ from unique-question coverage.
+`videomme_skipped_rows` counts rows skipped during sampling because of missing or unreadable
+media or invalid question fields. The opt-in accuracy runner rejects skipped rows, HTTP
+failures, duplicate question IDs, and missing gold answers. This checks the sampled subset;
+it does not establish that a supplied local mirror contains the entire official dataset.
+Use `--videomme-save-eval-items` (or `VIDEOMME_SAVE_EVAL_ITEMS=1`) for per-request
+`videomme_eval_items` rows.
+
 ### Multi-Modal Benchmark
 
 <details class="admonition abstract" markdown="1">
diff --git a/docs/cli/serve.md b/docs/cli/serve.md
index cf3d068a6..f77503091 100644
--- a/docs/cli/serve.md
+++ b/docs/cli/serve.md
@@ -1,5 +1,67 @@
 # vllm-omni serve
 
+## Multiple API frontends
+
+For local EngineCore pipelines with one or more stages, `--api-server-count` starts
+multiple API frontend processes that share one parent-owned set of stage
+engines:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
+    --api-server-count 2 \
+    --port 8091
+```
+
+This mode is intended for workloads whose request parsing, multimodal input
+processing, or response encoding can bottleneck a single frontend. It
+currently requires local multi-process EngineCore stages with one local
+process group per replica. A stage may still use multiple `num_replicas`.
+It cannot be combined with diffusion, headless or
+remote stages, intra-stage data parallelism, Ray, fault tolerance, elastic
+expert parallelism, sleep mode, or runtime LoRA updating. Runtime voice upload
+and deletion are also disabled because those mutations are process-local;
+built-in voices, inline reference audio, and voices restored at startup remain
+available. The `/v1/omni/sleep` and `/v1/omni/wakeup` control routes return HTTP
+409 for the same reason: their bookkeeping is process-local while stage engines
+are shared.
+
+A single-stage model pipeline is supported through the normal launch command;
+this is distinct from the distributed `--stage-id` / `--headless` launch mode.
+Every stage in the pipeline must be an EngineCore stage. Mixed AR-to-DiT
+pipelines, including MiniMax-H3, remain unsupported even when their first
+stage is an EngineCore stage. Diffusion support requires per-frontend channels
+and shared-engine lifecycle handling in the diffusion backend.
+
+### Workloads and performance validation
+
+Each API process owns its frontend processor, Orchestrator, request state,
+and per-replica EngineCore channels. Requests return through the channel of
+the originating API process; model weights and GPU stage engines are shared.
+This distributes frontend and orchestration work across CPU processes.
+
+| Workload | Potential benefit | Limitation |
+| ---------- | ------------------- | ------------ |
+| Concurrent cold image/video inputs on supported EngineCore pipelines | Parallel frontend processing when one API process is CPU-limited | A single cold request and GPU computation may be unchanged |
+| Many replicas producing frequent text/audio outputs | Less API/Orchestrator work and GIL contention per process | Routing remains serial within each Orchestrator |
+| Warm inputs or low-concurrency, GPU-limited generation | Additional frontend capacity | More API processes may add overhead without improving throughput |
+
+Here, a cold input means media or preprocessing caches miss, not that model
+weights must be loaded or GPU kernels compiled. Each frontend has its own
+processor/cache state, so cache duplication, CPU thread contention, and memory
+usage also matter. Multi-API serving does not itself change the output queue,
+move response encoding to an executor, or change the model's numerical scheduler.
+
+Compare `--api-server-count 1`, `2`, and higher counts with the same hardware,
+model/stage configuration, media, sampling parameters, output lengths, and
+offered load. Keep cold-cache and warmed-cache runs separate and report repeated
+measurements. Record CPU and request counts for every API worker, input and
+output queue delay, GPU utilization, first-output latency, and end-to-end latency.
+Confirm requests reach every worker: connection reuse can concentrate traffic
+on one process. Queue-only or single-API experiments do not establish a
+multi-API throughput gain. The multi-replica workload in
+[#4680](https://github.com/vllm-project/vllm-omni/issues/4680) remains a relevant
+validation target.
+
 ## Stage-based CLI quickstart
 
 The stage-based CLI is designed for deployments that require launching each pipeline stage in an isolated process
@@ -61,3 +123,10 @@ CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
 ## Arguments
 
 --8<-- "docs/generated/argparse_omni/omni_serve.inc.md"
+
+Async video jobs use process-local metadata and task handles. With multiple API
+workers, creating, listing, retrieving, downloading, and deleting these jobs
+returns HTTP 409. This restriction is independent of the current diffusion
+stage launch restriction: supporting multi-worker diffusion also requires a
+shared job lifecycle. Missing frontend topology state returns HTTP 503 for
+operations that require process-local state protection.
diff --git a/docs/configuration/environment_variables.md b/docs/configuration/environment_variables.md
index 4f9b4a50d..3f15cd8cc 100644
--- a/docs/configuration/environment_variables.md
+++ b/docs/configuration/environment_variables.md
@@ -70,6 +70,7 @@ The lifecycle labels used below are:
 | `OMNI_DIFFUSION_PROMPT_EMBED_CACHE_SIZE` | Positive integer; default `32` entries | Each diffusion runner; resolved during model setup | A valid environment value overrides the explicit cache size. A non-integer logs a warning; a non-positive value is ignored. | Experimental |
 | `OMNI_DIFFUSION_SESSION_STATE_MANAGER` | Boolean with the same accepted spellings as the prompt cache; default disabled | Experimental diffusion session manager; model setup | A recognized environment value overrides the explicit enable setting. An unrecognized value is ignored. | Experimental |
 | `OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS` | Positive integer; default `64` | Experimental diffusion session manager; model setup | A valid environment value overrides the explicit maximum. A non-integer logs a warning; a non-positive value is ignored. | Experimental |
+| `VLLM_OMNI_AR_DIFFUSION_KV_GATHER` | `1` enables; default `0` (off) | AR-diffusion KV manager at allocation and attention at dispatch; set before worker startup | Only the exact value `1` enables contiguous KV gathering. History staging additionally requires `ARDiffusionKVConfig.reuse_history_staging`. | Experimental |
 
 Backend names for `DIFFUSION_ATTENTION_BACKEND` are the members of
 `DiffusionAttentionBackendEnum`, such as `FLASH_ATTN`, `TORCH_SDPA`,
diff --git a/docs/configuration/stage_configs.md b/docs/configuration/stage_configs.md
index aa81d42c6..2540b19d9 100644
--- a/docs/configuration/stage_configs.md
+++ b/docs/configuration/stage_configs.md
@@ -53,7 +53,7 @@ The new deploy schema lives under `vllm_omni/deploy/` and is paired with a froze
 | ------- | ------ | ---------- | --------- | ------------- |
 | `base_config` | str (path) | optional | — | Overlay parent (relative or absolute). `stages:` / `platforms:` deep-merged by stage_id; other scalars overlay-wins. Intended for user-authored overlays; prod yamls stay flat. |
 | `async_chunk` | bool | optional | `true` | Enable chunked streaming between stages. Pin to `false` if the pipeline runs end-to-end. |
-| `session_mode` | str | optional | `"turn"` | Session behavior. Duplex models (pipelines with a `duplex_plugin`, e.g. MiniCPM-o 4.5) set `"duplex"`; `vllm-omni serve` then serves it over `/v1/realtime?duplex=1` and `/v1/chat/completions`, both on duplex sessions. |
+| `session_mode` | str | optional | `"turn"` | Session behavior. For pipelines with a `duplex_plugin`, explicitly select `"duplex"` for the duplex engine or `"turn"` for the ordinary online serving stack. The shipped MiniCPM-o 4.5 default remains `"duplex"`. See [Full Duplex](../serving/full_duplex_api.md#enable-full-duplex). |
 | `active_stream_window` | int | optional | `0` | Number of active downstream stream slots; `0` preserves all-stream cycling. |
 | `duplex_session` | dict | optional | runtime defaults | Full-duplex session lifecycle, buffering, replay, and capacity limits. |
 | `connectors` | dict | optional | `null` | Named connector specs (`{name, extra}`). Referenced by each stage's `input_connectors` / `output_connectors`. See [Connector schema](#connector-schema). |
@@ -290,3 +290,90 @@ vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/depl
 
 !!! important
     We are actively iterating on the definition of deployment configurations, and we welcome feedback from users and developers.
+
+## Qwen3-TTS with Model Runner V2
+
+Qwen3-TTS can opt into the native CUDA Model Runner V2 pipeline on vLLM
+0.29.0. Select one of these deployment profiles:
+
+| Profile | Runner | Code2Wav graph batches | Intended use |
+| --- | --- | --- | --- |
+| `qwen3_tts.yaml` | V1 | Existing defaults | Existing deployment / regression control |
+| `qwen3_tts_mrv2.yaml` | V2 | B1 | Native runner validation |
+| `qwen3_tts_high_concurrency_mrv2.yaml` | V2 | B1, B2 | Opt-in throughput tuning |
+| `qwen3_tts_high_concurrency_mrv2_b4.yaml` | V2 | B1, B2, B3, B4 | Experimental throughput / buffered playback |
+
+```bash
+vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-Base --omni \
+  --deploy-config vllm_omni/deploy/qwen3_tts_mrv2.yaml
+```
+
+The V2 profiles bound Talker prefill to 512 tokens per step and select the
+Talker AR runner and the Code2Wav generation
+runner together. Native inter-stage delivery carries codec payloads directly;
+request-owned snapshots preserve buffers through asynchronous completion and
+CUDA graph reuse. Terminal completion waits for upstream stage metrics before
+releasing request state. Platform sections retain V1 on NPU, XPU, ROCm and MUSA;
+this change does not qualify MRV2 on those backends or enable other model families.
+Selecting V2 for a stage without `supports_native_mrv2_data_plane` emits a warning
+when pipeline and deployment settings are merged. That stage retains the legacy
+transport path; the warning does not establish support for that combination.
+
+MRV2 model hooks use capability declarations rather than architecture or stage
+names. Omni lifecycle flags select the model state, and `_returns_tuple` declares
+the capture output contract. The optional batched predictor hook is `mtp`, with
+an explicit `mtp_output_key` (a string or two-part payload key), optional
+`mtp_validity_key`, and `mtp_graph_safe`/`mtp_disable_graph` capture controls.
+Its inputs are token IDs, embeddings, previous hidden states and per-row
+conditioning; it returns updated embeddings and prediction codes. Models may
+supply `mtp_sampling_params` and `get_mtp_seed(sampling_params)` for model-local explicit seeds, and declare
+`mtp_accepts_per_row_generators`, `mtp_accepts_req_infos`, or `mtp_sample_uniforms`
+(with `mtp_sample_steps` and `mtp_sample_vocab_size`) as needed. Qwen3-TTS retains
+its existing `talker_mtp` entry point for V1.
+
+### Included performance work
+
+- Request snapshots have a fast path for immutable scalar leaves, including
+  waveform lists. Mutable containers, aliases and cycles keep deep-copy
+  semantics. This is not the historical shallow `dict(prompt)` experiment.
+- The API reference cache holds owned float32 arrays with a default capacity
+  of 1024 entries and a 512 MiB waveform-payload budget. Cache hits return
+  independent lists. Qwen3-TTS model artifact caches also default to 1024
+  entries. These caches have different owners and eviction policies; equal
+  entry limits do not make them a single coherent cache.
+- Talker state stays on GPU where its lifecycle allows it. BOS/EOS projections
+  are cached in their projection dtype and invalidated on weight loading.
+- Code2Wav packs CPU codec inputs before device transfer. Optional B2/B4 graph
+  buckets batch compatible requests without sharing their per-request state.
+- Native output materialization runs in a bounded worker and drains before
+  closing the data plane. The existing control-only shortcut avoids launching
+  model work for a step that has only lifecycle events.
+
+MTP prefix re-prefill remains disabled in the high-concurrency V2 profile.
+Adding more graph shapes increases compilation cost and has not established a
+stable end-to-end gain for this extracted version.
+
+### Decoder batches and playback
+
+Changing `decode_cudagraph_batch_sizes` selects the captured batch buckets.
+Keep `decode_batch_max_size` consistent with the intended maximum too; the
+stateful graph path currently groups according to the captured buckets, while
+the stateless path also uses the explicit maximum.
+
+B4 remains experimental. First-packet latency alone does not establish
+uninterrupted playback. Validate inter-chunk arrival times, buffering, WER and
+speaker similarity before adopting either batching preset for a production
+workload. Floating-point decoder outputs can differ across batch sizes; this PR
+does not claim bitwise or quality equivalence.
+
+### Optional MPS deployment
+
+NVIDIA MPS is an optional operator setting for colocated CUDA processes, not a
+YAML option or a library default. This PR does not establish a throughput or
+first-packet latency benefit from MPS. Measure the exact deployment with and
+without MPS before enabling it.
+
+Use only assigned GPUs and an independent MPS pipe directory. A private MPS
+server does not provide exclusive GPU ownership or MIG isolation. For a
+single-GPU deployment, explicitly place both stages on that GPU; the supplied
+high-concurrency profile places its two stages on different GPUs by default.
diff --git a/docs/design/architecture_overview.md b/docs/design/architecture_overview.md
index 862516831..8b7168824 100644
--- a/docs/design/architecture_overview.md
+++ b/docs/design/architecture_overview.md
@@ -323,7 +323,7 @@ inputs, fields, and ownership rules are described below.
 flowchart TB
     layer1["Layer 1 · Authoring inputs<br/>PipelineConfig + DeployConfig"]
     layer2["Layer 2 · Production resolution boundary<br/>resolve_omni_config()<br/>(StageConfigFactory + VllmOmniConfig internally)"]
-    layer3["Layer 3 · Startup hand-off<br/>OmniConfigResolution<br/>PipelineConfig + temporary OmegaConf stage bridge"]
+    layer3["Layer 3 · Startup hand-off<br/>OmniConfigResolution<br/>PipelineConfig + typed stage configs"]
     layer4["Layer 4 · Runtime launch planning<br/>StageRuntime"]
     layer5["Layer 5 · Engine materialization<br/>VllmConfig / OmniDiffusionConfig"]
 
@@ -335,10 +335,10 @@ The production resolution boundary is `resolve_omni_config()` in
 It delegates typed construction to `StageConfigFactory.create_from_model()` and
 `VllmOmniConfig.from_pipeline_config()`, then returns an
 `OmniConfigResolution` consumed by both `AsyncOmniEngine` and headless startup.
-Until `StageRuntime` consumes typed stage configs directly, this envelope carries
-the effective `PipelineConfig` alongside OmegaConf-compatible `stage_configs` as
-a temporary runtime bridge; both views describe the same resolved topology,
-including injected stages.
+This envelope carries the effective `PipelineConfig` alongside typed
+`stage_configs`, which `StageRuntime` consumes directly. Both views describe the
+same resolved topology, including injected stages. Backend arguments are
+projected from these typed stages when each engine is initialized.
 
 The legacy `stage_args` YAML path has been removed. Model topology now resolves
 through `PipelineConfig`, with runtime overrides supplied by `DeployConfig`.
@@ -360,7 +360,7 @@ The important ownership rules are:
 3. CLI and Python overrides are applied at the resolution boundary, with
    per-stage overrides taking precedence over global values where supported.
 4. `OmniConfigResolution` is the sole startup hand-off. Its `pipeline_config`
-   and temporary `stage_configs` compatibility view must describe the same
+   and typed `stage_configs` must describe the same
    topology.
 5. `StageRuntime` owns launch planning and replica lifecycle. `ReplicaInitPlan`
    is runtime-private state, not a user configuration object.
diff --git a/docs/design/feature/mooncake-kv-transfer.md b/docs/design/feature/mooncake-kv-transfer.md
new file mode 100644
index 000000000..ed83d562f
--- /dev/null
+++ b/docs/design/feature/mooncake-kv-transfer.md
@@ -0,0 +1,89 @@
+# Mooncake KV Transfer
+
+## PR summary
+
+This change adds an opt-in AR-to-DiT KV handoff using vLLM's native
+`KVTransferConfig`, Scheduler-owned diffusion KV pages, and
+`MooncakeConnector`. The existing `OmniKVTransferManager` path remains the
+fallback when `kv_transfer_config` is absent.
+
+The orchestrator creates one transfer ticket per request and resolves the
+bound AR replica's Mooncake endpoint after generation. DiT allocates the
+destination pages, waits for every worker rank to finish loading, and releases
+the source and destination pages only after the connector lifecycle completes.
+Request registration failures are rolled back before Worker dispatch. Receive
+timeouts and cancellation terminate the request without recycling in-flight
+pages: the scheduler retains them until every CFG row has completed on every
+rank. Late completion is polled only while such requests remain. If a peer
+never completes, its pages remain reserved until shutdown; other requests can
+continue using the remaining capacity. Invalid pages, missing Worker ranks,
+and failures without a proven rollback still stop the replica before teardown.
+The example sets `transfer_timeout: 60.0` seconds explicitly. Cancellation
+queued during a synchronous receive is processed when that receive completes
+or times out; it does not interrupt the remote write.
+
+## Reference configuration
+
+| Stage | Replicas | Devices | Parallelism | KV cache |
+| --- | ---: | --- | --- | ---: |
+| AR | 2 | 0-3 | TP=2 per replica | 2 GiB per worker |
+| DiT | 2 | 4-7 | TP=2 per replica, EP enabled | 1 GiB per worker |
+
+The acceptance workload uses 512x512 images, two denoising steps, guidance
+scale 2.0, and `max_num_seqs=1`.
+
+For a four-GPU debug run, set both stages to one replica and assign AR TP=2 to
+devices `0,1` and DiT TP=2 to devices `2,3`.
+
+## Experiment
+
+The final comparison used one node with eight NVIDIA RTX PRO 6000 Blackwell
+Server Edition GPUs, TCP Mooncake transport, the same 50-prompt/seed T2I
+dataset, concurrency 8, and two independent 100-request runs per
+implementation. Each side completed 200/200 requests without an OOM or request
+failure.
+
+| Implementation | Run 1 (req/s) | Run 2 (req/s) | Mean (req/s) |
+| --- | ---: | ---: | ---: |
+| `OmniKVTransferManager` | 4.4103 | 4.4497 | 4.4300 |
+| Native `MooncakeConnector` | 4.4457 | 4.4699 | 4.4578 |
+
+Native throughput is **0.63% higher** than the legacy mean. The absolute
+performance difference is below the 1% acceptance threshold.
+
+For accuracy, a non-zero transferred prefix and the resulting attention output
+were compared bit-for-bit with the legacy manager path:
+
+```text
+prefix_bits_equal    True
+attention_bits_equal True
+max_abs_diff         0.0
+```
+
+The one-AR/one-DiT TP=2 debug topology also completed 20/20 sequential
+requests. A separate real-TCP transport check transferred both CFG rows from a
+TP=1 producer to a strict-Ulysses SP=2 consumer with exact values on both
+target ranks.
+
+## Scope and limitations
+
+- The fully validated end-to-end topology is 2x AR TP=2 plus 2x DiT TP=2.
+- Heterogeneous TP=1 to SP=2 reshaping is transport-tested, but arbitrary mixed
+  TP/CFG/SP end-to-end combinations have not been exhaustively validated.
+- CFG-parallel end-to-end deployment is not part of this acceptance run.
+- Native AR-to-DiT transfer currently requires `async_chunk: false`.
+- TCP is covered by the acceptance run. The supplementary single-node RDMA
+  measurements use a separate short workload; they do not establish RDMA
+  support for multi-node deployment, which remains out of scope.
+- The native path currently validates the two-stage `AR(0) -> DiT(1)` graph. Other stage graphs are rejected during startup until
+  their producer/consumer edge mapping is implemented.
+- Sleep mode is disabled for the native paged path because registered KV pages
+  must remain mapped for the connector lifetime.
+
+- Ascend NPU adaptation and its performance validation are maintained in a
+  separate follow-up PR; the GPU acceptance results above do not validate NPU.
+- The homogeneous piecewise CUDA batching optimization is retained. A native
+  paged-attention CUDA graph capture/replay regression covers two CFG rows,
+  strided QKV, mixed causal/image spans, changed inputs, and output stability.
+  It must be run on CUDA hardware; CPU unit tests do not establish graph or
+  end-to-end performance acceptance.
diff --git a/docs/design/feature/offloader/README.md b/docs/design/feature/offloader/README.md
index 0ec81f3b5..52797b68c 100644
--- a/docs/design/feature/offloader/README.md
+++ b/docs/design/feature/offloader/README.md
@@ -84,10 +84,22 @@ Block topology comes from the pipeline `OffloadPlan` first: `block_attrs` maps
 each DiT path to its ordered block containers, `encoder_block_attrs` declares
 streamable encoder stacks, `on_demand_component_paths` marks pipeline-managed
 residency, `resident_dit_paths` marks the DiTs that may hold resident layers,
-and `encoder_dlo_weight_replication` marks the encoders whose loader-produced
-weights are safe for AllGather. DiTs absent from the plan fall back to
-`_layerwise_offload_blocks_attrs` (including the deprecated singular-name
-compatibility path).
+`encoder_dlo_weight_replication` marks the encoders whose loader-produced
+weights are safe for AllGather, and `offload_submodules` maps a DiT submodule
+that owns its residency to its own block container. DiTs absent from the plan
+fall back to `_layerwise_offload_blocks_attrs` (including the deprecated
+singular-name compatibility path).
+
+An undeclared DiT submodule joins the plan only when it is large enough that
+keeping it resident would defeat streaming; its block container is then found
+by scanning well-known attribute names, which warns once per submodule class.
+Size is computed from parameter shapes and dtypes, including meta parameters,
+so resolving before mmap loading preserves the same residency decision.
+Block ownership validation includes nested components: a block shared with a
+parent, sibling, or encoder is rejected before any hooks or storage are changed.
+A submodule with no block container must implement the `load_to_device` /
+`offload_to_cpu` lifecycle, and the resolver rejects it before any component of
+the pipeline is placed or hooked.
 
 The resolver is pure: it moves no tensor, installs no hook, writes no module
 attribute, and reads no process group — multi-rank facts come from
diff --git a/docs/design/feature/omni_async_output_materialization.md b/docs/design/feature/omni_async_output_materialization.md
index 50a2e7c52..eff3024d8 100644
--- a/docs/design/feature/omni_async_output_materialization.md
+++ b/docs/design/feature/omni_async_output_materialization.md
@@ -318,18 +318,18 @@ The same behavior applies to the Base and VoiceDesign Qwen3-TTS checkpoints
 because they use the same Talker implementation.
 
 !!! warning
-    Do not pass `--no-async-chunk` or enable prefix caching when you want this
-    optimization. Either change causes the runner to fall back to synchronous
-    output construction. Enabling async chunk alone cannot activate the feature
-    for a model that has not opted into async Omni output.
+    Do not pass `--no-async-chunk` when you want this optimization. Disabling
+    async chunk causes the runner to fall back to synchronous output
+    construction. Enabling async chunk alone cannot activate the feature for a
+    model that has not opted into async Omni output.
 
 !!! note "Prefix cache compatibility"
-    Async Omni output materialization and Omni prefix caching cannot currently
-    run together. `_should_use_async_omni_output()` returns `False` whenever
-    `self.omni_prefix_cache` is present, so prefix caching selects synchronous
-    output materialization. Supporting both features requires snapshotting or
-    otherwise synchronizing prefix-cache merge and update state before the
-    background output path can consume it safely.
+    Prefix cache and async Omni output can run together. `save_outputs` returns
+    a `step_id`; the output builder later calls `materialize(sid, req_ids)` with
+    the save-time request list, which may be a step late relative to the live
+    `input_batch`. `_should_use_async_omni_output()` does not disable itself
+    when the cache is present. See
+    [Automatic Prefix Caching](prefix_caching.md#implementation).
 
 ## Compatibility and Fallbacks
 
@@ -341,10 +341,9 @@ runtime conditions hold:
 | AR async scheduling is enabled | The optimization relies on the scheduler advancing while the prior output is materialized |
 | `async_chunk` is enabled | The feature targets incremental downstream Omni payloads |
 | The model stage opts in with `use_async_omni_output` | Models must declare that their output lifecycle is safe to defer |
-| Omni prefix cache is disabled | Prefix-cache merge and update ordering currently requires synchronous materialization |
 | Speculative decoding is disabled | Speculative output state is not included in this deferred path |
 | Routed-expert output is disabled | Routed-expert extraction currently requires the synchronous path |
-| Postprocess is absent or explicitly runs eagerly | State needed by the next decode step must be updated before the runner returns |
+| Postprocess is absent or explicitly runs eagerly | State needed by the next decode step must be updated before the runner returns. Eager postprocess sees the scheduled slice (`None, None` combined tensors), not the prefix-cache-merged full prompt; it must only consume the tail |
 
 These checks are evaluated per stage on runners based on `GPUARModelRunner`.
 An unsupported combination does not prevent serving; it only falls back to
@@ -380,6 +379,8 @@ so Omni payload materialization remains synchronous.
 - `tests/worker/test_gpu_ar_model_runner.py`: Snapshot, guard, connector
   ordering, and background error-propagation tests.
 - [Async Chunk](async_chunk.md): Inter-stage chunking and scheduling design.
+- [Automatic Prefix Caching](prefix_caching.md#implementation): Prefix-cache
+  `step_id` / `materialize` contract used by the deferred output builder.
 - [Qwen3-Omni optimization blog](https://vllm.ai/blog/2026-07-01-qwen3-omni-optimization):
   Optimization context and controlled performance results.
 - [PR #4476](https://github.com/vllm-project/vllm-omni/pull/4476): Feature
diff --git a/docs/design/feature/prefix_caching.md b/docs/design/feature/prefix_caching.md
index a8fe4fc50..5aeef0f77 100644
--- a/docs/design/feature/prefix_caching.md
+++ b/docs/design/feature/prefix_caching.md
@@ -1,6 +1,5 @@
 # Automatic Prefix Caching in Omni Models
 
-
 ---
 
 ## Table of Contents
@@ -9,6 +8,8 @@
 - [High-Level Approach](#high-level-approach)
 - [Example](#example)
 - [What About Multimodal Inputs?](#what-about-multimodal-inputs)
+- [Implementation](#implementation)
+- [Related Files](#related-files)
 
 ---
 
@@ -27,6 +28,7 @@ vLLM implements automatic prefix caching for managing its kv-cache, which is bes
     This document describes vLLM-Omni's mechanism for caching tensor outputs that are meant to be passed between stages, when requests have common prefixes, similar to the way in which vLLM has prefix caching for the kv-cache. This works in conjunction with vLLM's multimodal encoder caching, but is distinct. See the final section for a concrete example for how they tie together in practice.
 
 ### High-Level Approach
+
 !!! note "Note 2"
     Prior to reading this section, it's recommended to take a look at the design documents in vLLM for [Automatic Prefix Caching](https://docs.vllm.ai/en/latest/features/automatic_prefix_caching/), which will make some of the concepts more clear.
 
@@ -38,8 +40,10 @@ The main focus of vLLM-Omni's approach to prefix caching stage outputs is to bui
 
 With this in mind, consider the set of blocks in a 2D layout, where the row represents the index of blocks being considered, and the columns represent the slots corresponding to tokens within each block. Since we know the `num_blocks` and `block_size` from our kv cache config, if we want to cache a tensor with feature size `D`, we can preallocate a CPU tensor of size `(num_blocks, block_size, D)`, and use the same block index and slot mapping to retrieve the corresponding feature vector.
 
+Host footprint: each cached key costs `num_blocks × block_size × D × dtype_bytes` of **pinned** CPU memory (pinned so device→host can overlap compute), allocated on the first `save_outputs` that sees the key — the first real request pays the `cudaHostAlloc`. Measured on a Qwen3-Omni deployment: thinker `__hidden_states__` `[15092, 16, 2048]` bf16 ≈ 0.92 GiB (plus the same again for each `hidden_states.layer_*` key a model exposes), Qwen3-TTS talker `codes.audio` `[16180, 16, 16]` ≈ 33 MiB. Budget host RAM for the stage accordingly.
 
 ### Example
+
 !!! note "Note 3"
     Prefix caching in vLLM-Omni currently is only supported on AutoRegressive stages with one kv-cache group. Configure it with the pipeline-wide `enable_prefix_caching` field in the deploy config.
 
@@ -56,7 +60,7 @@ The prefix cache flow is then outlined below.
 
 2. Say we process the request `The quick brown fox was tired and slept beneath the shady tree`, which is 12 tokens and evenly divides into 3 blocks as shown below.
 
-```
+```text
          [  The quick brown fox  ] [  was tired and slept ] [beneath the shady tree ]
 Block 1: |<--- block tokens ---->|
 Block 2: |<------- prefix ------>| |<--- block tokens --->|
@@ -65,10 +69,9 @@ Block 3: |<------------------ prefix -------------------->| |<--- block tokens -
 
 When the request processes, we inspect the multimodal outputs and identify the `mm_feature` tensor, which will be of shape `(seq_len, feature_dim)`, i.e., `(12, 16)` in this example. We note that the first axis is dependent on the `seq_len` and add a new cache_tensor of shape `(num_blocks, block_size, feature_dim)` to our multimodal cache for tensors.
 
+1. If we lay out the cache as a 2D tensor of shape (`num_blocks`, `block_size`), we'll have something like the following:
 
-3. If we lay out the cache as a 2D tensor of shape (`num_blocks`, `block_size`), we'll have something like the following:
-
-```
+```text
 0: [  The quick brown fox  ]
 1: [  was tired and slept  ]
 2: [beneath the shady tree ]
@@ -78,7 +81,8 @@ When the request processes, we inspect the multimodal outputs and identify the `
 ```
 
 Or, if we flatten it down to 1D,
-```
+
+```text
 0: The
 1: quick
 2: brown
@@ -90,7 +94,8 @@ Or, if we flatten it down to 1D,
 ```
 
 which we can think of as row indices into the hidden states tensor if we view it as the 2D shape `(num_blocks x block_size, feature_dim)`. That is, the analogous flattened (from 3D -> 2D) mapping of the cache for hidden states becomes the following.
-```
+
+```text
 0: <hidden states vector of len 2 corresponding to 'The'>
 1: <hidden states vector of len 2 corresponding to 'quick'>
 2: <hidden states vector of len 2 corresponding to 'brown'>
@@ -103,10 +108,9 @@ which we can think of as row indices into the hidden states tensor if we view it
 
 Similarly, for the multimodal outputs cache, the flattened coordinates are the same, but the `mm_feature` maps to vectors of length `16` instead of the hidden size of `2`. Note that in practice, we may have multiple  multimodal output tensors per forward pass, which may have different names and different feature dimensions.
 
+1. Now, say that we receive a new request `The quick brown fox jumped over the dog`.
 
-4. Now, say that we receive a new request `The quick brown fox jumped over the dog`.
-
-```
+```text
          [  The quick brown fox  ] [  jumped over the dog ]
 Block 1: |<--- block tokens ---->|
 Block 2: |<------- prefix ------>| |<--- block tokens --->|
@@ -116,7 +120,7 @@ Here, we will have a cache hit for `Block 1` which will be detected by vLLM base
 
 Since we have the block indices / slot mappings from the kv cache manager, we can simply mirror the mappings and leverage the same indices for the cached hidden states and multimodal outputs. This allows us to look up the correct tensors from our externally maintained 3D caches.
 
-```
+```text
 0: [  The quick brown fox  ] < already in the cache
 1: [  was tired and slept  ]
 2: [beneath the shady tree ]
@@ -129,11 +133,11 @@ Since we have the block indices / slot mappings from the kv cache manager, we ca
 
 Finally, to pass the full hidden states and multimodal outputs to the next stage, we simply concatenate the cached contents with the corresponding new tensors computed from the current forward call.
 
-
 ### What About Multimodal Inputs?
+
 It's also useful to consider the case about how Omni prefix caching is handled when we have multimodal inputs that don't cleanly end on block boundaries, as well as how this works with multimodal encoder caching in vLLM. For example:
 
-```
+```text
          [   Im0  Im1  Im2  Im3  ] [ Im4  Im5 foo <empty> ]
 Block 1: |<--- block tokens ---->|
 Block 2: |<------- prefix ------>| |<--- block tokens --->|
@@ -147,9 +151,9 @@ In reality, this isn't a big problem for correctness, because vLLM also maintain
 - The hash describing the image data starting at position 0 and with length 6
 - In vLLM's encoder cache, a mapping from the image hash above to the encoder output
 
-
 To understand what happens, say we get the following input as a second request:
-```
+
+```text
          [   Im0  Im1  Im2  Im3  ] [  Im4  Im5 bar  baz  ]
 Block 1: |<--- block tokens ---->|
 Block 2: |<------- prefix ------>| |<--- block tokens --->|
@@ -162,3 +166,162 @@ Because we have multimodal data in a scheduled span that isn't fully precomputed
 When we pass our multimodal tensors to the language model component in the same stage, we'll then expect the same outputs, because the prefix caching behaviors in vLLM-Omni / vLLM match, so the LLM will use vLLM's KV cache manager's prefix caching to correctly handle the attention information for `Block 1` while calculating the outputs for `Block 2`, giving us the correct results for processing `Block 2` with the context of `Block 1`.
 
 Finally, we look up the output hidden states/multimodal tensors corresponding to the prefix cache hit `Block 1` and concatenate it with the forward pass result to get the final result, which is expected to be identical to the full hidden states when prefix caching is disabled.
+
+### Implementation
+
+The block/slot model is `vllm_omni/core/prefix_cache/`.
+`OmniPrefixCacheManager` owns slot occupancy, the request-task table,
+hit spans, and merge.
+`OmniPrefixCacheController` moves data: a reusable `StagingBufferPool` for
+this step's device→host copy, and writes into the durable `PrefixBlockPool`.
+The state lock covers those tables only.
+
+Miss is not an error (this step's forward slice only). A hit span whose
+hidden rows are absent is fatal. For mm keys the rule is looser: a model may
+emit a key only for some requests, so a hit span with no rows behind an mm key
+reads zeros from the pool for those positions rather than raising. Abort still
+writes: once a hash entered this step's batch it must land in the cache.
+
+`enable_prefix_caching` is refused on KV-consumer stages (`kv_role` of
+`kv_consumer` or `kv_both`). KV received from a producer is reported as
+`num_computed_tokens` too, and the manager cannot tell it from a local hit.
+Producer-only stages are unaffected. Pooling stages never save, so they get
+no cache. This gate is one function, `stage_prefix_cache_config`, called by
+both the GPU and the NPU model runner at kv-cache init.
+
+Which stages may set `enable_prefix_caching: true`:
+
+| Stage | `enable_prefix_caching` | Why |
+| --- | --- | --- |
+| AR stage with one full-attention kv group whose hidden states / per-token mm feed the next stage (Qwen3-Omni thinker and talker) | supported | The case the cache is built for: full-prompt hidden states are merged from the pool on a hit. |
+| AR stage that sets `requires_full_prefix_cached_hidden_states = False`, optionally with `deferred_prefix_cache_mm_keys` (Qwen3-TTS talker, Higgs v3 talker) | supported | Hidden is not cached; deferred codec rows are written once on finish. |
+| Pooling stage | ignored | Never saves; the gate returns no config. |
+| `kv_role: kv_consumer` / `kv_both` | refused at kv-cache init (`OmniPrefixCacheUnmatchError`) | Producer KV shows up as `num_computed_tokens` and is indistinguishable from a local hit. |
+| Speculative decoding on the stage | refused at kv-cache init | Under async scheduling vLLM keeps `num_computed_tokens_cpu` optimistic (all drafts accepted) during the forward and corrects it afterwards; `step_slots_cpu` would mirror rows at the wrong slots. Not verified; refused as a whole. |
+| `prefix_match_unit` smaller than `block_size` | refused at kv-cache init | Sub-block hits make `num_computed_tokens` unaligned; the hit registry only mirrors whole blocks. |
+| Hybrid / sliding-window / multi-group kv cache (e.g. a talker with `attention_type: sliding_recompute`) | refused at kv-cache init | The cache mirrors exactly one full-attention block table. |
+| Attention backend whose kernel block size differs from `--block-size` (FlashInfer / FlashMLA / CutlassMLA with a block size they do not list natively), or decode context parallel | refused at first step (`FullAttentionGroupView`) | `step_slots_cpu` computes `table[req, pos // block_size] * block_size + pos % block_size` over allocator block ids; hybrid kernel blocks and DCP token striping change that row layout. FlashAttention / Triton accept any multiple of 16 and never split blocks. |
+| Codec decoder / Code2Wav stages (Qwen3-Omni stage 2, Qwen3-TTS stage 1) | keep `false` | Nothing downstream consumes their hidden states; the cache would only add device→host copies. Not validated. |
+| Diffusion stages | n/a | No vLLM KV cache to mirror. |
+
+Hit spans come from `scheduled_new_reqs` only, as in the pre-refactor cache:
+
+- A new request with a (partial) prefix hit is the normal path: the hit
+  blocks are read from the pool, the rest is this step's rows, and the
+  divergent tail is written under its own blocks. The gather starts on the
+  prefetch thread at `new_step_starts`; a same-step hit (vLLM hashes blocks
+  at schedule time, so `b` can hit blocks `a` computes in the same forward)
+  cannot plan until `a`'s write is registered and starts at `save_outputs`
+  instead. Either way it runs before the next step can hand those blocks
+  to a new tenant. vLLM frees blocks one step before `finished_req_ids`
+  arrives, so a finished request whose last step materializes late may
+  still find a hit slot reassigned. Each `(slot, key)` carries a write
+  version, bumped whenever a new write claims it. A planned read captures
+  that version and is registered in `_pending_reads`; a later write that
+  reclaims those slots copy-on-writes the still-`COMMITTED` rows into the
+  ref before it overwrites the pool, so a delayed fetch serves the original
+  tenant. A version mismatch with no preserved copy raises for live and
+  finished alike (the pool rows are a newer tenant's). Production defaults
+  stay opt-in until preempt/resume hit spans are reconstructed.
+- `async_chunk` continuation: when the next upstream chunk arrives, the same
+  request id re-enters `scheduled_new_reqs` with `num_computed_tokens` equal
+  to what it already computed itself. Ids already in `live_reqs` are skipped
+  for hit marking: those rows were delivered in earlier steps and re-emitting
+  them would duplicate output. A `delivered_upto` span for this case is
+  Phase 2.
+- Preemption + reschedule: vLLM resets `num_computed_tokens` to 0 on
+  preemption and re-runs prefix matching on resume, so the resumed request
+  can come back with a fresh hit. With the V1 model runner it arrives
+  through `scheduled_cached_reqs` (id in `resumed_req_ids`, `new_block_ids`
+  replaces the table); with the V2 runner it re-enters `scheduled_new_reqs`
+  while still in `live_reqs`. Neither path marks an omni hit span: the
+  resumed request gets only the rows it recomputes, and its still-open
+  deferred write keeps appending (a slot written twice keeps the later
+  chunk). Cache integrity holds either way — the hit blocks already have
+  rows, from this request or the one it hit. Stages that need full prompt
+  hidden states should be sized so preemption does not occur while prefix
+  caching is on. Same as before this refactor; tracked for Phase 2.
+
+Two write paths, split by `ModelCachePolicy.deferred_keys`:
+
+- Immediate (`JOIN_NEXT_STEP`): save launches a whole-step device→host into
+  a staging slot; the committer waits that event and writes the CPU pool.
+  The next save waits `done` (the pool write): a reused slot must never
+  leave a pending pool write behind, or a delayed hit read of the old rows
+  would find nothing recoverable.
+- Deferred (`JOIN_ON_FINISH`): mm whose first dim is this step's token count
+  stays on a per-request GPU clone; `_WriteChunk`s append across steps;
+  finish/abort (or GPU-byte-budget pressure) forces the copy. One open
+  WriteTask per request; a budget flush may close it mid-request, in which
+  case the next save opens a new one (`write_n` + 1) and a hit reads both,
+  so one long request cannot pin the whole budget.
+
+A `WriteTask` moves through `TaskState` only via `transition()`, one step at
+a time along a strict chain:
+`PENDING` (registered, not queued) → `QUEUED` (on a copy queue) →
+`COPYING` (one thread owns the copy stage) → `HOST_READY` (host rows ready) →
+`WRITTEN` (in the CPU pool); `FAILED` is reachable from any non-terminal
+state. Skipping a step raises. The worker claims `COPYING` in the same `_wake`
+critical section as the queue pop, so `escalate` never re-queues a task it can
+see is already claimed. `host_ready` / `done` are wait primitives set by the
+transitions into `HOST_READY` / `WRITTEN` / `FAILED`. GPU-clone bytes are
+charged once per clone on a `_BudgetTicket` pinned by every task that views
+it, and uncharged when the last holder releases (idempotent per tid).
+
+Mm whose first dim equals the unpadded scheduled length *or* the CUDA-graph
+padded length is registered on first sighting. Talker `codes.audio` is a
+cat of scheduled rows and stays unpadded while hidden is padded; both must
+open a pool key, whether immediate or deferred.
+Leftover mm (lists, `codes.ref`, any tensor whose first dim is not this
+step's token count) is copied to CPU at save without truncating that first
+dim. That leftover copy is the async-builder read replica for this step; it
+does not write the pool or carry abort/preempt occupancy.
+
+```python
+cache.register_policy(ModelCachePolicy.from_model(model))   # load_model
+cache.new_step_starts(scheduler_output)   # before _update_states
+sid = cache.save_outputs(hidden, mm_outputs, num_tokens_unpadded=n,
+                         num_tokens_padded=n_pad)
+outs = cache.materialize(sid, req_ids)    # or discard_step(sid)
+```
+
+Each step id is consumed exactly once. `req_ids` must be a subset of the save
+snapshot. At most `staging_depth` unused step ids may exist at once: every
+`save_outputs` claims one staging slot, including saves with only leftover
+mm that copy no device→host page. A slot is also held by each immediate
+write that views it, until the committer's pool write. A later save waits
+for `materialize`/`discard_step` or that pool write to free a slot;
+`staging_claim_timeout_s` then errors with the unused ids and the task count.
+`join`/`join_host_ready` use the same bound and raise with the stuck task's
+id and state instead of hanging the caller.
+`materialize` may run on the async output builder after the engine has
+entered the next step; leftover mm (not written to the pool) is copied
+to CPU at `save_outputs` so the builder never reads live CUDA-graph
+buffers. See
+[Async Omni Output Materialization](omni_async_output_materialization.md).
+
+The cache is constructed only on the last pipeline-parallel rank
+(`_ensure_omni_prefix_cache`). Other ranks skip it: they never call
+`save_outputs`, so a hit table there would resolve to absent slots.
+
+Threads, locks, and what each may block on:
+
+| Thread | Role | May block on | Must not hold while blocked |
+| --- | --- | --- | --- |
+| Engine | `new_step_starts`, `save_outputs` | previous-step `join` (`done`) / finished-write `join_host_ready`; `reserve()` GPU-byte flush; staging-slot claim; `dispatch()` / finish-abort `escalate()` (eager mode: the copy + pool write run inline) | `_state_lock` |
+| Async output builder | `materialize` (may overlap the next engine step) | this step's `step_d2h_event`; `join` (`done`); deferred `fetch_host` | `_state_lock` |
+| Committer | `_worker_loop`: wait device→host / deferred copy / pool write | `_wake.wait`; `step_d2h_event` or copy-stream sync | never takes `_state_lock` |
+| Prefetch pool | hit-span gather during forward | `join` (`done`); deferred `fetch_host` | `_state_lock` |
+
+| Lock | Covers | Does not cover |
+| --- | --- | --- |
+| manager `_state_lock` | occupancy tables, step contexts, hit spans, task registration, pool-key publish (`install_key`) | join, GPU-byte flush, copy, `step_d2h_event` wait, pool-key allocation, eager `dispatch()` / `escalate()` |
+| controller `_lock` / `_wake` | task registry, queues, GPU-clone byte budget | device→host / pool-write body (released before `synchronize`) |
+| `WriteTask.lock` | `state`, `reassigned`, `append_chunk` | waiting on `host_ready` / `done` (those are events) |
+
+### Related Files
+
+- `vllm_omni/core/prefix_cache/`
+- `vllm_omni/worker/gpu_model_runner.py` (`_ensure_omni_prefix_cache`)
+- `tests/core/test_prefix_cache.py`
+- [Async Omni Output Materialization](omni_async_output_materialization.md)
diff --git a/docs/design/fullduplex-personaplex.md b/docs/design/fullduplex-personaplex.md
index 33d125c97..6d32cd8e3 100644
--- a/docs/design/fullduplex-personaplex.md
+++ b/docs/design/fullduplex-personaplex.md
@@ -271,3 +271,111 @@ The required evidence is:
 
 Audio that is empty, all zero, non-finite, or only a protocol `listen` event is
 not a successful end-to-end result.
+
+### Paced multi-session load driver
+
+The existing driver keeps its two-session admission and slot-reuse validation
+when `--sessions` is omitted. Passing `--sessions N` selects a separate,
+bounded load mode; it does not replace the lifecycle test or change server
+admission capacity. Start an existing PersonaPlex server configured to admit
+the requested number of sessions, then run from a source checkout with the
+vLLM-Omni client dependencies installed:
+
+```bash
+python -m tests.e2e.online_serving.personaplex_realtime_duplex \
+  --model nvidia/personaplex-7b-v1 \
+  --input-wav /path/to/input.wav \
+  --sessions 2 --load-frames 1000 --drain-s 2 \
+  --server-revision SERVER_COMMIT --server-hardware A100-80GB \
+  --output-dir /tmp/personaplex-load-n2
+```
+
+Use a new output directory for every run. The driver refuses to overwrite an
+existing `load-result.json`. The server labels are supplied by the operator,
+not detected or verified by the client. Record the server command, package
+versions, checkpoint revision and hardware alongside a published measurement.
+
+All attempted sessions finish admission before admitted sessions share a
+common input start. A rejected session remains a failed row in the report;
+it is not removed from the denominator. Each session receives at most
+`--load-frames` input frames, without looping the WAV, and uses 80 ms pacing.
+A stalled send cannot cause a catch-up burst. The timeline records send
+schedule lateness so an overloaded client is visible rather than mistaken
+for a faster server. This mode measures steady concurrency, not join/leave
+interference; the original lifecycle mode still checks slot reuse.
+Load mode does not probe an additional N+1 session for `resource_exhausted`;
+the lifecycle mode owns that admission-limit check. A per-session
+`client_pacing_warning` and the summary's `client_pacing_warning_sessions`
+identify send-lateness p99 above one nominal frame (80 ms). This is a warning,
+not an extra acceptance gate: read it alongside server-facing measurements
+so a slow client is not mistaken for a slow server.
+
+The fixed drain window is part of the measurement configuration. Audio
+arriving during cleanup is excluded, so closing cannot rescue a session that
+missed its observation deadline. Cleanup is attempted for admitted sessions
+even when audio validation fails. Protocol errors, missing/invalid audio,
+shared response IDs and cleanup failures make the report fail and the CLI
+exit nonzero. Cancellation closes transports and propagates to the caller.
+`--cleanup-timeout-s` (default 5 s) bounds session-close send and acknowledgement
+together, independently of `--timeout-s`. The subsequent WebSocket close
+handshake has the same separate bound; an unresponsive close acknowledgement
+cannot hold cancellation for the full inference timeout.
+
+`load-result.json` retains per-session send and audio-packet timelines using
+the client's monotonic clock. It does not export handshake credentials or
+raw audio payloads. Metric definitions are explicit:
+
+Both modes validate each nonempty audio packet's strict base64 encoding, PCM16
+sample alignment, 24 kHz sample rate and response identity. Valid aggregate
+audio cannot hide a malformed packet. In load mode, rejected packets make the session fail
+and appear in `invalid_audio_packets` with their event index, receive time and
+fixed diagnostic code; they do not contribute samples or timing intervals.
+Empty audio deltas remain legal and contribute no samples. This check does
+not change the public client's decoding. The lifecycle scenario and dispatch
+remain the same, but malformed packets that aggregate checks once tolerated
+now fail that mode as well.
+
+The probe accepts both the current OpenAI Realtime audio event name
+`response.output_audio.delta` and the legacy `response.audio.delta`. Validation
+uses the wire payload directly rather than relying on a particular client
+library's alias table, so a server-side event-name migration cannot silently
+turn real audio into a zero-output measurement.
+
+| Field | Meaning |
+| --- | --- |
+| `client_audio_packet_interval_ms` | Consecutive nonempty packet arrivals: median, linear p99, max, and zero-based index of the first maximal interval. Interval index 0 ends at packet 1. One packet can contain multiple codec frames; this is not server tick latency. |
+| `client_first_audio_after_stream_start_ms` | First audio receipt minus first input send start; admission is excluded. |
+| `client_stream_rtf` | First input send start to last audio receipt, divided by received audio duration. This includes real-time input pacing and is not an inference-only RTF. |
+| `client_send_lateness_ms` | Send start minus its original shared schedule, clipped at zero. |
+| `frame_deficit` | Integer input-frame minus output-frame count from the shared session validation; missing when valid whole-frame accounting is unavailable. |
+| `output_frames`, `voiced_frames`, `silent_frames`, `frame_coverage_ratio`, `audio_rms`, `audio_chunks` | Session-validation statistics retained on success and on acceptance failure once computed. |
+| `acceptance_check` | Failed local check, with numeric diagnostics in `error`; other exceptions retain phase/type only, without remote handshake or metadata text. |
+| `audio_underrun_s`, `audio_underrun_event_count`, `audio_continuity_ok` | Shared `compute_continuity_stats` on valid PCM16 packet arrivals, with its default 100 ms underrun threshold; absent audio gives missing values rather than a continuity pass. |
+
+No output gives missing latency/RTF values, not zero. By default RTF is
+diagnostic; `--max-client-rtf` adds an explicit ceiling. The existing frame
+coverage, audible-frame and scheduler-data-plane checks still apply. A longer
+`--drain-s` can demonstrate eventual completion under backlog, but it must not
+be reported as real-time capacity when the fixed-window run failed or client
+RTF exceeded the stated target. Likewise, the first live session can pay
+one-time model/codec/JIT costs; either use the server's configured duplex
+warmup path or label that run as cold-start evidence before comparing steady
+capacity. Passing client-only metrics does not certify model quality or a
+real-time capacity target on another GPU. Begin with N=1 and N=2; higher N is a
+capacity experiment, not a promised property of an A100 or of this patch.
+Continuity is a client-arrival diagnostic, not proof of speaker playback and
+not an additional pass/fail gate. Packet-interval and send-lateness summaries
+retain their documented linear p99; the older client interval helper reports
+rounded nearest-rank p95 instead and is not substituted for that schema.
+
+Deterministic driver and localhost WebSocket checks need no model or GPU:
+
+```bash
+python -m pytest tests/e2e/online_serving/test_personaplex_load_driver.py \
+  -m 'core_model and cpu' --run-level core_model -q
+```
+
+These checks test the driver against controlled protocol responses. Run the
+load-driver command against real weights separately before reporting model-serving
+performance. Server tick timestamps and generic TTFT/TPOT aggregation remain
+the responsibility of the existing duplex metrics paths, not this driver.
diff --git a/docs/design/fullduplex.md b/docs/design/fullduplex.md
index 4646b85cd..324cd5bdc 100644
--- a/docs/design/fullduplex.md
+++ b/docs/design/fullduplex.md
@@ -9,6 +9,12 @@ the owner document for `vllm_omni/engine/duplex/**`,
 `vllm_omni/entrypoints/duplex_omni.py`, `vllm_omni/entrypoints/duplex/**`,
 `vllm_omni/clients/**` and the per-model `duplex/` packages.
 
+`vllm_omni/protocol/realtime/**` (the OpenAI Realtime API) and
+`vllm_omni/protocol/duplex/**` (vLLM-Omni's extension of it) are the shared
+wire codec duplex is built on. Duplex is its first consumer but not its owner: the codec
+is deliberately runtime-agnostic so a second Realtime surface can reuse it
+(RFC #6592 P0a).
+
 The public wire contract lives in
 [`docs/serving/realtime_duplex_api.md`](../serving/realtime_duplex_api.md);
 this page describes how it is produced.
@@ -108,23 +114,56 @@ plugin and the session runtime config to `DuplexOrchestrator` directly.
    `AsyncOmniEngine`, `OrchestratorBase` and `Orchestrator` carry only
    template seams; `tests/engine/test_duplex_import_boundary.py` checks that
    importing the turn-based stack loads no duplex module.
-4. **Every surface a duplex server exposes is backed by a session.**
+4. **Deployment selects the serving stack.**
    `vllm-omni serve` constructs `DuplexOmni` when the pipeline declares
-   `duplex_plugin`; the server exposes `/v1/realtime?duplex=1` (alias
+   `duplex_plugin` and the deploy configuration sets `session_mode: duplex`.
+   An explicit `session_mode: turn` selects `AsyncOmni` instead, without
+   changing the pipeline's duplex capability. In duplex mode the server exposes `/v1/realtime?duplex=1` (alias
    `/v1/duplex`), `POST /v1/chat/completions`, `/v1/models` and `/health`, and
-   every other turn-based route reports "not available". The chat route is
-   served by `DuplexChatCompletionsAdapter`, a Realtime client that runs one
-   short-lived session per request: speech becomes a committed turn, text is
-   seeded as the session's opening turn because a model-native model takes a
-   turn only when it hears speech. Whether a model can be reached with text is
-   `DuplexCapabilities.supports_chat_completions`; one that cannot is refused
-   at once rather than left to idle out. Turn-based use of the same model stays
-   available offline through `Omni` / `AsyncOmni`.
+   every other turn-based route reports "not available". The chat route uses
+   the ordinary chat service on the duplex engine, without a session, when
+   the plugin declares `DuplexCapabilities.supports_chat_completions`.
+   Turn-based deployments use the ordinary API initialization and retain
+   model capability checks and endpoint restrictions.
 5. **Serving is transport only.** The websocket handler does socket I/O,
    wire-envelope validation, command translation, event rendering and the
    attachment/resume/replay bookkeeping; it holds no session state.
 6. **No `typing.Protocol`** in the duplex surfaces: the plugin, data plane,
    session state, PCM buffer, stage port and client transport seams are ABCs.
+7. **The wire codec is not duplex, and a wire type is not a mailbox message.**
+   The event and command *vocabulary* plus its wire rendering, the audio format
+   negotiation, the conversation-item rules and the error envelope are model-
+   and runtime-agnostic, and split along the three tiers
+   [`docs/serving/realtime_duplex_api.md`](../serving/realtime_duplex_api.md)
+   already defines: **Tier 1** (identical to OpenAI) is
+   `vllm_omni/protocol/realtime/**`; **Tier 2** (OpenAI names carrying our
+   extensions) and **Tier 3** (ours alone) are `vllm_omni/protocol/duplex/**`.
+   A Tier 2 class *subclasses* its Tier 1 twin and declares only what it adds,
+   so the OpenAI surface stays honestly pure --- `session.created` without
+   `resume_token`, `input_audio_buffer.append` without `video_frames`. Our
+   error **codes** are Tier 3 (`protocol/duplex/errors.py`); only the envelope
+   shape and OpenAI's three `error.type` classes are Tier 1.
+   What stays engine-side is everything that is *internal representation*
+   rather than contract: `DuplexCommand.payload()` renders the session runner's
+   mailbox dictionary, whose channel genuinely differs from the client event
+   (`session.update` and the three `conversation.item.*` commands all travel on
+   `turn.signal`); `engine/duplex/realtime_commands.py` decides which command a
+   decoded event becomes; `engine/duplex/realtime_events.py` holds the
+   session's projection state. The codec may not import the engine, the
+   entrypoints, `model_executor` or the clients
+   (`tests/protocol/realtime/test_protocol_import_boundary.py`), and there is
+   exactly one implementation of each codec behaviour
+   (`tests/protocol/realtime/test_realtime_codec_single_source.py`).
+   The dependency chain is `protocol/realtime` <- `protocol/duplex` <- engine /
+   entrypoints / clients, and a duplex consumer uses **only** the middle link:
+   `protocol/duplex/**` re-exports the Tier 1 names it does not extend, so a
+   helper that later needs a duplex-specific version (`convert_input_audio_with_rate`
+   resamples to MiniCPM-o's 16 kHz rather than the client's rate) is overridden
+   in one file instead of at every call site
+   (`tests/protocol/duplex/test_duplex_protocol_facade.py`).
+   `DuplexEvent` is therefore a plain alias of `RealtimeEvent` --- an event has
+   no engine-internal half --- while `DuplexCommand` is a real class, because a
+   command does.
 
 ## Package layout
 
@@ -143,6 +182,31 @@ vllm_omni/
 │   │   ├── chat_completions.py      DuplexChatCompletionsAdapter (/v1/chat/completions on a session per request)
 │   │   └── websocket.py             websocket send/close/receive helpers
 │   └── openai/api_server.py         builds DuplexOmni for duplex models; session-backed app state
+├── protocol/                        SHARED WIRE CODEC (no engine / no model / no transport)
+│   ├── realtime/                    the OpenAI Realtime API itself
+│   │   ├── events.py                RealtimeEvent + OpenAI's 30 server events (22 ship as Tier 1;
+│   │   │                            8 have a Tier 2 twin in protocol/duplex)
+│   │   ├── commands.py              RealtimeCommand + OpenAI's 10 client commands (8 Tier 1,
+│   │   │                            2 with a Tier 2 twin) --- wire_type + fields, no payload()
+│   │   ├── formats.py               audio format spellings, what is supported, per-session validation
+│   │   ├── session.py               session-object readers; RealtimeInputDefaults (append defaults)
+│   │   ├── items.py                 conversation item shape, truncation, transcripts, camera frames
+│   │   ├── audio_input.py           decode_audio_append -> RealtimeAudioAppend; client speech hints
+│   │   ├── audio.py                 PCM / G.711 / WAV decode, resample, re-encode
+│   │   ├── errors.py                RealtimeProtocolError (the envelope's exception type)
+│   │   └── capabilities.py          RealtimeProtocolCapabilities: what one consumer can serve
+│   └── duplex/                      Tier 2 + Tier 3, and the one door a duplex consumer uses
+│       ├── __init__.py              re-exports the Tier 1 helper functions (audio, formats,
+│       │                            items, session, capabilities) so the engine never
+│       │                            imports protocol/realtime directly
+│       ├── events.py                the whole 42-event vocabulary: 22 Tier-1 re-exports,
+│       │                            8 Tier-2 subclasses (session.created + resume_token, ...),
+│       │                            12 Tier-3 events (listen/speak, playback, resume, ...);
+│       │                            DuplexEvent = RealtimeEvent
+│       ├── commands.py              the whole 17-command vocabulary: 8 Tier-1 re-exports,
+│       │                            2 Tier-2 subclasses (append + hints, commit + final),
+│       │                            7 Tier-3 commands (barge_in, playback.ack, ...)
+│       └── errors.py                our error-code vocabulary (Tier 3) + RealtimeProtocolError
 ├── engine/
 │   ├── omni_engine_base.py          OmniEngineBase (stage processes, orchestrator thread, queues, RPC)
 │   ├── async_omni_engine.py         AsyncOmniEngine (turn-based request building)
@@ -150,16 +214,20 @@ vllm_omni/
 │   ├── orchestrator.py              OrchestratorBase + Orchestrator
 │   ├── duplex_orchestrator.py       DuplexOrchestrator (+ DuplexOrchestratorRequestState; implements DuplexStagePort)
 │   └── duplex/
-│       ├── commands.py              DuplexCommand dataclasses, command_from_realtime
-│       ├── realtime_commands.py     Realtime client event -> DuplexCommand translation
-│       ├── events.py                DuplexEvent dataclasses (+ to_realtime), REALTIME_ERROR_TYPES_BY_CODE
+│       ├── commands.py              mailbox half: DuplexCommand.payload() + the mailbox `type`,
+│       │                            paired with each protocol command; command_from_realtime
+│       ├── realtime_commands.py     duplex binding of the codec: decoded event -> DuplexCommand,
+│       │                            DUPLEX_REALTIME_CAPABILITIES, duplex_response_format
+│       ├── events.py                re-export shim (DuplexEvent = RealtimeEvent) + the runner's
+│       │                            epoch-filter sets DOMAIN_TERMINAL_EVENTS / MODEL_OUTPUT_EVENTS
 │       ├── realtime_events.py       RealtimeProjectionState: internal event -> typed events
 │       ├── messages.py              queue envelopes (Open/Close/Resume/Touch/Command/Result/Event), DuplexSessionError
 │       ├── config.py                DuplexSessionConfig, DuplexCapabilities, ResponseCreateOptions
 │       ├── contracts.py             DuplexFence (session_id, epoch, turn_id), stage request records, DuplexStagePort
 │       ├── plugin.py                DuplexModelPlugin, DuplexModelSessionState, DuplexDataPlane, PcmAppendBuffer ABCs
 │       ├── turn_detection.py        server-side VAD turn detector used by the session
-│       ├── audio.py / vad.py / intermediate.py
+│       ├── audio.py                 compatibility re-export, via protocol/duplex
+│       ├── vad.py / intermediate.py
 │       └── session/                 one engine-resident session and everything that runs it
 │           ├── engine_session.py    DuplexEngineSession: ledgers, lease, fence, stage resources, append sequencing
 │           ├── runner.py            DuplexSessionRunner (per-session mailbox on the orchestrator loop)
diff --git a/docs/design/module/entrypoints.md b/docs/design/module/entrypoints.md
index db62f9cb6..0c0ba8439 100644
--- a/docs/design/module/entrypoints.md
+++ b/docs/design/module/entrypoints.md
@@ -30,6 +30,7 @@ primary_code_paths:
   - vllm_omni/entrypoints/utils.py
   - vllm_omni/entrypoints/duplex/**
   - vllm_omni/clients/**
+  - vllm_omni/protocol/**
 primary_path_exceptions:
   - path: vllm_omni/entrypoints/openai/errors.py
     owner: error_contracts.md
@@ -53,6 +54,7 @@ depends_on:
   - error_contracts.md
   - engine_orchestration.md
 validation_paths:
+  - tests/protocol/**
   - tests/entrypoints/test_omni_entrypoints.py
   - tests/entrypoints/test_async_omni.py
   - tests/entrypoints/test_async_omni_pause_sleep_routing.py
@@ -94,11 +96,43 @@ This document owns offline API semantics, CLI and serve composition,
 supported OpenAI-compatible routes, request validation and normalization,
 response conversion, streaming/session behavior, and engine handoff.
 
+When `--api-server-count` is greater than one, the serve composition root
+starts the frontend process manager while a parent-owned `StageRuntime`
+launches the shared local stage engines. Each frontend receives only its own
+stage-client channel configuration and does not launch or retire backend
+processes. CLI validation rejects unsupported distributed, diffusion,
+fault-tolerant, elastic-EP, Ray, and runtime-LoRA combinations before startup.
+
 It does not own configuration precedence, cross-stage routing, stage
 placement, payload implementation, or semantic error classification.
 `entrypoints/openai/errors.py` is an explicit primary-path exception owned by
 `error_contracts.md`.
 
+It also owns `vllm_omni/protocol/**`, the shared wire codec promoted by RFC
+[#6592](https://github.com/vllm-project/vllm-omni/issues/6592) P0a. It follows the three tiers
+`docs/serving/realtime_duplex_api.md` already defines. `protocol/realtime/**`
+is Tier 1, identical to OpenAI: 30 server events, 10 client commands, their
+typed fields and pure wire rendering, audio-format negotiation,
+conversation-item rules and the error-envelope shape. `protocol/duplex/**` is
+Tier 2 (OpenAI names carrying vLLM-Omni extensions, each a subclass of its
+Tier 1 twin declaring only what it adds) and Tier 3 (ours alone, including our
+error-code vocabulary), kept separate so a GA-only consumer is not handed a
+vocabulary its clients never send. That package sits
+outside `entrypoints/` on purpose --- the engine depends on it, so it belongs
+to neither layer --- but deciding what a Realtime client may put on the wire is
+this document's subject, and the same reasoning already places
+`vllm_omni/errors.py`, `inputs/` and `outputs/` under contract documents rather
+than under a consumer.
+
+It is deliberately **not** owned by `../fullduplex.md`, even though duplex is
+the codec's only consumer today. RFC #6592 asks for a named owner precisely so
+a second Realtime consumer does not need duplex review to change the codec
+(#6592 open question 8). Ownership here is review scope, not a dependency: the
+codec may not import the engine, the entrypoints or the model code, which
+`tests/protocol/realtime/test_protocol_import_boundary.py` enforces. When a
+second consumer lands (#6592 P0b) the package is expected to graduate to its
+own module document with owners drawn from both consumers.
+
 ## Candidate invariants
 
 These identifiers are proposals while the document is `draft`.
@@ -108,6 +142,22 @@ These identifiers are proposals while the document is `draft`.
 **Rule:** Entrypoints MUST NOT implement cross-stage routing or stage lifecycle
 policy.
 
+### ENTRY-INV-002: The shared Realtime codec does not depend on its consumers
+
+**Rule:** `vllm_omni/protocol/**` MUST NOT import `vllm_omni.engine`,
+`vllm_omni.entrypoints`, `vllm_omni.model_executor`, `vllm_omni.worker` or
+`vllm_omni.clients`; `protocol/duplex/**` MAY depend on `protocol/realtime/**`
+but never the reverse, and a Tier 1 class MUST NOT carry a vLLM-Omni extension
+field; and each protocol/codec behavior MUST have exactly one
+implementation that every consumer uses. A wire type MUST NOT carry a
+consumer's internal representation: the duplex mailbox rendering
+(`DuplexCommand.payload()`, whose channel differs from the client event for
+`session.update` and the `conversation.item.*` commands) stays engine-side.
+A duplex consumer (`engine/duplex/**`, `entrypoints/duplex/**`, the duplex
+clients) MUST import `vllm_omni.protocol.duplex` and MUST NOT import
+`vllm_omni.protocol.realtime` directly, so the tier boundary has exactly one
+extension point.
+
 ### ENTRY-INV-100: Public requests are normalized once
 
 **Rule:** Public protocol values MUST be validated and converted to internal
@@ -141,6 +191,9 @@ stage so `wake_up(stage_ids=[0])` does not skip a later `wake_up(stage_ids=[1])`
 Streaming input pumps take an admission slot immediately before each EngineCore
 ADD or update, not while waiting for the next client chunk. Frontend abort
 keeps `request_states` until `generate()` consumes the terminal output.
+Multi-API serving must preserve one client rank and one channel set per
+frontend, include every frontend in readiness/failure observation, and keep
+stage lifecycle ownership in the parent composition root.
 
 ## Promotion gate
 
diff --git a/docs/design/module/stage_runtime.md b/docs/design/module/stage_runtime.md
index aefba5a40..38255880f 100644
--- a/docs/design/module/stage_runtime.md
+++ b/docs/design/module/stage_runtime.md
@@ -77,6 +77,22 @@ readiness, one pool per logical stage, replica identity and membership,
 selection and affinity, stage-client/process lifecycle, liveness, draining,
 and shutdown.
 
+Local EngineCore initialization and multi-API serving use
+`StageRuntime.launch_stage_engines(num_api_servers=1)` as their common launch
+entry. It resolves plans when not supplied by the runtime's device-group
+scheduler, coordinates device locks and environment overlays, starts engines,
+and rolls back resources on startup or attachment failure. Single-API clients
+attach locally after readiness and take ownership of the engine resources;
+there is no additional API subprocess. Diffusion and remote attachment retain
+their backend-specific initialization.
+
+For local multi-API serving, the parent runtime owns and launches each stage
+engine once. It supplies a distinct input/output channel for every API
+frontend and stage replica; frontend workers attach clients to those engines
+without acquiring stage-process ownership. Readiness observation and shutdown
+remain parent-owned. This topology currently excludes diffusion and
+remote/headless stages, intra-stage data parallelism, and Ray backends.
+
 It does not own cross-stage request policy, model scheduler policy, connector
 transfer semantics, configuration precedence, or public error rendering.
 
@@ -114,6 +130,10 @@ affinity, membership changes, abort routing, process failure, draining, and
 repeated shutdown. Cross-stage policy changes belong in
 `engine_orchestration.md`.
 
+For multi-API changes, additionally exercise per-frontend channel assignment,
+shared-engine startup handshakes, frontend failure observation, and parent
+cleanup without duplicate stage shutdown.
+
 ## Promotion gate
 
 - Reconcile terminology and ownership after #5441 reaches a final state.
diff --git a/docs/features/comfyui.md b/docs/features/comfyui.md
index 876e80617..dda68b793 100644
--- a/docs/features/comfyui.md
+++ b/docs/features/comfyui.md
@@ -51,6 +51,7 @@ This extension offers the following nodes based on the output modalities:
 - **Generate Video** for text-to-video and image-to-video tasks
 - **Multimodality Understanding** for multimodality-to-text and multimodality-to-audio tasks
 - **TTS** and **TTS Voice Clone** for TTS tasks
+- **Generate Music** for text-to-music tasks
 
 This extension also offers example workflows (at **ComfyUI sidebar -> Templates -> vLLM-Omni**)
 
diff --git a/docs/features/custom_pipeline.md b/docs/features/custom_pipeline.md
index 887dfa769..463798d6d 100644
--- a/docs/features/custom_pipeline.md
+++ b/docs/features/custom_pipeline.md
@@ -1,7 +1,7 @@
 # Custom Pipeline Extension Guide
 
 Transformer already support Custom Pipeline via
-https://github.com/huggingface/diffusers/blob/main/docs/source/en/using-diffusers/custom_pipeline_overview.md
+<https://github.com/huggingface/diffusers/blob/main/docs/source/en/using-diffusers/custom_pipeline_overview.md>
 
 This guide demonstrates how to use the newly added features for extending vLLM-Omni's diffusion pipeline with custom functionality.
 
@@ -20,8 +20,9 @@ Three main features enable custom pipeline extension:
 `WorkerWrapperBase` is a wrapper class that creates `DiffusionWorker` instances with optional extension support. It enables dynamic inheritance, allowing you to add custom methods and functionality to workers without modifying the base worker class.
 
 **Key capabilities:**
+
 - Dynamic worker class extension via `worker_extension_cls`
-- Support for custom pipeline initialization via `custom_pipeline_args`
+- Support for custom pipeline initialization via `custom_pipeline_args["pipeline_class"]`
 - Method delegation to underlying worker
 - Attribute access forwarding
 
@@ -42,6 +43,7 @@ The `diffusion_load_format` parameter controls the initial diffusion model load.
 `CustomPipelineWorkerExtension` is a mixin class that extends `DiffusionWorker` with the ability to re-initialize the pipeline with a custom implementation.
 
 **Key method:**
+
 - `re_init_pipeline(custom_pipeline_args)`: Re-initializes the pipeline with custom arguments, properly cleaning up the old pipeline first
 
 **Location:** `vllm_omni/diffusion/worker/diffusion_worker.py`
@@ -150,6 +152,7 @@ omni = Omni(
     },
     worker_extension_cls=MyCustomExtension,
     # Note: worker_extension_cls is an internal parameter
-    # CustomPipelineWorkerExtension will automatically init pipeline when custom_pipeline_args is provided
+    # CustomPipelineWorkerExtension will automatically init pipeline when
+    # custom_pipeline_args includes "pipeline_class".
 )
 ```
diff --git a/docs/models/supported_models.md b/docs/models/supported_models.md
index 42971ed97..1f543a6d2 100644
--- a/docs/models/supported_models.md
+++ b/docs/models/supported_models.md
@@ -58,6 +58,7 @@ th {
 | `Magi2Pipeline` | MAGI-2 native Preview-stage T2VA and I2VA (272p/540p) | `sand-ai/MAGI-2-preview` | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/SandAI/MAGI-2-preview-L20X.md) |
 | `DreamZeroPipeline` | DreamZero-DROID | `GEAR-Dreams/DreamZero-DROID` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
 | `Pi0Pipeline` | π0 (Pi-Zero) VLA | `lerobot/pi0_base` | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/lerobot/Pi0.md) |
+| `Pi05Pipeline` | π0.5 VLA | `lerobot/pi05_base` | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/lerobot/Pi05.md) |
 | `HeliosPipeline`, `HeliosPyramidPipeline` | Helios | `BestWishYsh/Helios-Base`, `BestWishYsh/Helios-Mid`, `BestWishYsh/Helios-Distilled` | ✅︎ | ✅︎ | ✅︎ | | — |
 | `OvisImagePipeline` | Ovis-Image | `OvisAI/Ovis-Image` | ✅︎ | ✅︎ | | ✅︎ | — |
 | `LongcatImagePipeline` | LongCat-Image | `meituan-longcat/LongCat-Image` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
@@ -72,7 +73,6 @@ th {
 | `OmniVoiceModel` | OmniVoice | `k2-fsa/OmniVoice` | ✅︎ | | | ✅︎ | — |
 | `VoxCPM2TalkerForConditionalGeneration` | VoxCPM2 | `openbmb/VoxCPM2` | ✅︎ | | | ✅︎ | — |
 | `BreezeForConditionalGeneration` | Breeze-TTS-2 (TTS, voice clone, voice direction) | `BreezeBlue/Breeze-TTS-2` | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/BreezeBlue/Breeze-TTS-2.md) |
-| `DotsTTSForConditionalGeneration` | dots.tts | `dots-studio/dots.tts-soar` | ✅︎ | | | | — |
 | `MammothModa2ForConditionalGeneration` | MammothModa2-Preview | `bytedance-research/MammothModa2-Preview` | ✅︎ | ✅︎ | | | — |
 | `MammothModa2ForConditionalGeneration` | MammothModa2-Dev (AR-only image understanding) | `bytedance-research/MammothModa2-Dev` | ✅︎ | | | | — |
 | `Flux2KleinPipeline` | FLUX.2-klein | `black-forest-labs/FLUX.2-klein-4B`, `black-forest-labs/FLUX.2-klein-9B` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
@@ -106,12 +106,12 @@ th {
 | `HunyuanVideo15ImageToVideoPipeline` | HunyuanVideo-1.5-I2V | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_i2v`, `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-720p_i2v` | ✅︎ | ✅︎ | | | — |
 | `VoxtralTTSForConditionalGeneration` | Voxtral TTS | `mistralai/Voxtral-4B-TTS-2603` | ✅︎ | ✅︎ | | | — |
 | `CovoAudioForConditionalGeneration` | Covo-Audio-Chat | `tencent/Covo-Audio-Chat` | ✅︎ | | | | — |
-| `DyninOmniForConditionalGeneration` | Dynin-Omni | `snu-aidas/Dynin-Omni` | ✅︎ | | | ✅︎ | — |
 | `MiniCPMO45OmniForConditionalGeneration` | MiniCPM-o 4.5 | `openbmb/MiniCPM-o-4_5` | ✅︎ | | ✅︎ | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/OpenBMB/MiniCPM-o-4_5.md) |
 | `ErnieImagePipeline` | ERNIE-Image | `baidu/ERNIE-Image`, `baidu/ERNIE-Image-Turbo` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
 | `GepardTalkerForConditionalGeneration` | Gepard-1.0 | `nineninesix/gepard-1.0` | ✅︎ | | | ✅︎ | — |
 | `HiDreamImagePipeline` | HiDream-I1-Full | `HiDream-ai/HiDream-I1-Full` | ✅︎ | ✅︎ | | | — |
 | `HiDreamO1ImagePipeline` | HiDream-O1-Image | `HiDream-ai/HiDream-O1-Image` | ✅︎ | | | | — |
+| `AnimaPipeline` | Anima | `circlestone-labs/Anima` | ✅︎ | ✅︎ | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/circlestone-labs/Anima.md) |
 
 The `Recipe` column links the corresponding deployment recipe. `Published` is
 preferred when a corresponding `recipes.vllm.ai` page exists; otherwise the
diff --git a/docs/serving/full_duplex_api.md b/docs/serving/full_duplex_api.md
index 92511e84f..9b3eceb58 100644
--- a/docs/serving/full_duplex_api.md
+++ b/docs/serving/full_duplex_api.md
@@ -22,14 +22,14 @@ capability gates, see the [Realtime Duplex API guide](realtime_duplex_api.md).
 ## Enable Full Duplex
 
 A model is served full duplex when its registered pipeline declares a
-`duplex_plugin` (the model's `DuplexModelPlugin`). That declaration alone
-decides it: `vllm-omni serve` constructs `DuplexOmni` instead of `AsyncOmni`,
-and every surface the server exposes is backed by a duplex session. It serves
+`duplex_plugin` (the model's `DuplexModelPlugin`) and its deploy configuration
+sets `session_mode: duplex`. `vllm serve --omni` constructs `DuplexOmni`
+instead of `AsyncOmni`. It serves
 `/v1/realtime?duplex=1` (and its alias `/v1/duplex`),
 `POST /v1/chat/completions`, `/v1/models` and `/health`; every other
 turn-based HTTP route (speech, batch, embeddings, video, ...) answers "not
-available". Turn-based use of such a model stays available offline through the
-Python API (`Omni` / `AsyncOmni`).
+available". Set `session_mode: turn` to select the ordinary online serving
+stack instead. The model's supported tasks and endpoint restrictions still apply.
 
 `/v1/chat/completions` is the ordinary chat service running on the duplex
 engine: a request is a turn-based generation on the same stages, served
@@ -45,8 +45,24 @@ The deploy configuration of such a model must agree:
 session_mode: duplex
 ```
 
-A duplex model started with a deploy configuration that does not set it fails
-at startup rather than falling back to turn-based serving.
+A duplex-capable model must explicitly set `session_mode` to `duplex` or `turn`
+in its deploy configuration, possibly through `base_config` inheritance.
+Missing or invalid values fail at startup. The default MiniCPM-o deployment
+continues to use duplex mode.
+
+To run MiniCPM-o 4.5 with the turn-based engine:
+
+```bash
+vllm serve openbmb/MiniCPM-o-4_5 --omni \
+  --deploy-config vllm_omni/deploy/minicpmo_4_5_turn.yaml \
+  --trust-remote-code \
+  --port 8091
+```
+
+This profile inherits the default model and stage settings and overrides only
+`session_mode`. It supports ordinary HTTP requests without creating a duplex
+session handler. Mode selection happens at startup; a WebSocket query parameter
+does not switch engines. The Python `Omni` / `AsyncOmni` APIs are unchanged.
 
 !!! warning
 
diff --git a/docs/serving/realtime_duplex_api.md b/docs/serving/realtime_duplex_api.md
index cc10d99c9..cd8832c82 100644
--- a/docs/serving/realtime_duplex_api.md
+++ b/docs/serving/realtime_duplex_api.md
@@ -8,12 +8,41 @@ history stays honest, and a dropped connection can resume the same session.
 This page covers how to run a duplex deployment, how to drive it from Python
 with `vllm_omni.clients.duplex.DuplexClient`, and the complete wire contract.
 
-The endpoint is served for models that ship a duplex plugin — currently
-MiniCPM-o 4.5 only — and just for deploy configurations that declare
+The endpoint is served for models that ship a duplex plugin — including
+MiniCPM-o 4.5 and Qwen3-Omni — and just for deploy configurations that declare
 `session_mode: duplex`. PersonaPlex and Nemotron VoiceChat are ported to the
 plugin contract in follow-up PRs and are not served over this endpoint yet. The runtime architecture
 is described in [Full-Duplex Runtime (MiniCPM-o 4.5)](../design/fullduplex.md).
 
+## Qwen3-Omni conversation history
+
+Qwen3-Omni keeps incoming conversation items independently addressable by item
+ID. Before applying the model's chat template, it merges consecutive user
+items into one multimodal user message. An assistant message, including an
+empty message reserved for an interrupted or unheard answer, separates turns.
+The final user message places media before text instructions, following the
+[official Qwen3-Omni demo's `format_history()`](https://github.com/QwenLM/Qwen3-Omni/blob/e4235853125589c789f06a2dd83e9f4126df5e9d/web_demo.py#L84-L179).
+
+A camera image or text item may arrive after an audio commit and before
+`response.create`. Those items belong to the same pending user turn: the
+committed audio remains associated with its history item even when that item
+is no longer last. Prompt preparation snapshots the selected inputs; later
+items do not modify an already prepared request.
+
+The duplex adapter retains its existing budgets: at most four audio payloads
+(including the current input), an 8 MiB encoded-audio history budget (keeping
+at least the newest payload), and at most eight prompt images. The recent
+16-message window is rounded outwards to a complete turn. If any audio in an
+older turn is no longer retained, the entire turn's model context, including
+its images/text and assistant replies, is omitted. Images from that turn are
+therefore **not** permanent session-wide model context. These limits differ
+from the demo's one image-bearing turn and five audio-bearing turns; the
+shared rule is grouping before pruning, rather than copying its UI budgets.
+
+Grouping and pruning affect only the model-input view. They do not merge or
+delete the source conversation items exposed to clients, and do not change
+playback acknowledgement or interruption handling.
+
 ## Quick Start
 
 ### Start the Server
@@ -32,33 +61,19 @@ vllm-omni serve openbmb/MiniCPM-o-4_5 \
 mounts `ws://<host>:8099/v1/realtime?duplex=1` (this page; `ws://<host>:8099/v1/duplex`
 is an alias of the same route), `POST /v1/chat/completions`, `/v1/models` and
 `/health`, and nothing else. The remaining turn-based HTTP routes (speech,
-batch, embeddings, video, ...) are not served by a duplex model.
+batch, embeddings, video, ...) are not served in duplex mode.
 
-`/v1/chat/completions` is not a turn-based path on a duplex server: each
-request opens a short-lived duplex session and reads the answer off it. Audio
-content becomes an ordinary committed turn; text is seeded as the session's
-opening turn, because a model-native model takes a turn only when it hears
-speech. A model that cannot be seeded that way declares so, and a text request
-to it is refused with 400. Two consequences are worth sizing for:
+`/v1/chat/completions` uses the ordinary chat service on the same engine
+when the plugin declares `supports_chat_completions`. HTTP chat requests do
+not create duplex sessions or consume session admission slots. Their options
+follow the [Chat Completions API](chat_completions_api.md) and the model's
+capabilities and endpoint restrictions.
 
-- **Every request holds an admission slot** for its lifetime, so
-  `duplex_session.max_sessions` caps HTTP concurrency as well as websocket
-  sessions. Beyond it a request is refused with HTTP 503.
-- **Latency follows the model's own clock.** A model-native session generates
-  per audio unit, so even a short answer costs what that many units cost --
-  noticeably more than the same model would take turn-based.
-
-`n > 1`, `logprobs`, `tools`, and image or video content parts have no
-representation in one duplex turn and are refused with HTTP 400 -- a Realtime
-conversation item carries text and audio only. `temperature`,
-`max_completion_tokens`, `modalities` and
-`chat_template_kwargs.use_tts_template` apply; the other
-`chat_template_kwargs` keys are logged as ignored. `extra_body` is passed to
-the session unchanged, exactly as a websocket client's session `extra_body`
-is, which is how a request asking for `modalities: ["text", "audio"]` supplies
-the `ref_audio` MiniCPM-o requires for audio output. A model that should not
-serve the route lists it in the deploy config's `endpoint_restrictions`,
-exactly as a turn-based model does.
+For a turn-based online deployment, use `minicpmo_4_5_turn.yaml` or explicitly
+set `session_mode: turn` in a deploy configuration derived from the model's
+profile. This selects `AsyncOmni` and the ordinary API initialization instead
+of the duplex handler. See [Full Duplex](full_duplex_api.md#enable-full-duplex)
+for the command and configuration requirements.
 
 ### Run the Example Client
 
@@ -782,7 +797,10 @@ events with `server_event_seq > 40` are replayed in order)
 ```
 
 with camera frames (omni video; rides the append that closes a 1 s model
-unit; each entry is a **bare** base64 JPEG/PNG — no `data:` URL prefix)
+unit; each entry is a **bare** base64 JPEG/PNG — no `data:` URL prefix).
+Only a model whose Stage 0 interleaves a frame track at unit boundaries takes
+this field; a turn model has no such boundary and rejects it, expecting
+`conversation.item.create` with `input_image` content instead.
 
 ```json
 {
@@ -959,6 +977,10 @@ deferred commit during an active response (`event.response_create_deferred`)
 {"type": "conversation.item.truncated", "item_id": "item_resp_01", "content_index": 0, "audio_end_ms": 1850, "event": {"…": "…"}}
 ```
 
+After this acknowledgement, `conversation.item.retrieve` returns the truncated
+transcript. Without text/audio alignment marks, its prefix is estimated from
+the requested position and audio duration; this is not exact word alignment.
+
 #### Response lifecycle
 
 `C→S response.create`
@@ -1345,8 +1367,9 @@ them out into typed events before they reach a client.
 - Session capacity is bounded by `duplex_session.max_sessions` in the deploy
   configuration; admission beyond it fails with `resource_exhausted`
   (`rate_limit_error`, retryable).
-- A duplex deployment serves the duplex session surfaces only: the websocket
-  route and `/v1/chat/completions`, the latter on a session per request (see
-  [Start the Server](#start-the-server)). The other turn-based HTTP routes
-  report "not available" on a MiniCPM-o 4.5 server; turn-based use of the
-  model stays available offline through `Omni` / `AsyncOmni`.
+- A duplex deployment serves the websocket route and, when supported by the
+  model, ordinary `/v1/chat/completions` requests on the same engine without a
+  session per request (see [Start the Server](#start-the-server)). Other
+  turn-based HTTP routes report "not available" in duplex mode. To use the
+  ordinary online serving stack, select `session_mode: turn` as described in
+  [Full Duplex](full_duplex_api.md#enable-full-duplex).
diff --git a/docs/serving/speech_api.md b/docs/serving/speech_api.md
index 5f63739f6..c07d9eabf 100644
--- a/docs/serving/speech_api.md
+++ b/docs/serving/speech_api.md
@@ -521,6 +521,15 @@ are cached in-process with a shared LRU so repeated requests with the same
 all TTS model types; deleting a voice invalidates every model-type slot at
 once.
 
+Decoded reference waveforms use a separate LRU cache of owned, contiguous
+float32 arrays at the source sampling rate. Its byte budget counts numeric
+buffers (four bytes per mono sample), excluding cache metadata. Numeric storage
+avoids retaining a Python float object for every sample during garbage
+collection. MOSS reference encoding consumes these arrays directly; other
+list-based interfaces, including MOSS Nano, receive temporary lists that are
+not retained in the resolve cache. The MOSS reference encoder also releases
+completed batch inputs before waiting for more work.
+
 ### Precomputed Custom Voices
 
 Qwen3-TTS Base and VoxCPM2 can load offline-precomputed voices at startup.
diff --git a/docs/serving/streaming_video_output_api.md b/docs/serving/streaming_video_output_api.md
index d01489540..b219ee019 100644
--- a/docs/serving/streaming_video_output_api.md
+++ b/docs/serving/streaming_video_output_api.md
@@ -41,7 +41,7 @@ bytes.
 | Server to client | `video.start` | Confirms the request ID, format, and accepted configuration |
 | Server to client | `video.chunk_metadata` | Describes the next binary media frame |
 | Server to client | Binary frame | Carries one fragmented MP4 chunk |
-| Client to server | `session.interaction` | Queues an optional prompt update during generation |
+| Client to server | `session.interaction` | Queues an optional interaction (e.g., prompt. camera action) during generation |
 | Server to client | `session.interaction.queued` | Confirms that an interaction was queued |
 | Client to server | `session.ping` | Refreshes the stall clock |
 | Server to client | `session.pong` | Acknowledges a ping |
@@ -83,10 +83,39 @@ Models that implement interaction updates can change the active prompt:
 }
 ```
 
+Models that register the camera modality (for example LingBot-World) also
+accept structural SE3 payloads on `event.multi_modal_data.camera`. Coordinates
+follow Unity semantics (`+X` right, `+Y` up, `+Z` forward; same as LingBot's
+native camera frame). WASD key tokens are not admitted by the engine:
+
+```json
+{
+  "type": "session.interaction",
+  "interaction": {
+    "event_id": "forward-1",
+    "event": {
+      "multi_modal_data": {
+        "camera": {
+          "mode": "velocity",
+          "data": {
+            "translation": [0.0, 0.0, 0.05],
+            "rotation": [0.0, 0.0, 0.0, 1.0]
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+`mode` is `target` (lerp to an absolute pose over `transition_chunks`) or
+`velocity` (hold a per-frame SE3 delta until replaced). Prompt and camera may
+be combined in one interaction event.
+
 This feature is pipeline-dependent. An enabled endpoint does not imply that
-the loaded model supports midway prompt updates.
+the loaded model supports midway prompt or camera updates.
 
 The default start timeout is 10 seconds and the server reports a stall after
 about 60 seconds without generation progress or a `session.ping`. See the
 [streaming video generation example](https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/streaming_video_generation)
-for prompt-update scheduling and browser playback.
+for prompt/camera-update scheduling and browser playback.
diff --git a/docs/serving/videos_api.md b/docs/serving/videos_api.md
index 1152ebce3..da0fa1fd3 100644
--- a/docs/serving/videos_api.md
+++ b/docs/serving/videos_api.md
@@ -73,6 +73,10 @@ curl -L "http://localhost:8091/v1/videos/${video_id}/content" -o output.mp4
 | `image_reference` | string | null | JSON-encoded reference image payload; do not combine with `input_reference` or `video_reference` |
 | `video_reference` | string | null | JSON-encoded reference video payload; do not combine with `input_reference` or `image_reference` |
 | `audio_reference` | string | null | JSON-encoded audio reference for speech-to-video: `{"audio_url": "..."}` — supports HTTP(s) URLs or base64 data URLs |
+| `source_video` | file | null | MiniMax H3 latent-edit source video (`.mp4` or `.mov`, up to 512 MiB) |
+| `source_audio` | file | null | Optional MiniMax H3 latent-edit source audio (`.wav` or `.mp3`, up to 512 MiB) |
+| `video_noise_mask` | file | null | UTF-8 JSON MiniMax H3 video mask; `0` preserves and `1` regenerates a token |
+| `audio_noise_mask` | file | null | UTF-8 JSON MiniMax H3 audio mask; `0` preserves and `1` regenerates a token |
 | `width` | integer | model default | Output video width |
 | `height` | integer | model default | Output video height |
 | `num_frames` | integer | 1 | Number of generated frames |
@@ -214,6 +218,49 @@ upstream vLLM's media URL allowlist protection. Deployments should therefore
 treat remote media URLs as untrusted and choose this setting as part of their
 URL access policy.
 
+### MiniMax H3 Latent-Mask Editing
+
+MiniMax H3 accepts request-scoped source media and video/audio noise masks.
+At least one mask is required. A nontrivial `video_noise_mask` requires
+`source_video`, while a nontrivial `audio_noise_mask` requires either
+`source_audio` or a `source_video` with an audio stream. Mask values are in
+`[0, 1]`: `0` preserves the source, `1` regenerates it, and fractional values
+blend the two behaviors. Exact all-one masks are no-ops and do not require a
+source. Source uploads without a mask are rejected. Masks may be a JSON scalar
+or arrays matching the H3 latent/token grid; pixel-resolution masks must be
+resized or pooled by the client before upload.
+
+For an aligned output of `F` frames at `W x H`, the video latent grid is
+`[Tv, H/16, W/16]`, where `Tv = 2 + 5 * ((F - 5) / 17)`. The video mask may be
+a scalar, a flat token vector, `[Tv, H/32, W/32]`, or the full latent grid. For
+the model input, timestep, and velocity, a full-grid mask is max-pooled over
+each 2x2 spatial token and fractional values are rounded upward to 1/256
+levels. The final x0 restore uses the original, unquantized mask, so full-grid
+masks retain cell-level preservation inside a model token. The audio length is
+`Ta = round(F * 40 / 24)`, and its mask may be a scalar, `[Ta]`, `[2, Ta]`, or
+a flat `2 * Ta` vector. If source audio is short, its missing latent tail is
+forced to mask value `1` so H3 generates that portion. Each mask must be sent
+as a UTF-8 JSON file part and is limited to 8 MiB. A file may contain either a
+JSON scalar or an array.
+
+```bash
+curl -s http://localhost:8091/v1/videos/sync \
+  -F "prompt=Partially restyle the complete clip and soundtrack" \
+  -F 'extra_params={"task":"t2va","duration":4.0,"aspect_ratio":"16:9"}' \
+  -F "source_video=@source.mp4;type=video/mp4" \
+  -F "source_audio=@source.wav;type=audio/wav" \
+  -F "video_noise_mask=@video-mask.json;type=application/json" \
+  -F "audio_noise_mask=@audio-mask.json;type=application/json" \
+  -o edited.mp4
+```
+
+For example, each mask file in the request above may contain the JSON scalar
+`0.5`.
+
+The server streams source files to temporary request-scoped storage and removes
+them after synchronous or asynchronous generation finishes. Models that do not
+declare latent-mask editing support reject these fields.
+
 ### Speech-to-Video
 
 For models that support audio-driven generation (e.g., Wan2.2-S2V), pass both
@@ -251,6 +298,7 @@ These `extra_params` control how the server turns decoded frames into MP4 bytes.
 | Field | Type | Default | Description |
 | --- | --- | --- | --- |
 | `preencode_mp4` | boolean | false | Encode the MP4 on the worker while the VAE is still decoding, instead of after the full video is materialized |
+| `preencode_batch_frames` | positive integer | 17 (H3, Wan T2V/I2V); 1 (Wan S2V) | Minimum accumulated frames per worker transfer/encoding batch; used only with `preencode_mp4=true` |
 | `video_codec_options` | object | null | Encoder options passed through to the H.264 encoder, such as `{"preset": "ultrafast", "threads": "0"}` |
 
 With `preencode_mp4` enabled, each committed VAE chunk leaves the accelerator and
@@ -261,16 +309,29 @@ unchanged: the same complete MP4, byte-for-byte equivalent frames.
 ```bash
 curl -X POST http://localhost:8091/v1/videos/sync \
   -F "prompt=A small robot walking through a neon city" \
-  -F 'extra_params={"preencode_mp4": true, "video_codec_options": {"preset": "ultrafast"}}' \
+  -F 'extra_params={"preencode_mp4": true, "preencode_batch_frames": 33, "video_codec_options": {"preset": "ultrafast"}}' \
   -o output.mp4
 ```
 
+Set `preencode_batch_frames` in `extra_params` (or `extra_args` for offline
+sampling) to tune batching. The worker accumulates complete VAE chunks until
+it has at least this many frames, then transfers and encodes them together.
+It always flushes the final partial batch. This is a threshold, not an exact
+chunk length: a value of 1 submits every native chunk immediately, and a value
+smaller than a native chunk does not split it. Larger values reduce transfers
+but retain more frames on the accelerator and delay encoding. The VAE decode
+window and output frame count stay unchanged. Wan S2V keeps its existing
+per-clip behavior by default. Zero, negative, fractional, boolean, string, and
+null values are rejected when pre-encoding is enabled.
+
 `preencode_mp4` applies to the complete-MP4 response paths only. The
 `/v1/realtime/video` WebSocket endpoint rejects it, because that path already
-overlaps encoding through its own incremental fragmented-MP4 encoder.
+overlaps encoding through its own incremental fragmented-MP4 encoder. Wan also
+rejects it together with `enable_frame_interpolation`, which needs the decoded
+frames the pre-encoded path no longer materializes.
 
-Support is per model: MiniMax-H3 implements it, and other models ignore the flag
-and take the full-decode path.
+Support is per model: MiniMax-H3 and Wan 2.2 (T2V, I2V, and S2V) implement it,
+and other models ignore the flag and take the full-decode path.
 
 ## Storage
 
diff --git a/docs/user_guide/diffusion/attention_backends/rainfusion.md b/docs/user_guide/diffusion/attention_backends/rainfusion.md
index 00f4e37a1..1d91cabfa 100644
--- a/docs/user_guide/diffusion/attention_backends/rainfusion.md
+++ b/docs/user_guide/diffusion/attention_backends/rainfusion.md
@@ -78,3 +78,35 @@ Protected video tails require a compatible MindIE-SD release.
 For common configuration and selector behavior, see the
 [attention backend overview](../attention_backends.md) and the
 [backend selection design](../../../design/feature/attention_backend_selection.md).
+
+## Wan2.2 T2V quantization on Ascend
+
+`RAINFUSION_ATTN` accepts `diffusion_kv_cache_dtype: fp8` or `mxfp4` for
+Wan2.2 T2V A14B.
+MindIE-SD must expose `sparse_attention` with `rf_v3` and an explicit `precision`
+argument. Omni passes the selected precision directly to this API; the installed
+native operators must support that precision. Unsupported inputs or an
+incompatible Python API raise an actionable error; Omni does not change BSA
+precision automatically. Update `diffusion_kv_cache_dtype` to a precision
+supported by the installed MindIE-SD, or unset it. Native execution errors also
+propagate without retry.
+BSA FP8 and MXFP4 retain MindIE-SD's default rotation policy.
+
+`diffusion_kv_cache_skip_layers`/`diffusion_kv_cache_skip_steps` explicitly
+select floating-point BSA and keep attention sparse. The existing `block_sparse`
+warmup/layer exclusions and short-sequence threshold instead select Dense
+attention, using the configured Dense precision. Leave `block_sparse.precision`
+at its default when using `diffusion_kv_cache_dtype` as the shared Dense/BSA
+precision setting.
+
+Configure BSA quantization in the model's existing deployment YAML with
+`backend: RAINFUSION_ATTN` and stage-level `diffusion_kv_cache_dtype: fp8` or
+`mxfp4`. The precision and skip selectors are siblings of
+`diffusion_attention_config`; they are not per-role `quant` fields.
+For 40 denoising steps, `diffusion_kv_cache_skip_steps: "0,1,38,39"` and
+`diffusion_kv_cache_skip_layers: "0,39"` are recommended starting points. These
+fixed step indices do not automatically follow a changed step count. Selected
+forwards remain floating-point BSA; unsupported BSA precision is an error rather
+than an automatic fallback. See
+[quantized attention](../../quantization/quantized_kvcache.md#wan22-t2v-quantized-attention-on-ascend)
+for the shared configuration structure and index semantics.
diff --git a/docs/user_guide/diffusion/mot_config.md b/docs/user_guide/diffusion/mot_config.md
index 6661c6c9a..d25c1cd00 100644
--- a/docs/user_guide/diffusion/mot_config.md
+++ b/docs/user_guide/diffusion/mot_config.md
@@ -28,7 +28,7 @@ and their optimal Triton tile configurations:
 
 Config loading order (3-tier, see ops/mot_gemm.py):
     1. $VLLM_TUNED_CONFIG_FOLDER/<filename>  (env override)
-    2. This directory: vllm_omni/diffusion/layers/mot/configs/<filename>
+    2. This directory: vllm_omni/diffusion/models/bagel/mot/configs/<filename>
     3. Conservative default config (compiles everywhere, sub-optimal perf)
 
 If no config file matches the current device, a warning is printed with
@@ -39,7 +39,7 @@ To generate configs for your hardware:
     python benchmarks/kernels/mot_linear_benchmarks.py \
         --model ByteDance-Seed/BAGEL-7B-MoT \
         --tp-size 1 --dtype w16a16 --tune \
-        --save-dir vllm_omni/diffusion/layers/mot/configs/
+        --save-dir vllm_omni/diffusion/models/bagel/mot/configs/
 
 For multi-GPU tuning (uses Ray for parallel search):
 
diff --git a/docs/user_guide/diffusion/offloader/distributed_layerwise_offload.md b/docs/user_guide/diffusion/offloader/distributed_layerwise_offload.md
index b6e67c5ca..d36afb79e 100644
--- a/docs/user_guide/diffusion/offloader/distributed_layerwise_offload.md
+++ b/docs/user_guide/diffusion/offloader/distributed_layerwise_offload.md
@@ -353,9 +353,14 @@ modes can resolve the same `None` value to different schedules.
   Cache-DiT on any selected component. Prompt-embedding cache is also
   incompatible when the text encoder uses `allgather`. Rank-local cache hits
   could otherwise make ranks enter different weight collectives.
-- Per-tensor online FP8 linears use the ordinary loader and can run with either
-  DiT transfer path. With DiT `allgather`, every rank temporarily materializes
-  the complete FP8 model in host memory before DLO retains only its shard.
+- Per-tensor online FP8, INT8, and MXFP8 linears use the ordinary loader and
+  can run with either DiT transfer path. With DiT `allgather`, every rank
+  temporarily materializes the complete quantized model in host memory before
+  DLO retains only its shard. Layers too wide for the NPU quantization kernel
+  (`npu_quant_matmul` rejects an output dimension past 65535) stay
+  unquantized and load straight into host memory under offload-after-quant —
+  their runtime layout is a plain contiguous bf16 weight, the same layout DLO
+  shards on the ordinary path, so they are allowed under `allgather` too.
   Other online quantization methods require rank-local transfer for the
   affected component until their runtime layouts are validated.
 - Resident leading layers require DiT `rank-local` transfer and a model
diff --git a/docs/user_guide/examples/online_serving/bagel.md b/docs/user_guide/examples/online_serving/bagel.md
index 6c10c4349..6b1e20391 100644
--- a/docs/user_guide/examples/online_serving/bagel.md
+++ b/docs/user_guide/examples/online_serving/bagel.md
@@ -247,12 +247,18 @@ curl http://localhost:8091/v1/chat/completions \
   -d @payload.json
 ```
 
-BAGEL img2img derives its generated image size from the input image. It
-preserves the input aspect ratio, aligns dimensions to the latent stride, and
-applies the checkpoint size limit; explicit `height` and `width` values do not
-override this model-specific resize policy. In step mode, the effective size is
-resolved before scheduler admission so requests with different resulting
-shapes are not combined.
+When no output size is requested (`size=auto` on `/v1/images/edits`, or no
+`height`/`width` in a chat request), BAGEL img2img derives the canvas from the
+input image: it preserves the input aspect ratio, aligns dimensions to the
+latent stride (16 px), and applies the checkpoint size limit. An explicit
+`size`, `height`, or `width` is honored instead, in both the single-stage and
+the two-stage deployment; the input image is still resized to a stride-aligned
+size for the VAE/ViT prefill. The latent grid needs multiples of 16, so a
+requested side that is not one is floored to the next multiple (1000x700
+generates 992x688) and the server logs a warning; the response reports the
+generated size. A side above the checkpoint limit is rejected with HTTP 400.
+In step mode, the effective size is resolved before scheduler admission so
+requests with different resulting shapes are not combined.
 
 ### Image to Text (img2text)
 
@@ -318,8 +324,8 @@ curl http://localhost:8091/v1/chat/completions \
 | `--server` / `-s` | `http://localhost:8091` | Server URL |
 | `--image-url` / `-i` | `None` | Input image URL or local path (img2img/img2text) |
 | `--modality` / `-m` | `text2img` | `text2img`, `img2img`, `img2text`, `text2text` |
-| `--height` | `512` | Text-to-image output height; BAGEL img2img derives its size from the input image |
-| `--width` | `512` | Text-to-image output width; BAGEL img2img derives its size from the input image |
+| `--height` | `512` | Output height, a multiple of 16; omit both `--height` and `--width` to let img2img derive the size from the input image |
+| `--width` | `512` | Output width, a multiple of 16; omit both `--height` and `--width` to let img2img derive the size from the input image |
 | `--steps` | `25` | Number of inference steps |
 | `--seed` | `42` | Random seed |
 | `--negative` | `None` | Negative prompt for CFG |
diff --git a/docs/user_guide/examples/online_serving/qwen3_omni.md b/docs/user_guide/examples/online_serving/qwen3_omni.md
index 2c85c33fe..654802c5c 100644
--- a/docs/user_guide/examples/online_serving/qwen3_omni.md
+++ b/docs/user_guide/examples/online_serving/qwen3_omni.md
@@ -2,7 +2,6 @@
 
 Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/qwen3_omni>.
 
-
 ## 🛠️ Installation
 
 Please refer to [README.md](https://github.com/vllm-project/vllm-omni/tree/main/README.md)
@@ -15,6 +14,19 @@ Please refer to [README.md](https://github.com/vllm-project/vllm-omni/tree/main/
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```
 
+For a local deployment with multiple API frontend processes sharing one set
+of stage engines, add `--api-server-count`:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
+    --api-server-count 2 --port 8091
+```
+
+This mode supports local EngineCore stages with one local process group per
+replica, including stages configured with multiple `num_replicas`. Headless,
+remote, diffusion, intra-replica data-parallel, and Ray stage deployments
+remain single-frontend.
+
 The default deployment configuration situated at `vllm_omni/deploy/qwen3_omni_moe.yaml` is resolved and loaded
 automatically via the model registry, obviating the necessity for the `--deploy-config` flag in standard deployment topologies.
 The bundled Qwen3-Omni setup explicitly sets `moe_backend: triton` for the Thinker and Talker stages. This keeps
@@ -27,6 +39,7 @@ on the Thinker stage. Keep Talker and Code2Wav at `pipeline_parallel_size: 1`. T
 default asynchronous scheduling and audio chunk streaming can remain enabled.
 
 To explicitly utilize a custom deployment YAML, specify the configuration path:
+
 ```bash
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091 \
     --deploy-config /path/to/deploy_config_file
@@ -50,7 +63,7 @@ Adopt the stage-based CLI architecture to independently instantiate execution pr
 The example below pins Stage 0 to GPU 0 and Stage 1/2 to GPU 1 via
 `CUDA_VISIBLE_DEVICES`.
 
-**1. Stage 0 (Thinker + API server)**
+#### 1. Stage 0 (Thinker + API server)
 
 ```bash
 CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
@@ -60,7 +73,7 @@ CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
     --omni-master-port 26000
 ```
 
-**2. Stage 1 (Talker)**
+#### 2. Stage 1 (Talker)
 
 ```bash
 CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
@@ -70,7 +83,7 @@ CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
     --omni-master-port 26000
 ```
 
-**3. Stage 2 (Code2Wav)**
+#### 3. Stage 2 (Code2Wav)
 
 ```bash
 CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
@@ -95,6 +108,9 @@ To experiment with another supported MoE backend, set `moe_backend` in the
 deployment YAML for both the Thinker and Talker stages. For the stage-based
 CLI, pass `--moe-backend` directly on each stage command.
 
+For other stage settings, pass the option on that stage command. For example,
+to change its GPU memory utilization:
+
 ```bash
 CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
     --stage-id 1 \
@@ -107,11 +123,12 @@ CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
 ### Send Multi-modal Request
 
 Get into the example folder
+
 ```bash
 cd examples/online_serving/qwen3_omni
 ```
 
-####  Send request via python
+#### Send request via python
 
 ```bash
 python openai_chat_completion_client_for_multimodal_generation.py --query-type use_image --port 8091 --host "localhost"
@@ -126,7 +143,6 @@ The Python client supports the following command-line arguments:
 - `--audio-path` (or `-a`): Path to local audio file or URL. If not provided and query-type is `use_audio`, uses default audio URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs and common audio formats: MP3, WAV, OGG, FLAC, M4A. Example: `--audio-path /path/to/audio.wav` or `--audio-path https://example.com/audio.mp3`
 - `--prompt` (or `-p`): Custom text prompt/question. If not provided, uses default prompt for the selected query type. Example: `--prompt "What are the main activities shown in this video?"`
 
-
 For example, to use a local video file with custom prompt:
 
 ```bash
@@ -136,19 +152,20 @@ python openai_chat_completion_client_for_multimodal_generation.py \
     --prompt "What are the main activities shown in this video?"
 ```
 
-####  Send request via curl
+#### Send request via curl
 
 ```bash
 bash run_curl_multimodal_generation.sh use_image
 ```
 
 ## Modality control
+
 You can control output modalities to specify which types of output the model should generate. This is useful when you only need text output and want to skip audio generation stages for better performance.
 
 ### Supported modalities
 
 | Modalities | Output |
-|------------|--------|
+| ------------ | -------- |
 | `["text"]` | Text only |
 | `["audio"]` | Audio only |
 | `["text", "audio"]` | Text + Audio |
@@ -226,7 +243,9 @@ print(response.choices[1].message.audio)    # Audio response
 ```
 
 ## Streaming Output
+
 If you want to enable streaming output, please set the argument as below. The final output will be obtained just after generated by corresponding stage. We support both text streaming output and audio streaming output. Other modalities can output normally.
+
 ```bash
 python openai_chat_completion_client_for_multimodal_generation.py \
     --query-type use_image \
@@ -259,12 +278,14 @@ The convenience script launches both the vLLM server and Gradio demo together:
 ```
 
 This script will:
+
 1. Start the vLLM server in the background
 2. Wait for the server to be ready
 3. Launch the Gradio demo
 4. Handle cleanup when you press Ctrl+C
 
 The script supports the following arguments:
+
 - `--model`: Model name/path (default: Qwen/Qwen3-Omni-30B-A3B-Instruct)
 - `--server-port`: Port for vLLM server (default: 8091)
 - `--gradio-port`: Port for Gradio demo (default: 7861)
@@ -275,18 +296,19 @@ The script supports the following arguments:
 
 #### Option 2: Manual Launch (Two-Step Process)
 
-**Step 1: Launch the vLLM API server**
+##### Step 1: Launch the vLLM API server
 
 ```bash
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```
 
 If you have a custom deploy config file:
+
 ```bash
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091 --deploy-config /path/to/deploy_config_file
 ```
 
-**Step 2: Run the Gradio demo**
+##### Step 2: Run the Gradio demo
 
 In a separate terminal:
 
@@ -299,7 +321,7 @@ Then open `http://localhost:7861/` on your local browser to interact with the we
 The gradio script supports the following arguments:
 
 - `--model`: Model name/path (should match the server model)
-- `--api-base`: Base URL for the vLLM API server (default: http://localhost:8091/v1)
+- `--api-base`: Base URL for the vLLM API server (default: <http://localhost:8091/v1>)
 - `--ip`: Host/IP for Gradio server (default: 127.0.0.1)
 - `--port`: Port for Gradio server (default: 7861)
 - `--share`: Share the Gradio demo publicly (creates a public link)
diff --git a/docs/user_guide/examples/online_serving/text_to_speech.md b/docs/user_guide/examples/online_serving/text_to_speech.md
index e9499551f..c1107ad60 100644
--- a/docs/user_guide/examples/online_serving/text_to_speech.md
+++ b/docs/user_guide/examples/online_serving/text_to_speech.md
@@ -413,6 +413,22 @@ vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice --omni --port 8091
 ./qwen3_tts/run_server.sh Base
 ```
 
+For a local deployment with multiple API frontend processes sharing one set
+of TTS stage engines, add `--api-server-count`:
+
+```bash
+vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
+    --omni --api-server-count 2 --port 8091
+```
+
+This mode supports local EngineCore stages with one local process group per
+replica, including stages configured with multiple `num_replicas`. Headless,
+remote, intra-replica data-parallel, and Ray stage deployments are not
+supported. Runtime voice upload and deletion are disabled with multiple
+API frontends because their registries are process-local. Built-in voices,
+inline `ref_audio`, and voices restored from `custom_voice_dir` at startup are
+supported.
+
 ### Executor backend
 
 Single-GPU serves now default to the uniproc executor (lower IPC overhead, the Base cloning use case from [#2603](https://github.com/vllm-project/vllm-omni/issues/2603) / [#2604](https://github.com/vllm-project/vllm-omni/pull/2604)). `vllm_omni/deploy/qwen3_tts.yaml` is the only Qwen3-TTS deploy config; pass `--deploy-config <path>` to override.
@@ -478,6 +494,10 @@ checkpoint. When a request names an uploaded voice, the server infers
 `task_type="Base"`. Built-in presets such as `vivian` and `ryan` remain
 CustomVoice speakers and require a CustomVoice checkpoint.
 
+The runtime upload and delete routes require a single API frontend; with
+`--api-server-count > 1`, use inline `ref_audio` or restore precomputed voices
+from `custom_voice_dir` at startup.
+
 ### Precomputed custom voices
 
 For reused Base voice-cloning speakers, precompute the reference artifacts once
diff --git a/docs/user_guide/quantization/mxfp4.md b/docs/user_guide/quantization/mxfp4.md
index b18b3e7b3..00ff97c01 100644
--- a/docs/user_guide/quantization/mxfp4.md
+++ b/docs/user_guide/quantization/mxfp4.md
@@ -6,22 +6,25 @@ W4A4 MXFP4 (Microscaling FP4) quantizes both weights and activations to FP4
 (`float4_e2m1fn_x2`, packed 2 values per byte) using the OCP MX format: groups
 of 32 K-dimension elements share a single `float8_e8m0fnu` exponent scale.
 
+On Ascend, single-scale MXFP4 also supports Universal Optimal Scaling
+(UOS, `Qmax=7.25`), described in the single-scale scaling section below.
+
 vLLM-Omni provides two quantization methods with different scale structures:
 
 | Method | Scale structure | Mode | Use case |
-|--------|----------------|------|----------|
-| `mxfp4` | Single-scale (per-32 fine only) | Online only | Quick accuracy baseline; no checkpoint prep needed |
-| `mxfp4_dualscale` | Dual-scale (fine per-32 + coarse per-512 + per-channel `mul_scale`) | Online + Offline | Production; better accuracy; offline recommended |
+| -------- | ---------------- | ------ | ---------- |
+| `mxfp4` | Single-scale (per-32 fine only) | Online + pre-quantized single-scale weights | Online baseline, or an existing single-scale checkpoint in the layout below |
+| `mxfp4_dualscale` | Dual-scale (fine per-32 + coarse per-512 + per-channel `mul_scale`) | Online + Offline | W4A4 with dual-level scales; offline mode loads calibrated Smooth tensors |
 
-!!! tip "Recommended: `mxfp4_dualscale` offline"
-    For production deployments, use the `mxfp4_dualscale` offline mode with a
+!!! tip "Existing W4A4-only DualScale deployments"
+    For W4A4-only deployments, the existing `mxfp4_dualscale` offline mode uses a
     pre-quantized checkpoint produced by msModelSlim. Offline checkpoints load
-    calibrated `mul_scale` tensors from disk, providing measurably better accuracy
-    than any online method. The one-time preprocessing cost amortises across all
-    subsequent inference runs.
+    calibrated `mul_scale` tensors from disk. Quality depends on the model,
+    calibration recipe and BF16 fallback policy; evaluate the checkpoint against
+    your quality target before deployment.
 
-    Use `mxfp4` online only for quick experimentation where preprocessing time
-    is not acceptable and accuracy loss is tolerable.
+    W4A8 layer/step fallback requires single-scale `mxfp4`, online or offline.
+    DualScale supports W4A4 and BF16 routing only.
 
 !!! warning "Online single-scale ≠ Offline dual-scale"
     `mxfp4_dualscale` offline mode uses `NPUMxfp4DualScaleLinearMethod`:
@@ -34,61 +37,244 @@ vLLM-Omni provides two quantization methods with different scale structures:
 
 ## Hardware Support
 
-| Device | Support |
-|--------|---------|
-| NVIDIA Blackwell GPU (SM 100+) | ⭕ |
-| NVIDIA Ada/Hopper GPU (SM 89+) | ⭕ |
-| NVIDIA Ampere GPU (SM 80+) | ⭕ |
-| AMD ROCm (gfx950 / MI355X) | ✅ |
-| Intel XPU | ⭕ |
-| Ascend NPU (Atlas 950 A5) | ✅ |
+The following matrix describes these vLLM-Omni implementations, rather than
+hardware support for the MXFP4 format in general.
 
-Legend: `✅` supported, `❌` unsupported, `⭕` not verified in this guide.
+| Device | Single-scale online OCP | Single-scale offline | UOS / W4A8 fallback | DualScale |
+| -------- | -------- | -------- | -------- | -------- |
+| Ascend NPU (Atlas 950 A5) | ✅ | ✅ | ✅ | ✅ |
+| AMD ROCm (gfx950 / MI355X) | ✅ | ❌ | ❌ | ❌ |
+| Other AMD architectures | ❌ | ❌ | ❌ | ❌ |
+| NVIDIA GPU | ❌ | ❌ | ❌ | ❌ |
+| Intel XPU | ❌ | ❌ | ❌ | ❌ |
+
+Legend: `✅` supported by the implementation, `❌` unsupported.
+ROCm uses the existing AITER online path and requires `mxfp4_scale_alg=0`.
 
 ## Model Type Support
 
 ### Diffusion Model (Wan2.2)
 
 | Model | Online | Offline | Notes |
-|-------|--------|---------|-------|
-| Wan2.2-T2V-A14B | `mxfp4` / `mxfp4_dualscale` | `mxfp4_dualscale` | MoE cascade (`transformer` + `transformer_2`); both transformers quantized with the same config |
-| Wan2.2-I2V-A14B | `mxfp4` / `mxfp4_dualscale` | `mxfp4_dualscale` | MoE cascade; same scheme as T2V-A14B |
-| Wan2.2-TI2V-5B | ❌ | ❌ | Parameter count too small; W4A4 causes unacceptable accuracy loss |
+| ------- | -------- | --------- | ------- |
+| Wan2.2-T2V-A14B | `mxfp4` / `mxfp4_dualscale` | `mxfp4` / `mxfp4_dualscale` | Cascade experts resolve checkpoint metadata independently; explicit global runtime policy applies to both |
+| Wan2.2-I2V-A14B | `mxfp4` / `mxfp4_dualscale` | `mxfp4` / `mxfp4_dualscale` | Per-expert configuration uses the same interface as T2V; validate I2V checkpoints separately |
+| Wan2.2-TI2V-5B | Requires validation | Requires validation | This guide does not establish checkpoint compatibility or generation quality for TI2V-5B |
 
-The choice between `mxfp4` and `mxfp4_dualscale` in **online mode** is about
-quantization quality, not model compatibility — both work on cascade (A14B) and
-single-transformer models alike, the same as `mxfp8` online:
+Both methods can be integrated with single-transformer and cascade models.
+This alone does not establish support or quality for every model variant:
 
-- `mxfp4`: single-scale, lower overhead, simpler compute, online only
-- `mxfp4_dualscale`: dual-scale + optional BF16 fallback, better accuracy, online **and** offline
+- `mxfp4`: single-scale; online and pre-quantized weights, with optional W4A8 fallback on NPU
+- `mxfp4_dualscale`: dual-scale; online and offline, with BF16 fallback
 
-**Offline** checkpoints for A14B are always in `mxfp4_dualscale` format (produced
-by the merge script); there is no offline `mxfp4` single-scale format.
+The existing `merge_mxfp4_dualscale_checkpoint.py` produces **offline
+`mxfp4_dualscale`** checkpoints. Single-scale weights must satisfy the separate
+layout described below; changing a DualScale checkpoint's method name to
+`mxfp4` does not convert its weights. Prepare single-scale checkpoints with
+external tooling. Real exported checkpoint compatibility and model quality
+require validation of that checkpoint; the synthetic tests do not establish
+UOS export or video acceptance.
 
 !!! note "Per-layer BF16 fallback in offline cascade models"
-    The A14B offline checkpoint uses `quant_method: mxfp4_dualscale`. Most
+    An A14B offline DualScale checkpoint uses `quant_method: mxfp4_dualscale`. Most
     linear layers are stored as W4A4 MXFP4 DualScale; precision-sensitive layers
     retain their original BF16 weights and are listed in `ignored_layers` inside
     each transformer's `config.json`. The two transformers may have different
     `ignored_layers` sets — the pipeline reads each transformer's own `config.json`
-    and rebuilds the config locally when they differ, so routing is always
-    per-transformer-accurate.
-
-!!! warning "TI2V-5B not supported"
-    Wan2.2-TI2V-5B is excluded from W4A4 quantization. Its smaller parameter
-    count makes it significantly more sensitive to 4-bit quantization noise,
-    resulting in unacceptable accuracy loss. Use [MXFP8](mxfp8.md) for TI2V-5B.
+    and resolves the storage format and BF16 layer policy independently.
 
 ## Configuration
 
+### W4A8 fallback at selected layers and denoising steps (Ascend NPU)
+
+For single-scale `mxfp4`, set `w4a8_fallback_steps` to a list of zero-based
+request denoising loop indices (not scheduler timestep values).
+Set `w4a8_fallback_layers` to exact runtime Linear paths, for example
+`["blocks.10.attn1.to_qkv", "blocks.12.ffn.net_2"]`. A selected layer uses W4A8
+at every step; at a selected step, all other quantized layers also use W4A8.
+The rules are combined with **OR**. W4A8 uses MXFP8 activations with MXFP4
+weights. Omitting both lists or passing `[]` keeps the existing W4A4 behavior. Existing
+`ignored_layers` take priority: **BF16 > (layer OR step) W4A8 > W4A4**.
+DualScale's existing leading BF16 block rule is unchanged; it does not enable
+W4A8.
+
+```python
+from vllm_omni import Omni
+
+omni = Omni(
+    model="<Wan2.2-T2V-A14B-Diffusers>",
+    quantization_config={
+        "method": "mxfp4",
+        "w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"],
+        "w4a8_fallback_steps": [0, 1, 38, 39],
+    },
+)
+```
+
+Both policies also work with offline single-scale `mxfp4`. Any nonempty
+W4A8 list with `mxfp4_dualscale`, online or offline, raises an explicit error
+at configuration construction. Empty lists preserve its existing W4A4 path.
+Each expert's checkpoint still determines its serialized
+format and BF16 layer routing. A serialized checkpoint config is the complete
+storage contract: `ignored_layers`, or its `modules_to_not_convert` alias,
+selects the BF16 layers, and omitting both means no explicit BF16 layers. A
+method-only checkpoint value such as `"mxfp4"` or
+`{"quant_method": "mxfp4"}` carries no storage policy and leaves a caller's
+online `ignored_layers` unchanged. An explicitly supplied quantization config
+retains its W4A8 layer and step lists when the loader rebuilds either expert's
+config from disk, including empty lists that disable checkpoint policies.
+Within an explicit runtime config, an omitted W4A8 list defaults to `[]`;
+individual omitted fields do not inherit saved policies. Without an explicit
+runtime config, auto-detection uses the saved checkpoint policies.
+
+Layer names are relative to each expert (`blocks.10...`, without a
+`transformer.` or `transformer_2.` prefix). A global config applies the same
+list to both experts; per-component `transformer`/`transformer_2` configs can
+select different lists. Wan selects these expert names exactly: a `transformer`
+entry does not match `transformer_2`; an omitted expert uses `default` if set.
+A component mapped to `null` (or an unmatched component
+without a default) stays unquantized and requires a BF16 checkpoint; loading a
+quantized checkpoint for that disabled component raises an error. A top-level
+`quantization_config=None` retains checkpoint auto-detection.
+Names are exact, with no regex, wildcard, block expansion,
+or checkpoint-name remapping. Wan validates them against its runtime Linear
+modules and logs the selected paths/count and BF16 overrides per PP rank.
+Use `attn1.to_qkv` for fused self-attention; `attn1.to_q`, `to_k`, or `to_v`
+checkpoint names raise an error. Cross-attention `attn2.to_q/to_k/to_v` remains
+separate. Layer-only fallback does not require a denoise ForwardContext.
+
+The text-to-video example accepts the JSON directly:
+
+```bash
+ASCEND_RT_VISIBLE_DEVICES=0,1,2,3 \
+python examples/offline_inference/text_to_video/text_to_video.py \
+    --model /path/to/Wan2.2-T2V-A14B-Diffusers \
+    --quantization-config '{"method":"mxfp4","w4a8_fallback_steps":[0,2]}' \
+    --tensor-parallel-size 1 --ulysses-degree 2 --cfg-parallel-size 2 \
+    --enforce-eager --height 480 --width 832 --num-frames 81 \
+    --num-inference-steps 40 --seed 42 --output wan22-w4a8.mp4
+```
+
+Use either `--quantization` or `--quantization-config` in this example.
+Serving accepts the same JSON through `--diffusion-quantization-config`.
+
+The list uses one request's loop index across both high- and low-noise experts,
+and both CFG branches see the same index. A new request starts at step zero.
+Indices outside the request's step range are never selected. A pipeline must
+publish `ForwardContext.denoise_step_idx`; requesting step fallback without
+that context raises an error instead of silently ignoring the list.
+
+Single-scale W4A4 and W4A8 reuse the same prepared `weight` and `weight_scale`.
+Online loading quantizes the original BF16/FP16 weight once; offline loading
+packs the numeric FP4 values and reshapes the saved E8M0 scale without
+requantizing the weight. Only activation precision changes during forward.
+There is no DualScale decoding, second W4 representation or `w4a8_weight` /
+`w4a8_weight_scale` cache. No weight quantization runs inside the denoising loop.
+
+The mixed FP8/FP4 GEMM uses BF16 output and a matching BF16 row bias for
+compatibility with the target A5 runtime. An FP16 caller receives that result
+converted back to FP16; its output shape and dtype are preserved.
+
+The single-scale fallback validation target is eager Wan2.2 T2V A14B on A5.
+Quality scores, optimal fallback lists, real UOS exports and additional
+compile/offload combinations require separate evaluation. Existing W4A4-only
+DualScale still needs complete 512-channel input groups; use TP=1 with
+sequence/CFG parallelism for its initial multi-card run.
+
+### `mxfp4` — Pre-Quantized Single-Scale Weights (Ascend NPU)
+
+Set the following fields in each transformer's `config.json` when a
+single-scale checkpoint uses calibrated Smooth scaling:
+
+```json
+{
+  "quantization_config": {
+    "quant_method": "mxfp4",
+    "is_checkpoint_mxfp4_serialized": true,
+    "require_smooth_scale": true,
+    "ignored_layers": []
+  }
+}
+```
+
+Each quantized Linear must provide tensors under its model parameter name:
+
+| Tensor | Checkpoint layout | Meaning |
+| -------- | ------------------- | --------- |
+| `weight` | `(N, K)` numeric FP4 values | Packed to FP4 after loading |
+| `weight_scale` | `(N, ceil(K / 32))`, `uint8` | Raw E8M0 exponent bytes, required |
+| `mul_scale` | `(K,)`, FP32 | Smooth pre-scale, required when declared above |
+
+Both W4A4 and W4A8 quantize `x * mul_scale`. The Smooth tensor is converted
+to the layer's activation dtype after loading. Row-parallel layers load the
+corresponding input-channel shard. Pre-fused QKV weights must use one shared
+Smooth tensor for the fused projection.
+
+For backward compatibility, `require_smooth_scale` defaults to `false`:
+an absent tensor uses identity scaling, while a present tensor is still loaded.
+Without a declaration, an absent Smooth tensor cannot be distinguished from a
+legacy unsmoothed checkpoint. Calibrated checkpoints should declare
+`require_smooth_scale: true` so missing or misnamed Smooth tensors fail loading;
+incorrect tensor shapes, non-floating tensors, NaN/Inf and nonpositive values
+also fail. Values that overflow or underflow to zero in the activation dtype
+are rejected during weight processing. The flag requires serialized single-scale
+weights and is rejected for online quantization. It does not make DualScale
+scales optional or change missing-parameter policies for other backends.
+Either the checkpoint or an explicit caller can require Smooth: a `true`
+declaration is retained when per-expert metadata rebuilds the configuration,
+including when the other source omits the flag or sets it to `false`.
+
+Prepare the canonical numeric FP4 checkpoint before inference using external
+tooling. Runtime loading does not parse producer-specific export formats.
+Retain the producer recipe to identify the weight-generation algorithm and
+Smooth calibration; tensor storage alone does not establish UOS provenance.
+
+### `mxfp4` — Single-Scale Block Scaling (OCP / UOS)
+
+`mxfp4_scale_alg` selects the MXFP4 block-scaling method on NPU.
+UOS is a scaling rule, not a separate activation dtype or an activation-only
+algorithm. Both choices use FP4 E2M1 values with shared E8M0 scales.
+
+| Mode | Weight preparation | A4 activation quantization | W4A8 fallback |
+| --- | --- | --- | --- |
+| Online | Selected scaling method, once at loading | Selected scaling method | Same W4; OCP MXFP8 A8 |
+| Offline | Load existing W4 and scales unchanged | Selected scaling method | Same W4; OCP MXFP8 A8 |
+
+The available settings are:
+
+| Setting | MXFP4 scaling method | NPU parameters |
+| --- | --- | --- |
+| `0` (default) | OCP MX | `scale_alg=0` |
+| `2` | UOS (`Qmax=7.25`) | `scale_alg=2, dst_type_max=7.25` |
+
+Universal Optimal Scaling (UOS, `Qmax=7.25`) is derived in
+[MXAttention: Data-Free Optimal Scaling and Pre-Normalization Quantization for MXFP4 Attention](https://arxiv.org/abs/2607.24377),
+Section 4.1. The value `7.25` is the boundary used to select the shared
+power-of-two scale; the maximum finite E2M1 value remains `6`.
+This option applies UOS to Linear quantization. It does not implement the
+paper's full MXAttention pipeline or Pre-Normalization Quantization (PNQ).
+
+Both use FP4 E2M1 with E8M0 scales, `axis=-1`, `block_size=32`,
+`round_mode="rint"`. W4A8 always quantizes the activation to
+`float8_e4m3fn` with `scale_alg=0` and the same grouping/rounding, without
+UOS parameters. A4 and A8 share the prepared W4 and scale. UOS is currently
+NPU-only; ROCm retains its existing AITER online algorithm.
+
+An explicit UOS online configuration is
+`{"method": "mxfp4", "mxfp4_scale_alg": 2}`. For offline checkpoints the
+setting affects **only A4 activations**. Existing weights are never requantized:
+a UOS checkpoint can run UOS W4 + UOS A4 or UOS W4 + OCP A4, and both fall back to
+UOS W4 + OCP A8. Record the weight-generation algorithm separately from the
+runtime activation setting. Smooth remains active with either setting. The
+UOS configuration explicitly selects `2`; attention computation is unchanged.
+
 ### `mxfp4` — Single-Scale Online Mode
 
-Online mode requires no pre-processing. vLLM-Omni quantizes BF16 weights to
-MXFP4 at load time using `npu_dynamic_mx_quant`. A single block scale
-(`float8_e8m0fnu`, one per 32 K elements) is computed on the fly; no
-calibration `mul_scale` is available. Applies equally to single-transformer
-and cascade (A14B) models — both transformers in a cascade receive the same
-quantization config automatically.
+Online mode quantizes BF16/FP16 weights once at loading and computes activation
+scales during forward. Each block of 32 K elements shares one E8M0 scale;
+no calibrated `mul_scale` is available. An explicit global quantization config
+applies to both cascade experts. Per-component configs can select different
+policies; checkpoint auto-detection resolves each expert independently.
 
 ```python
 from vllm_omni import Omni
@@ -103,7 +289,7 @@ outputs = omni.generate(
 
 ```bash
 # Single-transformer or cascade model — same command
-python text_to_video.py --model <your-model> --quantization mxfp4
+python examples/offline_inference/text_to_video/text_to_video.py --model <your-model> --quantization mxfp4
 
 # Online serving
 vllm serve <your-model> --omni --quantization mxfp4
@@ -113,19 +299,19 @@ vllm serve <your-model> --omni --quantization mxfp4
 
 Online DualScale mode computes both fine and coarse scales on the fly from BF16
 weights using `npu_dynamic_dual_level_mx_quant`. Applies equally to
-single-transformer and cascade (A14B) models. Compared to `mxfp4` online,
-DualScale provides better quantization accuracy at higher compute cost.
+single-transformer and cascade (A14B) models with compatible Linear layers.
+Compare quality and performance using the intended model and workload.
 
 The default configuration keeps the leading 5 transformer blocks in BF16
-(`num_bf16_fallback_layers=5`). Accuracy evaluation on Wan2.2-A14B shows this
-is sufficient to meet quality requirements and is the recommended setting.
+(`num_bf16_fallback_layers=5`). This is an implementation default; select and
+validate the BF16 policy against your own quality target.
 
 ```python
 omni = Omni(model="<your-model>", quantization="mxfp4_dualscale")
 ```
 
 ```bash
-python text_to_video.py --model <your-model> --quantization mxfp4_dualscale
+python examples/offline_inference/text_to_video/text_to_video.py --model <your-model> --quantization mxfp4_dualscale
 ```
 
 If accuracy debugging identifies additional precision-sensitive layers, they
@@ -136,21 +322,22 @@ omni = Omni(
     model="<your-model>",
     quantization_config={
         "method": "mxfp4_dualscale",
-        "ignored_layers": ["blocks.10.attn1.to_q"],   # explicit per-layer override
+        "ignored_layers": ["blocks.10.attn1.to_qkv"],   # explicit per-layer override
     },
 )
 ```
 
 BF16 fallback routing in online mode applies two rules in priority order:
 
-1. **`ignored_layers`** (explicit per-layer override): any layer whose prefix
-   matches is kept in BF16 regardless of block index.
+1. **`ignored_layers`** (explicit per-layer override): a listed runtime Linear
+   module is kept in BF16 regardless of block index. Use exact module paths,
+   not arbitrary block prefixes or names ending in `.weight`.
 2. **`num_bf16_fallback_layers`** (coarse leading-block rule): the first N
    transformer blocks (`blocks.0` … `blocks.N-1`) fall back to BF16. Defaults
-   to `5` (recommended). Layers outside `blocks.N.*`
-   (e.g. `condition_embedder`) are always quantized.
+   to `5`. Layers outside `blocks.N.*` are quantized unless explicitly listed
+   in `ignored_layers`.
 
-### `mxfp4_dualscale` — DualScale Offline Mode (Recommended)
+### `mxfp4_dualscale` — DualScale Offline Mode
 
 Offline mode loads a pre-quantized DualScale checkpoint from msModelSlim. A
 preprocessing step converts the raw quantized output to the diffusers format
@@ -169,8 +356,8 @@ inside `config.json`. At runtime, each layer's prefix is matched against
 Each quantized linear layer stores four tensors:
 
 | Tensor | Shape | dtype | Description |
-|--------|-------|-------|-------------|
-| `weight` | `(N, K)` | float8_e4m3fn | FP4 packed (2 values per byte) |
+| -------- | ------- | ------- | ------------- |
+| `weight` | `(N, K)` | float8_e4m3fn | Numeric FP4 values; packed into two values per byte after loading |
 | `weight_scale` | `(N, K//32)` | uint8 | Fine block scale (`float8_e8m0fnu` bit pattern) |
 | `weight_dual_scale` | `(N, K//512, 1)` | float32 | Coarse block scale |
 | `mul_scale` | `(K,)` | float32 | Per-input-channel smooth pre-scale (from calibration) |
@@ -223,7 +410,7 @@ python vllm_omni/quantization/tools/merge_mxfp4_dualscale_checkpoint.py \
 ```
 
 | Argument | Description |
-|----------|-------------|
+| ---------- | ------------- |
 | `--model-type` | Model variant: `Wan2.2-T2V-A14B` or `Wan2.2-I2V-A14B` |
 | `--original-model` | Root directory of the original BF16 diffusers model |
 | `--quant-path` | Root directory of the msModelSlim quantized output |
@@ -251,14 +438,14 @@ The `quantization_config` injected into `config.json` for each transformer:
 ```
 
 `ignored_layers` lists every linear layer that retains its original BF16 weight,
-using vllm-omni model parameter names (QKV-fused, FFN underscored, `to_out`
+using vllm-omni runtime module paths (QKV-fused, FFN underscored, `to_out`
 unindexed). The exact entries are determined by the quantization tool (msModelSlim)
 and may differ between `transformer` and `transformer_2` in a cascade model.
 
 #### Step 3 — Serve
 
 ```bash
-python text_to_video.py --model /path/to/Wan2.2-T2V-A14B-MXFP4-DualScale
+python examples/offline_inference/text_to_video/text_to_video.py --model /path/to/Wan2.2-T2V-A14B-MXFP4-DualScale
 
 # Online serving
 vllm serve /path/to/Wan2.2-T2V-A14B-MXFP4-DualScale --omni
@@ -275,25 +462,32 @@ omni = Omni(model="/path/to/Wan2.2-T2V-A14B-MXFP4-DualScale")
 
 ## Parameters
 
-### `mxfp4` (single-scale, online only)
+### `mxfp4` (single-scale, online + offline)
 
 | Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
+| ----------- | ------ | --------- | ------------- |
 | `method` | str | — | `"mxfp4"` |
-| `ignored_layers` | list[str] | `[]` | Layer prefixes to keep in BF16 |
+| `mxfp4_scale_alg` | int | `0` | MXFP4 block scaling: `0` OCP MX, `2` UOS (`Qmax=7.25`, NPU only). Online: W4 and A4; offline: A4 only. A8 remains OCP MXFP8 |
+| `is_checkpoint_mxfp4_serialized` | bool | `false` | Load pre-quantized single-scale weights and scales; declared in checkpoint `config.json` |
+| `require_smooth_scale` | bool | `false` | Require calibrated Smooth tensors for offline single-scale weights |
+| `ignored_layers` | list[str] | `[]` | Exact runtime Linear module paths to keep in BF16 |
+| `w4a8_fallback_layers` | list[str] | `[]` | Exact runtime Linear paths that always use A8; NPU only |
+| `w4a8_fallback_steps` | list[int] | `[]` | Zero-based denoise steps that use A8; NPU only |
 
 ### `mxfp4_dualscale` (dual-scale, online + offline)
 
 | Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
+| ----------- | ------ | --------- | ------------- |
 | `method` | str | — | `"mxfp4_dualscale"` |
 | `is_checkpoint_serialized` | bool | `False` | `True` for offline DualScale checkpoints; auto-set from `config.json` when using the preprocessing script |
-| `ignored_layers` | list[str] | `[]` | Layer prefixes to keep in BF16. **Works in both modes**: offline — populated by the merge script for interleaved sensitive layers; online — user-supplied for explicit per-layer precision override |
-| `num_bf16_fallback_layers` | int | `5` | **Online mode only**: leading N transformer blocks (`blocks.0` … `blocks.N-1`) kept in BF16. Applied after `ignored_layers`; ignored in offline mode. Default of `5` is the evaluated recommended value for Wan2.2-A14B |
+| `ignored_layers` | list[str] | `[]` | Exact runtime Linear module paths to keep in BF16. **Works in both modes**: offline — populated by the merge script for interleaved sensitive layers; online — user-supplied for explicit per-layer precision override |
+| `num_bf16_fallback_layers` | int | `5` | **Online mode only**: leading N transformer blocks (`blocks.0` … `blocks.N-1`) kept in BF16. Applied after `ignored_layers`; ignored in offline mode. Validate the default of `5` against the intended model and quality target |
+| `w4a8_fallback_layers` | list[str] | `[]` | Must remain empty; DualScale does not support W4A8 fallback |
+| `w4a8_fallback_steps` | list[int] | `[]` | Must remain empty; DualScale does not support W4A8 fallback |
 
 #### BF16 fallback priority (online mode)
 
-```
+```text
 for each linear layer:
     if prefix in ignored_layers               → BF16  (explicit override, highest priority)
     elif block_idx < num_bf16_fallback_layers → BF16  (coarse leading-block rule)
@@ -307,8 +501,9 @@ unless they appear in `ignored_layers`.
 
 1. **Online single-scale (`mxfp4`)** quantizes BF16 weights at load time using
    `npu_dynamic_mx_quant` (single-scale). No calibration `mul_scale` is
-   available — all output partitions receive an identity pre-scale. No offline
-   checkpoint format exists for this method.
+   available — all output partitions receive an identity pre-scale. Offline
+   single-scale checkpoints use the canonical numeric FP4 layout
+   described above.
 
 2. **Online dual-scale (`mxfp4_dualscale`, `is_checkpoint_serialized=False`)**
    quantizes BF16 weights using `npu_dynamic_dual_level_mx_quant` (fine + coarse
@@ -316,7 +511,7 @@ unless they appear in `ignored_layers`.
    explicit `ignored_layers` stay in BF16 for accuracy.
 
 3. **Offline dual-scale (`mxfp4_dualscale`, `is_checkpoint_serialized=True`)** —
-   **recommended for production** — loads four tensors per quantized layer: FP4
+   loads four tensors per quantized layer: FP4
    weight, fine scale (`uint8` reinterpreted as `float8_e8m0fnu`), coarse scale
    (`float32`), and per-input-channel `mul_scale` (`float32`). BF16 fallback
    layers have no quantization tensors and are routed via `ignored_layers`.
@@ -325,21 +520,21 @@ unless they appear in `ignored_layers`.
    layout as `float8_e8m0fnu`) and reinterpreted at load time without a lossy
    float32 round-trip.
 
-5. **Cascade model config propagation**: in a cascade model (transformer +
-   transformer_2), vLLM-Omni reads each transformer's own `config.json` and
-   rebuilds the quant config locally when `ignored_layers` differs between
-   transformers, ensuring per-layer routing is accurate for each. The first
-   transformer's config is propagated to `od_config` so the second transformer
-   can reuse it as a starting point.
+5. **Cascade model configuration**: checkpoint auto-detection resolves each
+   expert's own `config.json` independently; the first expert's detected config
+   is not reused as the second expert's policy. An explicit global runtime
+   config applies to both experts, while per-component configs select policies
+   by the exact `transformer` / `transformer_2` names. Serialized checkpoint
+   metadata still determines each expert's storage format and BF16 layers.
 
 6. **Self-attention QKV fusion**: Q, K, V projection weights are fused into a
    single `QKVParallelLinear` layer at runtime. `ignored_layers` entries use the
    fused name (`attn1.to_qkv`), written automatically by the merge script.
 
-7. W4A4 carries higher quantization noise than W8A8 (16 vs 256 levels). The
-   DualScale offline method mitigates this with calibrated `mul_scale` smooth
-   quantization. Use `ignored_layers` and `num_bf16_fallback_layers` to trade
-   off compression vs. accuracy for precision-sensitive layers.
+7. FP4 has fewer representable values than FP8, so evaluate quantization
+   error and generation quality for the chosen recipe. Offline Smooth scaling
+   and BF16 fallback can help with sensitive layers.
+   `num_bf16_fallback_layers` applies only to online DualScale.
 
 ## Adapting MXFP4 for a New Model
 
@@ -350,27 +545,26 @@ a merge script for offline checkpoints.
 
 ### Step 1 — Discover runtime layer names
 
-`ignored_layers` entries must match the **runtime parameter names** used inside
-vllm-omni, which may differ from the names stored in the diffusers checkpoint.
-The canonical source of truth is the model's own `named_parameters()`.
+`ignored_layers` entries use exact **runtime Linear module paths**, without
+`.weight`. Inspect the actual transformer instance in model initialization or
+a developer harness; `Omni` does not expose an `omni.pipeline.transformer` API.
+For a transformer instance named `transformer`:
 
 ```python
-from vllm_omni import Omni
+from vllm.model_executor.layers.linear import LinearBase
 
-# Load the model without quantization to inspect parameter names.
-omni = Omni(model="/path/to/your-model")  # no --quantization flag
-for name, _ in omni.pipeline.transformer.named_parameters():
-    if "weight" in name and "scale" not in name:
+for name, module in transformer.named_modules():
+    if isinstance(module, LinearBase):
         print(name)
 ```
 
-Compare the printed names against the diffusers checkpoint keys
+Compare these module paths against the corresponding diffusers checkpoint keys
 (`safetensors.safe_open` or `torch.load`) to identify any renames your model
 applies. Common patterns that differ in Wan2.2 (and may appear in other
 models):
 
 | Diffusers checkpoint name | vllm-omni runtime name | Reason |
-|---------------------------|------------------------|--------|
+| --------------------------- | ------------------------ | -------- |
 | `attn1.to_q`, `attn1.to_k`, `attn1.to_v` | `attn1.to_qkv` | Self-attention Q/K/V fused into `QKVParallelLinear` |
 | `ffn.net.0.proj` | `ffn.net_0.proj` | Dots in sub-module names replaced with underscores |
 | `ffn.net.2` | `ffn.net_2` | Same underscore rule |
@@ -382,8 +576,9 @@ fused runtime parameters.
 
 !!! warning "Partial QKV fallback is not allowed"
     If your model fuses Q, K, V into a single layer, `ignored_layers` must
-    include **all three or none**. A partial fallback (e.g. `to_q` in BF16 but
-    `to_k`, `to_v` quantized) cannot be expressed at runtime because they share
+    name the fused runtime module (for Wan, `attn1.to_qkv`). The source
+    checkpoint must keep **all three or none** in BF16. A partial fallback
+    (e.g. `to_q` in BF16 but `to_k`, `to_v` quantized) cannot be expressed at runtime because they share
     one `QKVParallelLinear`. The merge script enforces this and raises an error
     if only some of the trio appear as non-quantized.
 
@@ -392,12 +587,13 @@ fused runtime parameters.
 #### Online mode
 
 Pass `ignored_layers` directly in the quantization config using the **runtime
-names** discovered in Step 1. No code changes to the model are required.
+names** discovered in Step 1. This assumes the model already passes its
+quantization config and module prefixes to compatible vLLM Linear layers.
 
 ```python
 omni = Omni(
     model="/path/to/your-model",
-    quantization={
+    quantization_config={
         "method": "mxfp4_dualscale",
         "ignored_layers": [
             "blocks.0.attn1.to_qkv",   # runtime name, not diffusers name
@@ -409,9 +605,14 @@ omni = Omni(
 ```
 
 ```bash
-# CLI does not support list-typed ignored_layers directly.
-# Use the Python API or set ignored_layers in config.json (offline).
-python your_script.py --model /path/to/your-model --quantization mxfp4_dualscale
+# The text-to-video example accepts list-valued fields through JSON.
+python examples/offline_inference/text_to_video/text_to_video.py \
+    --model /path/to/your-model \
+    --quantization-config '{"method":"mxfp4_dualscale","ignored_layers":["blocks.0.attn1.to_qkv"]}'
+
+# Serving accepts the same configuration.
+vllm serve /path/to/your-model --omni \
+    --diffusion-quantization-config '{"method":"mxfp4_dualscale","ignored_layers":["blocks.0.attn1.to_qkv"]}'
 ```
 
 The `num_bf16_fallback_layers` coarse rule is an alternative to listing layers
@@ -436,9 +637,13 @@ the merge script is correct. The injected block:
 }
 ```
 
-To add a layer manually (e.g. to pin an additional layer to BF16 without
-re-running the merge script), edit `config.json` inside the transformer
-subfolder. Use runtime names, not diffusers checkpoint names.
+Adding an offline BF16 fallback layer requires both the original BF16 weight
+from the base model and a matching `ignored_layers` entry. Regenerate the
+checkpoint with the revised storage policy, restoring the original weight
+(and bias, if present) and removing that layer's quantization tensors.
+Editing `config.json` alone does not reconstruct BF16 weights from stored FP4
+values. For fused QKV, restore all three projections together. Use runtime
+module paths in `ignored_layers`.
 
 ### Step 3 — Write a merge script for offline mode
 
@@ -474,6 +679,7 @@ renaming rules and collect the results.
 !!! tip "Validate before serving"
     After producing the offline checkpoint, load it without a `--quantization`
     flag and verify that vLLM-Omni auto-detects the correct method. Check that
-    the layer count reported in the startup log matches expectations: quantized
-    layer count + `ignored_layers` count should equal total linear layer count.
-    Any mismatch indicates a name-mapping bug in the merge script.
+    each intended runtime Linear module resolves to the expected quantized or
+    BF16 method and that every BF16 entry has original BF16 weights. Account
+    for fused modules and, in online DualScale, the leading-block fallback rule;
+    the raw length of `ignored_layers` alone is not a reliable layer count.
diff --git a/docs/user_guide/quantization/overview.md b/docs/user_guide/quantization/overview.md
index 8319077a2..7e7452bec 100644
--- a/docs/user_guide/quantization/overview.md
+++ b/docs/user_guide/quantization/overview.md
@@ -13,7 +13,7 @@ For the internal architecture and backend extension points, see the
 | Mode | Guide | Description | Methods |
 | ------ | ------- | ------------- | --------- |
 | Online quantization | [Online Quantization](online.md) | vLLM-Omni computes quantized weights and scales while loading the model. | FP8 W8A8, Int8 W8A8, BitsAndBytes W4, MXFP8 W8A8, MXFP4 W4A4 |
-| Runtime attention quantization | [Quantized KV Cache](quantized_kvcache.md) | vLLM-Omni dynamically quantizes eligible diffusion Flash Attention tensors during inference. | FP8 FA |
+| Runtime attention quantization | [Quantized KV Cache](quantized_kvcache.md) | vLLM-Omni dynamically quantizes eligible diffusion attention tensors during inference. | FP8, MXFP8, MXFP4 |
 | Pre-quantized checkpoints | Method-specific guides | The checkpoint or an offline quantizer provides quantized weights and scales before serving. | ModelOpt, AutoRound, TorchAO, msModelSlim, serialized Int8, offline MXFP8, offline MXFP4 DualScale |
 
 ## Hardware Support
diff --git a/docs/user_guide/quantization/quantized_kvcache.md b/docs/user_guide/quantization/quantized_kvcache.md
index 99a90e08a..30ba53593 100644
--- a/docs/user_guide/quantization/quantized_kvcache.md
+++ b/docs/user_guide/quantization/quantized_kvcache.md
@@ -2,41 +2,36 @@
 
 ## Overview
 
-In DiT-based image and video generation, Flash Attention can take a large share
-of denoising time, especially for high-resolution or long-frame workloads.
-vLLM-Omni supports online FP8 quantization for eligible diffusion Flash
-Attention (FA) to reduce FA latency while keeping model weights in their
-original dtype.
+In DiT-based image and video generation, attention can take a large share of
+denoising time, especially for high-resolution or long-frame workloads.
+vLLM-Omni supports online Q/K/V quantization for eligible diffusion attention
+paths while keeping model weights in their original dtype.
 
-This feature is configured through `diffusion_kv_cache_dtype` on
-`OmniDiffusionConfig` (CLI: `--diffusion-kv-cache-dtype`). It is intentionally
-**not** the same as vLLM's `--kv-cache-dtype`, which controls autoregressive
-language-model KV cache storage and defaults to `"auto"`. Diffusion FA
-quantization uses the dedicated diffusion flags so omni serve does not inherit
-that default.
+Runtime attention precision is configured through `diffusion_kv_cache_dtype`
+on `OmniDiffusionConfig` (CLI: `--diffusion-kv-cache-dtype`). This setting is
+separate from vLLM's `--kv-cache-dtype`, which controls autoregressive
+language-model KV cache storage.
 
 In vLLM-Omni diffusion pipelines, this is a runtime FA path: Q/K/V tensors are
 dynamically quantized before the attention operator. It does not quantize model
 weights and is separate from [FP8 W8A8](fp8.md), [Int8 W8A8](int8.md), or
 pre-quantized checkpoint formats.
 
-If `diffusion_kv_cache_dtype` is not set, behavior is unchanged and attention
-runs in the native dtype.
+If `diffusion_kv_cache_dtype` is not set, attention runs in the native dtype.
 
 ## Hardware Support
 
-| Device | FP8 FA |
-|--------|--------|
-| Ascend NPU | ✅ |
-| NVIDIA GPU | ❌ |
-| AMD ROCm | ❌ |
-| Intel XPU | ❌ |
+| Device | Dense FP8 | Dense MXFP8/MXFP4 | BSA FP8/MXFP4 |
+|--------|------------|-------------------|----------------|
+| Ascend NPU | ✅ | ✅ | ✅ |
+| NVIDIA GPU | ❌ | ❌ | ❌ |
+| AMD ROCm | ❌ | ❌ | ❌ |
+| Intel XPU | ❌ | ❌ | ❌ |
 
 Legend: `✅` supported, `❌` unsupported.
 
-FP8 FA is currently implemented only for the NPU Flash Attention backend. Other
-backends do not support `diffusion_kv_cache_dtype="fp8"` for diffusion attention
-and fall back to native dtype execution.
+These runtime methods are implemented only by the NPU Flash Attention and BSA
+backends. Other backends reject an incompatible explicit configuration.
 
 ## Model Type Support
 
@@ -44,7 +39,7 @@ and fall back to native dtype execution.
 
 | Model | Scope | Status | Notes |
 |-------|-------|--------|-------|
-| Wan2.2 | Eligible DiT full-attention FA on Ascend NPU | Tested | Compare quality and latency against a BF16 baseline before production use |
+| Wan2.2 | Self-attention on Ascend NPU | NPU interface and T2V smoke tested | Compare quality and latency against a BF16 baseline before production use |
 | Other diffusion models | Eligible DiT full-attention FA on Ascend NPU | Not tested | You can try `diffusion_kv_cache_dtype="fp8"`; tune `diffusion_kv_cache_skip_steps` and `diffusion_kv_cache_skip_layers` when higher precision is needed |
 
 ### Multi-Stage Omni/TTS Model (Qwen3-Omni, Qwen3-TTS)
@@ -105,12 +100,13 @@ The legacy keyword aliases `kv_cache_dtype`, `kv_cache_skip_steps`, and
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `diffusion_kv_cache_dtype` | str \| None | `None` | Set to `"fp8"` to enable dynamic FP8 FA on supported attention backends |
+| `diffusion_kv_cache_dtype` | str \| None | `None` | Runtime attention method. Dense FA supports `fp8`, `mxfp8`, and `mxfp4`; BSA supports `fp8` and `mxfp4` |
 | `diffusion_kv_cache_skip_steps` | str \| None | `None` | Denoising step selector to keep in native dtype, for example `"0,1,4-6"` |
 | `diffusion_kv_cache_skip_layers` | str \| None | `None` | Transformer layer selector to keep in native dtype, for example `"0-2,10"` |
 
 Selectors use comma-separated integers and inclusive ranges. Listed steps or
-layers skip FP8 FA; all other eligible full-attention forwards use the FP8 path.
+layers run floating-point attention through the selected Dense or BSA backend;
+all other eligible forwards use `diffusion_kv_cache_dtype`.
 
 ## Validation and Notes
 
@@ -123,3 +119,60 @@ layers skip FP8 FA; all other eligible full-attention forwards use the FP8 path.
 4. Report both latency and quality results when enabling this option for a new
    model. For image or video models, include visual comparison and quantitative
    metrics when available, such as PSNR or SSIM.
+
+## Wan2.2 T2V quantized attention on Ascend
+
+Wan2.2 T2V A14B supports quantized self-attention through MindIE-SD. Model
+weights are unchanged, and model-level opt-out keeps cross-attention in its
+native dtype.
+
+| Attention path | self-attention `backend` | Supported `diffusion_kv_cache_dtype` |
+| --- | --- | --- |
+| Dense FA | `FLASH_ATTN` | `fp8`, `mxfp8`, `mxfp4` |
+| BSA | `RAINFUSION_ATTN` | `fp8`, `mxfp4` |
+
+Configure the method and fallback selectors once at the diffusion stage. The
+per-role attention config only selects the self-attention backend:
+
+```yaml
+stages:
+  - stage_id: 0
+    diffusion_kv_cache_dtype: "mxfp8"
+    diffusion_kv_cache_skip_layers: "0,39"
+    diffusion_kv_cache_skip_steps: "0,1,38,39"
+    diffusion_attention_config:
+      per_role:
+        self:
+          backend: FLASH_ATTN  # Use RAINFUSION_ATTN with fp8 or mxfp4 for BSA.
+```
+
+For 40 denoising steps, `diffusion_kv_cache_skip_steps: "0,1,38,39"` and
+`diffusion_kv_cache_skip_layers: "0,39"` are recommended starting points. Steps
+are zero-based across the complete request and do not reset when Wan switches
+transformers; layer indices are zero-based and local to each transformer.
+Selectors accept comma-separated indices and inclusive ranges such as
+`"0,3-5"`. A selected forward uses floating-point attention while preserving
+the Dense or BSA path.
+
+Unsupported precision/input combinations raise an error and must be corrected
+in the configuration; operator errors are not retried with another precision.
+
+For BSA, change the backend to `RAINFUSION_ATTN` and set
+`diffusion_kv_cache_dtype` to `fp8` or `mxfp4`.
+See [RainFusion attention](../diffusion/attention_backends/rainfusion.md) for
+sparse-path configuration and behavior.
+
+### Requirement and interface test
+
+Until these APIs are available in a MindIE-SD release, use revision
+[`8637b5333b0225381b215390fd09a8732e671cc4`](https://gitcode.com/zqxu/MindIE-SD/commit/8637b5333b0225381b215390fd09a8732e671cc4).
+Build the Python package, PyTorch plugin, and custom operators from that same
+checkout. With CANN sourced, run the NPU interface tests from the Omni checkout:
+
+```bash
+python -m pytest tests/platforms/npu/quant/test_kv_quant_npu.py \
+    -k real_npu -vv -s -o addopts=''
+```
+
+A skipped NPU test is not a pass. Validate generated video quality against a
+floating-point run with the same prompt, seed, resolution, and step count.
diff --git a/examples/model_display_names.yml b/examples/model_display_names.yml
index 7a04ff8fa..be4ba2f80 100644
--- a/examples/model_display_names.yml
+++ b/examples/model_display_names.yml
@@ -2,7 +2,6 @@
 # The docs generator combines these names with the serving mode for each page H1.
 aura_omni: AURA Omni
 covo_audio: Covo-Audio-Chat
-dynin_omni: Dynin-Omni
 lance: Lance
 mimo_audio: MiMo-Audio
 ming_flash_omni: Ming-flash-omni 2.0
diff --git a/examples/offline_inference/dynin_omni/README.md b/examples/offline_inference/dynin_omni/README.md
deleted file mode 100644
index 6cf834142..000000000
--- a/examples/offline_inference/dynin_omni/README.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# Dynin-Omni: Offline inference
-
-This folder contains a unified offline inference entrypoint:
-
-- `end2end.py`
-
-## 1. Environment Setup
-
-Run from repository root:
-
-```bash
-cd <REPO_ROOT>
-```
-
-If needed, install this repo in editable mode:
-
-```bash
-pip install -e .
-```
-
-## 2. Extra Dependencies (EMOVA)
-
-Install the following packages for EMOVA-related components:
-
-```bash
-pip install \
-  "phonemizer==3.3.0" \
-  "Unidecode==1.4.0" \
-  "hydra-core==1.3.2" \
-  "pytorch-lightning==1.1.0" \
-  "wget==3.2" \
-  "wrapt==2.1.1" \
-  "onnx==1.20.1" \
-  "frozendict==2.4.7" \
-  "inflect==7.5.0" \
-  "braceexpand==0.1.7" \
-  "webdataset==1.0.2" \
-  "torch-stft==0.1.4" \
-  "editdistance==0.8.1"
-```
-
-## 3. Hardware and VRAM Requirements
-
-This example uses a 3-stage pipeline on one GPU by default
-([`dynin_omni.yaml`](../../../vllm_omni/deploy/dynin_omni.yaml)):
-
-- Stage-0 (`token2text`): `gpu_memory_utilization: 0.5`
-- Stage-1 (`token2image`): `gpu_memory_utilization: 0.1`
-- Stage-2 (`token2audio`): `gpu_memory_utilization: 0.1`
-
-### Requested GPU Memory Budget from `gpu_memory_utilization`
-
-| Stage | Utilization | A100 80GB | H200 141GB |
-| :-- | :-- | :-- | :-- |
-| Stage-0 (token2text) | 0.5 | ~40.0 GB | ~70.5 GB |
-| Stage-1 (token2image) | 0.1 | ~8.0 GB | ~14.1 GB |
-| Stage-2 (token2audio) | 0.1 | ~8.0 GB | ~14.1 GB |
-| Total requested budget | 0.7 | ~56.0 GB | ~98.7 GB |
-
-### Observed Runtime Signal (from your log)
-
-- Stage-0 reported: `Model loading took 15.12 GiB memory` (weights footprint signal).
-- Stages 1/2 can still add runtime memory depending on task path and backend allocations.
-- Keep extra headroom for CUDA/PyTorch overhead and temporary allocations.
-
-### GPU Compatibility
-
-- Confirmed target GPUs for this setup: **NVIDIA H200**, **NVIDIA A100**.
-- CI/e2e coverage in this repo also includes CUDA **L4** markers for Dynin tests.
-
-## 4. End2End Run Examples
-
-```bash
-# t2t
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task t2t --model snu-aidas/Dynin-Omni --text <INSTRUCTION_TEXT>
-
-# i2t
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task i2t --model snu-aidas/Dynin-Omni --image <IMAGE_PATH> --text "Please describe this image in detail."
-
-# s2t
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task s2t --model snu-aidas/Dynin-Omni --audio <AUDIO_PATH> --text "Transcribe the given audio."
-
-# t2i
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task t2i --model snu-aidas/Dynin-Omni --text <INSTRUCTION_TEXT>
-
-# v2t
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task v2t --model snu-aidas/Dynin-Omni --video <VIDEO_PATH> --text "Describe this video in detail."
-
-# i2i
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task i2i --model snu-aidas/Dynin-Omni --image <IMAGE_PATH> --text <INSTRUCTION_TEXT>
-
-# t2s
-python <REPO_ROOT>/examples/offline_inference/dynin_omni/end2end.py \
-  --task t2s --model snu-aidas/Dynin-Omni --text <INSTRUCTION_TEXT>
-```
-
-## 5. Notes
-
-- Outputs are saved under task-specific directories in `/tmp` by default.
-- You can override output path with `--output-dir`.
-- If you want to force local config resolution, pass `--dynin-config-path <PATH_TO_DYNIN_OMNI_YAML>`.
-- If you see the warning
-  `max_num_batched_tokens (32768) exceeds max_num_seqs * max_model_len (4096)`,
-  reduce `max_num_batched_tokens` in the deploy config (for example, `4096` in the CI config).
diff --git a/examples/offline_inference/dynin_omni/end2end.py b/examples/offline_inference/dynin_omni/end2end.py
deleted file mode 100644
index 74d33fe01..000000000
--- a/examples/offline_inference/dynin_omni/end2end.py
+++ /dev/null
@@ -1,1448 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import re
-import sys
-import time
-import types
-from importlib.machinery import ModuleSpec
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-import torch
-from PIL import Image
-
-TASK_CHOICES = ("t2t", "t2i", "t2s", "i2i", "i2t", "s2t", "v2t")
-
-TASK_DEFAULT_RUNTIME = {
-    "t2t": ("mmu", "mmu", 0, "text"),
-    "t2i": ("t2i", "t2i_gen", 2, "image"),
-    "t2s": ("t2s_mmu_like", "t2s_gen", 1, "audio"),
-    "i2i": ("i2i", "i2i", 2, "image"),
-    "i2t": ("mmu", "mmu", 0, "text"),
-    "s2t": ("s2t", "s2t", 0, "text"),
-    "v2t": ("v2t", "v2t", 0, "text"),
-}
-
-TASK_RUNTIME_FALLBACKS: dict[str, dict[str, Any]] = {
-    "t2t": {
-        "output_dir": "/tmp/dynin_end2end_outputs",
-        "prompt_max_text_len": 1024,
-        "max_new_tokens": 1024,
-        "steps": 1024,
-        "block_length": 16,
-        "temperature": 0.0,
-        "cfg_scale": 0.0,
-    },
-    "t2i": {
-        "output_dir": "/tmp/dynin_t2i_outputs",
-        "prompt_max_text_len": 128,
-        "image_token_count": 1024,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "timesteps": 20,
-        "guidance_scale": 3.5,
-        "temperature": 1.0,
-    },
-    "i2i": {
-        "output_dir": "/tmp/dynin_i2i_outputs",
-        "prompt_max_text_len": 128,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "timesteps": 64,
-        "guidance_scale": 3.5,
-        "temperature": 1.0,
-        "image_resolution": 336,
-        "use_train_i2i_prompt": True,
-    },
-    "i2t": {
-        "output_dir": "/tmp/dynin_i2t_outputs",
-        "prompt_max_text_len": 128,
-        "max_new_tokens": 128,
-        "steps": 128,
-        "block_length": 2,
-        "temperature": 0.0,
-        "cfg_scale": 0.0,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "image_resolution": 480,
-        "remasking": "low_confidence",
-    },
-    "s2t": {
-        "output_dir": "/tmp/dynin_s2t_outputs",
-        "prompt_max_text_len": 1024,
-        "max_new_tokens": 128,
-        "steps": 128,
-        "block_length": 2,
-        "temperature": 0.0,
-        "cfg_scale": 0.0,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "remasking": "low_confidence",
-    },
-    "t2s": {
-        "output_dir": "/tmp/dynin_t2s_outputs",
-        "runtime_task": "t2s_mmu_like",
-        "prompting_task": "t2s_gen",
-        "prompt_max_text_len": 1024,
-        "t2s_token_length": 512,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "audio_codebook_size": 4096,
-        "steps": 512,
-        "block_length": 128,
-        "temperature": 1.0,
-        "cfg_scale": 2.5,
-        "t2s_condition": "gender-female_emotion-neutral_speed-normal_pitch-normal",
-    },
-    "v2t": {
-        "output_dir": "/tmp/dynin_v2t_outputs",
-        "prompt_max_text_len": 1024,
-        "max_new_tokens": 128,
-        "steps": 128,
-        "block_length": 2,
-        "temperature": 0.0,
-        "cfg_scale": 0.0,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "image_resolution": 224,
-        "num_frames": 5,
-        "remasking": "low_confidence",
-    },
-}
-
-DEFAULT_I2T_QUESTION = "Please describe this image in detail."
-DEFAULT_S2T_INSTRUCTION = "Transcribe the given audio."
-DEFAULT_V2T_QUESTION = "Please provide a detailed description of the video."
-DEFAULT_T2T_PROMPT = "Explain multimodal LLM inference in 3 sentences."
-DEFAULT_T2S_INSTRUCTION = "Convert the given text into spoken audio."
-DEFAULT_T2S_PROMPT = "Hello. This is a default text-to-speech sample."
-
-DYNIN_SPECIAL_TOKENS = (
-    "<|soi|>",
-    "<|eoi|>",
-    "<|sov|>",
-    "<|eov|>",
-    "<|t2i|>",
-    "<|mmu|>",
-    "<|t2v|>",
-    "<|v2v|>",
-    "<|lvg|>",
-    "<|i2i|>",
-    "<|ti2ti|>",
-    "<|v2t|>",
-    "<|v2s|>",
-    "<|s2t|>",
-    "<|t2s|>",
-    "<|s2s|>",
-    "<|soa|>",
-    "<|eoa|>",
-)
-
-
-def bootstrap_repo_path() -> Path:
-    repo_root = Path(__file__).resolve().parents[3]
-    repo_root_str = str(repo_root)
-    if repo_root_str not in sys.path:
-        sys.path.insert(0, repo_root_str)
-    return repo_root
-
-
-def ensure_safe_import_for_vllm() -> None:
-    os.environ.setdefault("TRANSFORMERS_NO_TORCHVISION", "1")
-    try:
-        import torchvision  # noqa: F401
-
-        return
-    except Exception:
-        pass
-
-    import enum
-
-    class _InterpolationMode(enum.Enum):
-        NEAREST = 0
-        BILINEAR = 2
-        BICUBIC = 3
-        LANCZOS = 1
-        HAMMING = 4
-        BOX = 5
-
-    tv_mod = types.ModuleType("torchvision")
-    tv_mod.__dict__["__version__"] = "0.0-stub"
-    tv_mod.__spec__ = ModuleSpec(name="torchvision", loader=None)
-    transforms_mod = types.ModuleType("torchvision.transforms")
-    transforms_mod.__spec__ = ModuleSpec(name="torchvision.transforms", loader=None)
-    transforms_mod.InterpolationMode = _InterpolationMode
-    tv_mod.transforms = transforms_mod
-    sys.modules["torchvision"] = tv_mod
-    sys.modules["torchvision.transforms"] = transforms_mod
-
-
-def sanitize_repo_id(repo_id: str) -> str:
-    return re.sub(r"[^a-zA-Z0-9._-]+", "_", repo_id)
-
-
-def is_hf_repo_id(value: str) -> bool:
-    return isinstance(value, str) and value.count("/") == 1 and all(value.split("/", 1))
-
-
-def ensure_local_model_dir(model: str, cache_dir: Path, localize: bool) -> Path:
-    model_path = Path(model).expanduser()
-    if model_path.is_dir():
-        return model_path.resolve()
-    if not localize:
-        return Path(model)
-
-    from huggingface_hub import snapshot_download
-
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    os.environ.setdefault("HF_HOME", str(cache_dir / ".hf_home"))
-    local_dir = cache_dir / sanitize_repo_id(model)
-    if not local_dir.exists():
-        print(f"[end2end] Downloading model into local cache: {local_dir}")
-        snapshot_download(
-            repo_id=model,
-            local_dir=str(local_dir),
-            local_dir_use_symlinks=True,
-            resume_download=True,
-        )
-    return local_dir.resolve()
-
-
-def resolve_local_only(
-    override: bool | None,
-    source: str,
-    default: bool,
-) -> bool:
-    if override is not None:
-        return bool(override)
-    return default or Path(source).expanduser().is_dir()
-
-
-def load_text_tokenizer(tokenizer_source: str, local_files_only: bool):
-    from transformers import AutoTokenizer
-
-    kwargs = {
-        "trust_remote_code": True,
-        "padding_side": "left",
-        "local_files_only": bool(local_files_only),
-    }
-    try:
-        tokenizer = AutoTokenizer.from_pretrained(tokenizer_source, **kwargs)
-    except TypeError:
-        kwargs.pop("local_files_only", None)
-        tokenizer = AutoTokenizer.from_pretrained(tokenizer_source, **kwargs)
-    return tokenizer
-
-
-def preprocess_image(image: Image.Image, resolution: int) -> torch.Tensor:
-    w, h = image.size
-    short_side = min(w, h)
-    scale = resolution / short_side
-    new_w, new_h = round(w * scale), round(h * scale)
-    image = image.resize((new_w, new_h), Image.BICUBIC)
-    left = (new_w - resolution) // 2
-    top = (new_h - resolution) // 2
-    image = image.crop((left, top, left + resolution, top + resolution))
-    arr = np.array(image, dtype=np.float32) / 255.0
-    tensor = torch.from_numpy(arr).permute(2, 0, 1)
-    return (tensor - 0.5) / 0.5
-
-
-def load_vq_image_encoder(source: str, local_files_only: bool, device: torch.device) -> Any:
-    from vllm_omni.model_executor.models.dynin_omni.dynin_omni_common import get_dynin_magvit_attr
-
-    MAGVITv2 = get_dynin_magvit_attr("MAGVITv2", source=source, local_files_only=local_files_only)
-    vq_model = MAGVITv2.from_pretrained(source, local_files_only=local_files_only).to(device)
-    vq_model.requires_grad_(False)
-    vq_model.eval()
-    return vq_model
-
-
-def encode_image_tokens(
-    image_path: Path,
-    vq_model: Any,
-    device: torch.device,
-    resolution: int,
-) -> torch.Tensor:
-    image = Image.open(image_path).convert("RGB")
-    image_tensor = preprocess_image(image, resolution=resolution).unsqueeze(0).to(device)
-    with torch.no_grad():
-        token_ids = vq_model.get_code(image_tensor)
-    token_ids = torch.as_tensor(token_ids, dtype=torch.long).detach().cpu()
-    if token_ids.ndim == 2 and token_ids.shape[0] == 1:
-        token_ids = token_ids[0]
-    return token_ids.contiguous()
-
-
-def encode_video_tokens(
-    video_path: Path,
-    vq_model: Any,
-    device: torch.device,
-    resolution: int,
-    num_frames: int,
-) -> torch.Tensor:
-    import cv2
-
-    cap = cv2.VideoCapture(str(video_path))
-    frames: list[np.ndarray] = []
-    while True:
-        ok, frame = cap.read()
-        if not ok:
-            break
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        frames.append(frame)
-    cap.release()
-    if not frames:
-        raise ValueError(f"Video has no readable frames: {video_path}")
-    if len(frames) < num_frames:
-        raise ValueError(f"Video has {len(frames)} frames, requires >= {num_frames}: {video_path}")
-
-    indices = np.linspace(0, len(frames) - 1, num_frames).astype(int)
-    token_list: list[torch.Tensor] = []
-    for idx in indices:
-        pil = Image.fromarray(frames[int(idx)])
-        frame_tensor = preprocess_image(pil, resolution=resolution).unsqueeze(0).to(device)
-        with torch.no_grad():
-            token_list.append(torch.as_tensor(vq_model.get_code(frame_tensor), dtype=torch.long))
-    merged = torch.cat(token_list, dim=1).detach().cpu()
-    if merged.ndim == 2 and merged.shape[0] == 1:
-        merged = merged[0]
-    return merged.contiguous()
-
-
-def load_vq_audio_encoder(source: str, local_files_only: bool, device: torch.device) -> Any:
-    from transformers import AutoModel
-
-    kwargs = {
-        "trust_remote_code": True,
-        "local_files_only": bool(local_files_only),
-        "low_cpu_mem_usage": False,
-    }
-    try:
-        model = AutoModel.from_pretrained(source, **kwargs)
-    except TypeError:
-        kwargs.pop("low_cpu_mem_usage", None)
-        try:
-            model = AutoModel.from_pretrained(source, **kwargs)
-        except TypeError:
-            kwargs.pop("local_files_only", None)
-            model = AutoModel.from_pretrained(source, **kwargs)
-    model.requires_grad_(False)
-    model.eval()
-    if hasattr(model, "to"):
-        model = model.to(device)
-    return model
-
-
-def encode_audio_tokens(audio_path: Path, vq_audio_model: Any) -> torch.Tensor:
-    encoded = vq_audio_model.encode(str(audio_path))
-    if isinstance(encoded, dict):
-        for key in ("input_ids", "token_ids", "codes", "tokens"):
-            if key in encoded:
-                encoded = encoded[key]
-                break
-    encoded = torch.as_tensor(encoded, dtype=torch.long).detach().cpu()
-    if encoded.ndim == 1:
-        encoded = encoded.unsqueeze(0)
-    elif encoded.ndim > 2:
-        encoded = encoded.view(encoded.shape[0], -1)
-    return encoded.contiguous()
-
-
-def build_chat_prompt(content: str) -> str:
-    return (
-        f"<|start_header_id|>user<|end_header_id|>\n{content}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n"
-    )
-
-
-def resolve_task_text(
-    *,
-    task_name: str,
-    text: str,
-    instruction: str = "",
-    raw_prompt: bool = False,
-) -> str:
-    text = str(text or "").strip()
-
-    if task_name == "t2t" and not text:
-        return DEFAULT_T2T_PROMPT
-    if task_name == "i2t" and not text:
-        return DEFAULT_I2T_QUESTION
-    if task_name == "s2t" and not text:
-        return DEFAULT_S2T_INSTRUCTION
-    if task_name == "v2t" and not text:
-        return DEFAULT_V2T_QUESTION
-    if task_name in {"t2i", "i2i"} and not text:
-        return "A high quality detailed image."
-
-    if task_name != "t2s":
-        return text
-
-    if not text:
-        text = DEFAULT_T2S_PROMPT
-
-    if raw_prompt:
-        return text
-
-    instruction = str(instruction or "").strip() or DEFAULT_T2S_INSTRUCTION
-    return build_chat_prompt(f"{instruction}\n{text}")
-
-
-def load_universal_prompting(
-    *,
-    tokenizer: Any,
-    tokenizer_source: str,
-    max_text_len: int,
-    cond_dropout_prob: float,
-    local_files_only: bool,
-    max_audio_len: int = 512,
-    max_audio_len_short: int = 256,
-) -> Any:
-    from vllm_omni.model_executor.models.dynin_omni.dynin_omni_common import (
-        DYNIN_REMOTE_SETTINGS,
-        resolve_remote_attr,
-    )
-
-    UniversalPrompting = resolve_remote_attr(
-        "UniversalPrompting",
-        module_name="prompting_utils",
-        settings=DYNIN_REMOTE_SETTINGS,
-        source=tokenizer_source,
-        local_files_only=bool(local_files_only),
-        fallback_module_names=("modeling_dynin_omni",),
-    )
-    init_kwargs: dict[str, Any] = {
-        "max_text_len": int(max_text_len),
-        "special_tokens": DYNIN_SPECIAL_TOKENS,
-        "ignore_id": -100,
-        "cond_dropout_prob": float(cond_dropout_prob),
-        "use_reserved_token": True,
-        "max_audio_len": int(max_audio_len),
-        "max_audio_len_short": int(max_audio_len_short),
-    }
-    try:
-        return UniversalPrompting(tokenizer, **init_kwargs)
-    except TypeError:
-        init_kwargs.pop("max_audio_len", None)
-        init_kwargs.pop("max_audio_len_short", None)
-        return UniversalPrompting(tokenizer, **init_kwargs)
-
-
-def _runtime_fallback(task: str, key: str, value: Any) -> Any:
-    if isinstance(value, str):
-        if value.strip() != "":
-            return value
-    elif value is not None:
-        return value
-    return TASK_RUNTIME_FALLBACKS.get(task, {}).get(key)
-
-
-def _validate_generation_args(*, task: str, max_new_tokens: int, steps: int, block_length: int) -> None:
-    # Keep i2t/v2t generation constraints aligned with i2t.py/v2t.py.
-    if task not in {"i2t", "v2t"}:
-        return
-    if max_new_tokens <= 0:
-        raise ValueError(f"{task} requires max_new_tokens > 0.")
-    if block_length <= 0:
-        raise ValueError(f"{task} requires block_length > 0.")
-    if steps <= 0:
-        raise ValueError(f"{task} requires steps > 0.")
-    if max_new_tokens % block_length != 0:
-        raise ValueError(f"{task} requires max_new_tokens % block_length == 0, got {max_new_tokens} % {block_length}")
-    num_blocks = max_new_tokens // block_length
-    if num_blocks <= 0:
-        raise ValueError(f"{task} has invalid num_blocks.")
-    if steps % num_blocks != 0:
-        raise ValueError(
-            f"{task} requires steps % (max_new_tokens // block_length) == 0, "
-            f"got steps={steps}, max_new_tokens={max_new_tokens}, block_length={block_length}"
-        )
-
-
-def make_prompt_payload(
-    *,
-    task: str,
-    text: str,
-    image_tokens: torch.Tensor | None,
-    audio_tokens: torch.Tensor | None,
-    video_tokens: torch.Tensor | None,
-    image_placeholder_tokens: int,
-    audio_placeholder_tokens: int,
-    image_token_offset: int,
-    speech_token_offset: int,
-    mask_token_id: int,
-    use_train_i2i_prompt: bool,
-) -> tuple[Any, str]:
-    runtime_task, prompting_task, _, _ = TASK_DEFAULT_RUNTIME[task]
-    del runtime_task
-
-    if task == "t2t":
-        payload = ([[]], [build_chat_prompt(text)])
-        return payload, prompting_task
-
-    if task == "i2t":
-        if image_tokens is None:
-            raise ValueError("i2t requires image tokens")
-        img = image_tokens.view(-1).long() + int(image_token_offset)
-        payload = ([[img]], [build_chat_prompt(text)])
-        return payload, prompting_task
-
-    if task == "s2t":
-        if audio_tokens is None:
-            raise ValueError("s2t requires audio tokens")
-        aud = audio_tokens.long() + int(speech_token_offset)
-        if aud.ndim == 1:
-            aud = aud.unsqueeze(0)
-        payload = ([aud], [build_chat_prompt(text)])
-        return payload, prompting_task
-
-    if task == "v2t":
-        if video_tokens is None:
-            raise ValueError("v2t requires video tokens")
-        vid = video_tokens.view(-1).long() + int(image_token_offset)
-        payload = (vid.unsqueeze(0), [build_chat_prompt(text)])
-        return payload, prompting_task
-
-    if task == "t2i":
-        image_placeholder = torch.full(
-            (1, int(image_placeholder_tokens)),
-            fill_value=int(mask_token_id),
-            dtype=torch.long,
-        )
-        payload = ([text], image_placeholder)
-        return payload, prompting_task
-
-    if task == "i2i":
-        if image_tokens is None:
-            raise ValueError("i2i requires image tokens")
-        src = image_tokens.view(1, -1).long() + int(image_token_offset)
-        target_len = int(image_placeholder_tokens) if image_placeholder_tokens > 0 else int(src.shape[1])
-        image_placeholder = torch.full(
-            (1, target_len),
-            fill_value=int(mask_token_id),
-            dtype=torch.long,
-        )
-        if use_train_i2i_prompt:
-            labels_placeholder = torch.full(
-                (1, target_len),
-                fill_value=-100,
-                dtype=torch.long,
-            )
-            payload = ([text], src, image_placeholder, labels_placeholder)
-            return payload, "i2i"
-        payload = ([text], src, image_placeholder)
-        return payload, "i2i_gen"
-
-    if task == "t2s":
-        audio_placeholder = torch.full(
-            (1, int(audio_placeholder_tokens)),
-            fill_value=int(mask_token_id),
-            dtype=torch.long,
-        )
-        payload = ([text], audio_placeholder)
-        return payload, prompting_task
-
-    raise ValueError(f"Unsupported task: {task}")
-
-
-def _to_1d_int_list(value: Any) -> list[int]:
-    if value is None:
-        return []
-    if isinstance(value, torch.Tensor):
-        tensor = value.detach().to(device="cpu", dtype=torch.long)
-    else:
-        tensor = torch.as_tensor(value, dtype=torch.long)
-    if tensor.ndim == 0:
-        tensor = tensor.view(1)
-    elif tensor.ndim >= 2:
-        tensor = tensor.view(tensor.shape[0], -1)[0]
-    return [int(v) for v in tensor.tolist()]
-
-
-def _run_uni_prompting(uni_prompting: Any, payload: Any, prompting_task: str) -> tuple[list[int], list[int]]:
-    prepared = uni_prompting(payload, prompting_task)
-    if isinstance(prepared, tuple):
-        prepared_input_ids = prepared[0] if len(prepared) > 0 else None
-        prepared_attention_mask = prepared[1] if len(prepared) > 1 else None
-    else:
-        prepared_input_ids = prepared
-        prepared_attention_mask = None
-
-    input_ids = _to_1d_int_list(prepared_input_ids)
-    attention_mask = _to_1d_int_list(prepared_attention_mask)
-    if not input_ids:
-        raise RuntimeError(f"UniversalPrompting returned empty input_ids for task={prompting_task}")
-    return input_ids, attention_mask
-
-
-def _get_special_token_id(uni_prompting: Any, token: str) -> int:
-    sptids = getattr(uni_prompting, "sptids_dict", None) or {}
-    if token not in sptids:
-        raise KeyError(f"Special token not found in UniversalPrompting.sptids_dict: {token}")
-    token_ids = _to_1d_int_list(sptids[token])
-    if not token_ids:
-        raise ValueError(f"Special token id is empty for token: {token}")
-    return int(token_ids[0])
-
-
-def _tokenize_chat_query(tokenizer: Any, text: str) -> list[int]:
-    encoded = tokenizer(build_chat_prompt(text), return_tensors="pt").input_ids[0]
-    token_ids = _to_1d_int_list(encoded)
-    if not token_ids:
-        raise RuntimeError("Failed to tokenize chat query text.")
-    return token_ids
-
-
-def _flatten_media_token_ids_with_offset(token_ids: Any, token_offset: int) -> list[int]:
-    media_ids = token_ids
-    if isinstance(media_ids, torch.Tensor):
-        media_ids = media_ids.detach().cpu().reshape(-1).tolist()
-    else:
-        media_ids = np.asarray(media_ids).reshape(-1).tolist()
-    return [int(x) + int(token_offset) for x in media_ids]
-
-
-def _scalar_token_id(value: Any) -> int:
-    if isinstance(value, torch.Tensor):
-        if value.numel() == 0:
-            raise ValueError("Empty special-token tensor.")
-        return int(value.view(-1)[0].item())
-    if isinstance(value, (list, tuple)):
-        if not value:
-            raise ValueError("Empty special-token list.")
-        return int(value[0])
-    return int(value)
-
-
-def build_v2t_input_ids(
-    *,
-    video_token_ids: Any,
-    tokenizer: Any,
-    uni_prompting: Any,
-    question: str,
-    image_token_offset: int,
-) -> tuple[list[int], str]:
-    media_ids = video_token_ids
-    if isinstance(media_ids, torch.Tensor):
-        media_ids = media_ids.detach().cpu().reshape(-1).tolist()
-    else:
-        media_ids = np.asarray(media_ids).reshape(-1).tolist()
-    media_ids = [int(x) + int(image_token_offset) for x in media_ids]
-
-    sptids = uni_prompting.sptids_dict
-    task_id = _scalar_token_id(sptids["<|v2t|>"])
-    soi_id = _scalar_token_id(sptids["<|soi|>"])
-    eoi_id = _scalar_token_id(sptids["<|eoi|>"])
-    sot_id = _scalar_token_id(sptids["<|sot|>"])
-
-    prompt_text = build_v2t_chat_prompt(question)
-    query_ids = tokenizer(prompt_text, return_tensors="pt").input_ids[0].detach().cpu().tolist()
-    input_ids = [task_id, soi_id] + media_ids + [eoi_id, sot_id] + [int(v) for v in query_ids]
-    return input_ids, prompt_text
-
-
-def build_i2t_input_ids(
-    *,
-    image_token_ids: Any,
-    tokenizer: Any,
-    uni_prompting: Any,
-    question: str,
-    image_token_offset: int,
-) -> tuple[list[int], str]:
-    image_ids = image_token_ids
-    if isinstance(image_ids, torch.Tensor):
-        image_ids = image_ids.detach().cpu().reshape(-1).tolist()
-    else:
-        image_ids = np.asarray(image_ids).reshape(-1).tolist()
-    image_ids = [int(x) + int(image_token_offset) for x in image_ids]
-
-    sptids = uni_prompting.sptids_dict
-    task_id = _scalar_token_id(sptids["<|mmu|>"])
-    soi_id = _scalar_token_id(sptids["<|soi|>"])
-    eoi_id = _scalar_token_id(sptids["<|eoi|>"])
-    sot_id = _scalar_token_id(sptids["<|sot|>"])
-
-    prompt_text = build_i2t_chat_prompt(question)
-    query_ids = tokenizer(prompt_text, return_tensors="pt").input_ids[0].detach().cpu().tolist()
-    input_ids = [task_id, soi_id] + image_ids + [eoi_id, sot_id] + [int(v) for v in query_ids]
-    return input_ids, prompt_text
-
-
-def build_v2t_chat_prompt(question: str) -> str:
-    return (
-        f"<|start_header_id|>user<|end_header_id|>\n{question}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n"
-    )
-
-
-def build_i2t_chat_prompt(question: str) -> str:
-    return (
-        f"<|start_header_id|>user<|end_header_id|>\n{question}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n"
-    )
-
-
-def make_mmu_prompt(
-    *,
-    task: str,
-    text: str,
-    tokenizer: Any,
-    uni_prompting: Any,
-    image_tokens: torch.Tensor | None,
-    audio_tokens: torch.Tensor | None,
-    video_tokens: torch.Tensor | None,
-    image_token_offset: int,
-    speech_token_offset: int,
-) -> tuple[list[int], list[int]]:
-    query_ids = _tokenize_chat_query(tokenizer, text)
-
-    if task == "i2t":
-        token_ids, _ = build_i2t_input_ids(
-            image_token_ids=image_tokens,
-            tokenizer=tokenizer,
-            uni_prompting=uni_prompting,
-            question=text,
-            image_token_offset=int(image_token_offset),
-        )
-        token_ids = [int(v) for v in token_ids]
-        return token_ids, [1] * len(token_ids)
-
-    if task == "v2t":
-        token_ids, _ = build_v2t_input_ids(
-            video_token_ids=video_tokens,
-            tokenizer=tokenizer,
-            uni_prompting=uni_prompting,
-            question=text,
-            image_token_offset=int(image_token_offset),
-        )
-        token_ids = [int(v) for v in token_ids]
-        return token_ids, [1] * len(token_ids)
-
-    if task == "s2t":
-        if audio_tokens is None:
-            raise ValueError("s2t requires audio tokens")
-        audio_ids = _to_1d_int_list(audio_tokens.long() + int(speech_token_offset))
-        token_ids = [
-            _get_special_token_id(uni_prompting, "<|s2t|>"),
-            _get_special_token_id(uni_prompting, "<|soa|>"),
-            *audio_ids,
-            _get_special_token_id(uni_prompting, "<|eoa|>"),
-            *query_ids,
-        ]
-        return token_ids, [1] * len(token_ids)
-
-    raise ValueError(f"Unsupported task for validation-style MMU prompt: {task}")
-
-
-def iter_mm_outputs(outputs: list[Any]):
-    for omni_out in outputs:
-        req_out = omni_out
-        req_list = req_out if isinstance(req_out, list) else [req_out]
-        for item in req_list:
-            if item is None:
-                continue
-            mm_out = getattr(item, "multimodal_output", None) or {}
-            if mm_out:
-                yield mm_out
-            completions = getattr(item, "outputs", None) or []
-            for completion in completions:
-                c_mm_out = getattr(completion, "multimodal_output", None) or {}
-                if c_mm_out:
-                    yield c_mm_out
-        omni_mm = getattr(omni_out, "multimodal_output", None) or {}
-        if omni_mm:
-            yield omni_mm
-
-
-def _to_token_list(value: Any) -> list[int]:
-    if value is None:
-        return []
-    if hasattr(value, "detach"):
-        value = value.detach()
-    if hasattr(value, "cpu"):
-        value = value.cpu()
-    if hasattr(value, "flatten"):
-        value = value.flatten().tolist()
-    if isinstance(value, tuple):
-        value = list(value)
-    if not isinstance(value, list):
-        return []
-    out: list[int] = []
-    for token in value:
-        if isinstance(token, bool):
-            continue
-        try:
-            out.append(int(token))
-        except Exception:
-            continue
-    return out
-
-
-def extract_text_output(outputs: list[Any], tokenizer: Any) -> str:
-    for mm_out in iter_mm_outputs(outputs):
-        text = mm_out.get("text")
-        if isinstance(text, list) and text:
-            text = text[-1]
-        if isinstance(text, str) and text.strip():
-            return text.strip()
-        for key in ("text_tokens", "token_ids"):
-            token_ids = _to_token_list(mm_out.get(key))
-            if not token_ids:
-                continue
-            decoded = tokenizer.decode(token_ids, skip_special_tokens=True)
-            if isinstance(decoded, str) and decoded.strip():
-                return decoded.strip()
-    return ""
-
-
-def extract_image_output(outputs: list[Any]) -> torch.Tensor | None:
-    for mm_out in iter_mm_outputs(outputs):
-        image = mm_out.get("image")
-        if isinstance(image, list) and image:
-            image = image[-1]
-        if isinstance(image, torch.Tensor):
-            return image
-    return None
-
-
-def tensor_to_pil_image(image: torch.Tensor) -> Image.Image:
-    arr = image.detach().cpu().numpy()
-    if arr.ndim == 4:
-        arr = arr[0]
-    if arr.ndim == 3 and arr.shape[0] in (1, 3, 4):
-        arr = np.transpose(arr, (1, 2, 0))
-    if arr.dtype != np.uint8:
-        arr = arr.astype(np.float32)
-        if arr.max() <= 1.0:
-            arr = arr * 255.0
-        arr = np.clip(arr, 0.0, 255.0).astype(np.uint8)
-    if arr.ndim == 3 and arr.shape[-1] == 1:
-        arr = arr[..., 0]
-    return Image.fromarray(arr)
-
-
-def extract_audio_output(outputs: list[Any]) -> tuple[np.ndarray, int] | None:
-    for mm_out in iter_mm_outputs(outputs):
-        audio = mm_out.get("audio")
-        if audio is None:
-            audio = mm_out.get("speech")
-        if audio is None:
-            continue
-
-        def _to_wav_array(value: Any) -> np.ndarray:
-            if isinstance(value, torch.Tensor):
-                return value.detach().cpu().numpy().reshape(-1).astype(np.float32)
-            return np.asarray(value).reshape(-1).astype(np.float32)
-
-        if isinstance(audio, list):
-            chunks = [_to_wav_array(chunk) for chunk in audio]
-            wav = np.concatenate(chunks, axis=0) if chunks else np.zeros((0,), dtype=np.float32)
-        else:
-            wav = _to_wav_array(audio)
-        sr = mm_out.get("sr", 24000)
-        if hasattr(sr, "item"):
-            try:
-                sr = int(sr.item())
-            except Exception:
-                sr = 24000
-        elif isinstance(sr, list):
-            sr = int(sr[0]) if sr else 24000
-        else:
-            sr = int(sr)
-        return wav, sr
-    return None
-
-
-def save_audio_wav(path: Path, wav: np.ndarray, sr: int) -> None:
-    try:
-        import soundfile as sf
-
-        sf.write(str(path), wav, int(sr), format="WAV")
-    except Exception:
-        from scipy.io import wavfile
-
-        wav_i16 = np.clip(wav, -1.0, 1.0)
-        wav_i16 = (wav_i16 * 32767.0).astype(np.int16)
-        wavfile.write(str(path), int(sr), wav_i16)
-
-
-def parse_args(repo_root: Path) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Dynin-Omni unified offline end2end example.")
-    parser.add_argument("--task", type=str, required=True, choices=TASK_CHOICES)
-    parser.add_argument("--model", type=str, required=True, help="HF repo id or local model directory.")
-    parser.add_argument(
-        "--deploy-config",
-        type=str,
-        default=str(repo_root / "vllm_omni/deploy/dynin_omni.yaml"),
-        help="Path to deploy config yaml.",
-    )
-    parser.add_argument(
-        "--dynin-config-path",
-        type=str,
-        default="",
-        help="Path to DYNIN config yaml (passed through additional_information).",
-    )
-    parser.add_argument(
-        "--model-cache-dir",
-        type=str,
-        default="/tmp/dynin_localized_models",
-        help="Cache directory used when --model is HF repo id.",
-    )
-    parser.add_argument(
-        "--localize-model",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-        help="If true and --model is HF repo id, snapshot it under --model-cache-dir.",
-    )
-    parser.add_argument("--text", type=str, default="", help="Prompt/edit/question text.")
-    parser.add_argument("--instruction", type=str, default="", help="Optional extra instruction.")
-    parser.add_argument("--raw-prompt", action=argparse.BooleanOptionalAction, default=False)
-    parser.add_argument("--image", type=str, default="", help="Input image path for i2i/i2t.")
-    parser.add_argument("--audio", type=str, default="", help="Input audio path for s2t.")
-    parser.add_argument("--video", type=str, default="", help="Input video path for v2t.")
-    parser.add_argument("--image-resolution", type=int, default=None)
-    parser.add_argument("--num-frames", type=int, default=None)
-    parser.add_argument(
-        "--output-dir",
-        type=str,
-        default="",
-        help="Directory for generated outputs.",
-    )
-    parser.add_argument("--output-prefix", type=str, default="")
-    parser.add_argument("--seed", type=int, default=0)
-    parser.add_argument("--dtype", type=str, default="auto")
-    parser.add_argument("--max-tokens-per-stage", type=int, default=1)
-
-    parser.add_argument("--runtime-task", type=str, default="", help="Override runtime task key.")
-    parser.add_argument("--prompting-task", type=str, default="", help="Override prompting task key.")
-    parser.add_argument("--detok-id", type=int, default=None, help="Override detok id.")
-
-    parser.add_argument("--prompt-max-text-len", type=int, default=None)
-    parser.add_argument("--cond-dropout-prob", type=float, default=0.0)
-    parser.add_argument("--max-new-tokens", type=int, default=None)
-    parser.add_argument("--steps", type=int, default=None)
-    parser.add_argument("--block-length", type=int, default=None)
-    parser.add_argument("--temperature", type=float, default=None)
-    parser.add_argument("--cfg-scale", type=float, default=None)
-    parser.add_argument("--remasking", type=str, default="low_confidence")
-
-    parser.add_argument("--timesteps", type=int, default=None)
-    parser.add_argument("--guidance-scale", type=float, default=None)
-    parser.add_argument("--noise-type", type=str, default="mask")
-    parser.add_argument("--noise-schedule-name", type=str, default="cosine")
-    parser.add_argument("--noise-schedule-params", type=str, default="{}")
-
-    parser.add_argument("--mask-token-id", type=int, default=None)
-    parser.add_argument("--codebook-size", type=int, default=None)
-    parser.add_argument("--audio-codebook-size", type=int, default=None)
-    parser.add_argument("--image-token-count", type=int, default=None)
-    parser.add_argument("--t2s-token-length", type=int, default=None)
-    parser.add_argument(
-        "--t2s-condition",
-        type=str,
-        default="",
-    )
-    parser.add_argument(
-        "--use-train-i2i-prompt",
-        action="store_true",
-        help="Use i2i training prompt template (default behavior of i2i.py).",
-    )
-    parser.add_argument(
-        "--no-use-train-i2i-prompt",
-        dest="use_train_i2i_prompt",
-        action="store_false",
-        help="Use i2i_gen prompt template.",
-    )
-    parser.set_defaults(use_train_i2i_prompt=None)
-
-    parser.add_argument("--tokenizer-path", type=str, default="")
-    parser.add_argument("--model-local-files-only", action=argparse.BooleanOptionalAction, default=None)
-    parser.add_argument("--tokenizer-local-files-only", action=argparse.BooleanOptionalAction, default=None)
-
-    parser.add_argument("--vq-model-image-path", type=str, default="")
-    parser.add_argument("--vq-model-image-local-files-only", action=argparse.BooleanOptionalAction, default=None)
-    parser.add_argument("--vq-model-audio-path", type=str, default="")
-    parser.add_argument("--vq-model-audio-local-files-only", action=argparse.BooleanOptionalAction, default=None)
-
-    parser.add_argument("--disable-hf-xet", action=argparse.BooleanOptionalAction, default=True)
-    return parser.parse_args()
-
-
-def main() -> None:
-    repo_root = bootstrap_repo_path()
-    ensure_safe_import_for_vllm()
-    from vllm_omni.model_executor.models.dynin_omni.dynin_omni_common import (
-        DYNIN_PROMPT_SOURCE_KEY,
-        DYNIN_PROMPT_SOURCE_OFFLINE_PREBUILT,
-    )
-
-    args = parse_args(repo_root)
-
-    if args.disable_hf_xet:
-        os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
-
-    np.random.seed(args.seed)
-    torch.manual_seed(args.seed)
-
-    model_dir = ensure_local_model_dir(
-        model=args.model,
-        cache_dir=Path(args.model_cache_dir).expanduser(),
-        localize=bool(args.localize_model),
-    )
-    model_source = str(model_dir)
-
-    task_name = str(args.task)
-    dynin_config_path = str(Path(args.dynin_config_path).expanduser())
-    os.environ["DYNIN_CONFIG_PATH"] = dynin_config_path
-    default_runtime_task, default_prompting_task, default_detok_id, final_modality = TASK_DEFAULT_RUNTIME[task_name]
-    runtime_task = args.runtime_task.strip() or str(
-        _runtime_fallback(task_name, "runtime_task", None) or default_runtime_task
-    )
-    prompting_task = args.prompting_task.strip() or str(
-        _runtime_fallback(task_name, "prompting_task", None) or default_prompting_task
-    )
-    detok_id_default = _runtime_fallback(task_name, "detok_id", None)
-    if detok_id_default is None:
-        detok_id_default = default_detok_id
-    detok_id = int(detok_id_default if args.detok_id is None else args.detok_id)
-
-    output_dir_default = _runtime_fallback(task_name, "output_dir", args.output_dir)
-    resolved_output_dir = str(output_dir_default or "/tmp/dynin_end2end_outputs")
-
-    image_resolution_value = _runtime_fallback(
-        task_name,
-        "image_resolution",
-        args.image_resolution,
-    )
-    if image_resolution_value is None:
-        image_resolution_value = 336
-    image_resolution = int(image_resolution_value)
-
-    num_frames_value = _runtime_fallback(
-        task_name,
-        "num_frames",
-        args.num_frames,
-    )
-    if num_frames_value is None:
-        num_frames_value = 8
-    num_frames = int(num_frames_value)
-
-    prompt_max_text_len_value = _runtime_fallback(
-        task_name,
-        "prompt_max_text_len",
-        args.prompt_max_text_len,
-    )
-    if prompt_max_text_len_value is None:
-        prompt_max_text_len_value = 1024
-    prompt_max_text_len = int(prompt_max_text_len_value)
-
-    max_new_tokens_value = _runtime_fallback(
-        task_name,
-        "max_new_tokens",
-        args.max_new_tokens,
-    )
-    if max_new_tokens_value is None:
-        max_new_tokens_value = 256
-    max_new_tokens = int(max_new_tokens_value)
-
-    steps_value = _runtime_fallback(
-        task_name,
-        "steps",
-        args.steps,
-    )
-    if steps_value is None:
-        steps_value = 256
-    steps = int(steps_value)
-
-    block_length_value = _runtime_fallback(
-        task_name,
-        "block_length",
-        args.block_length,
-    )
-    if block_length_value is None:
-        block_length_value = 2
-    block_length = int(block_length_value)
-
-    temperature_value = _runtime_fallback(
-        task_name,
-        "temperature",
-        args.temperature,
-    )
-    if temperature_value is None:
-        temperature_value = 0.0
-    temperature = float(temperature_value)
-
-    cfg_scale_value = _runtime_fallback(
-        task_name,
-        "cfg_scale",
-        args.cfg_scale,
-    )
-    if cfg_scale_value is None:
-        cfg_scale_value = 0.0
-    cfg_scale = float(cfg_scale_value)
-
-    remasking = str(_runtime_fallback(task_name, "remasking", args.remasking) or "low_confidence")
-
-    timesteps_value = _runtime_fallback(
-        task_name,
-        "timesteps",
-        args.timesteps,
-    )
-    if timesteps_value is None:
-        timesteps_value = 20
-    timesteps = int(timesteps_value)
-
-    guidance_scale_value = _runtime_fallback(
-        task_name,
-        "guidance_scale",
-        args.guidance_scale,
-    )
-    if guidance_scale_value is None:
-        guidance_scale_value = 0.0
-    guidance_scale = float(guidance_scale_value)
-
-    mask_token_id_value = _runtime_fallback(
-        task_name,
-        "mask_token_id",
-        args.mask_token_id,
-    )
-    if mask_token_id_value is None:
-        mask_token_id_value = 126336
-    mask_token_id = int(mask_token_id_value)
-
-    codebook_size_value = _runtime_fallback(
-        task_name,
-        "codebook_size",
-        args.codebook_size,
-    )
-    if codebook_size_value is None:
-        codebook_size_value = 8192
-    codebook_size = int(codebook_size_value)
-
-    audio_codebook_size_value = _runtime_fallback(
-        task_name,
-        "audio_codebook_size",
-        args.audio_codebook_size,
-    )
-    if audio_codebook_size_value is None:
-        audio_codebook_size_value = 4096
-    audio_codebook_size = int(audio_codebook_size_value)
-
-    image_token_count_value = _runtime_fallback(
-        task_name,
-        "image_token_count",
-        args.image_token_count,
-    )
-    image_token_count = int(image_token_count_value) if image_token_count_value is not None else 0
-
-    t2s_token_length_value = _runtime_fallback(
-        task_name,
-        "t2s_token_length",
-        args.t2s_token_length,
-    )
-    if t2s_token_length_value is None:
-        t2s_token_length_value = 383
-    t2s_token_length = int(t2s_token_length_value)
-
-    t2s_condition = str(
-        _runtime_fallback(task_name, "t2s_condition", args.t2s_condition)
-        or "gender-female_emotion-neutral_speed-normal_pitch-normal"
-    )
-
-    _validate_generation_args(
-        task=task_name,
-        max_new_tokens=max_new_tokens,
-        steps=steps,
-        block_length=block_length,
-    )
-
-    use_train_i2i_prompt = _runtime_fallback(task_name, "use_train_i2i_prompt", args.use_train_i2i_prompt)
-    if use_train_i2i_prompt is None:
-        use_train_i2i_prompt = bool(task_name == "i2i")
-    use_train_i2i_prompt = bool(use_train_i2i_prompt)
-
-    if task_name in {"i2i", "i2t"} and not args.image:
-        raise ValueError(f"--task {task_name} requires --image")
-    if task_name == "s2t" and not args.audio:
-        raise ValueError("--task s2t requires --audio")
-    if task_name == "v2t" and not args.video:
-        raise ValueError("--task v2t requires --video")
-
-    text = resolve_task_text(
-        task_name=task_name,
-        text=args.text,
-        instruction=args.instruction,
-        raw_prompt=bool(args.raw_prompt),
-    )
-
-    tokenizer_source = args.tokenizer_path.strip() or model_source
-    model_local_only = resolve_local_only(
-        args.model_local_files_only, model_source, default=Path(model_source).is_dir()
-    )
-    tokenizer_local_only = resolve_local_only(
-        args.tokenizer_local_files_only,
-        tokenizer_source,
-        default=model_local_only,
-    )
-    tokenizer = load_text_tokenizer(tokenizer_source, local_files_only=tokenizer_local_only)
-    text_vocab_size = int(len(tokenizer))
-
-    image_tokens: torch.Tensor | None = None
-    audio_tokens: torch.Tensor | None = None
-    video_tokens: torch.Tensor | None = None
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-    vq_image_source = args.vq_model_image_path.strip() or "snu-aidas/magvitv2"
-    vq_audio_source = args.vq_model_audio_path.strip() or "snu-aidas/emova_speech_tokenizer_vllm"
-    vq_image_local_only = resolve_local_only(args.vq_model_image_local_files_only, vq_image_source, default=False)
-    vq_audio_local_only = resolve_local_only(args.vq_model_audio_local_files_only, vq_audio_source, default=False)
-
-    if task_name in {"i2i", "i2t", "v2t"}:
-        vq_image = load_vq_image_encoder(vq_image_source, vq_image_local_only, device)
-        if task_name in {"i2i", "i2t"}:
-            image_tokens = encode_image_tokens(
-                Path(args.image).expanduser().resolve(),
-                vq_model=vq_image,
-                device=device,
-                resolution=int(image_resolution),
-            )
-        if task_name == "v2t":
-            video_tokens = encode_video_tokens(
-                Path(args.video).expanduser().resolve(),
-                vq_model=vq_image,
-                device=device,
-                resolution=int(image_resolution),
-                num_frames=int(num_frames),
-            )
-        if hasattr(vq_image, "cpu"):
-            vq_image = vq_image.cpu()
-
-    if task_name == "s2t":
-        vq_audio = load_vq_audio_encoder(vq_audio_source, vq_audio_local_only, device)
-        audio_tokens = encode_audio_tokens(Path(args.audio).expanduser().resolve(), vq_audio)
-        if hasattr(vq_audio, "cpu"):
-            vq_audio = vq_audio.cpu()
-
-    noise_schedule_params: dict[str, Any] = {}
-    try:
-        parsed = json.loads(args.noise_schedule_params)
-        if isinstance(parsed, dict):
-            noise_schedule_params = {str(k): v for k, v in parsed.items()}
-    except Exception:
-        noise_schedule_params = {}
-
-    image_token_count = int(image_token_count)
-    if image_token_count <= 0:
-        if image_tokens is not None:
-            image_token_count = int(image_tokens.numel())
-        else:
-            base_res = int(image_resolution)
-            image_token_count = max(1, (base_res // 16) ** 2)
-
-    uncond_input_ids: list[int] | None = None
-    uncond_attention_mask: list[int] | None = None
-    if task_name == "t2t":
-        messages = [{"role": "user", "content": text}]
-        if getattr(tokenizer, "chat_template", None):
-            prompt_text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
-            encoded = tokenizer(prompt_text, return_tensors="pt", add_special_tokens=False)
-        else:
-            encoded = tokenizer(text, return_tensors="pt", add_special_tokens=True)
-        prompt_token_ids = _to_1d_int_list(encoded["input_ids"])
-        prompt_attention_mask = _to_1d_int_list(encoded.get("attention_mask"))
-        if not prompt_attention_mask:
-            prompt_attention_mask = [1] * len(prompt_token_ids)
-    else:
-        max_audio_len_for_prompt = int(max(t2s_token_length, 512))
-        if audio_tokens is not None:
-            max_audio_len_for_prompt = max(max_audio_len_for_prompt, int(audio_tokens.numel()))
-        max_audio_len_short_for_prompt = max(256, max_audio_len_for_prompt // 2)
-
-        uni_prompting = load_universal_prompting(
-            tokenizer=tokenizer,
-            tokenizer_source=tokenizer_source,
-            max_text_len=int(prompt_max_text_len),
-            cond_dropout_prob=float(args.cond_dropout_prob),
-            local_files_only=bool(tokenizer_local_only),
-            max_audio_len=int(max_audio_len_for_prompt),
-            max_audio_len_short=int(max_audio_len_short_for_prompt),
-        )
-        prompting_text_vocab_size = int(len(uni_prompting.text_tokenizer))
-
-        is_mmu_task = task_name in {"i2t", "s2t", "v2t"} and not args.prompting_task.strip()
-        if is_mmu_task:
-            prompt_token_ids, prompt_attention_mask = make_mmu_prompt(
-                task=task_name,
-                text=text,
-                tokenizer=uni_prompting.text_tokenizer,
-                uni_prompting=uni_prompting,
-                image_tokens=image_tokens,
-                audio_tokens=audio_tokens,
-                video_tokens=video_tokens,
-                image_token_offset=prompting_text_vocab_size,
-                speech_token_offset=prompting_text_vocab_size + int(codebook_size),
-            )
-        else:
-            prompt_payload, prompting_task = make_prompt_payload(
-                task=task_name,
-                text=text,
-                image_tokens=image_tokens,
-                audio_tokens=audio_tokens,
-                video_tokens=video_tokens,
-                image_placeholder_tokens=image_token_count,
-                audio_placeholder_tokens=int(t2s_token_length),
-                image_token_offset=text_vocab_size,
-                speech_token_offset=text_vocab_size + int(codebook_size),
-                mask_token_id=int(mask_token_id),
-                use_train_i2i_prompt=use_train_i2i_prompt,
-            )
-            if args.prompting_task.strip():
-                prompting_task = args.prompting_task.strip()
-
-            prompt_token_ids, prompt_attention_mask = _run_uni_prompting(
-                uni_prompting,
-                prompt_payload,
-                prompting_task,
-            )
-
-        if task_name in {"i2t", "s2t", "v2t"}:
-            prompt_attention_mask = [1] * len(prompt_token_ids)
-        if not prompt_attention_mask:
-            prompt_attention_mask = [1] * len(prompt_token_ids)
-
-        if task_name in {"t2i", "i2i"} and guidance_scale > 0:
-            uncond_payload, uncond_prompting_task = make_prompt_payload(
-                task=task_name,
-                text="",
-                image_tokens=image_tokens,
-                audio_tokens=audio_tokens,
-                video_tokens=video_tokens,
-                image_placeholder_tokens=image_token_count,
-                audio_placeholder_tokens=int(t2s_token_length),
-                image_token_offset=text_vocab_size,
-                speech_token_offset=text_vocab_size + int(codebook_size),
-                mask_token_id=int(mask_token_id),
-                use_train_i2i_prompt=use_train_i2i_prompt,
-            )
-            uncond_input_ids, uncond_attention_mask = _run_uni_prompting(
-                uni_prompting,
-                uncond_payload,
-                args.prompting_task.strip() or uncond_prompting_task,
-            )
-            if not uncond_attention_mask:
-                uncond_attention_mask = [1] * len(uncond_input_ids)
-
-    runtime_info: dict[str, Any] = {
-        "task": [runtime_task],
-        "detok_id": [int(detok_id)],
-        DYNIN_PROMPT_SOURCE_KEY: [DYNIN_PROMPT_SOURCE_OFFLINE_PREBUILT],
-        "dynin_config_path": [str(dynin_config_path)],
-        "attention_mask": [prompt_attention_mask],
-        "prompt_max_text_len": [int(prompt_max_text_len)],
-        "prompting_max_text_len": [int(prompt_max_text_len)],
-        "cond_dropout_prob": [float(args.cond_dropout_prob)],
-        "prompting_cond_dropout_prob": [float(args.cond_dropout_prob)],
-        "tokenizer_path": [str(tokenizer_source)],
-        "text_vocab_size": [int(text_vocab_size)],
-        "model_local_files_only": [bool(model_local_only)],
-        "max_new_tokens": [int(max_new_tokens)],
-        "steps": [int(steps)],
-        "block_length": [int(block_length)],
-        "temperature": [float(temperature)],
-        "cfg_scale": [float(cfg_scale)],
-        "remasking": [str(remasking)],
-        "mask_id": [int(mask_token_id)],
-        "mask_token_id": [int(mask_token_id)],
-        "codebook_size": [int(codebook_size)],
-        "audio_codebook_size": [int(audio_codebook_size)],
-        "timesteps": [int(timesteps)],
-        "guidance_scale": [float(guidance_scale)],
-        "noise_type": [str(args.noise_type)],
-        "noise_schedule_name": [str(args.noise_schedule_name)],
-        "noise_schedule_params": [noise_schedule_params],
-        "seq_len": [int(image_token_count)],
-        "condition": [str(t2s_condition)],
-        "vq_model_image_path": [str(vq_image_source)],
-        "vq_model_image_local_files_only": [bool(vq_image_local_only)],
-        "vq_model_audio_path": [str(vq_audio_source)],
-        "vq_model_audio_local_files_only": [bool(vq_audio_local_only)],
-    }
-
-    if task_name in {"t2t", "i2t", "s2t", "v2t"}:
-        runtime_info["prompt_length"] = [int(len(prompt_token_ids))]
-    if uncond_input_ids is not None:
-        runtime_info["uncond_input_ids"] = [uncond_input_ids]
-    if uncond_attention_mask is not None:
-        runtime_info["uncond_attention_mask"] = [uncond_attention_mask]
-
-    if task_name == "t2s":
-        runtime_info["max_new_tokens"] = [int(t2s_token_length)]
-
-    prompt = {
-        "prompt_token_ids": [int(v) for v in prompt_token_ids],
-        "additional_information": runtime_info,
-        "modalities": [final_modality],
-    }
-
-    from vllm import SamplingParams
-
-    from vllm_omni.entrypoints.omni import Omni
-
-    deploy_config_path = str(Path(args.deploy_config).expanduser())
-    omni = Omni(model=model_source, deploy_config=deploy_config_path, dtype=args.dtype)
-    sampling_params_list = [
-        SamplingParams(max_tokens=int(args.max_tokens_per_stage), temperature=0.0, top_p=1.0, detokenize=False)
-        for _ in range(omni.num_stages)
-    ]
-
-    try:
-        outputs = list(omni.generate(prompt, sampling_params_list))
-    finally:
-        omni.close()
-
-    out_dir = Path(resolved_output_dir).expanduser()
-    out_dir.mkdir(parents=True, exist_ok=True)
-    stamp = time.strftime("%Y%m%d_%H%M%S")
-    prefix = args.output_prefix.strip() or f"{task_name}_{stamp}"
-
-    if final_modality == "text":
-        text_out = extract_text_output(outputs, tokenizer=tokenizer)
-        if not text_out:
-            raise RuntimeError("No text output found.")
-        out_path = out_dir / f"{prefix}.txt"
-        out_path.write_text(text_out + "\n", encoding="utf-8")
-        print(f"[end2end] text saved: {out_path}")
-        print(text_out)
-        return
-
-    if final_modality == "image":
-        image_out = extract_image_output(outputs)
-        if image_out is None:
-            raise RuntimeError("No image output found.")
-        pil = tensor_to_pil_image(image_out)
-        out_path = out_dir / f"{prefix}.png"
-        pil.save(out_path)
-        print(f"[end2end] image saved: {out_path}")
-        return
-
-    if final_modality == "audio":
-        audio_out = extract_audio_output(outputs)
-        if audio_out is None:
-            raise RuntimeError("No audio output found.")
-        wav, sr = audio_out
-        out_path = out_dir / f"{prefix}.wav"
-        save_audio_wav(out_path, wav, sr)
-        print(f"[end2end] audio saved: {out_path} (sr={sr}, samples={wav.shape[0]})")
-        return
-
-    raise RuntimeError(f"Unsupported final modality: {final_modality}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/offline_inference/text_to_image/README.md b/examples/offline_inference/text_to_image/README.md
index cfe05255d..7664bb32d 100644
--- a/examples/offline_inference/text_to_image/README.md
+++ b/examples/offline_inference/text_to_image/README.md
@@ -19,23 +19,23 @@ This folder provides several entrypoints for experimenting with text-to-image di
 
 ### Supported Models
 
-| Model | Image Shape  | Peak VRAM (GiB) * | Model Weights (GiB) |
+| Model | Image Shape | Peak VRAM (GiB) * | Model Weights (GiB) |
 | ----- | ----------- | ----------- | ----------------- |
 | `Qwen/Qwen-Image` | 1024 x 1024 | 60.0 | 53.7 |
-| `Qwen/Qwen-Image-2512` |1024 x 1024 | 60.0 | 53.7 |
+| `Qwen/Qwen-Image-2512` | 1024 x 1024 | 60.0 | 53.7 |
 | `Tongyi-MAI/Z-Image-Turbo` | 1024 x 1024 | 24.8 | 19.2 |
 | `stepfun-ai/NextStep-1.1` | 512 x 512 | 71.8 | 28.1 |
 | `meituan-longcat/LongCat-Image` | 1024 x 1024 | 71.2 | 27.3 |
 | `AIDC-AI/Ovis-Image-7B` | 1024 x 1024 | 71.8 | 17.1 |
-| `OmniGen2/OmniGen2` |  1024 x 1024 | 20.1 | 14.7 |
+| `OmniGen2/OmniGen2` | 1024 x 1024 | 20.1 | 14.7 |
 | `stabilityai/stable-diffusion-3.5-medium` | 1024 x 1024 | 20.1 | 15.6 |
 | `black-forest-labs/FLUX.1-dev` | 1024 x 1024 | 33.9 | 31.4 |
 | `black-forest-labs/FLUX.1-schnell` | 1024 x 1024 | 33.9 | 31.4 |
 | `black-forest-labs/FLUX.2-klein-4B` | 1024 x 1024 | 72.7 | 14.9 |
 | `black-forest-labs/FLUX.2-klein-9B` | 1024 x 1024 | 37.1 | 32.3 |
 | `black-forest-labs/FLUX.2-dev` | 1024 x 1024 | 65.7 | >80 (CPU offload required) |
-| `HunyuanImage-3.0` | 1024 x 1024 | 80.0 (TP≥3)  | 160 |
-| `HiDream-I1-Full` | 1024 x 1024 | 63.7  | 57.7 |
+| `HunyuanImage-3.0` | 1024 x 1024 | 80.0 (TP≥3) | 160 |
+| `HiDream-I1-Full` | 1024 x 1024 | 63.7 | 57.7 |
 | `krea/Krea-2-Raw`, `krea/Krea-2-Turbo` | 1024 (Raw) / 2048 (Turbo) | — | ~30 |
 
 !!! info
@@ -112,9 +112,9 @@ python text_to_image.py \
 | `--enable-cpu-offload` | flag | off | Enable CPU offloading for diffusion models |
 | `--lora-path` | str | — | Path to PEFT LoRA adapter folder or checkpoint file |
 | `--lora-scale` | float | `1.0` | Scale factor for LoRA weights |
-| `--lora-backend` | str |`"peft"`| LoRA backend for loading LoRA adapters. Default: peft. Available options: peft, distill |
-| `--use-system-prompt` | str | `None` | System prompt preset: `en_unified`, `en_vanilla`, `en_recaption`, `en_think_recaption`, `dynamic`, `None`, or custom text. Recommended: `en_unified`. Only for HunyuanImage-3.0.|
-| `--system-prompt` | str | `None` | Custom system prompt text. Only used when `--use-system-prompt` is set to `custom`. Only for HunyuanImage-3.0.|
+| `--lora-backend` | str | `"peft"` | LoRA backend for loading LoRA adapters. Default: peft. Available options: peft, distill |
+| `--use-system-prompt` | str | `None` | System prompt preset: `en_unified`, `en_vanilla`, `en_recaption`, `en_think_recaption`, `dynamic`, `None`, or custom text. Recommended: `en_unified`. Only for HunyuanImage-3.0. |
+| `--system-prompt` | str | `None` | Custom system prompt text. Only used when `--use-system-prompt` is set to `custom`. Only for HunyuanImage-3.0. |
 | `--auxiliary-text-encoder` | str | `None` | Supplementary auxiliary text encoder parameters model name or path (especially for Hidream-l1-full). |
 
 **NextStep-1.1 specific arguments:**
@@ -127,7 +127,7 @@ python text_to_image.py \
 | `--use-norm` | flag | off | Apply layer normalization to sampled tokens |
 
 > If you encounter OOM errors, try using `--vae-use-slicing` and `--vae-use-tiling` to reduce memory usage.
-
+>
 > Qwen-Image currently publishes best-effort presets at `1328x1328`, `1664x928`, `928x1664`, `1472x1140`, `1140x1472`, `1584x1056`, and `1056x1584`. Adjust `--height/--width` accordingly for the most reliable outcomes.
 
 ## More CLI Examples
@@ -216,6 +216,26 @@ python examples/offline_inference/text_to_image/text_to_image.py \
   --output /output.png
 ```
 
+### Anima Single-File Checkpoints
+
+Anima uses the official model dimensions by default. A checkpoint may provide a JSON file with the same stem (for example, `anima.json` beside `anima.safetensors`) containing `transformer` and `text_conditioner` configuration objects. These override the default dimensions and must match the checkpoint weights. The shared tiny-model tests use this to load small random-weight models. Components in `text_encoder/`, `vae/`, `tokenizer/`, `t5_tokenizer/`, and `scheduler/` beside the checkpoint are discovered automatically.
+
+To load Anima, point `--model` to the single-file checkpoint path, pass the native pipeline class name using `--model-class-name`, and supply the converted components directory using `--custom-pipeline-args`:
+
+```bash
+python examples/offline_inference/text_to_image/text_to_image.py \
+  --model /path/to/models/anima-official/split_files/diffusion_models/anima-base-v1.0.safetensors \
+  --model-class-name AnimaPipeline \
+  --custom-pipeline-args '{"components_path": "/path/to/models/anima-components"}' \
+  --prompt "A cinematic close-up of a glass teapot on a wooden table." \
+  --seed 42 \
+  --guidance-scale 4.0 \
+  --num-inference-steps 50 \
+  --height 1024 \
+  --width 1024 \
+  --output anima_output.png
+```
+
 ### Krea 2
 
 Krea 2 is published as diffusers-format checkpoints: `krea/Krea-2-Turbo` (few-step distilled) and `krea/Krea-2-Raw`.
@@ -336,7 +356,7 @@ python text_to_image.py \
 
 LoRA adapters must be in PEFT format. A typical adapter directory structure:
 
-```
+```text
 lora_adapter/
 ├── adapter_config.json
 └── adapter_model.safetensors
diff --git a/examples/offline_inference/text_to_image/text_to_image.py b/examples/offline_inference/text_to_image/text_to_image.py
index adcc10669..c74236316 100644
--- a/examples/offline_inference/text_to_image/text_to_image.py
+++ b/examples/offline_inference/text_to_image/text_to_image.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import argparse
 import functools
@@ -58,6 +58,7 @@ def parse_json_object(value: str, flag_name: str = "argument") -> dict[str, Any]
 
 
 parse_profiler_config = functools.partial(parse_json_object, flag_name="--profiler-config")
+parse_custom_pipeline_args = functools.partial(parse_json_object, flag_name="--custom-pipeline-args")
 
 
 def build_text_to_image_prompt(prompt: str, negative_prompt: str | None) -> dict[str, Any]:
@@ -379,6 +380,18 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help="Supplementary auxiliary text encoder parameters model name or path (especially for Hidream-l1-full).",
     )
+    parser.add_argument(
+        "--model-class-name",
+        type=str,
+        default=None,
+        help="Override the diffusion pipeline class name (e.g. AnimaPipeline).",
+    )
+    parser.add_argument(
+        "--custom-pipeline-args",
+        type=parse_custom_pipeline_args,
+        default=None,
+        help='JSON object passed to native/custom pipelines (e.g. \'{"components_path": "/path"}\').',
+    )
     parser.add_argument(
         "--trust-remote-code",
         action="store_true",
@@ -558,7 +571,6 @@ def main():
         "vae_patch_parallel_size": args.vae_patch_parallel_size,
         "enable_expert_parallel": args.enable_expert_parallel,
         "enable_cpu_offload": args.enable_cpu_offload,
-        "mode": "text-to-image",
         "log_stats": args.log_stats,
         "enable_diffusion_pipeline_profiler": args.enable_diffusion_pipeline_profiler,
         "profiler_config": args.profiler_config,
@@ -576,9 +588,13 @@ def main():
         omni_kwargs["trust_remote_code"] = True
     if args.deploy_config:
         omni_kwargs["deploy_config"] = args.deploy_config
-    if use_nextstep:
+    if args.model_class_name:
+        omni_kwargs["model_class_name"] = args.model_class_name
+    elif use_nextstep:
         # NextStep-1.1 requires explicit pipeline class
         omni_kwargs["model_class_name"] = "NextStep11Pipeline"
+    if args.custom_pipeline_args is not None:
+        omni_kwargs["custom_pipeline_args"] = args.custom_pipeline_args
     # Cosmos3 loads its (gated) guardrail models at build time, so the guardrails
     # gate is an engine-level config (offline analog of the server's --no-guardrails).
     if args.extra_body and "guardrails" in args.extra_body:
@@ -614,6 +630,10 @@ def main():
         print(f"  LoRA: scale={args.lora_scale}")
     if args.deploy_config:
         print(f"  deploy-config: {args.deploy_config}")
+    if args.model_class_name:
+        print(f"  Model class name: {args.model_class_name}")
+    if args.custom_pipeline_args is not None:
+        print(f"  Custom pipeline args: {args.custom_pipeline_args}")
     print(f"{'=' * 60}\n")
 
     # Build LoRA request when --lora-path is set
@@ -723,7 +743,10 @@ def main():
     # stop-token-ids declaratively from the plain prompt + extra_body, so this
     # example stays model-agnostic. Models without one are untouched.
     ar_input_builder = get_ar_input_builder(model_class_name)
-    if ar_input_builder is not None:
+    # A model can also be deployed with only its diffusion stage. Keep those
+    # requests on the string-prompt path, as in the single-stage images API.
+    has_ar_stage = any(not isinstance(params, OmniDiffusionSamplingParams) for params in sampling_params_list)
+    if ar_input_builder is not None and has_ar_stage:
         _apply_ar_stage_inputs(
             ar_input_builder,
             model=args.model,
diff --git a/examples/offline_inference/text_to_speech/README.md b/examples/offline_inference/text_to_speech/README.md
index 04ff1a97d..36d1b44ee 100644
--- a/examples/offline_inference/text_to_speech/README.md
+++ b/examples/offline_inference/text_to_speech/README.md
@@ -13,7 +13,7 @@ list of supported architectures across all modalities, see
 ## Supported Models
 
 | Model | HuggingFace repo | Stages | Voice cloning | Streaming | Special modes | Sample rate |
-|---|---|---|---|---|---|---|
+| --- | --- | --- | --- | --- | --- | --- |
 | AuK | `tencent/AuK`, `tencent/AuK-Flash` (assembled with `tools/prepare_auk_checkpoint.py`) | 2 (thinker encoder + DiT) | ✓ | — | instruction-driven editing, enhancement, separation; no example script (use `vllm_omni.model_extras.auk`) | 24 kHz |
 | Audio8 TTS Preview | `Audio8/Audio8-TTS-Preview-0.6b` | dual-AR | ✓ | ✓ | 11 languages | 44.1 kHz |
 | Breeze-TTS-2 | `BreezeBlue/Breeze-TTS-2` | 2 (talker + codec) | ✓ | ✓ (async chunk) | voice design / voice direction (`--instruction`) | 24 kHz |
@@ -27,7 +27,6 @@ list of supported architectures across all modalities, see
 | OmniVoice | `k2-fsa/OmniVoice` | 2 (gen + dec) | ✓ | — | voice design, language hint | 24 kHz |
 | Qwen3-TTS | `Qwen/Qwen3-TTS-12Hz-1.7B-{CustomVoice,VoiceDesign,Base}` | 2 (talker + code2wav) | ✓ (Base) | ✓ | 3 task variants | 24 kHz |
 | VoxCPM2 | `openbmb/VoxCPM2` | single (native AR) | ✓ | ✓ (online) | continuation | 48 kHz |
-| dots.tts | `dots-studio/dots.tts-soar` | single (native AR) | — (text-only) | ✓ (online) | no-reference synthesis | 48 kHz |
 | IndexTTS-2 | `IndexTeam/IndexTTS-2` | 2 (AR talker + S2Mel DiT + BigVGAN) | ✓ (required) | — | emotion control (`--emo-audio`, `--emo-text`, `--emo-vector`) | 22.05 kHz |
 | IndexTTS-2.5 | native `checkpoints/` bundle | 2 (AR talker + EnhancedCodec + S2Mel DiT + BigVGAN) | ✓ (required) | — | multilingual (`--lang`) + emotion control | 22.05 kHz |
 | Voxtral TTS | `mistralai/Voxtral-4B-TTS-2603` | varies | ✓ | ✓ | voice presets | 24 kHz |
@@ -54,32 +53,38 @@ codec: a slow AR transformer predicts one semantic token per codec frame, and a
 4-layer fast AR predicts that frame's remaining 9 codebooks.
 
 ### Prerequisites
+
 No extra packages: the codec architecture ships in tree and its weights
 (`codec.pth`) come with the checkpoint.
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/audio8_tts/end2end.py \
     --text "Welcome to Audio8 TTS, a compact multilingual text to speech model."
 ```
 
 ### Voice cloning
+
 ```bash
 python examples/offline_inference/text_to_speech/audio8_tts/end2end.py \
     --text "Welcome to Audio8 TTS." \
     --ref-audio /path/to/reference.wav \
     --ref-text  "The exact transcript of the reference recording."
 ```
+
 The reference transcript must match what is actually spoken in the clip;
 a mismatch degrades both stability and speaker similarity.
 
 ### Streaming
+
 ```bash
 python examples/offline_inference/text_to_speech/audio8_tts/end2end.py \
     --text "Welcome to Audio8 TTS." --streaming
 ```
 
 ### Notes
+
 - Output: 44.1 kHz mono WAV; the codec emits ~21.5 frames/s (2048 samples per frame).
 - Context is 2048 packed text+audio positions, so `max_model_len` is 2048.
 - Greedy decoding (`temperature: 0`) is degenerate for this checkpoint — it
@@ -92,6 +97,7 @@ python examples/offline_inference/text_to_speech/audio8_tts/end2end.py \
 - `--num-prompts 4` smoke-tests concurrency (stage 0 runs `max_num_seqs: 4`).
 
 ### Measured behaviour (1x H20, shared GPU)
+
 `--streaming` on a 58-character English sentence: TTFA ~0.74 s (4-frame first
 chunk), 7 chunks, 1.55 s wall for 3.16 s of audio (RTF ~0.49). Treat these as
 smoke-test magnitudes, not a benchmark.
@@ -103,12 +109,14 @@ smoke-test magnitudes, not a benchmark.
 2-stage TTS pipeline (`talker` + `code2wav`) at 24 kHz.
 
 ### Prerequisites
+
 ```bash
 uv pip install -e .
 # Includes soundfile, onnxruntime, x-transformers, einops via requirements.
 ```
 
 Download the model snapshot:
+
 ```python
 from huggingface_hub import snapshot_download
 snapshot_download('FunAudioLLM/Fun-CosyVoice3-0.5B-2512',
@@ -116,15 +124,18 @@ snapshot_download('FunAudioLLM/Fun-CosyVoice3-0.5B-2512',
 ```
 
 If your downloaded checkpoint lacks `config.json`, add it:
+
 ```json
 {
     "model_type": "cosyvoice3",
     "architectures": ["CosyVoice3Model"]
 }
 ```
+
 This is required because `AutoConfig.register("cosyvoice3", CosyVoice3Config)` only registers the class mapping; the loader still reads `model_type` from `config.json` to select the class.
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/cosyvoice3/end2end.py \
     --model pretrained_models/Fun-CosyVoice3-0.5B \
@@ -132,9 +143,11 @@ python examples/offline_inference/text_to_speech/cosyvoice3/end2end.py \
 ```
 
 ### Voice cloning
+
 If `--ref-audio` is omitted, the script downloads the upstream
 [`zero_shot_prompt.wav`](https://github.com/FunAudioLLM/CosyVoice/blob/main/asset/zero_shot_prompt.wav) from the CosyVoice repo into the current directory.
 To use your own clip, pass `--ref-audio /path/to/reference.wav`, and modify `--prompt-text` correspondingly.
+
 ```bash
 python examples/offline_inference/text_to_speech/cosyvoice3/end2end.py \
     --model pretrained_models/Fun-CosyVoice3-0.5B \
@@ -144,9 +157,11 @@ python examples/offline_inference/text_to_speech/cosyvoice3/end2end.py \
 ```
 
 ### Streaming
+
 Streaming is enabled by default via `async_chunk: true` in `vllm_omni/deploy/cosyvoice3.yaml`. Pass `--no-async-chunk` on `vllm serve` to switch to the legacy synchronous path.
 
 ### Notes
+
 - Stage 0 (`talker`) emits speech tokens; stage 1 (`code2wav`) runs flow matching + HiFiGAN to synthesize waveform.
 - Deploy config auto-loads from `vllm_omni/deploy/cosyvoice3.yaml` based on HF `model_type`. Pass `--deploy-config <path>` to override.
 
@@ -157,6 +172,7 @@ Streaming is enabled by default via `async_chunk: true` in `vllm_omni/deploy/cos
 2-stage TTS pipeline (AR + DiT flow-matching) at 24 kHz. Every request requires reference audio and its transcript for zero-shot voice cloning.
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/glm_tts/end2end.py \
     --model zai-org/GLM-TTS \
@@ -167,12 +183,14 @@ python examples/offline_inference/text_to_speech/glm_tts/end2end.py \
 ```
 
 ### Architecture
+
 ```text
 Text → [Stage 0: AR] → Speech Tokens → [Stage 1: DiT + HiFT] → Audio (24 kHz)
         (Llama-based)    (32k vocab)      (Flow Matching)
 ```
 
 ### Notes
+
 - `--ref-audio` and `--ref-text` are **required** together; GLM-TTS does not support text-only synthesis.
 - Reference audio should be 3-10 seconds.
 - First run may be slow due to lazy loading of WhisperVQ tokenizer and CampPlus ONNX speaker embedder.
@@ -187,12 +205,14 @@ Text → [Stage 0: AR] → Speech Tokens → [Stage 1: DiT + HiFT] → Audio (24
 No extra packages are required; the DAC codec is vendored in vLLM-Omni.
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/fish_speech/end2end.py \
     --text "Hello, this is a test of the Fish Speech text to speech system."
 ```
 
 ### Voice cloning
+
 ```bash
 python examples/offline_inference/text_to_speech/fish_speech/end2end.py \
     --text "Hello, this is a cloned voice." \
@@ -201,14 +221,17 @@ python examples/offline_inference/text_to_speech/fish_speech/end2end.py \
 ```
 
 ### Streaming
+
 ```bash
 python examples/offline_inference/text_to_speech/fish_speech/end2end.py \
     --text "Hello, this is a streaming test." \
     --streaming
 ```
+
 Streaming requires `async_chunk: true` in the deploy config.
 
 ### Notes
+
 - Output: 44.1 kHz mono WAV.
 - DAC codec weights (`codec.pth`) are loaded lazily from the model directory.
 
@@ -219,6 +242,7 @@ Streaming requires `async_chunk: true` in the deploy config.
 Dense 0.5B two-stage TTS pipeline (`AR + flow` + audio VAE) at 44.1 kHz. The example covers style, IP voice, music-only generation, text-to-audio events, emotion, dialect, zero-shot cloning, podcast, speech+BGM, and speech+environment-sound cases.
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
     --case style \
@@ -227,6 +251,7 @@ python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
 ```
 
 ### Voice cloning
+
 ```bash
 python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
     --case zero_shot \
@@ -237,6 +262,7 @@ python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
 ```
 
 ### Streaming
+
 ```bash
 python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
     --case basic \
@@ -247,6 +273,7 @@ python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
 ```
 
 ### Notes
+
 - `style`, `ip`, `bgm`, and `tta` do not require reference audio.
 - Reference-audio cases use `--ref-audio`; `zero_shot` also requires `--ref-text`.
 - `podcast` uses multiple references via `--ref-audio-paths`.
@@ -259,14 +286,17 @@ python examples/offline_inference/text_to_speech/ming_tts/end2end.py \
 Standalone talker-only deployment of Ming-flash-omni-2.0 at 44.1 kHz. Voice is controlled through caption fields (`风格` / `IP` / `语速`/`基频`/`音量`) rather than reference audio.
 
 ### Prerequisites
+
 The example calls into `vllm_omni.model_executor.models.ming_flash_omni.prompt_utils` for the default prompt and instruction builder; no extra pip install on top of the base vLLM-Omni install.
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/ming_flash_omni_tts/end2end.py --case style
 ```
 
 ### Cases
+
 ```bash
 # ASMR-style whisper (caption-driven)
 python examples/offline_inference/text_to_speech/ming_flash_omni_tts/end2end.py --case style
@@ -281,6 +311,7 @@ python examples/offline_inference/text_to_speech/ming_flash_omni_tts/end2end.py
 Override the default text per case with `--text`, write to a custom path with `--output`.
 
 ### Notes
+
 - Talker-only deployment — for the multimodal Ming-flash-omni example, see [`examples/offline_inference/ming_flash_omni/`](../../ming_flash_omni/).
 - Deploy config: `vllm_omni/deploy/ming_flash_omni_tts.yaml` (single GPU, `enforce_eager`, `max_num_seqs: 1`).
 - Decode defaults from the Ming cookbook: `max_decode_steps=200`, `cfg=2.0`, `sigma=0.25`, `temperature=0.0`, `use_zero_spk_emb=True`.
@@ -294,6 +325,7 @@ Single-stage 0.1B AR LM + MOSS-Audio-Tokenizer-Nano codec at 48 kHz mono (mixed
 > **No built-in speaker presets.** `--ref-audio` is required on every call. Default `--mode voice_clone` matches upstream's recommended workflow; `--mode continuation` is exposed for completeness but upstream's continuation-with-prompt path emits very short / near-silent output, so it is rarely useful in practice. Sample reference clips ship in the upstream repo under [`assets/audio/`](https://github.com/OpenMOSS/MOSS-TTS-Nano/tree/main/assets/audio) (e.g. `zh_1.wav`, `en_2.wav`, `jp_2.wav`).
 
 ### Quick start
+
 ```bash
 # Fetch a sample reference clip (one-off, user-scoped cache).
 REF_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/moss-tts-nano"
@@ -305,9 +337,11 @@ python examples/offline_inference/text_to_speech/moss_tts_nano/end2end.py \
     --text "你好，这是MOSS-TTS-Nano的语音合成演示。" \
     --ref-audio "$REF_DIR/zh_1.wav"
 ```
+
 The first run downloads `OpenMOSS-Team/MOSS-TTS-Nano` and `OpenMOSS-Team/MOSS-Audio-Tokenizer-Nano` from Hugging Face.
 
 ### Reproducible runs
+
 ```bash
 python examples/offline_inference/text_to_speech/moss_tts_nano/end2end.py \
     --text "Deterministic test." \
@@ -316,6 +350,7 @@ python examples/offline_inference/text_to_speech/moss_tts_nano/end2end.py \
 ```
 
 ### Notes
+
 - Output: 48 kHz mono WAV (the tokenizer is internally stereo at 48 kHz; the wrapper averages to mono before reaching the engine).
 - Deploy config: `vllm_omni/deploy/moss_tts_nano.yaml` (auto-loaded; override with `--deploy-config`).
 - Default `--max-new-frames 375` ≈ 14 s of audio; raise for longer outputs.
@@ -329,12 +364,15 @@ python examples/offline_inference/text_to_speech/moss_tts_nano/end2end.py \
 Zero-shot multilingual TTS supporting 600+ languages, with three modes (auto / clone / design).
 
 ### Prerequisites
+
 ```bash
 huggingface-cli download k2-fsa/OmniVoice
 ```
+
 Voice cloning requires `transformers>=5.3.0`. Auto and design modes work with `transformers>=4.57.0`.
 
 ### Quick start (auto voice)
+
 ```bash
 python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
     --model k2-fsa/OmniVoice \
@@ -342,6 +380,7 @@ python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
 ```
 
 ### Voice cloning
+
 ```bash
 python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
     --model k2-fsa/OmniVoice \
@@ -351,6 +390,7 @@ python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
 ```
 
 ### Voice design
+
 ```bash
 python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
     --model k2-fsa/OmniVoice \
@@ -359,6 +399,7 @@ python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
 ```
 
 ### Language hint
+
 ```bash
 python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
     --model k2-fsa/OmniVoice \
@@ -367,6 +408,7 @@ python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
 ```
 
 ### Seed for Reproducibility
+
 ```bash
 python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
     --model k2-fsa/OmniVoice \
@@ -375,6 +417,7 @@ python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
 ```
 
 ### Notes
+
 - Stage 0 (Generator): Qwen3-0.6B with 32-step iterative unmasking.
 - Stage 1 (Decoder): HiggsAudioV2 RVQ + DAC at 24 kHz.
 
@@ -385,13 +428,16 @@ python examples/offline_inference/text_to_speech/omnivoice/end2end.py \
 3-task-variant TTS with 24 kHz output. Has its own argparse surface (this script does not follow the common `--text` / `--ref-audio` shape).
 
 ### Prerequisites
+
 For ROCm builds, replace `onnxruntime` with `onnxruntime-rocm`:
+
 ```bash
 pip uninstall onnxruntime
 pip install onnxruntime-rocm
 ```
 
 ### Task variants
+
 - `CustomVoice`: predefined speaker (speaker ID) with optional style instruction.
 - `VoiceDesign`: text + descriptive instruction designs a new voice.
 - `Base`: voice cloning from reference audio + transcript.
@@ -415,22 +461,27 @@ python examples/offline_inference/text_to_speech/qwen3_tts/end2end.py --query-ty
 ```
 
 ### Streaming
+
 ```bash
 python examples/offline_inference/text_to_speech/qwen3_tts/end2end.py \
     --query-type CustomVoice \
     --streaming \
     --output-dir /tmp/out_stream
 ```
+
 Streaming requires `async_chunk: true` in the deploy config.
 
 ### Word Timestamps
+
 Word-level timestamps are currently a serving-path feature: launch
 `vllm-omni serve` with `--forced-aligner` and request `word_timestamps`
 (see `examples/online_serving/text_to_speech/README.md`). An offline
 example is not provided in this release.
 
 ### Batched decoding
+
 The Code2Wav stage supports batched decoding through the SpeechTokenizer. Pass multiple prompts via `--txt-prompts` and set `--batch-size` accordingly. To raise `max_num_seqs` on either stage, create an overlay based on `vllm_omni/deploy/qwen3_tts.yaml` and pass it with `--deploy-config`:
+
 ```bash
 python examples/offline_inference/text_to_speech/qwen3_tts/end2end.py \
     --query-type CustomVoice \
@@ -438,9 +489,11 @@ python examples/offline_inference/text_to_speech/qwen3_tts/end2end.py \
     --batch-size 4 \
     --deploy-config /path/to/qwen3_tts_batched.yaml
 ```
+
 `--batch-size` must match a CUDA-graph capture size (1, 2, 4, 8, 16…).
 
 ### Notes
+
 - Run `--help` for the full argument surface.
 - See `qwen3_tts/end2end.py` for the prompt-length-estimation logic the Talker uses.
 
@@ -451,6 +504,7 @@ python examples/offline_inference/text_to_speech/qwen3_tts/end2end.py \
 Single-stage native AR TTS at 22.05 kHz. Pipeline: `Qwen3.5 backbone → 32 FSQ codebook heads (one frame/step) → NeMo NanoCodec`. Backbone runs under vLLM paged attention; the 32-head sampling + learned embedding feedback ride the native-AR runner hooks. `enforce_eager` (CUDA graph is a perf follow-up).
 
 ### Prerequisites
+
 The NanoCodec decoder needs NeMo (NVIDIA Open Model License), installed separately:
 
 ```bash
@@ -480,15 +534,18 @@ failure rather than an environment one. The PyTorch sampler it falls back to cos
 here.
 
 ### Quick start (zero-shot, default voice)
+
 ```bash
 python examples/offline_inference/text_to_speech/gepard/end2end.py \
     --text "Hello, this is a Gepard demo."
 ```
 
 ### Voice cloning
+
 Not yet — PR1 is zero-shot only (the learned `null_prefix` default voice). Reference-audio cloning (`ref_compressor` speaker prefix) is a follow-up PR.
 
 ### Notes
+
 - Output: 22.05 kHz mono WAV.
 - First run downloads two checkpoints, not one: the model itself, and the NanoCodec decoder it names in `codec_id` (`nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps` by default). Both are fetched automatically; expect the first startup to be correspondingly slower.
 - Offline and online: `examples/offline_inference/text_to_speech/gepard/end2end.py` and `/v1/audio/speech` (see the [online Gepard section](../../online_serving/text_to_speech/README.md#gepard-10)).
@@ -502,6 +559,7 @@ Not yet — PR1 is zero-shot only (the learned `null_prefix` default voice). Ref
 Single-stage native AR TTS at 48 kHz. Pipeline: `feat_encoder → MiniCPM4 → FSQ → residual_lm → LocDiT → AudioVAE`.
 
 ### Prerequisites
+
 ```bash
 pip install voxcpm
 # or, for a local source checkout:
@@ -509,6 +567,7 @@ export VLLM_OMNI_VOXCPM_CODE_PATH=/path/to/voxcpm
 ```
 
 ### Quick start
+
 ```bash
 python examples/offline_inference/text_to_speech/voxcpm2/end2end.py \
     --model openbmb/VoxCPM2 \
@@ -516,7 +575,9 @@ python examples/offline_inference/text_to_speech/voxcpm2/end2end.py \
 ```
 
 ### Voice cloning
+
 Pass a reference audio for isolated cloning, or both `--ref-audio` + `--ref-text` for prompt continuation:
+
 ```bash
 python examples/offline_inference/text_to_speech/voxcpm2/end2end.py \
     --text "Hello, this is a voice clone demo." \
@@ -525,39 +586,16 @@ python examples/offline_inference/text_to_speech/voxcpm2/end2end.py \
 ```
 
 ### Streaming
+
 Streaming is exposed through the online OpenAI Speech API (`stream=true`). See [`examples/online_serving/text_to_speech/voxcpm2/gradio_demo.py`](../../online_serving/text_to_speech/voxcpm2/gradio_demo.py) for an AudioWorklet-based gapless streaming player; the offline `end2end.py` script does not expose a streaming path.
 
 ### Notes
+
 - Output: 48 kHz mono WAV.
 - Deploy config: `vllm_omni/deploy/voxcpm2.yaml` (auto-loaded by HF `model_type`).
 
 ---
 
-## dots.tts
-
-Single-stage native AR TTS at 48 kHz (rednote-hilab). Pipeline: `Qwen2.5-1.5B base LM → DiT (10-step Euler flow matching) → patch_encoder AR loopback → AudioVAE (streaming decode)`. Same "vLLM-native base LM + side-path computation" pattern as VoxCPM2, with a plain Qwen2 backbone instead of MiniCPM4 and no FSQ / residual LM stage.
-
-### Quick start
-```bash
-python examples/offline_inference/text_to_speech/dots_tts/end2end.py \
-    --model dots-studio/dots.tts-soar \
-    --text "Hello, this is a test of dots TTS running on vLLM Omni."
-```
-
-### Voice cloning
-Not wired in this release. Generation is text-only and does not consume reference audio, a named voice, or a precomputed speaker embedding. The CAM++ x-vector speaker encoder weights load, but `end2end.py` has no `--ref-audio`/`--ref-text` flags yet.
-
-### Streaming
-The AudioVAE decoder emits incremental audio through its internal streaming path (`init_stream_state` / `stream_step` / `stream_flush`). Online streaming is exposed through the OpenAI-compatible `/v1/audio/speech` endpoint with `stream=true`; see the [online serving guide](../../online_serving/text_to_speech/README.md#dotstts). The offline `end2end.py` script returns the consolidated waveform.
-
-### Notes
-- Output: 48 kHz mono WAV.
-- Deploy config: `vllm_omni/deploy/dots_tts.yaml` (auto-loaded by HF `model_type`).
-- Checkpoints: `dots-studio/dots.tts-soar` is the validated default. `dots.tts-base` shares the same architecture but is unvalidated in this repo. `dots.tts-mf` (MeanFlow, 2-4 step) is not supported yet.
-- Known limitation: no CUDA graph capture and no batched side-path computation yet, so concurrent requests do not currently scale (each request's DiT Euler steps run serially). See `recipes/rednote-hilab/dots.tts.md` for details and the roadmap.
-
----
-
 ## IndexTTS-2 and IndexTTS-2.5
 
 Both versions use a 2-stage TTS pipeline and produce 22.05 kHz mono audio. Stage 0 is a GPT AR talker. IndexTTS-2 Stage 1 uses RepCodec semantic embeddings, GPT latent, S2Mel CFM/DiT, and BigVGAN. IndexTTS-2.5 replaces RepCodec with EnhancedCodec and uses the official code-only path (`use_gpt_latent=false`). Every request requires reference audio for zero-shot voice cloning.
@@ -592,6 +630,7 @@ python examples/offline_inference/text_to_speech/indextts2/end2end.py \
 ```
 
 ### Emotion control
+
 ```bash
 # Emotion from reference audio
 python examples/offline_inference/text_to_speech/indextts2/end2end.py \
@@ -616,6 +655,7 @@ python examples/offline_inference/text_to_speech/indextts2/end2end.py \
 ```
 
 ### Notes
+
 - `--ref-audio` is **required** — neither version provides text-only synthesis.
 - IndexTTS-2.5 Stage 0 (AR Talker) generates mel codes from text + reference audio using plain vLLM sampling. It does not reproduce the official default `num_beams=3` beam search. For parity comparisons, run upstream with `num_beams=1`; output quality can differ from the official beam-search result.
 - IndexTTS-2.5 accepts language codes such as `zh`, `en`, `zhen` (mixed Chinese/English), `ja`, and `yue`. `Mandarin` is a vLLM-Omni convenience alias for `zh`. Japanese (`ja`) uses `fugashi` tokenization and produces audio, but it does not automatically expand numbers, dates, or percentages; write those inputs as readable Japanese text before calling the model. Use `--no-text-normalization` only when the input is already normalized.
@@ -631,12 +671,15 @@ python examples/offline_inference/text_to_speech/indextts2/end2end.py \
 Voxtral-4B-TTS (Mistral). Has its own argparse surface; uses voice presets and the `mistral_common` `SpeechRequest` protocol.
 
 ### Prerequisites
+
 Latest `mistral_common` with `SpeechRequest` support:
+
 ```bash
 pip install -e /path/to/mistral-common  # or upgrade from PyPI when available
 ```
 
 ### Quick start (voice preset)
+
 ```bash
 python examples/offline_inference/text_to_speech/voxtral_tts/end2end.py \
     --write-audio --voice cheerful_female \
@@ -645,6 +688,7 @@ python examples/offline_inference/text_to_speech/voxtral_tts/end2end.py \
 ```
 
 ### Voice cloning (capability gated upstream)
+
 ```bash
 python examples/offline_inference/text_to_speech/voxtral_tts/end2end.py \
     --write-audio \
@@ -654,12 +698,14 @@ python examples/offline_inference/text_to_speech/voxtral_tts/end2end.py \
 ```
 
 ### Streaming + concurrency
+
 ```bash
 python examples/offline_inference/text_to_speech/voxtral_tts/end2end.py \
     --num-prompts 32 --concurrency 8 --streaming --write-audio --voice neutral_female \
     --model mistralai/Voxtral-4B-TTS-2603 \
     --text "..."
 ```
+
 Available voice presets are listed on the HF model card (`mistralai/Voxtral-4B-TTS-2603`).
 
 ### Notes
diff --git a/examples/offline_inference/text_to_speech/dots_tts/end2end.py b/examples/offline_inference/text_to_speech/dots_tts/end2end.py
deleted file mode 100644
index aa710db4a..000000000
--- a/examples/offline_inference/text_to_speech/dots_tts/end2end.py
+++ /dev/null
@@ -1,125 +0,0 @@
-"""Offline dots.tts inference example (single-stage native AR pipeline).
-
-Uses the single-stage native AR config (vllm_omni/deploy/dots_tts.yaml).
-Reference checkpoint: dots-studio/dots.tts-soar.
-"""
-
-from __future__ import annotations
-
-import os
-import time
-from pathlib import Path
-
-import soundfile as sf
-import torch
-
-from vllm_omni import Omni
-from vllm_omni.utils.tracking_parser import TrackingArgumentParser
-
-REPO_ROOT = Path(__file__).resolve().parents[4]
-SAMPLE_RATE = 48_000
-
-
-def parse_args():
-    parser = TrackingArgumentParser(description="Offline dots.tts native AR inference")
-    parser.add_argument(
-        "--model",
-        type=str,
-        default="dots-studio/dots.tts-soar",
-        help="dots.tts model path or HuggingFace repo ID.",
-    )
-    parser.add_argument(
-        "--text",
-        type=str,
-        default="Hello, this is a test of dots TTS running on vLLM Omni.",
-        help="Text to synthesize.",
-    )
-    parser.add_argument(
-        "--output-dir",
-        type=str,
-        default="output_audio",
-        help="Directory for output WAV files.",
-    )
-    parser.add_argument(
-        "--deploy-config",
-        type=str,
-        default=None,
-        help="Override the deploy config path. If unset, auto-loads "
-        "vllm_omni/deploy/dots_tts.yaml based on the HF model_type.",
-    )
-    return parser.parse_args()
-
-
-def extract_audio(multimodal_output: dict) -> torch.Tensor:
-    """Extract the final complete audio tensor from multimodal output.
-
-    The output processor concatenates per-step delta tensors under
-    ``model_outputs``.  Falls back to ``audio`` for backwards compat.
-    """
-    audio = multimodal_output.get("model_outputs")
-    if audio is None:
-        audio = multimodal_output.get("audio")
-    if audio is None:
-        raise ValueError(f"No audio key in multimodal_output: {list(multimodal_output.keys())}")
-
-    if isinstance(audio, list):
-        valid = [torch.as_tensor(a).float().cpu().reshape(-1) for a in audio if a is not None]
-        if not valid:
-            raise ValueError("Audio list is empty or all elements are None.")
-        return torch.cat(valid, dim=0) if len(valid) > 1 else valid[0]
-
-    return torch.as_tensor(audio).float().cpu().reshape(-1)
-
-
-def main():
-    args = parse_args()
-
-    output_dir = Path(args.output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    engine = Omni(
-        model=args.model,
-        deploy_config=args.deploy_config,
-    )
-
-    from transformers import AutoTokenizer
-
-    from vllm_omni.model_executor.models.dots_tts.dots_tts_prompt import (
-        build_dots_tts_prompt,
-    )
-
-    tokenizer = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True)
-
-    prompt = build_dots_tts_prompt(
-        tokenizer=tokenizer,
-        text=args.text,
-    )
-
-    print(f"Model       : {args.model}")
-    print(f"Text        : {args.text}")
-    print(f"Output dir  : {output_dir}")
-    print(f"Prompt len  : {len(prompt['prompt_token_ids'])} tokens")
-
-    t_start = time.perf_counter()
-    outputs = engine.generate([prompt])
-    elapsed = time.perf_counter() - t_start
-
-    request_output = outputs[0]
-    mm = request_output.outputs[0].multimodal_output
-    audio = extract_audio(mm)
-
-    duration = audio.numel() / SAMPLE_RATE
-    rtf = elapsed / duration if duration > 0 else float("inf")
-
-    output_path = output_dir / "output.wav"
-    sf.write(str(output_path), audio.numpy(), SAMPLE_RATE, format="WAV")
-
-    print(f"Saved       : {output_path}")
-    print(f"Duration    : {duration:.2f}s")
-    print(f"Inference   : {elapsed:.2f}s")
-    print(f"RTF         : {rtf:.3f}")
-
-
-if __name__ == "__main__":
-    os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-    main()
diff --git a/examples/offline_inference/text_to_video/text_to_video.py b/examples/offline_inference/text_to_video/text_to_video.py
index 06179ef9e..7b7bcb890 100644
--- a/examples/offline_inference/text_to_video/text_to_video.py
+++ b/examples/offline_inference/text_to_video/text_to_video.py
@@ -384,13 +384,20 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help='JSON profiler config for torch/cuda profiling, e.g. \'{"profiler":"torch","torch_profiler_dir":"./perf"}\'.',
     )
-    parser.add_argument(
+    quantization_group = parser.add_mutually_exclusive_group()
+    quantization_group.add_argument(
         "--quantization",
         type=str,
         default=None,
         choices=["fp8", "mxfp8", "mxfp4", "mxfp4_dualscale", "int8"],
         help="Quantization method for the transformer. mxfp8: W8A8 MXFP8 (NPU). mxfp4: W4A4 MXFP4 (NPU). mxfp4_dualscale: W4A4 MXFP4 dual-scale + BF16 fallback mixed (NPU). fp8: online FP8 (GPU).",
     )
+    quantization_group.add_argument(
+        "--quantization-config",
+        type=json.loads,
+        default=None,
+        help='Quantization JSON, e.g. \'{"method":"mxfp4","w4a8_fallback_steps":[0,2]}\'.',
+    )
 
     # Distributed and parallel execution
     parser.add_argument(
@@ -572,6 +579,8 @@ def main():
         omni_kwargs["flow_shift"] = args.flow_shift
     if args.quantization is not None:
         omni_kwargs["quantization"] = args.quantization
+    if args.quantization_config is not None:
+        omni_kwargs["quantization_config"] = args.quantization_config
     if args.cache_backend is not None:
         omni_kwargs["cache_backend"] = args.cache_backend
         omni_kwargs["cache_config"] = cache_config
diff --git a/examples/online_serving/dynin_omni/README.md b/examples/online_serving/dynin_omni/README.md
deleted file mode 100644
index 6e78a5c1f..000000000
--- a/examples/online_serving/dynin_omni/README.md
+++ /dev/null
@@ -1,97 +0,0 @@
-# Dynin-Omni: Online serving
-
-## Installation
-
-Please refer to [README.md](../../../README.md).
-
-## Launch the Server
-
-First, find the `transformers_modules` path:
-
-```bash
-python - <<'PY'
-from transformers.utils.hub import HF_MODULES_CACHE
-print(HF_MODULES_CACHE)
-PY
-```
-
-Then export it for both `PYTHONPATH` and `HF_MODULES_CACHE`:
-
-```bash
-export PYTHONPATH=<transformers_modules_path>:$PYTHONPATH
-export HF_MODULES_CACHE=<transformers_modules_path>
-```
-
-Run from repository root. The 3-stage pipeline is resolved automatically from
-the model type (`vllm_omni/deploy/dynin_omni.yaml`), so no config path is
-required. Pass `--deploy-config` only to override the defaults:
-
-```bash
-vllm-omni serve snu-aidas/Dynin-Omni \
-  --omni \
-  --port 8091
-```
-
-If `vllm-omni` is not in PATH, run:
-
-```bash
-PYTHONPATH="$(pwd)" python -m vllm_omni.entrypoints.cli.main serve snu-aidas/Dynin-Omni \
-  --omni \
-  --port 8091
-```
-
-Wait until the server logs show both `All stages initialized successfully` and
-`Application startup complete.` before sending requests.
-
-## Send Requests via Python Client
-
-Move to the example directory:
-
-```bash
-cd examples/online_serving/dynin_omni
-```
-
-### Text -> Image
-
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-  --query-type t2i \
-  --prompt "A realistic indoor living room with natural daylight."
-```
-
-### Image -> Image
-
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-  --query-type i2i \
-  --image-path ../../offline_inference/dynin_omni/data/image/sofa_under_water.jpg \
-  --prompt "Transform this surreal underwater setting into a realistic indoor living room while preserving the sofa layout."
-```
-
-### Text -> Speech
-
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-  --query-type t2s \
-  --prompt "Hello. This is Dynin-omni."
-```
-
-## CLI Arguments
-
-- `--query-type` (`t2i|t2s|i2i`)
-- `--model` (default: `snu-aidas/Dynin-Omni`)
-- `--host` / `--port` (OpenAI-compatible vLLM endpoint)
-- `--prompt` (custom text)
-- `--image-path` (required for `i2i`)
-- `--modalities` (optional output modalities override)
-- `--output-dir` (default: `/tmp/dynin_online_outputs`)
-
-## Notes
-
-- This client currently supports only `t2i`, `t2s`, and `i2i`.
-- `t2t` is intentionally not exposed in this online example.
-- This example intentionally uses the OpenAI-compatible chat completion endpoint.
-- Task routing for non-text outputs relies on Dynin task trigger tokens (`<|t2i|>`, `<|i2i|>`, `<|t2s|>`) injected by the client.
-- Outputs are saved under `/tmp/dynin_online_outputs` by default.
-- Dynin stage-0 warmup can take a while on first startup; do not send requests before startup completes.
-- Dynin itself can execute text-returning tasks such as `t2t`, `s2t`, `i2t`, and `v2t`, but this online serving example currently runs stage-0 in `generation` mode. In that path, the generation worker does not surface the final text as `output.text`, so OpenAI chat responses for those text-output tasks may complete internally but still return empty text.
diff --git a/examples/online_serving/dynin_omni/openai_chat_completion_client_for_multimodal_generation.py b/examples/online_serving/dynin_omni/openai_chat_completion_client_for_multimodal_generation.py
deleted file mode 100644
index 972855543..000000000
--- a/examples/online_serving/dynin_omni/openai_chat_completion_client_for_multimodal_generation.py
+++ /dev/null
@@ -1,342 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import argparse
-import base64
-import json
-import mimetypes
-import os
-import time
-from pathlib import Path
-from typing import Any
-
-DEFAULT_MODEL = "snu-aidas/Dynin-Omni"
-DEFAULT_OUTPUT_DIR = "/tmp/dynin_online_outputs"
-
-QUERY_CHOICES = ("t2i", "t2s", "i2i")
-DEFAULT_PROMPT_BY_QUERY = {
-    "t2i": "A high quality detailed living room interior photo.",
-    "t2s": "Please read this sentence naturally: Hello from Dynin-Omni online serving.",
-    "i2i": "Transform this image into a realistic indoor living room while preserving layout.",
-}
-DEFAULT_MODALITIES_BY_QUERY = {
-    "t2i": ["image"],
-    "t2s": ["audio"],
-    "i2i": ["image"],
-}
-OFFLINE_PARITY_STAGE_COUNT = 3
-OFFLINE_PARITY_STAGE_SAMPLING = {
-    "max_tokens": 1,
-    "temperature": 0.0,
-    "top_p": 1.0,
-    "detokenize": False,
-}
-
-
-def _infer_mime_type(path: Path) -> str:
-    mime_type, _ = mimetypes.guess_type(str(path))
-    return mime_type or "application/octet-stream"
-
-
-def _encode_file_as_data_url(path: Path) -> str:
-    mime_type = _infer_mime_type(path)
-    raw = path.read_bytes()
-    encoded = base64.b64encode(raw).decode("utf-8")
-    return f"data:{mime_type};base64,{encoded}"
-
-
-def _to_image_url(path_or_url: str) -> str:
-    value = str(path_or_url)
-    if value.startswith(("http://", "https://", "data:image/")):
-        return value
-    path = Path(value).expanduser().resolve()
-    if not path.exists():
-        raise FileNotFoundError(f"Image file not found: {path}")
-    return _encode_file_as_data_url(path)
-
-
-def _build_user_content(query_type: str, prompt: str, image_path: str | None) -> list[dict[str, Any]]:
-    if query_type == "t2i":
-        return [{"type": "text", "text": f"<|t2i|> {prompt}"}]
-
-    if query_type == "t2s":
-        return [{"type": "text", "text": f"<|t2s|> {prompt}"}]
-
-    if query_type == "i2i":
-        if not image_path:
-            raise ValueError("--image-path is required for query type i2i")
-        return [
-            {"type": "text", "text": f"<|i2i|> {prompt}"},
-            {"type": "image_url", "image_url": {"url": _to_image_url(image_path)}},
-        ]
-
-    raise ValueError(f"Unsupported query_type: {query_type}")
-
-
-def _collect_text_from_content(content: Any) -> list[str]:
-    texts: list[str] = []
-    if isinstance(content, str):
-        stripped = content.strip()
-        if stripped:
-            texts.append(stripped)
-        return texts
-
-    if isinstance(content, dict):
-        for key in ("text", "content", "value", "output_text"):
-            text_value = content.get(key)
-            if isinstance(text_value, str) and text_value.strip():
-                texts.append(text_value.strip())
-        return texts
-
-    if isinstance(content, list):
-        for item in content:
-            texts.extend(_collect_text_from_content(item))
-        return texts
-
-    content_text = getattr(content, "text", None)
-    if isinstance(content_text, str) and content_text.strip():
-        texts.append(content_text.strip())
-    content_value = getattr(content, "content", None)
-    if isinstance(content_value, str) and content_value.strip():
-        texts.append(content_value.strip())
-    output_text = getattr(content, "output_text", None)
-    if isinstance(output_text, str) and output_text.strip():
-        texts.append(output_text.strip())
-    return texts
-
-
-def _extract_text_outputs(chat_completion: Any) -> list[str]:
-    texts: list[str] = []
-    for choice in getattr(chat_completion, "choices", []) or []:
-        message = getattr(choice, "message", None)
-        if message is None:
-            continue
-        content = getattr(message, "content", None)
-        texts.extend(_collect_text_from_content(content))
-        reasoning_content = getattr(message, "reasoning_content", None)
-        if isinstance(reasoning_content, str) and reasoning_content.strip():
-            texts.append(reasoning_content.strip())
-        choice_text = getattr(choice, "text", None)
-        if isinstance(choice_text, str) and choice_text.strip():
-            texts.append(choice_text.strip())
-    top_level_output_text = getattr(chat_completion, "output_text", None)
-    if isinstance(top_level_output_text, str) and top_level_output_text.strip():
-        texts.append(top_level_output_text.strip())
-    return texts
-
-
-def _extract_image_data_urls(chat_completion: Any) -> list[str]:
-    urls: list[str] = []
-    for choice in getattr(chat_completion, "choices", []) or []:
-        message = getattr(choice, "message", None)
-        if message is None:
-            continue
-        content = getattr(message, "content", None)
-        if not isinstance(content, list):
-            continue
-        for item in content:
-            if not isinstance(item, dict):
-                continue
-            if item.get("type") != "image_url":
-                continue
-            image_url = (item.get("image_url") or {}).get("url")
-            if isinstance(image_url, str) and image_url.startswith("data:image"):
-                urls.append(image_url)
-    return urls
-
-
-def _extract_audio_payloads(chat_completion: Any) -> list[bytes]:
-    payloads: list[bytes] = []
-    for choice in getattr(chat_completion, "choices", []) or []:
-        message = getattr(choice, "message", None)
-        if message is None:
-            continue
-        message_audio = getattr(message, "audio", None)
-        if message_audio is None:
-            continue
-        data_b64 = getattr(message_audio, "data", None)
-        if isinstance(data_b64, str) and data_b64:
-            try:
-                payloads.append(base64.b64decode(data_b64))
-            except Exception:
-                continue
-    return payloads
-
-
-def _decode_data_url(data_url: str) -> tuple[bytes, str]:
-    header, data = data_url.split(",", 1)
-    mime_type = "image/png"
-    if ";" in header and ":" in header:
-        mime_type = header.split(":", 1)[1].split(";", 1)[0]
-    return base64.b64decode(data), mime_type
-
-
-def _image_extension_from_mime(mime_type: str) -> str:
-    if mime_type == "image/jpeg":
-        return ".jpg"
-    if mime_type == "image/webp":
-        return ".webp"
-    if mime_type == "image/gif":
-        return ".gif"
-    return ".png"
-
-
-def _save_outputs(
-    *,
-    query_type: str,
-    chat_completion: Any,
-    output_dir: Path,
-) -> None:
-    output_dir.mkdir(parents=True, exist_ok=True)
-    stamp = time.strftime("%Y%m%d_%H%M%S")
-
-    text_outputs = _extract_text_outputs(chat_completion)
-    image_data_urls = _extract_image_data_urls(chat_completion)
-    audio_payloads = _extract_audio_payloads(chat_completion)
-
-    if text_outputs:
-        text_path = output_dir / f"{query_type}_{stamp}.txt"
-        text_path.write_text("\n\n".join(text_outputs) + "\n", encoding="utf-8")
-        print(f"[dynin-online] text saved: {text_path}")
-        print(text_outputs[0])
-
-    for idx, image_url in enumerate(image_data_urls):
-        image_bytes, mime_type = _decode_data_url(image_url)
-        ext = _image_extension_from_mime(mime_type)
-        image_path = output_dir / f"{query_type}_{stamp}_{idx}{ext}"
-        image_path.write_bytes(image_bytes)
-        print(f"[dynin-online] image saved: {image_path}")
-
-    for idx, audio_bytes in enumerate(audio_payloads):
-        audio_path = output_dir / f"{query_type}_{stamp}_{idx}.wav"
-        audio_path.write_bytes(audio_bytes)
-        print(f"[dynin-online] audio saved: {audio_path}")
-
-    if not text_outputs and not image_data_urls and not audio_payloads:
-        print("[dynin-online] no output extracted from response")
-        raw_path = output_dir / f"{query_type}_{stamp}_raw_response.json"
-        try:
-            if hasattr(chat_completion, "model_dump_json"):
-                serialized = chat_completion.model_dump_json(indent=2)
-            else:
-                if hasattr(chat_completion, "model_dump"):
-                    raw_payload: Any = chat_completion.model_dump(mode="json")
-                else:
-                    raw_payload = chat_completion
-                try:
-                    serialized = json.dumps(raw_payload, ensure_ascii=False, indent=2)
-                except Exception:
-                    serialized = json.dumps({"repr": repr(raw_payload)}, ensure_ascii=False, indent=2)
-            raw_path.write_text(serialized + "\n", encoding="utf-8")
-            print(f"[dynin-online] raw response saved: {raw_path}")
-        except Exception:
-            pass
-
-
-def _build_offline_parity_sampling_params_list() -> list[dict[str, Any]]:
-    return [dict(OFFLINE_PARITY_STAGE_SAMPLING) for _ in range(OFFLINE_PARITY_STAGE_COUNT)]
-
-
-def run_request(args: argparse.Namespace) -> None:
-    from openai import OpenAI
-
-    client = OpenAI(
-        api_key="EMPTY",
-        base_url=f"http://{args.host}:{args.port}/v1",
-    )
-    prompt = args.prompt.strip() if args.prompt else DEFAULT_PROMPT_BY_QUERY[args.query_type]
-    user_content = _build_user_content(
-        query_type=args.query_type,
-        prompt=prompt,
-        image_path=args.image_path,
-    )
-    if args.modalities:
-        modalities = [item.strip() for item in args.modalities.split(",") if item.strip()]
-    else:
-        modalities = DEFAULT_MODALITIES_BY_QUERY[args.query_type]
-
-    extra_body = {
-        "sampling_params_list": _build_offline_parity_sampling_params_list(),
-    }
-    chat_completion = client.chat.completions.create(
-        model=args.model,
-        messages=[{"role": "user", "content": user_content}],
-        modalities=modalities,
-        extra_body=extra_body,
-    )
-    _save_outputs(
-        query_type=args.query_type,
-        chat_completion=chat_completion,
-        output_dir=Path(args.output_dir).expanduser(),
-    )
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Dynin-Omni online chat completion client")
-    parser.add_argument(
-        "--query-type",
-        "-q",
-        type=str,
-        default="t2i",
-        choices=QUERY_CHOICES,
-        help="Dynin query type",
-    )
-    parser.add_argument(
-        "--model",
-        "-m",
-        type=str,
-        default=DEFAULT_MODEL,
-        help="Model name/path",
-    )
-    parser.add_argument(
-        "--host",
-        type=str,
-        default="localhost",
-        help="Host/IP of the vLLM Omni API server",
-    )
-    parser.add_argument(
-        "--port",
-        type=int,
-        default=8091,
-        help="Port of the vLLM Omni API server",
-    )
-    parser.add_argument(
-        "--prompt",
-        "-p",
-        type=str,
-        default="",
-        help="Custom prompt text",
-    )
-    parser.add_argument(
-        "--image-path",
-        "-i",
-        type=str,
-        default=None,
-        help="Image path/URL for i2i",
-    )
-    parser.add_argument(
-        "--modalities",
-        type=str,
-        default="",
-        help="Comma-separated output modalities override (e.g., text,image,audio)",
-    )
-    parser.add_argument(
-        "--output-dir",
-        "-o",
-        type=str,
-        default=DEFAULT_OUTPUT_DIR,
-        help="Directory to save outputs",
-    )
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
-    run_request(args)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/online_serving/minicpmo/README.md b/examples/online_serving/minicpmo/README.md
index 67b268a77..ffd50167f 100644
--- a/examples/online_serving/minicpmo/README.md
+++ b/examples/online_serving/minicpmo/README.md
@@ -316,3 +316,12 @@ them unless `--allow-invalid-clock` is explicit.
   [`examples/offline_inference/minicpmo/`](../../offline_inference/minicpmo/)
 - Recipe:
   [`recipes/OpenBMB/MiniCPM-o-4_5.md`](../../../recipes/OpenBMB/MiniCPM-o-4_5.md)
+
+### Shared realtime UI implementation
+
+The `python -m examples.online_serving.minicpmo.realtime_web` command remains
+available with the same MiniCPM defaults and required `--ref-audio`. Its assets
+now live in [the shared realtime UI](../realtime_web/README.md), with a dedicated
+`minicpm-native` profile preserving native duplex input, playback ACKs and camera
+frames. Qwen3 uses a separate profile in the same shell, supporting manual STT
+turns or Server VAD turns with speech interruption.
diff --git a/examples/online_serving/minicpmo/realtime_web/server.py b/examples/online_serving/minicpmo/realtime_web/server.py
index ee78fff74..1ef12d186 100644
--- a/examples/online_serving/minicpmo/realtime_web/server.py
+++ b/examples/online_serving/minicpmo/realtime_web/server.py
@@ -1,185 +1,23 @@
-"""Static host and same-origin Realtime proxy for the full-duplex demo."""
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-from __future__ import annotations
+"""Backward-compatible MiniCPM entry point for the shared realtime UI."""
 
-import argparse
-import asyncio
-import base64
-import contextlib
-import hashlib
-import json
-import logging
-from pathlib import Path
-from urllib.parse import urlencode
+from examples.online_serving.realtime_web.server import (
+    APP_DIR,
+    STATIC_DIR,
+    _join_ws_url,
+    build_app,
+)
+from examples.online_serving.realtime_web.server import (
+    main as _main,
+)
 
-import uvicorn
-import websockets
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-from fastapi.responses import HTMLResponse, Response
-from fastapi.staticfiles import StaticFiles
-
-logger = logging.getLogger(__name__)
-APP_DIR = Path(__file__).parent / "app"
-STATIC_DIR = APP_DIR / "static"
-
-
-def _join_ws_url(base: str, path: str, query: str) -> str:
-    return base.rstrip("/") + path + (("?" + query) if query else "")
-
-
-async def _pump_client_to_backend(client: WebSocket, backend) -> None:
-    try:
-        while True:
-            message = await client.receive()
-            if message["type"] == "websocket.disconnect":
-                await backend.close()
-                return
-            if message.get("text") is not None:
-                await backend.send(message["text"])
-            elif message.get("bytes") is not None:
-                await backend.send(message["bytes"])
-    except (WebSocketDisconnect, websockets.ConnectionClosed):
-        with contextlib.suppress(Exception):
-            await backend.close()
-
-
-async def _pump_backend_to_client(client: WebSocket, backend) -> None:
-    try:
-        async for message in backend:
-            if isinstance(message, bytes):
-                await client.send_bytes(message)
-            else:
-                await client.send_text(message)
-    except (WebSocketDisconnect, websockets.ConnectionClosed):
-        return
-    except RuntimeError as exc:
-        if "websocket.send" in str(exc) and "websocket.close" in str(exc):
-            return
-        raise
-
-
-def _expected_proxy_close(exc: BaseException) -> bool:
-    if isinstance(exc, (WebSocketDisconnect, websockets.ConnectionClosed, asyncio.CancelledError)):
-        return True
-    return isinstance(exc, RuntimeError) and "websocket.send" in str(exc) and "websocket.close" in str(exc)
-
-
-def build_app(
-    *,
-    ws_backend: str = "ws://127.0.0.1:8099",
-    model: str = "openbmb/MiniCPM-o-4_5",
-    public_realtime_url: str | None = None,
-    ref_audio: str | None = None,
-) -> FastAPI:
-    app = FastAPI(title="Experimental Full-Duplex Web Demo")
-    index_path = APP_DIR / "index.html"
-    app_version_hash = hashlib.sha256()
-    for asset_path in (
-        STATIC_DIR / "app.js",
-        STATIC_DIR / "pcm_worklet.js",
-        STATIC_DIR / "playback_worklet.js",
-    ):
-        app_version_hash.update(asset_path.read_bytes())
-    app_version = app_version_hash.hexdigest()[:12]
-
-    ref_audio_uri: str | None = None
-    if ref_audio:
-        ref_path = Path(ref_audio)
-        if not ref_path.is_file():
-            raise SystemExit(f"--ref-audio not found: {ref_audio}")
-        encoded = base64.b64encode(ref_path.read_bytes()).decode("ascii")
-        ref_audio_uri = f"data:audio/wav;base64,{encoded}"
-
-    @app.get("/", response_class=HTMLResponse)
-    def index() -> HTMLResponse:
-        config = json.dumps(
-            {
-                "model": model,
-                "realtimePath": public_realtime_url or "v1/realtime",
-                "refAudio": ref_audio_uri,
-                "appVersion": app_version,
-            },
-            ensure_ascii=True,
-        )
-        html = (
-            index_path.read_text(encoding="utf-8")
-            .replace("__FULL_DUPLEX_CONFIG__", config)
-            .replace("__FULL_DUPLEX_APP_VERSION__", app_version)
-        )
-        return HTMLResponse(html, headers={"Cache-Control": "no-store"})
-
-    @app.get("/healthz")
-    def healthz() -> Response:
-        return Response(content="ok", media_type="text/plain")
-
-    @app.websocket("/v1/realtime")
-    async def realtime_proxy(websocket: WebSocket) -> None:
-        await websocket.accept()
-        query = urlencode(websocket.query_params.multi_items())
-        backend_url = _join_ws_url(ws_backend, "/v1/realtime", query)
-        logger.info("Proxying Realtime WebSocket to %s", backend_url)
-        try:
-            async with websockets.connect(
-                backend_url,
-                max_size=64 * 1024 * 1024,
-            ) as backend:
-                tasks = {
-                    asyncio.create_task(_pump_client_to_backend(websocket, backend)),
-                    asyncio.create_task(_pump_backend_to_client(websocket, backend)),
-                }
-                done, pending = await asyncio.wait(
-                    tasks,
-                    return_when=asyncio.FIRST_COMPLETED,
-                )
-                for task in pending:
-                    task.cancel()
-                await asyncio.gather(*pending, return_exceptions=True)
-                for result in await asyncio.gather(*done, return_exceptions=True):
-                    if isinstance(result, BaseException) and not _expected_proxy_close(result):
-                        raise result
-        except (WebSocketDisconnect, websockets.ConnectionClosed):
-            return
-        except Exception:
-            logger.exception("Realtime WebSocket proxy failed")
-            with contextlib.suppress(Exception):
-                await websocket.close(code=1011)
-
-    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
-    return app
+__all__ = ["APP_DIR", "STATIC_DIR", "_join_ws_url", "build_app", "main"]
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--host", default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=7862)
-    parser.add_argument("--ws-backend", default="ws://127.0.0.1:8099")
-    parser.add_argument(
-        "--public-realtime-url",
-        help="Browser-visible ws:// or wss:// Realtime URL; defaults to the same-origin proxy.",
-    )
-    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
-    parser.add_argument(
-        "--ref-audio",
-        required=True,
-        help=(
-            "Reference voice wav for TTS voice cloning, e.g. the "
-            "official MiniCPM-o-Demo assets/ref_audio/ref_minicpm_signature.wav"
-        ),
-    )
-    args = parser.parse_args()
-
-    logging.basicConfig(level=logging.INFO)
-    uvicorn.run(
-        build_app(
-            ws_backend=args.ws_backend,
-            model=args.model,
-            public_realtime_url=args.public_realtime_url,
-            ref_audio=args.ref_audio,
-        ),
-        host=args.host,
-        port=args.port,
-        log_level="info",
-    )
+    _main(default_profile="minicpm-native")
 
 
 if __name__ == "__main__":
diff --git a/examples/online_serving/qwen3_omni/README.md b/examples/online_serving/qwen3_omni/README.md
index 107e1f098..5eb9a2042 100644
--- a/examples/online_serving/qwen3_omni/README.md
+++ b/examples/online_serving/qwen3_omni/README.md
@@ -14,6 +14,17 @@ Please refer to [README.md](../../../README.md)
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```
 
+For a local deployment with multiple API frontend processes sharing one set
+of stage engines, add `--api-server-count`:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --api-server-count 2 --port 8091
+```
+
+This mode currently supports local EngineCore stages. It is not available
+with headless or remote stage deployments, and pure diffusion stages remain
+single-frontend.
+
 The default deployment configuration, situated at `vllm_omni/deploy/qwen3_omni_moe.yaml`, is resolved and loaded
 automatically via the model registry, obviating the `--deploy-config` flag in standard deployment topologies.
 Asynchronous chunk streaming operates as **enabled by default** within this bundled configuration.
@@ -156,7 +167,7 @@ parser defaults). If you don't pass a flag, the YAML value wins.
 > chunked vs end-to-end modes (e.g. qwen3_tts code2wav) dispatch
 > automatically based on that bool — no extra flag or variant yaml is
 > needed.
-
+>
 > ⚠️ **For multi-stage models that share GPUs (qwen3_omni_moe by default
 > shares cuda:1 between stages 1 and 2), avoid using global memory flags.**
 > A global `--gpu-memory-utilization 0.85` would apply to every stage and
@@ -309,24 +320,17 @@ python openai_realtime_client.py \
 Server VAD uses the pinned Silero v6.2 ONNX artifact from `istupakov/silero-vad-onnx` and never downloads model files while processing a session. Make the artifact available in the Hugging Face cache before startup, or configure a local artifact in the deployment YAML:
 
 ```yaml
+base_config: /path/to/vllm-omni/vllm_omni/deploy/qwen3_omni_duplex.yaml
 duplex_session:
   server_vad_model_path: /models/silero_vad.onnx
 ```
 
-Start from the bundled Qwen3-Omni deployment YAML, add the fields above at the top level, and serve that complete configuration:
-
-```bash
-cp vllm_omni/deploy/qwen3_omni_moe.yaml /path/to/qwen3_omni_server_vad.yaml
-# Edit /path/to/qwen3_omni_server_vad.yaml and add duplex_session.
-vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct \
-  --omni \
-  --port 8091 \
-  --deploy-config /path/to/qwen3_omni_server_vad.yaml
-```
-
-Keep Qwen's default `session_mode: turn`; `duplex_session` enables the Realtime handler without changing scheduler
-semantics. Bare `/v1/realtime` selects that handler. The client uses `?duplex=0` only for the existing non-Server-VAD
-wire flow; `?duplex=1` remains a supported compatibility alias.
+For the engine-owned plugin, use an overlay based on
+`vllm_omni/deploy/qwen3_omni_duplex.yaml`, with `duplex_session.server_vad_model_path`
+pointing to your local artifact. See the [complete duplex setup](../realtime_web/README.md#qwen3-with-server-vad-automatic-turns).
+The default `qwen3_omni_moe.yaml` remains a turn deployment. Duplex mode serves
+`/v1/realtime?duplex=1` and `/v1/chat/completions`; the legacy STT handler requires
+a turn deployment.
 
 The Python client supports the following command-line arguments:
 
@@ -573,3 +577,53 @@ The gradio script supports the following arguments:
 - `--ip`: Host/IP for Gradio server (default: 127.0.0.1)
 - `--port`: Port for Gradio server (default: 7861)
 - `--share`: Share the Gradio demo publicly (creates a public link)
+
+## Browser voice call (shared realtime UI)
+
+Run these commands from the repository root with the vLLM-Omni environment activated.
+
+### Without VAD: manually submit each turn
+
+Start the backend:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
+```
+
+In another terminal, check backend readiness and start the UI:
+
+```bash
+curl --fail http://127.0.0.1:8091/health
+python -m examples.online_serving.qwen3_omni.realtime_web \
+    --backend ws://127.0.0.1:8091 --stt --port 7863
+```
+
+Open `http://localhost:7863`, start a session, speak, and press **Send turn**.
+`--stt` is the default. Each turn uses a separate connection without shared model
+history; the conversation shown in the browser is a local log.
+
+### With VAD: automatically submit after silence
+
+Start the backend with a Server VAD deployment overlay and a compatible Silero
+ONNX artifact, following the
+[complete VAD setup](../realtime_web/README.md#qwen3-with-server-vad-automatic-turns).
+After its health check succeeds, start the UI:
+
+```bash
+python -m examples.online_serving.qwen3_omni.realtime_web \
+    --backend ws://127.0.0.1:8091 --vad --port 7863
+```
+
+Speak and pause for 500 ms to submit automatically. `--vad` configures the client;
+it does not load a VAD model or change the backend deployment by itself.
+
+VAD mode keeps uploading audio during replies and supports speech interruption.
+The engine-owned Qwen duplex plugin maintains conversation history and tracks
+played replies through playback acknowledgements. Each committed utterance starts
+a new generation request; the model does not use native streaming-input KV decoding.
+STT mode pauses microphone upload while the reply is generated and played.
+In VAD mode, click **Camera** to upload sampled frames with your spoken question;
+see [camera setup and limits](../realtime_web/README.md#qwen-vad-camera-input).
+STT remains audio-only. To switch back to manual turns, use the default turn
+deployment, restart the UI with `--stt`, refresh the page, and reconnect. Stop the existing UI before reusing port 7863.
+See the [shared UI guide](../realtime_web/README.md) for HTTPS access and testing.
diff --git a/examples/online_serving/qwen3_omni/openai_realtime_client.py b/examples/online_serving/qwen3_omni/openai_realtime_client.py
index 0a98d69a0..2a6bca0fe 100644
--- a/examples/online_serving/qwen3_omni/openai_realtime_client.py
+++ b/examples/online_serving/qwen3_omni/openai_realtime_client.py
@@ -130,7 +130,7 @@ async def run_client(
                                 "prefix_padding_ms": 300,
                                 "silence_duration_ms": 500,
                                 "create_response": True,
-                                "interrupt_response": False,
+                                "interrupt_response": True,
                             },
                         }
                     },
@@ -233,6 +233,7 @@ async def run_client(
                 continue
 
             if event_type == "response.done" and server_vad:
+                await ws.send(json.dumps({"type": "session.close"}))
                 break
 
             if event_type == "error":
diff --git a/examples/online_serving/qwen3_omni/realtime_web/__init__.py b/examples/online_serving/qwen3_omni/realtime_web/__init__.py
new file mode 100644
index 000000000..14c5daad2
--- /dev/null
+++ b/examples/online_serving/qwen3_omni/realtime_web/__init__.py
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Qwen3-Omni turn-based browser call UI."""
diff --git a/examples/online_serving/qwen3_omni/realtime_web/__main__.py b/examples/online_serving/qwen3_omni/realtime_web/__main__.py
new file mode 100644
index 000000000..698179528
--- /dev/null
+++ b/examples/online_serving/qwen3_omni/realtime_web/__main__.py
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from examples.online_serving.realtime_web.server import main
+
+if __name__ == "__main__":
+    main(default_profile="qwen3-turn")
diff --git a/examples/online_serving/realtime_web/README.md b/examples/online_serving/realtime_web/README.md
new file mode 100644
index 000000000..854aa4718
--- /dev/null
+++ b/examples/online_serving/realtime_web/README.md
@@ -0,0 +1,221 @@
+# Shared Realtime Web UI
+
+One browser shell provides microphone capture, speaker playback, a level meter,
+conversation text, and an event log. Model profiles own the wire protocol.
+This implements [RFC #7222](https://github.com/vllm-project/vllm-omni/issues/7222).
+
+| Profile | Turn control | Camera | Playback acknowledgement |
+| --- | --- | --- | --- |
+| `minicpm-native` | Model-controlled listen/speak, continuous audio input | Frames accompany audio | Yes |
+| `qwen3-turn --stt` (default) | User presses **Send turn** | No | No |
+| `qwen3-turn --vad` | Server detects trailing silence; speech interrupts replies | Sampled frames with each spoken turn | Yes |
+
+Qwen3 VAD uses an engine-owned duplex plugin: microphone upload continues
+while replies stream, and speech can interrupt generation and playback. The
+checkpoint still generates committed turns; this is not native streaming-input
+KV decoding. STT remains explicit-turn and audio-only.
+
+## MiniCPM: existing command stays valid
+
+Start your MiniCPM backend using the [existing deployment instructions](../minicpmo/README.md), then:
+
+```bash
+python -m examples.online_serving.minicpmo.realtime_web \
+    --ws-backend ws://127.0.0.1:8099 \
+    --ref-audio /path/to/ref_minicpm_signature.wav
+```
+
+The compatibility wrapper serves the shared assets with `minicpm-native`.
+The current native query, `extra_body`, reference voice, continuous microphone
+upload, camera frames and playback acknowledgements are retained.
+
+## Qwen3: explicit-turn STT adapter
+
+Start the backend, then the UI in a second terminal:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
+
+python -m examples.online_serving.qwen3_omni.realtime_web \
+    --backend ws://127.0.0.1:8091 --stt --port 7863
+```
+
+Open `http://localhost:7863`, start a session, speak, and press **Send turn**.
+Wait for the answer to finish playing before speaking again. The UI opens a
+fresh STT connection for each turn; the displayed conversation is a local log,
+and **previous turns are not provided as model history**. The STT endpoint
+accepts only model selection, so system-prompt controls are hidden in this mode.
+
+The adapter follows the shipped `qwen3_omni/openai_realtime_client.py` and
+`vllm_omni/entrypoints/openai/realtime_connection.py`:
+
+1. Explicit `duplex=0` selects the legacy STT handler on a turn deployment.
+   It does not enable STT on a duplex deployment.
+2. Send `{type: "session.update", model: ...}` and `commit(final=false)`.
+3. Stream mono PCM16 at 16 kHz; **Send turn** flushes buffered audio, then sends `commit(final=true)`.
+4. `response.output_audio.delta.audio` contains PCM; `response.output_audio.done`
+   terminates this adapter, including a response with no audio.
+5. The local implementation emits **model output** on `transcription.*`, so the
+   UI displays it as assistant text. This differs from the early RFC's suggested
+   user-transcript mapping. The VAD adapter also supports `response.output_text.*`
+   and audio-transcript events without duplicating the answer.
+
+## Qwen3 with Server VAD (automatic turns)
+
+Run commands from the repository root with the vLLM-Omni environment activated.
+Prepare the pinned Silero v6.2 ONNX artifact as described in the
+[Qwen3 Server VAD instructions](../qwen3_omni/README.md#realtime-websocket-client-openai_realtime_clientpy).
+The backend requires ONNX Runtime and a compatible local artifact; setting
+`--vad` on the UI alone does not enable VAD on the backend.
+
+Create an overlay named `qwen3_vad.yaml`, replacing both paths with absolute paths
+on the backend host:
+
+```yaml
+base_config: /path/to/vllm-omni/vllm_omni/deploy/qwen3_omni_duplex.yaml
+duplex_session:
+  server_vad_model_path: /path/to/silero_vad.onnx
+```
+
+The base configuration enables duplex mode and sets the per-prompt audio and image limits.
+
+Start the backend:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091 \
+    --deploy-config qwen3_vad.yaml
+```
+
+In a second terminal, wait until the health check succeeds, then start the UI:
+
+```bash
+curl --fail http://127.0.0.1:8091/health
+python -m examples.online_serving.qwen3_omni.realtime_web \
+    --backend ws://127.0.0.1:8091 --vad --port 7863
+```
+
+Open `http://localhost:7863` and start a session. Speak and pause: the server
+commits the turn automatically after 500 ms of silence. No **Send turn** action
+is needed. Defaults are a speech threshold of 0.5 and 300 ms of prefix padding.
+Speak again to interrupt an answer. The engine owns input buffering, VAD,
+request cancellation, playback acknowledgements, and conversation history.
+Each committed utterance starts a normal Thinker → Talker → Code2Wav request;
+it does not append input to a live Qwen KV cache. The capability response reports
+`implementation_level: turn_based_duplex` and `supports_core_resumable_request: false`.
+
+The plugin retains up to four audio inputs (including the current turn), pruning
+older audio at an 8 MiB base64 budget; one current utterance is bounded by the
+engine's pending-input limit. The UI reports playback progress both on normal
+drain and on interruption. Qwen does not provide text/audio alignment, so assistant
+text enters history only after the complete audio response has been generated and
+acknowledged as played. A partially played answer contributes no guessed text
+prefix. Image conversation items remain available until deleted. Model context limits still apply.
+The bundled duplex deploy allows four audio inputs and eight images per prompt.
+Use headphones to avoid speaker audio triggering VAD interruption. Reference
+voices and tool calls are not supported by this plugin.
+
+### Switching between VAD and manual turns
+
+| Mode | Backend | UI flag | Submit a turn |
+| --- | --- | --- | --- |
+| Without VAD | Default Qwen turn deployment | `--stt` (default) | Press **Send turn** |
+| With VAD | Server VAD configuration and Silero artifact | `--vad` | Pause after speaking |
+
+Stop the existing UI process before starting another on the same port, then
+refresh the browser and reconnect. To use STT, start a backend with the default
+turn deployment and restart the UI with `--stt`. The duplex backend exposes
+Realtime duplex and ChatCompletion; it does not expose the legacy STT handler.
+To enable VAD on a default backend, first restart that backend with the overlay.
+Make `--backend` match the actual backend port; the UI and backend use separate
+ports. `Connection refused` means the target backend is unavailable: check its
+startup log and `/health` before connecting.
+
+VAD connects with `duplex=1` and sends nested `session.audio.input` configuration
+with `create_response: true` and `interrupt_response: true`. It sends playback
+ACKs when speaker audio drains. `response.audio.done` / `response.output_audio.done`
+only drain playback; `response.done` terminates a turn. Backpressure displays a
+notice without pausing the microphone. Failed handshakes time out after 15 seconds;
+Silero initialization failures display a specific error.
+
+After updating the backend Python code, restart the backend, refresh the UI, and
+start a new session so the plugin and browser assets use the updated code. A
+successful `/health` check confirms readiness, not which deployment mode is active.
+
+## Qwen VAD camera input
+
+After starting a session with `--vad`, click **Camera** and allow access. The UI
+sends one JPEG per second, resized to a longest side of 448 pixels, independently
+of microphone uploads (including while muted). Each frame is a user conversation
+item using the [OpenAI Realtime image input](https://developers.openai.com/api/docs/guides/realtime-conversations#image-inputs) shape:
+
+```json
+{"type":"conversation.item.create","item":{"id":"camera_1","type":"message","role":"user","content":[{"type":"input_image","image_url":"data:image/jpeg;base64,..."}]}}
+```
+
+Images become conversation context immediately; they do not start a response.
+Speak and let VAD commit your audio, or send `response.create` after adding an
+image/text item. A manual `input_audio_buffer.commit` only commits audio; follow
+it with `response.create` to generate. Images persist across audio commits,
+interruptions, and audio-buffer clears. Remove them with `conversation.item.delete`.
+The browser retains eight camera items and deletes the oldest before adding a
+ninth. Camera-off stops capture but leaves those items in the conversation.
+
+This deployment accepts JPEG/PNG Base64 data URLs with a total image-context
+budget of eight images and 4 MiB; external image URLs are not supported. Clients
+must delete old image items when reaching the limit. There is no precise
+video/audio timestamp alignment or native streaming-video KV update.
+
+### Protocol compatibility boundary
+
+Qwen VAD uses `session.update`, 24 kHz PCM16 `input_audio_buffer.append`,
+`conversation.item.create` with `input_image`/`input_text`, and `response.create`.
+The engine resamples input to Qwen's 16 kHz processing rate. Qwen rejects the
+custom `video_frames` field on an append: it answers whole turns, so it has no
+audio unit for a frame track to align to. MiniCPM keeps that field for its
+native camera protocol, where Stage 0 interleaves frames at unit boundaries.
+
+This is a supported subset, not full OpenAI Realtime API compatibility.
+`duplex=1`, `overlap_policy`, `playback.ack`, and `session.close` remain vLLM-Omni
+extensions. The legacy `--stt` mode is unchanged and is not the standard Realtime
+conversation API. This demo does not add WebRTC, semantic VAD, or tool calling.
+
+## Shared host options
+
+The shared entry point can select either profile explicitly:
+
+```bash
+python -m examples.online_serving.realtime_web --profile qwen3-turn \
+    --backend ws://127.0.0.1:8091 --stt --port 7863
+```
+
+- `--backend` / `--ws-backend`: backend WebSocket origin (not the full `/v1/realtime` URL).
+- `--model`: override the wrapper's model name.
+- `--public-realtime-url`: optional browser-visible WebSocket URL; otherwise the
+  static host proxies `/v1/realtime` on the same origin.
+- `--host`, `--port`: UI bind address and port (default port 7862).
+- `--ref-audio`: required for MiniCPM; rejected for Qwen3.
+
+Microphone and camera access require `localhost` or HTTPS. For a remote backend,
+use an SSH tunnel to the UI host or an HTTPS reverse proxy with WebSocket support.
+An explicit `wss://` public URL retains its scheme.
+
+## Validation
+
+```bash
+node --test tests/examples/test_realtime_web_profiles.cjs
+pytest tests/examples/test_minicpmo_realtime_web_server.py \
+       tests/examples/test_minicpmo_realtime_web_static.py \
+       tests/examples/test_realtime_web_profiles.py
+pytest -m cpu tests/model_executor/models/qwen3_omni/test_duplex_plugin.py \
+       tests/engine/duplex/test_session_runner.py \
+       tests/engine/test_duplex_orchestrator.py
+```
+
+These CPU tests cover profile messages, two STT turns, VAD terminal/drain ordering,
+backpressure, native capture during playback, server config injection, and shared
+worklets. Backend regressions cover current audio inclusion in history-based
+prompts, delayed playback ACK ordering, and no extra generation during silence
+after a completed VAD turn. Hardware acceptance still requires a MiniCPM call
+with camera/barge-in and two Qwen turns against each enabled backend, including
+speech interruption in VAD mode; simulated tests do not
+establish model quality or hardware latency.
diff --git a/examples/online_serving/realtime_web/__init__.py b/examples/online_serving/realtime_web/__init__.py
new file mode 100644
index 000000000..9e82f8967
--- /dev/null
+++ b/examples/online_serving/realtime_web/__init__.py
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Shared browser audio UI and model-specific realtime profiles."""
diff --git a/examples/online_serving/realtime_web/__main__.py b/examples/online_serving/realtime_web/__main__.py
new file mode 100644
index 000000000..618f3c542
--- /dev/null
+++ b/examples/online_serving/realtime_web/__main__.py
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from .server import main
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/minicpmo/realtime_web/app/index.html b/examples/online_serving/realtime_web/app/index.html
similarity index 76%
rename from examples/online_serving/minicpmo/realtime_web/app/index.html
rename to examples/online_serving/realtime_web/app/index.html
index 46ab15907..a38a731e4 100644
--- a/examples/online_serving/minicpmo/realtime_web/app/index.html
+++ b/examples/online_serving/realtime_web/app/index.html
@@ -4,37 +4,35 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="color-scheme" content="light">
-    <title>MiniCPM-o 4.5 Voice</title>
+    <title>Omni Realtime Voice</title>
     <link rel="stylesheet" href="static/styles.css">
   </head>
   <body>
     <header class="app-header">
       <div>
-        <p class="eyebrow">Experimental full-duplex runtime</p>
-        <h1>MiniCPM-o 4.5 Voice</h1>
+        <p id="pageEyebrow" class="eyebrow"></p>
+        <h1 id="pageTitle">Omni Realtime Voice</h1>
       </div>
       <span id="connectionState" class="status status-offline">Offline</span>
     </header>
 
     <main>
+      <p id="profileDescription" role="note"></p>
       <section class="call-bar" aria-label="Session controls">
         <div class="call-actions">
           <button id="callButton" class="primary" type="button">Start session</button>
+          <button id="sendTurnButton" class="secondary" type="button" hidden disabled>Send turn</button>
           <button id="muteButton" class="secondary" type="button" disabled>Mute</button>
           <button id="cameraButton" class="secondary" type="button" disabled>Camera</button>
           <video id="cameraPreview" muted playsinline style="display:none;width:96px;height:72px;border-radius:8px;object-fit:cover;background:#000"></video>
         </div>
-        <div style="display:flex;gap:8px;align-items:flex-start;margin-top:8px;width:100%">
+        <div id="promptControls" style="display:flex;gap:8px;align-items:flex-start;margin-top:8px;width:100%">
           <label style="display:inline-flex;flex-direction:column;gap:4px;font-size:13px;opacity:.85;white-space:nowrap">
             Prompt preset
             <select id="promptPreset" style="font-size:13px;padding:4px 6px;border-radius:6px">
-              <option value="omni" selected>Omni (official omni preset)</option>
-              <option value="chinese_call">中文通话 (official audio preset)</option>
-              <option value="english_call">English Call (official audio preset)</option>
-              <option value="custom">Custom</option>
             </select>
           </label>
-          <textarea id="systemPrompt" rows="2" placeholder="System prompt" style="flex:1;font-size:13px;padding:6px 8px;border-radius:6px;resize:vertical">Streaming Omni Conversation.</textarea>
+          <textarea id="systemPrompt" rows="2" placeholder="System prompt" style="flex:1;font-size:13px;padding:6px 8px;border-radius:6px;resize:vertical"></textarea>
         </div>
         <div class="meter" aria-label="Microphone level">
           <span>Mic</span>
@@ -53,7 +51,7 @@
             <p class="eyebrow">Live transcript</p>
             <h2 id="conversationTitle">Conversation</h2>
           </div>
-          <span class="policy-label">Model-controlled listen / speak</span>
+          <span id="policyLabel" class="policy-label"></span>
         </div>
         <div id="conversation" class="conversation" aria-live="polite">
           <p id="emptyConversation" class="empty-state">Start a session and speak naturally.</p>
@@ -73,7 +71,10 @@
       </details>
     </main>
 
-    <script>window.FULL_DUPLEX_CONFIG = __FULL_DUPLEX_CONFIG__;</script>
+    <script>window.OMNI_REALTIME_CONFIG = __FULL_DUPLEX_CONFIG__; window.FULL_DUPLEX_CONFIG = window.OMNI_REALTIME_CONFIG;</script>
+    <script src="static/profiles/common.js?v=__FULL_DUPLEX_APP_VERSION__"></script>
+    <script src="static/profiles/minicpm_native.js?v=__FULL_DUPLEX_APP_VERSION__"></script>
+    <script src="static/profiles/qwen3_turn.js?v=__FULL_DUPLEX_APP_VERSION__"></script>
     <script src="static/app.js?v=__FULL_DUPLEX_APP_VERSION__"></script>
   </body>
 </html>
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/app.js b/examples/online_serving/realtime_web/app/static/app.js
similarity index 56%
rename from examples/online_serving/minicpmo/realtime_web/app/static/app.js
rename to examples/online_serving/realtime_web/app/static/app.js
index 4d2b78247..1dd01d4b3 100644
--- a/examples/online_serving/minicpmo/realtime_web/app/static/app.js
+++ b/examples/online_serving/realtime_web/app/static/app.js
@@ -1,8 +1,10 @@
 (() => {
   'use strict';
 
-  const config = window.FULL_DUPLEX_CONFIG || {};
+  const config = window.OMNI_REALTIME_CONFIG || window.FULL_DUPLEX_CONFIG || {};
+  const profile = window.OmniRealtimeProfiles[config.profile || 'minicpm-native'](config);
   const callButton = document.getElementById('callButton');
+  const sendTurnButton = document.getElementById('sendTurnButton');
   const muteButton = document.getElementById('muteButton');
   const cameraButton = document.getElementById('cameraButton');
   const cameraPreview = document.getElementById('cameraPreview');
@@ -27,20 +29,26 @@
   const INITIAL_PLAYBACK_BUFFER_MS = 400;
   const SESSION_CLOSE_TIMEOUT_MS = 1000;
 
-  // Default prompts mirroring the official MiniCPM-o-Demo presets
-  // (assets/presets/{omni,audio_duplex}/*.yaml).
-  const PROMPT_PRESETS = {
-    omni: 'Streaming Omni Conversation.',
-    chinese_call: '扮演一个具有以上声音特征的助手。请认真、高质量地回复用户的问题。'
-      + '请用高自然度的方式和用户聊天。你处于双工模式，可以一边听、一边说。'
-      + '你是由面壁智能开发的人工智能助手：面壁小钢炮。',
-    english_call: 'Replicate the tone and style from the input audio. Your task is to be '
-      + 'a helpful assistant using this voice pattern. Please answer the user\'s questions '
-      + 'seriously and in a high quality. Please chat with the user in a high naturalness '
-      + 'style. You are in duplex mode, where you can listen and speak at the same time.',
-  };
+  const PROMPT_PRESETS = profile.presets;
+  document.title = profile.title;
+  document.getElementById('pageTitle').textContent = profile.title;
+  document.getElementById('pageEyebrow').textContent = profile.eyebrow;
+  document.getElementById('profileDescription').textContent = profile.description;
+  document.getElementById('policyLabel').textContent = profile.policy;
+  cameraButton.hidden = !profile.camera;
+  sendTurnButton.hidden = !profile.clientCommit;
+  promptPreset.replaceChildren();
+  for (const name of [...Object.keys(PROMPT_PRESETS), 'custom']) {
+    const option = document.createElement('option');
+    option.value = name;
+    option.textContent = name.replaceAll('_', ' ');
+    promptPreset.appendChild(option);
+  }
+  systemPromptInput.value = Object.values(PROMPT_PRESETS)[0];
+  document.getElementById('promptControls').hidden = !profile.instructions;
 
   let socket = null;
+  let closingSocket = null;
   let mediaStream = null;
   let captureContext = null;
   let captureNode = null;
@@ -65,6 +73,70 @@
   let liveUserTurn = null;
   let liveAssistantTurn = null;
   let sessionCloseResolver = null;
+  let responseComplete = false;
+  let playbackComplete = true;
+  let turnSubmitted = false;
+  let echoTimer = null;
+  let sessionGeneration = 0;
+  let audioChain = Promise.resolve();
+  // Retain interrupted IDs until startSession() resets the session. Queued
+  // events and pending audio decodes can outlive response.done, so removing
+  // IDs there could resume interrupted playback. This set grows with the
+  // interruptions in a call; sessionGeneration rejects old-session decodes
+  // after the set is cleared for a new session.
+  const interruptedResponses = new Set();
+  const pendingEvents = new Set();
+  let assistantTextChannel = null;
+  let connectionReady = false;
+  let turnCounter = 0;
+  let stopping = null;
+  let turnTimeout = null;
+
+  function markBusy() {
+    assistantActive = true;
+    if (profile.halfDuplex) pendingCapture = [];
+  }
+
+  function armTurnTimeout() {
+    clearTimeout(turnTimeout);
+    turnTimeout = window.setTimeout(() => {
+      failSession('Timed out waiting for the model response. Check the backend event log and restart the session.');
+    }, 120000);
+  }
+
+  async function failSession(message) {
+    appendLog(message, true);
+    await stopSession({ terminal: false });
+    setConnection('Error', 'error');
+    runtimeDetail.textContent = message;
+  }
+
+  function finishResponseIfReady() {
+    if (!responseComplete || !playbackComplete || echoTimer !== null) return;
+    const generation = sessionGeneration;
+    echoTimer = window.setTimeout(async () => {
+      echoTimer = null;
+      if (!running || generation !== sessionGeneration) return;
+      if (profile.reconnectEachTurn) {
+        connectionReady = false;
+        const previous = socket;
+        socket = null;
+        if (previous) { previous.onclose = null; previous.onmessage = null; previous.close(); }
+        try { await openSocket(); }
+        catch (error) { await failSession(error.message); return; }
+        if (!running || generation !== sessionGeneration) return;
+      }
+      assistantActive = false;
+      responseComplete = false;
+      turnSubmitted = false;
+      currentResponseId = null;
+      responseHasAudio = false;
+      assistantTextChannel = null;
+      if (profile.halfDuplex) pendingCapture = [];
+      sendTurnButton.disabled = !profile.clientCommit;
+      setModel(profile.waiting);
+    }, ECHO_GUARD_MS);
+  }
 
   function staticAssetUrl(path) {
     const version = String(config.appVersion || '').trim();
@@ -82,12 +154,7 @@
   }
 
   function realtimeUrl() {
-    const url = new URL(config.realtimePath, window.location.href);
-    url.protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    url.searchParams.set('duplex', '1');
-    url.searchParams.set('model', config.model || 'openbmb/MiniCPM-o-4_5');
-    url.searchParams.set('autostart', '0');
-    return url.toString();
+    return profile.url(config, window.location.href);
   }
 
   function setConnection(label, kind) {
@@ -250,7 +317,7 @@
   }
 
   function microphoneUploadEnabled() {
-    return running && !muted;
+    return running && connectionReady && !muted && (!profile.halfDuplex || !assistantActive);
   }
 
   function flushCapture() {
@@ -267,19 +334,9 @@
       offset += chunk.length;
     }
     pendingCapture = [];
-    const pcm = resampleInt16(merged, captureRate, INPUT_RATE);
-    const appendEvent = {
-      type: 'input_audio_buffer.append',
-      audio: int16ToBase64(pcm),
-      format: 'pcm16',
-      sample_rate_hz: INPUT_RATE,
-    };
-    // Omni duplex: ~1 fps camera frame rides the audio append (official
-    // MiniCPM-o-Demo contract: one base64 JPEG per ~1 s chunk).
-    if (cameraPendingFrame) {
-      appendEvent.video_frames = [cameraPendingFrame];
-      cameraPendingFrame = null;
-    }
+    const pcm = resampleInt16(merged, captureRate, profile.inputSampleRate || INPUT_RATE);
+    const appendEvent = profile.append(int16ToBase64(pcm), cameraPendingFrame);
+    cameraPendingFrame = null;
     socket.send(JSON.stringify(appendEvent));
   }
 
@@ -287,13 +344,17 @@
     currentResponseId = responseId || currentResponseId;
     responseHasAudio = false;
     assistantActive = true;
-    setModel('Speaking');
+    responseComplete = false;
+    playbackComplete = true;
+    if (profile.halfDuplex) pendingCapture = [];
+    setModel(profile.halfDuplex ? 'Thinking' : 'Speaking');
   }
 
   function feedPlayback(decoded, responseId) {
     if (!decoded || !decoded.pcm || decoded.pcm.length === 0 || !playbackNode) return;
     const pcm = resampleInt16(decoded.pcm, decoded.sourceRate, playbackRate);
     responseHasAudio = true;
+    playbackComplete = false;
     assistantActive = true;
     setPlayback('Buffering');
     playbackNode.port.postMessage({
@@ -305,6 +366,7 @@
   }
 
   function requestPlaybackDrain(responseId) {
+    if (!responseHasAudio) { playbackComplete = true; finishResponseIfReady(); return; }
     if (!playbackNode) return;
     playbackNode.port.postMessage({ type: 'drain', responseId: responseId || currentResponseId });
   }
@@ -314,90 +376,133 @@
       if (!responseId && playedMs > 0) appendLog('playback ack skipped: missing response id', true);
       return;
     }
-    socket.send(JSON.stringify({
-      type: 'playback.ack',
-      response_id: responseId,
-      item_id: `item_${responseId}`,
-      played_ms: playedMs,
-      committed_ms: playedMs,
-    }));
+    const ack = profile.ack(responseId, playedMs);
+    if (ack) socket.send(JSON.stringify(ack));
   }
 
   function playbackDrained(message) {
     const responseId = message.responseId || currentResponseId;
-    sendPlaybackAck(responseId, Number(message.playedMs) || 0);
+    if (currentResponseId && responseId !== currentResponseId) return;
+    if (profile.playbackAck) sendPlaybackAck(responseId, Number(message.playedMs) || 0);
     setPlayback('Idle');
-    if (message.underrunMs > 0) {
-      appendLog(`playback underrun ${message.underrunMs} ms`);
-    }
-    window.setTimeout(() => {
-      assistantActive = false;
-      currentResponseId = null;
-      responseHasAudio = false;
-      if (running) setModel('Listening');
-    }, ECHO_GUARD_MS);
+    playbackComplete = true;
+    if (message.underrunMs > 0) appendLog(`playback underrun ${message.underrunMs} ms`);
+    if (!profile.halfDuplex && !profile.waitForResponseDone) responseComplete = true;
+    finishResponseIfReady();
   }
 
-  function handleEvent(event) {
+  async function handleAudioEvent(action) {
+    markBusy();
+    currentResponseId = action.responseId || currentResponseId || `turn-${turnCounter}`;
+    setModel('Speaking');
+    const generation = sessionGeneration;
+    const responseId = currentResponseId;
+    const decoded = await decodeAudioDelta(action.event);
+    if (generation === sessionGeneration && !interruptedResponses.has(responseId)) feedPlayback(decoded, responseId);
+  }
+
+  function handleTranscriptEvent(action) {
+    if (action.role === 'assistant') {
+      // Qwen may emit both text and audio-transcript representations.
+      // Display one channel per response instead of duplicating the answer.
+      if (profile.deduplicateTranscript && assistantTextChannel && action.channel !== assistantTextChannel) return;
+      if (action.text) assistantTextChannel = action.channel || assistantTextChannel;
+    }
+    if (action.kind === 'text') addTranscript(action.role, action.text);
+    else if (profile.deduplicateTranscript && action.role === 'assistant') {
+      if (action.text) {
+        const turn = ensureTurn('assistant');
+        turn.value = action.text;
+        turn.text.textContent = action.text;
+      }
+    } else finishTranscript(action.role, action.text);
+  }
+
+  async function handleEvent(event, action = profile.mapEvent(event)) {
     appendEventLog(event);
-    const responseId = responseIdOf(event);
-    switch (event.type) {
-      case 'session.created':
-      case 'session.updated':
+    const responseId = action.responseId || responseIdOf(event);
+    if (responseId && interruptedResponses.has(responseId) && action.kind !== 'interrupt') return;
+    switch (action.kind) {
+      case 'connected':
         setConnection('Connected', 'online');
-        setModel('Listening');
+        if (!assistantActive) setModel(profile.waiting);
         break;
-      case 'response.listen':
+      case 'interrupt': {
+        if (responseId) interruptedResponses.add(responseId);
+        // A late cancellation belongs to its own response, not the newer one
+        // currently playing. Speech-start events interrupt the local playback.
+        if (responseId && responseId !== currentResponseId) break;
+        if (currentResponseId) interruptedResponses.add(currentResponseId);
+        sessionGeneration += 1;
+        audioChain = Promise.resolve();
+        // Move queued events off the interrupted decode, preserving any newer
+        // response already received. Its chunks must not be lost with the old one.
+        const queued = [...pendingEvents];
+        pendingEvents.clear();
+        for (const pending of queued) enqueueEvent(pending.event, pending.action, pending.source);
+        clearTimeout(echoTimer);
+        echoTimer = null;
+        // Local playback completes immediately on interruption, including
+        // when the server already completed generation.
+        clearTimeout(turnTimeout);
+        if (playbackNode) playbackNode.port.postMessage({ type: 'clear' });
+        responseComplete = true;
+        playbackComplete = true;
+        responseHasAudio = false;
         assistantActive = false;
-        setModel('Listening');
+        currentResponseId = null;
+        assistantTextChannel = null;
+        finishTranscript('assistant');
+        setPlayback('Idle');
+        setModel(profile.waiting);
         break;
-      case 'response.created':
-      case 'response.speak':
+      }
+      case 'listen':
+        assistantActive = false;
+        setModel(profile.waiting);
+        break;
+      case 'begin':
+        if (profile.halfDuplex) armTurnTimeout();
+        if (echoTimer !== null) { clearTimeout(echoTimer); echoTimer = null; }
         beginAssistant(responseId);
         break;
-      case 'response.output_audio.delta':
-        currentResponseId = responseId || currentResponseId;
-        assistantActive = true;
-        setModel('Speaking');
-        decodeAudioDelta(event)
-          .then((decoded) => feedPlayback(decoded, responseId))
-          .catch((error) => appendLog(`audio decode failed: ${error.message || error}`, true));
+      case 'audio':
+        await handleAudioEvent(action);
         break;
-      case 'response.output_audio.done':
+      case 'drain':
         requestPlaybackDrain(responseId);
         break;
-      case 'response.output_audio_transcript.delta':
-        addTranscript('assistant', event.delta || '');
+      case 'text': case 'text-final':
+        handleTranscriptEvent(action);
         break;
-      case 'response.output_audio_transcript.done':
-        finishTranscript('assistant', event.transcript || '');
-        break;
-      case 'conversation.item.input_audio_transcription.delta':
-        addTranscript('user', event.delta || '');
-        break;
-      case 'conversation.item.input_audio_transcription.completed':
-        finishTranscript('user', event.transcript || '');
-        break;
-      case 'response.done':
+      case 'done':
+        clearTimeout(turnTimeout);
+        responseComplete = true;
         finishTranscript('assistant');
-        if (!responseHasAudio) requestPlaybackDrain(responseId);
+        requestPlaybackDrain(responseId);
+        finishResponseIfReady();
         break;
-      case 'playback.acknowledged':
-        {
-          const acknowledgement = event.event || event;
-          runtimeDetail.textContent = `Playback committed ${acknowledgement.committed_ms || 0} ms`;
-        }
+      case 'backpressure':
+        armTurnTimeout();
+        markBusy();
+        setModel('Thinking / Speaking');
+        runtimeDetail.textContent = action.message;
         break;
-      case 'session.closed':
+      case 'ack':
+        runtimeDetail.textContent = `Playback committed ${action.committedMs} ms`;
+        break;
+      case 'closed':
         if (sessionCloseResolver) sessionCloseResolver();
         sessionCloseResolver = null;
         break;
       case 'error':
-        setConnection('Error', 'error');
-        runtimeDetail.textContent = String(event.error || event.code || 'Server error');
-        break;
-      default:
+        if (action.fatal) { await failSession(action.message); break; }
+        // A rejected frame or a refused update costs one operation, not the
+        // call: report it and keep listening.
+        appendLog(action.message, true);
+        runtimeDetail.textContent = action.message;
         break;
+      default: break;
     }
   }
 
@@ -406,8 +511,15 @@
     playbackRate = playbackContext.sampleRate;
     await playbackContext.audioWorklet.addModule(staticAssetUrl('static/playback_worklet.js'));
     playbackNode = new AudioWorkletNode(playbackContext, 'fullduplex-pcm-playback');
+    const currentPlaybackNode = playbackNode;
     playbackNode.port.onmessage = (message) => {
+      if (playbackNode !== currentPlaybackNode) return;
       if (message.data.type === 'playback-started') setPlayback('Playing');
+      else if (message.data.type === 'playback-stopped') {
+        // The old response may report after the next one has started. ACK its
+        // own cursor without changing the current response's UI state.
+        if (profile.playbackAck) sendPlaybackAck(message.data.responseId, Number(message.data.playedMs) || 0);
+      }
       else if (message.data.type === 'playback-drained') playbackDrained(message.data);
       else if (message.data.type === 'playback-underrun') {
         runtimeDetail.textContent = `Playback underrun ${message.data.underrunMs || 0} ms`;
@@ -448,51 +560,86 @@
     await captureContext.resume();
   }
 
+  function enqueueEvent(event, action, source) {
+    const pending = { event, action, source };
+    pendingEvents.add(pending);
+    const generation = sessionGeneration;
+    audioChain = audioChain.then(() => {
+      if (!pendingEvents.delete(pending)) return;
+      if (socket === source || action.kind === 'closed') return handleEvent(event, action);
+    }).catch((error) => {
+      if (generation === sessionGeneration) return failSession(`Server event failed: ${error.message}`);
+    });
+  }
+
   function openSocket() {
     return new Promise((resolve, reject) => {
       const url = realtimeUrl();
-      socket = new WebSocket(url);
+      const current = new WebSocket(url);
+      socket = current;
+      connectionReady = false;
+      turnCounter += 1;
       let settled = false;
-      socket.onopen = () => {
+      const timer = window.setTimeout(() => {
+        if (settled) return;
         settled = true;
-        const extraBody = {
-          auto_response: true,
-        };
-        const session = {
-          modalities: ['audio', 'text'],
-          voice: 'default',
-          extra_body: extraBody,
-        };
-        // Reference voice for TTS cloning, provided by the server via
-        // --ref-audio (mirrors the official demo's default ref audio).
-        if (config.refAudio) session.ref_audio = config.refAudio;
-        const instructions = systemPromptInput ? systemPromptInput.value.trim() : '';
-        if (instructions) session.instructions = instructions;
-        socket.send(JSON.stringify({ type: 'session.update', session }));
-        runtimeDetail.textContent = `${captureRate} Hz capture / ${playbackRate} Hz playback`;
+        current.onclose = null;
+        current.close();
+        reject(new Error(`Session handshake timed out. ${profile.connectionHint}`));
+      }, 15000);
+      const rejectOnce = (message) => {
+        clearTimeout(timer);
+        if (!settled) { settled = true; reject(new Error(message)); }
+      };
+      current.onopen = () => {
+        const instructions = systemPromptInput.value.trim();
+        for (const event of profile.initialMessages(config, instructions)) current.send(JSON.stringify(event));
         appendLog(`websocket open  ${url}`);
-        resolve();
       };
-      socket.onmessage = (message) => {
-        if (typeof message.data !== 'string') return;
-        try {
-          handleEvent(JSON.parse(message.data));
-        } catch (error) {
-          appendLog(`invalid server event: ${error.message || error}`, true);
+      current.onmessage = (message) => {
+        if (typeof message.data !== 'string' || (socket !== current && closingSocket !== current)) return;
+        let event;
+        try { event = JSON.parse(message.data); }
+        catch (error) {
+          if (socket !== current) return;
+          const detail = `Invalid server event: ${error.message}`;
+          if (!settled) rejectOnce(detail);
+          else void failSession(detail);
+          return;
         }
-      };
-      socket.onerror = () => {
-        if (!settled) {
+        // Shutdown has detached the active socket. Only its close acknowledgement
+        // may pass, directly: the event queue can itself be awaiting cleanup.
+        if (closingSocket === current) {
+          if (event?.type === 'session.closed' && sessionCloseResolver) sessionCloseResolver();
+          return;
+        }
+        const action = profile.mapEvent(event);
+        if (action.kind === 'error' && !settled) {
+          rejectOnce(action.message);
+          return;
+        }
+        if (event.type === profile.readyEvent && !settled) {
+          clearTimeout(timer);
           settled = true;
-          reject(new Error(`WebSocket connection failed: ${url}`));
+          connectionReady = true;
+          runtimeDetail.textContent = `${captureRate} Hz capture / ${playbackRate} Hz playback`;
+          resolve();
         }
+        // Stop the speaker immediately, even while an old WAV is decoding.
+        // Ordinary completion still waits for its preceding audio chunks.
+        if (action.kind === 'interrupt') {
+          void handleEvent(event, action);
+          return;
+        }
+        enqueueEvent(event, action, current);
       };
-      socket.onclose = (event) => {
+      current.onerror = () => rejectOnce(`WebSocket connection failed. ${profile.connectionHint}`);
+      current.onclose = (event) => {
+        clearTimeout(timer);
+        connectionReady = false;
         appendLog(`websocket closed  code=${event.code}`);
-        if (running) {
-          setConnection('Disconnected', 'error');
-          stopSession();
-        }
+        if (!settled) rejectOnce(`Connection closed before session ready. ${profile.connectionHint}`);
+        else if (running && socket === current) failSession(`Backend disconnected (${event.code}). ${profile.connectionHint}`);
       };
     });
   }
@@ -515,46 +662,61 @@
     setConnection('Connecting', 'connecting');
     runtimeDetail.textContent = 'Requesting microphone access';
     try {
+      sessionGeneration += 1;
+      audioChain = Promise.resolve();
+      interruptedResponses.clear();
+      pendingEvents.clear();
       await openPlayback();
       await openCapture();
       await openSocket();
       running = true;
       muted = false;
       assistantActive = false;
-      sendTimer = window.setInterval(flushCapture, SEND_INTERVAL_MS);
+      sendTimer = window.setInterval(flushCapture, profile.sendIntervalMs || SEND_INTERVAL_MS);
       startClock();
       callButton.textContent = 'End session';
       callButton.classList.add('is-active');
       muteButton.disabled = false;
-      cameraButton.disabled = false;
+      cameraButton.disabled = !profile.camera;
+      sendTurnButton.disabled = !profile.clientCommit;
       setConnection('Connected', 'online');
-      setModel('Listening');
+      setModel(profile.waiting);
       appendLog('session started');
     } catch (error) {
       appendLog(`start failed: ${error.message || error}`, true);
+      await stopSession({ terminal: false });
       setConnection('Error', 'error');
       runtimeDetail.textContent = String(error.message || error);
-      await stopSession();
     } finally {
       callButton.disabled = false;
     }
   }
 
   async function startCamera() {
-    if (cameraStream) return;
+    if (!profile.camera || cameraStream) return;
     cameraStream = await navigator.mediaDevices.getUserMedia({ video: true, audio: false });
     cameraPreview.srcObject = cameraStream;
     cameraPreview.style.display = '';
     await cameraPreview.play().catch(() => {});
     // Official omni-duplex cadence: one JPEG (quality 0.7) per ~1 s chunk,
     // no client-side resize (the server normalizes at scale_resolution=448).
-    cameraTimer = window.setInterval(() => {
+    const captureCameraFrame = () => {
       if (!cameraStream || cameraPreview.videoWidth === 0) return;
-      cameraCanvas.width = cameraPreview.videoWidth;
-      cameraCanvas.height = cameraPreview.videoHeight;
-      cameraCanvas.getContext('2d').drawImage(cameraPreview, 0, 0);
-      cameraPendingFrame = cameraCanvas.toDataURL('image/jpeg', 0.7).split(',')[1];
-    }, 1000);
+      const scale = profile.cameraMaxDimension
+        ? Math.min(1, profile.cameraMaxDimension / Math.max(cameraPreview.videoWidth, cameraPreview.videoHeight)) : 1;
+      cameraCanvas.width = Math.max(1, Math.round(cameraPreview.videoWidth * scale));
+      cameraCanvas.height = Math.max(1, Math.round(cameraPreview.videoHeight * scale));
+      cameraCanvas.getContext('2d').drawImage(cameraPreview, 0, 0, cameraCanvas.width, cameraCanvas.height);
+      const frame = cameraCanvas.toDataURL('image/jpeg', 0.7).split(',')[1];
+      if (profile.imageMessages) {
+        if (connectionReady && socket?.readyState === WebSocket.OPEN) {
+          for (const event of profile.imageMessages(frame)) socket.send(JSON.stringify(event));
+        }
+      } else cameraPendingFrame = frame;
+    };
+    // Do not make the first spoken turn race a one-second timer.
+    captureCameraFrame();
+    cameraTimer = window.setInterval(captureCameraFrame, 1000);
     cameraButton.textContent = 'Camera off';
     cameraButton.classList.add('is-active');
     appendLog('camera on (1 fps omni frames)');
@@ -590,15 +752,33 @@
       const finish = () => {
         if (done) return;
         done = true;
+        clearTimeout(timer);
         if (sessionCloseResolver === finish) sessionCloseResolver = null;
         resolve();
       };
       sessionCloseResolver = finish;
-      window.setTimeout(finish, timeoutMs);
+      const timer = window.setTimeout(finish, timeoutMs);
     });
   }
 
-  async function stopSession({ terminal = true } = {}) {
+  function stopSession(options = {}) {
+    if (stopping) return stopping;
+    stopping = cleanupSession(options).finally(() => { stopping = null; });
+    return stopping;
+  }
+
+  async function cleanupSession({ terminal = true } = {}) {
+    sessionGeneration += 1;
+    pendingEvents.clear();
+    connectionReady = false;
+    clearTimeout(echoTimer);
+    clearTimeout(turnTimeout);
+    echoTimer = null;
+    responseComplete = false;
+    playbackComplete = true;
+    turnSubmitted = false;
+    assistantTextChannel = null;
+    sendTurnButton.disabled = true;
     running = false;
     assistantActive = false;
     pendingCapture = [];
@@ -607,15 +787,16 @@
     sendTimer = null;
     clockTimer = null;
     if (socket) {
-      const closingSocket = socket;
+      closingSocket = socket;
       socket = null;
       closingSocket.onclose = null;
-      if (terminal && closingSocket.readyState === WebSocket.OPEN) {
+      if (terminal && profile.closeSession && closingSocket.readyState === WebSocket.OPEN) {
         const closed = waitForSessionClosed(closingSocket, SESSION_CLOSE_TIMEOUT_MS);
         closingSocket.send(JSON.stringify({ type: 'session.close' }));
         await closed;
       }
       closingSocket.close(1000, 'client stop');
+      closingSocket = null;
     }
     if (playbackNode) playbackNode.port.postMessage({ type: 'clear' });
     if (mediaStream) {
@@ -632,6 +813,8 @@
     playbackNode = null;
     currentResponseId = null;
     responseHasAudio = false;
+    finishTranscript('user');
+    finishTranscript('assistant');
     meterFill.style.width = '0%';
     sessionTimer.textContent = '00:00';
     callButton.textContent = 'Start session';
@@ -659,6 +842,18 @@
     if (running) stopSession();
     else startSession();
   });
+  sendTurnButton.addEventListener('click', () => {
+    if (!running || !connectionReady || !profile.clientCommit || turnSubmitted) return;
+    flushCapture();
+    for (const event of profile.commitMessages()) socket.send(JSON.stringify(event));
+    turnSubmitted = true;
+    responseComplete = false;
+    markBusy();
+    armTurnTimeout();
+    sendTurnButton.disabled = true;
+    setModel('Thinking');
+    appendLog('turn submitted');
+  });
   muteButton.addEventListener('click', toggleMute);
   clearLogButton.addEventListener('click', () => {
     eventLog.textContent = '';
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/pcm_worklet.js b/examples/online_serving/realtime_web/app/static/pcm_worklet.js
similarity index 100%
rename from examples/online_serving/minicpmo/realtime_web/app/static/pcm_worklet.js
rename to examples/online_serving/realtime_web/app/static/pcm_worklet.js
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/playback_worklet.js b/examples/online_serving/realtime_web/app/static/playback_worklet.js
similarity index 95%
rename from examples/online_serving/minicpmo/realtime_web/app/static/playback_worklet.js
rename to examples/online_serving/realtime_web/app/static/playback_worklet.js
index f0d3d42ae..8aaa131c6 100644
--- a/examples/online_serving/minicpmo/realtime_web/app/static/playback_worklet.js
+++ b/examples/online_serving/realtime_web/app/static/playback_worklet.js
@@ -39,6 +39,13 @@ class FullDuplexPcmPlayback extends AudioWorkletProcessor {
       }
       this.notifyIfDrained();
     } else if (message.type === 'clear') {
+      if (this.activeResponseId) {
+        this.port.postMessage({
+          type: 'playback-stopped',
+          responseId: this.activeResponseId,
+          playedMs: Math.round((this.playedFrames * 1000) / sampleRate),
+        });
+      }
       this.queue = [];
       this.offset = 0;
       this.playedFrames = 0;
diff --git a/examples/online_serving/realtime_web/app/static/profiles/common.js b/examples/online_serving/realtime_web/app/static/profiles/common.js
new file mode 100644
index 000000000..feefbaa74
--- /dev/null
+++ b/examples/online_serving/realtime_web/app/static/profiles/common.js
@@ -0,0 +1,56 @@
+/* Shared wire helpers. Profiles translate server events into shell actions. */
+(function (root) {
+  'use strict';
+  const profiles = root.OmniRealtimeProfiles = root.OmniRealtimeProfiles || {};
+  profiles.url = (config, location) => {
+    const url = new URL(config.realtimePath || 'v1/realtime', location);
+    if (url.protocol === 'http:') url.protocol = 'ws:';
+    if (url.protocol === 'https:') url.protocol = 'wss:';
+    return url;
+  };
+  /* Errors that leave the session unusable, so the shell has to tear it down.
+     Everything else costs one operation --- a rejected image, a refused
+     session.update, a late playback ack --- and the call carries on.
+     'runtime_append_failed' is deliberately absent: the engine reports it and
+     keeps the session, unlike 'runtime_append_task_failed' which kills it. */
+  profiles.fatalErrorCodes = new Set([
+    'unknown_session',
+    'session_closed',
+    'resource_exhausted',
+    'unsupported',
+    'unsupported_turn_detection',
+    'server_vad_unavailable',
+    'runtime_append_task_failed',
+    'internal_error',
+  ]);
+  profiles.event = (event) => {
+    const responseId = event.response_id || event.response?.id || null;
+    const action = (kind, extra = {}) => ({ kind, responseId, ...extra });
+    switch (event.type) {
+      case 'session.created': case 'session.updated': return action('connected');
+      case 'response.created': return action('begin');
+      case 'response.audio.delta': case 'response.output_audio.delta':
+        return action('audio', { event: { ...event, delta: event.delta || event.audio || event.response?.audio } });
+      case 'response.audio.done': case 'response.output_audio.done': return action('drain');
+      case 'response.audio_transcript.delta': case 'response.output_audio_transcript.delta':
+        return action('text', { role: 'assistant', channel: 'audio', text: event.delta || '' });
+      case 'response.audio_transcript.done': case 'response.output_audio_transcript.done':
+        return action('text-final', { role: 'assistant', channel: 'audio', text: event.transcript || '' });
+      case 'conversation.item.input_audio_transcription.delta':
+        return action('text', { role: 'user', text: event.delta || '' });
+      case 'conversation.item.input_audio_transcription.completed':
+        return action('text-final', { role: 'user', text: event.transcript || '' });
+      case 'response.done': return action('done');
+      case 'session.closed': return action('closed');
+      case 'error': {
+        const code = event.code || event.error?.code;
+        return action('error', {
+          code,
+          fatal: profiles.fatalErrorCodes.has(code),
+          message: typeof event.error === 'string' ? event.error : event.error?.message || event.message || code || 'Server error',
+        });
+      }
+      default: return action('ignore');
+    }
+  };
+})(globalThis);
diff --git a/examples/online_serving/realtime_web/app/static/profiles/minicpm_native.js b/examples/online_serving/realtime_web/app/static/profiles/minicpm_native.js
new file mode 100644
index 000000000..801d549be
--- /dev/null
+++ b/examples/online_serving/realtime_web/app/static/profiles/minicpm_native.js
@@ -0,0 +1,55 @@
+(function (root) {
+  'use strict';
+  const profiles = root.OmniRealtimeProfiles;
+  profiles['minicpm-native'] = () => ({
+    title: 'MiniCPM-o 4.5 Voice', eyebrow: 'Experimental full-duplex runtime',
+    policy: 'Model-controlled listen / speak',
+    description: 'Speak naturally. The model can listen and speak at the same time. Camera frames are sent with your audio.',
+    waiting: 'Listening', camera: true, playbackAck: true, clientCommit: false,
+    halfDuplex: false, closeSession: true, reconnectEachTurn: false,
+    readyEvent: 'session.updated', instructions: true, sendIntervalMs: 200,
+    presets: {
+      omni: 'Streaming Omni Conversation.',
+      chinese_call: '扮演一个具有以上声音特征的助手。请认真、高质量地回复用户的问题。'
+        + '请用高自然度的方式和用户聊天。你处于双工模式，可以一边听、一边说。'
+        + '你是由面壁智能开发的人工智能助手：面壁小钢炮。',
+      english_call: 'Replicate the tone and style from the input audio. Your task is to be '
+        + 'a helpful assistant using this voice pattern. Please answer the user\'s questions '
+        + 'seriously and in a high quality. Please chat with the user in a high naturalness '
+        + 'style. You are in duplex mode, where you can listen and speak at the same time.',
+    },
+    url(config, location) {
+      const url = profiles.url(config, location);
+      url.searchParams.set('duplex', '1');
+      url.searchParams.set('model', config.model || 'openbmb/MiniCPM-o-4_5');
+      url.searchParams.set('autostart', '0');
+      return url.toString();
+    },
+    initialMessages(config, instructions) {
+      const session = { modalities: ['audio', 'text'], voice: 'default',
+        extra_body: { auto_response: true } };
+      if (config.refAudio) session.ref_audio = config.refAudio;
+      if (instructions) session.instructions = instructions;
+      return [{ type: 'session.update', session }];
+    },
+    append(audio, frame) {
+      const event = { type: 'input_audio_buffer.append', audio, format: 'pcm16', sample_rate_hz: 16000 };
+      if (frame) event.video_frames = [frame];
+      return event;
+    },
+    commitMessages: () => [],
+    ack(responseId, playedMs) {
+      return { type: 'playback.ack', response_id: responseId, item_id: `item_${responseId}`,
+        played_ms: playedMs, committed_ms: playedMs };
+    },
+    mapEvent(event) {
+      if (event.type === 'response.listen') return { kind: 'listen' };
+      if (event.type === 'response.speak') return { kind: 'begin', responseId: event.response_id || event.response?.id };
+      if (event.type === 'playback.acknowledged') {
+        return { kind: 'ack', committedMs: (event.event || event).committed_ms || 0 };
+      }
+      return profiles.event(event);
+    },
+    connectionHint: 'Check the MiniCPM duplex deployment and reference voice configuration.',
+  });
+})(globalThis);
diff --git a/examples/online_serving/realtime_web/app/static/profiles/qwen3_turn.js b/examples/online_serving/realtime_web/app/static/profiles/qwen3_turn.js
new file mode 100644
index 000000000..5c4fa9d6f
--- /dev/null
+++ b/examples/online_serving/realtime_web/app/static/profiles/qwen3_turn.js
@@ -0,0 +1,116 @@
+(function (root) {
+  'use strict';
+  const profiles = root.OmniRealtimeProfiles;
+  profiles['qwen3-turn'] = (config) => {
+    const vad = config.adapter === 'vad';
+    let interruptOnSpeech = vad;
+    let imageSeq = 0;
+    let imageItems = [];
+    // The engine refuses a ninth image (or 4 MiB of them) for the whole
+    // session, so the camera track retires its own oldest frame instead.
+    const MAX_IMAGE_ITEMS = 8;
+    const hint = 'This Qwen deploy needs session_mode: duplex and Server VAD support; use --stt or enable Server VAD.';
+    return {
+      title: 'Qwen3-Omni Voice', eyebrow: vad ? 'Engine-owned duplex call' : 'Turn-based realtime call',
+      policy: vad ? 'Server VAD • interruptible responses' : 'Send turn • one response at a time',
+      description: vad
+        ? 'Pause to send your turn; speak again to interrupt. Microphone upload continues during playback. Requires the Qwen duplex plugin and Silero. Optional camera frames accompany each spoken turn.'
+        : 'Speak, then press Send turn. Microphone upload pauses while the model answers. Each turn uses a fresh connection; conversation history is not carried between turns. No barge-in or camera input.',
+      waiting: 'Waiting for you', camera: vad, cameraMaxDimension: 448, playbackAck: vad, clientCommit: !vad,
+      waitForResponseDone: true, halfDuplex: !vad, deduplicateTranscript: true, closeSession: vad, reconnectEachTurn: !vad,
+      inputSampleRate: vad ? 24000 : 16000,
+      readyEvent: vad ? 'session.updated' : 'session.created', instructions: vad, sendIntervalMs: 200,
+      presets: { assistant: 'You are a helpful assistant. Answer clearly and concisely.' },
+      url(config, location) {
+        const url = profiles.url(config, location);
+        for (const key of ['native_duplex', 'minicpmo45_native_duplex', 'autostart']) url.searchParams.delete(key);
+        // Explicit opt-out matches the local file client, including servers
+        // that auto-select the duplex endpoint when the query is omitted.
+        url.searchParams.set('duplex', vad ? '1' : '0');
+        url.searchParams.set('model', config.model || 'Qwen/Qwen3-Omni-30B-A3B-Instruct');
+        return url.toString();
+      },
+      initialMessages(config, instructions) {
+        imageItems = [];
+        interruptOnSpeech = vad;
+        if (!vad) return [
+          { type: 'session.update', model: config.model },
+          { type: 'input_audio_buffer.commit', final: false },
+        ];
+        const session = { model: config.model, overlap_policy: 'barge_in_on_speech', audio: { input: {
+          format: { type: 'audio/pcm', rate: 24000 },
+          turn_detection: { type: 'server_vad', threshold: 0.5, prefix_padding_ms: 300,
+            silence_duration_ms: 500, create_response: true, interrupt_response: true },
+        } } };
+        if (instructions) session.instructions = instructions;
+        return [{ type: 'session.update', session }];
+      },
+      append(audio) {
+        return vad ? { type: 'input_audio_buffer.append', audio }
+          : { type: 'input_audio_buffer.append', audio, format: 'pcm16', sample_rate_hz: 16000 };
+      },
+      // Qwen is a turn model: a frame is a picture added to the conversation,
+      // not a track interleaved into the audio. That is exactly the OpenAI
+      // Realtime image interface, so the camera sends conversation items
+      // rather than an extension field on the append.
+      imageMessages(frame) {
+        if (!vad) return [];
+        const messages = [];
+        if (imageItems.length >= MAX_IMAGE_ITEMS) {
+          // Retire before creating: the engine counts what is already stored.
+          messages.push({ type: 'conversation.item.delete', item_id: imageItems.shift() });
+        }
+        const id = `camera_${++imageSeq}`;
+        imageItems.push(id);
+        messages.push({ type: 'conversation.item.create', item: {
+          id, type: 'message', role: 'user',
+          content: [{ type: 'input_image', image_url: `data:image/jpeg;base64,${frame}` }],
+        } });
+        return messages;
+      },
+      commitMessages: () => vad ? [] : [{ type: 'input_audio_buffer.commit', final: true }],
+      ack: (responseId, playedMs) => vad ? { type: 'playback.ack', response_id: responseId,
+        item_id: `item_${responseId}`, played_ms: playedMs, committed_ms: playedMs } : null,
+      mapEvent(event) {
+        if (event.type === 'session.created' || event.type === 'session.updated') {
+          const input = event.session?.audio?.input;
+          const turnDetection = input && 'turn_detection' in input
+            ? input.turn_detection : event.session?.turn_detection;
+          if (turnDetection !== undefined) {
+            interruptOnSpeech = vad && turnDetection?.type === 'server_vad'
+              && turnDetection.interrupt_response !== false;
+          }
+        }
+        // Generation can finish long before the speaker drains its queue. In
+        // that case the server has no active response left to cancel for us.
+        if (interruptOnSpeech && event.type === 'input_audio_buffer.speech_started') {
+          return { kind: 'interrupt' };
+        }
+        if (event.type === 'playback.acknowledged') return { kind: 'ack', committedMs: (event.event || event).committed_ms || 0 };
+        if (event.type === 'response.output_text.delta' || event.type === 'transcription.delta') {
+          // On the shipped STT route transcription.* is model-generated text,
+          // not a separate ASR transcript of the user. See realtime_connection.py.
+          return { kind: 'text', role: 'assistant', channel: 'text', text: event.delta || '' };
+        }
+        if (event.type === 'response.output_text.done' || event.type === 'transcription.done') {
+          return { kind: 'text-final', role: 'assistant', channel: 'text', text: event.text || '' };
+        }
+        if (vad && (event.type === 'output_audio_buffer.cleared' ||
+            (event.type === 'response.done' && event.response?.status === 'cancelled'))) {
+          return { kind: 'interrupt', responseId: event.response_id || event.response?.id || null };
+        }
+        if (event.type === 'input_audio_buffer.committed') return { kind: 'begin' };
+        if (event.type === 'input_audio_buffer.cleared') return { kind: 'backpressure', message: 'Input cleared. Model is answering; please wait.' };
+        if (!vad && event.type === 'response.output_audio.done') return { kind: 'done' };
+        const action = profiles.event(event);
+        if (action.kind === 'error') {
+          if (action.code === 'input_backpressure') return { ...action, kind: 'backpressure', message: 'Input buffer is full; please repeat dropped speech after the response.' };
+          if (action.code === 'server_vad_initialization_failed') action.message = 'Server VAD could not load Silero. Configure the server artifact or restart this UI with --stt.';
+          else if (vad && action.code === 'unsupported') action.message += ` ${hint}`;
+        }
+        return action;
+      },
+      connectionHint: vad ? hint : 'Check the Qwen /v1/realtime STT endpoint and model name.',
+    };
+  };
+})(globalThis);
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/styles.css b/examples/online_serving/realtime_web/app/static/styles.css
similarity index 98%
rename from examples/online_serving/minicpmo/realtime_web/app/static/styles.css
rename to examples/online_serving/realtime_web/app/static/styles.css
index 9b080176b..bf25c3eff 100644
--- a/examples/online_serving/minicpmo/realtime_web/app/static/styles.css
+++ b/examples/online_serving/realtime_web/app/static/styles.css
@@ -125,3 +125,6 @@ button:disabled { opacity: .46; cursor: default; }
 @media (prefers-reduced-motion: reduce) {
   *, *::before, *::after { animation-duration: .01ms !important; animation-iteration-count: 1 !important; }
 }
+
+/* Profile-specific controls may have inline flex styles. */
+[hidden] { display: none !important; }
diff --git a/examples/online_serving/realtime_web/server.py b/examples/online_serving/realtime_web/server.py
new file mode 100644
index 000000000..85e4b63d5
--- /dev/null
+++ b/examples/online_serving/realtime_web/server.py
@@ -0,0 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Static host and same-origin proxy for the shared realtime browser UI."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import contextlib
+import hashlib
+import json
+import logging
+from pathlib import Path
+from urllib.parse import urlencode
+
+import uvicorn
+import websockets
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse, Response
+from fastapi.staticfiles import StaticFiles
+
+logger = logging.getLogger(__name__)
+APP_DIR = Path(__file__).parent / "app"
+STATIC_DIR = APP_DIR / "static"
+
+
+def _join_ws_url(base: str, path: str, query: str) -> str:
+    return base.rstrip("/") + path + (("?" + query) if query else "")
+
+
+async def _pump_client_to_backend(client: WebSocket, backend) -> None:
+    try:
+        while True:
+            message = await client.receive()
+            if message["type"] == "websocket.disconnect":
+                await backend.close()
+                return
+            if message.get("text") is not None:
+                await backend.send(message["text"])
+            elif message.get("bytes") is not None:
+                await backend.send(message["bytes"])
+    except (WebSocketDisconnect, websockets.ConnectionClosed):
+        with contextlib.suppress(Exception):
+            await backend.close()
+
+
+async def _pump_backend_to_client(client: WebSocket, backend) -> None:
+    try:
+        async for message in backend:
+            if isinstance(message, bytes):
+                await client.send_bytes(message)
+            else:
+                await client.send_text(message)
+    except (WebSocketDisconnect, websockets.ConnectionClosed):
+        return
+    except RuntimeError as exc:
+        if "websocket.send" in str(exc) and "websocket.close" in str(exc):
+            return
+        raise
+
+
+def _expected_proxy_close(exc: BaseException) -> bool:
+    if isinstance(exc, (WebSocketDisconnect, websockets.ConnectionClosed, asyncio.CancelledError)):
+        return True
+    return isinstance(exc, RuntimeError) and "websocket.send" in str(exc) and "websocket.close" in str(exc)
+
+
+def build_app(
+    *,
+    ws_backend: str | None = None,
+    model: str | None = None,
+    public_realtime_url: str | None = None,
+    ref_audio: str | None = None,
+    profile: str = "minicpm-native",
+    adapter: str = "stt",
+) -> FastAPI:
+    if profile not in {"minicpm-native", "qwen3-turn"}:
+        raise ValueError(f"Unknown profile: {profile}")
+    if adapter not in {"stt", "vad"}:
+        raise ValueError(f"Unknown adapter: {adapter}")
+    if profile == "qwen3-turn" and ref_audio:
+        raise ValueError("Qwen3 profile does not accept --ref-audio")
+    native = profile == "minicpm-native"
+    ws_backend = ws_backend or ("ws://127.0.0.1:8099" if native else "ws://127.0.0.1:8091")
+    model = model or ("openbmb/MiniCPM-o-4_5" if native else "Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    app = FastAPI(title="Omni Realtime Web UI")
+    index_path = APP_DIR / "index.html"
+    app_version_hash = hashlib.sha256()
+    for asset_path in (
+        STATIC_DIR / "app.js",
+        STATIC_DIR / "pcm_worklet.js",
+        STATIC_DIR / "playback_worklet.js",
+        *sorted((STATIC_DIR / "profiles").glob("*.js")),
+    ):
+        app_version_hash.update(asset_path.read_bytes())
+    app_version = app_version_hash.hexdigest()[:12]
+
+    ref_audio_uri: str | None = None
+    if ref_audio:
+        ref_path = Path(ref_audio)
+        if not ref_path.is_file():
+            raise SystemExit(f"--ref-audio not found: {ref_audio}")
+        encoded = base64.b64encode(ref_path.read_bytes()).decode("ascii")
+        ref_audio_uri = f"data:audio/wav;base64,{encoded}"
+
+    @app.get("/", response_class=HTMLResponse)
+    def index() -> HTMLResponse:
+        config = json.dumps(
+            {
+                "model": model,
+                "profile": profile,
+                "adapter": adapter,
+                "realtimePath": public_realtime_url or "v1/realtime",
+                "refAudio": ref_audio_uri,
+                "appVersion": app_version,
+            },
+            ensure_ascii=True,
+        ).replace("<", "\\u003c")
+        html = (
+            index_path.read_text(encoding="utf-8")
+            .replace("__FULL_DUPLEX_CONFIG__", config)
+            .replace("__FULL_DUPLEX_APP_VERSION__", app_version)
+        )
+        return HTMLResponse(html, headers={"Cache-Control": "no-store"})
+
+    @app.get("/healthz")
+    def healthz() -> Response:
+        return Response(content="ok", media_type="text/plain")
+
+    @app.websocket("/v1/realtime")
+    async def realtime_proxy(websocket: WebSocket) -> None:
+        await websocket.accept()
+        query = urlencode(websocket.query_params.multi_items())
+        backend_url = _join_ws_url(ws_backend, "/v1/realtime", query)
+        logger.info("Proxying Realtime WebSocket to %s", backend_url)
+        try:
+            async with websockets.connect(
+                backend_url,
+                max_size=64 * 1024 * 1024,
+            ) as backend:
+                tasks = {
+                    asyncio.create_task(_pump_client_to_backend(websocket, backend)),
+                    asyncio.create_task(_pump_backend_to_client(websocket, backend)),
+                }
+                done, pending = await asyncio.wait(
+                    tasks,
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for task in pending:
+                    task.cancel()
+                await asyncio.gather(*pending, return_exceptions=True)
+                for result in await asyncio.gather(*done, return_exceptions=True):
+                    if isinstance(result, BaseException) and not _expected_proxy_close(result):
+                        raise result
+        except (WebSocketDisconnect, websockets.ConnectionClosed):
+            return
+        except (OSError, TimeoutError) as exc:
+            message = (
+                f"Cannot connect to realtime backend {ws_backend}. "
+                "Check that vllm serve is running and --backend matches its --port. "
+                "For containers or remote hosts, use the backend address reachable from the UI server."
+            )
+            logger.warning("%s (%s)", message, exc)
+            with contextlib.suppress(Exception):
+                await websocket.send_json({"type": "error", "code": "backend_unavailable", "error": message})
+                await websocket.close(code=1011)
+        except Exception:
+            logger.exception("Realtime WebSocket proxy failed")
+            with contextlib.suppress(Exception):
+                await websocket.close(code=1011)
+        finally:
+            with contextlib.suppress(Exception):
+                await websocket.close()
+
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+    return app
+
+
+def main(default_profile: str = "minicpm-native") -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=7862)
+    parser.add_argument("--profile", choices=("minicpm-native", "qwen3-turn"), default=default_profile)
+    parser.add_argument("--ws-backend", "--backend", dest="ws_backend")
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument("--stt", dest="adapter", action="store_const", const="stt")
+    mode.add_argument("--vad", dest="adapter", action="store_const", const="vad")
+    parser.set_defaults(adapter="stt")
+    parser.add_argument(
+        "--public-realtime-url",
+        help="Browser-visible ws:// or wss:// Realtime URL; defaults to the same-origin proxy.",
+    )
+    parser.add_argument("--model")
+    parser.add_argument(
+        "--ref-audio",
+        help=(
+            "Reference voice wav for TTS voice cloning, e.g. the "
+            "official MiniCPM-o-Demo assets/ref_audio/ref_minicpm_signature.wav"
+        ),
+    )
+    args = parser.parse_args()
+    native = args.profile == "minicpm-native"
+    if native and not args.ref_audio:
+        parser.error("--ref-audio is required for the minicpm-native profile")
+    if not native and args.ref_audio:
+        parser.error("--ref-audio is only supported by minicpm-native")
+    args.model = args.model or ("openbmb/MiniCPM-o-4_5" if native else "Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    args.ws_backend = args.ws_backend or ("ws://127.0.0.1:8099" if native else "ws://127.0.0.1:8091")
+
+    logging.basicConfig(level=logging.INFO)
+    uvicorn.run(
+        build_app(
+            ws_backend=args.ws_backend,
+            model=args.model,
+            public_realtime_url=args.public_realtime_url,
+            ref_audio=args.ref_audio,
+            profile=args.profile,
+            adapter=args.adapter,
+        ),
+        host=args.host,
+        port=args.port,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/streaming_video_generation/README.md b/examples/online_serving/streaming_video_generation/README.md
index 8e535ce0e..ba4724c69 100644
--- a/examples/online_serving/streaming_video_generation/README.md
+++ b/examples/online_serving/streaming_video_generation/README.md
@@ -21,7 +21,7 @@ The `--diffusion-streaming-output` CLI flag is forwarded as `streaming_output=Tr
 | Direction | Message | Format | Description |
 | --- | --- | --- | --- |
 | Client to server | `session.start` | JSON text: `{"type":"session.start","model":"...","prompt":"...","format":"m4s"}` | Starts generation. `format` is optional and accepts `m4s` (default). Sampling fields such as `width`, `height`, `fps`, `num_frames`, and `extra_params` may be included. Image-conditioned models take a first frame as `image_reference`: `{"image_url":"https://..."}` or a `data:` URL. |
-| Client to server | `session.interaction` | JSON text: `{"type":"session.interaction","interaction":{"event_id":"xxx","event":{"prompt":"..."},"transition_chunks":3}}` | Updates the active prompt midway through generation. `event_id` is optional and `transition_chunks` defaults to the model setting. |
+| Client to server | `session.interaction` | JSON text: `{"type":"session.interaction","interaction":{"event_id":"xxx","event":{"prompt":"..."},"transition_chunks":3}}` | Updates the active prompt and/or camera midway through generation. Camera at `event.multi_modal_data.camera` is structural SE3 (`mode` + `translation`/`rotation`). `event_id` is optional and `transition_chunks` defaults to the model setting. |
 | Server to client | `video.start` | JSON text: `{"type":"video.start","request_id":"...","format":"m4s","config":{...}}` | Confirms the session and mirrors the accepted `format`. |
 | Server to client | `video.chunk_metadata` | JSON text: `{"type":"video.chunk_metadata","request_id":"...","kind":"media","transport_chunk_index":0,"generation_chunk_index":0,"num_frames":9,"byte_length":1234,"started_event_ids":[],"active_event_ids":[],"completed_event_ids":[]}` | Precedes each binary frame and describes the immediately following payload. |
 | Server to client | Video chunk | Binary WebSocket frame | Fragmented MP4 (`m4s`) video bytes. |
@@ -59,10 +59,10 @@ python streaming_video_client.py \
   --output helios_stream.mp4
 ```
 
-The client sends one `session.start` message, prints each received binary video chunk with its byte size and elapsed time, and saves the received bytes to `--output` after `session.done`.
+The example client sends one `session.start` message, prints each received binary video chunk with its byte size and elapsed time, and saves the received bytes to `--output` after `session.done`.
 The client remuxes the gathered stream to a regular progressive MP4 file so that local playback knows the video duration.
 
-Schedule midway prompt updates with `--prompt-updates`. None are sent unless you ask for them, and only pipelines that implement midway prompt updates accept them (LingBot-World, for one, does not, and rejects the whole session). Each entry uses `"at"` as seconds on the client clock after the server sends `video.start`:
+Schedule midway prompt updates with `--prompt-updates`. None are sent unless you ask for them, and only pipelines that implement midway prompt updates accept them. Each entry uses `"at"` as seconds on the client clock after the server sends `video.start`:
 
 ```bash
 python streaming_video_client.py \
@@ -73,6 +73,21 @@ python streaming_video_client.py \
   ]'
 ```
 
+Schedule midway camera updates with `--camera-updates` when the served model
+registers the camera modality (e.g., LingBot World 2).
+It accepts `["camera"]["data"]["translation"/"rotation"]` in the endpoint's required SE3 format.
+It also accepts `["actions"]` at the update level and converts keystrokes to the SE3 format.
+
+```bash
+python streaming_video_client.py \
+  --model robbyant/lingbot-world-v2-14b-causal-fast-diffusers \
+  --image-reference /path/to/first_frame.png \
+  --camera-updates '[
+    {"at": 1.0, "actions": ["w"]},
+    {"at": 3.0, "camera": {"mode": "target", "data": {"translation": [0.0, 0.0, 1.0], "rotation": [0.0, 0.0, 0.0, 1.0]}}, "transition_chunks": 2}
+  ]'
+```
+
 The Helios demo continues the default prompt into an underwater storm:
 
 ```bash
@@ -144,6 +159,7 @@ python streaming_video_client.py \
   --output lingbot_world_v2_stream.mp4
 ```
 
-`camera_action_script` carries one three-latent-frame WASD action list per generated
-chunk. Mid-session `session.interaction` only updates the prompt, so a LingBot rollout
-follows the camera script it started with.
+`camera_action_script` is an optional request-scoped WASD script (one
+three-latent-frame action list per generated chunk). Prefer mid-session
+`session.interaction` camera control via `--camera-updates` when you need
+live motion; the engine wire format is structural SE3 only.
diff --git a/examples/online_serving/streaming_video_generation/camera_utils.py b/examples/online_serving/streaming_video_generation/camera_utils.py
new file mode 100644
index 000000000..82f493b37
--- /dev/null
+++ b/examples/online_serving/streaming_video_generation/camera_utils.py
@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Client-side helpers that map WASD/IJKL keys to structural SE3 camera payloads.
+Convenience for demos.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+# Unity-frame (+X right, +Y up, +Z forward) step sizes used by the optional
+# WASD helper. Magnitudes mirror LingBot's script integrator; the engine never
+# sees key tokens — only structural SE3 payloads.
+_WASD_STEP = 0.05
+_WASD_PITCH_DEG = 4.0
+_WASD_YAW_DEG = 6.0
+# Match LingBot's per-frame pitch clamp; without absolute pose this only limits
+# a single helper call, not cumulative held velocity.
+_WASD_PITCH_LIMIT_DEG = 85.0
+
+
+def _quat_from_axis_angle(axis: tuple[float, float, float], degrees: float) -> list[float]:
+    """Return a unit quaternion ``[x, y, z, w]`` for a right-handed axis-angle."""
+    radians = math.radians(degrees)
+    half = 0.5 * radians
+    sine = math.sin(half)
+    return [axis[0] * sine, axis[1] * sine, axis[2] * sine, math.cos(half)]
+
+
+def wasd_to_camera_payload(actions: list[str], *, mode: str = "velocity") -> dict[str, Any]:
+    """Map WASD/IJKL key tokens to a structural camera interaction payload.
+
+    This is a client convenience only. Servers reject ``data.actions``.
+
+    The delta is chosen so that at the identity pose, ``T_base @ T_delta``
+    matches LingBot's script integrator rotation
+    ``R_y(yaw) @ R_x(pitch)``. Without the current absolute pose this remains
+    an approximation once the camera has already yawed/pitched.
+    """
+    keys = {str(action).lower() for action in actions}
+    dx = _WASD_STEP * (("d" in keys) - ("a" in keys))
+    dy = 0.0
+    dz = _WASD_STEP * (("w" in keys) - ("s" in keys))
+    pitch = _WASD_PITCH_DEG * (("i" in keys) - ("k" in keys))
+    yaw = _WASD_YAW_DEG * (("l" in keys) - ("j" in keys))
+    pitch = max(-_WASD_PITCH_LIMIT_DEG, min(_WASD_PITCH_LIMIT_DEG, pitch))
+
+    # R_delta = R_y(yaw) @ R_x(pitch): apply pitch first, then yaw.
+    qx, qy, qz, qw = 0.0, 0.0, 0.0, 1.0
+    if abs(pitch) > 0.0:
+        px, py, pz, pw = _quat_from_axis_angle((1.0, 0.0, 0.0), pitch)
+        qx, qy, qz, qw = px, py, pz, pw
+    if abs(yaw) > 0.0:
+        yx, yy, yz, yw = _quat_from_axis_angle((0.0, 1.0, 0.0), yaw)
+        # q = yaw ⊗ pitch
+        qx, qy, qz, qw = (
+            yw * qx + yx * qw + yy * qz - yz * qy,
+            yw * qy - yx * qz + yy * qw + yz * qx,
+            yw * qz + yx * qy - yy * qx + yz * qw,
+            yw * qw - yx * qx - yy * qy - yz * qz,
+        )
+
+    return {
+        "mode": mode,
+        "data": {
+            "translation": [dx, dy, dz],
+            "rotation": [qx, qy, qz, qw],
+        },
+    }
diff --git a/examples/online_serving/streaming_video_generation/streaming_video_client.py b/examples/online_serving/streaming_video_generation/streaming_video_client.py
index 268891284..d159234e4 100644
--- a/examples/online_serving/streaming_video_generation/streaming_video_client.py
+++ b/examples/online_serving/streaming_video_generation/streaming_video_client.py
@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import Any
 
 import av
+from camera_utils import wasd_to_camera_payload
 
 try:
     from websockets.asyncio.client import connect  # pyright: ignore[reportMissingImports]
@@ -56,6 +57,15 @@ class ScheduledPromptUpdate:
     transition_chunks: int
 
 
+@dataclass(frozen=True)
+class ScheduledCameraUpdate:
+    """Client-side schedule entry for a midway camera ``session.interaction``."""
+
+    at: float
+    camera: dict[str, Any]
+    transition_chunks: int | None
+
+
 def _image_reference(value: str) -> dict[str, Any]:
     """Accept an http(s) URL as-is, or inline a local image as a data URL."""
     if value.startswith(("http://", "https://", "data:")):
@@ -119,6 +129,61 @@ def _parse_prompt_updates(value: str) -> list[ScheduledPromptUpdate]:
     return sorted(updates, key=lambda update: update.at)
 
 
+def _parse_camera_updates(value: str) -> list[ScheduledCameraUpdate]:
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise argparse.ArgumentTypeError(f"--camera-updates must be valid JSON: {exc}") from exc
+    if not isinstance(parsed, list):
+        raise argparse.ArgumentTypeError("--camera-updates must be a JSON array")
+
+    updates: list[ScheduledCameraUpdate] = []
+    for index, item in enumerate(parsed):
+        if not isinstance(item, dict):
+            raise argparse.ArgumentTypeError(f"--camera-updates[{index}] must be a JSON object")
+        try:
+            at = float(item["at"])
+        except (KeyError, TypeError, ValueError) as exc:
+            raise argparse.ArgumentTypeError(f"--camera-updates[{index}] must have a valid 'at' field") from exc
+        if at < 0:
+            raise argparse.ArgumentTypeError(f"--camera-updates[{index}].at must be >= 0")
+
+        if "camera" in item:
+            camera = item["camera"]
+            if not isinstance(camera, dict):
+                raise argparse.ArgumentTypeError(f"--camera-updates[{index}].camera must be an object")
+        elif "actions" in item:
+            actions = item["actions"]
+            if not isinstance(actions, list):
+                raise argparse.ArgumentTypeError(f"--camera-updates[{index}].actions must be a list of WASD/IJKL keys")
+            mode = item.get("mode", "velocity")
+            if mode not in ("target", "velocity"):
+                raise argparse.ArgumentTypeError(f"--camera-updates[{index}].mode must be target or velocity")
+            camera = wasd_to_camera_payload(actions, mode=mode)
+        else:
+            raise argparse.ArgumentTypeError(
+                f"--camera-updates[{index}] must provide 'camera' (structural SE3) "
+                "or 'actions' (client-side WASD helper)"
+            )
+
+        transition_chunks: int | None
+        if "transition_chunks" not in item:
+            transition_chunks = None if camera.get("mode") == "velocity" else DEFAULT_TRANSITION_CHUNKS
+        else:
+            try:
+                transition_chunks = int(item["transition_chunks"])
+            except (TypeError, ValueError) as exc:
+                raise argparse.ArgumentTypeError(
+                    f"--camera-updates[{index}].transition_chunks must be an integer"
+                ) from exc
+            if transition_chunks < 0:
+                raise argparse.ArgumentTypeError(f"--camera-updates[{index}].transition_chunks must be >= 0")
+
+        updates.append(ScheduledCameraUpdate(at=at, camera=camera, transition_chunks=transition_chunks))
+
+    return sorted(updates, key=lambda update: update.at)
+
+
 def _maybe_set(payload: dict[str, Any], key: str, value: Any) -> None:
     if value is not None:
         payload[key] = value
@@ -173,7 +238,7 @@ async def _run_prompt_update_scheduler(
         payload = {
             "type": "session.interaction",
             "interaction": {
-                "event_id": f"scheduled-{update.at:.3f}",
+                "event_id": f"scheduled-prompt-{update.at:.3f}",
                 "event": {"prompt": update.prompt},
                 "transition_chunks": update.transition_chunks,
             },
@@ -183,6 +248,30 @@ async def _run_prompt_update_scheduler(
         print(f"Sent session.interaction at t={update.at:.2f}s: {json.dumps(payload, ensure_ascii=False)}")
 
 
+async def _run_camera_update_scheduler(
+    websocket: Any,
+    updates: list[ScheduledCameraUpdate],
+    *,
+    video_started_at: float,
+    send_lock: asyncio.Lock,
+) -> None:
+    for update in updates:
+        delay = (video_started_at + update.at) - time.perf_counter()
+        if delay > 0:
+            await asyncio.sleep(delay)
+
+        interaction: dict[str, Any] = {
+            "event_id": f"scheduled-camera-{update.at:.3f}",
+            "event": {"multi_modal_data": {"camera": update.camera}},
+        }
+        if update.transition_chunks is not None:
+            interaction["transition_chunks"] = update.transition_chunks
+        payload = {"type": "session.interaction", "interaction": interaction}
+        async with send_lock:
+            await websocket.send(json.dumps(payload, ensure_ascii=False))
+        print(f"Sent session.interaction at t={update.at:.2f}s: {json.dumps(payload, ensure_ascii=False)}")
+
+
 def _count_decoded_frames(video_bytes: bytes, *, stream_format: str) -> int | None:
     """Return the number of decodable video frames in a streamed byte sequence, if known."""
     if not video_bytes:
@@ -241,6 +330,7 @@ async def stream_video(args: argparse.Namespace) -> None:
     ws = None
     send_lock = asyncio.Lock()
     prompt_update_task: asyncio.Task[None] | None = None
+    camera_update_task: asyncio.Task[None] | None = None
     pending_chunk_metadata: dict[str, Any] | None = None
 
     try:
@@ -295,8 +385,8 @@ async def stream_video(args: argparse.Namespace) -> None:
                 if msg_type == "video.start":
                     stream_format = msg.get("format") or stream_format
                     print(f"Video session started: request_id={msg.get('request_id')} format={msg.get('format')}")
+                    video_started_at = time.perf_counter()
                     if args.prompt_updates and prompt_update_task is None:
-                        video_started_at = time.perf_counter()
                         prompt_update_task = asyncio.create_task(
                             _run_prompt_update_scheduler(
                                 websocket,
@@ -305,6 +395,15 @@ async def stream_video(args: argparse.Namespace) -> None:
                                 send_lock=send_lock,
                             )
                         )
+                    if args.camera_updates and camera_update_task is None:
+                        camera_update_task = asyncio.create_task(
+                            _run_camera_update_scheduler(
+                                websocket,
+                                args.camera_updates,
+                                video_started_at=video_started_at,
+                                send_lock=send_lock,
+                            )
+                        )
                 elif msg_type == "video.chunk_metadata":
                     # Save the metadata for the incoming video chunk
                     pending_chunk_metadata = msg
@@ -315,6 +414,8 @@ async def stream_video(args: argparse.Namespace) -> None:
                     done = True
                     if prompt_update_task is not None:
                         prompt_update_task.cancel()
+                    if camera_update_task is not None:
+                        camera_update_task.cancel()
                     break
                 elif msg_type == "error":
                     print(f"ERROR: {msg.get('message', msg)}")
@@ -335,6 +436,10 @@ async def stream_video(args: argparse.Namespace) -> None:
             prompt_update_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await prompt_update_task
+        if camera_update_task is not None:
+            camera_update_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await camera_update_task
         print(
             "Saving video... (May take a while. Remuxing concatenated chunks into one progressive MP4 file with total duration metadata in file header)"
         )
@@ -405,9 +510,9 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help="JSON object merged into extra_params; overrides preset keys on conflict.",
     )
-    # Midway prompt updates are pipeline-specific: a model that does not implement
-    # them (LingBot-World, for one) rejects the whole session on the first one, so
-    # nothing is scheduled unless the caller asks for it.
+    # Midway interactions are pipeline-specific: unsupported modalities reject
+    # the update (and may leave the session running). Nothing is scheduled unless
+    # the caller asks for it.
     parser.add_argument(
         "--prompt-updates",
         type=_parse_prompt_updates,
@@ -419,6 +524,19 @@ def parse_args() -> argparse.Namespace:
             f"'transition_chunks' defaults to {DEFAULT_TRANSITION_CHUNKS}."
         ),
     )
+    parser.add_argument(
+        "--camera-updates",
+        type=_parse_camera_updates,
+        default=[],
+        help=(
+            "JSON array of scheduled camera updates for models that register the "
+            "camera modality (e.g. LingBot-World). Each object needs 'at' and either "
+            "'camera' (structural SE3: mode + translation/rotation) or "
+            "'actions' (client-side WASD/IJKL helper converted before send). "
+            "Optional 'transition_chunks' defaults to None for velocity and "
+            f"{DEFAULT_TRANSITION_CHUNKS} for target."
+        ),
+    )
     return parser.parse_args()
 
 
diff --git a/examples/online_serving/text_to_speech/README.md b/examples/online_serving/text_to_speech/README.md
index b749731e0..711fdec6b 100644
--- a/examples/online_serving/text_to_speech/README.md
+++ b/examples/online_serving/text_to_speech/README.md
@@ -13,7 +13,7 @@ For the full list of supported architectures across all modalities, see
 ## Supported Models
 
 | Model | HuggingFace repo | Voice cloning | Streaming | Voice presets / upload | Gradio demo |
-|---|---|---|---|---|---|
+| --- | --- | --- | --- | --- | --- |
 | Breeze-TTS-2 | `BreezeBlue/Breeze-TTS-2` | ✓ (`ref_audio`+`ref_text`) | ✓ (PCM stream) | speaker tags (`S0`..`S9`, default `S0`) | — |
 | Audio8 TTS Preview | `Audio8/Audio8-TTS-Preview-0.6b` | ✓ (`ref_audio`+`ref_text`) | ✓ (PCM stream) | uploaded audio voice only; no presets | ✓ |
 | Fish Speech S2 Pro | `fishaudio/s2-pro` | ✓ (`ref_audio`+`ref_text`) | ✓ (PCM stream) | — | ✓ |
@@ -27,7 +27,6 @@ For the full list of supported architectures across all modalities, see
 | OmniVoice | `k2-fsa/OmniVoice` | ✓ | — | — | — |
 | Qwen3-TTS | `Qwen/Qwen3-TTS-12Hz-1.7B-{CustomVoice,VoiceDesign,Base}` | ✓ (Base) | ✓ (PCM + WebSocket) | ✓ (presets + `/v1/audio/voices` upload) | ✓ (standard + FastRTC) |
 | VoxCPM2 | `openbmb/VoxCPM2` | ✓ | ✓ (AudioWorklet via gradio) | — | ✓ |
-| dots.tts | `dots-studio/dots.tts-soar` | — (text-only) | ✓ (PCM stream) | — (default placeholder only) | — |
 | Voxtral TTS | `mistralai/Voxtral-4B-TTS-2603` | ✓ (gated upstream) | ✓ | ✓ (presets) | ✓ |
 
 CosyVoice3 is intentionally absent: no online example exists for it yet. See its [offline section](../../offline_inference/text_to_speech/README.md#cosyvoice3) instead.
@@ -143,42 +142,6 @@ python examples/online_serving/text_to_speech/gepard/speech_client.py \
 - Concurrent requests at `max_num_seqs: 4` are supported. Native-AR recompute preemption is a known limitation of this architecture (a request that is preempted mid-generation can resume incorrectly); keep concurrency at or below `max_num_seqs` and treat preemption as out of scope until the platform fix lands.
 - Optional comparison against the upstream Gepard reference server needs Blackwell/Hopper + CUDA 13 + Postgres and is not part of CI.
 
-## dots.tts
-
-Single-stage, text-only TTS at 48 kHz. The current integration supports
-no-reference synthesis; voice cloning, reference audio, named voices, and
-precomputed speaker embeddings are not supported yet.
-
-### Launch
-
-```bash
-vllm serve dots-studio/dots.tts-soar --omni --trust-remote-code --port 8091
-```
-
-### Sending requests
-
-```bash
-# Non-streaming WAV
-curl -X POST http://localhost:8091/v1/audio/speech \
-    -H "Content-Type: application/json" \
-    -d '{
-        "input": "Hello, this is a dots TTS online-serving test.",
-        "voice": "default",
-        "response_format": "wav"
-    }' --output output.wav
-
-# Streaming 48 kHz mono PCM
-curl -X POST http://localhost:8091/v1/audio/speech \
-    -H "Content-Type: application/json" \
-    -d '{
-        "input": "Hello, this is a streaming dots TTS test.",
-        "voice": "default",
-        "stream": true,
-        "stream_format": "audio",
-        "response_format": "pcm"
-    }' --no-buffer | play -t raw -r 48000 -e signed -b 16 -c 1 -
-```
-
 ---
 
 ## GLM-TTS
@@ -781,6 +744,20 @@ vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice --omni --port 8091
 ./qwen3_tts/run_server.sh Base
 ```
 
+For a local deployment with multiple API frontend processes sharing one set
+of TTS stage engines, add `--api-server-count`:
+
+```bash
+vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
+    --omni --api-server-count 2 --port 8091
+```
+
+This mode supports local EngineCore stages only; headless or remote stage
+deployments are not supported. Runtime voice upload and deletion are disabled
+with multiple API frontends because their registries are process-local.
+Built-in voices, inline `ref_audio`, and voices restored from `custom_voice_dir`
+at startup are supported.
+
 ### Executor backend
 
 Single-GPU serves now default to the uniproc executor (lower IPC overhead, the Base cloning use case from [#2603](https://github.com/vllm-project/vllm-omni/issues/2603) / [#2604](https://github.com/vllm-project/vllm-omni/pull/2604)). `vllm_omni/deploy/qwen3_tts.yaml` is the only Qwen3-TTS deploy config; pass `--deploy-config <path>` to override.
@@ -835,6 +812,10 @@ checkpoint. When a request names an uploaded voice, the server infers
 `task_type="Base"`. Built-in presets such as `vivian` and `ryan` remain
 CustomVoice speakers and require a CustomVoice checkpoint.
 
+The runtime upload and delete routes require a single API frontend; with
+`--api-server-count > 1`, use inline `ref_audio` or restore precomputed voices
+from `custom_voice_dir` at startup.
+
 ### Precomputed custom voices
 
 For reused Base voice-cloning speakers, precompute the reference artifacts once
diff --git a/pyproject.toml b/pyproject.toml
index 434c4305c..c463d3917 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -66,14 +66,12 @@ dev = [
     "jiwer==4.0.0",
     "zhon==2.1.1",
     "zhconv==1.4.3",
-    "scipy==1.18.0",
     "funasr==1.3.29",
     "lpips==0.1.4", # for quantization fp8
     "orjson==3.11.9", # to make v1/embeddings API fast
     "voxcpm==2.0.3", # for VoxCPM2 path-locating in tests
     "torchdiffeq==0.2.5", # for covo_audio Test
     "FlagEmbedding==1.4.0", # for hunyuan_image3 tests
-    "s3tokenizer==0.3.0", # for tts test
     # Provides top-level cosyvoice2; do not co-install stepaudio2-minicpmo,
     # whose top-level stepaudio2 package conflicts with this distribution.
     "step-audio2==1.0.0", # Step-Audio2 / MiniCPM-o 4.5 Token2Wav (flashcosyvoice / hyperpyyaml)
diff --git a/recipes/Bagel/BAGEL-7B-MoT.md b/recipes/Bagel/BAGEL-7B-MoT.md
index 19ace3d33..17e10fb69 100644
--- a/recipes/Bagel/BAGEL-7B-MoT.md
+++ b/recipes/Bagel/BAGEL-7B-MoT.md
@@ -120,12 +120,19 @@ python examples/offline_inference/image_to_image/image_edit.py \
 The `--extra-args` JSON forwards BAGEL-specific parameters (e.g. `cfg_text_scale`,
 `cfg_img_scale`, `cfg_interval`, `cfg_renorm_type`) into
 `OmniDiffusionSamplingParams.extra_args` via the model-extras registry.
-For BAGEL img2img, the pipeline derives the generated image size from the input
-image: it preserves the input aspect ratio, aligns dimensions to the latent
-stride, and applies the checkpoint size limit. Explicit `--height` and
-`--width` values do not override that BAGEL-specific resize policy. Step-mode
-admission resolves this effective size before batching so differently shaped
-requests are scheduled separately.
+For BAGEL img2img, an explicit `--height`/`--width` (or `size` on
+`/v1/images/edits`) sets the output canvas, in both the single-stage and the
+two-stage deployment; the input image is still resized to a stride-aligned size
+for the VAE/ViT prefill. The latent grid needs multiples of 16, so a requested
+side that is not one is floored to the next multiple (1000x700 generates
+992x688) with a server-side warning, and the response reports the generated
+size. A side above the checkpoint limit is rejected with HTTP 400. When no size
+is requested
+(`size=auto`, or no `height`/`width`), the pipeline derives the canvas from the
+input image: it preserves the input aspect ratio, aligns dimensions to the
+latent stride, and applies the checkpoint size limit. Step-mode admission
+resolves this effective size before batching so differently shaped requests are
+scheduled separately.
 
 Run text-to-text with the shared understanding example. BAGEL's default
 `bagel.yaml` deploy config is discovered from the checkpoint, so no model-specific
diff --git a/recipes/Boogu/Boogu-Image.md b/recipes/Boogu/Boogu-Image.md
index 9a5ce0397..6ff848539 100644
--- a/recipes/Boogu/Boogu-Image.md
+++ b/recipes/Boogu/Boogu-Image.md
@@ -132,18 +132,19 @@ with `guidance_scale=1.0` remain valid on the same server: every rank evaluates
 only the positive branch, no negative embeddings are built, and no guidance is
 applied.
 
-### 1 x RTX 4090 48 GB (FP8)
+### 1 x RTX 4090 24 GB / 48 GB (FP8)
 
-Boogu-Image supports two ways to quantize or load the DiT transformer:
+Boogu-Image supports the following FP8 loading paths:
 
-| Path               | Base model                       | Edit model                       | Method                       | Scheme                  |
-| ------------------ | -------------------------------- | -------------------------------- | ---------------------------- | ----------------------- |
-| Serialized TorchAO | `Boogu/Boogu-Image-0.1-Base-fp8` | `Boogu/Boogu-Image-0.1-Edit-fp8` | `torchao_float8_weight_only` | FP8 weight-only (W8A16) |
-| Native online FP8  | `Boogu/Boogu-Image-0.1-Base`     | `Boogu/Boogu-Image-0.1-Edit`     | `fp8`                        | Dynamic W8A8            |
+| Path | Checkpoints | MLLM | DiT |
+| --- | --- | --- | --- |
+| Pre-quantized FP8 | `Boogu/Boogu-Image-0.1-{Base,Edit}-fp8` | HF checkpoint FP8 configuration | TorchAO FP8 weight-only (W8A16) |
+| Online FP8 | `Boogu/Boogu-Image-0.1-{Base,Edit}` | Optional 128x128 block FP8: Triton W8A8 (vLLM 0.28.0); Marlin W8A16 (vLLM 0.29.0) | Native dynamic FP8 (CUTLASS W8A8) |
 
 #### Environment
 
-The following configuration was validated:
+The following isolated environments were used for Base T2I and Edit I2I
+measurements at 512x512:
 
 - OS: Linux
 - Python: 3.12
@@ -152,7 +153,9 @@ The following configuration was validated:
 - vLLM-Omni version or commit: Use a commit that contains TorchAO FP8
   checkpoint loading for diffusion models
 - TorchAO version: 0.17.0
-- `kernels` / `kernels-data`: 0.16.1 / matching kernels-data
+- `kernels` / `kernels-data`: 0.16.1 / 0.16.1
+- Transformers: 5.17.0
+- Tokenizers: 0.23.1
 
 #### Command
 
@@ -167,19 +170,61 @@ vllm serve Boogu/Boogu-Image-0.1-Base-fp8 \
   '{"transformer":{"method":"torchao_float8_weight_only"}}'
 ```
 
-Native online FP8 (currently applied only to eligible vLLM-quantizable linear
-layers in the DiT transformer):
+Native online FP8:
 
 ```bash
+# DiT only
 vllm serve Boogu/Boogu-Image-0.1-Base \
   --omni \
   --port 8091 \
   --diffusion-quantization-config \
-  '{"transformer":{"method":"fp8"}}'
+  '{"mllm":null,"transformer":"fp8","vae":null}'
+
+# MLLM + DiT
+vllm serve Boogu/Boogu-Image-0.1-Base \
+  --omni \
+  --port 8091 \
+  --quantization fp8
+
+# MLLM + DiT (using --diffusion-quantization-config)
+vllm serve Boogu/Boogu-Image-0.1-Base \
+  --omni \
+  --port 8091 \
+  --diffusion-quantization-config \
+  '{"mllm":"fp8","transformer":"fp8","vae":null}'
+
 ```
 
-For image editing, use the matching Edit model ID from the table and keep the
-corresponding quantization configuration.
+For image editing, replace `Base` with `Edit` and keep the corresponding
+quantization configuration.
+
+#### Notes
+
+- **Memory usage:**
+    - The serialized TorchAO FP8 path uses approximately 21.1 GiB at 512x512
+      and 24.2-24.6 GiB at 1024x1024.
+    - The DiT-only online FP8 path uses approximately 26.9 GiB at 512x512
+      and 29.9-30.9 GiB at 1024x1024.
+    - The MLLM + DiT online FP8 path uses approximately 20.5-20.6 GiB at
+      512x512 and 23.6-24.5 GiB at 1024x1024.
+
+- **Quantization scope:** For original Base/Edit checkpoints, `--quantization fp8`
+  quantizes the MLLM's language-model linear layers through per-block FP8
+  and the DiT's linear layers through native online FP8. The vision encoder,
+  embeddings, normalization layers and VAE remain unquantized.
+
+- **Performance:** In the 48 GB Base/Edit benchmarks at 512x512, both DiT-only
+  and MLLM + DiT online FP8 reduced E2E latency by over 10 seconds compared with
+  official FP8 and vLLM-Omni pre-quantized FP8. The main runtime difference lies in the DiT quantization implementation, which switches from TorchAO weight-only FP8 (W8A16) to native CUTLASS
+  W8A8 kernels. This reduces additional dequantization overhead and enables
+  FP8 Tensor Core acceleration.
+
+- **Known Limitation:**
+    - **Output consistency:** With MLLM + DiT online FP8, same-seed outputs may visibly differ from BF16 for some Base prompts, but these differences do not mean lower image quality.
+
+    - **Import compatibility conflict between TorchAO and Diffusers::** Loading pre-quantized checkpoints requires `torchao>=0.17.0`, which has a compatibility conflict with `diffusers==0.40.0`. This produces a warning when Diffusers is imported, but currently does not affect Boogu-Image weight loading.
+
+    - **Conflict between the default kernels and Transformers versions:** The default Transformers version range (`>=5.10.1,<5.15`) conflicts with `kernels==0.16.1` when loading pre-quantized FP8 MLLM weights through Hugging Face `FP8Linear`. When using this loading path with `kernels==0.16.1`, please upgrade Transformers to `5.17.0`.
 
 #### Verification
 
@@ -190,19 +235,6 @@ ID passed to `vllm serve`. For example, use
 corresponding Edit model.
 
 Base text-to-image:
-## Fast text-to-image (Boogu-Image-0.1-Turbo)
-
-Turbo is the distilled text-to-image checkpoint. Its `model_index.json`
-declares `BooguImageTurboPipeline`, which runs the four-step DMD path instead
-of the scheduler-driven path used by Base.
-
-### Command
-
-```bash
-vllm serve Boogu/Boogu-Image-0.1-Turbo --omni --port 8091
-```
-
-### Verification
 
 ```bash
 curl -X POST http://localhost:8091/v1/images/generations \
@@ -231,22 +263,24 @@ curl -X POST http://localhost:8091/v1/images/edits \
   | jq -r '.data[0].b64_json' | base64 -d > edited_fp8.png
 ```
 
-#### Notes
+## Fast text-to-image (Boogu-Image-0.1-Turbo)
 
-- **Memory usage:**
-    - The serialized TorchAO FP8 path uses approximately 21.1 GiB at 512x512
-      and 24.2-24.6 GiB at 1024x1024.
-    - The native online FP8 path uses approximately 31.5 GiB for Base and
-      30.7 GiB for Edit at 1024x1024. It uses more memory because only eligible
-      DiT linear layers are quantized online, while the MLLM from the regular
-      Base/Edit checkpoint remains in BF16. Most of the observed difference
-      comes from the MLLM precision, although differences in the two DiT FP8
-      representations and kernels may also contribute.
-- **Quantization scope:** The transformer-scoped configuration applies to the
-  DiT. With the serialized `-fp8` checkpoints, the MLLM follows its own
-  checkpoint-declared FP8 configuration. With the regular checkpoints used for
-  online FP8, the MLLM remains in BF16. The VAE and scheduler are outside this
-  quantization routing.
+Turbo is the distilled text-to-image checkpoint. Its `model_index.json`
+declares `BooguImageTurboPipeline`, which runs the four-step DMD path instead
+of the scheduler-driven path used by Base.
+
+### Command
+
+```bash
+vllm serve Boogu/Boogu-Image-0.1-Turbo --omni --port 8091
+```
+
+### Verification
+
+```bash
+curl -X POST http://localhost:8091/v1/images/generations \
+  -H "Content-Type: application/json" \
+  -d '{
     "model": "Boogu/Boogu-Image-0.1-Turbo",
     "prompt": "A mountain lake at sunset, photorealistic, cinematic lighting",
     "size": "1024x1024",
diff --git a/recipes/BreezeBlue/Breeze-TTS-2.md b/recipes/BreezeBlue/Breeze-TTS-2.md
index 50e8858af..fb26ce91c 100644
--- a/recipes/BreezeBlue/Breeze-TTS-2.md
+++ b/recipes/BreezeBlue/Breeze-TTS-2.md
@@ -30,10 +30,20 @@ Four prompt modes are selected automatically from the request fields:
 | `ref_clone_tata` (clone) | `ref_audio` + `ref_text` + `input` | reference clip and its exact transcript |
 | `ref_edit_tata` (voice direction) | reference trio + `instructions` | keep the reference timbre, direct the delivery |
 
-Current scope: greedy sampling with `cfg_scale=1.0`; CFG ≠ 1.0 and
+Current scope: greedy sampling with `cfg_scale=1.0` and a default
+`repetition_penalty=1.1` on generated codebook-0 tokens; CFG ≠ 1.0 and
 `negative_prompt` are rejected with explicit client errors until companion
 request support lands.
 
+The [official inference example](https://github.com/breezeblue-ai/breeze-tts/blob/main/infer.py)
+also uses repetition penalty `1.1`, but its
+[runtime defaults](https://github.com/breezeblue-ai/breeze-tts/blob/main/breeze_infer/runtime.py)
+sample both the backbone and depth decoder with temperature `0.9` and top-k
+`50`. The [official voice-design examples](https://huggingface.co/BreezeBlue/Breeze-TTS-2#-voice-design)
+use CFG `4`. Those sampling and guidance settings are outside the current
+port's scope, so the examples below do not establish parity with the official
+voice-design outputs.
+
 ## Supported model contract
 
 | Item | Value |
@@ -42,9 +52,9 @@ request support lands.
 | Modes | plain, voice design (`instructions`), voice clone (`ref_audio` + `ref_text`), voice direction (reference + `instructions`) |
 | Languages | English and Chinese (model card) |
 | Reference audio | exactly one clip per request with its exact transcript; encoded by the bundled Qwen3-TTS tokenizer to 16 codebooks at 12.5 Hz |
-| Output | 24 kHz mono; `wav` or `pcm`; streaming SSE `speech.audio.delta` |
+| Output | 24 kHz mono; `wav` or `pcm`; raw audio streaming (`stream_format="audio"`) or SSE `speech.audio.delta` (`stream_format="sse"`) |
 | Length | prompt bounded by stage-0 `max_model_len=4096`; synthesis bounded by `max_new_tokens` codec frames (default 2048, about 164 s) |
-| Sampling | greedy (`temperature=0`) with `cfg_scale=1.0`; other guidance values and `negative_prompt` are rejected |
+| Sampling | greedy (`temperature=0`) with `cfg_scale=1.0` and `repetition_penalty=1.1`; other guidance values and `negative_prompt` are rejected |
 | Deployment profile | `vllm_omni/deploy/breeze_tts_2.yaml`: two stages on one GPU, async-chunk streaming with 8-frame codec chunks, stage 0 `gpu_memory_utilization=0.80`, stage 1 `0.15` |
 
 ## References
@@ -106,7 +116,7 @@ Voice design (instruction only, no reference audio):
 curl -X POST http://localhost:8091/v1/audio/speech \
     -H "Content-Type: application/json" \
     -d '{
-        "input": "[laughs] Welcome to tonight's story time.",
+        "input": "(laugh) Welcome to our story time.",
         "instructions": "A warm young woman, clear voice, lively delivery.",
         "response_format": "wav"
     }' --output breeze_design.wav
@@ -139,7 +149,7 @@ curl -X POST http://localhost:8091/v1/audio/speech \
     }' --output breeze_direction.wav
 ```
 
-Streaming PCM (SSE `speech.audio.delta` events):
+Streaming raw PCM (`stream_format="audio"`):
 
 ```bash
 curl -N -X POST http://localhost:8091/v1/audio/speech \
@@ -153,8 +163,9 @@ curl -N -X POST http://localhost:8091/v1/audio/speech \
     }' --output breeze_stream.pcm
 ```
 
-Expected results: finite, non-silent 24 kHz mono WAV files; streaming requests
-return incremental PCM deltas. On 1x L20 (greedy, single request after
+Expected results: finite, non-silent 24 kHz mono WAV files; the streaming example
+returns raw PCM bytes. Use `stream_format="sse"` for `speech.audio.delta`
+events containing base64-encoded audio. On 1x L20 (greedy, single request after
 warm-up) a few seconds of speech completes in roughly 3.4–3.8 s wall time.
 
 ## Notes
@@ -166,6 +177,12 @@ warm-up) a few seconds of speech completes in roughly 3.4–3.8 s wall time.
   supported yet.
 - **CFG**: `guidance_scale`/`cfg_scale` must be `1.0`. Non-1.0 values and
   `negative_prompt` return a client error.
+- **Repetition penalty**: the default `1.1` matches upstream's penalty on
+  generated codebook-0 tokens and discourages repeated silence. Override it
+  with `extra_params: {"repetition_penalty": 1.0}` to disable it, or another
+  finite positive value. Text and reference audio are excluded from its history.
+  The legacy `tools/breeze_tts_2_upstream_golden.py` uses penalty `1.0`; set
+  the same serving override when comparing against those golden frames.
 - **Length budget**: prompt length is bounded by stage 0 `max_model_len=4096`;
   synthesis length by `max_new_tokens` (default 2048 frames ≈ 164 s at the
   12.5 Hz codec frame rate) — set `max_new_tokens` for shorter caps.
@@ -181,7 +198,7 @@ warm-up) a few seconds of speech completes in roughly 3.4–3.8 s wall time.
 
 | Feature | Status | Notes |
 | ------- | ------ | ----- |
-| Streaming output | ✓ | `async_chunk: true`, 8-frame inter-stage chunks, SSE `speech.audio.delta` PCM |
+| Streaming output | ✓ | `async_chunk: true`, 8-frame inter-stage chunks; raw audio or SSE `speech.audio.delta` |
 | Voice cloning | ✓ | one reference clip plus transcript per request |
 | Voice design / voice direction | ✓ | `instructions` field, with or without a reference |
 | Classifier-free guidance | ✗ | `cfg_scale` must be `1.0`; `negative_prompt` rejected (follow-up) |
diff --git a/recipes/MammothModa2/MammothModa2.md b/recipes/MammothModa2/MammothModa2.md
index 02f8e30bf..26ec9ed1f 100644
--- a/recipes/MammothModa2/MammothModa2.md
+++ b/recipes/MammothModa2/MammothModa2.md
@@ -18,11 +18,18 @@ The generic example formats the AR prompt, drives the AR → DiT stage pipeline,
 and forwards MammothModa2-specific generation parameters through the
 pipeline-declared `extra_body` contract.
 
-MammothModa2's DiT stage consumes its inputs through the multi-stage kwargs
-interface (not `OmniDiffusionRequest`), so its generation knobs
-(`text_guidance_scale`, `cfg_range`, `num_inference_steps`) are passed via
-`--extra-body` rather than the standard `--num-inference-steps` / `--cfg-scale`
-flags. Image size uses the standard `--height` / `--width` flags.
+MammothModa2's DiT stage runs in the shared diffusion runtime in request mode.
+The first integration intentionally supports one request and one image per
+forward only (`max_num_seqs: 1`, `num_outputs_per_prompt: 1`). Request-level
+batching, step execution, continuous batching, cache acceleration,
+compilation, quantization, parallelism, and offload are not enabled by this
+recipe.
+
+Image size, seed, guidance, and denoising steps use the standard diffusion
+request fields. `cfg_range` remains a MammothModa2-specific `extra_body`
+parameter. For compatibility, the runtime also accepts the former
+`text_guidance_scale` and `num_inference_steps` keys in `extra_body`; when
+present and non-null, those keys take precedence over the standard fields.
 
 ## References
 
@@ -41,11 +48,11 @@ flags. Image size uses the standard `--height` / `--width` flags.
 
 ## Hardware Support
 
-The default deploy config runs both the AR and DiT stages on a single GPU
-(`devices: "0"`). The committed `gpu_memory_utilization` split (stage-0 AR `0.5`,
-stage-1 DiT `0.3`) is sized for an ~80 GB GPU. The model also fits on a 48 GB GPU
-after rebalancing the split so the AR weights (~23 GB) leave room for the KV
-cache — see the note under *1x L40S 48GB*.
+The default deploy config places both the AR and DiT stages on one GPU
+(`devices: "0"`). Its committed `gpu_memory_utilization` split is 0.5 for
+stage 0 and 0.3 for stage 1. The A800 validation section below also shows a
+two-GPU placement with one stage per GPU for attributable timing and memory;
+the measured results are summarized below.
 
 ## GPU
 
@@ -102,12 +109,13 @@ not implied.
 > set the stage-0 (AR) value to `0.8` and the stage-1 (DiT) value to `0.16`
 > before running. (On an ~80 GB GPU, leave the defaults unchanged.)
 
+### 1x NVIDIA A800 80GB
+
 #### Environment
 
 - OS: Linux
 - Python: Match the repository requirements for your checkout
-- Driver / runtime: NVIDIA CUDA environment with one L40S 48 GB (verified) or an
-  ~80 GB GPU for the default config
+- Driver / runtime: NVIDIA CUDA environment with one A800 80 GB
 - vLLM version: Match the repository requirements for your checkout
 - vLLM-Omni version or commit: Use the commit you are deploying from
 
@@ -120,8 +128,7 @@ hf download bytedance-research/MammothModa2-Preview --local-dir ./MammothModa2-P
 ```
 
 Run text-to-image with the shared offline example from the repository root. The
-deploy config sets `trust_remote_code`, so no extra flag is needed. Forward the
-MammothModa2 generation parameters as a JSON object through `--extra-body`:
+deploy config sets `trust_remote_code`, so no extra flag is needed:
 
 ```bash
 python examples/offline_inference/text_to_image/text_to_image.py \
@@ -130,23 +137,25 @@ python examples/offline_inference/text_to_image/text_to_image.py \
   --prompt "A stylish woman riding a motorcycle in NYC, movie poster style" \
   --height 1024 \
   --width 1024 \
-  --extra-body '{"text_guidance_scale": 4.0, "cfg_range": [0.0, 1.0], "num_inference_steps": 50}' \
+  --seed 42 \
+  --guidance-scale 4.0 \
+  --num-inference-steps 50 \
+  --extra-body '{"cfg_range": [0.0, 1.0]}' \
   --output mammoth_t2i.png
 ```
 
-The `--extra-body` JSON forwards MammothModa2-specific parameters into
-`OmniDiffusionSamplingParams.extra_args`. Keys are filtered against the model's
-declared `extra_body_params` (see
+The standard diffusion request fields are `height`, `width`, `seed`,
+`guidance_scale`, and `num_inference_steps`; use their corresponding CLI flags
+shown above. `--height` and `--width` must be multiples of 16.
+
+`cfg_range` is the only recommended MammothModa2 field in `--extra-body`; it
+sets the relative step range `[start, end]` over which CFG is applied (default
+`[0.0, 1.0]`). For compatibility, `text_guidance_scale` and
+`num_inference_steps` remain accepted `extra_body` aliases and, when non-null,
+take precedence over the standard request fields. Model extras are filtered
+against the declared `extra_body_params` (see
 [`vllm_omni/model_extras/mammothmodal2_preview.py`](../../vllm_omni/model_extras/mammothmodal2_preview.py)),
-so unknown keys for MammothModa2 are silently dropped:
-
-- `text_guidance_scale` — classifier-free guidance scale for the DiT stage
-  (default `9.0`; CFG is active only when `> 1.0`).
-- `cfg_range` — relative step range `[start, end]` over which CFG is applied
-  (default `[0.0, 1.0]`).
-- `num_inference_steps` — number of DiT denoising steps (default `50`).
-
-`--height` and `--width` must be multiples of 16.
+so unknown MammothModa2 extras may be dropped.
 
 Run text-to-text through the shared understanding example. It recognizes the
 MammothModa2 checkpoint and automatically selects `mammoth_moda2_ar.yaml`:
@@ -177,7 +186,49 @@ ls -lh mammoth_t2i.png
 python -c "from PIL import Image; print(Image.open('mammoth_t2i.png').size)"
 ```
 
-### 1x AMD MI300X, MammothModa2 Preview
+### 2x NVIDIA A800 80GB validation
+
+Use one A800 per stage so AR and DiT memory and timing are attributable. The
+per-stage override changes placement only; both stages remain single-rank.
+
+```bash
+VLLM_LOGGING_LEVEL=DEBUG vllm serve ./MammothModa2-Preview --omni \
+  --deploy-config vllm_omni/deploy/mammoth_moda2.yaml \
+  --stage-overrides '{"0":{"devices":"0"},"1":{"devices":"1"}}' \
+  --port 8099 \
+  --log-stats
+```
+
+Startup logs should identify stage 1 as `StageDiffusionClient` and resolve it
+to `MammothModa2DiTPipeline`. `DiffusionEngine` step timing is a DEBUG-level,
+per-request message, so it appears only after sending a text-to-image request
+with `VLLM_LOGGING_LEVEL=DEBUG`; it is not a startup marker. Seeing the legacy
+generation model runner for stage 1 is a failed migration.
+
+#### Migration benchmark
+
+The request-mode migration was checked on 2x NVIDIA A800 80GB PCIe with AR on
+GPU 0 and DiT on GPU 1. Each revision ran one warmup followed by 10 serial
+measured requests in the same initialized process. Both used BF16 eager mode,
+1024x1024 output, 50 denoising steps, guidance scale 4.0, seed 42, and no
+diffusion cache. The baseline was the pre-migration revision `caed3061`; the
+candidate was `19de562a`. Lower latency is better.
+
+| Metric | Baseline p50 | Baseline p95 | Candidate p50 | Candidate p95 |
+| --- | ---: | ---: | ---: | ---: |
+| End-to-end latency | 105.36 s | 106.01 s | 104.94 s | 105.79 s |
+| AR stage latency | 86.97 s | 87.61 s | 86.26 s | 87.11 s |
+| DiT stage latency | 18.27 s | 18.41 s | 18.60 s | 18.62 s |
+
+Peak sampled device memory was 39,209 MiB on the AR GPU for both revisions.
+The DiT GPU used 11,089 MiB for the baseline and 10,967 MiB for the candidate.
+The candidate's shared runtime reported 372.02 ms p50 per denoising step and a
+5.89 ms p50 AR-to-diffusion adapter time. All measured requests completed and
+both revisions produced valid, prompt-aligned 1024x1024 RGB images. The small
+latency differences are regression evidence, not a statistically significant
+speedup claim.
+
+### 1x AMD MI300X, MammothModa2 Preview (pre-migration baseline)
 
 #### Environment
 
diff --git a/recipes/MiniMaxAI/MiniMax-H3-NPU-950PR.md b/recipes/MiniMaxAI/MiniMax-H3-NPU-950PR.md
index 36eb78a5d..039b40272 100644
--- a/recipes/MiniMaxAI/MiniMax-H3-NPU-950PR.md
+++ b/recipes/MiniMaxAI/MiniMax-H3-NPU-950PR.md
@@ -1,195 +1,224 @@
-# MiniMax-H3 on a single NPU 950PR
+# MiniMax H3 on Ascend 950PR / 950DT
 
-This recipe runs MiniMax-H3 with online INT8 quantization on one NPU 950PR
-NPU (128 GB HiBL 1.0 HBM). It covers the single-card T2VA configuration at
-1024x576. For the eight-card Atlas 800I A3 BF16 route at 768P, see
-[MiniMax-H3-NPU.md](MiniMax-H3-NPU.md).
+> Joint video and audio generation — Ascend NPU deployment guide for the
+> four-card Ascend 950PR / 950DT route
 
-## Capacity requirements
+## Summary
 
-| Resource | Requirement |
-| --- | ---: |
-| NPU | 1x NPU 950PR |
-| NPU HBM | 128 GiB (131,072 MiB reported by `npu-smi`) |
-| Observed HBM high-water mark | 118,442 MiB (90.4% of capacity) |
-| Checkpoint storage | 135 GiB per partition, local disk strongly preferred |
-| Container shared memory | 8 GiB, or a writable local filesystem for spill |
-
-The observed high-water mark leaves about 12.3 GiB of headroom, so this card is
-sized for exactly one resident task partition at 1024x576. Do not expect a
-larger output shape or concurrency greater than one to fit.
-
-Because a single 950PR holds the whole partition in HBM, this route does not
-need layerwise offload, and the 200 GiB system-RAM floor carried by the 72 GiB
-GPU recipes does not apply. The validated run completed inside a container
-limited to 32 GiB of RAM. Passing `--enable-layerwise-offload` on this card is
-actively harmful: it stages weights in non-reclaimable host memory and the
-container's OOM killer terminates the server with exit code -9.
+- Vendor: MiniMaxAI
+- Model: [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- Tasks: T2VA, FL2VA, and Ref2VA
+- Mode: OpenAI-compatible `/v1/videos` HTTP serving
+- Hardware: Ascend 950PR / Ascend 950DT, 4x NPU (128 GB HBM per device)
+- Maintainer: Community
 
+This recipe covers the four-card 950PR / 950DT configuration at 1344x768.
+For the eight-card Atlas 800I A2 / A3 route, see
+[MiniMax-H3-NPU.md](MiniMax-H3-NPU.md); checkpoint layout, container
+preparation, MindIE-SD installation, and the ffmpeg/decord dependencies are
+described there and apply unchanged.
 
 ## Environment
 
-- Host architecture: x86_64
--  driver: 25.7.rc1.6 (hal 7.35.23)
--  firmware: 9.0.0.105.229
-- CANN toolkit: 9.1.0 (`/usr/local//cann-9.1.0`)
-- npu-smi: 25.7.rc1.6
-- Python: 3.12.13
-- PyTorch: 2.10.0+cpu
-- torch_npu: 2.10.0.post2
-- vLLM: 0.26.0
-- vLLM-Omni: 0.26.1.dev103+g584d78c67.npu (commit `584d78c6`)
-
-Install vLLM-Omni from a checkout with MiniMax-H3 support:
+Use the A5 variant of the official vLLM-Omni NPU images (see
+[NPU installation](../../docs/getting_started/installation/npu.md)):
 
 ```bash
-uv venv
-source .venv/bin/activate
-uv pip install -e .
+export IMAGE=quay.io/ascend/vllm-omni:v0.29.0-a5
 ```
 
+Check the [tag list](https://quay.io/repository/ascend/vllm-omni?tab=tags)
+for newer releases. Inside the container, install MindIE-SD and the optional
+Ref2VA media dependencies as described in
+[MiniMax-H3-NPU.md § Environment](MiniMax-H3-NPU.md#environment).
+
 ## Start a server
 
+Task selection follows the eight-card recipe: pass `--task-type fl2va` or
+`--task-type ref2va` to pick the task partition. The configurations below use
+4-card USP, 4-card text-encoder TP, and VAE `tile` parallelism.
+
+The two recommended configurations differ in how they fit memory: the
+lossless configuration enables distributed layerwise offload (DLO) to avoid
+activation OOM at longer durations, while the lossy configuration fits the
+maximum supported MiniMax-H3 workload shape without OOM, so DLO is omitted
+for performance.
+
+### Recommended lossless configuration (Ascend 950PR / 950DT)
+
 ```bash
-export MODEL=/path/to/MiniMax-H3/FL2VA
-export PORT=8000
+export PORT=9098
+export MODEL=/path/to/MiniMax-H3
 export VLLM_WORKER_MULTIPROC_METHOD=spawn
-export VLLM_OMNI_VIDEO_SYNC_TIMEOUT=14400
+export VLLM_OMNI_VIDEO_SYNC_TIMEOUT=4000
+export PYTHONDONTWRITEBYTECODE=1
+export HF_HUB_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
+export HCCL_NPU_SOCKET_PORT_RANGE="auto"
 
 vllm serve "${MODEL}" \
   --omni \
   --host 0.0.0.0 \
   --port "${PORT}" \
   --trust-remote-code \
-  --num-gpus 1 \
-  --tensor-parallel-size 1 \
-  --usp 1 \
+  --task-type fl2va \
+  --num-gpus 4 \
+  --usp 4 \
   --ring 1 \
-  --text-encoder-tp-size 1 \
-  --vae-patch-parallel-size 1 \
+  --text-encoder-tp-size 4 \
   --vae-parallel-mode tile \
   --vae-use-tiling \
-  --init-timeout 14400 \
-  --stage-init-timeout 14400 \
-  --quantization int8
+  --vae-patch-parallel-size 4 \
+  --enable-diffusion-pipeline-profiler \
+  --enable-distributed-layerwise-offload \
+  --diffusion-attention-backend FLASH_ATTN
 ```
 
-Do not pass `--diffusion-attention-backend CUDNN_ATTN`. cuDNN attention has no
-NPU implementation and fails at the first denoise step. Leave the backend
-unset: it resolves to `TORCH_SDPA`, or to `FLASH_ATTN` when MindIE-SD is
-installed (see [MiniMax-H3-NPU.md § Environment](MiniMax-H3-NPU.md#environment)).
+H3 is CFG-distilled, so `--cfg-parallel-size` must remain 1. The first
+request includes regional compilation; warm the server once before measuring
+steady-state latency.
 
-H3 is CFG-distilled, so `--cfg-parallel-size` must remain 1.
+### Recommended lossy configuration (Ascend 950PR / 950DT)
 
-## Validated evidence
-
-Measured on one NPU 950PR with the server command above plus
-`--enable-diffusion-pipeline-profiler`, generating a 5 s 1024x576 T2VA clip from
-the request in [§ T2VA request example](#t2va-request-example). MiniMax-H3
-requested 60 denoise steps and executed 59 denoise updates, so per-step latency
-is `denoise / 59`. `ffprobe` confirms every returned MP4 is 1024x576, 24 fps,
-124 video frames, 5.175 s, with a 32 kHz audio track of 165,600 samples.
-
-Five requests were issued back to back with no idle time between them. The card
-is measurably faster on the first request than in steady state, so both regimes
-are reported.
-
-| Stage | First request, cold card | Thermal steady state |
-| --- | ---: | ---: |
-| End-to-end request | 462.13 s | 506.38 s |
-| Text encode | 0.55 s | 0.05 s |
-| Denoise (59 updates) | 429.29 s | 471.74 s |
-| Per denoise update | 7,276 ms | 7,996 ms |
-| VAE decode | 8.43 s | 8.14 s |
-| Worker-to-server handoff | 24 s | 27 s |
-| MP4 muxing | 0.57 s | 0.50 s |
-| Server-reported `denoise_step_latency_ms` | 7,702 ms | 8,440 ms |
-| Peak HBM (`npu-smi`) | 118,442 MiB | 118,442 MiB |
-| Average NPU power | 566.9 W | 556.9 W |
-| Peak NPU temperature | 104 C | 104 C |
-
-Sample counts differ per row. The cold column is a single request. In the steady
-column, text encode, denoise and VAE decode are means over the four subsequent
-requests — denoise spanned 470.37 to 473.21 s, a 0.60% spread — while
-end-to-end, handoff and muxing are means over the two of those four that
-survived the handoff timeout described above.
-
-**Report the steady-state column.** The cold card completes denoise 9.9% faster
-while drawing only 1.8% more average power, and both regimes reach the same
-104 C ceiling, so the first request is buying a short window of higher clocks
-before the die saturates. Any benchmark that issues a single request against an
-idle card will overstate throughput by about 10%.
-
-**Do not read `denoise_step_latency_ms` as a per-step time.** The server divides
-the entire stage wall time by the 60 *requested* steps, so it absorbs text
-encoding, VAE decode and the 837 MiB handoff. All three successful requests
-satisfy `denoise_step_latency_ms == e2e_stage_wall_time_ms / 60` exactly. The
-per-update figure in the table is `diffuse / 59` from the pipeline profiler.
-
-Denoise accounts for 93% of the steady-state request and the handoff accounts
-for 5.3%, so keeping the transfer in shared memory should bring end-to-end down
-to roughly 480 s.
-
-Peak HBM is sampled externally with `npu-smi` at a 3 s interval. It is a
-reserved high-water mark rather than live allocation: it reads 111,272 MiB after
-weight loading and before the first request, and does not fall back after
-requests complete. Re-measure for longer outputs, a different output shape, or
-concurrency greater than one.
-
-### Startup
-
-Weight loading took **31 min 50 s** on the validated host (first log line
-08:04:59, `Application startup complete` 08:36:49), with the checkpoint on a
-shared GlusterFS network mount. This is why the server command sets
-`--init-timeout 14400` and `--stage-init-timeout 14400`; the stock 600 s and
-1800 s timeouts both abort mid-load with `TimeoutError` and exit code 143.
-Reduce both timeouts when the partition is staged on local disk.
-
-## T2VA request example
+Adds EQBSA sparse attention (block-sparse with Q/K INT8 + V FP8 mixed
+precision) and MXFP8 online quantization, and drops DLO:
 
 ```bash
-export API_URL="http://127.0.0.1:${PORT}/v1/videos/sync"
+export PORT=9098
+export MODEL=/path/to/MiniMax-H3
+export VLLM_WORKER_MULTIPROC_METHOD=spawn
+export VLLM_OMNI_VIDEO_SYNC_TIMEOUT=4000
+export PYTHONDONTWRITEBYTECODE=1
+export HF_HUB_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
+export HCCL_NPU_SOCKET_PORT_RANGE="auto"
 
-curl -sS --max-time 1800 -X POST "${API_URL}" \
-  -F 'prompt=At night, three cats march into a bedroom playing tiny brass instruments, then abruptly file out, with synchronized room ambience.' \
-  -F 'width=1024' \
-  -F 'height=576' \
-  -F 'aspect_ratio=16:9' \
-  -F 'fps=24' \
-  -F 'num_inference_steps=60' \
-  -F 'flow_shift=12' \
-  -F 'seed=1101' \
-  -F 'extra_params={"task":"t2va","duration":5,"audio_flow_shift":3.0}' \
-  -o t2va.mp4
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --task-type fl2va \
+  --num-gpus 4 \
+  --usp 4 \
+  --ring 1 \
+  --text-encoder-tp-size 4 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --vae-patch-parallel-size 4 \
+  --enable-diffusion-pipeline-profiler \
+  --diffusion-attention-config '{"default":{"backend":"RAINFUSION_ATTN","block_sparse":{"sparsity":0.8,"precision":"mix","start_step":8,"end_step":12}}}' \
+  --diffusion-quantization-config '{"transformer":{"method":"mxfp8"}}'
 ```
 
+The recommended lossy configuration uses a **start=8 / end=12** dense-fallback
+window; see below for more aggressive settings.
+
+### Optional optimizations
+
+The following sections list only the **increment or replacement** relative to
+the recommended lossless configuration; environment variables and the
+remaining flags stay unchanged.
+
+#### Tuning the EQBSA dense-fallback window
+
+`start_step` and `end_step` are the numbers of leading/trailing steps that
+fall back to dense attention — not step indices. `precision` defaults to
+`bf16`; EQBSA requires setting it to `mix` explicitly. For 1344x768, 50-step
+T2VA:
+
+| Configuration | `start_step` | `end_step` | Notes |
+| --- | ---: | ---: | --- |
+| Quality first (recommended) | 8 | 13 | General and complex-motion scenes |
+| Balanced | 0 | 13 | Balanced |
+| Speed first | 0 | 0 | Simple, low-motion scenes |
+
+When frames look discontinuous or details unstable, increase `end_step`
+first, then `start_step`; do not compensate by lowering `sparsity` alone.
+These pairings were validated at 1344x768 / 50 steps only; re-evaluate for
+other resolutions or step counts.
+
+#### Cache-DiT
+
+Append to enable DiT block caching with TaylorSeer extrapolation — see the
+[Cache-DiT guide](../../docs/user_guide/diffusion/cache_acceleration/cache_dit.md):
+
+```bash
+  --cache-backend cache_dit \
+  --enable-cache-dit-summary \
+  --cache-config '{"Fn_compute_blocks":2,"Bn_compute_blocks":1,"max_warmup_steps":4,"residual_diff_threshold":0.4,"max_continuous_cached_steps":4,"enable_taylorseer":true,"taylorseer_order":2}'
+```
+
+#### MXFP4 online quantization
+
+Append to switch the DiT to MXFP4 online quantization:
+
+```bash
+  --diffusion-quantization-config '{"transformer":{"method":"mxfp4"}}'
+```
+
+and remove `--enable-distributed-layerwise-offload`.
+
+## Request examples
+
+Identical to the eight-card recipe; see
+[MiniMax-H3-NPU.md § HTTP API examples](MiniMax-H3-NPU.md#http-api-examples)
+and the GPU recipe's full parameter table.
+
+## Benchmarks (Ascend 950PR)
+
+Measured with `--enable-diffusion-pipeline-profiler` on vLLM-Omni 0.28.0:
+lossless rows use the recommended lossless configuration (with DLO), lossy
+rows the recommended lossy configuration (EQBSA + MXFP8, without DLO). Memory
+figures are per device.
+
+| Task | Resolution | Frames | Duration (s) | Config | E2E (s) | DiT total (s) | DiT per-step (s) | DiT steps | Text encode (s) | Ref video encode (s) | Ref audio encode (s) | VAE decode (s) | Ref preprocess (s) | Post-process (s) | CPU MP4 (s) | Resident weights (GB) | Peak memory (GB) |
+| ---- | ---- | ---- | ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| t2va | 1344x768 | 124 | 5 | lossless | 203.95 | 198.10 | 4.04 | 49 | 0.57 | NA | NA | 5.05 | NA | 0.001 | 0.23 | 3.97 | 22.2 |
+| t2va | 1344x768 | 362 | 15 | lossless | 1489.17 | 1474.35 | 30.08 | 49 | 0.69 | NA | NA | 13.45 | NA | 0.001 | 0.82 | 3.97 | 32.14 |
+| t2va | 1344x768 | 124 | 5 | lossy | 113.86 | 109.81 | 2.24 | 49 | 0.03 | NA | NA | 3.82 | NA | 0.001 | 0.21 | 56.99 | 64.38 |
+| t2va | 1344x768 | 362 | 15 | lossy | 762.17 | 749.40 | 15.29 | 49 | 0.03 | NA | NA | 12.19 | NA | 0.001 | 0.61 | 56.99 | 74.26 |
+| ref2va | 1344x768 | 124 | 5 | lossless | 745.43 | 730.22 | 14.9 | 49 | 1.16 | 8.15 | 0.13 | 5.12 | 0.41 | 0.001 | 0.28 | 3.97 | 23.82 |
+| ref2va | 1344x768 | 362 | 15 | lossless | 5887.24 | 5847.57 | 119.33 | 49 | 2.54 | 22.07 | 0.23 | 13.34 | 0.81 | 0.001 | 0.70 | 3.97 | 32.53 |
+| ref2va | 1344x768 | 124 | 5 | lossy | 400.40 | 387.82 | 7.91 | 49 | 0.95 | 7.05 | 0.09 | 3.91 | 0.41 | 0.001 | 0.21 | 56.6 | 66.03 |
+| ref2va | 1344x768 | 362 | 15 | lossy | 3037.84 | 3001.31 | 61.24 | 49 | 2.28 | 20.64 | 0.15 | 12.1 | 0.81 | 0.001 | 0.70 | 56.6 | 74.76 |
+
+The resident-weight figures reflect the DLO strategy difference: with DLO
+(lossless rows) DiT weights live in host memory and only the active layer
+stays on the device, while without DLO (lossy rows) the quantized weights are
+resident in HBM. Peak memory stays well inside the 128 GB per-device capacity
+in both cases. These numbers describe the validated shapes rather than a
+general throughput guarantee.
+
 ## Known limitations
 
-- INT8 online quantization is validated for T2VA on this card. Use BF16 for
-  FL2VA and Ref2VA, or re-measure before relying on it.
-- Single-card serving loads one task partition at a time. For Ref2VA, stop the
-  server and restart it against the `Ref2VA` directory.
-- Sustained load drives the die to 104 C and costs about 10% of denoise
-  throughput relative to a cold card. Warm the server with at least one full
-  request before measuring, and treat steady state as the reportable number.
-- Requests can fail during result handoff on hosts where the IPC spill path is
-  slow. See [§ Result handoff and shared
-  memory](#result-handoff-and-shared-memory).
-- Loading the checkpoint from a network mount takes over 30 minutes and forces
-  very large init timeouts. Stage the partition on local disk when possible.
-- The configuration measured here is 1024x576 at 60 steps, which differs from
-  the 1344x768 at 50 steps used by the GPU recipes in this directory. Denoise
-  cost scales superlinearly with token count, so the numbers are not directly
-  comparable across recipes.
-- The image ships a `triton` package whose  backend is not built
-  (`No module named 'triton._C.libtriton.'`). vLLM logs this as an error
-  at startup and disables Triton; the diffusion path does not need it and the
-  run completes normally.
+- Task serving is partitioned by `--task-type`: T2VA/FL2VA and Ref2VA load
+  different DiTs, so switching between them requires a restart with the other
+  partition.
+- H3 currently executes one generation request per diffusion batch.
+- The first regional-compile request is a warmup and should not be included
+  in steady-state performance measurements.
+- VAE patch parallelism requires size 1 or the full DiT group size and
+  supports the H3 native `tile` mode only.
+- The lossy configuration (EQBSA + MXFP8) is validated for T2VA and Ref2VA;
+  use the lossless configuration for FL2VA or re-validate first.
+- The lossless configuration trades throughput for activation headroom via
+  DLO; if your workload never approaches the maximum duration, dropping
+  `--enable-distributed-layerwise-offload` may improve latency at the risk of
+  OOM on longer durations.
 
 ## Additional resources
 
 - [MiniMax-H3.md](MiniMax-H3.md) — full GPU guide
-- [MiniMax-H3-NPU.md](MiniMax-H3-NPU.md) — eight-card Atlas 800I A3 BF16 guide
-- [Int8 quantization](../../docs/user_guide/quantization/int8.md)
+- [MiniMax-H3-NPU.md](MiniMax-H3-NPU.md) — eight-card Atlas 800I A2 / A3
+  guide (checkpoint, container, and dependency details)
+- [NPU installation](../../docs/getting_started/installation/npu.md)
+- [RainFusion attention](../../docs/user_guide/diffusion/attention_backends/rainfusion.md)
+  — block-sparse knobs and tuning
+- [Online quantization](../../docs/user_guide/quantization/online.md)
+  — INT8 / MXFP8 / MXFP4
+- [Cache-DiT guide](../../docs/user_guide/diffusion/cache_acceleration/cache_dit.md)
 - [Supported models](../../docs/models/supported_models.md)
 - [Video API](../../docs/serving/videos_api.md)
diff --git a/recipes/MiniMaxAI/MiniMax-H3-NPU.md b/recipes/MiniMaxAI/MiniMax-H3-NPU.md
index c6ee0904b..971be278d 100755
--- a/recipes/MiniMaxAI/MiniMax-H3-NPU.md
+++ b/recipes/MiniMaxAI/MiniMax-H3-NPU.md
@@ -1,7 +1,8 @@
 # MiniMax H3 on Ascend NPU
 
 > Joint video and audio generation with text, first/last keyframes, and mixed
-> image/video/audio references — Ascend NPU deployment guide
+> image/video/audio references — Ascend NPU deployment guide for Atlas 800I A2
+> and Atlas 800I A3
 
 ## Summary
 
@@ -9,7 +10,7 @@
 - Model: [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
 - Tasks: T2VA, FL2VA, and Ref2VA
 - Mode: OpenAI-compatible `/v1/videos` HTTP serving
-- Hardware: Atlas 800I A3
+- Hardware: Atlas 800I A2 / Atlas 800I A3, 8x NPU
 - Maintainer: Community
 
 This recipe adapts [MiniMax-H3.md](MiniMax-H3.md) for Ascend NPU
@@ -22,103 +23,288 @@ environments. Differences from the GPU path:
   automatically falls back to soundfile / ffmpeg for wav/mp3/m4a/mp4 audio
   inputs.
 
+For the four-card Ascend 950PR / 950DT route, see
+[MiniMax-H3-NPU-950PR.md](MiniMax-H3-NPU-950PR.md).
+
 ## Prerequisites
 
 ### Checkpoint
 
-Same as the GPU recipe — Hugging Face access approval is required. Authenticate
-once; `vllm serve` downloads the required nested components automatically:
+Download the weights once; `vllm serve` accepts the repository ID or a local
+path and resolves the nested components automatically:
 
 ```bash
-hf auth login
-export MODEL=MiniMaxAI/MiniMax-H3
+export MODEL=/path/to/MiniMax-H3
+hf download MiniMaxAI/MiniMax-H3 --local-dir "${MODEL}"
+```
+
+The checkpoint directory layout is:
+
+```text
+MiniMax-H3/
+├── FL2VA/          # shared by T2VA/FL2VA tasks
+├── Ref2VA/         # Ref2VA task weights
+└── model_index.json
 ```
 
 ### Environment
 
-- Ascend driver & firmware: 25.5.1
-- CANN toolkit: 9.0.1
-- Python: 3.12
-- PyTorch: 2.10.0+cpu
-- torch_npu: 2.10.0.post2
-- Install vLLM-Omni from a checkout with MiniMax H3 support:
+The recommended deployment uses the official vLLM-Omni NPU images, which ship
+the matching vLLM / vLLM-Ascend / vLLM-Omni stack (see
+[NPU installation](../../docs/getting_started/installation/npu.md)). Pick the
+image matching the hardware — `quay.io/ascend/vllm-omni:v0.29.0` for
+Atlas 800I A2, `quay.io/ascend/vllm-omni:v0.29.0-a3` for Atlas 800I A3 — and
+check the
+[tag list](https://quay.io/repository/ascend/vllm-omni?tab=tags) for newer
+releases:
 
 ```bash
-uv venv
-source .venv/bin/activate
-uv pip install -e .
+export IMAGE=quay.io/ascend/vllm-omni:v0.29.0-a3
+export CONTAINER_NAME=h3
+
+docker run -it -u root --name ${CONTAINER_NAME} \
+  --privileged=true \
+  --shm-size=2000g \
+  --net=host \
+  --device /dev/davinci0 \
+  --device /dev/davinci1 \
+  --device /dev/davinci2 \
+  --device /dev/davinci3 \
+  --device /dev/davinci4 \
+  --device /dev/davinci5 \
+  --device /dev/davinci6 \
+  --device /dev/davinci7 \
+  --device /dev/davinci_manager \
+  --device /dev/devmm_svm \
+  --device /dev/hisi_hdc \
+  -v /home:/home \
+  -v /usr/local/dcmi:/usr/local/dcmi \
+  -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \
+  -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \
+  -v /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info \
+  -v /etc/ascend_install.info:/etc/ascend_install.info \
+  -v /root/.cache:/root/.cache \
+  ${IMAGE} \
+  /bin/bash
 ```
 
-Install the **mindie-sd** operator library to enable Ascend-optimized fused
-operators (`adalayernorm`, etc.) and the RainFusion `rf_v2` block-sparse
-attention kernel:
+Inside the container:
+
+- **MindIE-SD** provides the Ascend-optimized fused operators
+  (`adalayernorm`, etc.), the LaserAttention kernel, and the RainFusion
+  block-sparse attention kernel. If the image does not ship it, build it from
+  source:
 
 ```bash
-git clone https://gitcode.com/Ascend/MindIE-SD.git && cd MindIE-SD
-
-# Comment out the tik_ops build step (not needed for this use case)
-sed -i 's|^\(\s*\)source ${current_script_dir}/build_tik_ops.sh|\1# source ${current_script_dir}/build_tik_ops.sh|' build/build_ops.sh
-
+git clone https://gitcode.com/Ascend/MindIE-SD.git
+cd MindIE-SD
 python setup.py bdist_wheel
-cd dist
-pip install mindiesd-*.whl
+pip install dist/mindiesd-*.whl
 ```
 
-- `ffmpeg` and `ffprobe` must be available on `PATH`. They are used for
-  reference-video preparation and MP4 output.
-- Reference-video decoding uses `decord` when available and falls back to
-  PyAV otherwise.
-- Audio inputs do not require TorchCodec: wav/mp3/m4a/mp4 files are loaded
-  at native sample rate through the soundfile / ffmpeg fallback.
+- To track the latest vLLM-Omni, install it from a checkout:
+
+```bash
+git clone https://github.com/vllm-project/vllm-omni.git
+cd vllm-omni
+VLLM_OMNI_TARGET_DEVICE=npu pip install -e . --no-build-isolation
+```
+
+- `ffmpeg` and `ffprobe` must be available on `PATH` (reference-video
+  preparation and MP4 output). Reference-video decoding uses `decord` when
+  available and falls back to PyAV otherwise; `decord` is required only for
+  the Ref2VA workflow and can be built with:
+
+```bash
+apt update
+apt install -y ffmpeg pkg-config libavcodec-dev libavformat-dev \
+  libavutil-dev libswscale-dev libavfilter-dev libavdevice-dev
+git clone --depth 1 --recursive https://github.com/dmlc/decord.git
+cd decord
+mkdir -p build && cd build
+cmake .. -DUSE_CUDA=0 -DDECODE_FFMPEG=1 -DCMAKE_BUILD_TYPE=Release
+make
+cd ../python
+pip3 install . --no-build-isolation
+```
 
 ## Start a server
 
-Pass the repository ID directly. The pipeline loads the two nested DiTs while
-sharing the tokenizer, processor, text encoder, and VAEs from `FL2VA`.
+T2VA and FL2VA share one set of weights; the Ref2VA weights differ. Select
+the task partition at startup with **`--task-type`** (`fl2va` or `ref2va`).
+When unset, only the T2VA/FL2VA weights are loaded. All remaining flags are
+task-agnostic.
 
-### Multi-NPU: 768P combined-service configuration
+### Recommended lossless configuration (Atlas 800I A2 / A3)
 
-Use Ulysses sequence parallelism degree 8, text-encoder tensor parallelism
-degree 8, native tiled VAE patch parallelism degree 8, and distributed
-layerwise offload:
+Lossless means fused operators plus the high-performance FLASH_ATTN backend
+only. The configuration uses 8-card USP, 8-card text-encoder TP, distributed
+layerwise offload (DLO), and VAE `tile` parallelism:
 
 ```bash
-export ASCEND_RT_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
 export PORT=9098
-export MODEL=MiniMaxAI/MiniMax-H3
+export MODEL=/path/to/MiniMax-H3
 export VLLM_WORKER_MULTIPROC_METHOD=spawn
-export VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800
+export VLLM_OMNI_VIDEO_SYNC_TIMEOUT=4000
 export PYTHONDONTWRITEBYTECODE=1
+export HF_HUB_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
+export MINDIE_SD_FA_TYPE="ascend_laser_attention"
+export HCCL_NPU_SOCKET_PORT_RANGE="auto"
 
 vllm serve "${MODEL}" \
   --omni \
   --host 0.0.0.0 \
   --port "${PORT}" \
   --trust-remote-code \
+  --task-type fl2va \
   --num-gpus 8 \
   --usp 8 \
   --ring 1 \
   --text-encoder-tp-size 8 \
-  --enable-distributed-layerwise-offload \
   --vae-parallel-mode tile \
   --vae-use-tiling \
   --vae-patch-parallel-size 8 \
+  --enable-distributed-layerwise-offload \
+  --enable-diffusion-pipeline-profiler \
   --diffusion-attention-backend FLASH_ATTN
 ```
 
-Do not add `--enforce-eager`. The first request includes regional
-compilation; warm the server once before measuring steady-state latency.
-H3 is CFG-distilled, so `--cfg-parallel-size` must remain 1.
+Notes:
 
-The same endpoint accepts `task=t2va`, `task=fl2va`, and `task=ref2va`; no
-partition restart is required. Layerwise offload applies to both DiTs.
+- Do not add `--enforce-eager`. The first request includes regional
+  compilation; warm the server once before measuring steady-state latency.
+- H3 is CFG-distilled, so `--cfg-parallel-size` must remain 1.
+- Keep `--ring 1` when switching to RainFusion attention (below): the
+  block-sparse kernel ranks key blocks over the whole sequence, so ring
+  parallelism would split away the keys it needs. Scale with `--usp` instead.
+- DLO offloads DiT layers with parameters gathered across the parallel group
+  instead of replicated per rank, which is what fits the combined 768P
+  service into 64 GB HBM per device (Atlas 800I A3). Host (CPU) memory usage
+  is high with this option.
 
-On Atlas 800I A3 (64 GB HBM per device) the combined service does not fit at
-768P without offloading or sharding: use distributed layerwise offload (as
-above) or HSDP — see
-[§ Memory and attention optimizations](#memory-and-attention-optimizations-a3).
+### Recommended lossy configuration (Atlas 800I A2 / A3)
 
-### CPU MP4 response encoding (Atlas A2)
+Adds RainFusion block-sparse attention and INT8 online quantization on top of
+the lossless configuration. Validated for T2VA and Ref2VA; see
+[Benchmarks](#benchmarks-atlas-800i-a2--a3):
+
+```bash
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --task-type fl2va \
+  --num-gpus 8 \
+  --usp 8 \
+  --ring 1 \
+  --text-encoder-tp-size 8 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --vae-patch-parallel-size 8 \
+  --enable-distributed-layerwise-offload \
+  --enable-diffusion-pipeline-profiler \
+  --diffusion-quantization-config '{"transformer":{"method":"int8"}}' \
+  --diffusion-attention-config '{"default": {"backend": "RAINFUSION_ATTN",
+      "block_sparse": {"sparsity": 0.8, "start_step": 12}}}'
+```
+
+Online INT8 quantization can be combined with distributed layerwise offload
+while AllGather is enabled. Keep AllGather enabled for SP>1; use
+`--dlo-no-use-allgather` only when collective communication is unavailable.
+
+### Optional optimizations
+
+The following sections list only the **increment or replacement** relative to
+the recommended lossless configuration; environment variables and the
+remaining flags stay unchanged.
+
+#### Cache-DiT
+
+Append to enable DiT block caching with TaylorSeer extrapolation — see the
+[Cache-DiT guide](../../docs/user_guide/diffusion/cache_acceleration/cache_dit.md):
+
+```bash
+  --cache-backend cache_dit \
+  --enable-cache-dit-summary \
+  --cache-config '{"Fn_compute_blocks":2,"Bn_compute_blocks":1,"max_warmup_steps":4,"residual_diff_threshold":0.4,"max_continuous_cached_steps":4,"enable_taylorseer":true,"taylorseer_order":2}'
+```
+
+#### EQBSA sparse attention
+
+EQBSA applies Q/K INT8 with V FP8 mixed quantization on top of block-sparse
+attention. Replace `--diffusion-attention-backend FLASH_ATTN` with:
+
+```bash
+  --diffusion-attention-config '{"default":{"backend":"RAINFUSION_ATTN","block_sparse":{"sparsity":0.8,"start_step":8,"end_step":13,"precision":"mix"}}}'
+```
+
+`precision` defaults to `bf16`; enabling EQBSA requires setting it to `mix`
+explicitly. `start_step` and `end_step` are the numbers of leading/trailing
+steps that fall back to dense attention — not step indices. For 1344x768,
+50-step T2VA:
+
+| Configuration | `start_step` | `end_step` | Notes |
+| --- | ---: | ---: | --- |
+| Quality first (recommended) | 8 | 13 | General and complex-motion scenes |
+| Balanced | 0 | 13 | Balanced |
+| Speed first | 0 | 0 | Simple, low-motion scenes |
+
+When frames look discontinuous or details unstable, increase `end_step`
+first, then `start_step`; do not compensate by lowering `sparsity` alone.
+These pairings were validated at 1344x768 / 50 steps only; re-evaluate for
+other resolutions or step counts.
+
+## HTTP API examples
+
+The request contract is identical to the GPU recipe; see
+[MiniMax-H3.md § HTTP API examples](MiniMax-H3.md#http-api-examples). Use the
+validated 768P shapes (e.g. `width=1344 height=768`) on NPU. Quick start
+against the synchronous endpoint:
+
+```bash
+export API_URL="http://127.0.0.1:${PORT}/v1/videos/sync"
+
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=In a snowy blue-purple forest, Ori carefully walks past a sleeping giant; footsteps crunch in the snow while the creature breathes and softly snorts.' \
+  -F 'width=1344' \
+  -F 'height=768' \
+  -F 'aspect_ratio=16:9' \
+  -F 'fps=24' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12.0' \
+  -F 'audio_flow_shift=3.0' \
+  -F 'seed=1101' \
+  -F 'extra_params={"task":"t2va","duration":5.0}' \
+  -o t2va.mp4
+```
+
+Switch tasks via `extra_params.task` (`t2va` / `fl2va` / `ref2va`); FL2VA and
+Ref2VA additionally pass `input_references` (first-frame image, reference
+video/audio). The full parameter table lives in the GPU recipe.
+
+## FlashGen 4-step online LoRA (T2VA)
+
+The FlashGen 4-step weights are a native-layout LoRA single file
+(`key_format=minimax-h3-native`) loaded at runtime — no merge into the base
+checkpoint. Download them from
+[FlashGen/Minimax-H3-4step-lora-flashgen](https://modelscope.cn/models/FlashGen/Minimax-H3-4step-lora-flashgen),
+then on top of the recommended configuration above:
+
+- append `--lora-backend peft --lora-path "${FLASHGEN_LORA}"`,
+- use `--diffusion-attention-backend FLASH_ATTN` (dense; drop the RainFusion
+  attention config),
+- issue T2VA requests with `num_inference_steps=4` and the `lora` request
+  field (`name` / `path` / `scale`) — see
+  [MiniMax-H3.md § FlashGen native LoRA](MiniMax-H3.md#flashgen-native-lora).
+
+T2VA only; FL2VA and Ref2VA are not supported, and neither
+`--enable-cpu-offload` nor `--enable-layerwise-offload` may be combined with
+it.
+
+## CPU MP4 response encoding (Atlas A2)
 
 Non-streaming MP4 responses use one public automatic encoder. It checks the
 runtime frame shape, common dtype, and RGB channel-plane contiguity for every
@@ -127,121 +313,65 @@ inputs fall back to the legacy muxer before opening the PyAV container. No CLI
 flag, model declaration, or user configuration is required. Streaming fMP4
 output remains on its existing incremental path.
 
-Current performance and correctness validation is limited to one Atlas A2 host
-with 8x Ascend 910B4-1 NPUs, the `FL2VA`/`t2va` partition, one request at a
-time, 1344x768 at 24 fps, and 5, 8.7, and 15 second requests. This optimization
-only changes CPU MP4 response encoding; it does not change DiT execution or
-stage 0.
+## Ascend-optimized components
 
-### Optional optimizations
+The optimizations stacked by the recommended configurations above:
 
-Two independent optimizations may be enabled on top of the configuration
-above. Both are validated for T2VA only.
+1. Ascend-friendly attention: the MindIE-SD `ascend_laser_attention` fused
+   kernel selected through `MINDIE_SD_FA_TYPE`, carried by the FLASH_ATTN
+   backend with a mask-free packed varlen path and K/V prefix slicing driven
+   by the packed `cu_seqlens` metadata.
+2. Ascend-friendly fused operators: RMSNorm, AddRMSNorm, GQA, SwiGLU, and
+   rotary position embedding from MindIE-SD.
+3. RainFusion block-sparse attention, optionally with EQBSA mixed INT8/FP8
+   precision — see
+   [RainFusion](../../docs/user_guide/diffusion/attention_backends/rainfusion.md).
+4. Online quantization: INT8, MXFP8, and MXFP4 — see
+   [online quantization](../../docs/user_guide/quantization/online.md).
+5. Parallelism: USP, text-encoder TP, and native VAE `tile` patch
+   parallelism, plus distributed layerwise offload.
+6. Post-training: few-step distillation via the FlashGen online LoRA.
 
-**RainFusion block-sparse attention** — switch the attention backend, keeping
-every other flag unchanged:
+## Benchmarks (Atlas 800I A2 / A3)
 
-```bash
-  --diffusion-attention-backend RAINFUSION_ATTN
-```
+Measured with `--enable-diffusion-pipeline-profiler` on vLLM-Omni 0.28.0:
+lossless rows use the recommended lossless configuration, lossy rows the
+recommended lossy configuration. Memory figures are per device.
 
-**INT8 online quantization** — add one flag to the server command above:
+### Atlas 800I A2
 
-```bash
-  --quantization int8
-```
+| Task | Resolution | Frames | Duration (s) | Config | E2E (s) | DiT total (s) | DiT per-step (s) | DiT steps | Text encode (s) | Ref video encode (s) | Ref audio encode (s) | VAE decode (s) | Ref preprocess (s) | Post-process (s) | CPU MP4 (s) | Resident weights (GB) | Peak memory (GB) |
+| ---- | ---- | ---- | ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| t2va | 1344x768 | 124 | 5 | lossless | 150.06 | 139.9 | 2.85 | 49 | 0.83 | NA | NA | 6.76 | NA | 0.462 | 1.18 | 2.97 | 24.7 |
+| t2va | 1344x768 | 362 | 15 | lossless | 786.24 | 761.36 | 15.53 | 49 | 1.20 | NA | NA | 15.87 | NA | 1.98 | 2.95 | 2.97 | 36.21 |
+| t2va | 1344x768 | 124 | 5 | lossy | 108.1 | 95.85 | 1.95 | 49 | 0.9 | NA | NA | 6.73 | NA | 0.745 | 1.04 | 2.55 | 22.47 |
+| t2va | 1344x768 | 362 | 15 | lossy | 552.51 | 526.04 | 10.73 | 49 | 1.28 | NA | NA | 16.07 | NA | 1.90 | 3.76 | 2.55 | 35.11 |
+| ref2va | 1344x768 | 124 | 5 | lossless | 474.89 | 421.68 | 8.6 | 49 | 2.42 | 13.31 | 0.38 | 6.47 | 3.94 | 0.489 | 1.16 | 3.4 | 23.45 |
+| ref2va | 1344x768 | 362 | 15 | lossless | 3414.18 | 3336.98 | 68.08 | 49 | 6.48 | 30.85 | 0.59 | 15.8 | 12.59 | 1.99 | 3.08 | 3.4 | 36.28 |
+| ref2va | 1344x768 | 124 | 5 | lossy | 380.92 | 326.50 | 6.66 | 49 | 2.47 | 13.48 | 0.38 | 6.36 | 4.68 | 0.591 | 1.22 | 2.55 | 22.57 |
+| ref2va | 1344x768 | 362 | 15 | lossy | 2332.04 | 2249.63 | 45.89 | 49 | 6.33 | 35.1 | 0.59 | 15.72 | 11.07 | 1.35 | 2.3 | 2.55 | 35.58 |
 
-Keep `--ring 1` when using RainFusion: the `rf_v2` kernel ranks key blocks
-over the whole sequence, so ring parallelism would split away the keys it
-needs. Scale with `--usp` instead.
+### Atlas 800I A3
 
-## Memory and attention optimizations (A3)
+| Task | Resolution | Frames | Duration (s) | Config | E2E (s) | DiT total (s) | DiT per-step (s) | DiT steps | Text encode (s) | Ref video encode (s) | Ref audio encode (s) | VAE decode (s) | Ref preprocess (s) | Post-process (s) | CPU MP4 (s) | Resident weights (GB) | Peak memory (GB) |
+| ---- | ---- | ---- | ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| t2va | 1344x768 | 124 | 5 | lossless | 114.19 | 105.87 | 2.16 | 49 | 0.48 | NA | NA | 6.56 | NA | 0.001 | 0.46 | 3.49 | 24.7 |
+| t2va | 1344x768 | 362 | 15 | lossless | 599.29 | 580.38 | 11.84 | 49 | 1.83 | NA | NA | 14.95 | NA | 0.001 | 1.02 | 3.49 | 36.21 |
+| t2va | 1344x768 | 124 | 5 | lossy | 84.82 | 77.47 | 1.58 | 49 | 0.57 | NA | NA | 6.23 | NA | 0.001 | 0.61 | 2.63 | 22.47 |
+| t2va | 1344x768 | 362 | 15 | lossy | 401.43 | 383.56 | 7.82 | 49 | 1.72 | NA | NA | 14.83 | NA | 0.001 | 1.14 | 2.63 | 35.11 |
+| ref2va | 1344x768 | 124 | 5 | lossless | 355.53 | 311.86 | 6.36 | 49 | 1.89 | 12.37 | 0.24 | 5.55 | 2.49 | 0.001 | 0.43 | 3.49 | 23.45 |
+| ref2va | 1344x768 | 362 | 15 | lossless | 2339.56 | 2277.61 | 46.47 | 49 | 5.61 | 34.46 | 0.36 | 13.61 | 6.83 | 0.001 | 1.11 | 3.49 | 36.28 |
+| ref2va | 1344x768 | 124 | 5 | lossy | 306.82 | 247.72 | 5.05 | 49 | 1.88 | 12.71 | 0.24 | 5.24 | 2.45 | 0.001 | 0.54 | 2.63 | 22.57 |
+| ref2va | 1344x768 | 362 | 15 | lossy | 1695.26 | 1634.58 | 33.35 | 49 | 5.57 | 33.27 | 0.36 | 13.51 | 6.96 | 0.001 | 1.22 | 2.63 | 35.58 |
 
-### Fitting 768P into 64 GB HBM: distributed layerwise offload or HSDP
-
-Each Atlas 800I A3 NPU has 64 GB of HBM, which is not enough for the
-combined MiniMax-H3 service at 768P. Enable **one** of the following at
-server startup:
-
-**Distributed layerwise offload** — DiT layers are offloaded with parameters
-gathered across the parallel group instead of replicated per rank:
-
-```bash
-  --enable-distributed-layerwise-offload
-```
-
-Measured peak NPU memory is about 45 GB per device for Ref2VA with a 13.88 s
-input video generating a 15 s 768P (1344x768) output video. Host (CPU) memory
-usage is high with this option.
-
-**HSDP** — hybrid sharded data parallelism for the DiT parameters. The
-multi-stream memory-reuse knob is mandatory with this flag:
-
-```bash
-export MULTI_STREAM_MEMORY_REUSE=2
-```
-
-```bash
-  --use-hsdp
-```
-
-Host memory usage is small, but large shapes may still OOM; HBM usage
-optimizations for this path are ongoing.
-
-### FLASH_ATTN backend with MindIE-SD
-
-Keep `--diffusion-attention-backend FLASH_ATTN` and install MindIE-SD (see
-[§ Environment](#environment)). On NPU this backend carries most of the
-memory-reduction and performance work: a mask-free packed varlen path that
-never materializes the quadratic `full_qk` padding mask, and K/V prefix
-slicing, both driven by the packed `cu_seqlens` metadata emitted by the H3
-transformer.
-
-### Optional: LaserAttention fused kernel
-
-For an additional attention speedup, select the Ascend LaserAttention fused
-kernel before starting the server:
-
-```bash
-export MINDIE_SD_FA_TYPE="ascend_laser_attention"
-```
-
-This requires the FLASH_ATTN backend and MindIE-SD. H3 automatically applies
-exact power-of-two input pre-scaling (`laser_input_scale=256`) so the
-kernel's fp16 workspace cannot overflow on outlier activations. Measured
-speedup numbers will be added here.
-
-
-## HTTP API examples
-
-The request format is identical to the GPU recipe; see
-[MiniMax-H3.md § HTTP API examples](MiniMax-H3.md#http-api-examples).
-Use the validated 768P shapes (e.g. `width=1344 height=768`) on NPU.
-
-## Key parameters
-
-Same as the GPU recipe; see
-[MiniMax-H3.md § Key parameters](MiniMax-H3.md#key-parameters).
-The validated resolution on NPU is 768P (e.g. 1344x768).
-
-## Validated NPU evidence
-
-Measured on an Atlas 800I A3 server (8x NPU) with CANN 9.0.1,
-PyTorch 2.10.0+cpu, and torch_npu 2.10.0.post2, using the multi-NPU
-configuration above:
-
-| Workload | Configuration |
-|----------|---------------|
-| T2VA, 209 frames, 1344x768 | TE TP8, distributed layerwise offload, Ulysses 8, VPP8 tile, regional compile |
-| Ref2VA (prompt + video), 124 frames, 1344x768 | TE TP8, distributed layerwise offload, Ulysses 8, VPP8 tile, regional compile |
-
-These measurements describe the validated shapes rather than a general
-throughput guarantee.
+These numbers describe the validated shapes rather than a general throughput
+guarantee.
 
 ## Known limitations
 
-- Combined serving requires sibling `FL2VA` and `Ref2VA` directories, loads
-  both task-specific DiTs, and loads one copy of every shared component.
+- Task serving is partitioned by `--task-type`: T2VA/FL2VA and Ref2VA load
+  different DiTs, so switching between them requires a restart with the other
+  partition.
 - H3 currently executes one generation request per diffusion batch.
 - The first regional-compile request is a warmup and should not be included
   in steady-state performance measurements.
@@ -250,17 +380,19 @@ throughput guarantee.
   the same HTTP request contract.
 - VAE patch parallelism requires size 1 or the full DiT group size and
   supports the H3 native `tile` mode only.
-- RainFusion block-sparse attention and INT8 quantization are validated for
-  T2VA only; use the BF16 dense configuration for FL2VA and Ref2VA.
-- Online INT8 quantization can be combined with distributed layerwise offload
-  while AllGather is enabled. Keep AllGather enabled for SP>1; use
-  `--dlo-no-use-allgather` only when collective communication is unavailable.
+- The lossy configuration (RainFusion + INT8) is validated for T2VA and
+  Ref2VA; use the lossless configuration for FL2VA or re-validate first.
 
 ## Additional resources
 
 - [MiniMax-H3.md](MiniMax-H3.md) — full GPU guide
-- [Attention backends § RAINFUSION_ATTN](../../docs/user_guide/diffusion/attention_backends.md#rainfusion_attn-backend-and-block-sparse-video-attention)
-  — RainFusion knobs and tuning
-- [Int8 quantization](../../docs/user_guide/quantization/int8.md)
+- [MiniMax-H3-NPU-950PR.md](MiniMax-H3-NPU-950PR.md) — four-card
+  Ascend 950PR / 950DT guide
+- [NPU installation](../../docs/getting_started/installation/npu.md)
+- [RainFusion attention](../../docs/user_guide/diffusion/attention_backends/rainfusion.md)
+  — block-sparse knobs and tuning
+- [Online quantization](../../docs/user_guide/quantization/online.md)
+  — INT8 / MXFP8 / MXFP4
+- [Cache-DiT guide](../../docs/user_guide/diffusion/cache_acceleration/cache_dit.md)
 - [Supported models](../../docs/models/supported_models.md)
 - [Video API](../../docs/serving/videos_api.md)
diff --git a/recipes/MiniMaxAI/MiniMax-H3-Spark-GB10.md b/recipes/MiniMaxAI/MiniMax-H3-Spark-GB10.md
index efd88c068..f4304cd4a 100644
--- a/recipes/MiniMaxAI/MiniMax-H3-Spark-GB10.md
+++ b/recipes/MiniMaxAI/MiniMax-H3-Spark-GB10.md
@@ -16,6 +16,12 @@ Validated on:
   50 steps, text-encoder TP2, and DiT USP2
 - Common sampling settings: `flow_shift=12`, `seed=1101`
 
+The commands and measurements below describe this pinned revision. Newer
+versions have changed the scope of `--quantization fp8`; see
+[Online FP8 quantization](MiniMax-H3.md#online-fp8-quantization) for the current
+component selection and offload support. Re-qualify memory, output, and latency
+on GB10 before comparing results across revisions.
+
 ## Capacity requirements
 
 | Resource | DGX Spark (GB10) |
@@ -40,8 +46,10 @@ math relative to the RTX and datacenter recipes:
 - **Do not use `--enable-cpu-offload`.** Moving weights from "VRAM" to "host RAM"
   frees nothing here.
 - **`--quantization fp8` is mandatory.** A BF16 partition is 135 GiB and does not
-  fit in 121 GiB. Online FP8 quantizes the DiT only (62 GiB to ~31 GiB); the
-  Qwen3-VL text encoder and both VAEs stay BF16.
+  fit in 121 GiB. At the validated revision, online FP8 quantizes the DiT only
+  (62 GiB to ~31 GiB); the Qwen3-VL text encoder and both VAEs stay BF16.
+  Current versions also quantize eligible text-decoder linears by default, so
+  the same flag does not imply the same quantization scope across revisions.
 
 With ~97.7 GiB of the pool held by the allocator at peak, T2VA leaves roughly
 23 GiB of headroom for the OS, page cache, and any other process on the box.
@@ -295,6 +303,8 @@ shorter than a 50-step Ref2VA run.
 - Ref2VA requires a vLLM-Omni build newer than `v0.26.0`. See the version note
   under **Validated on**: FP8 weight loading and image-only Ref2VA are both
   broken on `release/v0.26.0`. The suggested version is `v0.26.1`.
-- Online FP8 is incompatible with layerwise offload — the offload path produces a
-  weight stride the Cutlass FP8 kernel rejects. This is not a practical
-  restriction here since offload is unusable on GB10 anyway.
+- At the validated revision, online FP8 with layerwise offload produced a weight
+  stride the Cutlass FP8 kernel rejected. Current H3 supports online FP8 with
+  layerwise offload and both DLO transfer paths; see the linked FP8 section
+  above. This does not change the GB10 capacity guidance: offload uses the same
+  unified-memory pool and is not enabled in this recipe.
diff --git a/recipes/MiniMaxAI/MiniMax-H3.md b/recipes/MiniMaxAI/MiniMax-H3.md
index b48a1f472..9eac85ece 100644
--- a/recipes/MiniMaxAI/MiniMax-H3.md
+++ b/recipes/MiniMaxAI/MiniMax-H3.md
@@ -825,7 +825,7 @@ at most 15 seconds combined.
 | FL2VA | first image, last image, or ordered first+last images | at most 2 images; `frame_indices` is `[0]`, `[-1]`, or `[0,-1]` |
 | Ref2VA | image-only, image+image, image+video, video+audio, and mixed image/video/audio | images ≤9, videos ≤3, audios ≤3, total references ≤12; audio requires a visual reference |
 
-The H3 output contract is 4–15 seconds at 24 FPS, stereo 32 kHz audio, and a
+The default H3 output contract is 4–15 seconds at 24 FPS, stereo 32 kHz audio, and a
 32-pixel canvas multiple. T2VA requires one named output ratio from `21:9`,
 `16:9`, `4:3`, `1:1`, `3:4`, or `9:16`. FL2VA always follows the first input
 image's ratio and ignores a generic `aspect_ratio` override. Ref2VA defaults to
@@ -836,6 +836,152 @@ default. `short_edge` controls the 768-pixel canvas and must be `768`.
 outputs; the synchronous raw-MP4 endpoint returns the first output when more
 than one is requested.
 
+## Long video and driving audio
+
+Set `extra_params.long_video=true` to opt into durations above 15 seconds.
+Ref2VA long-video requests now default to latent continuation with global
+temporal RoPE positions (A+B), described below. Set `long_video_mode=full`
+explicitly to sample the entire target latent at once for comparison. Both modes
+retain the native `17n+5` video-frame grid, `5n+2` video-latent grid, and 40 Hz
+audio latents. A request for 75 seconds becomes 1,807 frames (75.292 seconds at
+24 FPS). In full mode, attention cost and activation memory grow with the full
+sequence length. Reference-video and reference-audio limits remain unchanged.
+Other task types retain full-mode behavior. Requests are limited to 30 seconds
+in full mode and 300 seconds in continuation mode; without `long_video=true`,
+the limit remains 15 seconds. The limits cover duration aliases and explicit
+`num_frames`, and externally encoded requests are checked again before diffusion.
+Native frame-grid alignment can round the output slightly above the requested
+limit. These are request sanity bounds, not a guarantee that a given resolution
+fits GPU memory. Full mode still allocates the whole sequence, and continuation
+retains cumulative latents and reference inputs.
+
+Use `audio_mode=lock_source` with one `audio_reference` to drive generation
+with a soundtrack, rather than treating it as a short reference. The encoder
+places that waveform in the target audio latent, crops or zero-pads its two
+channels independently to the output duration, and keeps those rows clean
+(timestep 1) throughout sampling. This mode does not insert an `<Audio 1>`
+reference tag. It supports request and step execution; the default `native`
+mode continues generating audio normally. Returned audio is the audio VAE's
+reconstruction, not a byte-for-byte copy of the input recording.
+
+Against a Ref2VA server, using the same asset-server setup as above:
+
+```bash
+curl --fail-with-body -sS -X POST "${API_URL}" \
+  -F 'prompt=<prompt.txt' \
+  -F 'width=960' -F 'height=544' -F 'fps=24' \
+  -F 'num_inference_steps=50' -F 'flow_shift=12' -F 'seed=19960422' \
+  -F 'extra_params={"task":"ref2va","duration":75,"long_video":true,"audio_mode":"lock_source","audio_flow_shift":3,"preencode_mp4":true,"preencode_batch_frames":17}' \
+  -F "input_reference=@${REF_IMAGE};type=image/png" \
+  -F "audio_reference={\"audio_url\":\"${AUDIO_URL}\"}" \
+  -o long-video.mp4
+```
+
+`preencode_mp4` decodes and muxes temporal chunks on the worker, avoiding a
+full decoded long video in the API process. It does not reduce the denoiser's
+sequence length. For Turbo adapters, use the matching adapter's step count
+and flow shift from the Turbo table below.
+
+The [RunningHub workflow](https://www.runninghub.cn/post/2100530217365364737/)
+uses T8's `MiniMaxH3AudioConditioningT8`, a full-length latent, and
+`MiniMaxH3DualClockSamplerT8`; its `remix_source` strength is zero, equivalent
+to source locking. This differs from rolling-overlap continuation nodes.
+See [T8 conditioning](https://github.com/T8mars/comfyui-minimax-h3-audio-T8)
+and [ComfyUI H3 masking](https://github.com/Comfy-Org/ComfyUI/blob/master/comfy/ldm/minimax/model.py).
+The workflow's custom Dasiwa weights, Sol attention, and T8-specific LoRA are
+not supplied by this feature.
+
+### Latent-tail continuation with global temporal positions (A+B)
+
+`long_video=true` selects this mode by default for Ref2VA. It can also be selected
+explicitly with `long_video_mode=continuation`. This experimental mode supports
+Ref2VA request execution with uncached denoising (`quality=lossless`); step
+execution is rejected. Use `long_video_mode=full` explicitly for whole-target
+sampling, including requests up to 30 seconds that require step execution.
+Continuation currently rejects latent-mask editing (`video_noise_mask` or
+`audio_noise_mask` with retained source regions). Full mode supports editing;
+`audio_mode=lock_source` cannot be combined with audio latent-mask editing.
+
+```json
+{
+  "task": "ref2va",
+  "duration": 75,
+  "long_video": true,
+  "long_video_mode": "continuation",
+  "continuation_window_frames": 277,
+  "continuation_overlap_frames": 22,
+  "audio_mode": "lock_source",
+  "audio_flow_shift": 3,
+  "preencode_mp4": true,
+  "preencode_batch_frames": 17
+}
+```
+
+These defaults sample seven windows for a 1,807-frame output. Each continuation
+uses the preceding AV latent tail as fixed condition rows at the new target's
+time origin, samples a fresh unmasked target, discards its hidden overlap, and
+appends only the new suffix. The reference image and full prompt remain present
+in every window. Both window and overlap use the `17n+5` frame grid; the window
+must be 107..345 frames and larger than the overlap. A final window may be shorter.
+Audio boundaries are rounded on the cumulative 24 FPS / 40 Hz timeline to avoid
+drift; a locked driving track is sliced separately for each stereo channel.
+
+Before RoPE evaluation, every window adds `start_frame * 40 / 24` to the temporal
+position IDs of its target audio/video, reference audio/video, and latent-tail
+guides. The start includes the overlap (not just the newly appended frames).
+Text, static image references, spatial coordinates, and padding remain unchanged.
+Offsets retain fractional precision independently of rounded audio slice indices.
+For the default windows starting at frames 0, 255, 510, the added positions are
+0, 425, 850. This follows the media-only global-offset convention in
+[LongMedia temporal positioning](https://github.com/vizart-vj/ComfyUI-MiniMax-H3-LongMedia/blob/main/temporal_positioning.py).
+The shifted layout is constructed once per window and then used by all denoising
+steps and sequence-parallel ranks; no RoPE-frequency scaling is applied.
+
+For a narrative with different scenes, pass `continuation_prompts` as a JSON
+list containing exactly one non-empty prompt string per planned window (seven
+strings for the default 75-second request). These prompts are independently
+encoded with the same reference assets and selected in window order. Shot times
+inside each prompt describe that local window, including its hidden overlap.
+This option requires a local text encoder; external-encoder stage execution is
+not supported. Media positions use one shared origin after the longest encoded
+text prefix, so different prompt lengths do not shift the global AV clock.
+Without this list, the request's single prompt is reused as before.
+
+The cumulative latent is decoded once after all windows. Denoising memory is
+bounded by the window, while cumulative latent storage still grows with duration.
+This follows the [ComfyUI latent-tail continuation algorithm](https://github.com/ttulttul/ComfyUI-Minimax-H3-Continuation).
+Global positions can still exceed the model's trained temporal range. This
+mode does not guarantee seamless cuts or adherence to absolute shot timestamps in
+a repeated prompt. For comparison, keep the model, seed, prompt, source media,
+steps, shifts, and output size fixed, changing only `long_video_mode`.
+
+For a reproducible approximately 20-second comparison, use a request-mode
+Ref2VA server with caching disabled and the same `prompt.txt` and `REF_IMAGE`
+for both requests. Use a single prompt without `continuation_prompts` so that
+both modes receive identical text. The commands below generate native audio:
+
+```bash
+for mode in full continuation; do
+  curl --fail-with-body -sS --max-time 14400 "${API_URL}" \
+    -F 'prompt=<prompt.txt' \
+    -F "input_reference=@${REF_IMAGE};type=image/png" \
+    -F 'width=960' -F 'height=544' -F 'fps=24' \
+    -F 'num_inference_steps=50' -F 'flow_shift=12' -F 'seed=19960422' \
+    -F 'quality=lossless' \
+    -F "extra_params={\"task\":\"ref2va\",\"duration\":20,\"long_video\":true,\"long_video_mode\":\"${mode}\",\"audio_flow_shift\":3,\"preencode_mp4\":true}" \
+    -o "h3-20s-${mode}.mp4" || break
+done
+```
+
+Both outputs should contain 481 frames (20.042 seconds at 24 FPS).
+Continuation uses windows `[0,277)` and `[255,481)`; inspect frames 276/277
+(about 11.54 seconds) for visual and audio discontinuities. Compare the complete
+clips for motion, identity, prompt adherence, and sound, not just frame similarity:
+the trajectories differ by design. Report the tested commit, checkpoint, hardware,
+settings, and both videos with any comparison; the command alone is not quality
+evidence. A matching seed does not imply matching noise over differently sized
+full and windowed latents.
+
 ## Request-scoped quality
 
 Add one of these fields to any HTTP request above. No Cache-DiT startup option
@@ -1106,6 +1252,68 @@ generations move the end-to-end figure toward the denoising one. Fusing the
 adapter does not measurably change startup: weight loading took 77.3 s with it
 against 85.8 s without.
 
+### FastH3 8-Step V2 full checkpoint
+
+[FastH3 8-Step V2](https://huggingface.co/FastVideo/FastVideo-FastH3-8-Step-V2)
+ships a full Diffusers-format transformer, including learned VSA compression
+gates. Serve the Hugging Face model ID or a downloaded snapshot directly:
+
+```bash
+export FASTH3_V2_MODEL=FastVideo/FastVideo-FastH3-8-Step-V2
+```
+
+Use a Hugging Face account with access to the release, and pin `--revision`
+when reproducing a result. The existing component loader reads its safetensors
+shards; the H3 weight loader maps names and loads Q/K/V and MLP projections into
+native parameters in memory. No conversion command or second transformer
+checkpoint is needed.
+
+The transformer and text components come from the V2 release. To retain Omni's
+native tiled and parallel VAE execution, the loader fetches only the video/audio
+VAEs from the `MiniMaxAI/MiniMax-H3` revision pinned in V2's `provenance.json`.
+Those components use the normal Hugging Face cache. No separate base-model
+argument or full base-transformer download is required. Download time is a
+preparation cost, separate from warmup and request latency.
+
+Install the optional `fastvideo-kernel` build required by the
+`FASTVIDEO_VSA` backend, including its H3 block-map entry point. A four-GPU
+configuration is:
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1,2,3 vllm serve "${FASTH3_V2_MODEL}" --omni \
+  --host 127.0.0.1 --port 8095 --trust-remote-code --task-type fl2va \
+  --served-model-name FastH3-V2 \
+  --num-gpus 4 --usp 4 --ring 1 \
+  --vae-patch-parallel-size 4 --vae-parallel-mode tile --vae-use-tiling \
+  --diffusion-attention-backend FASTVIDEO_VSA
+
+curl --fail-with-body -sS http://127.0.0.1:8095/v1/videos/sync \
+  -F 'model=FastH3-V2' \
+  -F 'prompt=A red fox runs through fresh snow at dawn, with fast pawsteps, winter wind and distant birds.' \
+  -F 'width=1344' -F 'height=768' -F 'aspect_ratio=16:9' -F 'fps=24' \
+  -F 'num_inference_steps=8' -F 'guidance_scale=1' -F 'flow_shift=10' \
+  -F 'seed=1101' \
+  -F 'extra_params={"task":"t2va","duration":4.4,"audio_flow_shift":3.0}' \
+  -o fasth3_v2.mp4
+```
+
+V2 pins video/audio shifts **10/3**, guidance **1**, and the unshifted ladder
+`[0.999, 0.874, 0.749, 0.624, 0.5, 0.375, 0.25, 0.125, 0.0]`.
+Use **`num_inference_steps=8`** in Omni: these nine nodes bound eight model
+evaluations. FastVideo's `--steps 9` counts nodes instead. The existing H3 ODE
+update is reused without stochastic re-noising.
+
+The trained attention policy is **80% sparsity with 64-token video tiles**.
+Omni derives the number of selected video tiles from each request's geometry;
+do not supply a fixed `--fastvideo-vsa-topk`. Text/condition/audio prefix keys
+remain available to every query, and prefix queries remain dense. Missing VSA
+geometry or a failed H3 kernel raises an error instead of serving the student
+with dense attention.
+
+This release supports T2VA only, with local or pure Ulysses attention. Additional
+LoRA adapters, Ref2VA and FL2VA conditioning are unsupported. The legacy
+four-step adapter keeps its original sampling and fixed-top-k behavior.
+
 ## Key parameters
 
 | Parameter | Recommended value | Notes |
diff --git a/recipes/OpenBMB/VoxCPM2.md b/recipes/OpenBMB/VoxCPM2.md
index 0fd8e210e..42f770a00 100644
--- a/recipes/OpenBMB/VoxCPM2.md
+++ b/recipes/OpenBMB/VoxCPM2.md
@@ -43,9 +43,65 @@ sufficient — no tensor parallelism is required.
 
 ## Hardware Support
 
-This recipe documents one tested 24 GB consumer-GPU configuration.
-Larger-VRAM (H20 / H100 / A100) and other vendor sections (ROCm, NPU) are
-welcome as community validation lands.
+This recipe documents tested single-card configurations for a 24 GB NVIDIA
+GPU and an Ascend Atlas A2.
+
+## Ascend NPU
+
+### 1 x Ascend 910B3 64GB (Atlas A2)
+
+VoxCPM2 runs on one Atlas A2 card with the standard deploy config. The model's
+LocDiT path uses eager PyTorch on NPU; keep `enforce_eager: true`. The default
+config enables fused QKV, fused gate/up projection, and the zero-delta-time
+cache for this path.
+
+#### Environment
+
+- Hardware: 1 x Ascend 910B3 64GB (Atlas A2)
+- Container: `quay.nju.edu.cn/ascend/vllm-omni:v0.28.0`
+- vLLM: 0.28.0
+- vLLM-Omni: current `main`
+- Model: `openbmb/VoxCPM2`, bfloat16
+
+#### Command
+
+Expose one physical NPU to the container, then start the server normally. The
+visible card is addressed as logical device `0` by `voxcpm2.yaml`.
+
+```bash
+export ASCEND_RT_VISIBLE_DEVICES=5
+export VLLM_WORKER_MULTIPROC_METHOD=spawn
+
+vllm serve /path/to/VoxCPM2 --omni \
+    --host 0.0.0.0 --port 8000
+```
+
+#### Performance validation
+
+The component timer was measured after model warmup with a single Chinese TTS
+request. Each decode step executes nine LocDiT estimator calls, so per-step
+measurements compare the same amount of model work even when generated audio
+duration differs.
+
+| path | CFM estimator / call | decode / step | forward / step |
+| ---- | -------------------- | ------------- | -------------- |
+| Before (optimization flags skipped on NPU) | 18.84 ms | 193.86 ms | 265.35 ms |
+| Fused QKV + fused MLP + zero-dt cache | 17.50 ms | 182.22 ms | 254.07 ms |
+| Above + experimental reduced-precision RoPE | 14.93 ms | 157.36 ms | 227.33 ms |
+
+The default fused path reduces CFM estimator latency by about **7.1%** and
+complete decode-step latency by **6.0%**. Its generated WAV was byte-identical
+to the pre-optimization baseline. Setting
+`enable_loc_dit_fast_rope: true` can increase the reductions to about **20.8%**
+and **18.8%**, respectively, but changes the recurrent acoustic state and is
+therefore an opt-in quality/performance tradeoff. Its test audio was valid 48
+kHz mono PCM with finite samples and no clipping; evaluate voice quality on a
+representative corpus before enabling it in production.
+
+Do not set `enforce_eager: false` for VoxCPM2 on Ascend yet. ACL Graph captures
+the language-model runner, but the request-owned VoxCPM2 state has dynamic
+prefill/decode shapes; replay can therefore feed an empty captured row into a
+non-empty residual state and fail at `aclnnCat`.
 
 ## GPU
 
@@ -88,8 +144,8 @@ Pass `--deploy-config <path>` to override.
 #### Verification
 
 **Server cold-start**: ~60 s from `vllm serve` to `Application startup
-complete` (subprocess fork + vLLM 0.21 init + model load + flashinfer JIT
-+ torch.compile of LocDiT / feat_encoder / AudioVAE + CUDA-Graph warmup).
+complete` (subprocess fork, vLLM 0.21 init, model load, flashinfer JIT,
+torch.compile of LocDiT / feat_encoder / AudioVAE, and CUDA-Graph warmup).
 The first request after startup pays a small additional cost; steady-state
 requests are much faster.
 
@@ -199,7 +255,7 @@ after a one-off ~28 s engine init:
 | ---- | -------- | --------- | ----- | ------------------------------------------------ |
 | #1   | 6.72 s   | 11.97 s   | 1.782 | cold: torch.compile + CUDA-Graph capture         |
 | #2   | 6.24 s   | 11.43 s   | 1.831 | still runtime warmup                             |
-| #3   | 6.88 s   | 0.82 s    | 0.120 | ⚡ steady-state                                   |
+| #3   | 6.88 s   | 0.82 s    | 0.120 | steady-state                                     |
 | #4   | 6.56 s   | 0.78 s    | 0.119 | steady-state                                     |
 | #5   | 5.76 s   | 0.70 s    | 0.121 | steady-state                                     |
 
@@ -231,7 +287,7 @@ Same 5-call methodology as the zero-shot table, this time with a
 | ---- | -------- | --------- | ----- | ------------------------------------------------ |
 | #1   | 5.44 s   | 12.38 s   | 2.276 | cold: compile + CUDA-Graph capture + ref encode  |
 | #2   | 5.12 s   | 2.47 s    | 0.482 | most warmup done                                 |
-| #3   | 5.44 s   | 0.76 s    | 0.139 | ⚡ steady-state                                   |
+| #3   | 5.44 s   | 0.76 s    | 0.139 | steady-state                                     |
 | #4   | 4.96 s   | 0.68 s    | 0.137 | steady-state                                     |
 | #5   | 5.28 s   | 0.71 s    | 0.134 | steady-state                                     |
 
diff --git a/recipes/README.md b/recipes/README.md
index 078466e80..22174a9bb 100644
--- a/recipes/README.md
+++ b/recipes/README.md
@@ -29,6 +29,8 @@ Example layout:
 
 ```text
 recipes/
+  lerobot/
+    Pi05.md
   Qwen/
     Qwen3-Omni-H100.md
     Qwen3-TTS-A100.md
@@ -47,12 +49,14 @@ recipes/
 | [`BosonAI/Higgs-Audio-V3-TTS.md`](./BosonAI/Higgs-Audio-V3-TTS.md) | Online + offline multilingual TTS with voice cloning | 1x H100 80GB |
 | [`BreezeBlue/Breeze-TTS-2.md`](./BreezeBlue/Breeze-TTS-2.md) | Online + offline TTS (plain / voice design / voice clone / voice direction, streaming PCM) | 1x NVIDIA L20 48GB |
 | [`ByteDance/Lance.md`](./ByteDance/Lance.md) | Unified AR+diffusion: text/img/video gen + understanding (Lance 3B) | 1x B300 / A100 80GB |
+| [`circlestone-labs/Anima.md`](./circlestone-labs/Anima.md) | Native single-file text-to-image serving | 1x AMD MI300X |
 | [`fishaudio/Fish-Speech-S2-Pro.md`](./fishaudio/Fish-Speech-S2-Pro.md) | Online serving for TTS | 1x A800 80GB |
 | [`Helios/Helios.md`](./Helios/Helios.md) | Text-to-video, image-to-video, and video-to-video generation | 1x NVIDIA H20 |
 | [`HiDream-ai/HiDream-O1-Image.md`](./HiDream-ai/HiDream-O1-Image.md) | Text-to-image with shared offline example | 1x or 2x H100 80GB |
 | [`inclusionAI/Ming-flash-omni-2.0.md`](./inclusionAI/Ming-flash-omni-2.0.md) | Online serving for multimodal chat + standalone TTS | 4x H100 / 1x H100 80GB |
 | [`inclusionAI/Ming-omni-tts.md`](./inclusionAI/Ming-omni-tts.md) | Offline + online dense Ming TTS/audio generation | 1x H100 80GB / 1x AMD MI300X (ROCm 7.2) |
 | [`k2-fsa/OmniVoice.md`](./k2-fsa/OmniVoice.md) | Offline and online multilingual text-to-speech | 1x AMD MI300X (ROCm 7.2) |
+| [`lerobot/Pi05.md`](./lerobot/Pi05.md) | Online OpenPI serving for the π0.5 vision-language-action policy | 1x H100 80GB |
 | [`IndexTeam/IndexTTS-2.md`](./IndexTeam/IndexTTS-2.md) | Online serving for voice-cloned TTS with optional emotion control | 1x L4 24GB or larger CUDA GPU |
 | [`IndexTeam/IndexTTS-2_5.md`](./IndexTeam/IndexTTS-2_5.md) | Online + offline multilingual voice-cloned TTS with native speed and emotion control | 1x NVIDIA H20 96GB |
 | [`MiniMaxAI/MiniMax-H3.md`](./MiniMaxAI/MiniMax-H3.md) | T2VA, FL2VA, image+audio Ref2VA, and multi-video Ref2VA serving | 1x GPU with CPU offload / 4x B300 |
@@ -72,7 +76,7 @@ recipes/
 | [`cosmos3/Cosmos3-Edge.md`](./cosmos3/Cosmos3-Edge.md) | T2I / T2V / I2V + action (Physical-AI) generation on the Nemotron-based Edge transformer | 1x GPU (~8 GiB) |
 | [`cosmos3/Cosmos3-Super.md`](./cosmos3/Cosmos3-Super.md) | 64B T2I / T2V / I2V / V2V generation (+ optional audio) / Action policy | 8x H200/H100/A100 / 2x H200 / B300 |
 | [`OpenBMB/MiniCPM-o-4_5.md`](./OpenBMB/MiniCPM-o-4_5.md) | Online full-duplex serving and offline inference for omni multimodal chat (text / image / audio / video → text + 24 kHz speech) | 2x A100/H100 80GB / 3x mid-tier GPU / 8x RTX 4090 24GB |
-| [`OpenBMB/VoxCPM2.md`](./OpenBMB/VoxCPM2.md) | Online + offline TTS with native AR pipeline (48 kHz, 30+ languages) | 1x RTX 4090 24GB |
+| [`OpenBMB/VoxCPM2.md`](./OpenBMB/VoxCPM2.md) | Online + offline TTS with native AR pipeline (48 kHz, 30+ languages) | 1x RTX 4090 24GB / 1x Ascend 910B3 64GB |
 | [`OpenMOSS/MOSS-TTS.md`](./OpenMOSS/MOSS-TTS.md) | Online + offline multilingual TTS (MOSS-TTS family, 8B) | 1x H100 80GB |
 | [`OpenMOSS/MOSS-TTS-Nano-NPU.md`](./OpenMOSS/MOSS-TTS-Nano-NPU.md) | Online multilingual voice-cloned TTS | 1x Ascend 910B3 64GB |
 | [`NVIDIA/Nemotron-Labs-Audex.md`](./NVIDIA/Nemotron-Labs-Audex.md) | TTS / text-to-audio / audio understanding / cascaded S2S (Audex 2B + 30B-A3B) | 1x H100 80GB |
diff --git a/recipes/Robbyant/LingBot-World-2.0.md b/recipes/Robbyant/LingBot-World-2.0.md
index ab8c498fa..7add2f7d8 100644
--- a/recipes/Robbyant/LingBot-World-2.0.md
+++ b/recipes/Robbyant/LingBot-World-2.0.md
@@ -21,13 +21,12 @@ below.
 
 - **Realtime stepwise** — see [Streaming video serving](#streaming-video-serving).
   The suggested path: one `WS /v1/realtime/video` session produces the whole
-  rollout, one video chunk per AR block. It cannot take realtime camera
-  interaction yet; that is being added, and this path is the one that will
-  remain.
+  rollout, one video chunk per AR block. Mid-session camera control uses
+  structural SE3 `session.interaction` payloads; optional
+  `camera_action_script` remains for request-scoped WASD scripts.
 - **Realtime tick** *(deprecated)* — see
   [Realtime in-process generation](#realtime-in-process-generation-deprecated).
-  The only path that takes realtime camera interaction today, so it stays until
-  the stepwise path can, but it takes no new work and will be removed.
+  Older one-block-per-`generate()` control plane with JSONL WASD frames; will be removed in the future.
 - **Offline** — see [Offline generation](#offline-generation). Replays a fixed
   pose/intrinsics trajectory in one request and writes an MP4. Use it when the
   camera path is known up front and streaming is not needed.
@@ -54,12 +53,32 @@ source frames, at least as many as requested and at most 4096. The runtime
 consumes only the prefix needed by the request. Longer rollouts also require
 sufficient device memory.
 
+## Experimental KV writeback reuse
+
+To reuse KV from the final denoising step instead of running the additional
+clean-latent writeback, pass this option in the `model_config` supplied to
+`Omni` or `AsyncOmni`:
+
+```python
+model_config = {"lingbot_reuse_last_step_kv": True}
+```
+
+The default is `False`. The value must be a boolean, not a string or integer.
+It is validated and fixed when the pipeline instance is constructed; changing
+it requires a new instance. It is not a per-request `extra_args` option.
+The previous `VLLM_OMNI_LINGBOT_REUSE_LAST_STEP_KV` environment variable is no
+longer read.
+
+This experimental mode stores the final noisy probe's KV rather than clean
+`x0` KV, so generated outputs can differ. The four denoising steps, chunk
+boundaries, and paged-context finalization remain the same.
+
 ## Realtime in-process generation (deprecated)
 
-Use [Streaming video serving](#streaming-video-serving) instead unless you need
-mid-session camera interaction, which only this path has. It still works and
-emits no runtime warning; removal is tracked as B4 of the LingBot World 2.0
-roadmap ([#6672](https://github.com/vllm-project/vllm-omni/issues/6672)).
+Prefer [Streaming video serving](#streaming-video-serving) for mid-session
+camera control. This tick example still works and emits no runtime warning;
+removal is tracked as B4 of the LingBot World 2.0 roadmap
+([#6672](https://github.com/vllm-project/vllm-omni/issues/6672)).
 
 The realtime example keeps AR-Diffusion KV and model-owned state across
 requests. Each JSONL line describes the prompt and/or three latent-frame camera
@@ -96,8 +115,8 @@ The stepwise path keeps AR-Diffusion paged KV but issues **one** request for
 the whole rollout: `prepare_encode` runs once, then every AR block is four DMD
 steps followed by one streamed chunk. Identity metadata uses
 `session_id = request_id` with contiguous `chunk_index` values from zero.
-Camera motion for this landing is request-scoped: one three-frame action list
-per chunk, fixed when the rollout starts.
+Camera motion can be request-scoped (`camera_action_script` / `action_path`) or
+updated mid-session via `session.interaction`.
 
 Serve it with the AR-Diffusion deploy config, which selects the AR-Diffusion
 engine and enables streamed step execution:
@@ -115,11 +134,11 @@ keep their request-mode topology when no deploy config is given, and the
 stepwise serving topology is only ever an explicit choice.
 
 Clients then use the generic WebSocket protocol documented in
-[`docs/serving/video_stream_api.md`](../../docs/serving/video_stream_api.md):
+[`docs/serving/streaming_video_output_api.md`](../../docs/serving/streaming_video_output_api.md):
 `session.start` begins one rollout and each AR block arrives as a binary video
-chunk. The model is image-conditioned, so the first frame is required and rides
-on `image_reference` as an `http(s)` or `data:` URL; per-chunk camera actions
-ride on `extra_params`:
+chunk. The model is image-conditioned, so the first frame is required
+at `image_reference` as an `http(s)` or `data:` URL; an optional request-scoped
+pre-scripted list of WASD actions can be provided in `extra_params`:
 
 ```json
 {"type": "session.start", "model": "robbyant/lingbot-world-v2-14b-causal-fast-diffusers",
@@ -134,7 +153,26 @@ ride on `extra_params`:
 chunk, and a request generates `((num_frames - 1) // 4 + 1) // 3` chunks:
 three for `num_frames: 33`, seven for `num_frames: 81`.
 
-The bundled client speaks this protocol:
+Mid-session camera control uses structural SE3 on `session.interaction`
+(Unity frame: `+X` right, `+Y` up, `+Z` forward). WASD key tokens belong in
+clients and are required to be converted before submitting to the service:
+
+```json
+{"type": "session.interaction",
+ "interaction": {
+   "event_id": "forward-1",
+   "event": {
+     "multi_modal_data": {
+       "camera": {
+         "mode": "velocity",
+         "data": {"translation": [0.0, 0.0, 0.05], "rotation": [0.0, 0.0, 0.0, 1.0]}
+       }
+     }
+   }
+ }}
+```
+
+The bundled client helps translate the protocol, converting `--camera-updates` keystrokes to corresponding SE3 matrices:
 
 ```bash
 python examples/online_serving/streaming_video_generation/streaming_video_client.py \
@@ -142,23 +180,21 @@ python examples/online_serving/streaming_video_generation/streaming_video_client
   --prompt "The camera moves slowly forward through the scene." \
   --image-reference /path/to/first_frame.png \
   --width 832 --height 480 --num-frames 33 --fps 16 --seed 42 \
-  --extra-params '{"camera_action_script":[[["w"],["w"],["w"]],[["a"],[],[]],[[],[],[]]]}' \
+  --camera-updates '[{"at": 1.0, "actions": ["w"]}, {"at": 3.0, "actions": ["a"]}]' \
   --output lingbot_world_v2_stream.mp4
 ```
 
 A served request may instead point at a pose/intrinsics trajectory with
 `extra_params.action_path`, which is resolved inside the trusted root set by
 `model_config.lingbot_action_root` or `VLLM_OMNI_LINGBOT_ACTION_ROOT`; a server
-started without that root configured accepts only `camera_action_script`.
+started without that root configured accepts only `camera_action_script` or
+mid-session camera interaction.
 
 Requested `width`/`height` must match `ar_diffusion_width`/`ar_diffusion_height`
 in the deploy config, because the AR cache geometry is fixed at load time.
 Blocks are decoded independently, so seams between chunks are possible; a
 session-owned streaming decoder is tracked separately.
 
-Mid-session `session.interaction` for camera control is not wired yet, so a
-served rollout follows the script it started with.
-
 The deprecated tick example remains available for the older
 one-block-per-`generate()` control plane.
 
@@ -199,8 +235,8 @@ tested commit.
 
 - Only the 14B causal-fast checkpoint is supported.
 - The tick control plane is internal; the public transport is the stepwise
-  `WS /v1/realtime/video` path, which cannot take mid-session camera
-  interaction yet.
+  `WS /v1/realtime/video` path with structural SE3 mid-session camera
+  interaction (WASD remains a client-side or `camera_action_script` convenience).
 - Stepwise serving requires an explicit
   `--deploy-config vllm_omni/deploy/lingbot_world_v2_stepwise.yaml`; there is
   no default deploy config for this model.
diff --git a/recipes/circlestone-labs/Anima.md b/recipes/circlestone-labs/Anima.md
new file mode 100644
index 000000000..bcaf84364
--- /dev/null
+++ b/recipes/circlestone-labs/Anima.md
@@ -0,0 +1,158 @@
+# Anima
+
+> Native single-file diffusion text-to-image
+
+## Summary
+
+- Vendor: circlestone-labs
+- Model: [`circlestone-labs/Anima`](https://huggingface.co/circlestone-labs/Anima)
+- Task: text2img
+- Mode: Offline inference, Online serving (OpenAI-compatible API)
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe to run Anima via vLLM-Omni's native `AnimaPipeline`. Anima is a
+Cosmos-style diffusion transformer text-to-image model distributed as a
+single-file transformer checkpoint, not as a normal Hugging Face model
+directory.
+
+The native path reads the Anima transformer checkpoint directly, converts
+original Cosmos transformer keys when needed, and loads the Cosmos transformer
+and text conditioner into native vLLM-Omni modules. Non-denoiser components
+such as `text_encoder`, `tokenizer`, `t5_tokenizer`, `vae`, and optionally
+`scheduler` must be supplied through a Diffusers-layout components directory.
+
+Native Anima currently supports baseline single-GPU execution. Cache-DiT,
+TeaCache, CPU offload, layer-wise offload, quantization, TP/SP, CFG parallel,
+HSDP, and step execution are not supported by `AnimaPipeline` yet.
+
+## References
+
+- Offline example:
+  [`examples/offline_inference/text_to_image/README.md`](../../examples/offline_inference/text_to_image/README.md)
+- Supported model entry:
+  [`docs/models/supported_models.md`](../../docs/models/supported_models.md)
+- HuggingFace model page:
+  [circlestone-labs/Anima](https://huggingface.co/circlestone-labs/Anima)
+- Diffusers-layout components:
+  [circlestone-labs/Anima-Base-v1.0-Diffusers](https://huggingface.co/circlestone-labs/Anima-Base-v1.0-Diffusers)
+
+## Hardware Support
+
+## ROCm
+
+### 1x AMD MI300X
+
+#### Environment
+
+- OS: Ubuntu 22.04.5 LTS (x86_64)
+- Python: 3.12.13
+- Driver / runtime: ROCm 7.2.53211, HIP runtime 7.2.53211, MIOpen 3.5.1
+- PyTorch: 2.10.0+git8514f05 built with ROCm 7.2.53211
+- GPU: 1x AMD MI300X
+- vLLM version: 0.23.0
+- vLLM-Omni version or commit: 0.1.dev2002+g704724675.rocm
+
+Recommended environment variables:
+
+```bash
+export VLLM_WORKER_MULTIPROC_METHOD=spawn
+export VLLM_ROCM_USE_AITER=0
+export PYTORCH_ROCM_ARCH=gfx942
+export PYTORCH_NVML_BASED_CUDA_CHECK=1
+```
+
+#### Command - prepare assets
+
+Download the official transformer checkpoint and the Diffusers-layout component
+directory:
+
+```bash
+mkdir -p /path/to/models/anima-official
+mkdir -p /path/to/models/anima-components
+
+hf download circlestone-labs/Anima \
+    split_files/diffusion_models/anima-base-v1.0.safetensors \
+    --local-dir /path/to/models/anima-official
+
+hf download circlestone-labs/Anima-Base-v1.0-Diffusers \
+    --local-dir /path/to/models/anima-components
+
+export ANIMA_CHECKPOINT=/path/to/models/anima-official/split_files/diffusion_models/anima-base-v1.0.safetensors
+export ANIMA_COMPONENTS=/path/to/models/anima-components
+```
+
+The `ANIMA_COMPONENTS` directory must be in Diffusers `from_pretrained()`
+layout. Raw auxiliary files such as `qwen_3_06b_base.safetensors` and
+`qwen_image_vae.safetensors` are converter inputs; they are not accepted
+directly as `components_path`.
+
+#### Command - text-to-image
+
+```bash
+python examples/offline_inference/text_to_image/text_to_image.py \
+    --model "$ANIMA_CHECKPOINT" \
+    --model-class-name AnimaPipeline \
+    --custom-pipeline-args "{\"components_path\":\"$ANIMA_COMPONENTS\"}" \
+    --prompt "A cinematic close-up of a glass teapot on a wooden table." \
+    --seed 42 \
+    --guidance-scale 4.0 \
+    --num-inference-steps 50 \
+    --height 1024 \
+    --width 1024 \
+    --output /tmp/anima_output.png
+```
+
+Use 1024x1024, 50 denoising steps, `max_sequence_length=512`, one image per
+prompt, empty negative prompt, and CFG scale 4.0 when matching Anima's default
+Diffusers settings.
+
+#### Verification
+
+Check that `/tmp/anima_output.png` exists and contains a generated image.
+
+#### Notes
+
+- Key flags: `--model-class-name AnimaPipeline` selects the native Anima path;
+  `--custom-pipeline-args` supplies `components_path`.
+- Keep the default diffusion load format. No deploy config is required when a
+  local checkpoint and `--model-class-name AnimaPipeline` are provided.
+- Start with `max-concurrency=1` for correctness and latency validation.
+- Keep requests at the same resolution when comparing runs.
+- Do not enable parallelism, cache acceleration, offload, or quantized
+  checkpoint flags for Anima until support is added to `AnimaPipeline`.
+
+## Online Serving
+
+Anima supports text-to-image generation through the OpenAI-compatible image
+generation API.
+
+### Launch
+
+```bash
+vllm serve "$ANIMA_CHECKPOINT" \
+    --omni \
+    --port 8099 \
+    --model-class-name AnimaPipeline \
+    --custom-pipeline-args "{\"components_path\":\"$ANIMA_COMPONENTS\"}"
+```
+
+### Send requests
+
+```bash
+curl http://localhost:8099/v1/images/generations \
+    -H "Content-Type: application/json" \
+    -d "{
+      \"model\": \"$ANIMA_CHECKPOINT\",
+      \"prompt\": \"A cinematic close-up of a glass teapot on a wooden table.\",
+      \"size\": \"1024x1024\",
+      \"num_inference_steps\": 50,
+      \"guidance_scale\": 4.0,
+      \"seed\": 42
+    }"
+```
+
+The same generation knobs used by other text-to-image recipes apply:
+`num_inference_steps`, `seed`, `height` / `width` through `size`, and optional
+negative prompting.
diff --git a/recipes/lerobot/Pi05.md b/recipes/lerobot/Pi05.md
new file mode 100644
index 000000000..af648f5ad
--- /dev/null
+++ b/recipes/lerobot/Pi05.md
@@ -0,0 +1,154 @@
+# Pi0.5 (π0.5) VLA
+
+> Vision-Language-Action policy serving over the OpenPI realtime websocket
+
+## Summary
+
+- Vendor: Physical Intelligence (checkpoint redistributed by LeRobot)
+- Model: `lerobot/pi05_base`
+- Task: Vision-Language-Action — multi-camera images + a language instruction +
+  robot proprioceptive state → a continuous action chunk
+  `[action_horizon, action_dim] = [50, 32]` via flow-matching denoising. π0.5
+  does **not** emit text tokens.
+- Mode: Online serving via the OpenPI realtime robot API
+  (`/v1/realtime/robot/openpi` websocket)
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe to deploy `lerobot/pi05_base` as a robot policy server: a robot
+client connects over the OpenPI websocket and, per control step, sends an
+observation (camera frames + state + instruction) and receives an action chunk.
+
+A single pipeline class (`Pi05Pipeline`) serves the policy. π0.5 is stateless
+across calls (first-order Markov, no KV reuse), so the protocol's `session_id` /
+`reset` are accepted but ignored.
+
+This recipe covers the functional path only. Serving runs in eager mode, with no
+CUDA Graph capture, no Triton kernels and no prefix or encoder caching, and both
+`float32` and `bfloat16` are supported. Two π0.5 capabilities are not
+implemented, and a checkpoint that declares either is rejected when it loads:
+
+- **MEM** short-horizon observation memory (`use_visual_memory`,
+  `use_proprioceptive_memory`)
+- **RTC** real-time chunking (`rtc_config`)
+
+A checkpoint with `use_relative_actions` must also carry `action_feature_names`
+in `config.json`.
+
+## Weights
+
+| Component | Params | Part of |
+| --- | ---: | --- |
+| Vision tower, SigLIP So400m/14 | 412 M | PaliGemma |
+| Language model, Gemma-2B, with the multimodal projector | 2.51 B | PaliGemma |
+| Action expert, Gemma-300M, with AdaRMS and the action/time heads | 693 M | π0.5 |
+| Total | 3.62 B | 13.5 GiB in float32 |
+
+| Artifact | Repository |
+| --- | --- |
+| `model.safetensors`, 812 tensors, ~14.5 GB | `lerobot/pi05_base` |
+| `policy_preprocessor.json` + `policy_preprocessor_step_*.safetensors` | `lerobot/pi05_base` |
+| Tokenizer, gated | `google/paligemma-3b-pt-224` |
+
+## Hardware Support
+
+### 1x H100 80GB (Online serving)
+
+The nightly end-to-end job runs on one H100, and serving was also verified on an
+RTX 4090 and an RTX PRO 5000.
+
+#### Environment
+
+- OS: Ubuntu 22.04+
+- Python: 3.12+
+- Driver / runtime: NVIDIA CUDA environment
+- vLLM / vLLM-Omni: use the commit you are deploying from
+- Hugging Face: `google/paligemma-3b-pt-224` license accepted, `hf auth login`
+- OpenPI client extras (robot side, and for the e2e test): `openpi-client`,
+  `websockets`, `msgpack`, `msgpack-numpy`. CI pins `openpi-client` to OpenPI
+  revision `215abfb217dbac7d5f1273282331b9b1866c0479`.
+
+#### Command
+
+```bash
+vllm serve lerobot/pi05_base \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --deploy-config vllm_omni/deploy/pi05.yaml \
+  --enforce-eager --disable-log-stats
+```
+
+The deploy config (`vllm_omni/deploy/pi05.yaml`) declares a single diffusion
+stage (`Pi05Pipeline`), `float32`, `max_num_seqs: 1`, `tokenizer_max_length: 200`
+and `state_num_bins: 256`, together with the `policy_server_config` handshake
+metadata (3 cameras, `joint_position`, action horizon 50, action dim 32) that
+enables the OpenPI realtime serving layer. Keep `action_horizon`, `action_dim`
+and `image_resolution` in that block in sync with `model_config`.
+
+To serve in bfloat16, set `dtype: bfloat16` in the same file.
+
+#### Verification
+
+The observation is a flat dict per inference:
+
+```python
+{
+    "observation.images.base_0_rgb":        np.uint8[H, W, 3],  # or float32 in [0, 1]
+    "observation.images.left_wrist_0_rgb":  np.uint8[H, W, 3],
+    "observation.images.right_wrist_0_rgb": np.uint8[H, W, 3],
+    "state":   np.float32[state_dim],   # must match the checkpoint's declared width
+    "prompt":  "pick up the red block",
+    "session_id": "<uuid>",             # accepted but ignored (π0.5 is stateless)
+    "sampling_params": {"num_inference_steps": 4},   # optional engine knobs
+}
+```
+
+Camera keys must match the server's `image_feature_keys`, which is the
+checkpoint's `input_features` order. If your robot uses different camera names,
+set `model_config.image_key_map` in `pi05.yaml` to map raw obs keys → feature
+keys. Every request needs at least one configured camera and a non-null state.
+
+`state` must have the width `input_features["observation.state"]` declares, 32
+for `lerobot/pi05_base`. That checkpoint ships no normalization statistics, so
+its values must already be normalized.
+
+PIL and uint8 images use the `[0, 255]` domain, while floating ndarray and
+tensor images must be finite and in `[0, 1]`. Both are converted with
+`x * 2 - 1`.
+
+Engine knobs live under `sampling_params`. It currently holds
+`num_inference_steps`, which overrides the deploy-config denoising steps for a
+single request.
+
+### Target-hardware validation
+
+Client E2E round trip over the OpenPI websocket: msgpack pack, send, engine,
+denoise, unpack. Eager, batch 1, 10 denoising steps, p50 of 30 round
+trips after 3 warmup.
+
+| GPU | dtype | Client E2E p50 (ms), 1 / 2 / 3 cameras | Device peak (GiB) |
+| --- | --- | ---: | ---: |
+| H100 80 GB HBM3 (sm_90) | float32 | 282 / 356 / 398 | 15.0 |
+| H100 80 GB HBM3 (sm_90) | bfloat16 | 290 / 301 / 312 | 9.1 |
+| RTX PRO 5000 72 GB (sm_120) | float32 | 185 / 231 / 281 | 14.8 |
+| RTX PRO 5000 72 GB (sm_120) | bfloat16 | 156 / 177 / 203 | 8.9 |
+
+## Correctness
+
+π0.5's flow-matching kernel reproduces the LeRobot `PI05Policy` reference
+exactly (`max|Δ| = 0`, CPU/float32, fixed noise, 1/2/3 cameras). The same file
+also compares the prompt tokens carrying the discretized state, the
+relative-action path, and a bfloat16 run against LeRobot in bfloat16:
+`tests/diffusion/models/pi05/test_pi05_parity.py`.
+
+## References
+
+- Model blog: <https://www.physicalintelligence.company/blog/pi05>
+- LeRobot π0.5 docs: <https://github.com/huggingface/lerobot/blob/main/docs/source/policy_pi05_README.md>
+- Checkpoint: <https://huggingface.co/lerobot/pi05_base>
+- Pipeline: [`vllm_omni/diffusion/models/pi05/pipeline_pi05.py`](../../vllm_omni/diffusion/models/pi05/pipeline_pi05.py)
+- Deploy config: [`vllm_omni/deploy/pi05.yaml`](../../vllm_omni/deploy/pi05.yaml)
+- Tests: CPU units + LeRobot parity in [`tests/diffusion/models/pi05/`](../../tests/diffusion/models/pi05/),
+  OpenPI websocket e2e in
+  [`tests/e2e/online_serving/test_pi05_expansion.py`](../../tests/e2e/online_serving/test_pi05_expansion.py)
diff --git a/recipes/rednote-hilab/dots.tts.md b/recipes/rednote-hilab/dots.tts.md
deleted file mode 100644
index cc180020e..000000000
--- a/recipes/rednote-hilab/dots.tts.md
+++ /dev/null
@@ -1,166 +0,0 @@
-# dots.tts
-
-> Continuous-AR TTS at 48 kHz (rednote-hilab)
-
-## Summary
-
-- Vendor: rednote-hilab
-- Model: `dots-studio/dots.tts-soar`
-- Task: Text-to-speech, zero-shot synthesis only
-- Mode: Offline inference and OpenAI-compatible online serving
-- Maintainer: Community
-
-## When to use this recipe
-
-Use this recipe as a known-good starting point for running
-`dots-studio/dots.tts-soar` on vLLM-Omni on consumer-class GPUs.
-dots.tts is a ~1.7B-parameter continuous-AR TTS model (Qwen2.5-1.5B base LM
-+ 344M DiT flow-matching head + 180M AudioVAE) that emits 48 kHz mono audio.
-It follows the same "vLLM-native base LM + side-path computation" pattern as
-VoxCPM2 — single-stage pipeline
-`Qwen2.5-1.5B base LM → DiT (10-step Euler flow matching) → patch_encoder AR
-loopback → AudioVAE (streaming decode)` — with a plain Qwen2 backbone
-instead of MiniCPM4, and no FSQ / residual-LM stage.
-
-This is an early integration; review the [Known limitations](#known-limitations)
-before deploying it in production.
-
-## References
-
-- Offline end-to-end script:
-  [`examples/offline_inference/text_to_speech/dots_tts/end2end.py`](../../examples/offline_inference/text_to_speech/dots_tts/end2end.py)
-- Example guide:
-  [`examples/offline_inference/text_to_speech/README.md`](../../examples/offline_inference/text_to_speech/README.md#dotstts)
-- Online serving guide:
-  [`examples/online_serving/text_to_speech/README.md`](../../examples/online_serving/text_to_speech/README.md#dotstts)
-- Default deploy config:
-  [`vllm_omni/deploy/dots_tts.yaml`](../../vllm_omni/deploy/dots_tts.yaml)
-- Talker / pipeline source:
-  [`vllm_omni/model_executor/models/dots_tts/`](../../vllm_omni/model_executor/models/dots_tts/)
-- Upstream: [rednote-hilab/dots.tts](https://github.com/rednote-hilab/dots.tts)
-
-## Hardware Support
-
-This recipe documents one tested 16 GB consumer-GPU configuration. Other
-vendor sections (ROCm, NPU) and larger-VRAM configurations are welcome as
-community validation lands.
-
-## GPU
-
-### 1 x RTX 5080 16GB (Single GPU, Minimum Recommended)
-
-dots.tts (~1.7B params across the base LM + DiT + AudioVAE + CAM++
-speaker encoder, bfloat16) fits comfortably on a single 16 GB GPU. The
-bundled default config at
-[`vllm_omni/deploy/dots_tts.yaml`](../../vllm_omni/deploy/dots_tts.yaml)
-(`gpu_memory_utilization: 0.8`, `max_num_seqs: 4`, `enforce_eager: true`,
-`enable_prefix_caching: false`) loads cleanly with ~5.1 GiB for model
-weights and ~0.3 GiB peak activation; the remainder of the configured
-budget is available for KV cache. Total resident footprint at idle is
-roughly **7-8 GiB / 16 GB** — the only tight spot in the full CUDA-Graph
-roadmap would be step 8's graph capture (not implemented yet; this
-release runs `enforce_eager: true`, so it doesn't apply today).
-
-#### Environment
-
-- OS: Linux (WSL2)
-- Python: 3.12
-- Driver / runtime: NVIDIA driver 595.95
-- torch: 2.11.0+cu130
-- vLLM: 0.26.0
-- vLLM-Omni: 0.22.1.dev (current `main`)
-
-#### Command
-
-```bash
-python examples/offline_inference/text_to_speech/dots_tts/end2end.py \
-    --model dots-studio/dots.tts-soar \
-    --text "Hello, this is a test of dots TTS running on vLLM Omni."
-```
-
-The deploy config at
-[`vllm_omni/deploy/dots_tts.yaml`](../../vllm_omni/deploy/dots_tts.yaml)
-is loaded automatically by the model registry (HF `model_type=dots_tts`).
-Pass `--deploy-config <path>` to override.
-
-#### Verification
-
-**T1 — offline zero-shot synthesis**:
-
-```bash
-python examples/offline_inference/text_to_speech/dots_tts/end2end.py \
-    --model dots-studio/dots.tts-soar \
-    --text "Hello, this is a test of dots TTS running on vLLM Omni."
-```
-
-Observed: `output_audio/output.wav`, 3.52 s @ 48 kHz mono. Single
-one-shot process (init → one `generate()` → exit), so the reported
-numbers include engine init and first-request warmup, not just steady-state
-per-step throughput — same caveat as VoxCPM2's recipe. `Inference: 5.52s`,
-`RTF: 1.569`.
-
-Weight-loading breakdown from the same run (all tensors matched, no
-missing/extra keys): 951/951 AudioVAE, 244/244 DiT, 270/270
-patch_encoder, 198 Qwen2, 938/938 CAM++ speaker encoder.
-
-Whisper transcription of the output matched the input text with no
-dropped leading word (confirms the streaming-vocoder patch-boundary fix
-described in [Known limitations](#known-limitations)).
-
-**T2 — online text-only synthesis**:
-
-```bash
-vllm serve dots-studio/dots.tts-soar --omni --trust-remote-code --port 8091
-```
-
-```bash
-curl -X POST http://localhost:8091/v1/audio/speech \
-    -H "Content-Type: application/json" \
-    -d '{
-        "input": "Hello, this is a test of dots TTS online serving.",
-        "voice": "default",
-        "response_format": "wav"
-    }' --output output.wav
-```
-
-The endpoint also supports raw streaming audio with `stream=true`,
-`stream_format="audio"`, and `response_format="pcm"`.
-
-#### Notes
-
-- Output: 48 kHz mono WAV.
-- Checkpoints: `dots-studio/dots.tts-soar` is the validated default
-  used throughout this recipe. `rednote-hilab/dots.tts-base` shares the
-  same architecture but is unvalidated in this repo. `rednote-hilab/dots.tts-mf`
-  (MeanFlow, 2-4 step) is not supported — see below.
-- `enforce_eager: true` and `enable_prefix_caching: false` in the deploy
-  config are load-bearing, not just conservative defaults: with prefix
-  caching enabled, vLLM-Omni's prefix-cache multimodal-output merge path
-  does not preserve the `sparse_audio` marker this model relies on to
-  route audio output correctly, and generation silently truncates to a
-  single ~160 ms patch. Do not override `enable_prefix_caching` for this
-  model until that framework-level gap is fixed.
-
-## Known limitations
-
-- **Voice cloning is not wired.** The CAM++ x-vector speaker encoder
-  weights load and are exercised by `load_weights()`, but nothing in the
-  prompt builder consumes reference audio or a precomputed speaker embedding
-  yet. Both offline and online generation are text-only; `ref_audio`,
-  `ref_text`, named voices, and speaker embeddings are not supported.
-- **`dots.tts-mf` (MeanFlow, 2-4 step) checkpoint is not supported.** Only
-  the fixed 10-step Euler DiT sampler used by `dots.tts-soar` /
-  `dots.tts-base` is implemented.
-- **No CUDA graph capture.** The talker runs fully eager. voxcpm2's three
-  captured graphs (base LM decode, CFM solver, VAE decode) have no
-  dots.tts equivalent yet.
-- **Concurrent requests do not scale.** Each request's 10-step DiT Euler
-  integration runs serially in the side path (no cross-request batching,
-  unlike voxcpm2's `enable_batched_cfm`). A community review of this
-  integration measured no throughput gain at `c=4` concurrent requests
-  versus `c=1`.
-- **`SamplingParams.seed` does not control audio-generation randomness.**
-  The DiT's flow-matching noise is deterministically derived per-request
-  from a fixed internal seed (reproducible run-to-run, matching
-  voxcpm2's `deterministic_cfm_seed` convention) rather than from the
-  caller-supplied `seed` field — the same limitation voxcpm2 has today.
diff --git a/requirements/common.txt b/requirements/common.txt
index 855fb6b0a..d7b845e32 100644
--- a/requirements/common.txt
+++ b/requirements/common.txt
@@ -41,3 +41,8 @@ pydantic-settings>=2.0.0
 gguf>=0.10.0
 # Required for running the Cosmos3 model with guardrails enabled (default behavior).
 cosmos-guardrail>=0.3.1
+# Required for CosyVoice3 (get_window/resample_poly). >=1.18.0 requires
+# Python >=3.12, breaking base installs on the project's supported 3.10/3.11;
+# these are long-stable APIs with no version-specific need for 1.18.
+scipy>=1.11.0
+s3tokenizer==0.3.0
diff --git a/tests/attention/test_fish_kvcache_attn.py b/tests/attention/test_fish_kvcache_attn.py
index 4a8ea17e8..73d44295a 100644
--- a/tests/attention/test_fish_kvcache_attn.py
+++ b/tests/attention/test_fish_kvcache_attn.py
@@ -3,6 +3,7 @@
 
 import pytest
 import torch
+from vllm.platforms import current_platform
 
 from vllm_omni.attention import fish_kvcache_attn, fish_kvcache_backend
 
@@ -113,6 +114,15 @@ def test_fish_kvcache_enabled_by_default(monkeypatch):
     assert not fish_kvcache_attn.is_fish_kvcache_attn_required()
 
 
+def test_fish_kvcache_fast_path_is_unavailable_off_cuda(monkeypatch):
+    monkeypatch.setattr(current_platform, "is_cuda", lambda: False)
+    monkeypatch.setattr(
+        fish_kvcache_attn, "_triton_backend", lambda: pytest.fail("Triton backend must not load off CUDA")
+    )
+
+    assert not fish_kvcache_attn.is_available()
+
+
 @pytest.mark.parametrize("value", ["", "1", "true", "yes", "on", "required"])
 def test_fish_kvcache_enabled_values_are_consistent(monkeypatch, value):
     monkeypatch.setenv("VLLM_OMNI_FISH_KVCACHE_ATTN", value)
diff --git a/tests/benchmarks/duplex/test_omni_duplex_eval_media.py b/tests/benchmarks/duplex/test_omni_duplex_eval_media.py
index 28a502428..ad2fffc9d 100644
--- a/tests/benchmarks/duplex/test_omni_duplex_eval_media.py
+++ b/tests/benchmarks/duplex/test_omni_duplex_eval_media.py
@@ -1,15 +1,289 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""Tests for omni_duplex_eval_media — PyAV-backed media helpers."""
+
 from __future__ import annotations
 
+import io
+from pathlib import Path
+
+import av
+import numpy as np
 import pytest
 
-from vllm_omni.benchmarks.duplex.omni_duplex_eval_media import materialize_media
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_media import (
+    _ffmpeg_q_to_pil_quality,
+    extract_jpeg,
+    materialize_media,
+    read_audio_pcm16,
+    video_duration,
+)
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+# ---------------------------------------------------------------------------
+# Helpers: synthetic test media generated with PyAV (no external files)
+# ---------------------------------------------------------------------------
+
+
+def _make_synthetic_mp4(duration: float = 1.0, fps: int = 30) -> bytes:
+    """Return an MP4 byte blob with a solid-color pattern.
+
+    Uses the built-in ``mpeg4`` encoder — available everywhere PyAV's bundled
+    FFmpeg is present — so no external codec dependency.
+    """
+    buf = io.BytesIO()
+    total_frames = int(duration * fps)
+    with av.open(buf, mode="w", format="mp4") as container:
+        stream = container.add_stream("mpeg4", rate=fps)
+        stream.width = 64
+        stream.height = 64
+        stream.pix_fmt = "yuv420p"
+        for i in range(total_frames):
+            frame = av.VideoFrame.from_ndarray(np.full((64, 64, 3), (i * 8) % 256, dtype=np.uint8), format="rgb24")
+            for pkt in stream.encode(frame):
+                container.mux(pkt)
+        for pkt in stream.encode():
+            container.mux(pkt)
+    return buf.getvalue()
+
+
+def _make_synthetic_wav(duration: float = 1.0, sample_rate: int = 16000) -> bytes:
+    """Return a 16-bit mono PCM WAV byte blob (440 Hz sine wave)."""
+    import wave as _wave
+
+    n = int(sample_rate * duration)
+    samples = (np.sin(2 * np.pi * 440 * np.arange(n) / sample_rate) * 32767).astype(np.int16)
+    buf = io.BytesIO()
+    with _wave.open(buf, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)
+        wf.setframerate(sample_rate)
+        wf.writeframes(samples.tobytes())
+    return buf.getvalue()
+
+
+def _make_synthetic_ogg(duration: float = 1.0, sample_rate: int = 16000) -> bytes:
+    """Return an OGG Vorbis byte blob (440 Hz sine wave).
+
+    Uses ``libopus`` as a fallback if ``libvorbis`` is unavailable in the
+    bundled FFmpeg (e.g. PyAV wheels from an older build).
+    """
+    buf = io.BytesIO()
+    n = int(sample_rate * duration)
+    samples = (np.sin(2 * np.pi * 440 * np.arange(n) / sample_rate) * 0.3).astype(np.float32)
+    with av.open(buf, mode="w", format="ogg") as container:
+        codec_name = "libopus" if "libvorbis" not in av.codecs_available else "libvorbis"
+        stream = container.add_stream(codec_name, rate=sample_rate, layout="mono")
+        frame = av.AudioFrame.from_ndarray(samples[np.newaxis, :], format="fltp", layout="mono")
+        frame.sample_rate = sample_rate
+        for pkt in stream.encode(frame):
+            container.mux(pkt)
+        for pkt in stream.encode():
+            container.mux(pkt)
+    return buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# video_duration
+# ---------------------------------------------------------------------------
+
+
+class TestVideoDuration:
+    @staticmethod
+    def test_returns_duration(tmp_path: Path) -> None:
+        mp4 = _make_synthetic_mp4(duration=2.0, fps=30)
+        path = tmp_path / "test.mp4"
+        path.write_bytes(mp4)
+        dur = video_duration(path)
+        assert abs(dur - 2.0) < 0.05, f"expected ~2.0s, got {dur}"
+
+    @staticmethod
+    def test_raises_for_missing_file(tmp_path: Path) -> None:
+        with pytest.raises((OSError, ValueError)):
+            video_duration(tmp_path / "nonexistent.mp4")
+
+    @staticmethod
+    def test_raises_for_broken_file(tmp_path: Path) -> None:
+        broken = tmp_path / "broken.mp4"
+        broken.write_bytes(b"\x00\x00\x00\x00")
+        with pytest.raises((OSError, ValueError)):
+            video_duration(broken)
+
+
+# ---------------------------------------------------------------------------
+# extract_jpeg
+# ---------------------------------------------------------------------------
+
+
+class TestExtractJpeg:
+    @staticmethod
+    def test_returns_valid_jpeg(tmp_path: Path) -> None:
+        mp4 = _make_synthetic_mp4(duration=1.0, fps=30)
+        path = tmp_path / "test.mp4"
+        path.write_bytes(mp4)
+        jpeg = extract_jpeg(path, timestamp=0.5, quality=3)
+        assert jpeg.startswith(b"\xff\xd8"), "not a valid JPEG header"
+        assert len(jpeg) > 100
+
+    @staticmethod
+    def test_quality_maps_to_pil_scale(tmp_path: Path) -> None:
+        """Higher ffmpeg quality (lower q value) produces a larger JPEG."""
+        mp4 = _make_synthetic_mp4(duration=1.0, fps=30)
+        path = tmp_path / "test.mp4"
+        path.write_bytes(mp4)
+        high = extract_jpeg(path, timestamp=0.5, quality=1)
+        low = extract_jpeg(path, timestamp=0.5, quality=31)
+        assert len(high) > len(low), "quality=1 should produce larger JPEG than quality=31"
+
+    @staticmethod
+    def test_negative_timestamp_clamped(tmp_path: Path) -> None:
+        """Negative timestamps are clamped to 0."""
+        mp4 = _make_synthetic_mp4(duration=1.0, fps=30)
+        path = tmp_path / "test.mp4"
+        path.write_bytes(mp4)
+        jpeg = extract_jpeg(path, timestamp=-1.0, quality=3)
+        assert jpeg.startswith(b"\xff\xd8")
+
+    @staticmethod
+    def test_raises_value_error_for_no_video(tmp_path: Path) -> None:
+        wav = _make_synthetic_wav()
+        path = tmp_path / "test.wav"
+        path.write_bytes(wav)
+        with pytest.raises(ValueError):
+            extract_jpeg(path, timestamp=0.0)
+
+    @staticmethod
+    def test_long_gop_returns_different_frames_for_different_timestamps(tmp_path: Path) -> None:
+        """Long GOP: different timestamps must return different frame content (P2)."""
+        # Create a long-GOP video: 3s @ 10fps = 30 frames, gop_size=30 (1 keyframe)
+        buf = io.BytesIO()
+        fps = 10
+        duration = 3.0
+        total_frames = int(duration * fps)
+        with av.open(buf, mode="w", format="mp4") as container:
+            stream = container.add_stream("mpeg4", rate=fps)
+            stream.width = 64
+            stream.height = 64
+            stream.pix_fmt = "yuv420p"
+            stream.gop_size = 30  # 3 seconds per keyframe
+            for i in range(total_frames):
+                frame = av.VideoFrame.from_ndarray(np.full((64, 64, 3), (i * 64) % 256, dtype=np.uint8), format="rgb24")
+                for pkt in stream.encode(frame):
+                    container.mux(pkt)
+            for pkt in stream.encode():
+                container.mux(pkt)
+        mp4 = buf.getvalue()
+
+        path = tmp_path / "long_gop.mp4"
+        path.write_bytes(mp4)
+
+        # Extract frames at different timestamps
+        frame0 = extract_jpeg(path, timestamp=0.0, quality=3)
+        frame1 = extract_jpeg(path, timestamp=1.0, quality=3)
+        frame2 = extract_jpeg(path, timestamp=2.0, quality=3)
+
+        # Verify all are valid JPEGs
+        assert frame0.startswith(b"\xff\xd8")
+        assert frame1.startswith(b"\xff\xd8")
+        assert frame2.startswith(b"\xff\xd8")
+
+        # Verify content differs: decode JPEGs and compare mean brightness
+        from PIL import Image
+
+        img0 = np.asarray(Image.open(io.BytesIO(frame0)))
+        img1 = np.asarray(Image.open(io.BytesIO(frame1)))
+        img2 = np.asarray(Image.open(io.BytesIO(frame2)))
+        means = [img.mean() for img in (img0, img1, img2)]
+        assert len(set(round(m, 1) for m in means)) >= 2, (
+            f"timestamps 0/1/2s should give different frames, got means {means}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# read_audio_pcm16
+# ---------------------------------------------------------------------------
+
+
+class TestReadAudioPcm16:
+    @staticmethod
+    def test_wav_fast_path(tmp_path: Path) -> None:
+        """WAV with matching params uses the fast wave module path."""
+        wav = _make_synthetic_wav(duration=1.0, sample_rate=16000)
+        path = tmp_path / "test.wav"
+        path.write_bytes(wav)
+        pcm = read_audio_pcm16(path)
+        assert len(pcm) == 16000 * 2, f"expected 32000 bytes, got {len(pcm)}"
+        assert isinstance(pcm, bytes)
+
+    @staticmethod
+    def test_wav_different_rate_resamples(tmp_path: Path) -> None:
+        """A 48 kHz WAV is resampled down to 16 kHz — exact sample count after flush."""
+        wav = _make_synthetic_wav(duration=1.0, sample_rate=48000)
+        path = tmp_path / "test.wav"
+        path.write_bytes(wav)
+        pcm = read_audio_pcm16(path)
+        assert len(pcm) > 0
+        assert len(pcm) % 2 == 0
+        # 1s @ 48kHz → 1s @ 16kHz = 16000 samples = 32000 bytes (±1 sample)
+        assert abs(len(pcm) - 32000) <= 4, f"expected ~32000 bytes, got {len(pcm)}"
+
+    @staticmethod
+    def test_non_wav_ogg(tmp_path: Path) -> None:
+        """Non-WAV audio (OGG) is decoded and resampled via PyAV."""
+        ogg = _make_synthetic_ogg(duration=1.0, sample_rate=16000)
+        path = tmp_path / "test.ogg"
+        path.write_bytes(ogg)
+        pcm = read_audio_pcm16(path)
+        assert len(pcm) > 0
+        assert len(pcm) % 2 == 0
+
+    @staticmethod
+    def test_non_wav_ogg_resample_accuracy(tmp_path: Path) -> None:
+        """OGG resample should produce exact sample count after flush."""
+        ogg = _make_synthetic_ogg(duration=1.5, sample_rate=48000)
+        path = tmp_path / "test.ogg"
+        path.write_bytes(ogg)
+        pcm = read_audio_pcm16(path)
+        # 1.5s @ 48kHz → 1.5s @ 16kHz = 24000 samples = 48000 bytes (±1 sample)
+        expected = int(1.5 * 16000) * 2
+        assert abs(len(pcm) - expected) <= 4, f"expected ~{expected} bytes, got {len(pcm)}"
+
+    @staticmethod
+    def test_raises_for_broken_file(tmp_path: Path) -> None:
+        """Corrupt audio must raise, not return empty bytes (L1)."""
+        broken = tmp_path / "broken.mp3"
+        broken.write_bytes(b"\x00\x00\x00\x00")
+        with pytest.raises((OSError, ValueError)):
+            read_audio_pcm16(broken)
+
+
+# ---------------------------------------------------------------------------
+# _ffmpeg_q_to_pil_quality
+# ---------------------------------------------------------------------------
+
+
+class TestFfmpegQToPilQuality:
+    @staticmethod
+    def test_q1_maps_to_best() -> None:
+        assert _ffmpeg_q_to_pil_quality(1) >= 90
+
+    @staticmethod
+    def test_q31_maps_to_lowest() -> None:
+        assert _ffmpeg_q_to_pil_quality(31) <= 10
+
+    @staticmethod
+    def test_monotonic() -> None:
+        """Higher ffmpeg q → lower PIL quality (monotonically non-increasing)."""
+        prev = 100
+        for q in range(1, 32):
+            p = _ffmpeg_q_to_pil_quality(q)
+            assert p <= prev, f"quality.increase at q={q}: {prev} → {p}"
+            prev = p
+
+
 def test_dict_with_bytes_materializes_a_real_file(tmp_path):
     # A Hugging Face Audio/Video feature value {"bytes": ..., "path": ...} used
     # to short-circuit on ``path`` (the artifact name inside the dataset, which
diff --git a/tests/benchmarks/patch/test_benchmark_result.py b/tests/benchmarks/patch/test_benchmark_result.py
new file mode 100644
index 000000000..1e9619fe3
--- /dev/null
+++ b/tests/benchmarks/patch/test_benchmark_result.py
@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Verify metric sample counts survive benchmark JSON serialization."""
+
+import asyncio
+import json
+import time
+
+import pytest
+from vllm.benchmarks.datasets import SampleRequest
+from vllm.benchmarks.serve import TaskType
+
+from vllm_omni.benchmarks.patch import patch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.benchmark, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize("selected_metrics", [["ttft", "tpot", "itl"], []])
+@pytest.mark.parametrize("measured", [True, False])
+def test_benchmark_result_preserves_tpot_sample_count(monkeypatch, measured, selected_metrics):
+    async def request_func(**kwargs):
+        return patch.MixRequestFuncOutput(
+            success=True,
+            prompt_len=2,
+            output_tokens=3,
+            generated_text="hello world!",
+            start_time=time.perf_counter(),
+            ttft=0.01,
+            latency=0.03,
+            text_latency=0.03,
+            itl=[0.01, 0.01] if measured else [0.0, 0.0],
+        )
+
+    monkeypatch.setitem(patch.ASYNC_REQUEST_FUNCS, "test-result", request_func)
+    result = asyncio.run(
+        patch.benchmark(
+            task_type=TaskType.GENERATION,
+            endpoint_type="test-result",
+            api_url="http://unused/v1/chat/completions",
+            base_url="http://unused",
+            model_id="test-model",
+            model_name="test-model",
+            tokenizer=None,
+            input_requests=[SampleRequest(prompt="hi", prompt_len=2, expected_output_len=3)],
+            logprobs=None,
+            request_rate=float("inf"),
+            burstiness=1.0,
+            disable_tqdm=True,
+            num_warmups=0,
+            profile=False,
+            selected_percentile_metrics=selected_metrics,
+            selected_percentiles=[50.0],
+            ignore_eos=False,
+            goodput_config_dict={},
+            max_concurrency=1,
+            lora_modules=None,
+            extra_headers=None,
+            extra_body=None,
+            ready_check_timeout_sec=0,
+        )
+    )
+    # DFX reads this dictionary from the benchmark's JSON result file.
+    saved_result = json.loads(json.dumps(result))
+    assert saved_result["completed"] == 1
+    assert saved_result.get("num_tpot_samples") == int(measured)
+    assert saved_result["num_ttft_samples"] == 1
+    assert saved_result["num_itl_samples"] == 2
+    assert "num_audio_ttfp_samples" in saved_result
+    assert "num_audio_rtf_samples" in saved_result
+    if measured and "tpot" in selected_metrics:
+        assert saved_result["mean_tpot_ms"] == pytest.approx(10.0)
+    else:
+        assert "mean_tpot_ms" not in saved_result
diff --git a/tests/benchmarks/test_accuracy_bench_utils.py b/tests/benchmarks/test_accuracy_bench_utils.py
index 8d78da2b2..8f9f74785 100644
--- a/tests/benchmarks/test_accuracy_bench_utils.py
+++ b/tests/benchmarks/test_accuracy_bench_utils.py
@@ -47,11 +47,50 @@ from benchmarks.accuracy.text_to_image.gbench import (
 from tests.e2e.accuracy.qwen3_omni.qwen3_omni_acc_bench_core import (
     build_serve_common_argv,
     seed_tts_bench_argv,
+    videomme_bench_argv,
 )
 from tests.e2e.accuracy.qwen3_omni.run_qwen_omni_acc_benchmark import sync_dataset_env_from_ns
 from vllm_omni.benchmarks.data_modules.seed_tts_dataset import resolve_seed_tts_root
 
 
+def test_videomme_bench_argv_preserves_hf_repo_id_from_env(monkeypatch):
+    monkeypatch.setenv("VLLM_VIDEOMME_DATASET_PATH", "lmms-eval/Video-MME")
+    monkeypatch.delenv("VLLM_VIDEOMME_REPO", raising=False)
+    monkeypatch.delenv("VIDEOMME_ROOT", raising=False)
+
+    argv = videomme_bench_argv()
+
+    dataset_idx = argv.index("--dataset-path")
+    assert argv[argv.index("--dataset-name") + 1] == "videomme"
+    assert argv[dataset_idx + 1] == "lmms-eval/Video-MME"
+
+
+def test_videomme_bench_argv_uses_local_directory(monkeypatch, tmp_path: Path):
+    monkeypatch.setenv("VLLM_VIDEOMME_DATASET_PATH", str(tmp_path))
+    monkeypatch.delenv("VIDEOMME_ROOT", raising=False)
+
+    argv = videomme_bench_argv()
+
+    assert argv[argv.index("--dataset-path") + 1] == str(tmp_path.resolve())
+
+
+def test_sync_dataset_env_preserves_videomme_hf_repo_id(monkeypatch):
+    ns = argparse.Namespace(
+        daily_omni_repo=None,
+        daily_omni_qa_json=None,
+        daily_omni_video_dir=None,
+        videomme_repo=None,
+        videomme_dataset_path="lmms-eval/Video-MME",
+        seed_tts_dataset_path=None,
+        seed_tts_root=None,
+    )
+
+    monkeypatch.delenv("VLLM_VIDEOMME_DATASET_PATH", raising=False)
+    sync_dataset_env_from_ns(ns)
+
+    assert os.environ["VLLM_VIDEOMME_DATASET_PATH"] == "lmms-eval/Video-MME"
+
+
 def test_seed_tts_bench_argv_preserves_hf_repo_id_from_env(monkeypatch):
     monkeypatch.setenv("VLLM_SEED_TTS_DATASET_PATH", "zhaochenyang20/seed-tts-eval")
     monkeypatch.delenv("VLLM_SEED_TTS_REPO", raising=False)
diff --git a/tests/benchmarks/test_diffusion_benchmark_warmups.py b/tests/benchmarks/test_diffusion_benchmark_warmups.py
new file mode 100644
index 000000000..9d72189b7
--- /dev/null
+++ b/tests/benchmarks/test_diffusion_benchmark_warmups.py
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import importlib
+import sys
+
+import pytest
+
+from benchmarks.diffusion import backends
+from benchmarks.diffusion.backends import RequestFuncInput, RequestFuncOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.benchmark, pytest.mark.cpu, pytest.mark.asyncio]
+
+ENDPOINT = "/v1/chat/completions"
+TEST_MODEL = "test-model"
+
+
+@pytest.fixture
+def diffusion_benchmark(monkeypatch):
+    # The standalone script imports its sibling backend module by name.
+    monkeypatch.setitem(sys.modules, "backends", backends)
+    return importlib.import_module("benchmarks.diffusion.diffusion_benchmark_serving")
+
+
+@pytest.fixture
+def warmup_args(diffusion_benchmark):
+    from benchmarks.diffusion.diffusion_benchmark_serving import build_parser
+
+    parser = build_parser()
+    return parser.parse_args(
+        [
+            f"--endpoint={ENDPOINT}",
+            "--dataset=random",
+            "--task=t2i",
+            "--warmup-requests=2",
+            "--warmup-num-inference-steps=4",
+        ]
+    )
+
+
+@pytest.fixture
+def input_requests():
+    return [
+        RequestFuncInput(
+            prompt=prompt,
+            api_url=f"http://test.local{ENDPOINT}",
+            model=TEST_MODEL,
+            num_inference_steps=20,
+        )
+        for prompt in ("first", "second")
+    ]
+
+
+async def test_disabled_warmup_sends_no_requests(diffusion_benchmark, warmup_args, input_requests):
+    warmup_args.warmup_requests = 0
+
+    async def unexpected_request(*args):
+        pytest.fail("disabled warmup must not send requests")
+
+    pairs = await diffusion_benchmark._run_warmups(input_requests, warmup_args, None, unexpected_request)
+
+    assert pairs == []
+
+
+async def test_successful_warmups_preserve_request_output_pairs(diffusion_benchmark, warmup_args, input_requests):
+    outputs = [RequestFuncOutput(success=True, latency=0.5), RequestFuncOutput(success=True, latency=1.0)]
+    pending_outputs = iter(outputs)
+
+    async def successful_request(req, session, pbar):
+        return next(pending_outputs)
+
+    pairs = await diffusion_benchmark._run_warmups(input_requests, warmup_args, None, successful_request)
+
+    assert [request.prompt for request, _ in pairs] == ["first", "second"]
+    assert [request.num_inference_steps for request, _ in pairs] == [4, 4]
+    assert [output for _, output in pairs] == outputs
+    assert [request.num_inference_steps for request in input_requests] == [20, 20]
+
+
+@pytest.mark.parametrize("failed_count", [1, 2], ids=["partial-failure", "all-failed"])
+@pytest.mark.parametrize(
+    "error",
+    ["HTTP 503: private prompt rejected", "Cannot connect to https://test.local/?token=private"],
+    ids=["http-error", "transport-error"],
+)
+async def test_failed_warmups_abort_without_exposing_response_errors(
+    diffusion_benchmark, warmup_args, input_requests, failed_count, error
+):
+    outputs = iter(
+        [RequestFuncOutput(success=False, error=error) for _ in range(failed_count)]
+        + [RequestFuncOutput(success=True) for _ in range(2 - failed_count)]
+    )
+
+    async def request(req, session, pbar):
+        return next(outputs)
+
+    with pytest.raises(RuntimeError, match=f"{failed_count}/2 warmup requests failed") as exc_info:
+        await diffusion_benchmark._run_warmups(input_requests, warmup_args, None, request)
+
+    assert error not in str(exc_info.value)
+    assert "server logs" in str(exc_info.value)
+
+
+async def test_benchmark_does_not_start_measurement_after_failed_warmup(
+    monkeypatch, mocker, diffusion_benchmark, warmup_args, input_requests
+):
+    sent = []
+
+    async def failed_request(req, session, pbar):
+        sent.append(req)
+        return RequestFuncOutput(success=False, error="HTTP 503: unavailable")
+
+    monkeypatch.setitem(
+        diffusion_benchmark.backends_function_mapping["2i"],
+        warmup_args.endpoint,
+        (failed_request, warmup_args.endpoint),
+    )
+    dataset = mocker.Mock(spec=diffusion_benchmark.RandomDataset)
+    dataset.get_requests.return_value = input_requests
+    monkeypatch.setattr(diffusion_benchmark, "RandomDataset", mocker.Mock(return_value=dataset))
+    timer = mocker.Mock(spec=diffusion_benchmark.time)
+    timer.perf_counter.side_effect = AssertionError("measurement started after failed warmup")
+    monkeypatch.setattr(diffusion_benchmark, "time", timer)
+
+    with pytest.raises(RuntimeError, match="2/2 warmup requests failed"):
+        await diffusion_benchmark.benchmark(warmup_args)
+
+    assert len(sent) == warmup_args.warmup_requests
diff --git a/tests/benchmarks/test_videomme_local_source.py b/tests/benchmarks/test_videomme_local_source.py
new file mode 100644
index 000000000..d1029b1e2
--- /dev/null
+++ b/tests/benchmarks/test_videomme_local_source.py
@@ -0,0 +1,546 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Offline Video-MME sources: local mirrors must not fall back to a Hub id."""
+
+from __future__ import annotations
+
+import os
+import zipfile
+from argparse import Namespace
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote, urlparse
+
+import pytest
+from PIL import Image
+
+from tests.e2e.accuracy.qwen3_omni.run_qwen_omni_acc_benchmark import _validate_videomme
+from vllm_omni.benchmarks.data_modules.videomme_dataset import (
+    VideoMMEDataset,
+    VideoMMESampleRequest,
+    cached_videomme_snapshots,
+    ensure_videomme_hub_root,
+    ensure_videomme_videos_extracted,
+    resolve_videomme_local_root,
+    videomme_local_parquet,
+    videomme_local_subtitle_dir,
+    videomme_local_video_dir,
+)
+from vllm_omni.benchmarks.data_modules.videomme_eval import (
+    compute_videomme_accuracy_metrics,
+    extract_characters_regex,
+    normalize_gold_answer,
+)
+from vllm_omni.benchmarks.patch.patch import _looks_like_hf_dataset_id, _videomme_repo_from_args, get_samples
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.benchmark]
+
+
+def _write_parquet_placeholder(root: Path) -> Path:
+    path = root / "videomme" / "test-00000-of-00001.parquet"
+    path.parent.mkdir(parents=True)
+    path.write_bytes(b"parquet")
+    return path
+
+
+def test_resolve_local_root_returns_none_for_hub_id() -> None:
+    assert resolve_videomme_local_root("lmms-eval/Video-MME") is None
+    assert resolve_videomme_local_root("") is None
+    assert resolve_videomme_local_root(None) is None
+
+
+def test_plain_local_mirror(tmp_path: Path) -> None:
+    pq = _write_parquet_placeholder(tmp_path)
+    video = tmp_path / "video" / "abc.mp4"
+    video.parent.mkdir()
+    video.write_bytes(b"fake")
+    (tmp_path / "subtitle").mkdir()
+    (tmp_path / "subtitle" / "abc.srt").write_text("1\n", encoding="utf-8")
+
+    root = resolve_videomme_local_root(str(tmp_path))
+    assert root == tmp_path.resolve()
+    assert videomme_local_parquet(root) == pq.resolve()
+    assert videomme_local_video_dir(root) == tmp_path.resolve() / "video"
+    assert videomme_local_subtitle_dir(root) == tmp_path.resolve() / "subtitle"
+
+
+def test_hf_cache_dir_resolves_to_snapshot(tmp_path: Path) -> None:
+    cache_dir = tmp_path / "datasets--lmms-eval--Video-MME"
+    snapshot = cache_dir / "snapshots" / "deadbeef"
+    snapshot.mkdir(parents=True)
+    _write_parquet_placeholder(snapshot)
+    (cache_dir / "refs").mkdir()
+    (cache_dir / "refs" / "main").write_text("deadbeef", encoding="utf-8")
+
+    root = resolve_videomme_local_root(str(cache_dir))
+    assert root == snapshot.resolve()
+    assert videomme_local_parquet(root) is not None
+
+
+def test_hf_cache_dir_with_unusable_ref_falls_back_to_revision(tmp_path: Path) -> None:
+    cache_dir = tmp_path / "datasets--lmms-eval--Video-MME"
+    snapshot = cache_dir / "snapshots" / "deadbeef"
+    snapshot.mkdir(parents=True)
+    _write_parquet_placeholder(snapshot)
+    (cache_dir / "refs").mkdir()
+    # An empty ref must not resolve to snapshots/, which holds no dataset files.
+    (cache_dir / "refs" / "main").write_text("", encoding="utf-8")
+
+    assert resolve_videomme_local_root(str(cache_dir)) == snapshot.resolve()
+
+
+def _stub_failing_hub(monkeypatch: pytest.MonkeyPatch, hub_cache: Path) -> dict[str, object]:
+    """Point the Hub cache at ``hub_cache`` and make every snapshot_download miss."""
+    from huggingface_hub import constants as hf_constants
+    from huggingface_hub.errors import LocalEntryNotFoundError
+
+    from vllm_omni.transformers_utils import repo_utils
+
+    seen: dict[str, object] = {}
+
+    class _Api:
+        def snapshot_download(self, **kwargs: object) -> str:
+            seen.update(kwargs)
+            raise LocalEntryNotFoundError("no cached snapshot")
+
+    monkeypatch.setattr(hf_constants, "HF_HUB_OFFLINE", True)
+    monkeypatch.setattr(hf_constants, "HF_HUB_CACHE", str(hub_cache))
+    monkeypatch.setattr(repo_utils, "hf_api", lambda: _Api())
+    return seen
+
+
+def test_hub_root_offline_without_cache_points_at_local_options(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    seen = _stub_failing_hub(monkeypatch, tmp_path)
+
+    with pytest.raises(FileNotFoundError, match="--videomme-video-dir") as excinfo:
+        ensure_videomme_hub_root("lmms-lab/Video-MME")
+
+    # Offline runs must consult the cache directly instead of resolving over the network.
+    assert seen["local_files_only"] is True
+    assert "already cached under another repo id" not in str(excinfo.value)
+
+
+def test_hub_root_offline_names_snapshot_cached_under_another_repo_id(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    sibling = tmp_path / "datasets--lmms-eval--Video-MME" / "snapshots" / "deadbeef"
+    sibling.mkdir(parents=True)
+    _write_parquet_placeholder(sibling)
+    _stub_failing_hub(monkeypatch, tmp_path)
+
+    with pytest.raises(FileNotFoundError) as excinfo:
+        ensure_videomme_hub_root("lmms-lab/Video-MME")
+
+    assert str(sibling.resolve()) in str(excinfo.value)
+
+
+def test_cached_videomme_snapshots_skips_partial_download(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    from huggingface_hub import constants as hf_constants
+
+    (tmp_path / "datasets--lmms-eval--Video-MME" / "snapshots" / "deadbeef").mkdir(parents=True)
+    monkeypatch.setattr(hf_constants, "HF_HUB_CACHE", str(tmp_path))
+
+    assert cached_videomme_snapshots() == []
+
+
+def test_extract_videos_rejects_empty_tree(tmp_path: Path) -> None:
+    (tmp_path / "video").mkdir()
+
+    with pytest.raises(FileNotFoundError):
+        ensure_videomme_videos_extracted(tmp_path)
+    assert not (tmp_path / ".videomme_videos_extracted").exists()
+
+
+def test_nested_unzipped_videos_are_discovered(tmp_path: Path) -> None:
+    nested = tmp_path / "videos" / "videos_chunked_01" / "data" / "xyz.mp4"
+    nested.parent.mkdir(parents=True)
+    nested.write_bytes(b"fake")
+
+    assert videomme_local_video_dir(tmp_path) == tmp_path / "videos"
+
+
+def test_extract_characters_regex_matches_official_prefixes() -> None:
+    assert extract_characters_regex("The best answer is B.") == "B"
+    assert extract_characters_regex("Answer: C") == "C"
+    assert extract_characters_regex("I think D is correct") == "D"
+    assert extract_characters_regex("no letter here at all in this long sentence") is None
+
+
+def test_normalize_gold_answer() -> None:
+    assert normalize_gold_answer("a") == "A"
+    assert normalize_gold_answer("B. content") == "B"
+    assert normalize_gold_answer("") is None
+
+
+class _Out:
+    def __init__(self, text: str, *, success: bool = True) -> None:
+        self.generated_text = text
+        self.success = success
+        self.error = "" if success else "http fail"
+
+
+def test_compute_videomme_accuracy_metrics() -> None:
+    reqs = [
+        VideoMMESampleRequest(
+            prompt="q",
+            prompt_len=1,
+            expected_output_len=8,
+            videomme_gold_answer="A",
+            videomme_video_id="v1",
+            videomme_question_id="q1",
+            videomme_duration="short",
+            videomme_domain="Knowledge",
+            videomme_sub_category="Science",
+            videomme_task_type="QA",
+        ),
+        VideoMMESampleRequest(
+            prompt="q",
+            prompt_len=1,
+            expected_output_len=8,
+            videomme_gold_answer="B",
+            videomme_video_id="v2",
+            videomme_question_id="q2",
+            videomme_duration="long",
+            videomme_domain="Knowledge",
+            videomme_sub_category="Science",
+            videomme_task_type="QA",
+        ),
+    ]
+    metrics = compute_videomme_accuracy_metrics(reqs, [_Out("A"), _Out("The answer is C")])
+    assert metrics is not None
+    assert metrics["videomme_correct"] == 1
+    assert metrics["videomme_evaluated_ok"] == 2
+    assert metrics["videomme_accuracy"] == 0.5
+    assert metrics["videomme_submitted"] == 2
+    assert metrics["videomme_unique_question_ids"] == 2
+    assert _validate_videomme(metrics, min_accuracy=0.4) == []
+    assert "videomme_eval_items" not in metrics
+    assert metrics["videomme_per_duration_accuracy"]["short"] == 1.0
+    assert metrics["videomme_per_duration_accuracy"]["long"] == 0.0
+
+
+def test_compute_videomme_accuracy_metrics_http_fail_excluded_from_default() -> None:
+    reqs = [
+        VideoMMESampleRequest(
+            prompt="q",
+            prompt_len=1,
+            expected_output_len=8,
+            videomme_gold_answer="A",
+            videomme_question_id="q1",
+        ),
+        VideoMMESampleRequest(
+            prompt="q",
+            prompt_len=1,
+            expected_output_len=8,
+            videomme_gold_answer="B",
+            videomme_question_id="q2",
+        ),
+    ]
+    metrics = compute_videomme_accuracy_metrics(reqs, [_Out("A"), _Out("", success=False)])
+    assert metrics is not None
+    assert metrics["videomme_accuracy"] == 1.0
+    assert metrics["videomme_accuracy_incl_http_fail"] == 0.5
+    assert metrics["videomme_request_failed"] == 1
+    errs = _validate_videomme(metrics, min_accuracy=0.68)
+    assert any("videomme_request_failed" in err for err in errs)
+
+
+def test_compute_videomme_accuracy_metrics_saves_eval_items() -> None:
+    req = VideoMMESampleRequest(
+        prompt="q",
+        prompt_len=1,
+        expected_output_len=8,
+        videomme_gold_answer="A",
+        videomme_question_id="q1",
+    )
+    metrics = compute_videomme_accuracy_metrics([req], [_Out("A")], include_per_item=True)
+    assert metrics is not None
+    assert metrics["videomme_eval_items"][0]["question_id"] == "q1"
+
+
+def test_videomme_save_eval_items_cli_sets_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    from vllm_omni.benchmarks import serve
+
+    seen: dict[str, str | None] = {}
+
+    async def fake_main_async(args: Namespace) -> dict[str, str]:
+        seen["env"] = os.environ.get("VIDEOMME_SAVE_EVAL_ITEMS")
+        return {"ok": "1"}
+
+    monkeypatch.delenv("VIDEOMME_SAVE_EVAL_ITEMS", raising=False)
+    monkeypatch.setattr(serve, "main_async", fake_main_async)
+
+    args = Namespace(
+        videomme_save_eval_items=True,
+        seed_tts_wer_eval=False,
+        seed_tts_wer_save_items=False,
+        daily_omni_save_eval_items=False,
+        omni_request_timeout_s=None,
+        endpoint=None,
+        backend="openai-chat-omni",
+        explicit_keys=frozenset(),
+        extra_body=None,
+        print_stage=False,
+        dataset_name="videomme",
+    )
+    assert serve.main(args) == {"ok": "1"}
+    assert seen["env"] == "1"
+
+
+def _file_uri_path(url: str) -> Path:
+    parsed = urlparse(url)
+    assert parsed.scheme == "file"
+    return Path(unquote(parsed.path))
+
+
+def test_relative_video_dir_emits_absolute_file_uris_cold_and_warm(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    videos = tmp_path / "videos"
+    videos.mkdir()
+    (videos / "vid1.mp4").write_bytes(b"fake")
+
+    def fake_extract(cls, video_path, *, include_audio, max_num_frames):  # noqa: ANN001
+        return [Image.new("RGB", (4, 4), color="red")], []
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(VideoMMEDataset, "load_data", lambda self: None)
+    monkeypatch.setattr(VideoMMEDataset, "_extract_frames_and_audio", classmethod(fake_extract))
+
+    ds = VideoMMEDataset(parquet_path="dummy.parquet", video_dir="videos", max_frames=1)
+    assert ds.video_dir == videos.resolve()
+
+    cold = ds._get_minicpm_frame_parts("vid1", include_audio=False)
+    assert cold is not None
+    cold_path = _file_uri_path(cold[0]["image_url"]["url"])
+    assert cold_path.is_absolute()
+    assert cold_path.is_file()
+
+    warm_ds = VideoMMEDataset(parquet_path="dummy.parquet", video_dir="videos", max_frames=1)
+    warm = warm_ds._get_minicpm_frame_parts("vid1", include_audio=False)
+    assert warm is not None
+    warm_path = _file_uri_path(warm[0]["image_url"]["url"])
+    assert warm_path.is_absolute()
+    assert warm_path == cold_path
+
+
+def test_videomme_repo_from_args_honors_custom_hub_id() -> None:
+    args = Namespace(dataset_name="videomme", dataset_path="my-org/custom-videomme", hf_name=None)
+    assert _videomme_repo_from_args(args, explicit=True) == "my-org/custom-videomme"
+
+
+def test_videomme_repo_from_args_defaults_when_path_omitted() -> None:
+    args = Namespace(dataset_name="videomme", dataset_path=None, hf_name=None)
+    assert _videomme_repo_from_args(args, explicit=True) is None
+
+
+def test_videomme_repo_from_args_rejects_unsupported_path() -> None:
+    args = Namespace(dataset_name="videomme", dataset_path="not-a-local-dir-or-hub-id", hf_name=None)
+    with pytest.raises(ValueError, match="Unsupported Video-MME"):
+        _videomme_repo_from_args(args, explicit=True)
+
+
+def test_get_samples_rejects_unsupported_videomme_dataset_path() -> None:
+    args = Namespace(
+        dataset_name="videomme",
+        dataset_path="not-a-local-dir-or-hub-id",
+        hf_name=None,
+        backend="openai-chat-omni",
+        seed=0,
+    )
+    with pytest.raises(ValueError, match="Unsupported Video-MME"):
+        get_samples(args, None)
+
+
+def test_hf_dataset_name_does_not_auto_detect_custom_repo() -> None:
+    args = Namespace(dataset_name="hf", dataset_path="my-org/custom-videomme", hf_name=None)
+    assert _videomme_repo_from_args(args) is None
+    assert _looks_like_hf_dataset_id("my-org/custom-videomme")
+    assert not _looks_like_hf_dataset_id("./videos")
+    official = Namespace(dataset_name="hf", dataset_path="lmms-eval/Video-MME", hf_name=None)
+    assert _videomme_repo_from_args(official) == "lmms-eval/Video-MME"
+
+
+@pytest.mark.parametrize("max_frames", [0, -1])
+def test_rejects_nonpositive_max_frames(max_frames: int, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(VideoMMEDataset, "load_data", lambda self: None)
+    with pytest.raises(ValueError, match="max_frames must be positive"):
+        VideoMMEDataset(parquet_path="unused.parquet", max_frames=max_frames)
+
+
+def test_frame_cache_rebuild_overwrites_incomplete_files(tmp_path: Path) -> None:
+    frame = tmp_path / "frame_0000.jpg"
+    frame.write_bytes(b"interrupted JPEG")
+    VideoMMEDataset._emit_media(tmp_path, frame.name, b"complete JPEG", "image_url", "image/jpeg")
+    assert frame.read_bytes() == b"complete JPEG"
+
+
+def test_frame_cache_rejects_empty_media(tmp_path: Path) -> None:
+    (tmp_path / "manifest.json").write_text('{"count": 1}', encoding="utf-8")
+    (tmp_path / "frame_0000.jpg").touch()
+    dataset = object.__new__(VideoMMEDataset)
+    assert dataset._cached_parts_from_disk(tmp_path, include_audio=False) is None
+
+
+@pytest.mark.parametrize("case", ["duplicates", "missing_gold"])
+def test_accuracy_gate_rejects_incomplete_question_coverage(case: str) -> None:
+    def request(question_id: str, gold: str) -> VideoMMESampleRequest:
+        return VideoMMESampleRequest(
+            prompt="q",
+            prompt_len=1,
+            expected_output_len=8,
+            videomme_question_id=question_id,
+            videomme_gold_answer=gold,
+        )
+
+    requests = [
+        request("q1", "A"),
+        request("q1" if case == "duplicates" else "q2", "" if case == "missing_gold" else "A"),
+    ]
+    metrics = compute_videomme_accuracy_metrics(requests, [_Out("A"), _Out("A")])
+    assert metrics is not None
+    assert metrics["videomme_accuracy"] == 1.0
+    errors = _validate_videomme(metrics, min_accuracy=0.68)
+    assert any(("unique" if case == "duplicates" else "no_gold") in error for error in errors)
+
+
+@pytest.fixture
+def videomme_mirror(tmp_path: Path) -> Path:
+    import pandas as pd
+
+    parquet = tmp_path / "videomme" / "test-00000-of-00001.parquet"
+    parquet.parent.mkdir()
+    pd.DataFrame(
+        [
+            {
+                "videoID": f"v{i}",
+                "question_id": f"q{i}",
+                "question": "Which option is correct?",
+                "options": ["A. first", "B. second", "C. third", "D. fourth"],
+                "answer": "A",
+                "duration": duration,
+            }
+            for i, duration in enumerate(("short", "long"), start=1)
+        ]
+    ).to_parquet(parquet)
+    videos = tmp_path / "video"
+    videos.mkdir()
+    for i in (1, 2):
+        (videos / f"v{i}.mp4").write_bytes(b"video")
+    return tmp_path
+
+
+def _sample_video_urls(dataset: VideoMMEDataset, monkeypatch: pytest.MonkeyPatch, **kwargs: Any) -> list:
+    monkeypatch.setattr(
+        "vllm_omni.benchmarks.data_modules.videomme_dataset.get_cached_tokenizer", lambda tokenizer: tokenizer
+    )
+    return dataset.sample(Namespace(encode=lambda text: [1]), **kwargs)
+
+
+@pytest.mark.parametrize("no_oversample", [True, False])
+def test_missing_video_cannot_pass_accuracy_gate(
+    videomme_mirror: Path, monkeypatch: pytest.MonkeyPatch, no_oversample: bool
+) -> None:
+    (videomme_mirror / "video" / "v2.mp4").unlink()
+    dataset = VideoMMEDataset(dataset_path=str(videomme_mirror), pack_mode="video_url", disable_shuffle=True)
+    requests = _sample_video_urls(dataset, monkeypatch, num_requests=2, no_oversample=no_oversample)
+    metrics = compute_videomme_accuracy_metrics(requests, [_Out("A") for _ in requests])
+    assert metrics is not None
+    assert metrics["videomme_accuracy"] == 1.0
+    assert metrics["videomme_submitted"] == (1 if no_oversample else 2)
+    assert metrics["videomme_skipped_rows"] == 1
+    assert any("videomme_skipped_rows" in error for error in _validate_videomme(metrics, min_accuracy=0.68))
+
+
+def test_complete_duration_subset_can_pass_accuracy_gate(
+    videomme_mirror: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    dataset = VideoMMEDataset(dataset_path=str(videomme_mirror), pack_mode="video_url", duration_filter="short")
+    requests = _sample_video_urls(dataset, monkeypatch, num_requests=2700, no_oversample=True)
+    metrics = compute_videomme_accuracy_metrics(requests, [_Out("A") for _ in requests])
+    assert metrics is not None
+    assert metrics["videomme_submitted"] == 1
+    assert metrics["videomme_skipped_rows"] == 0
+    assert _validate_videomme(metrics, min_accuracy=0.68) == []
+
+
+def test_dataset_direct_hub_loading_resolves_video_assets(
+    videomme_mirror: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    downloaded = []
+
+    def download(repo_id: str) -> Path:
+        downloaded.append(repo_id)
+        return videomme_mirror
+
+    monkeypatch.setattr("vllm_omni.benchmarks.data_modules.videomme_dataset.ensure_videomme_hub_root", download)
+    dataset = VideoMMEDataset(dataset_path="my-org/custom-videomme", pack_mode="video_url")
+    assert downloaded == ["my-org/custom-videomme"]
+    assert dataset.video_dir == videomme_mirror / "video"
+    assert len(dataset.data) == 2
+
+
+def test_local_source_with_explicit_parquet_keeps_video_root(videomme_mirror: Path) -> None:
+    dataset = VideoMMEDataset(
+        dataset_path=str(videomme_mirror),
+        parquet_path=str(videomme_local_parquet(videomme_mirror)),
+        pack_mode="video_url",
+    )
+    assert dataset.video_dir == videomme_mirror / "video"
+    assert len(dataset.data) == 2
+
+
+def test_local_source_without_parquet_fails_locally(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    def unexpected_hub(*args, **kwargs):
+        pytest.fail("An explicitly selected local mirror must not fall back to Hub loading")
+
+    monkeypatch.setattr("vllm_omni.benchmarks.data_modules.videomme_dataset.load_dataset", unexpected_hub)
+    with pytest.raises(FileNotFoundError, match="No Video-MME parquet"):
+        VideoMMEDataset(dataset_path=str(tmp_path))
+
+
+def test_get_samples_prefers_local_root_over_hf_name(videomme_mirror: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    args = Namespace(
+        dataset_name="videomme",
+        dataset_path=str(videomme_mirror),
+        hf_name="unused-hf-name",
+        backend="openai-chat-omni",
+        seed=0,
+        videomme_pack_mode="video_url",
+        num_prompts=2,
+        request_id_prefix="",
+        no_oversample=True,
+    )
+    monkeypatch.setattr(
+        "vllm_omni.benchmarks.data_modules.videomme_dataset.get_cached_tokenizer", lambda tokenizer: tokenizer
+    )
+    requests = get_samples(args, Namespace(encode=lambda text: [1]))
+    assert len(requests) == 2
+    assert {request.videomme_question_id for request in requests} == {"q1", "q2"}
+
+
+def test_extraction_replaces_truncated_video(tmp_path: Path) -> None:
+    video = tmp_path / "video" / "v1.mp4"
+    video.parent.mkdir()
+    video.write_bytes(b"partial")
+    with zipfile.ZipFile(tmp_path / "videos_chunked_01.zip", "w") as archive:
+        archive.writestr("nested/v1.mp4", b"complete video")
+    assert ensure_videomme_videos_extracted(tmp_path) == video.parent
+    assert video.read_bytes() == b"complete video"
+
+
+def test_failed_extraction_does_not_publish_partial_video(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    with zipfile.ZipFile(tmp_path / "videos_chunked_01.zip", "w") as archive:
+        archive.writestr("v1.mp4", b"complete video")
+
+    def interrupted_copy(src, dst):
+        dst.write(b"partial")
+        raise OSError("interrupted")
+
+    monkeypatch.setattr("vllm_omni.benchmarks.data_modules.videomme_dataset.shutil.copyfileobj", interrupted_copy)
+    with pytest.raises(OSError, match="interrupted"):
+        ensure_videomme_videos_extracted(tmp_path)
+    assert list((tmp_path / "video").iterdir()) == []
+    assert not (tmp_path / ".videomme_videos_extracted").exists()
diff --git a/tests/buildkite/test_amd_pipeline.py b/tests/buildkite/test_amd_pipeline.py
index c2c45f5ef..fac4f8c29 100644
--- a/tests/buildkite/test_amd_pipeline.py
+++ b/tests/buildkite/test_amd_pipeline.py
@@ -11,6 +11,8 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 AMD_MERGE_PIPELINE = Path(".buildkite/amd/test-amd-merge.yml")
 AMD_NIGHTLY_PIPELINE = Path(".buildkite/amd/test-amd-nightly.yml")
+AMD_READY_PIPELINE = Path(".buildkite/amd/test-amd-ready.yml")
+AMD_TEMPLATE = Path(".buildkite/amd/test-template-amd-omni.j2")
 
 
 def _find_step(label: str, pipeline_path: Path = AMD_MERGE_PIPELINE) -> dict:
@@ -53,3 +55,25 @@ def test_qwen3_accuracy_defers_artifact_path_expansion() -> None:
     assert '"$${BUILDKITE_BUILD_CHECKOUT_PATH:?}"' in staging_command
     assert '"$$artifact_dir"' in staging_command
     assert step["artifact_paths"] == ["tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc/*.json"]
+
+
+def test_ready_diffusion_cpu_suite_is_sharded() -> None:
+    step = _find_step("Simple · Diffusion Test · Shard %N/%t", AMD_READY_PIPELINE)
+    pytest_command = next(command for command in step["commands"] if "pytest" in command)
+
+    assert step["parallelism"] == 4
+    assert step["timeout_in_minutes"] == 45
+    assert "--num-shards=$$BUILDKITE_PARALLEL_JOB_COUNT" in pytest_command
+    assert "--shard-id=$$BUILDKITE_PARALLEL_JOB" in pytest_command
+
+
+def test_cosyvoice_gpu_abort_gets_one_fresh_job_retry() -> None:
+    step = _find_step("CosyVoice3-TTS E2E Test", AMD_READY_PIPELINE)
+
+    assert step["retry"] == {"automatic": [{"exit_status": 134, "limit": 1}]}
+
+    template = AMD_TEMPLATE.read_text(encoding="utf-8")
+    # Both grouped and top-level AMD steps must preserve an explicit retry
+    # policy when the source suite is rendered into the uploaded pipeline.
+    assert template.count("{% if step.retry %}") == 2
+    assert template.count("{% for retry_rule in step.retry.automatic %}") == 2
diff --git a/tests/buildkite/test_rocm_dockerfile.py b/tests/buildkite/test_rocm_dockerfile.py
index 9171b3d53..8101b2157 100644
--- a/tests/buildkite/test_rocm_dockerfile.py
+++ b/tests/buildkite/test_rocm_dockerfile.py
@@ -9,8 +9,10 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 AMD_TEMPLATE = REPO_ROOT / ".buildkite/amd/test-template-amd-omni.j2"
+AMD_BUILD_SCRIPT = REPO_ROOT / ".buildkite/amd/scripts/build-ci-image.sh"
 CI_DOCKERFILE = REPO_ROOT / "docker/Dockerfile.ci"
 ROCM_DOCKERFILE = REPO_ROOT / "docker/Dockerfile.rocm"
+ROCM_DOCKERIGNORE = REPO_ROOT / "docker/Dockerfile.rocm.dockerignore"
 
 
 def _docker_arg(path: Path, name: str) -> str:
@@ -42,16 +44,63 @@ def test_rocm_defaults_to_prebuilt_base_image() -> None:
     assert _docker_arg(ROCM_DOCKERFILE, "USE_NIGHTLY_BUILD") == "0"
 
 
-def test_amd_build_uses_rocm_dockerfile_defaults() -> None:
+def test_amd_build_uses_registry_cache() -> None:
     template = AMD_TEMPLATE.read_text(encoding="utf-8")
-    build_commands = [line.strip() for line in template.splitlines() if '"docker build ' in line]
+    script_command = '"bash .buildkite/amd/scripts/build-ci-image.sh"'
+    script = AMD_BUILD_SCRIPT.read_text(encoding="utf-8")
 
-    assert len(build_commands) == 1, f"expected one AMD image build command, found {len(build_commands)}"
-    build_command = build_commands[0]
-    assert "-f docker/Dockerfile.rocm" in build_command
+    assert template.count(script_command) == 1
+    assert "docker buildx build --push" in script
+    assert '--cache-from "type=registry,ref=${CACHE_REF}"' in script
+    assert '--cache-to "type=registry,ref=${CACHE_REF}' in script
+    assert "mode=max" in script
+
+
+def test_amd_cache_key_tracks_dependency_inputs_and_architecture() -> None:
+    script = AMD_BUILD_SCRIPT.read_text(encoding="utf-8")
+
+    for cache_input in (
+        "docker/Dockerfile.rocm",
+        "${DOCKERFILE}.dockerignore",
+        "pyproject.toml",
+        "setup.py",
+        "requirements",
+        "tools/install_torchcodec_rocm.sh",
+        "ROCM_ARCH",
+    ):
+        assert cache_input in script
+
+
+def test_amd_build_uses_rocm_dockerfile_defaults() -> None:
+    build_script = AMD_BUILD_SCRIPT.read_text(encoding="utf-8")
+
+    assert 'DOCKERFILE="docker/Dockerfile.rocm"' in build_script
     for arg_name in ("BASE_IMAGE", "USE_NIGHTLY_BUILD"):
-        assert f"--build-arg {arg_name}" not in build_command
-        assert f"--build-arg={arg_name}" not in build_command
+        assert f"--build-arg {arg_name}" not in build_script
+        assert f"--build-arg={arg_name}" not in build_script
+
+
+def test_rocm_source_copy_preserves_dependency_cache() -> None:
+    dockerfile = ROCM_DOCKERFILE.read_text(encoding="utf-8")
+    lines = dockerfile.splitlines()
+    source_copy_index = _line_index(lines, "COPY --link . .")
+    test_stage_index = _line_index(lines, "FROM base AS test")
+
+    assert "FROM deps AS base" in lines[:source_copy_index]
+    assert any('-e ".[dev]"' in line for line in lines[:source_copy_index])
+    assert not any(
+        line.startswith(("RUN ", "COPY ", "ADD ")) for line in lines[source_copy_index + 1 : test_stage_index]
+    )
+
+
+def test_rocm_build_context_excludes_git_history() -> None:
+    patterns = {
+        line.strip()
+        for line in ROCM_DOCKERIGNORE.read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.lstrip().startswith("#")
+    }
+
+    assert ".git" in patterns
 
 
 def test_rocm_source_ref_tracks_ci_vllm_release() -> None:
diff --git a/tests/config/composable_parallel/test_factory_integration.py b/tests/config/composable_parallel/test_factory_integration.py
index 468b3db2c..d49d32042 100644
--- a/tests/config/composable_parallel/test_factory_integration.py
+++ b/tests/config/composable_parallel/test_factory_integration.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Integration tests: strategy overlay on the real merge_pipeline_deploy seam."""
 
 from __future__ import annotations
@@ -20,6 +20,7 @@ from vllm_omni.config.composable_parallel import (
     apply_strategy_specs,
 )
 from vllm_omni.config.config_factory import StageConfigFactory
+from vllm_omni.config.omni_config import VllmOmniConfig
 from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
 from vllm_omni.config.stage_config import load_deploy_config, merge_pipeline_deploy
 
@@ -137,3 +138,31 @@ def test_cli_overrides_strategy_with_warning():
     assert _resolved(stages, "talker").runtime.num_replicas == 3
     # ...and the override was warned about, naming the conflicting field.
     assert any("num_replicas" in m and "overrides the strategy-derived" in m for m in messages)
+
+
+def test_typed_cli_overrides_strategy():
+    pipeline = OMNI_PIPELINES["qwen2_5_omni"]
+    config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=load_deploy_config(_DEPLOY),
+        cli_overrides={"stage_1_num_replicas": 3},
+        strategy_specs={"talker": [_stage_replica(2, "round_robin")]},
+    )
+
+    talker = next(stage for stage in config.stage_configs if stage.model_stage == "talker")
+    assert talker.runtime_config.num_replicas == 3
+    assert config.orchestrator_config.omni_lb_policy == "round-robin"
+    assert config.strategy_omni_lb_policy == "round-robin"
+
+
+def test_typed_tp_only_strategy_has_no_derived_lb_policy():
+    pipeline = OMNI_PIPELINES["qwen2_5_omni"]
+    config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=load_deploy_config(_DEPLOY),
+        cli_overrides={"omni_lb_policy": "round-robin"},
+        strategy_specs={"thinker": [_tp(1)]},
+    )
+
+    assert config.orchestrator_config.omni_lb_policy == "round-robin"
+    assert config.strategy_omni_lb_policy is None
diff --git a/tests/config/test_config_factory.py b/tests/config/test_config_factory.py
index c81a4b3b7..fdba7e90a 100644
--- a/tests/config/test_config_factory.py
+++ b/tests/config/test_config_factory.py
@@ -1429,6 +1429,9 @@ stages:
         assert deploy.async_chunk is True
         assert deploy.connectors is not None
         assert deploy.platforms is not None
+        connector = deploy.connectors["connector_of_shared_memory"]
+        assert "async_chunk_batch_min_size" not in connector["extra"]
+        assert "async_chunk_batch_max_wait_ms" not in connector["extra"]
 
     @pytest.mark.parametrize(
         ("hf_config", "model"),
@@ -2625,6 +2628,15 @@ class TestPlatformOverrides:
 
         assert stages[1].yaml_engine_args["dtype"] == dtype
 
+    def test_moss_tts_rocm_disables_codec_cudagraph(self):
+        deploy_path = Path(get_deploy_config_path("moss_tts.yaml"))
+
+        base = load_deploy_config(deploy_path)
+        assert base.stages[1].enforce_eager is False
+
+        rocm = _apply_platform_overrides(base, platform="rocm")
+        assert rocm.stages[1].enforce_eager is True
+
     def test_higgs_audio_v3_rocm_uses_triton_attention(self):
         deploy_path = Path(get_deploy_config_path("higgs_multimodal_qwen3.yaml"))
 
@@ -2688,6 +2700,63 @@ class TestPlatformOverrides:
             # Explicit null clears the inherited single-GPU 2 GiB CUDA cap.
             assert replica_stages[1].yaml_engine_args.get("kv_cache_memory_bytes") is None
 
+    def test_fish_speech_npu_uses_ascend_kv_block_size(self):
+        deploy_path = Path(get_deploy_config_path("fish_qwen3_omni.yaml"))
+
+        deploy = _apply_platform_overrides(load_deploy_config(deploy_path), platform="npu")
+
+        assert deploy.stages[0].engine_extras["block_size"] == 128
+
+    @pytest.mark.parametrize("platform", ["cuda", "npu"])
+    def test_recommended_native_runner_platform_defaults(self, platform):
+        filename, pipeline_key = "qwen3_tts_mrv2.yaml", "qwen3_tts"
+        deploy = load_deploy_config(Path(get_deploy_config_path(filename)))
+        deploy = _apply_platform_overrides(deploy, platform=platform)
+        expect_v2 = platform == "cuda"
+        assert deploy.model_runner == ("v2" if expect_v2 else "v1")
+
+        # The selection must reach the live worker-dispatch consumer, not just
+        # the transport-level DeployConfig field.
+        pipeline = resolve_pipeline_config(pipeline_key)
+        stages = merge_pipeline_deploy(pipeline, deploy)
+        assert [stage.yaml_engine_args["use_v2_model_runner"] for stage in stages] == [expect_v2] * len(stages)
+
+        if expect_v2 and pipeline.stages and deploy.async_chunk:
+            # v2 only engages the native plane on stages declaring support.
+            assert all(ps.supports_native_mrv2_data_plane for ps in pipeline.stages)
+
+    @pytest.mark.parametrize("runner,native", [("v1", False), ("v2", False), ("v2", True)])
+    def test_mrv2_undeclared_transport_warns(self, monkeypatch, runner, native):
+        from unittest.mock import Mock
+
+        warning = Mock()
+        monkeypatch.setattr("vllm_omni.config.stage_config.logger.warning", warning)
+        pipeline = PipelineConfig(
+            model_type="custom_pipeline",
+            stages=[
+                StagePipelineConfig(
+                    stage_id=0, model_stage="custom_ar", final_output=True, supports_native_mrv2_data_plane=native
+                )
+            ],
+        )
+        merge_pipeline_deploy(pipeline, DeployConfig(model_runner=runner))
+        assert warning.call_count == int(runner == "v2" and not native)
+        if warning.called:
+            assert "legacy transport path" in warning.call_args.args[0]
+
+    def test_runner_selection_rejects_engine_extras_override(self):
+        pipeline = PipelineConfig(
+            model_type="runner_selection_reserved",
+            stages=SINGLE_STAGE_PIPE_CFG,
+        )
+        for reserved in ("use_v2_model_runner", "supports_native_mrv2_data_plane"):
+            deploy = DeployConfig(
+                model_runner="v2",
+                stages=[StageDeployConfig(stage_id=0, engine_extras={reserved: False})],
+            )
+            with pytest.raises(ValueError, match=f"{reserved!r} must not be set"):
+                merge_pipeline_deploy(pipeline, deploy)
+
     def test_npu_overrides(self):
         deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
diff --git a/tests/config/test_endpoint_policy.py b/tests/config/test_endpoint_policy.py
index aeb1ffa51..fa42b80c7 100644
--- a/tests/config/test_endpoint_policy.py
+++ b/tests/config/test_endpoint_policy.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Tests for endpoint restrictions logic."""
 
 import pytest
@@ -44,6 +44,32 @@ def test_restricted_completions_returns_400():
     assert body["error"]["type"] == "BadRequestError"
 
 
+def test_restricted_image_edits_returns_400():
+    """Ensure pipelines can reject image edits independently of generation."""
+    app = FastAPI()
+
+    @app.post("/v1/images/edits")
+    async def existing_handler():
+        return {"ok": True}
+
+    @app.post("/v1/images/generations")
+    async def generations_handler():
+        return {"ok": True}
+
+    restrictions = (EndpointRestriction(OmniServingCapability.IMAGE_EDITS, REJECTION_REASON),)
+    shutdown_unsupported_routes(app, restrictions)
+
+    client = TestClient(app)
+    resp = client.post("/v1/images/edits")
+    assert resp.status_code == 400
+    assert resp.json()["error"]["message"] == REJECTION_REASON
+
+    # The restriction is endpoint-specific and must not remove generations.
+    resp = client.post("/v1/images/generations")
+    assert resp.status_code == 200
+    assert resp.json() == {"ok": True}
+
+
 def test_unrestricted_completions_not_blocked():
     """Ensure that if we don't shutdown any routes, the route stays."""
     app = _make_app_with_server_route()
diff --git a/tests/config/test_environment_variables.py b/tests/config/test_environment_variables.py
index b73062689..e1561dab8 100644
--- a/tests/config/test_environment_variables.py
+++ b/tests/config/test_environment_variables.py
@@ -164,11 +164,11 @@ def test_inventory_matches_reviewed_snapshot_counts():
     """Make an inventory expansion an explicit review decision."""
     category_counts = Counter(item.category for item in ENVIRONMENT_VARIABLE_INVENTORY.values())
     assert category_counts == {
-        EnvironmentVariableCategory.PUBLIC_OMNI: 28,
+        EnvironmentVariableCategory.PUBLIC_OMNI: 29,
         EnvironmentVariableCategory.INHERITED_VLLM: 20,
         EnvironmentVariableCategory.PLATFORM_EXTERNAL: 27,
-        EnvironmentVariableCategory.MODEL_SPECIFIC: 64,
-        EnvironmentVariableCategory.BENCHMARK_TRANSITIONAL: 20,
+        EnvironmentVariableCategory.MODEL_SPECIFIC: 57,
+        EnvironmentVariableCategory.BENCHMARK_TRANSITIONAL: 21,
         EnvironmentVariableCategory.INTERNAL: 2,
     }
 
@@ -178,11 +178,11 @@ def test_inventory_matches_reviewed_snapshot_counts():
         if item.category is EnvironmentVariableCategory.MODEL_SPECIFIC
     )
     assert {disposition: disposition_counts[disposition] for disposition in ModelEnvironmentVariableDisposition} == {
-        ModelEnvironmentVariableDisposition.PROMOTE: 38,
-        ModelEnvironmentVariableDisposition.REQUEST_SCOPE: 6,
+        ModelEnvironmentVariableDisposition.PROMOTE: 31,
+        ModelEnvironmentVariableDisposition.REQUEST_SCOPE: 5,
         ModelEnvironmentVariableDisposition.EXTERNAL: 0,
-        ModelEnvironmentVariableDisposition.INTERNALIZE: 15,
-        ModelEnvironmentVariableDisposition.DEPRECATE_REMOVE: 5,
+        ModelEnvironmentVariableDisposition.INTERNALIZE: 14,
+        ModelEnvironmentVariableDisposition.DEPRECATE_REMOVE: 7,
     }
 
 
diff --git a/tests/config/test_forced_aligner_injection.py b/tests/config/test_forced_aligner_injection.py
index 73a7bcda2..2037b22f1 100644
--- a/tests/config/test_forced_aligner_injection.py
+++ b/tests/config/test_forced_aligner_injection.py
@@ -1,11 +1,20 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import pytest
+from vllm.pooling_params import PoolingParams
 
 import vllm_omni.config.pipeline_registry  # noqa: F401  (populate registry)
+from vllm_omni.config.omni_config import VllmOmniConfig
 from vllm_omni.config.pipeline_registry import OMNI_PIPELINES as _PIPELINE_REGISTRY
 from vllm_omni.config.stage_config import (
     DeployConfig,
     StageExecutionType,
 )
+from vllm_omni.engine.stage_init_utils import (
+    build_engine_args_dict_from_omni_stage_config,
+    extract_stage_metadata_from_omni_stage_config,
+)
 from vllm_omni.model_executor.stage_input_processors.forced_aligner import (
     POOLING_OUTPUT_DECODER_PATH,
     TIMESTAMPS_MODALITY,
@@ -69,3 +78,55 @@ def test_inject_noop_without_forced_aligner():
 
     assert ext_pipeline is pipeline
     assert len(ext_deploy.stages) == 0
+
+
+@pytest.mark.parametrize("async_chunk", [True, False])
+@pytest.mark.parametrize("cli_async_chunk", [None, True, False])
+def test_aligner_uses_completed_audio_without_disabling_upstream_chunks(async_chunk, cli_async_chunk):
+    from vllm_omni.config.config_factory import StageConfigFactory
+
+    pipeline = _PIPELINE_REGISTRY["qwen3_tts"]
+    deploy = DeployConfig(async_chunk=async_chunk)
+    resolution = StageConfigFactory._resolve_legacy_from_registry(
+        pipeline,
+        {"forced_aligner": "/models/Qwen3-ForcedAligner-0.6B", "async_chunk": cli_async_chunk},
+        user_deploy_config=deploy,
+    )
+    stages = [stage.to_omegaconf() for stage in resolution.stage_configs]
+    expected_async = async_chunk if cli_async_chunk is None else cli_async_chunk
+    assert len(stages) == 3
+    assert [stage.engine_args.async_chunk for stage in stages] == [expected_async, expected_async, False]
+    assert stages[2].custom_process_input_func.endswith("code2wav2aligner")
+    assert stages[2].engine_args.runner == "pooling"
+    assert len(pipeline.stages) == 2
+    assert deploy.stages == []
+
+
+def test_injected_aligner_survives_typed_config_and_runtime_projections():
+    pipeline, deploy = inject_forced_aligner_stage(
+        _PIPELINE_REGISTRY["qwen3_tts"],
+        DeployConfig(),
+        {"forced_aligner": "/models/Qwen3-ForcedAligner-0.6B"},
+    )
+    config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=deploy,
+        cli_overrides={"model": "/models/Qwen3-TTS"},
+    )
+    stage = config.stage_configs[-1]
+
+    assert stage.pooling_config.runner == "pooling"
+    assert stage.pooling_config.pooling_output_decoder == POOLING_OUTPUT_DECODER_PATH
+    assert isinstance(stage.pooling_config.default_pooling_params, PoolingParams)
+    assert stage.pooling_config.default_pooling_params.task == deploy.stages[-1].default_pooling_params["task"]
+
+    metadata = extract_stage_metadata_from_omni_stage_config(stage)
+    assert isinstance(metadata.default_sampling_params, PoolingParams)
+    assert metadata.default_sampling_params.task == deploy.stages[-1].default_pooling_params["task"]
+
+    engine_args = build_engine_args_dict_from_omni_stage_config(
+        stage,
+        stage.model_config.model or "/models/Qwen3-ForcedAligner-0.6B",
+    )
+    assert engine_args["runner"] == "pooling"
+    assert engine_args["pooling_output_decoder"] == POOLING_OUTPUT_DECODER_PATH
diff --git a/tests/config/test_mammoth_moda2_shared_runtime.py b/tests/config/test_mammoth_moda2_shared_runtime.py
new file mode 100644
index 000000000..f5c11b2a5
--- /dev/null
+++ b/tests/config/test_mammoth_moda2_shared_runtime.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+
+from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.config.endpoint_policy import OmniServingCapability
+from vllm_omni.config.stage_config import StageExecutionType, load_deploy_config
+from vllm_omni.diffusion.registry import _DIFFUSION_MODELS
+from vllm_omni.model_executor.models.mammoth_moda2.pipeline import (
+    MAMMOTH_MODA2_AR_PIPELINE,
+    MAMMOTH_MODA2_PIPELINE,
+)
+from vllm_omni.model_executor.models.registry import _OMNI_MODELS
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_mammothmoda2_generation_stage_uses_shared_diffusion_runtime() -> None:
+    ar_stage, dit_stage = MAMMOTH_MODA2_PIPELINE.stages
+    assert ar_stage.execution_type is StageExecutionType.LLM_AR
+    assert dit_stage.execution_type is StageExecutionType.DIFFUSION
+    assert dit_stage.model_arch == "MammothModa2DiTPipeline"
+    assert dit_stage.custom_process_input_func.endswith(".ar2diffusion")
+    assert dit_stage.omni_kv_config == {"need_recv_cache": False}
+    assert dit_stage.input_sources == (0,)
+    assert dit_stage.final_output is True
+    assert dit_stage.final_output_type == "image"
+
+
+def test_mammothmoda2_dit_is_registered_only_with_diffusion_runtime() -> None:
+    assert _DIFFUSION_MODELS["MammothModa2DiTPipeline"] == (
+        "mammoth_moda2",
+        "pipeline_mammothmoda2_dit",
+        "MammothModa2DiTPipeline",
+    )
+    assert "MammothModa2DiTPipeline" not in _OMNI_MODELS
+
+
+def test_mammothmoda2_deploy_does_not_shadow_request_sampling_fields() -> None:
+    deploy = load_deploy_config(get_deploy_config_path("mammoth_moda2.yaml"))
+
+    assert deploy.stages[1].default_sampling_params is None
+
+
+def test_mammothmoda2_rejects_unsupported_image_edits() -> None:
+    restrictions = {
+        restriction.capability: restriction.reason for restriction in MAMMOTH_MODA2_PIPELINE.endpoint_restrictions
+    }
+
+    assert set(restrictions) == {OmniServingCapability.IMAGE_EDITS}
+    assert "img2img" in restrictions[OmniServingCapability.IMAGE_EDITS]
+    assert MAMMOTH_MODA2_AR_PIPELINE.endpoint_restrictions == ()
+
+
+def test_mammothmoda2_ar_only_topology_is_unchanged() -> None:
+    assert len(MAMMOTH_MODA2_AR_PIPELINE.stages) == 1
+    stage = MAMMOTH_MODA2_AR_PIPELINE.stages[0]
+    assert stage.execution_type is StageExecutionType.LLM_AR
+    assert stage.final_output_type == "text"
diff --git a/tests/config/test_omni_config.py b/tests/config/test_omni_config.py
index a8a2056b6..331717ba6 100644
--- a/tests/config/test_omni_config.py
+++ b/tests/config/test_omni_config.py
@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import warnings
 from dataclasses import fields
 from inspect import Parameter, signature
 from multiprocessing.reduction import ForkingPickler
@@ -11,6 +12,7 @@ from pathlib import Path
 
 import msgspec
 import pytest
+import torch
 from pydantic import ValidationError
 from pydantic.fields import FieldInfo
 from transformers import Qwen3OmniMoeConfig
@@ -23,6 +25,7 @@ from vllm.config import SchedulerConfig as VllmSchedulerConfig
 
 from tests.helpers.stage_config import get_deploy_config_path
 from vllm_omni.config import omni_config as omni_config_module
+from vllm_omni.config.config_factory import StageConfigFactory
 from vllm_omni.config.omni_config import (
     BaseVllmOmniStageConfig,
     OmniStageCacheConfig,
@@ -47,8 +50,10 @@ from vllm_omni.config.stage_config import (
     StageDeployConfig,
     StageExecutionType,
     StagePipelineConfig,
+    _apply_platform_overrides,
     load_deploy_config,
     merge_pipeline_deploy,
+    resolve_deploy_yaml,
 )
 from vllm_omni.diffusion.diffusion_kv.config import DiffusionKVCacheMode
 from vllm_omni.engine.stage_engine_startup import _serialize_stage_config
@@ -59,6 +64,24 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 _DEPLOY_DIR = Path(__file__).parents[2] / "vllm_omni" / "deploy"
 
 
+@pytest.mark.parametrize("async_chunk", [False, True])
+def test_native_kv_transfer_requires_completed_ar_stage(async_chunk):
+    from types import SimpleNamespace
+
+    pipeline = SimpleNamespace(stages=(), model_type="test")
+    deploy = DeployConfig(
+        async_chunk=async_chunk,
+        stages=[
+            StageDeployConfig(stage_id=0, engine_extras={"kv_transfer_config": {"kv_connector": "MooncakeConnector"}})
+        ],
+    )
+    if async_chunk:
+        with pytest.raises(ValueError, match="requires async_chunk=False"):
+            omni_config_module._validate_async_chunk_support(pipeline, deploy)
+    else:
+        omni_config_module._validate_async_chunk_support(pipeline, deploy)
+
+
 @pytest.fixture(autouse=True)
 def _stable_test_platform(monkeypatch):
     from vllm_omni import platforms
@@ -94,6 +117,20 @@ def _from_pipeline_key(
     )
 
 
+def test_mammothmoda2_diffusion_stage_projects_native_backend_config() -> None:
+    config = _from_pipeline_key(
+        "mammoth_moda2",
+        cli_overrides={"model": "/models/MammothModa2-Preview"},
+    )
+    stage = config.stage_by_id(1)
+    assert isinstance(stage, VllmOmniDiffusionStageConfig)
+    assert stage.diffusion_config.model_class_name == "MammothModa2DiTPipeline"
+    assert stage.diffusion_config.model == "/models/MammothModa2-Preview"
+    assert stage.diffusion_config.step_execution is False
+    assert stage.scheduler_config.max_num_seqs == 1
+    assert stage.connector_config.omni_kv_config == {"need_recv_cache": False}
+
+
 def test_minimax_h3_text_encoder_tp_targets_only_structured_stage_zero() -> None:
     config = _from_pipeline_key(
         "minimax_h3_disaggregated",
@@ -123,6 +160,42 @@ def test_non_duplex_deploy_keeps_model_session_capacity_at_one(tmp_path: Path) -
     assert [stage.model_config.session_mode for stage in omni_config.stage_configs] == ["turn", "turn"]
 
 
+def test_nested_stage_override_deep_merges_structured_model_config() -> None:
+    config = _from_pipeline_key(
+        "cosmos3_policy",
+        deploy_config_path=get_deploy_config_path("cosmos3_policy_droid.yaml"),
+        cli_overrides={"stage_0_model_config": {"guardrails": False}},
+    )
+
+    model_config = config.stage_by_id(0).diffusion_config.model_config
+    assert model_config["guardrails"] is False
+    assert model_config["policy_server_config"]["action_space"] == "joint_position"
+
+
+def _build_single_diffusion_config(
+    *,
+    cli_overrides: dict | None = None,
+    engine_extras: dict | None = None,
+) -> VllmOmniConfig:
+    pipeline = PipelineConfig(
+        model_type="diffusion-owner-test",
+        stages=(
+            StagePipelineConfig(
+                stage_id=0,
+                model_stage="diffusion",
+                execution_type=StageExecutionType.DIFFUSION,
+                final_output=True,
+            ),
+        ),
+    )
+    deploy_stages = [StageDeployConfig(stage_id=0, engine_extras=engine_extras)] if engine_extras is not None else []
+    return VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=DeployConfig(async_chunk=False, stages=deploy_stages),
+        cli_overrides=cli_overrides,
+    )
+
+
 @pytest.mark.parametrize("model_type", sorted(OMNI_PIPELINES))
 def test_vllm_omni_config_from_pipeline_config_matches_merge_pipeline_deploy(model_type: str):
     pipeline = _resolve_pipeline_or_skip(model_type)
@@ -219,7 +292,7 @@ def test_from_pipeline_config_normalizes_stage_engine_extras_without_expanding_s
 def test_frontend_log_stats_flag_is_not_an_unowned_stage_argument(disabled):
     from vllm_omni.engine.stage_init_utils import build_engine_args_dict_from_omni_stage_config
 
-    config = _from_pipeline_key("dots_tts", cli_overrides={"disable_log_stats": disabled})
+    config = _from_pipeline_key("voxcpm2", cli_overrides={"disable_log_stats": disabled})
     assert config.stage_configs
     engine_args = build_engine_args_dict_from_omni_stage_config(config.stage_by_id(0), model="test-model")
     assert "disable_log_stats" not in engine_args
@@ -242,6 +315,30 @@ def test_from_pipeline_config_applies_cli_overrides_without_stage_config_runtime
     assert stage1.runtime_config.num_gpus == stage1.parallel_config.world_size
 
 
+def test_diffusion_cli_parallel_overrides_beat_nested_deploy_parallel_config():
+    """Flat CLI parallel flags override the deploy YAML's nested parallel_config.
+
+    Regression for the NPU nightly failure (#7778): hunyuan_image3_dit.yaml's
+    platform section sets nested parallel_config.tensor_parallel_size=4 while
+    the perf tests pass --tensor-parallel-size 2. The flat CLI value must win,
+    mirroring StageConfig.to_omegaconf, or the stage demands more devices than
+    the machine has (tp=4 x usp=2 = 8 on a 4-card box).
+    """
+    omni_config = VllmOmniConfig.from_pipeline_config(
+        _resolve_pipeline_or_skip("hunyuan_image3_dit"),
+        user_deploy_config=DeployConfig(
+            stages=[StageDeployConfig(stage_id=0, engine_extras={"parallel_config": {"tensor_parallel_size": 4}})]
+        ),
+        cli_overrides={"tensor_parallel_size": 2, "ulysses_degree": 2},
+    )
+
+    stage = omni_config.stage_by_id(0)
+
+    assert stage.parallel_config.tensor_parallel_size == 2
+    assert stage.parallel_config.ulysses_degree == 2
+    assert stage.parallel_config.world_size == 4
+
+
 @pytest.mark.parametrize(
     "cli_overrides",
     [
@@ -424,7 +521,7 @@ def test_from_pipeline_config_normalizes_nested_parallel_config_aliases(field_na
     assert "data_parallel_master_ip" in stage.parallel_config._omni_explicit_fields
 
 
-def test_from_pipeline_config_accepts_diffusion_only_cli_fields_for_diffusion_stage():
+def test_from_pipeline_config_keeps_global_kv_cache_dtype_outside_diffusion_stage():
     stage = _from_pipeline_key(
         "dreamzero",
         deploy_config_path="dreamzero_tp1_cfg2",
@@ -432,11 +529,57 @@ def test_from_pipeline_config_accepts_diffusion_only_cli_fields_for_diffusion_st
     ).stage_by_id(0)
 
     assert isinstance(stage, VllmOmniDiffusionStageConfig)
-    assert stage.diffusion_config.diffusion_kv_cache_dtype == "fp8"
+    assert stage.diffusion_config.diffusion_kv_cache_dtype is None
 
 
 def test_stage_cli_field_selection_defers_ownership_validation_until_sources_are_merged():
-    assert omni_config_module._stage_cli_overrides(0, {"enable_lora": True}) == {"enable_lora": True}
+    assert omni_config_module._stage_cli_overrides(
+        0,
+        {"enable_lora": True},
+    ) == {"enable_lora": True}
+
+
+@pytest.mark.parametrize(
+    ("cli_overrides", "expected_dtype"),
+    [
+        ({}, torch.float32),
+        ({"dtype": None}, torch.float32),
+        ({"dtype": "float16"}, torch.float16),
+        ({"dtype": "auto"}, torch.bfloat16),
+        ({"stage_0_dtype": "bfloat16"}, torch.bfloat16),
+    ],
+)
+def test_diffusion_deploy_dtype_survives_unset_cli_overrides(cli_overrides, expected_dtype):
+    stage = _build_single_diffusion_config(
+        engine_extras={"dtype": "float32", "cache_backend": "tea_cache"},
+        cli_overrides=cli_overrides,
+    ).stage_by_id(0)
+
+    assert stage.diffusion_config.dtype == expected_dtype
+    assert stage.diffusion_config.cache_backend == "tea_cache"
+
+
+@pytest.mark.parametrize(
+    "coordination_kwargs",
+    [
+        {"omni_master_address": "127.0.0.1", "omni_master_port": 30000},
+        {"omni_dp_size_local": 2, "omni_heartbeat_timeout": 60.0, "omni_lb_policy": "random"},
+    ],
+)
+def test_diffusion_ingress_routes_coordination_fields_away(coordination_kwargs):
+    normalize = omni_config_module.normalize_and_validate_diffusion_engine_ingress_kwargs
+    assert normalize({**coordination_kwargs, "enable_sleep_mode": True}, stage_id=0) == {"enable_sleep_mode": True}
+    with pytest.raises(ValueError, match="omni_master_unknown_field"):
+        normalize({**coordination_kwargs, "omni_master_unknown_field": "unknown"}, stage_id=0)
+
+
+def test_diffusion_ingress_defers_defaults(monkeypatch):
+    monkeypatch.setenv("DIFFUSION_CACHE_BACKEND", "tea_cache")
+
+    assert omni_config_module.normalize_and_validate_diffusion_engine_ingress_kwargs({}, stage_id=0) == {}
+    assert omni_config_module.normalize_and_validate_diffusion_engine_ingress_kwargs(
+        {"dtype": None, "cache_backend": None}, stage_id=0
+    ) == {"dtype": None, "cache_backend": None}
 
 
 @pytest.mark.parametrize(
@@ -642,6 +785,67 @@ def test_joyai_code2wav_waits_for_full_payload():
     assert code2wav.model_config.requires_full_payload_input is True
 
 
+@pytest.mark.parametrize("model_runner", ["v1", "v2"])
+def test_deploy_model_runner_selection_propagates_to_every_stage(tmp_path: Path, model_runner: str):
+    deploy_path = tmp_path / "qwen3_tts_runner.yaml"
+    deploy_path.write_text(
+        f"""\
+pipeline: qwen3_tts
+model_runner: {model_runner}
+async_chunk: true
+stages:
+  - stage_id: 0
+  - stage_id: 1
+"""
+    )
+
+    deploy = load_deploy_config(deploy_path)
+    pipeline = _resolve_pipeline_or_skip("qwen3_tts")
+    legacy_stages = merge_pipeline_deploy(pipeline, deploy)
+    structured = _from_pipeline_key("qwen3_tts", deploy_config_path=str(deploy_path))
+    expect_v2 = model_runner == "v2"
+
+    assert deploy.model_runner == model_runner
+    assert all(stage.yaml_engine_args["use_v2_model_runner"] is expect_v2 for stage in legacy_stages)
+    assert all(stage.model_config.use_v2_model_runner is expect_v2 for stage in structured.stage_configs)
+
+
+@pytest.mark.parametrize("platform", ["npu", "xpu"])
+def test_mrv2_fails_fast_on_platforms_without_native_workers(platform: str):
+    with pytest.raises(NotImplementedError, match="Model Runner V2"):
+        _apply_platform_overrides(DeployConfig(model_runner="v2"), platform=platform)
+
+
+@pytest.mark.parametrize(
+    ("default_name", "mrv2_name"),
+    [
+        ("qwen3_tts.yaml", "qwen3_tts_mrv2.yaml"),
+        (
+            "qwen3_tts_high_concurrency.yaml",
+            "qwen3_tts_high_concurrency_mrv2.yaml",
+        ),
+    ],
+)
+def test_qwen3_mrv2_profiles_are_explicit_opt_in(default_name: str, mrv2_name: str):
+    assert load_deploy_config(_DEPLOY_DIR / default_name).model_runner == "v1"
+    assert load_deploy_config(_DEPLOY_DIR / mrv2_name).model_runner == "v2"
+
+
+def test_qwen3_tts_mrv2_retunes_do_not_change_default_mrv1_profile():
+    default = resolve_deploy_yaml(_DEPLOY_DIR / "qwen3_tts_high_concurrency.yaml")
+    mrv2 = resolve_deploy_yaml(_DEPLOY_DIR / "qwen3_tts_high_concurrency_mrv2.yaml")
+    default_extra = default["connectors"]["connector_of_shared_memory"]["extra"]
+    mrv2_extra = mrv2["connectors"]["connector_of_shared_memory"]["extra"]
+
+    # B2 batch stays consistent with the graph buckets; V1 profile untouched.
+    assert default_extra["decode_batch_max_size"] == 1
+    assert mrv2_extra["decode_batch_max_size"] == 2
+    assert mrv2_extra["decode_cudagraph_batch_sizes"] == [1, 2]
+    assert mrv2_extra["code_predictor_prefix_graphs"] is False
+    assert mrv2["stages"][1]["enforce_eager"] is False
+    assert default["stages"][1]["enforce_eager"] is True
+
+
 def test_vllm_omni_stage_config_public_fields_use_typed_stage_realizations():
     assert not hasattr(BaseVllmOmniStageConfig, "from_stage_config")
     assert not hasattr(BaseVllmOmniStageConfig, "to_legacy_stage_config")
@@ -654,6 +858,7 @@ def test_vllm_omni_stage_config_public_fields_use_typed_stage_realizations():
         "load_config",
         "cache_config",
         "scheduler_config",
+        "pooling_config",
         "connector_config",
         "runtime_config",
         "parallel_config",
@@ -737,9 +942,11 @@ def test_sub_config_fields_match_structured_scopes():
         "limit_mm_per_prompt",
         "interleave_mm_strings",
         "media_io_kwargs",
+        "final_output",
         "active_stream_window",
         "session_mode",
         "duplex_max_sessions",
+        "use_v2_model_runner",
         "enable_sleep_mode",
         "default_sampling_params",
         "subtalker_sampling_params",
@@ -748,6 +955,7 @@ def test_sub_config_fields_match_structured_scopes():
         "custom_voice_dir",
         "task_type",
         "codec_frame_rate_hz",
+        "supports_native_mrv2_data_plane",
         "enforce_eager",
         "max_cudagraph_capture_size",
         "enable_flashinfer_autotune",
@@ -797,6 +1005,7 @@ def test_sub_config_fields_match_structured_scopes():
     assert {f.name for f in fields(OmniStageConnectorConfig)} == {
         "async_chunk",
         "omni_kv_config",
+        "kv_transfer_config",
         "stage_connector",
         "output_connectors",
         "input_connectors",
@@ -889,6 +1098,17 @@ def test_structured_llm_stage_registration_payloads_remain_msgpack_transport_saf
         msgspec.msgpack.encode(payload)
 
 
+def test_structured_diffusion_torch_dtype_is_msgpack_transport_safe():
+    stage_config = _from_pipeline_key(
+        "hunyuan_image3_dit",
+        cli_overrides={"dtype": torch.bfloat16},
+    ).stage_by_id(0)
+
+    serialized = _serialize_stage_config(stage_config)
+    assert serialized["diffusion_config"]["dtype"] == "bfloat16"
+    msgspec.msgpack.encode(serialized)
+
+
 def test_diffusion_parallel_config_fields_cover_legacy_surface():
     from vllm_omni.diffusion.data import DiffusionParallelConfig
 
@@ -1352,18 +1572,19 @@ def test_diffusion_config_from_kwargs_reuses_legacy_normalization(monkeypatch):
     monkeypatch.setenv("DIFFUSION_CACHE_BACKEND", "TEA_CACHE")
     monkeypatch.setattr(current_omni_platform, "is_cuda", lambda: True)
 
-    cfg = omni_config_module._DiffusionConfigProjection.from_kwargs(
-        diffusion_attention_backend="flash_attn",
-        fa_deterministic=True,
-        kv_cache_dtype="fp8",
-        kv_cache_skip_steps="0-1",
-        kv_cache_skip_layers=[2],
-        static_lora_scale=0.25,
-        diffusion_kv_mode="paged_scheduler",
-        diffusion_kv_max_rows_per_request=2,
-        diffusers_load_kwargs=None,
-        diffusers_call_kwargs=None,
-    )
+    with pytest.warns(FutureWarning):
+        cfg = omni_config_module._DiffusionConfigProjection.from_kwargs(
+            diffusion_attention_backend="flash_attn",
+            fa_deterministic=True,
+            kv_cache_dtype="fp8",
+            kv_cache_skip_steps="0-1",
+            kv_cache_skip_layers=[2],
+            static_lora_scale=0.25,
+            diffusion_kv_mode="paged_scheduler",
+            diffusion_kv_max_rows_per_request=2,
+            diffusers_load_kwargs=None,
+            diffusers_call_kwargs=None,
+        )
 
     assert cfg.diffusion_attention_config.default.backend == "flash_attn"
     assert cfg.fa_deterministic is True
@@ -1400,47 +1621,6 @@ def test_diffusion_config_none_values_preserve_dataclass_defaults():
     assert config.enable_sleep_mode is False
 
 
-@pytest.mark.parametrize(
-    ("canonical_key", "alias_key", "canonical_value", "alias_value"),
-    [
-        ("lora_scale", "static_lora_scale", 0.75, 0.25),
-        (
-            "quantization_config",
-            "diffusion_quantization_config",
-            {"method": "canonical"},
-            {"method": "diffusion-alias"},
-        ),
-        (
-            "quantization_config",
-            "quantization",
-            {"method": "canonical"},
-            "legacy-alias",
-        ),
-        ("diffusion_kv_cache_dtype", "kv_cache_dtype", "fp8", "fp16"),
-        ("diffusion_kv_cache_skip_steps", "kv_cache_skip_steps", "0-1", "2-3"),
-        ("diffusion_kv_cache_skip_layers", "kv_cache_skip_layers", "1-2", "3-4"),
-        ("streaming_output", "diffusion_streaming_output", False, True),
-    ],
-)
-def test_diffusion_alias_conflicts_prefer_canonical_key(
-    canonical_key,
-    alias_key,
-    canonical_value,
-    alias_value,
-):
-    from vllm_omni.diffusion.data import normalize_omni_diffusion_kwargs
-
-    normalized = normalize_omni_diffusion_kwargs(
-        {
-            canonical_key: canonical_value,
-            alias_key: alias_value,
-        }
-    )
-
-    assert normalized[canonical_key] == canonical_value
-    assert alias_key not in normalized
-
-
 def test_from_pipeline_config_normalizes_diffusion_config_aliases_from_engine_args(tmp_path, monkeypatch):
     from vllm_omni.platforms import current_omni_platform
 
@@ -1465,10 +1645,11 @@ def test_from_pipeline_config_normalizes_diffusion_config_aliases_from_engine_ar
         )
     )
 
-    stage = _from_pipeline_key(
-        "dreamzero",
-        deploy_config_path=str(deploy_path),
-    ).stage_by_id(0)
+    with pytest.warns(FutureWarning):
+        stage = _from_pipeline_key(
+            "dreamzero",
+            deploy_config_path=str(deploy_path),
+        ).stage_by_id(0)
 
     assert isinstance(stage, VllmOmniDiffusionStageConfig)
     assert stage.diffusion_config.diffusion_attention_config.default.backend == "flash_attn"
@@ -1480,8 +1661,11 @@ def test_from_pipeline_config_normalizes_diffusion_config_aliases_from_engine_ar
     from vllm_omni.diffusion.data import OmniDiffusionConfig
     from vllm_omni.engine.stage_init_utils import build_engine_args_dict_from_omni_stage_config
 
-    engine_args = build_engine_args_dict_from_omni_stage_config(stage, model="test-model")
-    od_config = OmniDiffusionConfig.from_kwargs(**engine_args)
+    engine_args = build_engine_args_dict_from_omni_stage_config(stage, model=str(tmp_path))
+    diffusion_kwargs = omni_config_module.extract_diffusion_stage_config_kwargs(
+        engine_args, stage_id=stage.stage_id, include_engine_adapter_metadata=True
+    )
+    od_config = OmniDiffusionConfig.from_kwargs(**diffusion_kwargs)
     assert od_config.kv_transfer_config.engine_id == "dit-engine-1"
 
 
@@ -1634,10 +1818,8 @@ def test_video_output_transport_survives_stage_override_filtering() -> None:
 
 
 def test_video_output_transport_reaches_default_diffusion_stage() -> None:
-    from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
-
     transport = {"enable_device_postprocess": True}
-    stages = AsyncOmniEngine._create_default_diffusion_stage_cfg(
+    stages = StageConfigFactory.create_default_diffusion(
         {
             "model": "unused",
             "model_class_name": "UnknownPipeline",
@@ -1705,3 +1887,157 @@ def test_compact_offload_config_is_validated_during_projection():
                 "components": ["dit"],
             }
         )
+
+
+@pytest.mark.parametrize("pipeline_async", [True, False])
+@pytest.mark.parametrize("stage_async", [None, False, True])
+def test_stage_async_chunk_opt_out_matches_legacy_config(pipeline_async, stage_async):
+    pipeline = _resolve_pipeline_or_skip("qwen3_tts")
+    deploy = DeployConfig(
+        async_chunk=pipeline_async,
+        stages=[StageDeployConfig(stage_id=i, async_chunk=stage_async) for i in (0, 1)],
+    )
+    config = VllmOmniConfig.from_pipeline_config(pipeline, user_deploy_config=deploy)
+    legacy = merge_pipeline_deploy(pipeline, deploy)
+    expected = pipeline_async and stage_async is not False
+    assert config.stage_by_id(0).connector_config.async_chunk is expected
+    assert config.stage_by_id(1).connector_config.async_chunk is expected
+    assert legacy[1].yaml_engine_args["async_chunk"] is expected
+    assert config.stage_by_id(1).custom_process_input_func == legacy[1].custom_process_input_func
+    if not expected:
+        assert config.stage_by_id(1).custom_process_input_func.endswith("talker2code2wav_token_only")
+
+
+@pytest.mark.parametrize("disabled_stage", [0, 1])
+@pytest.mark.parametrize("builder", [merge_pipeline_deploy, VllmOmniConfig.from_pipeline_config])
+def test_async_chunk_rejects_mismatched_connector_edge(disabled_stage, builder):
+    pipeline = _resolve_pipeline_or_skip("qwen3_tts")
+    deploy = DeployConfig(
+        async_chunk=True,
+        stages=[StageDeployConfig(stage_id=disabled_stage, async_chunk=False)],
+    )
+    with pytest.raises(ValueError, match="incompatible async_chunk settings on connector edge 0 -> 1"):
+        if builder is merge_pipeline_deploy:
+            builder(pipeline, deploy)
+        else:
+            builder(pipeline, user_deploy_config=deploy)
+
+
+@pytest.mark.parametrize("explicit", [False, True])
+def test_diffusion_quantization_origin_survives_projection_and_transport(monkeypatch, explicit):
+    from vllm_omni.diffusion.data import OmniDiffusionConfig, TransformerConfig
+    from vllm_omni.quantization import build_quant_config
+
+    checkpoint = TransformerConfig.from_dict(
+        {
+            "quantization_config": {
+                "quant_method": "mxfp4",
+                "is_checkpoint_mxfp4_serialized": True,
+                "w4a8_fallback_steps": [37],
+            }
+        }
+    )
+    requested = build_quant_config("mxfp4", w4a8_fallback_steps=[]) if explicit else None
+    cfg = omni_config_module._DiffusionConfigProjection.from_kwargs(
+        tf_model_config=checkpoint,
+        quantization_config=requested,
+    )
+    assert cfg.quantization_config_is_auto_detected is not explicit
+    monkeypatch.setattr(OmniDiffusionConfig, "_resolve_master_port", lambda _self: 29500)
+    monkeypatch.setattr(OmniDiffusionConfig, "enrich_config", lambda self: self.set_tf_model_config(checkpoint))
+    cfg.enrich_config()
+    restored = ForkingPickler.loads(ForkingPickler.dumps(cfg))
+    assert restored.quantization_config_is_auto_detected is not explicit
+    assert restored.quantization_config.w4a8_fallback_steps == ([] if explicit else [37])
+
+
+@pytest.mark.parametrize(
+    "factory",
+    [
+        omni_config_module._DiffusionConfigProjection.from_kwargs,
+        pytest.param(
+            lambda **kwargs: __import__(
+                "vllm_omni.diffusion.data",
+                fromlist=["OmniDiffusionConfig"],
+            ).OmniDiffusionConfig.from_kwargs(**kwargs),
+            id="runtime-config",
+        ),
+    ],
+)
+def test_diffusion_config_entrypoints_reject_unknown_none(factory):
+    with pytest.raises((ValueError, ValidationError), match="enable_sleep_mod"):
+        factory(enable_sleep_mod=None)
+
+
+def test_diffusion_config_projection_rejects_unknown_none():
+    with pytest.raises(ValueError, match="enable_sleep_mod"):
+        omni_config_module._DiffusionConfigProjection.from_kwargs(enable_sleep_mod=None)
+
+
+def test_runtime_diffusion_config_rejects_unknown_none():
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+
+    with pytest.raises(ValueError, match="enable_sleep_mod"):
+        OmniDiffusionConfig.from_kwargs(enable_sleep_mod=None)
+
+
+def test_direct_diffusion_aliases_promote_none_and_reject_real_conflicts(monkeypatch):
+    from vllm_omni.diffusion import data as diffusion_data
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+
+    monkeypatch.setattr(diffusion_data, "build_quant_config", lambda config: config)
+    with pytest.warns(FutureWarning) as warnings:
+        config = OmniDiffusionConfig.from_kwargs(
+            quantization={"method": "example"},
+            quantization_config=None,
+            kv_cache_dtype="fp8",
+            diffusion_kv_cache_dtype=None,
+            enable_sleep_mode=False,
+            request_batch_max_wait_ms=0.0,
+        )
+
+    warning_messages = [str(warning.message) for warning in warnings]
+    assert any("quantization" in message for message in warning_messages)
+    assert any("kv_cache_dtype" in message for message in warning_messages)
+    assert config.quantization_config == {"method": "example"}
+    assert config.diffusion_kv_cache_dtype == "fp8"
+    assert config.enable_sleep_mode is False
+    assert config.request_batch_max_wait_ms == 0.0
+    with pytest.raises(ValueError, match=r"quantization.*quantization_config"):
+        OmniDiffusionConfig.from_kwargs(quantization="fp8", quantization_config={"method": "example"})
+
+
+def test_structured_diffusion_stage_rejects_unknown_engine_extra():
+    with pytest.raises(ValueError, match=r"stage 0.*enable_sleep_mod"):
+        _build_single_diffusion_config(engine_extras={"enable_sleep_mod": None})
+
+    with pytest.raises(ValueError, match=r"stage 0.*enable_sleep_mod"):
+        _build_single_diffusion_config(cli_overrides={"enable_sleep_mod": None})
+
+    with pytest.raises(ValueError, match=r"stage 0.*enable_sleep_mod"):
+        _build_single_diffusion_config(cli_overrides={"stage_0_enable_sleep_mod": None})
+
+    with pytest.raises(ValueError, match=r"no structured config owner: parallel_config\.unknown_field"):
+        _build_single_diffusion_config(engine_extras={"parallel_config": {"unknown_field": 1}})
+
+
+def test_structured_diffusion_stage_keeps_shared_globals_outside_diffusion():
+    with warnings.catch_warnings(record=True) as caught:
+        stage = _build_single_diffusion_config(
+            cli_overrides={"kv_cache_dtype": "fp8", "seed": 7},
+        ).stage_by_id(0)
+
+    assert stage.diffusion_config.diffusion_kv_cache_dtype is None
+    assert not any(issubclass(warning.category, FutureWarning) for warning in caught)
+
+
+@pytest.mark.parametrize(
+    ("field_name", "config_kwargs"),
+    [
+        ("seed", {"cli_overrides": {"stage_0_seed": None}}),
+        ("kv_cache_dtype", {"engine_extras": {"kv_cache_dtype": "fp8"}}),
+    ],
+)
+def test_structured_diffusion_stage_rejects_explicit_shared_engine_field(field_name, config_kwargs):
+    with pytest.raises(ValueError, match=rf"stage 0.*{field_name}"):
+        _build_single_diffusion_config(**config_kwargs)
diff --git a/tests/config/test_sleep_mode_deploy.py b/tests/config/test_sleep_mode_deploy.py
new file mode 100644
index 000000000..13040ebd9
--- /dev/null
+++ b/tests/config/test_sleep_mode_deploy.py
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Check the sleep/wake E2E topology before loading large BAGEL weights."""
+
+import pytest
+
+from tests.entrypoints.test_omni_sleep_mode import _sleep_deploy_config
+from vllm_omni.config.omni_config import (
+    VllmOmniConfig,
+    VllmOmniDiffusionStageConfig,
+    extract_diffusion_stage_config_kwargs,
+)
+from vllm_omni.config.pipeline_registry import resolve_pipeline_config
+from vllm_omni.config.stage_config import load_deploy_config
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.engine.stage_init_utils import build_engine_args_dict_from_omni_stage_config
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize("diffusion_only,tp_size", [(False, 1), (False, 2), (True, 2)])
+def test_sleep_deploy_resolves_expected_stages(diffusion_only, tp_size):
+    deploy = load_deploy_config(_sleep_deploy_config(diffusion_only=diffusion_only, tp_size=tp_size))
+    pipeline = resolve_pipeline_config(deploy.pipeline or "bagel")
+    config = VllmOmniConfig.from_pipeline_config(pipeline, user_deploy_config=deploy)
+
+    assert len(config.stage_configs) == (1 if diffusion_only else 2)
+    for stage in config.stage_configs:
+        is_diffusion = diffusion_only or stage.stage_id == 1
+        assert isinstance(stage, VllmOmniDiffusionStageConfig) == is_diffusion
+        # Keep BAGEL's batch budget: a single multimodal item needs 8625 tokens.
+        assert stage.scheduler_config.max_num_batched_tokens == 32768
+        assert stage.model_config.enable_sleep_mode is True
+        assert stage.parallel_config.tensor_parallel_size == tp_size
+        assert stage.runtime_config.devices == ",".join(str(stage.stage_id * tp_size + rank) for rank in range(tp_size))
+        if not is_diffusion:
+            assert stage.cache_config.gpu_memory_utilization == 0.8
+        if is_diffusion:
+            engine_args = build_engine_args_dict_from_omni_stage_config(stage, "test-bagel")
+            terminal = OmniDiffusionConfig.from_kwargs(
+                **extract_diffusion_stage_config_kwargs(
+                    engine_args, stage_id=stage.stage_id, include_engine_adapter_metadata=True
+                )
+            )
+            assert terminal.enable_sleep_mode is True
+            assert terminal.parallel_config.tensor_parallel_size == tp_size
+
+    if not diffusion_only:
+        assert config.stage_by_id(1).stage_pipeline_config.input_sources == (0,)
+        assert deploy.stages[1].input_connectors["from_stage_0"] == "shared_memory_connector"
diff --git a/tests/core/sched/test_generation_scheduler_restore.py b/tests/core/sched/test_generation_scheduler_restore.py
index 096471e5b..377d6265f 100644
--- a/tests/core/sched/test_generation_scheduler_restore.py
+++ b/tests/core/sched/test_generation_scheduler_restore.py
@@ -1,14 +1,22 @@
-"""Test that OmniGenerationScheduler restores chunk-waiting requests
-even when the OmniNewRequestData rewrapping fails.
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-Regression test: if process_pending_chunks() moves requests into
-internal deques but restore_queues() is not called due to an exception,
-those requests are permanently orphaned.
-"""
+"""Chunk-lifecycle coverage for OmniGenerationScheduler: restore on error,
+native terminal state, in-flight no-resubmission, slot release on finish,
+and single scheduling of a terminal empty-prompt chunk."""
 
 from collections import deque
+from types import SimpleNamespace
 
 import pytest
+import torch
+from vllm import SamplingParams
+from vllm.v1.core.sched.interface import PauseState
+from vllm.v1.core.sched.request_queue import SchedulingPolicy, create_request_queue
+from vllm.v1.request import Request, RequestStatus
+
+from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler, _has_async_chunk_payload_to_run
+from vllm_omni.engine.serialization import serialize_additional_information
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -20,16 +28,20 @@ class FakeAdapter:
         self.waiting_for_chunk_waiting_requests = deque()
         self.waiting_for_chunk_running_requests = deque()
         self.restore_called = False
+        self.done_request_ids = set()
 
-    def process_pending_chunks(self, waiting, running):
-        """Simulate moving requests out of the scheduler queues."""
-        # Move one request from running into internal deque
+    def process_pending_chunks(self, waiting, running, scheduler_requests=None):
         if running:
             req = running.pop()
             self.waiting_for_chunk_running_requests.append(req)
 
+    def is_done_receiving_chunks(self, request_id):
+        return request_id in self.done_request_ids
+
+    def collect_failed_send_request_ids(self):
+        return {}
+
     def restore_queues(self, waiting, running, scheduler_requests=None):
-        """Put requests back."""
         self.restore_called = True
         running.extend(self.waiting_for_chunk_running_requests)
         self.waiting_for_chunk_running_requests = deque()
@@ -38,6 +50,131 @@ class FakeAdapter:
         pass
 
 
+def _make_generation_scheduler(waiting_request, *, use_v2_model_runner=False):
+    scheduler = OmniGenerationScheduler.__new__(OmniGenerationScheduler)
+    scheduler.max_num_scheduled_tokens = 8
+    scheduler.max_num_running_reqs = 1
+    scheduler._pause_state = PauseState.UNPAUSED
+    scheduler.running = []
+    scheduler.waiting = create_request_queue(SchedulingPolicy.FCFS)
+    scheduler.waiting.add_request(waiting_request)
+    scheduler.skipped_waiting = create_request_queue(SchedulingPolicy.FCFS)
+    scheduler.requests = {waiting_request.request_id: waiting_request}
+    scheduler.policy = SchedulingPolicy.FCFS
+    scheduler.chunk_transfer_adapter = FakeAdapter()
+    scheduler.input_coordinator = None
+    scheduler.log_stats = False
+    scheduler.scheduler_config = SimpleNamespace(enable_chunked_prefill=True)
+    scheduler.num_lookahead_tokens = 0
+    scheduler.kv_cache_manager = SimpleNamespace(
+        new_step_starts=lambda: None,
+        allocate_slots=lambda *args, **kwargs: SimpleNamespace(get_block_ids=lambda: ([1],)),
+        get_num_common_prefix_blocks=lambda request_id: [0],
+        take_new_block_ids=lambda: None,
+    )
+    scheduler.kv_cache_config = SimpleNamespace(kv_cache_groups=[object()])
+    scheduler.use_v2_model_runner = use_v2_model_runner
+    scheduler._retains_state_across_chunks = False
+    scheduler.needs_kv_cache_zeroing = False
+    scheduler.finished_req_ids = set()
+    scheduler.encoder_cache_manager = SimpleNamespace(get_freed_mm_hashes=lambda: [])
+    scheduler.connector = None
+    scheduler.ec_connector = None
+    scheduler.prev_step_scheduled_req_ids = set()
+    scheduler._pending_finish_reqs = []
+    scheduler._consume_pending_connector_output = lambda model_mode: None
+    scheduler._process_pending_input_timeouts = lambda: None
+    scheduler._make_cached_request_data = lambda **kwargs: SimpleNamespace(
+        req_ids=[],
+        resumed_req_ids=[],
+        new_token_ids=[],
+        all_token_ids=[],
+        new_block_ids=[],
+        num_computed_tokens=[],
+        num_output_tokens=[],
+    )
+    scheduler._update_after_schedule = lambda output: None
+    scheduler._wrap_omni_scheduler_output = lambda output: output
+    return scheduler
+
+
+def _chunk_request(request_id, **kwargs):
+    defaults = dict(
+        request_id=request_id,
+        prompt_token_ids=[1],
+        num_computed_tokens=0,
+        num_in_flight_tokens=0,
+        status=None,
+        sampling_params=None,
+        pooling_params=None,
+        mm_features=None,
+        lora_request=None,
+        prompt_is_token_ids=True,
+        additional_information=None,
+        external_req_id=request_id,
+        prefill_stats=None,
+        record_event=lambda *args, **kwargs: None,
+    )
+    defaults.update(kwargs)
+    return SimpleNamespace(**defaults)
+
+
+def test_chunk_lifecycle_no_resubmit_and_state_survives_requeue(monkeypatch) -> None:
+    # Native plane: a completed payload without a new chunk is never executed
+    # again; requeued requests keep WAITING_FOR_CHUNK and their token counts.
+    scheduler = _make_generation_scheduler(_chunk_request("unused"))
+    monkeypatch.setattr("vllm_omni.core.sched.omni_generation_scheduler.create_request_queue", create_request_queue)
+    scheduler._native_data_plane = True
+    scheduler.chunk_transfer_adapter = None
+    scheduler.input_coordinator = SimpleNamespace(finished_requests=set(), restore_queues=lambda *args, **kwargs: None)
+    scheduler.running = []
+    scheduler.waiting = create_request_queue(scheduler.policy)
+    scheduler.skipped_waiting = create_request_queue(scheduler.policy)
+
+    completed = Request("completed", [1, 2], SamplingParams(max_tokens=4), pooling_params=None)
+    completed.status = RequestStatus.RUNNING
+    completed.num_computed_tokens = 2
+    scheduler.running = [completed]
+    scheduler.requests = {"completed": completed}
+    scheduler.input_coordinator.finished_requests.add("completed")  # terminal payload, no new chunk
+
+    assert scheduler._is_done_receiving_chunks("completed")
+    assert not scheduler._is_done_receiving_chunks("unknown")
+    output = scheduler.schedule()
+    assert not output.num_scheduled_tokens
+    assert scheduler._pending_finish_reqs == [completed]
+
+    completed.status = RequestStatus.WAITING_FOR_CHUNK
+    scheduler._pending_finish_reqs = []
+    scheduler._requeue_completed_native_chunks()
+    assert completed.status == RequestStatus.WAITING_FOR_CHUNK
+    assert completed.num_computed_tokens == 2
+    assert not scheduler.running
+
+
+def test_generation_scheduler_schedules_terminal_empty_prompt_chunk_once(monkeypatch: pytest.MonkeyPatch) -> None:
+    waiting = _chunk_request(
+        "terminal",
+        prompt_token_ids=[],
+        num_prompt_tokens=0,
+        additional_information=serialize_additional_information(
+            {"codes": {"audio": torch.tensor([[1, 2, 3]], dtype=torch.long)}}
+        ),
+    )
+    scheduler = _make_generation_scheduler(waiting)
+    scheduler.chunk_transfer_adapter.done_request_ids.add("terminal")
+    scheduler.requests = {"terminal": waiting}
+    assert _has_async_chunk_payload_to_run(waiting)
+    # A terminal codec request with an empty prompt is still scheduled exactly once.
+    monkeypatch.setattr("vllm_omni.core.sched.omni_generation_scheduler.create_request_queue", create_request_queue)
+
+    output = OmniGenerationScheduler.schedule(scheduler)
+
+    assert output.num_scheduled_tokens == {"terminal": 1}
+    assert output.scheduled_new_reqs[0].req_id == "terminal"
+    assert scheduler._pending_finish_reqs == []
+
+
 class TestRestoreQueuesOnError:
     """Verify that restore_queues is called even when rewrapping raises."""
 
diff --git a/tests/core/sched/test_omni_ar_scheduler_aborted_queue_sweep.py b/tests/core/sched/test_omni_ar_scheduler_aborted_queue_sweep.py
index d9fbc452b..f8b9d9b4c 100644
--- a/tests/core/sched/test_omni_ar_scheduler_aborted_queue_sweep.py
+++ b/tests/core/sched/test_omni_ar_scheduler_aborted_queue_sweep.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Tests for ``OmniARScheduler._drop_aborted_queued_requests``.
 
 ``schedule()`` sweeps ``FINISHED_ABORTED`` requests out of the queues before
@@ -68,6 +71,7 @@ def test_schedule_sweeps_skipped_waiting_before_upstream_selection(
     aborted = _StubRequest("req-aborted", RequestStatus.FINISHED_ABORTED)
     scheduler = _make_scheduler(policy, skipped_waiting=[aborted])
     scheduler.chunk_transfer_adapter = None
+    scheduler.max_num_running_reqs = 8
     scheduler.input_coordinator = None
     scheduler.num_waiting_for_streaming_input = 0
     scheduler._process_pending_omni_inputs = lambda model_mode: None
diff --git a/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py b/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py
index 73c71fd63..8bc63795f 100644
--- a/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py
+++ b/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py
@@ -7,6 +7,7 @@ window fills with stale entries after K completions.
 
 from __future__ import annotations
 
+from types import SimpleNamespace
 from unittest.mock import MagicMock
 
 import pytest
@@ -15,6 +16,7 @@ import pytest
 # Request / RequestStatus are bound in this module. Ruff isort would reorder them.
 # isort: off
 import vllm_omni  # noqa: F401 - import for side effects (patch vLLM)
+from vllm.v1.request import RequestStatus
 from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
 
 # isort: on
@@ -72,3 +74,85 @@ def test_free_request_is_safe_without_a_chunk_transfer_adapter():
     sched._free_request(request)  # must not raise
 
     sched._free_input_coordinator_request.assert_called_once_with("req-1")
+
+
+def test_native_mooncake_finish_uses_confirmed_token_boundary() -> None:
+    sched = _make_scheduler(chunk_transfer_adapter=None)
+    sched.vllm_config = SimpleNamespace(kv_transfer_config=SimpleNamespace(kv_connector="MooncakeConnector"))
+    observed = {}
+
+    def connector_finished(request):
+        observed["status"] = request.status
+        observed["num_computed_tokens"] = request.num_computed_tokens
+        return True, None
+
+    sched._connector_finished = connector_finished
+    request = _make_finished_request("req-native")
+    request.client_index = 0
+    request.status = RequestStatus.FINISHED_STOPPED
+    request.kv_transfer_params = {
+        "do_remote_decode": True,
+        "transfer_id": "xfer-req-native",
+    }
+    request.num_computed_tokens = 13
+    request.num_output_placeholders = 1
+    request.num_prompt_tokens = 10
+
+    kv_params, _ = sched._free_request(request)
+
+    assert observed == {
+        "status": RequestStatus.FINISHED_LENGTH_CAPPED,
+        "num_computed_tokens": 12,
+    }
+    assert request.status == RequestStatus.FINISHED_STOPPED
+    assert request.num_computed_tokens == 13
+    assert kv_params == {
+        "transfer_id": "xfer-req-native",
+        "num_transfer_tokens": 12,
+    }
+
+
+def test_native_mooncake_recycles_ar_pages_in_physical_order() -> None:
+    sched = OmniARScheduler.__new__(OmniARScheduler)
+    sched.vllm_config = SimpleNamespace(kv_transfer_config=SimpleNamespace(kv_connector="MooncakeConnector"))
+    blocks = [SimpleNamespace(block_id=7), SimpleNamespace(block_id=2), SimpleNamespace(block_id=4)]
+    sched.kv_cache_manager = SimpleNamespace(
+        enable_caching=False,
+        pop_blocks_for_free=MagicMock(return_value=blocks),
+        block_pool=SimpleNamespace(free_blocks=MagicMock()),
+    )
+    sched.defer_block_free = False
+    sched.processed_step_seq = 3
+    request = SimpleNamespace(last_sched_seq=3)
+
+    sched._free_request_blocks(request)
+
+    sched.kv_cache_manager.block_pool.free_blocks.assert_called_once()
+    freed = sched.kv_cache_manager.block_pool.free_blocks.call_args.args[0]
+    assert [block.block_id for block in freed] == [2, 4, 7]
+
+
+def test_native_mooncake_deferred_ar_pages_drain_in_physical_order() -> None:
+    from collections import deque
+
+    sched = OmniARScheduler.__new__(OmniARScheduler)
+    sched.vllm_config = SimpleNamespace(kv_transfer_config=SimpleNamespace(kv_connector="MooncakeConnector"))
+    blocks = [SimpleNamespace(block_id=7), SimpleNamespace(block_id=2), SimpleNamespace(block_id=4)]
+    sched.kv_cache_manager = SimpleNamespace(
+        enable_caching=False,
+        pop_blocks_for_free=MagicMock(return_value=blocks),
+        block_pool=SimpleNamespace(free_blocks=MagicMock()),
+    )
+    sched.defer_block_free = True
+    sched.processed_step_seq = 2
+    sched.sched_step_seq = 3
+    sched.deferred_frees = deque()
+    request = SimpleNamespace(last_sched_seq=3)
+
+    sched._free_request_blocks(request)
+    assert [block.block_id for block in sched.deferred_frees[0][1]] == [7, 4, 2]
+
+    sched.processed_step_seq = 3
+    sched._drain_deferred_frees()
+    freed = list(sched.kv_cache_manager.block_pool.free_blocks.call_args.args[0])
+    assert [block.block_id for block in freed] == [2, 4, 7]
diff --git a/tests/core/sched/test_omni_ar_scheduler_logprobs.py b/tests/core/sched/test_omni_ar_scheduler_logprobs.py
index 810c506c7..13594b3bd 100644
--- a/tests/core/sched/test_omni_ar_scheduler_logprobs.py
+++ b/tests/core/sched/test_omni_ar_scheduler_logprobs.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Tests for the AR sampled-token logprob contract."""
 
 from __future__ import annotations
@@ -93,6 +96,7 @@ class _Request:
         self.num_computed_tokens = 0
         self.num_in_flight_tokens = 0
         self.num_output_placeholders = 0
+        self.output_token_ids: list[int] = []
         # vLLM 0.27 (a0c092ee72): Request gained num_stale_output_tokens to
         # track in-flight outputs discarded at preemption/streaming-stop.
         self.num_stale_output_tokens = 0
@@ -145,6 +149,14 @@ def _make_scheduler_stub(requests: list[_Request]) -> SimpleNamespace:
         kv_cache_manager=SimpleNamespace(take_events=lambda: None),
         kv_event_publisher=SimpleNamespace(publish=lambda _events: None),
         recompute_kv_load_failures=False,
+        _native_data_plane=False,
+        vllm_config=SimpleNamespace(
+            model_config=SimpleNamespace(
+                use_v2_model_runner=False,
+                async_chunk=False,
+                final_output=True,
+            )
+        ),
     )
     for name in _MIXIN_UPDATE_HELPERS:
         setattr(scheduler, name, MethodType(getattr(OmniSchedulerMixin, name), scheduler))
@@ -167,10 +179,15 @@ def _bind_request_lifecycle(
         scheduler.requests.pop(request.request_id, None)
         scheduler.finished_req_ids.add(request.request_id)
         scheduler.finished_req_ids_dict[request.client_index].add(request.request_id)
-        # vLLM 0.26 contract: (kv_xfer_params, ec_xfer_params)
+        # Current vLLM contract: (kv_xfer_params, ec_xfer_params)
         return None, None
 
-    scheduler._update_request_with_output = update_request
+    def update_with_history(request, token_ids):
+        accepted, stopped = update_request(request, token_ids)
+        request.output_token_ids.extend(accepted)
+        return accepted, stopped
+
+    scheduler._update_request_with_output = update_with_history
     scheduler._process_kv_transfer_trigger = lambda _request, _tokens: False
     scheduler._handle_stopped_request = handle_stopped or (lambda _request: True)
     scheduler._free_request = free_request
@@ -219,6 +236,7 @@ def test_mid_step_stop_trims_logprob_rows_with_token_ids() -> None:
     (output,) = outputs[0].outputs
 
     assert output.new_token_ids == [7]
+    assert output.num_generation_tokens == 1
     assert output.finish_reason is FinishReason.STOP
     token_rows = np.asarray(output.new_logprobs.logprob_token_ids)
     value_rows = np.asarray(output.new_logprobs.logprobs)
diff --git a/tests/core/sched/test_omni_ar_scheduler_output_policy.py b/tests/core/sched/test_omni_ar_scheduler_output_policy.py
new file mode 100644
index 000000000..89c08bf38
--- /dev/null
+++ b/tests/core/sched/test_omni_ar_scheduler_output_policy.py
@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.core.sched.omni_ar_scheduler import _should_emit_engine_output
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    ("async_chunk", "final_output", "use_v2", "stopped", "has_control", "expected"),
+    [
+        (True, False, True, False, False, False),  # async+v2 suppresses data
+        (True, False, False, False, False, True),  # v1 continues to emit
+        (True, False, True, True, False, True),  # stopped always emits
+        (True, False, True, False, True, True),  # control-only still emits
+    ],
+)
+def test_async_chunk_intermediate_stage_emits_only_control_outputs(
+    async_chunk: bool,
+    final_output: bool,
+    use_v2: bool,
+    stopped: bool,
+    has_control: bool,
+    expected: bool,
+) -> None:
+    model_config = SimpleNamespace(
+        async_chunk=async_chunk,
+        final_output=final_output,
+        use_v2_model_runner=use_v2,
+    )
+
+    assert (
+        _should_emit_engine_output(
+            model_config,
+            stopped=stopped,
+            has_control=has_control,
+        )
+        is expected
+    )
diff --git a/tests/core/sched/test_omni_ar_scheduler_streaming.py b/tests/core/sched/test_omni_ar_scheduler_streaming.py
index 154644fb2..83c7038f2 100644
--- a/tests/core/sched/test_omni_ar_scheduler_streaming.py
+++ b/tests/core/sched/test_omni_ar_scheduler_streaming.py
@@ -17,6 +17,7 @@ import pytest
 import vllm_omni  # noqa: F401 - import for side effects (patch vLLM)
 from vllm.sampling_params import SamplingParams
 from vllm.v1.core.sched.output import SchedulerOutput
+from vllm.v1.core.sched.scheduler import Scheduler as VLLMScheduler
 from vllm.v1.outputs import ModelRunnerOutput
 from vllm.v1.engine import FinishReason
 from vllm.v1.core.sched.request_queue import SchedulingPolicy, create_request_queue
@@ -1261,3 +1262,47 @@ def test_context_overflow_emits_an_error_output_with_the_reason() -> None:
 
     sched._emit_streaming_context_overflow_outputs(outputs)
     assert len(outputs[2]) == 1
+
+
+@pytest.mark.parametrize("native", [True, False])
+def test_async_chunk_reserves_parked_slots_during_ar_admission(monkeypatch, native) -> None:
+    sched = _make_scheduler(stage_id=1)
+    parked = SimpleNamespace(request_id="parked")
+    sched.requests = {"parked": parked}
+    sched.waiting = []
+    sched.running = []
+    sched._native_data_plane = native
+    sched.use_v2_model_runner = native
+    sched.max_num_running_reqs = 8
+    sched.input_coordinator = (
+        SimpleNamespace(_waiting_for_chunk_running=[parked], restore_queues=lambda _w, _r: None) if native else None
+    )
+    sched.chunk_transfer_adapter = (
+        None
+        if native
+        else SimpleNamespace(
+            waiting_for_chunk_running_requests=[parked],
+            _held_non_active=[],
+            process_pending_chunks=lambda *_a, **_kw: None,
+            collect_failed_send_request_ids=lambda: {},
+            restore_queues=lambda *_a, **_kw: None,
+            postprocess_scheduler_output=lambda *_a, **_kw: None,
+        )
+    )
+    sched._consume_pending_connector_output = lambda model_mode: None
+    sched._process_pending_input_timeouts = lambda: None
+    sched._should_defer_waiting_admission = lambda: False
+    sched.get_finished_requests_needing_kv_transfer = lambda: {}
+    sched._wrap_omni_scheduler_output = lambda output, **_kwargs: output
+    observed_limits: list[int] = []
+
+    def fake_schedule(self, _throttle_prefills=False):
+        observed_limits.append(self.max_num_running_reqs)
+        return SimpleNamespace(scheduled_new_reqs=[])
+
+    monkeypatch.setattr(VLLMScheduler, "schedule", fake_schedule)
+
+    sched.schedule()
+
+    assert observed_limits == [7 if native else 8]
+    assert sched.max_num_running_reqs == 8
diff --git a/tests/core/sched/test_omni_ar_scheduler_unified_decode_deferral.py b/tests/core/sched/test_omni_ar_scheduler_unified_decode_deferral.py
index 0e0ed04ad..de68f7d5a 100644
--- a/tests/core/sched/test_omni_ar_scheduler_unified_decode_deferral.py
+++ b/tests/core/sched/test_omni_ar_scheduler_unified_decode_deferral.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from __future__ import annotations
 
 from types import SimpleNamespace
@@ -141,6 +144,7 @@ def test_voxcpm2_unified_decode_graph_does_not_defer_without_cuda_graph(monkeypa
 
 def test_unified_decode_graph_deferral_restores_waiting_queue(monkeypatch) -> None:
     scheduler = _make_scheduler()
+    scheduler.max_num_running_reqs = 8
     scheduler.running = [_MockRequest("decode")]
     original_waiting_req = _MockRequest("waiting", status=RequestStatus.WAITING)
     deferred_by_upstream = _MockRequest("deferred-by-upstream", status=RequestStatus.WAITING)
diff --git a/tests/core/sched/test_omni_sched_deferred_free_fence.py b/tests/core/sched/test_omni_sched_deferred_free_fence.py
index 36b084f7c..9088c6bc2 100644
--- a/tests/core/sched/test_omni_sched_deferred_free_fence.py
+++ b/tests/core/sched/test_omni_sched_deferred_free_fence.py
@@ -123,6 +123,9 @@ def _make_fast_path_sched(*, defer_block_free: bool) -> tuple[MagicMock, Request
 
     sched = MagicMock()
     sched.max_num_scheduled_tokens = 8
+    sched.max_num_running_reqs = 8
+    sched._native_data_plane = False
+    sched._retains_state_across_chunks = False
     sched._pause_state = PauseState.UNPAUSED
     sched.requests = {request.request_id: request}
     sched.running = [request]
diff --git a/tests/core/sched/test_omni_scheduler_mixin_shared.py b/tests/core/sched/test_omni_scheduler_mixin_shared.py
index bb9fd8859..ba4b2454c 100644
--- a/tests/core/sched/test_omni_scheduler_mixin_shared.py
+++ b/tests/core/sched/test_omni_scheduler_mixin_shared.py
@@ -1,5 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from collections import defaultdict
 from types import SimpleNamespace
+from typing import Any
 
 import pytest
 from vllm.v1.engine import FinishReason
@@ -87,7 +91,7 @@ def test_full_payload_coordinator_matches_legacy_gate(monkeypatch, stage_id, asy
 
 
 def test_schedule_lifecycle_helpers_process_and_restore_both_input_paths():
-    calls = []
+    calls: list[tuple[Any, ...]] = []
     scheduler = _Scheduler()
     scheduler.waiting = ["waiting"]
     scheduler.running = ["running"]
@@ -115,7 +119,7 @@ def test_schedule_lifecycle_helpers_process_and_restore_both_input_paths():
         collect_failed_send_request_ids=_collect_failed_sends,
     )
     scheduler.input_coordinator = SimpleNamespace(
-        restore_queues=lambda waiting: calls.append(("restore-full", waiting))
+        restore_queues=lambda waiting, running: calls.append(("restore-full", waiting, running))
     )
 
     scheduler._process_pending_omni_inputs("ar")
@@ -130,7 +134,7 @@ def test_schedule_lifecycle_helpers_process_and_restore_both_input_paths():
         ("chunk-timeouts", omni_scheduler_mixin.DEFAULT_INPUT_WAIT_TIMEOUT_S),
         ("failed-sends",),
         ("restore-chunks", scheduler.waiting, scheduler.running, scheduler.requests),
-        ("restore-full", scheduler.waiting),
+        ("restore-full", scheduler.waiting, scheduler.running),
     ]
 
 
diff --git a/tests/core/sched/test_omni_scheduler_ready_inbox.py b/tests/core/sched/test_omni_scheduler_ready_inbox.py
new file mode 100644
index 000000000..483255f21
--- /dev/null
+++ b/tests/core/sched/test_omni_scheduler_ready_inbox.py
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Drain ready events once, merging live requests and filtering cancellations."""
+
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
+from vllm_omni.outputs import OmniConnectorOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_ready_inbox_coalesces_live_events_and_drops_cancelled(mocker):
+    scheduler = OmniSchedulerMixin()
+    scheduler.requests, scheduler.waiting, scheduler.running = {"r": object()}, [], []
+    coordinator = SimpleNamespace(
+        _async_chunk=True, update_request_metadata=mocker.Mock(), process_pending_chunks=mocker.Mock()
+    )
+    scheduler.input_coordinator = coordinator
+    scheduler._init_omni_connector_output_inbox()
+    scheduler.enqueue_omni_connector_output(OmniConnectorOutput(chunk_ready_req_ids={"r"}))
+    scheduler.enqueue_omni_connector_output(
+        OmniConnectorOutput(
+            chunk_ready_req_ids={"r", "aborted"},
+            chunk_finished_req_ids={"r", "aborted"},
+            request_metadata={"r": {"decode_token_end": 2}, "aborted": {"decode_token_end": 99}},
+        )
+    )
+    scheduler._consume_pending_connector_output(model_mode="ar")
+    coordinator.update_request_metadata.assert_called_once_with(
+        scheduler.requests, {"r": {"decode_token_end": 2}}, model_mode="ar"
+    )
+    coordinator.process_pending_chunks.assert_called_once_with([], [], {"r"}, {"r"})
+    scheduler._consume_pending_connector_output(model_mode="ar")
+    assert coordinator.update_request_metadata.call_count == 1
+    coordinator.process_pending_chunks.assert_called_with([], [], set(), set())
diff --git a/tests/core/sched/test_omni_scheduler_streaming_input_counter.py b/tests/core/sched/test_omni_scheduler_streaming_input_counter.py
index 6f44aadac..bc392abca 100644
--- a/tests/core/sched/test_omni_scheduler_streaming_input_counter.py
+++ b/tests/core/sched/test_omni_scheduler_streaming_input_counter.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Tests for the ``num_waiting_for_streaming_input`` resync placed in
 ``OmniARScheduler.finish_requests`` / ``OmniGenerationScheduler.finish_requests``
 and in ``OmniARScheduler.schedule``.
@@ -128,6 +131,7 @@ def test_ar_schedule_resyncs_before_delegating_upstream(monkeypatch: pytest.Monk
     scheduler.skipped_waiting = []
     scheduler.num_waiting_for_streaming_input = 1  # leaked by the status rewrite
     scheduler.policy = "fcfs"
+    scheduler.max_num_running_reqs = 8
 
     seen: dict[str, int] = {}
 
diff --git a/tests/core/sched/test_omni_scheduling_coordinator.py b/tests/core/sched/test_omni_scheduling_coordinator.py
index f37aac29f..8a62cbbfd 100644
--- a/tests/core/sched/test_omni_scheduling_coordinator.py
+++ b/tests/core/sched/test_omni_scheduling_coordinator.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for OmniSchedulingCoordinator.
 
 These tests use mock request objects and mock queues.  They do not require
@@ -20,7 +20,9 @@ import torch
 import vllm_omni.core.sched.omni_scheduling_coordinator as coord_mod
 from vllm_omni.core.sched.omni_scheduling_coordinator import (
     OmniSchedulingCoordinator,
+    uses_native_mrv2_data_plane,
 )
+from vllm_omni.core.sched.output import OmniChunkRecvHandle
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -56,6 +58,7 @@ def _make_request(req_id: str, status: str = "waiting") -> SimpleNamespace:
         prompt_token_ids=[],
         num_prompt_tokens=0,
         num_computed_tokens=0,
+        num_output_placeholders=0,
         _all_token_ids=[],
         _output_token_ids=[],
         payload_sender_info=None,
@@ -83,7 +86,7 @@ class MockQueue:
     def prepend_requests(self, requests):
         self._items = list(requests) + self._items
 
-    def remove(self, request):
+    def remove_request(self, request):
         self._items.remove(request)
 
     def remove_requests(self, requests):
@@ -96,7 +99,47 @@ class MockQueue:
 # ------------------------------------------------------------------ #
 
 
-class TestCoordinatorUpdateRequestMetadata(unittest.TestCase):
+class TestNativeMRV2DataPlaneSelection(unittest.TestCase):
+    def test_native_plane_requires_v2_and_async_chunk_capability(self):
+        native = SimpleNamespace(async_chunk=True, supports_native_mrv2_data_plane=True)
+
+        self.assertTrue(uses_native_mrv2_data_plane(native, use_v2_model_runner=True))
+        self.assertFalse(uses_native_mrv2_data_plane(native, use_v2_model_runner=False))
+        self.assertFalse(uses_native_mrv2_data_plane(SimpleNamespace(async_chunk=False), use_v2_model_runner=True))
+
+
+def test_chunk_registration_ready_and_terminal_lifecycle():
+    coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1, async_chunk=True)
+    req = _make_request("internal", status=RequestStatus.WAITING)
+    req.external_req_id = "external"
+    waiting = MockQueue([req])
+    coord.process_pending_chunks(waiting, [], set(), set())
+    assert req.status == RequestStatus.WAITING_FOR_CHUNK
+    [handle] = coord.pending_chunk_registrations
+    assert isinstance(handle, OmniChunkRecvHandle)
+    assert (handle.request_id, handle.external_req_id) == ("internal", "external")
+    coord.restore_queues(waiting, [])
+    coord.process_pending_chunks(waiting, [], {"internal"}, set())
+    assert req.status == RequestStatus.WAITING
+    assert "internal" in coord.requests_with_ready_chunks
+    req.status = RequestStatus.WAITING_FOR_CHUNK
+    coord.process_pending_chunks(waiting, [], set(), {"internal"})
+    assert "internal" in coord.finished_requests
+
+
+def test_chunk_waiting_removes_request_from_running_list():
+    coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1, async_chunk=True)
+    req = _make_request("running", status=RequestStatus.RUNNING)
+    running = [req]
+
+    coord.process_pending_chunks(MockQueue(), running, set(), set())
+
+    assert running == []
+    assert req.status == RequestStatus.WAITING_FOR_CHUNK
+    assert list(coord._waiting_for_chunk_running) == [req]
+
+
+class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
     """Test update_request_metadata applies scheduling metadata to requests."""
 
     def test_ar_mode_no_longer_sets_additional_information(self):
@@ -382,17 +425,18 @@ class TestTimeoutDetection(unittest.TestCase):
         self.assertEqual(result, {"r1"})
         self.assertEqual(len(coord._waiting_for_input), 0)
 
-    def test_free_finished_request_clears_waiting_since(self):
-        """free_finished_request clears coordinator lifecycle markers."""
-        coord = OmniSchedulingCoordinator(stage_id=1)
-        coord._waiting_since["r1"] = 0.0
-        coord._full_payload_input_received.add("r1")
+    def test_free_finished_request_clears_all_lifecycle_state(self):
+        """free_finished_request makes stale connector events harmless."""
+        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        r1, r2 = _make_request("r1"), _make_request("r2")
         coord.finished_requests.add("r1")
+        coord.requests_with_ready_chunks.add("r1")
+        coord._waiting_for_chunk_running.extend([r1, r2])
+        coord.pending_chunk_registrations = [OmniChunkRecvHandle(request_id="r1"), OmniChunkRecvHandle(request_id="r2")]
+
         coord.free_finished_request("r1")
-        self.assertNotIn("r1", coord._waiting_since)
-        self.assertNotIn("r1", coord._full_payload_input_received)
+
         self.assertNotIn("r1", coord.finished_requests)
-
-
-if __name__ == "__main__":
-    unittest.main()
+        self.assertNotIn("r1", coord.requests_with_ready_chunks)
+        self.assertEqual([r.request_id for r in coord._waiting_for_chunk_running], ["r2"])
+        self.assertEqual([h.request_id for h in coord.pending_chunk_registrations], ["r2"])
diff --git a/tests/core/test_prefix_cache.py b/tests/core/test_prefix_cache.py
index 4f91a95b7..171f36f71 100644
--- a/tests/core/test_prefix_cache.py
+++ b/tests/core/test_prefix_cache.py
@@ -1,917 +1,1801 @@
-import math
-from typing import NamedTuple
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for vllm_omni/core/prefix_cache (manager + controller + pool).
+
+CPU-only: the controller runs in eager mode. Uses a fake group view, so no
+vLLM runtime is required (runnable without a vllm install via
+``pytest --confcutdir=tests/core``).
+"""
+
+import ast
+import logging
+import sys
+import threading
+import time
+from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 import torch
 
-from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
+try:  # pragma: no cover - shim only matters on vllm-less dev machines
+    import vllm  # noqa: F401
+except ModuleNotFoundError:
+    # Bypass vllm_omni/__init__ (which imports vllm): register namespace
+    # parents so the pure-torch prefix_cache subpackage imports directly.
+    _root = Path(__file__).resolve().parents[2]
+    for _pkg in ("vllm_omni", "vllm_omni.core", "vllm_omni.utils"):
+        if _pkg not in sys.modules:
+            _m = __import__("types").ModuleType(_pkg)
+            _m.__path__ = [str(_root / _pkg.replace(".", "/"))]
+            sys.modules[_pkg] = _m
+    _vllm = __import__("types").ModuleType("vllm")
+    _vllm_logger = __import__("types").ModuleType("vllm.logger")
+    _vllm_logger.init_logger = logging.getLogger
+    _vllm.logger = _vllm_logger
+    sys.modules["vllm"] = _vllm
+    sys.modules["vllm.logger"] = _vllm_logger
+
+from vllm_omni.core.prefix_cache.controller import StagingBufferHolder
+from vllm_omni.core.prefix_cache.group_view import (
+    FullAttentionGroupView,
+    check_prefix_cache_kv_groups,
+    stage_prefix_cache_config,
+)
+from vllm_omni.core.prefix_cache.interface import (
+    HIDDEN_KEY,
+    ModelCachePolicy,
+    OmniPrefixCacheStagingTimeoutError,
+    OmniPrefixCacheUnmatchError,
+    PrefixCacheConfig,
+    WriteSchedule,
+)
+from vllm_omni.core.prefix_cache.manager import (
+    OmniPrefixCacheManager,
+    _is_step_token_tensor,
+    _snapshot_leftover_mm_cpu,
+)
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
-
-DEFAULT_SEQ_LEN = 15
-NUM_BLOCKS = 10
+NUM_BLOCKS = 16
 BLOCK_SIZE = 4
-HIDDEN_SIZE = 2
+HIDDEN = 8
 DTYPE = torch.float32
-OTHER_DTYPE = torch.float16
-DEFAULT_SHAPE = torch.Size([NUM_BLOCKS, BLOCK_SIZE, HIDDEN_SIZE])
 
 
-class MockInputBatch:
-    def __init__(self, num_computed_tokens_cpu, block_table=None):
-        self.req_ids = ["req1", "req2"]
-        self.req_id_to_index = {req_id: i for i, req_id in enumerate(self.req_ids)}
-        self.num_computed_tokens_cpu = num_computed_tokens_cpu
+class FakeView:
+    """Duck-typed group view backed by plain dicts."""
 
-        # Block table is only mocked for validation of length;
-        # we don't actually need to add valid values here since
-        # we patch the table when testing.
-        if block_table is None:
+    def __init__(self):
+        self.block_size = BLOCK_SIZE
+        self.req_blocks: dict[str, list[int]] = {}
+        self.order: list[str] = []
+        self.computed: dict[str, int] = {}
+        self.step_slot_mapping: torch.Tensor | None = None
 
-            class _DummyBlockTable:
-                pass
+    def slots_for(self, req_id, token_start, token_end):
+        blocks = self.req_blocks[req_id]
+        slots = []
+        for pos in range(token_start, token_end):
+            slots.append(blocks[pos // BLOCK_SIZE] * BLOCK_SIZE + pos % BLOCK_SIZE)
+        return torch.tensor(slots, dtype=torch.long)
 
-            self.block_table = _DummyBlockTable()
-            self.block_table.block_tables = [None]
+    def batch_req_ids(self) -> list[str]:
+        return list(self.order)
+
+    def step_slots_cpu(self, req_ids, num_scheduled) -> torch.Tensor:
+        parts = []
+        for r in req_ids:
+            n = int(num_scheduled.get(r, 0))
+            if n <= 0:
+                continue
+            start = self.computed.get(r, 0)
+            parts.append(self.slots_for(r, start, start + n))
+        return torch.cat(parts) if parts else torch.empty((0,), dtype=torch.long)
+
+
+class FakeNewReq:
+    def __init__(self, req_id, num_computed_tokens=0, block_ids=None):
+        self.req_id = req_id
+        self.num_computed_tokens = num_computed_tokens
+        self.block_ids = block_ids
+
+
+class FakeSchedOut:
+    def __init__(self, new_reqs=(), finished=(), num_scheduled=None):
+        self.scheduled_new_reqs = list(new_reqs)
+        self.finished_req_ids = set(finished)
+        self.num_scheduled_tokens = dict(num_scheduled or {})
+
+
+def make_manager(view=None, policy=None, **cfg_kwargs) -> tuple[OmniPrefixCacheManager, FakeView]:
+    view = view or FakeView()
+    config = PrefixCacheConfig(num_blocks=NUM_BLOCKS, block_size=BLOCK_SIZE, **cfg_kwargs)
+    mgr = OmniPrefixCacheManager(config, view, eager=True)
+    if policy is not None:
+        mgr.register_policy(policy)
+    return mgr, view
+
+
+def run_step(
+    mgr,
+    view,
+    reqs: dict[str, tuple[list[int], int, int]],
+    new_hits=None,
+    finished=(),
+    mm=None,
+    num_tokens_padded=None,
+) -> int:
+    """One step: reqs = req_id -> (blocks, sched_start_pos, sched_tokens)."""
+    view.order = list(reqs.keys())
+    new_reqs = []
+    num_sched = {}
+    slot_parts = []
+    hidden_parts = []
+    for req_id, (blocks, start_pos, sched) in reqs.items():
+        view.req_blocks[req_id] = blocks
+        view.computed[req_id] = start_pos
+        num_sched[req_id] = sched
+        slots = view.slots_for(req_id, start_pos, start_pos + sched)
+        slot_parts.append(slots)
+        hidden_parts.append(slots.to(DTYPE).unsqueeze(1).expand(sched, HIDDEN).clone())
+        hit = (new_hits or {}).get(req_id, 0)
+        new_reqs.append(FakeNewReq(req_id, num_computed_tokens=hit, block_ids=[list(blocks)]))
+    view.step_slot_mapping = torch.cat(slot_parts)
+    hidden = torch.cat(hidden_parts)
+    sched_out = FakeSchedOut(new_reqs=new_reqs, finished=finished, num_scheduled=num_sched)
+    mgr.new_step_starts(sched_out)
+    n = int(view.step_slot_mapping.numel())
+    padded = n if num_tokens_padded is None else int(num_tokens_padded)
+    return mgr.save_outputs(hidden, mm or {}, num_tokens_unpadded=n, num_tokens_padded=padded)
+
+
+def expected_rows(slots: torch.Tensor) -> torch.Tensor:
+    return slots.to(DTYPE).unsqueeze(1).expand(slots.numel(), HIDDEN)
+
+
+def plan_fetch(mgr, slots, key, *, req_id):
+    with mgr._state_lock:
+        src = mgr._slot_ref(slots, key, req_id)
+    with torch.inference_mode():
+        return mgr._fetch_source(src)
+
+
+def _assert_leftover_shapes(inp, got, n: int) -> None:
+    """Every leftover tensor keeps its shape unless dim0 is this step's token count."""
+    if isinstance(inp, torch.Tensor):
+        if inp.ndim >= 1 and n > 0 and inp.shape[0] == n:
+            assert got.shape == (n, *inp.shape[1:])
         else:
-
-            class _TensorWrapper:
-                def __init__(self, tensor):
-                    self.cpu = tensor
-
-            class _BlockGroup:
-                def __init__(self, tensor):
-                    self.block_table = _TensorWrapper(tensor)
-
-            class _BlockTable:
-                def __init__(self, tensor):
-                    self._group = _BlockGroup(tensor)
-                    self.block_tables = [self._group.block_table]
-
-                def __getitem__(self, idx):
-                    assert idx == 0
-                    return self._group
-
-            self.block_table = _BlockTable(block_table)
+            assert got.shape == inp.shape
+        return
+    if isinstance(inp, dict):
+        assert set(got) == set(inp)
+        for k in inp:
+            _assert_leftover_shapes(inp[k], got[k], n)
+        return
+    if isinstance(inp, (list, tuple)):
+        assert len(got) == len(inp)
+        for a, b in zip(inp, got):
+            _assert_leftover_shapes(a, b, n)
 
 
-def get_omni_pcache_with_mm_tensors(feat_dims, seq_len) -> OmniTensorPrefixCache:
-    """Build an OmniTensorPrefixCache and init mm tensors."""
-    cache = get_omni_pcache()
-    mm_outputs = get_multimodal_outputs(feat_dims, seq_len)
-    cache.maybe_init_missing_mm_cache_keys(mm_outputs, seq_len)
-    return cache
+def _module_scope_imported_modules(path: Path) -> list[str]:
+    """Top-level import module names, skipping ``if TYPE_CHECKING`` blocks."""
+    tree = ast.parse(path.read_text())
+    names: list[str] = []
+
+    def _from_stmt(node: ast.AST) -> None:
+        if isinstance(node, ast.Import):
+            names.extend(alias.name for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            names.append(node.module)
+
+    for node in tree.body:
+        if isinstance(node, ast.If) and isinstance(node.test, ast.Name) and node.test.id == "TYPE_CHECKING":
+            continue
+        _from_stmt(node)
+    return names
 
 
-def get_omni_pcache() -> OmniTensorPrefixCache:
-    """Build an OmniTensorPrefixCache, but don't init mm tensors."""
-    cache = OmniTensorPrefixCache(
+def test_prefix_cache_package_has_no_module_scope_vllm_import():
+    """This package must import without vllm. See the package docstring."""
+    pkg = Path(__file__).resolve().parents[2] / "vllm_omni" / "core" / "prefix_cache"
+    leaked: list[str] = []
+    for path in sorted(pkg.glob("*.py")):
+        for mod in _module_scope_imported_modules(path):
+            if mod == "vllm" or mod.startswith("vllm."):
+                leaked.append(f"{path.name}: {mod}")
+    assert not leaked, leaked
+
+
+def test_no_hit_passthrough():
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    outs = mgr.materialize(sid, ["a"])
+    assert torch.equal(outs.hidden_states["a"], expected_rows(view.slots_for("a", 0, 8)))
+
+
+def test_hit_merge_from_mirror():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8}, finished=["a"])
+    outs = mgr.materialize(s2, ["b"])
+    merged = outs.hidden_states["b"]
+    assert merged.shape == (12, HIDDEN)
+    assert torch.equal(merged[:8], expected_rows(view.slots_for("b", 0, 8)))
+    assert torch.equal(merged[8:], expected_rows(view.slots_for("b", 8, 12)))
+
+
+@pytest.mark.parametrize("a_finished_before_b", [False, True])
+def test_partial_match_hits_shared_prefix_and_writes_divergent_block(a_finished_before_b):
+    """`a` occupies [0, 1, 2]; `b` shares the first two blocks and diverges on
+    the third ([0, 1, 3]). `b` must merge 8 hit rows from the shared blocks
+    plus its own 4 rows, land block 3 in the pool, and leave `a`'s block 2
+    untouched — whether `a` already finished or is still running."""
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1, 2], 0, 12)})
+    mgr.materialize(s1, ["a"])
+    a_tail = view.slots_for("a", 8, 12)
+    assert torch.equal(plan_fetch(mgr, a_tail, HIDDEN_KEY, req_id="a"), expected_rows(a_tail))
+
+    finished = ["a"] if a_finished_before_b else ()
+    s2 = run_step(mgr, view, {"b": ([0, 1, 3], 8, 4)}, new_hits={"b": 8}, finished=finished)
+    outs = mgr.materialize(s2, ["b"])
+    merged = outs.hidden_states["b"]
+    assert merged.shape == (12, HIDDEN)
+    assert torch.equal(merged[:8], expected_rows(view.slots_for("b", 0, 8)))
+    assert torch.equal(merged[8:], expected_rows(view.slots_for("b", 8, 12)))
+    # Divergent third block landed; the shared prefix and a's own tail did not move.
+    b_tail = view.slots_for("b", 8, 12)
+    assert torch.equal(plan_fetch(mgr, b_tail, HIDDEN_KEY, req_id="b"), expected_rows(b_tail))
+    assert torch.equal(plan_fetch(mgr, a_tail, HIDDEN_KEY, req_id="a"), expected_rows(a_tail))
+    shared = view.slots_for("a", 0, 8)
+    assert torch.equal(plan_fetch(mgr, shared, HIDDEN_KEY, req_id="a"), expected_rows(shared))
+
+    if not a_finished_before_b:
+        # `a` finishes later; releasing its task must not disturb b's rows.
+        s3 = run_step(mgr, view, {"b": ([0, 1, 3, 4], 12, 1)}, finished=["a"])
+        mgr.materialize(s3, ["b"])
+        assert torch.equal(plan_fetch(mgr, b_tail, HIDDEN_KEY, req_id="b"), expected_rows(b_tail))
+
+
+def test_live_req_reentering_new_reqs_is_not_a_hit():
+    """async_chunk continuation: the same id re-enters scheduled_new_reqs with
+    num_computed_tokens equal to what it computed itself. No hit span is
+    opened and materialize returns only this step's rows (parity with the
+    pre-refactor cache; a delivered_upto span is Phase 2). Once the id has
+    finished, the same id is a new request again and its hit is merged."""
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    mgr.materialize(s1, ["a"])
+
+    # Next chunk arrives: `a` is scheduled again as a "new" request at 8.
+    s2 = run_step(mgr, view, {"a": ([0, 1, 2], 8, 4)}, new_hits={"a": 8})
+    assert not mgr._step_ctxs[s2].hits
+    outs = mgr.materialize(s2, ["a"])
+    assert torch.equal(outs.hidden_states["a"], expected_rows(view.slots_for("a", 8, 12)))
+
+    # `a` finishes; a later request reusing the id is new and does hit.
+    s3 = run_step(mgr, view, {"b": ([3], 0, 2)}, finished=["a"])
+    mgr.materialize(s3, ["b"])
+    s4 = run_step(mgr, view, {"a": ([0, 1, 4], 8, 4)}, new_hits={"a": 8}, finished=["b"])
+    assert mgr._step_ctxs[s4].hits == {"a": (8, [0, 1])}
+    outs = mgr.materialize(s4, ["a"])
+    assert outs.hidden_states["a"].shape == (12, HIDDEN)
+    assert torch.equal(outs.hidden_states["a"][:8], expected_rows(view.slots_for("a", 0, 8)))
+
+
+def test_join_next_step_hit_waits_done_then_reads_pool():
+    """CPU stand-in for the non-eager path: dispatch holds the task instead of
+    writing the pool. A same-step hit must join(done), drain, then read the pool."""
+    mgr, view = make_manager()
+    real_run = mgr._controller._run_eager
+    real_join = mgr._controller.join
+
+    def join_then_scatter(tids):
+        # Stand-in committer: the write lands only when someone joins it.
+        for tid in tids:
+            task = mgr._controller.get_task(tid)
+            if task is not None and not task.done.is_set():
+                real_run(task)
+        real_join(tids)
+
+    mgr._controller.dispatch = lambda tasks: None
+    mgr._controller.join = join_then_scatter
+
+    view.req_blocks["a"] = [0, 1]
+    sid = run_step(
+        mgr,
+        view,
+        {"a": ([0, 1], 0, 8), "b": ([0, 1, 2], 8, 4)},
+        new_hits={"b": 8},
+    )
+    outs = mgr.materialize(sid, ["a", "b"])
+    assert torch.equal(outs.hidden_states["b"][:8], expected_rows(view.slots_for("b", 0, 8)))
+    slots = view.slots_for("a", 0, 8)
+    assert torch.equal(mgr._pool.rows(HIDDEN_KEY, slots), expected_rows(slots))
+
+
+def test_same_step_hit_reads_in_transit():
+    mgr, view = make_manager()
+    view.req_blocks["a"] = [0, 1]
+    sid = run_step(
+        mgr,
+        view,
+        {"a": ([0, 1], 0, 8), "b": ([0, 1, 2], 8, 4)},
+        new_hits={"b": 8},
+    )
+    outs = mgr.materialize(sid, ["a", "b"])
+    assert torch.equal(outs.hidden_states["b"][:8], expected_rows(view.slots_for("b", 0, 8)))
+
+
+def test_absent_hit_fails_fast():
+    mgr, view = make_manager()
+    view.req_blocks["c"] = [5, 6]
+    sid = run_step(mgr, view, {"c": ([5, 6, 7], 8, 4)}, new_hits={"c": 8})
+    d2h = mgr._step_ctxs[sid].d2h
+    with pytest.raises(OmniPrefixCacheUnmatchError):
+        mgr.materialize(sid, ["c"])
+    if d2h is not None:
+        assert not mgr._controller._staging_pool._busy[d2h.staging_slot]
+
+
+def test_hit_not_block_aligned_fails_at_register():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    mgr.materialize(s1, ["a"])
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="prefix hit not block aligned"):
+        run_step(mgr, view, {"b": ([0, 1, 2], 8, 4)}, new_hits={"b": 6})
+
+
+def test_mm_cached_key_merge():
+    mgr, view = make_manager()
+    feat = 3
+    mm1 = {"talker.h": torch.arange(8 * feat, dtype=DTYPE).reshape(8, feat)}
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)}, mm=mm1)
+    mgr.materialize(s1, ["a"])
+    mm2 = {"talker.h": torch.full((4, feat), 7.0)}
+    s2 = run_step(mgr, view, {"b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8}, finished=["a"], mm=mm2)
+    outs = mgr.materialize(s2, ["b"])
+    merged = outs.mm_outputs["talker.h"]["b"]
+    assert merged.shape == (12, feat)
+    assert torch.equal(merged[:8], mm1["talker.h"])
+    assert torch.equal(merged[8:], mm2["talker.h"])
+
+
+def test_codes_audio_matches_ordinary_mm_key():
+    """Without a deferred policy, codes.audio is an ordinary mm key (dim0 = tokens)."""
+    mgr, view = make_manager()
+    step1 = torch.arange(8 * 2, dtype=DTYPE).reshape(8, 2)
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)}, mm={"codes.audio": step1})
+    assert torch.equal(mgr.materialize(s1, ["a"]).mm_outputs["codes.audio"]["a"], step1)
+    step2 = torch.full((4, 2), 7.0)
+    s2 = run_step(mgr, view, {"b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8}, finished=["a"], mm={"codes.audio": step2})
+    merged = mgr.materialize(s2, ["b"]).mm_outputs["codes.audio"]["b"]
+    assert torch.equal(merged, torch.cat([step1, step2], dim=0))
+
+
+def test_unpadded_mm_registers_on_padded_step():
+    """Qwen3-TTS codes.audio is scheduled-length; cudagraph makes padded > n.
+
+    Immediate-only `shape[0] == padded` would skip ensure_key, drop the
+    rows into leftover, and silently serve hits without a cached prefix.
+    """
+    mgr, view = make_manager()
+    audio = torch.arange(8 * 2, dtype=DTYPE).reshape(8, 2)
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)}, mm={"codes.audio": audio}, num_tokens_padded=16)
+    assert mgr._pool.has_key("codes.audio")
+    assert "codes.audio" not in mgr._step_ctxs[s1].mm_cpu_snapshot
+    assert torch.equal(mgr.materialize(s1, ["a"]).mm_outputs["codes.audio"]["a"], audio)
+    s2 = run_step(
+        mgr,
+        view,
+        {"b": ([0, 1, 2], 8, 4)},
+        new_hits={"b": 8},
+        finished=["a"],
+        mm={"codes.audio": torch.full((4, 2), 3.0)},
+        num_tokens_padded=16,
+    )
+    merged = mgr.materialize(s2, ["b"]).mm_outputs["codes.audio"]["b"]
+    assert torch.equal(merged[:8], audio)
+    assert torch.equal(merged[8:], torch.full((4, 2), 3.0))
+
+
+def test_split_step_outputs_routes_immediate_deferred_leftover():
+    """One split: immediate device→host, deferred write + leftover read, leftover only."""
+    policy = ModelCachePolicy(needs_full_hidden_states=True, deferred_keys=frozenset({"codes.audio"}))
+    mgr, view = make_manager(policy=policy)
+    view.order = ["a"]
+    view.req_blocks["a"] = [0]
+    view.computed["a"] = 0
+    n = 4
+    mgr.new_step_starts(FakeSchedOut(new_reqs=[FakeNewReq("a")], num_scheduled={"a": n}))
+    hidden = torch.ones(n, HIDDEN)
+    mm = {
+        "codes.audio": torch.full((n, 2), 5.0),
+        "codes.ref": torch.zeros(15, 2),
+        "tok": torch.full((n, 2), 7.0),
+    }
+    step_outputs = mgr._split_step_outputs(
+        hidden,
+        mm,
+        n,
+        n,
+        slots_cpu=view.step_slots_cpu(["a"], {"a": n}),
+        req_order=["a"],
+        num_sched={"a": n},
+        query_start={"a": 0},
+    )
+    assert HIDDEN_KEY in step_outputs.immediate and "tok" in step_outputs.immediate
+    assert "codes.audio" not in step_outputs.immediate and "codes.ref" not in step_outputs.immediate
+    assert "codes.audio" in step_outputs.leftover and "codes.ref" in step_outputs.leftover
+    assert "tok" not in step_outputs.leftover
+    assert len(step_outputs.deferred_chunks) == 1
+    assert step_outputs.deferred_chunks[0][0] == "a"
+    assert "codes.audio" in step_outputs.deferred_chunks[0][1].tensors
+
+
+def test_leftover_snapshot_preserves_non_token_major_shapes():
+    """P1: leftover copy must not use `shape[0] >= n` as a slice predicate.
+
+    Tensors whose first dim is this step's token count (`shape[0] == n`)
+    may be sliced; every other tensor — including `codes.ref` with
+    ref_len >> n, and list-held tensors — must keep the input shape.
+    """
+    n = 4
+    mm = {
+        "codes.ref": torch.arange(30, dtype=DTYPE).reshape(15, 2),
+        "tags": [torch.ones(3, 5), torch.zeros(7)],
+        "tokenish": torch.arange(n * 2, dtype=DTYPE).reshape(n, 2),
+        "scalar": torch.tensor(3.0),
+    }
+    out, event = _snapshot_leftover_mm_cpu(mm, set(), n)
+    assert event is None
+    _assert_leftover_shapes(mm, out, n)
+    assert torch.equal(out["codes.ref"], mm["codes.ref"])
+    assert out["codes.ref"].shape == (15, 2)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA leftover copy")
+def test_leftover_snapshot_cuda_is_pinned_and_event_ordered():
+    """CUDA leftover lands pinned via a non-blocking copy; values are exact once the event is waited."""
+    n = 4
+    mm = {
+        "codes.audio": torch.arange(n * 2, dtype=DTYPE, device="cuda").reshape(n, 2),
+        "codes.ref": torch.arange(30, dtype=DTYPE, device="cuda").reshape(15, 2),
+        "tags": [torch.ones(3, 5, device="cuda")],
+    }
+    out, event = _snapshot_leftover_mm_cpu(mm, set(), n)
+    assert event is not None
+    event.synchronize()
+    _assert_leftover_shapes(mm, out, n)
+    for t in (out["codes.audio"], out["codes.ref"], out["tags"][0]):
+        assert t.device.type == "cpu" and t.is_pinned()
+    assert torch.equal(out["codes.audio"], mm["codes.audio"].cpu())
+    assert torch.equal(out["codes.ref"], mm["codes.ref"].cpu())
+
+
+def test_codes_ref_matches_old_build_mm_cpu_path():
+    """Leftover `codes.ref` equals the old runner path: build_mm_cpu + to_payload_element."""
+    pytest.importorskip("vllm")
+    from vllm_omni.utils.mm_outputs import build_mm_cpu, to_payload_element
+
+    refs = [torch.arange(8, dtype=torch.long), torch.arange(12, dtype=torch.long)]
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"a": ([0], 0, 2), "b": ([1], 0, 2)}, mm={"codes.ref": refs})
+    ctx = mgr._step_ctxs[sid]
+    assert "codes.ref" in ctx.mm_cpu_snapshot
+    assert [t.shape for t in ctx.mm_cpu_snapshot["codes.ref"]] == [t.shape for t in refs]
+    outs = mgr.materialize(sid, ["a", "b"])
+    old = build_mm_cpu({"codes.ref": refs})
+    total = 4
+    for req_id, idx, start, end in (("a", 0, 0, 2), ("b", 1, 2, 4)):
+        want = to_payload_element(old["codes.ref"], idx, start=start, end=end, pass_lists_through=True, seq_len=total)
+        got = outs.mm_outputs["codes.ref"][req_id]
+        assert len(got) == len(want)
+        for g, w in zip(got, want):
+            assert torch.equal(g, w)
+
+
+def test_is_step_token_tensor():
+    n, padded = 4, 8
+    assert _is_step_token_tensor(torch.zeros(n, 2), n, padded)
+    assert _is_step_token_tensor(torch.zeros(padded, 2), n, padded)
+    assert not _is_step_token_tensor([torch.zeros(1, 8)], n, padded)
+    assert not _is_step_token_tensor(torch.zeros(15, 2), n, padded)
+    assert not _is_step_token_tensor(torch.tensor([1, 2, 3]), n, padded)
+
+
+def test_policy_from_model_shim():
+    class M:
+        requires_full_prefix_cached_hidden_states = False
+        deferred_prefix_cache_mm_keys = {"codes.audio"}
+
+    p = ModelCachePolicy.from_model(M())
+    assert p.needs_full_hidden_states is False
+    assert p.hidden_key is None
+    assert p.deferred_keys == frozenset({"codes.audio"})
+    assert p.get_hit_keys([HIDDEN_KEY, "codes.audio"]) == ["codes.audio"]
+    assert p.skip_immediate_mm("codes.audio")
+    d = ModelCachePolicy.from_model(object())
+    assert d.needs_full_hidden_states is True and not d.deferred_keys
+    assert d.hidden_key == HIDDEN_KEY
+    assert d.get_hit_keys(["talker.h", HIDDEN_KEY]) == [HIDDEN_KEY, "talker.h"]
+
+
+def test_deferred_key_accumulates_and_flushes_on_finish():
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"codes.audio"}))
+    mgr, view = make_manager(policy=policy)
+    feat = 2
+    for pos in range(2):
+        sid = run_step(
+            mgr,
+            view,
+            {"a": ([3], pos, 1)},
+            mm={"codes.audio": torch.full((1, feat), float(pos + 1))},
+        )
+        mgr.materialize(sid, ["a"])
+    slots = view.slots_for("a", 0, 2)
+    rows = plan_fetch(mgr, slots, "codes.audio", req_id="a")
+    assert torch.equal(rows[:, 0], torch.tensor([1.0, 2.0]))
+    sid = run_step(mgr, view, {"z": ([9], 0, 1)}, finished=["a"])
+    mgr.materialize(sid, ["z"])
+    mirror = mgr._pool.rows("codes.audio", slots)
+    assert torch.equal(mirror[:, 0], torch.tensor([1.0, 2.0]))
+
+
+def test_deferred_gpu_bytes_held_until_last_view_drops():
+    """Shared deferred clone is one allocation; finishing the first
+    co-scheduled request must not drop ``_staged_bytes`` while the other
+    still pins it."""
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    feat = 2
+    n = 4
+    s1 = run_step(
+        mgr,
+        view,
+        {"a": ([0], 0, 2), "b": ([1], 0, 2)},
+        mm={"k": torch.zeros(n, feat)},
+    )
+    mgr.materialize(s1, ["a", "b"])
+    clone_bytes = n * feat * 4  # float32
+    assert mgr._controller._staged_bytes == clone_bytes
+    s2 = run_step(mgr, view, {"z": ([9], 0, 1)}, finished=["a"])
+    mgr.materialize(s2, ["z"])
+    assert mgr._controller._staged_bytes == clone_bytes
+    s3 = run_step(mgr, view, {"z2": ([9], 1, 1)}, finished=["b"])
+    mgr.materialize(s3, ["z2"])
+    assert mgr._controller._staged_bytes == 0
+
+
+def test_cap_forces_flush_of_deferred():
+    """One long request's deferred clone must not pin the whole budget:
+    the flush closes its open task and the next step opens a new one."""
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy, gpu_staging_bytes=48)  # three (1, 4) fp32 chunks
+    for pos in range(4):
+        sid = run_step(mgr, view, {"a": ([2, 3], pos, 1)}, mm={"k": torch.full((1, 4), float(pos + 1))})
+        mgr.materialize(sid, ["a"])
+    # Fourth chunk flushed the first three; only it is still charged.
+    assert mgr._controller._staged_bytes == 16
+    rows = mgr._pool.rows("k", view.slots_for("a", 0, 4))[:, 0].tolist()
+    assert rows == [1.0, 2.0, 3.0, 0.0]
+    assert mgr._request_tasks.deferred["a"].write_n == 2
+    assert len(mgr._request_tasks.tasks["a"]) == 1  # the flushed write was drained
+
+
+def test_deferred_tenant_succession_no_stale_wins():
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([2], 0, 2)}, mm={"k": torch.full((2, 2), 1.0)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([2], 0, 2)}, mm={"k": torch.full((2, 2), 2.0)})
+    mgr.materialize(s2, ["b"])
+    slots = view.slots_for("b", 0, 2)
+    s3 = run_step(mgr, view, {"z1": ([9], 0, 1)}, finished=["b"])
+    mgr.materialize(s3, ["z1"])
+    s4 = run_step(mgr, view, {"z2": ([9], 1, 1)}, finished=["a"])
+    mgr.materialize(s4, ["z2"])
+    assert torch.equal(mgr._pool.rows("k", slots), torch.full((2, 2), 2.0))
+
+
+def test_reacquired_slot_deferred_rewrite_wins_over_interim_tenant():
+    """Preempt + resume onto the same block: the rewrite must open a new
+    write, or the old task's reassigned tombstone drops the fresh rows and
+    the interim tenant's stale value is served as a's."""
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([2], 0, 1)}, mm={"k": torch.full((1, 2), 11.0)})
+    mgr.materialize(s1, ["a"])
+    slots = view.slots_for("a", 0, 1)
+    s2 = run_step(mgr, view, {"b": ([2], 0, 1)}, mm={"k": torch.full((1, 2), 22.0)})
+    mgr.materialize(s2, ["b"])
+    s3 = run_step(mgr, view, {"z": ([9], 0, 1)}, finished=["b"])  # 22 committed
+    mgr.materialize(s3, ["z"])
+    s4 = run_step(mgr, view, {"a": ([2], 0, 1)}, mm={"k": torch.full((1, 2), 33.0)})  # a re-claims
+    mgr.materialize(s4, ["a"])
+    s5 = run_step(mgr, view, {"z2": ([9], 1, 1)}, finished=["a"])  # flush a's write
+    mgr.materialize(s5, ["z2"])
+    assert torch.equal(mgr._pool.rows("k", slots), torch.full((1, 2), 33.0))
+
+
+def test_deferred_key_hit_reads_staged_rows_not_mirror():
+    policy = ModelCachePolicy(needs_full_hidden_states=True, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([0], 0, 4)}, mm={"k": torch.full((4, 2), 1.0)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([0, 1], 4, 2)}, new_hits={"b": 4}, mm={"k": torch.full((2, 2), 9.0)})
+    rows = mgr.materialize(s2, ["b"]).mm_outputs["k"]["b"]
+    assert torch.equal(rows[:4], torch.full((4, 2), 1.0)), rows
+    assert torch.equal(rows[4:], torch.full((2, 2), 9.0))
+
+
+def test_append_to_closed_deferred_entry_opens_new_one():
+    """A deferred task closed by the budget flush (or an early escalate)
+    cannot take more chunks; the next save opens a new write and a hit
+    reads both."""
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([2], 0, 1)}, mm={"k": torch.full((1, 2), 1.0)})
+    mgr.materialize(s1, ["a"])
+    first = mgr._request_tasks.deferred["a"]
+    mgr._controller.escalate([first.tid])
+    s2 = run_step(mgr, view, {"a": ([2], 1, 1)}, mm={"k": torch.full((1, 2), 2.0)})
+    mgr.materialize(s2, ["a"])
+    assert mgr._request_tasks.deferred["a"].tid != first.tid
+    slots = view.slots_for("a", 0, 2)
+    rows = plan_fetch(mgr, slots, "k", req_id="a")
+    assert torch.equal(rows[:, 0], torch.tensor([1.0, 2.0]))
+
+
+def test_deferred_unpadded_registers_on_padded_step():
+    """Qwen3-TTS: deferred codes.audio is unpadded; cudagraph pads hidden."""
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"codes.audio"}))
+    mgr, view = make_manager(policy=policy)
+    audio = torch.arange(8 * 2, dtype=DTYPE).reshape(8, 2)
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)}, mm={"codes.audio": audio}, num_tokens_padded=16)
+    assert mgr._pool.has_key("codes.audio")
+    assert "codes.audio" in mgr._step_ctxs[s1].mm_cpu_snapshot
+    rows = plan_fetch(mgr, view.slots_for("a", 0, 8), "codes.audio", req_id="a")
+    assert torch.equal(rows, audio)
+    outs = mgr.materialize(s1, ["a"])
+    assert torch.equal(outs.mm_outputs["codes.audio"]["a"], audio)
+
+
+def test_check_kv_groups_rejects_empty_or_multi():
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="single full-attention"):
+        check_prefix_cache_kv_groups([])
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="single full-attention"):
+        check_prefix_cache_kv_groups([object(), object()])
+
+
+def _stage_cfg(*, enable=True, pooling=False, kv_transfer=None, groups=(object(),), spec=None, match_unit=None):
+    return stage_prefix_cache_config(
+        kv_cache_config=SimpleNamespace(num_blocks=NUM_BLOCKS, kv_cache_groups=list(groups)),
+        cache_config=SimpleNamespace(enable_prefix_caching=enable, block_size=BLOCK_SIZE, prefix_match_unit=match_unit),
+        kv_transfer_config=kv_transfer,
+        scheduler_config=SimpleNamespace(max_num_batched_tokens=64, max_model_len=128),
+        model_config=None,
+        is_pooling_model=pooling,
+        speculative_config=spec,
+    )
+
+
+def test_stage_prefix_cache_config_gate():
+    """The runner-side gate the GPU and NPU runners share: off / pooling
+    stages get no cache; kv_consumer, spec decode, sub-block matching and
+    hybrid groups refuse loudly."""
+    assert _stage_cfg(enable=False) is None
+    assert _stage_cfg(pooling=True) is None
+    # kv_consumer / kv_both refuse before the group check, on both platforms.
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="KV connector"):
+        _stage_cfg(kv_transfer=SimpleNamespace(is_kv_consumer=True), groups=())
+    assert _stage_cfg(kv_transfer=SimpleNamespace(is_kv_consumer=True), enable=False) is None
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="speculative decoding"):
+        _stage_cfg(spec=SimpleNamespace(method="ngram"), groups=())
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="block-aligned"):
+        _stage_cfg(match_unit=BLOCK_SIZE // 2, groups=())
+    # A unit equal to the block is a whole-block match; only the group check is left.
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="single full-attention"):
+        _stage_cfg(match_unit=BLOCK_SIZE, groups=())
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="single full-attention"):
+        _stage_cfg(groups=(object(), object()))
+
+
+def test_npu_runner_uses_shared_prefix_cache_gate():
+    """npu_model_runner cannot be imported without vllm_ascend; pin at the
+    source level that it stages through the shared gate instead of a
+    hand-rolled subset of the GPU checks."""
+    path = Path(__file__).resolve().parents[2] / "vllm_omni/platforms/npu/worker/npu_model_runner.py"
+    tree = ast.parse(path.read_text())
+    calls = {n.func.id for n in ast.walk(tree) if isinstance(n, ast.Call) and isinstance(n.func, ast.Name)}
+    assert "stage_prefix_cache_config" in calls
+    assert "check_prefix_cache_kv_groups" not in calls
+
+
+def _table_slots(table, req_idx, token_start, token_end, block_size=BLOCK_SIZE):
+    if token_end <= token_start:
+        return torch.empty((0,), dtype=torch.long)
+    token_positions = torch.arange(token_start, token_end, dtype=torch.long)
+    block_offsets = token_positions // block_size
+    max_blocks = int(table.shape[1])
+    valid = block_offsets < max_blocks
+    if not bool(valid.all()):
+        token_positions = token_positions[valid]
+        block_offsets = block_offsets[valid]
+    if token_positions.numel() == 0:
+        return torch.empty((0,), dtype=torch.long)
+    block_ids = table[req_idx, block_offsets].to(torch.long)
+    return block_ids * block_size + (token_positions % block_size)
+
+
+def test_group_view_step_slots_cpu():
+    class TensorWrap:
+        def __init__(self, t):
+            self.cpu = t
+
+    class Group:
+        def __init__(self, t):
+            self.block_table = TensorWrap(t)
+
+    class BT:
+        def __init__(self, t):
+            self._g = Group(t)
+            self.block_tables = [self._g.block_table]
+
+        def __getitem__(self, idx):
+            assert idx == 0
+            return self._g
+
+    class IB:
+        def __init__(self, table):
+            self.req_ids = ["r1", "r2"]
+            self.req_id_to_index = {"r1": 0, "r2": 1}
+            self.num_computed_tokens_cpu = torch.tensor([8, 0])
+            self.block_table = BT(table)
+
+    table = torch.tensor([[2, 5, 7], [1, 0, 0]])
+    view = FullAttentionGroupView(IB(table), block_size=BLOCK_SIZE)
+    assert view.step_slots_cpu(["r1"], {"r1": 2}).tolist() == [7 * 4 + 0, 7 * 4 + 1]
+    assert view.step_slots_cpu(["r1"], {"r1": 8}).tolist() == [7 * 4 + i for i in range(4)]
+    assert view.step_slots_cpu(["r1"], {"r1": 0}).numel() == 0
+
+
+def test_join_next_step_previous_save():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0], 0, 2)})
+    assert len(mgr._join_next_step_tids) == 1
+    task_id = mgr._join_next_step_tids[0]
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"a": ([0], 2, 1)})
+    assert mgr._controller.get_task(task_id) is None
+    assert int(mgr._slot_status.state[HIDDEN_KEY][view.slots_for("a", 0, 2)].min()) == 2
+    mgr.materialize(s2, ["a"])
+
+
+def test_tenant_succession_hit_reads_newest():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0], 0, 4)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([0], 0, 4)}, finished=["a"])
+    mgr.materialize(s2, ["b"])
+    b_hidden = expected_rows(view.slots_for("b", 0, 4))
+    s3 = run_step(mgr, view, {"c": ([0, 1], 4, 2)}, new_hits={"c": 4}, finished=["b"])
+    outs = mgr.materialize(s3, ["c"])
+    assert torch.equal(outs.hidden_states["c"][:4], b_hidden)
+
+
+def test_tenant_succession_mm_key():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([2], 0, 4)}, mm={"k": torch.full((4, 2), 1.0)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([2], 0, 4)}, finished=["a"], mm={"k": torch.full((4, 2), 2.0)})
+    mgr.materialize(s2, ["b"])
+    s3 = run_step(
+        mgr, view, {"c": ([2, 3], 4, 2)}, new_hits={"c": 4}, finished=["b"], mm={"k": torch.full((2, 2), 3.0)}
+    )
+    rows = mgr.materialize(s3, ["c"]).mm_outputs["k"]["c"]
+    assert torch.equal(rows[:4], torch.full((4, 2), 2.0))
+    assert torch.equal(rows[4:], torch.full((2, 2), 3.0))
+
+
+def test_scatter_rows_coalesces_per_key_last_chunk_wins_and_skips_reassigned():
+    from vllm_omni.core.prefix_cache.controller import WriteSchedule, WriteTask, _BudgetTicket, _WriteChunk
+
+    t1, t2 = _BudgetTicket(nbytes=8), _BudgetTicket(nbytes=8)
+
+    def chunk(slots, base, ticket):
+        s = torch.tensor(slots, dtype=torch.int64)
+        host = {"k": torch.full((len(slots), 2), float(base)) + s[:, None]}
+        return _WriteChunk(slots_cpu=s, tensors={}, host=host, budget=ticket)
+
+    task = WriteTask(
+        tid=1,
+        req_id="a",
+        write_n=1,
+        schedule=WriteSchedule.JOIN_ON_FINISH,
+        chunks=[chunk([0, 1], 10, t1), chunk([2, 3], 20, t1), chunk([1, 4], 30, t2)],
+    )
+    assert task.budget_tickets() == [t1, t2]
+    task.add_reassigned("k", torch.tensor([3], dtype=torch.int64))
+    rows = task.scatter_rows()
+    assert len(rows) == 1
+    key, slots, host = rows[0]
+    assert key == "k" and slots.tolist() == [0, 2, 1, 4]
+    # slot 1: the third chunk's row (base 30) replaces the first chunk's; slot 3 is reassigned.
+    assert host[:, 0].tolist() == [10.0, 22.0, 31.0, 34.0]
+
+
+def test_slot_reuse_pushes_skip_to_old_task():
+    """Reassignment = task swap. Keep the old write in progress so the
+    new write records those rows as no longer owned by it."""
+    mgr, view = make_manager()
+
+    def hold(tasks):
+        for task in tasks:
+            task.host_ready.set()
+            task.done.set()  # satisfy the next save's done barrier; state stays QUEUED
+
+    mgr._controller.dispatch = hold
+    policy = ModelCachePolicy(needs_full_hidden_states=False)
+    mgr.register_policy(policy)
+    s1 = run_step(mgr, view, {"a": ([2], 0, 1)}, mm={"k": torch.ones(1, 2)})
+    mgr.materialize(s1, ["a"])
+    old_tid = next(iter(mgr._request_tasks.tasks["a"]))
+    old_task = mgr._controller.get_task(old_tid)
+    s2 = run_step(mgr, view, {"b": ([2], 0, 2)}, mm={"k": torch.full((2, 2), 2.0)})
+    assert old_task is not None and "k" in old_task.reassigned
+    reused = view.slots_for("b", 0, 1)
+    assert bool(torch.isin(reused, old_task.reassigned["k"]).all())
+    mgr.materialize(s2, ["b"])
+
+
+def test_step_slots_cpu_matches_block_table_math():
+    class TensorWrap:
+        def __init__(self, t):
+            self.cpu = t
+
+    class Group:
+        def __init__(self, t):
+            self.block_table = TensorWrap(t)
+
+    class BT:
+        def __init__(self, t):
+            self._g = Group(t)
+            self.block_tables = [self._g.block_table]
+
+        def __getitem__(self, idx):
+            return self._g
+
+    class IB:
+        def __init__(self, table, computed):
+            self.req_ids = ["r1", "r2"]
+            self.req_id_to_index = {"r1": 0, "r2": 1}
+            self.num_computed_tokens_cpu = torch.tensor(computed)
+            self.block_table = BT(table)
+
+    table = torch.tensor([[2, 5, 7], [1, 3, 4]])
+    view = FullAttentionGroupView(IB(table, [4, 0]), block_size=BLOCK_SIZE)
+    num_sched = {"r1": 3, "r2": 5}
+    got = view.step_slots_cpu(["r1", "r2"], num_sched)
+    want = torch.cat([_table_slots(table, 0, 4, 7), _table_slots(table, 1, 0, 5)])
+    assert torch.equal(got, want), (got, want)
+    assert torch.equal(view.step_slots_cpu(["r1", "r2"], {"r1": 3, "r2": 0}), _table_slots(table, 0, 4, 7))
+
+
+def _ib_with_layout(**layout):
+    """InputBatch fake whose group-0 block table carries vLLM's layout attrs."""
+    attrs = dict(kv_cache_block_size=BLOCK_SIZE, blocks_per_kv_block=1, use_hybrid_blocks=False, dcp_world_size=1)
+    attrs.update(layout)
+    group = SimpleNamespace(block_table=SimpleNamespace(cpu=torch.zeros((1, 2), dtype=torch.int32)), **attrs)
+
+    class BT:
+        block_tables = [group.block_table]
+
+        def __getitem__(self, idx):
+            return group
+
+    return SimpleNamespace(req_ids=[], req_id_to_index={}, num_computed_tokens_cpu=torch.zeros(1), block_table=BT())
+
+
+def test_group_view_refuses_hybrid_kernel_blocks_and_dcp():
+    """step_slots_cpu assumes one allocator block per table column and no
+    token striping; both are silent wrong-slot writes if not refused."""
+    FullAttentionGroupView(_ib_with_layout(), block_size=BLOCK_SIZE)
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="kernel_block_size"):
+        FullAttentionGroupView(_ib_with_layout(use_hybrid_blocks=True, blocks_per_kv_block=2), block_size=BLOCK_SIZE)
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="decode context parallel"):
+        FullAttentionGroupView(_ib_with_layout(dcp_world_size=2), block_size=BLOCK_SIZE)
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="does not match"):
+        FullAttentionGroupView(_ib_with_layout(kv_cache_block_size=BLOCK_SIZE * 2), block_size=BLOCK_SIZE)
+
+
+def test_step_context_consumed_by_id_not_order():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0], 0, 4)})
+    s2 = run_step(mgr, view, {"b": ([1], 0, 4)})
+    mgr.discard_step(s2)
+    outs = mgr.materialize(s1, ["a"])
+    assert torch.equal(outs.hidden_states["a"], expected_rows(view.slots_for("a", 0, 4)))
+    assert len(mgr._step_ctxs) == 0
+
+
+def test_step_context_exactly_once():
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"a": ([0], 0, 4)})
+    mgr.materialize(sid, ["a"])
+    with pytest.raises(OmniPrefixCacheUnmatchError):
+        mgr.materialize(sid, ["a"])
+    with pytest.raises(OmniPrefixCacheUnmatchError):
+        mgr.discard_step(sid)
+
+
+def test_unconsumed_contexts_timeout():
+    mgr, view = make_manager(staging_claim_timeout_s=0.0)
+    with pytest.raises(OmniPrefixCacheStagingTimeoutError, match="unconsumed step contexts"):
+        for pos in range(8):
+            run_step(mgr, view, {"a": ([0, 1, 2, 3], pos, 1)})
+
+
+def test_save_waits_until_a_slot_is_consumed():
+    mgr, view = make_manager(staging_depth=2, staging_claim_timeout_s=2.0)
+    s0 = run_step(mgr, view, {"a": ([0], 0, 1)})
+    s1 = run_step(mgr, view, {"a": ([0], 1, 1)})
+    err: list[BaseException] = []
+    sid_holder: list[int] = []
+
+    def _blocked_save() -> None:
+        try:
+            sid_holder.append(run_step(mgr, view, {"a": ([0], 2, 1)}))
+        except BaseException as e:
+            err.append(e)
+
+    t = threading.Thread(target=_blocked_save, daemon=True)
+    t.start()
+    time.sleep(0.1)
+    assert t.is_alive()
+    mgr.discard_step(s0)
+    t.join(timeout=1.0)
+    assert not t.is_alive()
+    assert not err
+    mgr.discard_step(s1)
+    mgr.discard_step(sid_holder[0])
+
+
+def test_leftover_only_save_claims_staging_slot():
+    policy = ModelCachePolicy(needs_full_hidden_states=False)
+    mgr, view = make_manager(policy=policy, staging_depth=2, staging_claim_timeout_s=0.0)
+    leftover = {"codes.ref": torch.zeros(3, 2)}
+    s0 = run_step(mgr, view, {"a": ([0], 0, 1)}, mm=leftover)
+    s1 = run_step(mgr, view, {"a": ([0], 1, 1)}, mm=leftover)
+    assert mgr._step_ctxs[s0].d2h is not None and mgr._step_ctxs[s0].d2h.views == {}
+    assert mgr._step_ctxs[s1].d2h is not None and mgr._step_ctxs[s1].d2h.views == {}
+    with pytest.raises(OmniPrefixCacheStagingTimeoutError, match="unconsumed step contexts"):
+        run_step(mgr, view, {"a": ([0], 2, 1)}, mm=leftover)
+
+
+def test_save_slot_mismatch_fails_fast():
+    mgr, view = make_manager()
+    view.order = ["a"]
+    view.req_blocks["a"] = [0]
+    view.computed["a"] = 0
+    mgr.new_step_starts(FakeSchedOut(new_reqs=[FakeNewReq("a")], num_scheduled={"a": 2}))
+    hidden = torch.zeros(4, HIDDEN, dtype=DTYPE)
+    with pytest.raises(OmniPrefixCacheUnmatchError):
+        mgr.save_outputs(hidden, {}, num_tokens_unpadded=4, num_tokens_padded=4)
+
+
+def test_materialize_rejects_out_of_snapshot_ids():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8}, finished=["a"])
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="outside the save snapshot"):
+        mgr.materialize(s2, ["b", "late_joiner"])
+
+
+def test_materialize_unknown_step_id_fails_fast():
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"a": ([0], 0, 4)})
+    with pytest.raises(OmniPrefixCacheUnmatchError):
+        mgr.materialize(sid + 999, ["ghost"])
+    mgr.discard_step(sid)
+
+
+def test_mm_hit_span_never_registered_serves_mirror_baseline():
+    """A hit span slot on which a sparse mm key was never registered is
+    legitimate absence — served from the mirror baseline, not a crash."""
+    policy = ModelCachePolicy(needs_full_hidden_states=True, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([0], 0, 4)}, mm={"k": torch.full((4, 2), 5.0)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"c": ([1], 0, 4)})
+    mgr.materialize(s2, ["c"])
+    s3 = run_step(mgr, view, {"b": ([0, 1, 2], 8, 2)}, new_hits={"b": 8}, mm={"k": torch.full((2, 2), 9.0)})
+    rows = mgr.materialize(s3, ["b"]).mm_outputs["k"]["b"]
+    assert torch.equal(rows[:4], torch.full((4, 2), 5.0))
+    assert torch.equal(rows[4:8], torch.zeros(4, 2))
+    assert torch.equal(rows[8:], torch.full((2, 2), 9.0))
+
+
+def test_mm_in_transit_unresolvable_fails_fast():
+    """Rows registered in-transit whose entry cannot serve them must raise."""
+    policy = ModelCachePolicy(needs_full_hidden_states=True, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([0], 0, 4)}, mm={"k": torch.full((4, 2), 1.0)})
+    mgr.materialize(s1, ["a"])
+    tid = mgr._request_tasks.deferred["a"].tid
+    mgr._controller._tasks.pop(tid)
+    s2 = run_step(mgr, view, {"b": ([0, 1], 4, 2)}, new_hits={"b": 4}, mm={"k": torch.full((2, 2), 9.0)})
+    with pytest.raises(OmniPrefixCacheUnmatchError):
+        mgr.materialize(s2, ["b"])
+
+
+def test_lock_never_covers_fetch_or_join():
+    """State lock must not be held across join / join_host_ready / fetch_host."""
+    policy = ModelCachePolicy(needs_full_hidden_states=True, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    calls = []
+
+    def probe(kind):
+        on_facade = not threading.current_thread().name.startswith("omni-prefix-cache-prefetch")
+        calls.append((kind, on_facade and mgr._state_lock.locked()))
+
+    real_fetch = mgr._controller.fetch_host
+    real_join_hr = mgr._controller.join_host_ready
+    real_join = mgr._controller.join
+    mgr._controller.fetch_host = lambda *a, **kw: (probe("fetch"), real_fetch(*a, **kw))[1]
+    mgr._controller.join_host_ready = lambda ids: (probe("join"), real_join_hr(ids))[1]
+    mgr._controller.join = lambda ids: (probe("join"), real_join(ids))[1]
+
+    s1 = run_step(mgr, view, {"a": ([0], 0, 4)}, mm={"k": torch.full((4, 2), 1.0)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([0, 1], 4, 2)}, new_hits={"b": 4}, mm={"k": torch.full((2, 2), 9.0)})
+    mgr.materialize(s2, ["b"])
+    assert any(kind == "fetch" for kind, _ in calls)
+    assert any(kind == "join" for kind, _ in calls)
+    assert all(not locked for _, locked in calls), calls
+
+
+def test_failed_write_fails_fast_at_next_facade_entry():
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"a": ([0], 0, 4)})
+    mgr.materialize(sid, ["a"])
+    from vllm_omni.core.prefix_cache.controller import WriteTask, _WriteChunk
+
+    task = WriteTask(
+        tid=999,
+        req_id="x",
+        write_n=1,
+        schedule=WriteSchedule.JOIN_NEXT_STEP,
+        chunks=[_WriteChunk(slots_cpu=torch.tensor([0]), tensors={})],
+    )
+    mgr._controller._tasks[999] = task
+    mgr._controller._fail_task(999)
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="write failed"):
+        run_step(mgr, view, {"a": ([0, 1], 4, 1)})
+    # Sticky: the record is one-shot and the first raise may land in a
+    # swallowed path (prefetch Future dropped by discard_step); a later
+    # entry must keep raising, never serve zeros for the lost rows.
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="write failed"):
+        run_step(mgr, view, {"c": ([0, 1], 0, 4)})
+
+
+def test_join_raises_on_failed_task():
+    """A joiner woken by FAILED must not treat the wake as a completed
+    write; the one-shot failure record may already be drained elsewhere."""
+    mgr, view = make_manager()
+    _hold_writes(mgr)
+    run_step(mgr, view, {"a": ([0], 0, 4)})
+    tid = next(iter(mgr._request_tasks.tasks["a"]))
+    mgr._controller._fail_task(tid)
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="failed before done"):
+        mgr._controller.join([tid])
+
+
+@pytest.mark.parametrize("fail_at", ["copy", "scatter"])
+def test_eager_dispatch_failure_releases_step_and_all_task_owners(monkeypatch, fail_at):
+    from vllm_omni.core.prefix_cache.controller import TaskState, WriteTask
+
+    mgr, view = make_manager(staging_claim_timeout_s=0)
+    ctrl = mgr._controller
+    preserved_sid = run_step(mgr, view, {"previous": ([3], 0, 4)})
+    if fail_at == "copy":
+        original = WriteTask.mark_host_ready
+
+        def fail_copy(task):
+            if task.req_id == "b":
+                raise RuntimeError("injected copy failure")
+            return original(task)
+
+        monkeypatch.setattr(WriteTask, "mark_host_ready", fail_copy)
+    else:
+        original = ctrl._scatter
+
+        def fail_scatter(task):
+            if task.req_id == "b":
+                raise RuntimeError("injected scatter failure")
+            return original(task)
+
+        monkeypatch.setattr(ctrl, "_scatter", fail_scatter)
+
+    try:
+        with pytest.raises(RuntimeError, match=f"injected {fail_at} failure"):
+            run_step(mgr, view, {"a": ([0], 0, 4), "b": ([1], 0, 4), "c": ([2], 0, 4)})
+        assert set(mgr._step_ctxs) == {preserved_sid}
+        assert ctrl._staged_bytes == 0
+        tasks = [task for task in ctrl._tasks.values() if task.req_id in {"a", "b", "c"}]
+        assert len(tasks) == 3
+        for task in tasks:
+            expected = TaskState.WRITTEN if task.req_id == "a" else TaskState.FAILED
+            assert task.state is expected
+            assert task.done.is_set() and task.host_ready.is_set()
+        assert all(
+            holder == StagingBufferHolder.for_step(preserved_sid)
+            for holders in ctrl._staging_pool._busy
+            for holder in holders
+        )
+        mgr.discard_step(preserved_sid)
+        assert all(not holders for holders in ctrl._staging_pool._busy)
+        with pytest.raises(OmniPrefixCacheUnmatchError, match="write failed"):
+            mgr.new_step_starts(FakeSchedOut())
+    finally:
+        mgr.shutdown()
+
+
+def test_eager_escalation_failure_releases_deferred_tasks(monkeypatch):
+    from vllm_omni.core.prefix_cache.controller import TaskState
+
+    mgr, view = make_manager(policy=ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"})))
+    ctrl = mgr._controller
+    sid = run_step(mgr, view, {"a": ([0], 0, 4), "b": ([1], 0, 4)}, mm={"k": torch.ones(8, 2)})
+    mgr.discard_step(sid)
+    assert ctrl._staged_bytes > 0
+    tasks = list(ctrl._tasks.values())
+
+    def fail_scatter(task):
+        raise RuntimeError("injected deferred scatter failure")
+
+    monkeypatch.setattr(ctrl, "_scatter", fail_scatter)
+    try:
+        with pytest.raises(RuntimeError, match="injected deferred scatter failure"):
+            ctrl.escalate([task.tid for task in tasks])
+        assert ctrl._staged_bytes == 0
+        assert all(task.state is TaskState.FAILED for task in tasks)
+        assert all(task.done.is_set() and task.host_ready.is_set() for task in tasks)
+        assert all(not holders for holders in ctrl._staging_pool._busy)
+        with pytest.raises(OmniPrefixCacheUnmatchError, match="write failed"):
+            mgr.new_step_starts(FakeSchedOut())
+    finally:
+        mgr.shutdown()
+
+
+def test_per_request_staging_writes():
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"p": ([0, 1], 0, 8), "d": ([2], 0, 1)})
+    tp = mgr._controller.get_task(next(iter(mgr._request_tasks.tasks["p"])))
+    td = mgr._controller.get_task(next(iter(mgr._request_tasks.tasks["d"])))
+    assert tp is not None and td is not None
+    assert (tp.req_id, td.req_id) == ("p", "d")
+    assert mgr._join_next_step_tids == [tp.tid, td.tid]
+    outs = mgr.materialize(sid, ["p", "d"])
+    assert torch.equal(outs.hidden_states["p"], expected_rows(view.slots_for("p", 0, 8)))
+    assert torch.equal(outs.hidden_states["d"], expected_rows(view.slots_for("d", 0, 1)))
+
+
+def test_staging_step_prefills_task_host_and_recycles():
+    mgr, view = make_manager()
+    for i in range(6):
+        sid = run_step(mgr, view, {"a": ([i % 8, (i % 8) + 8], i, 1)})
+        ctx = mgr._step_ctxs[sid]
+        assert ctx.d2h is not None
+        expect = expected_rows(view.slots_for("a", i, i + 1))
+        outs = mgr.materialize(sid, ["a"])
+        assert torch.equal(outs.hidden_states["a"], expect), i
+
+
+def test_oversized_step_fails_fast():
+    mgr, view = make_manager(staging_capacity_tokens=4)
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="staging capacity is 4"):
+        run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+
+
+def test_staging_slot_eager_save_leaves_only_step_holder():
+    """Eager submit writes the pool inline, so the task holder is bound and
+    released inside save; materialize then empties the slot."""
+    mgr, view = make_manager()
+    sid = run_step(mgr, view, {"p": ([0, 1], 0, 8)})
+    ctx = mgr._step_ctxs[sid]
+    assert ctx.d2h is not None
+    busy = mgr._controller._staging_pool._busy[ctx.d2h.staging_slot]
+    assert busy == {StagingBufferHolder.for_step(sid)}
+    mgr.materialize(sid, ["p"])
+    assert not busy
+
+
+def _hold_writes(mgr) -> None:
+    """Non-eager stand-in: dispatch takes the task to device→host done, but
+    leaves the pool write to the caller (`mgr._controller._scatter`)."""
+
+    def dispatch(tasks):
+        for task in tasks:
+            assert task.claim_copy()
+            task.mark_host_ready()
+
+    mgr._controller.dispatch = dispatch
+
+
+def test_eager_copy_runs_outside_state_lock_and_key_install_inside():
+    """Eager mode (NPU/CPU): the copy + pool write must not run under
+    _state_lock, or materialize on the builder thread waits a whole D2H;
+    publishing a new pool key must happen under it."""
+    policy = ModelCachePolicy(needs_full_hidden_states=True, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    seen: dict[str, bool] = {}
+
+    def probe(name):
+        free = mgr._state_lock.acquire(blocking=False)
+        if free:
+            mgr._state_lock.release()
+        seen[name] = free
+
+    real_run, real_install = mgr._controller._run_eager, mgr._pool.install_key
+
+    def run_eager(task):
+        probe("run_eager")
+        real_run(task)
+
+    def install_key(key, storage):
+        probe("install_key")
+        real_install(key, storage)
+
+    mgr._controller._run_eager = run_eager
+    mgr._pool.install_key = install_key
+    sid = run_step(mgr, view, {"a": ([0], 0, 2)}, mm={"k": torch.ones(2, 2)})
+    assert seen == {"run_eager": True, "install_key": False}
+    mgr.materialize(sid, ["a"])
+    assert mgr._pool.has_key("k") and "k" in mgr._slot_status.state
+
+
+def test_eager_finish_escalate_runs_outside_state_lock():
+    """Finish/abort escalate must not _run_eager under _state_lock."""
+    policy = ModelCachePolicy(needs_full_hidden_states=False, deferred_keys=frozenset({"k"}))
+    mgr, view = make_manager(policy=policy)
+    s1 = run_step(mgr, view, {"a": ([2], 0, 1)}, mm={"k": torch.ones(1, 2)})
+    mgr.materialize(s1, ["a"])
+    seen: list[bool] = []
+    real_run = mgr._controller._run_eager
+
+    def run_eager(task):
+        free = mgr._state_lock.acquire(blocking=False)
+        if free:
+            mgr._state_lock.release()
+        seen.append(free)
+        real_run(task)
+
+    mgr._controller._run_eager = run_eager
+    s2 = run_step(mgr, view, {"z": ([9], 0, 1)}, finished=["a"])
+    assert seen == [True]
+    mgr.materialize(s2, ["z"])
+
+
+def test_staging_task_slot_released_at_pool_write_not_drain():
+    mgr, view = make_manager()
+    _hold_writes(mgr)
+    sid = run_step(mgr, view, {"p": ([0, 1], 0, 8)})
+    ctx = mgr._step_ctxs[sid]
+    tid = next(iter(mgr._request_tasks.tasks["p"]))
+    busy = mgr._controller._staging_pool._busy[ctx.d2h.staging_slot]
+    assert StagingBufferHolder.for_task(tid) in busy and StagingBufferHolder.for_step(sid) in busy
+    task = mgr._controller.get_task(tid)
+    mgr._controller._scatter(task)
+    # Released by the committer's pool write; the manager has not drained yet.
+    assert busy == {StagingBufferHolder.for_step(sid)}
+    assert mgr._controller.get_task(tid) is not None
+    mgr.materialize(sid, ["p"])
+    assert not busy
+    assert mgr._controller.get_task(tid) is None
+
+
+def test_blocked_save_is_released_by_pool_write_alone():
+    """All step contexts consumed, the only slot held by a pending write:
+    the committer finishing that write must unblock the waiting save."""
+    mgr, view = make_manager(staging_depth=1, staging_claim_timeout_s=2.0)
+    _hold_writes(mgr)
+    s0 = run_step(mgr, view, {"a": ([0], 0, 1)})
+    tid = next(iter(mgr._request_tasks.tasks["a"]))
+    mgr.materialize(s0, ["a"])
+    slot = mgr._step_ctxs.get(s0)  # consumed
+    assert slot is None
+    assert mgr._controller._staging_pool._busy[0] == {StagingBufferHolder.for_task(tid)}
+    err: list[BaseException] = []
+    sid_holder: list[int] = []
+
+    def _blocked_save() -> None:
+        try:
+            sid_holder.append(run_step(mgr, view, {"a": ([0], 1, 1)}))
+        except BaseException as e:
+            err.append(e)
+
+    t = threading.Thread(target=_blocked_save, daemon=True)
+    t.start()
+    time.sleep(0.1)
+    assert t.is_alive()
+    mgr._controller._scatter(mgr._controller.get_task(tid))
+    t.join(timeout=1.0)
+    assert not t.is_alive()
+    assert not err
+    mgr.discard_step(sid_holder[0])
+
+
+def test_hit_prefetch_prebuilds_merged_buffer():
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    mgr.materialize(s1, ["a"])
+    s2 = run_step(mgr, view, {"b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8}, finished=["a"])
+    ctx = mgr._step_ctxs[s2]
+    fut = ctx.hit_prefetch["b"][HIDDEN_KEY]
+    buf = fut.result()
+    assert buf.shape == (12, HIDDEN)
+    assert torch.equal(buf[:8], expected_rows(view.slots_for("b", 0, 8)))
+    merged = mgr.materialize(s2, ["b"]).hidden_states["b"]
+    assert merged.data_ptr() == buf.data_ptr()
+    assert torch.equal(merged[8:], expected_rows(view.slots_for("b", 8, 12)))
+
+
+def test_same_step_hit_prefetch_starts_at_save(caplog):
+    """b hits blocks a computes in the same step: nothing to plan at
+    new_step_starts (rows ABSENT), planned at publish once a's write is
+    registered, so the gather runs before the next step can reuse them."""
+    mgr, view = make_manager()
+    view.req_blocks["a"] = [0, 1]
+    with caplog.at_level(logging.CRITICAL, logger="vllm_omni.core.prefix_cache.manager"):
+        sid = run_step(mgr, view, {"a": ([0, 1], 0, 8), "b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8})
+    assert not any("omni prefix cache unmatch" in r.message for r in caplog.records)
+    ctx = mgr._step_ctxs[sid]
+    fut = ctx.hit_prefetch["b"][HIDDEN_KEY]
+    assert torch.equal(fut.result()[:8], expected_rows(view.slots_for("b", 0, 8)))
+    outs = mgr.materialize(sid, ["a", "b"])
+    assert torch.equal(outs.hidden_states["b"][:8], expected_rows(view.slots_for("b", 0, 8)))
+
+
+def test_delayed_read_of_reassigned_hit_raises():
+    """A version check with no COW copy still raises for live and finished.
+    The production path registers the ref first so remap preserves the rows
+    (see test_delayed_read_after_committed_reuse_serves_preserved)."""
+    mgr, view = make_manager()
+    s1 = run_step(mgr, view, {"a": ([0, 1], 0, 8)})
+    mgr.materialize(s1, ["a"])
+    slots = view.slots_for("a", 0, 8)
+    with mgr._state_lock:
+        planned = mgr._slot_status.get_slot_status(HIDDEN_KEY).slot_version[slots].clone()
+    mgr._controller.dispatch = lambda tasks: None  # new tenant's write stays IN_TRANSIT
+    s2 = run_step(mgr, view, {"c": ([0, 1], 0, 8)}, finished=["a"])
+    for req in ("c", "a"):  # live then finished — both fatal without a preserved copy
+        with pytest.raises(OmniPrefixCacheUnmatchError, match="reassigned"):
+            mgr._ensure_not_reassigned(slots, HIDDEN_KEY, req_id=req, planned_version=planned)
+    mgr.discard_step(s2)
+
+
+def test_delayed_read_after_committed_reuse_serves_preserved():
+    """Amy's block-0 reuse: plan A's read, then B commits over the same
+    slots. The reusing write copy-on-writes A's committed rows into the
+    planned ref; the delayed fetch must return those, not B's."""
+    mgr, view = make_manager()
+    sa = run_step(mgr, view, {"a": ([0], 0, 4)})
+    mgr.materialize(sa, ["a"])  # A committed into block 0
+    slots = view.slots_for("a", 0, 4)
+    with mgr._state_lock:
+        src = mgr._slot_ref(slots, HIDDEN_KEY, "a")  # plan A's read
+    assert src.already_staged and not src.staged_list and not src.join_tids
+    sb = run_step(mgr, view, {"b": ([0], 0, 4)}, finished=["a"])
+    mgr.materialize(sb, ["b"])  # A freed, block 0 reused by B and COMMITTED
+    # run_step derives rows from slot ids, so A's and B's values coincide.
+    # Scribble the pool so only the preserved copy can produce A's rows.
+    assert set(src.preserved) == {int(s) for s in slots.tolist()}
+    with torch.inference_mode():
+        mgr._pool.write(HIDDEN_KEY, slots, torch.full((4, HIDDEN), 99.0, dtype=DTYPE))
+        got = mgr._fetch_source(src)
+    assert torch.equal(got, expected_rows(slots))
+    assert all(ref is not src for ref in mgr._pending_reads)
+
+
+def test_done_fires_only_after_completion_record_published():
+    """A join(done) waiter (the save barrier) must find the completion record
+    on its next drain — done-before-append leaves occupancy IN_TRANSIT and the
+    COW preserve skips the reused rows."""
+    mgr, view = make_manager()
+    checks = []
+    orig_scatter = mgr._controller._scatter
+
+    def scatter(task):
+        orig_set = task.done.set
+
+        def checked_set():
+            checks.append(task.tid in mgr._controller._completed)
+            orig_set()
+
+        task.done.set = checked_set
+        orig_scatter(task)
+
+    mgr._controller._scatter = scatter
+    sid = run_step(mgr, view, {"a": ([0], 0, 4)})
+    mgr.materialize(sid, ["a"])
+    assert checks and all(checks)
+
+
+def test_failed_wakes_only_after_failure_record_published():
+    """Same window as the done/_completed one, failure side: a joiner woken
+    by FAILED must find the record on drain, not read never-written rows."""
+    mgr, view = make_manager()
+    _hold_writes(mgr)  # keep the write non-terminal
+    run_step(mgr, view, {"a": ([0], 0, 4)})
+    tid = next(iter(mgr._request_tasks.tasks["a"]))
+    task = mgr._controller.get_task(tid)
+    checks = []
+    orig_set = task.done.set
+
+    def checked_set():
+        checks.append(tid in mgr._controller._failed)
+        orig_set()
+
+    task.done.set = checked_set
+    mgr._controller._fail_task(tid)
+    assert checks and all(checks)
+
+
+def test_save_waits_pool_write_of_previous_step():
+    """A save must not reuse slots whose JOIN_NEXT_STEP write has not reached
+    the pool — no delayed read could recover such a row."""
+    mgr, view = make_manager(staging_claim_timeout_s=0.2)
+    _hold_writes(mgr)  # host_ready only; the pool write never happens
+    run_step(mgr, view, {"a": ([0], 0, 4)})
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="did not reach done"):
+        run_step(mgr, view, {"b": ([1], 0, 4)})
+
+
+def test_join_next_step_hit_survives_task_already_drained():
+    mgr, view = make_manager()
+    mgr._controller.dispatch = lambda tasks: None  # registered, never run
+    view.req_blocks["a"] = [0, 1]
+    sid = run_step(mgr, view, {"a": ([0, 1], 0, 8), "b": ([0, 1, 2], 8, 4)}, new_hits={"b": 8})
+    with mgr._state_lock:
+        src = mgr._slot_ref(view.slots_for("b", 0, 8), HIDDEN_KEY, "b")
+    for tid in src.join_tids:
+        mgr._controller._run_eager(mgr._controller.get_task(tid))
+    with torch.inference_mode():
+        with mgr._state_lock:
+            mgr._commit_drained_writes()
+        assert mgr._controller.get_task(src.join_tids[0]) is None
+        assert torch.equal(mgr._fetch_source(src), expected_rows(view.slots_for("b", 0, 8)))
+    mgr.materialize(sid, ["a", "b"])
+
+
+def test_leftover_mm_snapshot_survives_live_overwrite():
+    """Leftover mm is copied at save; mutating the live buffer
+    afterwards must not change the snapshot."""
+    mgr, view = make_manager()
+    live = [torch.arange(10, dtype=DTYPE)]
+    sid = run_step(mgr, view, {"a": ([0], 0, 2)}, mm={"codes.ref": live})
+    assert "codes.ref" in mgr._step_ctxs[sid].mm_cpu_snapshot
+    snap = mgr._step_ctxs[sid].mm_cpu_snapshot["codes.ref"]
+    live[0].fill_(99.0)
+    assert torch.equal(snap[0], torch.arange(10, dtype=DTYPE))
+    mgr.discard_step(sid)
+
+
+@pytest.mark.parametrize("needs_full_hidden_states", [True, False])
+def test_deferred_leftover_snapshot_survives_live_overwrite(needs_full_hidden_states):
+    """Deferred tails are leftover-copied at save for materialize; the GPU
+    freeze is a different product (pool write on finish). ``False`` is the
+    hidden opt-out + miss path (Qwen3-TTS / Higgs talker)."""
+    policy = ModelCachePolicy(
+        needs_full_hidden_states=needs_full_hidden_states, deferred_keys=frozenset({"codes.audio"})
+    )
+    mgr, view = make_manager(policy=policy)
+    live = torch.full((2, 2), 1.0)
+    ref = [torch.arange(4, dtype=DTYPE)]
+    sid = run_step(mgr, view, {"a": ([0], 0, 2)}, mm={"codes.audio": live, "codes.ref": ref})
+    assert "codes.audio" in mgr._step_ctxs[sid].mm_cpu_snapshot
+    live.fill_(99.0)
+    ref[0].fill_(99.0)
+    outs = mgr.materialize(sid, ["a"])
+    assert torch.equal(outs.mm_outputs["codes.audio"]["a"], torch.full((2, 2), 1.0))
+    assert torch.equal(outs.mm_outputs["codes.ref"]["a"][0], torch.arange(4, dtype=DTYPE))
+    assert (outs.hidden_states is None) == (not needs_full_hidden_states)
+
+
+def test_frozen_mm_clone_survives_live_overwrite():
+    mgr, view = make_manager()
+    live = torch.full((2, 2), 1.0)
+    sid = run_step(mgr, view, {"a": ([0], 0, 2)}, mm={"codes.audio": live})
+    assert "codes.audio" not in mgr._step_ctxs[sid].mm_cpu_snapshot
+    live.fill_(99.0)
+    outs = mgr.materialize(sid, ["a"])
+    assert torch.equal(outs.mm_outputs["codes.audio"]["a"], torch.full((2, 2), 1.0))
+
+
+def test_hidden_opt_out_miss_returns_mm_and_releases_slot():
+    policy = ModelCachePolicy(needs_full_hidden_states=False)
+    mgr, view = make_manager(policy=policy)
+    for i in range(6):
+        sid = run_step(mgr, view, {"a": ([i % 8, (i % 8) + 8], i, 1)}, mm={"k": torch.full((1, 2), float(i))})
+        ctx = mgr._step_ctxs[sid]
+        assert ctx.d2h is not None, i
+        outs = mgr.materialize(sid, ["a"])
+        assert outs.hidden_states is None
+        assert torch.equal(outs.mm_outputs["k"]["a"], torch.full((1, 2), float(i)))
+        assert not mgr._controller._staging_pool._busy[ctx.d2h.staging_slot], i
+
+
+def test_save_releases_staging_if_commit_drained_writes_fails():
+    mgr, view = make_manager(staging_depth=2)
+    calls = {"n": 0}
+    real = mgr._commit_drained_writes
+
+    def wrapped():
+        calls["n"] += 1
+        if calls["n"] == 2:
+            raise OmniPrefixCacheUnmatchError("injected fail")
+        return real()
+
+    mgr._commit_drained_writes = wrapped
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="injected fail"):
+        run_step(mgr, view, {"a": ([0], 0, 4)})
+    assert all(not busy for busy in mgr._controller._staging_pool._busy)
+    mgr._commit_drained_writes = real
+    sid = run_step(mgr, view, {"a": ([0], 0, 4)})
+    assert mgr._step_ctxs[sid].d2h is not None
+    mgr.materialize(sid, ["a"])
+
+
+def test_fetch_host_maps_slots_across_layouts():
+    """Identity, prefix, gapped, and a two-`_WriteChunk` gather."""
+    from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+    from vllm_omni.core.prefix_cache.controller import OmniPrefixCacheController, WriteTask, _WriteChunk
+
+    cfg = PrefixCacheConfig(num_blocks=NUM_BLOCKS, block_size=BLOCK_SIZE)
+    pool = PrefixBlockPool(cfg)
+    pool.ensure_key(HIDDEN_KEY, DTYPE, HIDDEN)
+    ctrl = OmniPrefixCacheController(pool, cfg, eager=True)
+
+    slots = torch.tensor([40, 41, 42, 43, 44], dtype=torch.int64)
+    rows = torch.arange(slots.numel() * HIDDEN, dtype=DTYPE).reshape(slots.numel(), HIDDEN)
+
+    def _expect(want):
+        return torch.stack([rows[(slots == s).nonzero()[0, 0]] for s in want.tolist()])
+
+    one = WriteTask(
+        tid=1,
+        req_id="r",
+        write_n=1,
+        schedule=WriteSchedule.JOIN_ON_FINISH,
+        chunks=[_WriteChunk(slots_cpu=slots, tensors={HIDDEN_KEY: rows})],
+    )
+    for want in (slots, slots[:3], slots[[0, 1, 3, 4]]):
+        assert torch.equal(ctrl.fetch_host(one, want, HIDDEN_KEY), _expect(want))
+
+    two = WriteTask(
+        tid=2,
+        req_id="r",
+        write_n=2,
+        schedule=WriteSchedule.JOIN_ON_FINISH,
+        chunks=[
+            _WriteChunk(slots_cpu=slots[:3], tensors={HIDDEN_KEY: rows[:3]}),
+            _WriteChunk(slots_cpu=slots[3:], tensors={HIDDEN_KEY: rows[3:]}),
+        ],
+    )
+    want = slots[[0, 3, 1, 4]]
+    assert torch.equal(ctrl.fetch_host(two, want, HIDDEN_KEY), _expect(want))
+
+
+def test_fetch_host_waits_staging_step_d2h_event():
+    """JOIN_NEXT_STEP stores chunk.host as a staging view; fetch_host waits
+    step_d2h_event before slicing. Production JOIN_NEXT_STEP hits wait for
+    the pool write instead; this is the unit-level wait contract for that branch."""
+    from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+    from vllm_omni.core.prefix_cache.controller import OmniPrefixCacheController, WriteTask, _WriteChunk
+
+    cfg = PrefixCacheConfig(num_blocks=NUM_BLOCKS, block_size=BLOCK_SIZE)
+    pool = PrefixBlockPool(cfg)
+    ctrl = OmniPrefixCacheController(pool, cfg, eager=True)
+
+    slots = torch.tensor([0, 1, 2], dtype=torch.int64)
+    src = torch.arange(3 * HIDDEN, dtype=DTYPE).reshape(3, HIDDEN)
+    landing = torch.zeros_like(src)
+
+    class _HostEvent:
+        n = 0
+
+        def synchronize(self):
+            self.n += 1
+            landing.copy_(src)
+
+    event = _HostEvent()
+    chunk = _WriteChunk(slots_cpu=slots, tensors={HIDDEN_KEY: src})
+    chunk.host = {HIDDEN_KEY: landing}
+    task = WriteTask(
+        tid=1,
+        req_id="r",
+        write_n=1,
+        schedule=WriteSchedule.JOIN_NEXT_STEP,
+        chunks=[chunk],
+        staging_slot=0,
+        step_d2h_event=event,
+    )
+    rows = ctrl.fetch_host(task, slots, HIDDEN_KEY)
+    assert event.n == 1
+    assert torch.equal(rows, src)
+
+
+def _bare_controller(eager=True):
+    from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+    from vllm_omni.core.prefix_cache.controller import OmniPrefixCacheController
+
+    cfg = PrefixCacheConfig(num_blocks=NUM_BLOCKS, block_size=BLOCK_SIZE)
+    pool = PrefixBlockPool(cfg)
+    pool.ensure_key(HIDDEN_KEY, DTYPE, HIDDEN)
+    ctrl = OmniPrefixCacheController(pool, cfg, eager=eager)
+    return ctrl, pool
+
+
+def _bare_task(tid=7, schedule=WriteSchedule.JOIN_NEXT_STEP, host=None, tensors=None, budget=None, queued=False):
+    from vllm_omni.core.prefix_cache.controller import TaskState, WriteTask, _WriteChunk
+
+    slots = torch.tensor([0, 1], dtype=torch.int64)
+    chunk = _WriteChunk(slots_cpu=slots, tensors=tensors or {}, budget=budget)
+    if host is not None:
+        chunk.host = {HIDDEN_KEY: host}
+    task = WriteTask(tid=tid, req_id="r", write_n=1, schedule=schedule, chunks=[chunk])
+    if queued:
+        task.transition(TaskState.QUEUED)
+    return task, slots
+
+
+def test_task_state_is_a_strict_chain():
+    """PENDING -> QUEUED -> COPYING -> HOST_READY -> WRITTEN, one step at a time."""
+    from vllm_omni.core.prefix_cache.controller import TaskState
+
+    task, _ = _bare_task()
+    assert task.state is TaskState.PENDING
+    assert not task.claim_copy()  # PENDING may not skip QUEUED
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="illegal transition PENDING -> HOST_READY"):
+        task.transition(TaskState.HOST_READY)
+    task.transition(TaskState.QUEUED)
+    assert task.claim_copy()
+    assert task.state is TaskState.COPYING and not task.host_ready.is_set()
+    assert not task.claim_copy()  # second claimant loses
+    task.mark_host_ready()
+    assert task.state is TaskState.HOST_READY and task.host_ready.is_set() and not task.done.is_set()
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="illegal transition HOST_READY -> COPYING"):
+        task.transition(TaskState.COPYING)  # no going back
+    task.mark_done()
+    assert task.state is TaskState.WRITTEN and task.done.is_set()
+    assert not task.mark_failed()  # terminal stays terminal
+    assert task.state is TaskState.WRITTEN
+
+
+def test_task_failed_sets_both_events_and_closes_append():
+    from vllm_omni.core.prefix_cache.controller import TaskState, _WriteChunk
+
+    task, slots = _bare_task()
+    assert task.mark_failed()
+    assert task.state is TaskState.FAILED and task.host_ready.is_set() and task.done.is_set()
+    assert task.append_chunk(_WriteChunk(slots_cpu=slots, tensors={})) is TaskState.FAILED
+
+
+def test_escalate_leaves_claimed_task_alone():
+    """Once the worker owns the copy stage (COPYING), escalate must not
+    re-queue the tid — that re-queue was the double-write race."""
+    from vllm_omni.core.prefix_cache.controller import TaskState
+
+    ctrl, _ = _bare_controller(eager=True)
+    ctrl._eager = False  # exercise the queue path without a worker thread
+    later, _ = _bare_task(tid=1, schedule=WriteSchedule.JOIN_ON_FINISH)
+    ctrl.submit(later, queued=False)
+    assert later.state is TaskState.PENDING
+    ctrl.escalate([1])
+    assert later.state is TaskState.QUEUED and list(ctrl._queue_hi) == [1]
+    ctrl.escalate([1])  # already high-priority: no duplicate
+    assert list(ctrl._queue_hi) == [1]
+
+    ctrl._queue_hi.clear()
+    later.transition(TaskState.COPYING)
+    ctrl.escalate([1])
+    assert list(ctrl._queue_hi) == [] and list(ctrl._queue_lo) == []
+
+
+def test_join_on_stuck_committer_raises_instead_of_hanging():
+    from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+    from vllm_omni.core.prefix_cache.controller import OmniPrefixCacheController, TaskState
+
+    cfg = PrefixCacheConfig(num_blocks=NUM_BLOCKS, block_size=BLOCK_SIZE, staging_claim_timeout_s=0.05)
+    ctrl = OmniPrefixCacheController(PrefixBlockPool(cfg), cfg, eager=True)
+    ctrl._eager = False  # queue path without a worker thread: nothing will finish the task
+    task, _ = _bare_task(tid=1, schedule=WriteSchedule.JOIN_ON_FINISH)
+    ctrl.submit(task, queued=True)
+    task.transition(TaskState.COPYING)
+
+    with pytest.raises(
+        OmniPrefixCacheUnmatchError, match=r"task 1 \(join_on_finish\) did not reach host_ready .*state=COPYING"
+    ):
+        ctrl.join_host_ready([1])
+    with pytest.raises(OmniPrefixCacheUnmatchError, match="did not reach done"):
+        ctrl.join([1])
+
+
+def test_scatter_host_ready_writes_only_staged_tasks():
+    from vllm_omni.core.prefix_cache.controller import TaskState
+
+    ctrl, pool = _bare_controller()
+    task, slots = _bare_task(host=torch.ones(2, HIDDEN), queued=True)
+    ctrl._tasks[task.tid] = task
+    assert task.claim_copy()
+    ctrl._blocked.append(task.tid)
+    ctrl._scatter_host_ready()  # COPYING: not ready, stays blocked
+    assert ctrl._blocked == [task.tid] and list(ctrl._completed) == []
+    task.mark_host_ready()
+    ctrl._scatter_host_ready()
+    assert ctrl._blocked == [] and list(ctrl._completed) == [task.tid]
+    assert task.state is TaskState.WRITTEN
+    assert torch.equal(pool.rows(HIDDEN_KEY, slots), torch.ones(2, HIDDEN))
+
+
+def test_budget_ticket_uncharges_once_per_clone():
+    from vllm_omni.core.prefix_cache.controller import _BudgetTicket
+
+    ctrl, _ = _bare_controller()
+    ticket = _BudgetTicket(nbytes=100)
+    ctrl.reserve(100)
+    a, _ = _bare_task(tid=1, budget=ticket)
+    b, _ = _bare_task(tid=2, budget=ticket)
+    ctrl.pin_budget(ticket, 1)
+    ctrl.pin_budget(ticket, 2)
+    ctrl._release_staged_bytes(a)
+    assert ctrl._staged_bytes == 100  # b still holds the clone
+    ctrl._release_staged_bytes(a)  # idempotent per tid
+    assert ctrl._staged_bytes == 100
+    ctrl._release_staged_bytes(b)
+    assert ctrl._staged_bytes == 0
+    ctrl._release_staged_bytes(b)  # freed once, never twice
+    assert ctrl._staged_bytes == 0
+
+
+def test_fail_task_after_copy_does_not_uncharge_twice():
+    from vllm_omni.core.prefix_cache.controller import TaskState, _BudgetTicket
+
+    ctrl, _ = _bare_controller()
+    ticket = _BudgetTicket(nbytes=64)
+    ctrl.reserve(64)
+    task, _ = _bare_task(tid=3, budget=ticket, queued=True)
+    ctrl._tasks[task.tid] = task
+    ctrl.pin_budget(ticket, 3)
+    assert task.claim_copy()
+    task.mark_host_ready()
+    ctrl._release_staged_bytes(task)  # what _copy_task does on HOST_READY
+    assert ctrl._staged_bytes == 0
+    ctrl._fail_task(3)
+    assert task.state is TaskState.FAILED and ctrl._staged_bytes == 0
+    assert list(ctrl._failed) == [3]
+    ctrl._fail_task(3)  # terminal: no second publish
+    assert list(ctrl._failed) == [3]
+
+
+def test_from_vllm_config_uses_batched_tokens():
+    cfg = PrefixCacheConfig.from_vllm_config(
         num_blocks=NUM_BLOCKS,
         block_size=BLOCK_SIZE,
-        hidden_size=HIDDEN_SIZE,
-        hs_dtype=DTYPE,
+        scheduler_config=SimpleNamespace(max_num_batched_tokens=8192, max_model_len=32768, max_num_seqs=64),
     )
-    return cache
-
-
-def get_multimodal_outputs(feat_dims: dict[str, int], seq_len: int) -> dict[str, torch.Tensor]:
-    fake_mm_inputs = {}
-    for mm_key, feat_dim in feat_dims.items():
-        fake_mm_inputs[mm_key] = torch.rand((seq_len, feat_dim), dtype=DTYPE)
-    return fake_mm_inputs
-
-
-### Tests for initialization
-def test_initialization_simple():
-    """Check default initialization only creates the hidden states."""
-    cache = get_omni_pcache()
-    assert isinstance(cache.hidden_states_cache, torch.Tensor)
-    assert cache.hidden_states_cache.shape == DEFAULT_SHAPE
-    assert len(cache.mm_outputs_cache) == 0
-    assert len(cache.mm_cache_keys) == 0
-
-
-def test_initialization_with_multimodal():
-    """Check initialization + registration of multimodal outputs."""
-    cache = get_omni_pcache()
-    feat_dims = {"foo": 100, "bar": 50, "baz": 10}
-    mm_outputs = get_multimodal_outputs(
-        feat_dims,
-        seq_len=DEFAULT_SEQ_LEN,
+    assert cfg.staging_capacity_tokens == 8192
+    assert cfg.staging_depth == 4
+    cfg_fallback = PrefixCacheConfig.from_vllm_config(
+        num_blocks=NUM_BLOCKS,
+        block_size=BLOCK_SIZE,
+        scheduler_config=SimpleNamespace(max_num_batched_tokens=None, max_model_len=4096),
     )
-    # Cast one of the keys to a different dtype; the dtype of the tensor
-    # that is used to initialize the cache dictates the cache dtype.
-    mm_outputs["foo"] = mm_outputs["foo"].to(OTHER_DTYPE)
-
-    cache.maybe_init_missing_mm_cache_keys(mm_outputs, DEFAULT_SEQ_LEN)
-    assert len(cache.mm_cache_keys) == 3
-    assert set(cache.mm_cache_keys) == set(feat_dims.keys())
-    for mm_key in cache.mm_cache_keys:
-        cache_tensor = cache.mm_outputs_cache[mm_key]
-        assert isinstance(cache_tensor, torch.Tensor)
-        assert cache_tensor.shape[-1] == feat_dims[mm_key]
-        assert mm_outputs[mm_key].dtype == cache_tensor.dtype
-
-
-def test_init_missing_mm_cache_keys_is_idempotent():
-    """Ensure that the cache doesn't reinitialize old keys."""
-    cache = get_omni_pcache()
-    mm_key = "foo"
-    feat_dims = {mm_key: 100}
-    mm_outputs = get_multimodal_outputs(
-        feat_dims,
-        seq_len=DEFAULT_SEQ_LEN,
-    )
-    cache.maybe_init_missing_mm_cache_keys(mm_outputs, DEFAULT_SEQ_LEN)
-    assert len(cache.mm_cache_keys) == 1
-    assert mm_key in cache.mm_cache_keys
-
-    # Cache is initialized to 0 - fill it with 1s
-    cache.mm_outputs_cache[mm_key].fill_(1)
-
-    # Ensure that running another initialization
-    # doesn't zero out our cache values
-    cache.maybe_init_missing_mm_cache_keys(mm_outputs, DEFAULT_SEQ_LEN)
-    assert len(cache.mm_cache_keys) == 1
-    assert mm_key in cache.mm_cache_keys
-    assert torch.all(cache.mm_outputs_cache[mm_key] == 1)
-
-
-### Tests for Update
-def test_update_no_multimodal():
-    """Test that slot mappings act as row indices hidden states."""
-    cache = get_omni_pcache()
-
-    num_tokens_unpadded = 8
-    slot_offset = 8
-    slot_mapping = torch.arange(slot_offset, slot_offset + num_tokens_unpadded)
-    new_hidden_states = torch.rand((num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=new_hidden_states,
-        multimodal_outputs=None,
-        num_tokens_unpadded=num_tokens_unpadded,
-        slot_mapping=slot_mapping,
-    )
-
-    # Ensure that if we reshape our 3D cache back to 2D, we can use the
-    # indices in our slot mappings to access the hidden states as expected
-    hs_rows = cache.hidden_states_cache.view(NUM_BLOCKS * BLOCK_SIZE, HIDDEN_SIZE)
-    for slot_idx, new_states in zip(slot_mapping, new_hidden_states):
-        slot_states = hs_rows[slot_idx]
-        assert torch.all(slot_states == new_states)
-
-
-def test_update_uses_precomputed_hidden_states_cpu():
-    """Precomputed CPU staging should be the only hidden-state cache source."""
-    cache = get_omni_pcache()
-
-    num_tokens_unpadded = 8
-    slot_offset = 8
-    slot_mapping = torch.arange(slot_offset, slot_offset + num_tokens_unpadded)
-    hidden_states = torch.zeros((num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-    hidden_states_cpu = torch.rand((num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=hidden_states,
-        hidden_states_cpu=hidden_states_cpu,
-        multimodal_outputs=None,
-        num_tokens_unpadded=num_tokens_unpadded,
-        slot_mapping=slot_mapping,
-    )
-
-    hs_rows = cache.hidden_states_cache.view(NUM_BLOCKS * BLOCK_SIZE, HIDDEN_SIZE)
-    for slot_idx, new_states in zip(slot_mapping, hidden_states_cpu):
-        slot_states = hs_rows[slot_idx]
-        assert torch.all(slot_states == new_states)
-
-
-@pytest.mark.parametrize(
-    "hidden_states_cpu",
-    [
-        torch.rand((4, HIDDEN_SIZE), dtype=DTYPE),
-        torch.rand((8, HIDDEN_SIZE), dtype=OTHER_DTYPE),
-        torch.rand((8, HIDDEN_SIZE + 1), dtype=DTYPE),
-        torch.rand((HIDDEN_SIZE, 8), dtype=DTYPE).t(),
-    ],
-)
-def test_update_rejects_invalid_hidden_states_cpu(hidden_states_cpu):
-    cache = get_omni_pcache()
-
-    num_tokens_unpadded = 8
-    slot_mapping = torch.arange(num_tokens_unpadded)
-    hidden_states = torch.rand((num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-
-    with pytest.raises(RuntimeError):
-        cache.update_omni_tensor_prefix_cache(
-            hidden_states=hidden_states,
-            hidden_states_cpu=hidden_states_cpu,
-            multimodal_outputs=None,
-            num_tokens_unpadded=num_tokens_unpadded,
-            slot_mapping=slot_mapping,
-        )
-
-
-@pytest.mark.skipif(not torch.cuda.is_available(), reason="requires CUDA")
-def test_update_rejects_gpu_hidden_states_cpu():
-    cache = get_omni_pcache()
-
-    num_tokens_unpadded = 8
-    slot_mapping = torch.arange(num_tokens_unpadded)
-    hidden_states = torch.rand((num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-    hidden_states_cpu = torch.rand((num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE, device="cuda")
-
-    with pytest.raises(RuntimeError):
-        cache.update_omni_tensor_prefix_cache(
-            hidden_states=hidden_states,
-            hidden_states_cpu=hidden_states_cpu,
-            multimodal_outputs=None,
-            num_tokens_unpadded=num_tokens_unpadded,
-            slot_mapping=slot_mapping,
-        )
-
-
-@pytest.mark.parametrize(
-    "feat_dims",
-    [
-        {"foo": 100, "bar": 100},
-        {"foo": 100, "bar": 50, "baz": 10},
-    ],
-)
-def test_update_with_multimodal_outputs(feat_dims):
-    """Test that slot mappings are correct for multimodal tensors."""
-    cache = get_omni_pcache_with_mm_tensors(feat_dims, seq_len=DEFAULT_SEQ_LEN)
-
-    num_tokens_unpadded = 8
-    slot_offset = 8
-    slot_mapping = torch.arange(slot_offset, slot_offset + num_tokens_unpadded)
-    feature_dims = {key: val.shape[-1] for key, val in cache.mm_outputs_cache.items()}
-    mm_outputs = {key: torch.rand((num_tokens_unpadded, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys}
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs=mm_outputs,
-        num_tokens_unpadded=num_tokens_unpadded,
-        slot_mapping=slot_mapping,
-    )
-
-    for mm_key in feat_dims.keys():
-        assert mm_key in cache.mm_outputs_cache
-        key_feat_dim = feature_dims[mm_key]
-        mm_state_rows = cache.mm_outputs_cache[mm_key].view(NUM_BLOCKS * BLOCK_SIZE, key_feat_dim)
-
-        # Similar to hidden states, but for each key in the dict;
-        # Different tensors may have different feature dims
-        new_mm_outputs = mm_outputs[mm_key]
-        for slot_idx, new_output in zip(slot_mapping, new_mm_outputs):
-            slot_states = mm_state_rows[slot_idx]
-            assert torch.all(slot_states == new_output)
-
-
-def test_deferred_multimodal_cache_write_commits_on_completion():
-    cache = get_omni_pcache()
-    mm_key = "codes.audio"
-    block_table = torch.tensor(
-        [
-            [2, 3, 4, 5],
-            [6, 7, 8, 9],
-        ],
-        dtype=torch.long,
-    )
-    input_batch = MockInputBatch(
-        num_computed_tokens_cpu=torch.tensor([4, 0], dtype=torch.long),
-        block_table=block_table,
-    )
-
-    first_chunk = torch.arange(8, dtype=torch.long).reshape(4, 2)
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs={mm_key: first_chunk},
-        num_tokens_unpadded=4,
-        slot_mapping=torch.arange(8, 12),
-        skip_mm_cache_keys={mm_key},
-    )
-
-    rows = cache.mm_outputs_cache[mm_key].view(-1, 2)
-    assert torch.all(rows[8:12] == 0)
-
-    cache.stage_deferred_mm_outputs(
-        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: first_chunk},
-        num_scheduled_tokens={"req1": 4, "req2": 0},
-        deferred_mm_cache_keys={mm_key},
-    )
-
-    second_chunk = torch.arange(8, 16, dtype=torch.long).reshape(4, 2)
-    input_batch.num_computed_tokens_cpu = torch.tensor([8, 0], dtype=torch.long)
-    cache.stage_deferred_mm_outputs(
-        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: second_chunk},
-        num_scheduled_tokens={"req1": 4, "req2": 0},
-        deferred_mm_cache_keys={mm_key},
-    )
-
-    cache.commit_deferred_mm_outputs({"req1"}, input_batch)
-
-    expected = torch.cat([first_chunk, second_chunk], dim=0)
-    rows = cache.mm_outputs_cache[mm_key].view(-1, 2)
-    assert torch.equal(rows[8:16], expected)
-
-
-def test_discard_deferred_mm_outputs_drops_pending_chunks():
-    """discard_deferred_mm_outputs is the abort path: a request that
-    leaves without a cache commit must not leak its staged chunks into
-    the cache if commit_deferred_mm_outputs is later called for it."""
-    cache = get_omni_pcache()
-    mm_key = "codes.audio"
-    block_table = torch.tensor(
-        [
-            [2, 3, 4, 5],
-            [6, 7, 8, 9],
-        ],
-        dtype=torch.long,
-    )
-    input_batch = MockInputBatch(
-        num_computed_tokens_cpu=torch.tensor([4, 0], dtype=torch.long),
-        block_table=block_table,
-    )
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs={mm_key: torch.arange(8, dtype=torch.long).reshape(4, 2)},
-        num_tokens_unpadded=4,
-        slot_mapping=torch.arange(8, 12),
-        skip_mm_cache_keys={mm_key},
-    )
-
-    chunk = torch.arange(8, dtype=torch.long).reshape(4, 2)
-    cache.stage_deferred_mm_outputs(
-        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: chunk},
-        num_scheduled_tokens={"req1": 4, "req2": 0},
-        deferred_mm_cache_keys={mm_key},
-    )
-    assert "req1" in cache._deferred_mm_outputs
-
-    cache.discard_deferred_mm_outputs("req1")
-    assert "req1" not in cache._deferred_mm_outputs
-
-    # A later commit call for the now-discarded req_id must be a no-op,
-    # not a resurrection of the dropped chunk.
-    cache.commit_deferred_mm_outputs({"req1"}, input_batch)
-    rows = cache.mm_outputs_cache[mm_key].view(-1, 2)
-    assert torch.all(rows[8:12] == 0)
-
-
-def test_deferred_mm_outputs_request_id_reused_after_discard():
-    """A request ID reused after discard_deferred_mm_outputs must start
-    clean: the new occupant's committed data must not be mixed with the
-    previous (discarded) occupant's staged chunks."""
-    cache = get_omni_pcache()
-    mm_key = "codes.audio"
-    block_table = torch.tensor(
-        [
-            [2, 3, 4, 5],
-            [6, 7, 8, 9],
-        ],
-        dtype=torch.long,
-    )
-    input_batch = MockInputBatch(
-        num_computed_tokens_cpu=torch.tensor([4, 0], dtype=torch.long),
-        block_table=block_table,
-    )
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs={mm_key: torch.arange(8, dtype=torch.long).reshape(4, 2)},
-        num_tokens_unpadded=4,
-        slot_mapping=torch.arange(8, 12),
-        skip_mm_cache_keys={mm_key},
-    )
-
-    stale_chunk = torch.full((4, 2), -1, dtype=torch.long)
-    cache.stage_deferred_mm_outputs(
-        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: stale_chunk},
-        num_scheduled_tokens={"req1": 4, "req2": 0},
-        deferred_mm_cache_keys={mm_key},
-    )
-    cache.discard_deferred_mm_outputs("req1")
-
-    # "req1" is reused by a brand-new request with different data.
-    fresh_chunk = torch.arange(8, dtype=torch.long).reshape(4, 2)
-    cache.stage_deferred_mm_outputs(
-        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: fresh_chunk},
-        num_scheduled_tokens={"req1": 4, "req2": 0},
-        deferred_mm_cache_keys={mm_key},
-    )
-    cache.commit_deferred_mm_outputs({"req1"}, input_batch)
-
-    rows = cache.mm_outputs_cache[mm_key].view(-1, 2)
-    assert torch.equal(rows[8:12], fresh_chunk)
-
-
-def test_deferred_multimodal_cache_can_be_merged_on_full_block_hit():
-    cache = get_omni_pcache()
-    mm_key = "codes.audio"
-    block_table = torch.tensor(
-        [
-            [2, 3, 4, 5],
-            [6, 7, 8, 9],
-        ],
-        dtype=torch.long,
-    )
-    input_batch = MockInputBatch(
-        num_computed_tokens_cpu=torch.tensor([8, 0], dtype=torch.long),
-        block_table=block_table,
-    )
-    cached_codes = torch.arange(16, dtype=torch.long).reshape(8, 2)
-    cache.stage_deferred_mm_outputs(
-        query_start_loc=torch.tensor([0, 8], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: cached_codes},
-        num_scheduled_tokens={"req1": 8, "req2": 0},
-        deferred_mm_cache_keys={mm_key},
-    )
-    cache.commit_deferred_mm_outputs({"req1"}, input_batch)
-
-    new_codes = torch.tensor([[99, 100]], dtype=torch.long)
-    cache.add_prefix_cached_new_req_id("req1")
-    merged = cache.get_merged_multimodal_states(
-        query_start_loc=torch.tensor([0, 1], dtype=torch.long),
-        input_batch=input_batch,
-        multimodal_outputs={mm_key: new_codes},
-        num_scheduled_tokens={"req1": 1, "req2": 0},
-    )
-
-    assert torch.equal(merged[mm_key]["req1"], torch.cat([cached_codes, new_codes], dim=0))
-
-
-### Tests for Merging
-def fake_get_cached_block_ids(self, req_idx, *args, **kwargs):
-    """Fake block table lookup.
-
-    Assumption:
-        req_idx 0 is a cache hit with slots 8, 9, ..., 15
-        req_idx 1 is a cache miss
-    """
-    assert req_idx < 2
-    if req_idx == 0:
-        # With the slot offset we provided (8), the corresponding
-        # blocks IDs are 2 & 3 because the block size is 4.
-        return torch.tensor([2, 3], dtype=torch.long)
-    return torch.tensor([], dtype=torch.long)
-
-
-@pytest.mark.parametrize("num_tokens_padded", [None, 16])
-def test_get_merged_hidden_states(num_tokens_padded, mocker):
-    """Ensure that hidden states are merged correctly."""
-    cache = get_omni_pcache()
-
-    orig_num_tokens_unpadded = 8
-    slot_offset = 8  # We'll put our states in slots 8, 9, 10, ..., 15
-    orig_slot_mapping = torch.arange(slot_offset, slot_offset + orig_num_tokens_unpadded)
-    orig_hidden_states = torch.rand((orig_num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=orig_hidden_states,
-        multimodal_outputs=None,
-        num_tokens_unpadded=orig_num_tokens_unpadded,
-        slot_mapping=orig_slot_mapping,
-        num_tokens_padded=num_tokens_padded,
-    )
-
-    # Say that we have two requests, but only one of them is a cache hit
-    num_new_toks_req1 = 3
-    num_new_toks_req2 = 2
-    cache.add_prefix_cached_new_req_id("req1")
-
-    num_scheduled_tokens = {
-        "req1": num_new_toks_req1,
-        "req2": num_new_toks_req2,
-    }
-    new_hidden_states = torch.rand(
-        (num_new_toks_req1 + num_new_toks_req2, HIDDEN_SIZE),
-        dtype=DTYPE,
-    )
-    req1_new_states = new_hidden_states[:num_new_toks_req1]
-    req2_new_states = new_hidden_states[-num_new_toks_req2:]
-
-    input_batch = MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0]))
-
-    mocker.patch(
-        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
-        new=fake_get_cached_block_ids,
-    )
-    merged_states = cache.get_merged_hidden_states(
-        query_start_loc=[0, num_new_toks_req1],
-        input_batch=input_batch,
-        hidden_states=new_hidden_states,
-        num_scheduled_tokens=num_scheduled_tokens,
-    )
-
-    assert "req1" in merged_states and "req2" in merged_states
-    req1_merged_states = merged_states["req1"]
-    req2_merged_states = merged_states["req2"]
-
-    # First, check the cache hit case
-    assert req1_merged_states.shape == torch.Size([orig_num_tokens_unpadded + num_new_toks_req1, HIDDEN_SIZE])
-    # Ensure that the req1 merged states are the cached states + the new req1 states
-    assert torch.all(req1_merged_states[:orig_num_tokens_unpadded] == orig_hidden_states)
-    assert torch.all(req1_merged_states[-num_new_toks_req1:] == req1_new_states)
-
-    # Next, ensure that the cache miss case only has the new states
-    assert req2_merged_states.shape == torch.Size([num_new_toks_req2, HIDDEN_SIZE])
-    assert torch.all(req2_merged_states == req2_new_states)
-
-
-def test_get_merged_hidden_states_uses_precomputed_hidden_states_cpu(mocker):
-    cache = get_omni_pcache()
-
-    orig_num_tokens_unpadded = 8
-    slot_offset = 8
-    orig_slot_mapping = torch.arange(slot_offset, slot_offset + orig_num_tokens_unpadded)
-    orig_hidden_states = torch.rand((orig_num_tokens_unpadded, HIDDEN_SIZE), dtype=DTYPE)
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=orig_hidden_states,
-        multimodal_outputs=None,
-        num_tokens_unpadded=orig_num_tokens_unpadded,
-        slot_mapping=orig_slot_mapping,
-    )
-
-    num_new_toks_req1 = 3
-    num_new_toks_req2 = 2
-    cache.add_prefix_cached_new_req_id("req1")
-    num_scheduled_tokens = {
-        "req1": num_new_toks_req1,
-        "req2": num_new_toks_req2,
-    }
-    new_hidden_states = torch.zeros(
-        (num_new_toks_req1 + num_new_toks_req2, HIDDEN_SIZE),
-        dtype=DTYPE,
-    )
-    hidden_states_cpu = torch.rand_like(new_hidden_states)
-    req1_new_states = hidden_states_cpu[:num_new_toks_req1]
-    req2_new_states = hidden_states_cpu[-num_new_toks_req2:]
-    input_batch = MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0]))
-
-    mocker.patch(
-        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
-        new=fake_get_cached_block_ids,
-    )
-    merged_states = cache.get_merged_hidden_states(
-        query_start_loc=[0, num_new_toks_req1],
-        input_batch=input_batch,
-        hidden_states=new_hidden_states,
-        hidden_states_cpu=hidden_states_cpu,
-        num_scheduled_tokens=num_scheduled_tokens,
-    )
-
-    assert torch.all(merged_states["req1"][:orig_num_tokens_unpadded] == orig_hidden_states)
-    assert torch.all(merged_states["req1"][-num_new_toks_req1:] == req1_new_states)
-    assert torch.all(merged_states["req2"] == req2_new_states)
-
-
-def test_get_merged_hidden_states_rejects_short_hidden_states_cpu(mocker):
-    cache = get_omni_pcache()
-    num_scheduled_tokens = {
-        "req1": 3,
-        "req2": 2,
-    }
-    input_batch = MockInputBatch(num_computed_tokens_cpu=torch.Tensor([0, 0]))
-
-    mocker.patch(
-        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
-        new=fake_get_cached_block_ids,
-    )
-    with pytest.raises(RuntimeError):
-        cache.get_merged_hidden_states(
-            query_start_loc=[0, 3],
-            input_batch=input_batch,
-            hidden_states=torch.rand((5, HIDDEN_SIZE), dtype=DTYPE),
-            hidden_states_cpu=torch.rand((4, HIDDEN_SIZE), dtype=DTYPE),
-            num_scheduled_tokens=num_scheduled_tokens,
-        )
-
-
-@pytest.mark.parametrize("num_tokens_padded", [None, 16])
-@pytest.mark.parametrize(
-    "feat_dims",
-    [
-        {"foo": 100, "bar": 100},
-        {"foo": 100, "bar": 50, "baz": 10},
-    ],
-)
-def test_get_merged_multimodal_outputs(feat_dims, num_tokens_padded, mocker):
-    cache = get_omni_pcache_with_mm_tensors(feat_dims, seq_len=DEFAULT_SEQ_LEN)
-
-    orig_num_tokens_unpadded = 8
-    slot_offset = 8  # We'll put our states in slots 8, 9, 10, ..., 15
-    orig_slot_mapping = torch.arange(slot_offset, slot_offset + orig_num_tokens_unpadded)
-    feature_dims = {key: val.shape[-1] for key, val in cache.mm_outputs_cache.items()}
-    orig_mm_outputs = {
-        key: torch.rand((orig_num_tokens_unpadded, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
-    }
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs=orig_mm_outputs,
-        num_tokens_unpadded=orig_num_tokens_unpadded,
-        slot_mapping=orig_slot_mapping,
-        num_tokens_padded=num_tokens_padded,
-    )
-
-    # Similar to hs test- say that we have two requests, but only one of them is a cache hit
-    num_new_toks_req1 = 3
-    num_new_toks_req2 = 2
-    cache.add_prefix_cached_new_req_id("req1")
-
-    num_scheduled_tokens = {
-        "req1": num_new_toks_req1,
-        "req2": num_new_toks_req2,
-    }
-
-    new_mm_outputs = {}
-    for mm_key in cache.mm_cache_keys:
-        new_mm_outputs[mm_key] = torch.rand(
-            (num_new_toks_req1 + num_new_toks_req2, feature_dims[mm_key]),
-            dtype=DTYPE,
-        )
-    # We also want to make sure passthrough data (outside of our keys) isn't dropped
-    new_mm_outputs["passthrough_data"] = "Something else"
-    # Lists are a special case because we can't split them yet if we want to match
-    # the nonprefix cache behavior, because this runs before post process.
-    new_mm_outputs["passthrough_list"] = ["should", "not", "split"]
-
-    input_batch = MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0]))
-
-    mocker.patch(
-        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
-        new=fake_get_cached_block_ids,
-    )
-    merged_mm_outputs = cache.get_merged_multimodal_states(
-        query_start_loc=[0, num_new_toks_req1],
-        input_batch=input_batch,
-        multimodal_outputs=new_mm_outputs,
-        num_scheduled_tokens=num_scheduled_tokens,
-    )
-
-    # Ensure the passthrough data wasn't dropped
-    assert "passthrough_data" in merged_mm_outputs
-    assert "passthrough_list" in merged_mm_outputs
-
-    for mm_key, mm_output in merged_mm_outputs.items():
-        # Ensure passthrough data is just forwarded normally and not duplicated
-        assert isinstance(mm_output, dict)
-        assert "req1" in mm_output and "req2" in mm_output
-        if mm_key == "passthrough_data":
-            assert mm_key not in cache.mm_cache_keys
-            assert new_mm_outputs[mm_key] == mm_output["req1"]
-            assert new_mm_outputs[mm_key] == mm_output["req2"]
-        elif mm_key == "passthrough_list":
-            assert mm_key not in cache.mm_cache_keys
-            assert new_mm_outputs[mm_key] == mm_output["req1"]
-            assert new_mm_outputs[mm_key] == mm_output["req2"]
-        else:
-            assert mm_key in cache.mm_cache_keys
-            curr_feat_dim = feature_dims[mm_key]
-            # Ensure that req1 (cache hit) merged the mm data
-            req1_merged_mm_outputs = mm_output["req1"]
-            req1_new_mm_outputs = new_mm_outputs[mm_key][:num_new_toks_req1]
-
-            assert req1_merged_mm_outputs.shape == torch.Size(
-                [orig_num_tokens_unpadded + num_new_toks_req1, curr_feat_dim]
-            )
-            # Ensure that the req1 merged mm data are the cached data + the new data
-            assert torch.all(req1_merged_mm_outputs[:orig_num_tokens_unpadded] == orig_mm_outputs[mm_key])
-            assert torch.all(req1_merged_mm_outputs[-num_new_toks_req1:] == req1_new_mm_outputs)
-
-            # Ensure that req2 (cache miss) only has the new mm data
-            req2_merged_mm_outputs = mm_output["req2"]
-            req2_new_mm_outputs = new_mm_outputs[mm_key][-num_new_toks_req2:]
-
-            assert req2_merged_mm_outputs.shape == torch.Size([num_new_toks_req2, curr_feat_dim])
-            assert torch.all(req2_merged_mm_outputs == req2_new_mm_outputs)
-
-
-@pytest.mark.parametrize(
-    "passthrough_shape",
-    [(5,), (5, 3)],
-    ids=["1d_token_metadata", "2d_feature_tensor"],
-)
-def test_get_merged_multimodal_outputs_slices_passthrough_tensor_per_request(passthrough_shape, mocker):
-    """A passthrough key that is itself a real tensor (not the string/list
-    passthrough already covered above) must be sliced per request through
-    to_payload_element's tensor branch, under the same mixed cache
-    hit/miss + uneven scheduled-length batch as test_get_merged_multimodal_outputs.
-
-    Covers both a 1D token-aligned metadata tensor (e.g. ref_code_len,
-    codec_streaming -- shape (total_tokens,)) and a 2D per-token feature
-    tensor (shape (total_tokens, feat_dim)), since W2's batching could
-    easily special-case one and silently mishandle the other.
-    """
-    feat_dims = {"foo": 100, "bar": 100}
-    cache = get_omni_pcache_with_mm_tensors(feat_dims, seq_len=DEFAULT_SEQ_LEN)
-
-    orig_num_tokens_unpadded = 8
-    slot_offset = 8
-    orig_slot_mapping = torch.arange(slot_offset, slot_offset + orig_num_tokens_unpadded)
-    feature_dims = {key: val.shape[-1] for key, val in cache.mm_outputs_cache.items()}
-    orig_mm_outputs = {
-        key: torch.rand((orig_num_tokens_unpadded, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
-    }
-
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs=orig_mm_outputs,
-        num_tokens_unpadded=orig_num_tokens_unpadded,
-        slot_mapping=orig_slot_mapping,
-        num_tokens_padded=None,
-    )
-
-    num_new_toks_req1 = 3
-    num_new_toks_req2 = 2
-    cache.add_prefix_cached_new_req_id("req1")
-
-    num_scheduled_tokens = {
-        "req1": num_new_toks_req1,
-        "req2": num_new_toks_req2,
-    }
-
-    new_mm_outputs = {}
-    for mm_key in cache.mm_cache_keys:
-        new_mm_outputs[mm_key] = torch.rand(
-            (num_new_toks_req1 + num_new_toks_req2, feature_dims[mm_key]),
-            dtype=DTYPE,
-        )
-    total_scheduled_tokens = num_new_toks_req1 + num_new_toks_req2
-    assert passthrough_shape[0] == total_scheduled_tokens
-    passthrough_tensor = torch.arange(int(torch.prod(torch.tensor(passthrough_shape))), dtype=DTYPE).reshape(
-        passthrough_shape
-    )
-    new_mm_outputs["passthrough_tensor"] = passthrough_tensor
-
-    input_batch = MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0]))
-
-    mocker.patch(
-        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
-        new=fake_get_cached_block_ids,
-    )
-    merged_mm_outputs = cache.get_merged_multimodal_states(
-        query_start_loc=[0, num_new_toks_req1],
-        input_batch=input_batch,
-        multimodal_outputs=new_mm_outputs,
-        num_scheduled_tokens=num_scheduled_tokens,
-    )
-
-    assert "passthrough_tensor" not in cache.mm_cache_keys
-
-    passthrough_out = merged_mm_outputs["passthrough_tensor"]
-    # req1 (cache hit) gets tokens [0:3), req2 (cache miss) gets tokens [3:5) --
-    # a passthrough tensor is sliced by scheduled position, not merged with
-    # any cached history (unlike the mm_cache_keys tensors above).
-    assert torch.equal(passthrough_out["req1"], passthrough_tensor[0:num_new_toks_req1])
-    assert torch.equal(passthrough_out["req2"], passthrough_tensor[num_new_toks_req1:total_scheduled_tokens])
-
-
-class MergeHarness(NamedTuple):
-    """A primed cache plus the arguments get_merged_multimodal_states needs."""
-
-    cache: OmniTensorPrefixCache
-    input_batch: MockInputBatch
-    num_scheduled_tokens: dict[str, int]
-    query_start_loc: list[int]
-    total_scheduled_tokens: int
-    new_mm_outputs: dict[str, object]
-
-
-def build_mixed_hit_miss_harness(mocker, num_new_toks_req1: int = 3, num_new_toks_req2: int = 2) -> MergeHarness:
-    """Two requests over one cache key: req1 hits 8 cached tokens, req2 misses,
-    and their scheduled lengths differ -- the same batch shape as
-    test_get_merged_multimodal_outputs, which is what makes a per-request
-    boundary error observable. Callers add their passthrough keys to
-    ``new_mm_outputs`` before calling get_merged_multimodal_states.
-    """
-    cache = get_omni_pcache_with_mm_tensors({"foo": 100}, seq_len=DEFAULT_SEQ_LEN)
-
-    orig_num_tokens_unpadded = 8
-    feature_dims = {key: val.shape[-1] for key, val in cache.mm_outputs_cache.items()}
-    cache.update_omni_tensor_prefix_cache(
-        hidden_states=None,
-        multimodal_outputs={
-            key: torch.rand((orig_num_tokens_unpadded, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
-        },
-        num_tokens_unpadded=orig_num_tokens_unpadded,
-        slot_mapping=torch.arange(8, 8 + orig_num_tokens_unpadded),
-        num_tokens_padded=None,
-    )
-    cache.add_prefix_cached_new_req_id("req1")
-
-    total_scheduled_tokens = num_new_toks_req1 + num_new_toks_req2
-    mocker.patch(
-        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
-        new=fake_get_cached_block_ids,
-    )
-    return MergeHarness(
-        cache=cache,
-        input_batch=MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0])),
-        num_scheduled_tokens={"req1": num_new_toks_req1, "req2": num_new_toks_req2},
-        query_start_loc=[0, num_new_toks_req1],
-        total_scheduled_tokens=total_scheduled_tokens,
-        new_mm_outputs={
-            key: torch.rand((total_scheduled_tokens, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
-        },
-    )
-
-
-def test_get_merged_multimodal_outputs_passes_per_request_tensor_list_through(mocker):
-    """The passthrough shape qwen3-tts actually emits: a nested ``codes``/``meta``
-    dict whose ``codes.ref`` holds one tensor per request
-    (qwen3_tts_talker.make_omni_output), carried through to_payload_element's
-    pass_lists_through branch beside 1D int metadata that IS sliced per request.
-
-    Each request must receive the list *whole*. Per-request indexing happens
-    later, in the runner's _unwrap_lists; a W2 that split the list here would
-    make that second index select a different request's reference codes. The
-    existing list coverage passes a list of strings, which cannot catch a
-    tensor-specific regression, and no other test covers an int dtype.
-    """
-    harness = build_mixed_hit_miss_harness(mocker)
-
-    ref_codes = [torch.tensor([11, 12], dtype=torch.long), torch.tensor([21], dtype=torch.long)]
-    ref_code_len = torch.arange(harness.total_scheduled_tokens, dtype=torch.int32)
-    harness.new_mm_outputs["codes"] = {"ref": ref_codes}
-    harness.new_mm_outputs["meta"] = {"ref_code_len": ref_code_len}
-
-    merged = harness.cache.get_merged_multimodal_states(
-        query_start_loc=harness.query_start_loc,
-        input_batch=harness.input_batch,
-        multimodal_outputs=harness.new_mm_outputs,
-        num_scheduled_tokens=harness.num_scheduled_tokens,
-    )
-
-    assert "codes" not in harness.cache.mm_cache_keys
-    for req_id in ("req1", "req2"):
-        req_refs = merged["codes"][req_id]["ref"]
-        assert len(req_refs) == len(ref_codes)
-        for got, want in zip(req_refs, ref_codes):
-            assert torch.equal(got, want)
-            assert got.dtype == torch.long
-
-    # Per-request clones: the branch exists so one request's downstream mutation
-    # cannot reach another request's payload or the source list.
-    merged["codes"]["req1"]["ref"][0] += 100
-    assert torch.equal(merged["codes"]["req2"]["ref"][0], torch.tensor([11, 12], dtype=torch.long))
-    assert torch.equal(ref_codes[0], torch.tensor([11, 12], dtype=torch.long))
-
-    # Token-aligned 1D metadata is still split per request, unlike the list.
-    req1_len = harness.num_scheduled_tokens["req1"]
-    assert torch.equal(merged["meta"]["req1"]["ref_code_len"], ref_code_len[:req1_len])
-    assert torch.equal(merged["meta"]["req2"]["ref_code_len"], ref_code_len[req1_len:])
-    assert merged["meta"]["req1"]["ref_code_len"].dtype == torch.int32
-
-
-@pytest.mark.parametrize(
-    "passthrough_shape",
-    [(3, 4), (1, 4), (7,)],
-    ids=["shorter_2d", "single_row_2d", "longer_1d"],
-)
-def test_get_merged_multimodal_outputs_broadcasts_non_token_aligned_passthrough(passthrough_shape, mocker):
-    """A passthrough tensor whose first dimension is not the scheduled-token
-    count is request-invariant: to_payload_element hands every request the whole
-    tensor, cloned, rather than slicing it.
-
-    W2 batching most plausibly breaks by assuming every passthrough tensor is
-    token-aligned; that assumption would slice these and give each request a
-    truncated view, or an empty one once start exceeds the first dimension.
-    """
-    harness = build_mixed_hit_miss_harness(mocker)
-    assert passthrough_shape[0] != harness.total_scheduled_tokens
-
-    passthrough = torch.arange(math.prod(passthrough_shape), dtype=DTYPE).reshape(passthrough_shape)
-    expected = passthrough.clone()
-    harness.new_mm_outputs["speaker_embedding"] = passthrough
-
-    merged = harness.cache.get_merged_multimodal_states(
-        query_start_loc=harness.query_start_loc,
-        input_batch=harness.input_batch,
-        multimodal_outputs=harness.new_mm_outputs,
-        num_scheduled_tokens=harness.num_scheduled_tokens,
-    )
-
-    assert "speaker_embedding" not in harness.cache.mm_cache_keys
-    out = merged["speaker_embedding"]
-    for req_id in ("req1", "req2"):
-        assert out[req_id].shape == passthrough_shape
-        assert torch.equal(out[req_id], expected)
-
-    out["req1"] += 100
-    assert torch.equal(out["req2"], expected)
-    assert torch.equal(passthrough, expected)
+    assert cfg_fallback.staging_capacity_tokens == 4096
diff --git a/tests/core/test_prefix_cache_async_write.py b/tests/core/test_prefix_cache_async_write.py
deleted file mode 100644
index fa1980227..000000000
--- a/tests/core/test_prefix_cache_async_write.py
+++ /dev/null
@@ -1,119 +0,0 @@
-import pytest
-import torch
-
-from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
-
-# `cpu` is the lane selector, not a hardware claim: the only Buildkite steps that
-# reach tests/ select `core_model and cpu`, and they run on GPU hardware (l4_1).
-# Marking this `cuda` collects it nowhere. Real hardware need is the skipif below.
-pytestmark = [
-    pytest.mark.core_model,
-    pytest.mark.cpu,
-    pytest.mark.skipif(not torch.cuda.is_available(), reason="requires a CUDA device"),
-]
-
-NUM_BLOCKS = 10
-BLOCK_SIZE = 4
-HIDDEN_SIZE = 2
-DTYPE = torch.float32
-
-
-def get_omni_pcache() -> OmniTensorPrefixCache:
-    """Build an OmniTensorPrefixCache, but don't init mm tensors."""
-    return OmniTensorPrefixCache(
-        num_blocks=NUM_BLOCKS,
-        block_size=BLOCK_SIZE,
-        hidden_size=HIDDEN_SIZE,
-        hs_dtype=DTYPE,
-    )
-
-
-def test_drain_ready_async_writes_is_a_noop_before_the_event_is_ready(monkeypatch):
-    """drain_ready_async_writes() must not touch the cache while the
-    scheduled D2H's event has not completed, and must consume it exactly
-    once after it has.
-
-    Real GPU timing (e.g. via torch.cuda._sleep to stall the copy stream)
-    was tried and found unreliable on this box: cross-stream wait_stream/
-    wait_event did not reliably delay event.query() from reporting ready
-    immediately, likely a virtualization/driver quirk of this cloud GPU.
-    Forcing the event's query() result directly tests the branching logic
-    in drain_ready_async_writes/_consume_pending_write deterministically,
-    independent of real CUDA scheduling behavior.
-    """
-    cache = get_omni_pcache()
-    mm_key = "codes.audio"
-    cache.maybe_init_missing_mm_cache_keys({mm_key: torch.zeros(4, HIDDEN_SIZE)}, seq_len=4)
-
-    num_tokens = 4
-    slot_mapping_gpu = torch.arange(8, 8 + num_tokens, dtype=torch.int64, device="cuda")
-    mm_gpu = {
-        mm_key: torch.arange(num_tokens * HIDDEN_SIZE, dtype=torch.float32, device="cuda").reshape(
-            num_tokens, HIDDEN_SIZE
-        )
-    }
-
-    cache.schedule_async_write(
-        hidden_states_gpu=None,
-        multimodal_outputs_gpu=mm_gpu,
-        slot_mapping_gpu=slot_mapping_gpu,
-        num_tokens_unpadded=num_tokens,
-        num_tokens_padded=num_tokens,
-    )
-
-    pending_event = cache._pending_write.event
-    rows = cache.mm_outputs_cache[mm_key].view(-1, HIDDEN_SIZE)
-
-    monkeypatch.setattr(pending_event, "query", lambda: False)
-    assert cache.drain_ready_async_writes() == 0
-    assert torch.all(rows[8 : 8 + num_tokens] == 0)
-    assert cache._pending_write is not None
-
-    monkeypatch.setattr(pending_event, "query", lambda: True)
-    assert cache.drain_ready_async_writes() == 1
-    assert torch.equal(rows[8 : 8 + num_tokens], mm_gpu[mm_key].cpu())
-    assert cache._pending_write is None
-
-    # Nothing pending anymore: a second drain is a no-op, not a re-scatter.
-    assert cache.drain_ready_async_writes() == 0
-
-
-def test_schedule_async_write_consumes_previous_pending_write_first():
-    """Scheduling step N+1's write must first consume (scatter) step N's
-    pending write, even if the caller never explicitly called
-    drain_ready_async_writes() in between -- otherwise step N's data would
-    be silently dropped when overwritten by step N+1's pending write."""
-    cache = get_omni_pcache()
-    mm_key = "codes.audio"
-    cache.maybe_init_missing_mm_cache_keys({mm_key: torch.zeros(4, HIDDEN_SIZE)}, seq_len=4)
-
-    num_tokens = 4
-    first_slots = torch.arange(8, 8 + num_tokens, dtype=torch.int64, device="cuda")
-    first_gpu = {mm_key: torch.full((num_tokens, HIDDEN_SIZE), 1.0, device="cuda")}
-    second_slots = torch.arange(12, 12 + num_tokens, dtype=torch.int64, device="cuda")
-    second_gpu = {mm_key: torch.full((num_tokens, HIDDEN_SIZE), 2.0, device="cuda")}
-
-    cache.schedule_async_write(
-        hidden_states_gpu=None,
-        multimodal_outputs_gpu=first_gpu,
-        slot_mapping_gpu=first_slots,
-        num_tokens_unpadded=num_tokens,
-        num_tokens_padded=num_tokens,
-    )
-    torch.accelerator.synchronize()
-
-    # This call's internal _consume_pending_write() must flush the FIRST
-    # write before the second one is scheduled; the caller never drained.
-    cache.schedule_async_write(
-        hidden_states_gpu=None,
-        multimodal_outputs_gpu=second_gpu,
-        slot_mapping_gpu=second_slots,
-        num_tokens_unpadded=num_tokens,
-        num_tokens_padded=num_tokens,
-    )
-    torch.accelerator.synchronize()
-    cache.drain_ready_async_writes()
-
-    rows = cache.mm_outputs_cache[mm_key].view(-1, HIDDEN_SIZE)
-    assert torch.all(rows[8:12] == 1.0)
-    assert torch.all(rows[12:16] == 2.0)
diff --git a/tests/core/test_prefix_cache_runner_mixin.py b/tests/core/test_prefix_cache_runner_mixin.py
new file mode 100644
index 000000000..3809c20b8
--- /dev/null
+++ b/tests/core/test_prefix_cache_runner_mixin.py
@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CPU tests for PrefixCacheRunnerMixin: one-shot construction, policy
+snapshot identity/isolation, and the shared save/materialize gates.
+No vLLM and no GPU required (same shim as test_prefix_cache.py)."""
+
+import sys
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+import pytest
+import torch
+
+try:  # pragma: no cover - shim only matters on vllm-less dev machines
+    import vllm  # noqa: F401
+except ModuleNotFoundError:
+    _root = Path(__file__).resolve().parents[2]
+    for _pkg in ("vllm_omni", "vllm_omni.core"):
+        if _pkg not in sys.modules:
+            _m = ModuleType(_pkg)
+            _m.__path__ = [str(_root / _pkg.replace(".", "/"))]
+            sys.modules[_pkg] = _m
+    import logging
+
+    _vllm = ModuleType("vllm")
+    _vllm_logger = ModuleType("vllm.logger")
+    setattr(_vllm_logger, "init_logger", logging.getLogger)
+    setattr(_vllm, "logger", _vllm_logger)
+    sys.modules["vllm"] = _vllm
+    sys.modules["vllm.logger"] = _vllm_logger
+
+from vllm_omni.core.prefix_cache.interface import PrefixCacheConfig, StageCacheOutputs
+from vllm_omni.core.prefix_cache.runner_mixin import PrefixCacheRunnerMixin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+BLOCK_SIZE = 4
+
+
+def _patch_pp(monkeypatch, is_last: bool) -> None:
+    """Route the mixin's call-time get_pp_group import to a fake rank."""
+    mod = ModuleType("vllm.distributed.parallel_state")
+    setattr(mod, "get_pp_group", lambda: SimpleNamespace(is_last_rank=is_last))
+    if "vllm.distributed" not in sys.modules:
+        monkeypatch.setitem(sys.modules, "vllm.distributed", ModuleType("vllm.distributed"))
+    monkeypatch.setitem(sys.modules, "vllm.distributed.parallel_state", mod)
+
+
+def _full_attention_groups():
+    """A single-group config that passes check_prefix_cache_kv_groups.
+
+    Real FullAttentionSpec when vllm is installed; otherwise a stand-in
+    registered under the import path the check resolves at call time.
+    """
+    try:
+        from vllm.v1.kv_cache_interface import FullAttentionSpec
+    except ModuleNotFoundError:
+        iface = sys.modules.get("vllm.v1.kv_cache_interface")
+        if iface is None:
+            iface = ModuleType("vllm.v1.kv_cache_interface")
+
+            class _FullAttentionSpecStub:
+                pass
+
+            setattr(iface, "FullAttentionSpec", _FullAttentionSpecStub)
+            sys.modules["vllm.v1"] = ModuleType("vllm.v1")
+            sys.modules["vllm.v1.kv_cache_interface"] = iface
+        FullAttentionSpec = getattr(iface, "FullAttentionSpec")
+    return [SimpleNamespace(kv_cache_spec=FullAttentionSpec.__new__(FullAttentionSpec))]
+
+
+class _FakeBlockTables:
+    """Group-0 table whose layout attrs pass check_prefix_cache_block_layout."""
+
+    def __init__(self):
+        self.block_tables = [object()]
+
+    def __getitem__(self, idx):
+        return SimpleNamespace()
+
+
+class _Runner(PrefixCacheRunnerMixin):
+    def __init__(self, cfg: PrefixCacheConfig | None = None):
+        # Any: tests swap in _CacheStub for the manager.
+        self.omni_prefix_cache: Any = None
+        self._omni_prefix_cache_cfg = cfg
+        self.input_batch = SimpleNamespace(block_table=_FakeBlockTables(), req_ids=[])
+        self.kv_cache_config = SimpleNamespace(kv_cache_groups=_full_attention_groups())
+        self.is_pooling_model = False
+
+
+def _cfg() -> PrefixCacheConfig:
+    return PrefixCacheConfig(num_blocks=8, block_size=BLOCK_SIZE)
+
+
+def _sched():
+    return SimpleNamespace(scheduled_new_reqs=(), finished_req_ids=set(), num_scheduled_tokens={})
+
+
+class _CacheStub:
+    def __init__(self):
+        self.save_calls = []
+        self.materialize_calls = []
+        self.outs = StageCacheOutputs(hidden_states=None, mm_outputs={})
+
+    def save_outputs(self, hidden, mm, *, num_tokens_unpadded, num_tokens_padded):
+        self.save_calls.append((hidden, mm, num_tokens_unpadded, num_tokens_padded))
+        return 7
+
+    def materialize(self, step_id, req_ids):
+        self.materialize_calls.append((step_id, req_ids))
+        return self.outs
+
+
+def test_step_begin_builds_once_and_registers_snapshot_policy(monkeypatch):
+    _patch_pp(monkeypatch, is_last=True)
+    r = _Runner(_cfg())
+    r._snapshot_prefix_cache_model_policy(
+        SimpleNamespace(requires_full_prefix_cached_hidden_states=True, deferred_prefix_cache_mm_keys=("k",))
+    )
+    r._prefix_cache_step_begin(_sched())
+    mgr = r.omni_prefix_cache
+    assert mgr is not None and r._omni_prefix_cache_cfg is None
+    assert mgr._policy is r._omni_cache_policy  # the load-time snapshot, same object
+    r._prefix_cache_step_begin(_sched())
+    assert r.omni_prefix_cache is mgr  # one-shot
+
+
+def test_default_policy_isolated_per_instance():
+    a, b = _Runner(), _Runner()
+    a._snapshot_prefix_cache_model_policy(SimpleNamespace(requires_full_prefix_cached_hidden_states=False))
+    assert a._omni_cache_policy.needs_full_hidden_states is False
+    assert a._model_needs_full_prefix_hidden_states() is False
+    assert b._omni_cache_policy.needs_full_hidden_states is True  # class default untouched
+    assert PrefixCacheRunnerMixin._omni_cache_policy.needs_full_hidden_states is True
+
+
+def test_non_last_rank_consumes_cfg_without_building(monkeypatch):
+    _patch_pp(monkeypatch, is_last=False)
+    r = _Runner(_cfg())
+    r._prefix_cache_step_begin(_sched())
+    assert r.omni_prefix_cache is None and r._omni_prefix_cache_cfg is None
+
+
+def test_disabled_cache_step_begin_is_a_noop():
+    r = _Runner(cfg=None)  # enable_prefix_caching off: nothing staged
+    r._prefix_cache_step_begin(_sched())
+    assert r.omni_prefix_cache is None
+
+
+def test_save_step_gates_and_passthrough(monkeypatch):
+    r = _Runner()
+    stub = _CacheStub()
+    hidden = torch.zeros(2, 2)
+
+    def save():
+        return r._prefix_cache_save_step(hidden, None, num_tokens_unpadded=2, num_tokens_padded=2)
+
+    _patch_pp(monkeypatch, is_last=True)
+    assert save() is None  # cache off
+    r.omni_prefix_cache = stub
+    r.is_pooling_model = True
+    assert save() is None  # pooling stage never writes
+    r.is_pooling_model = False
+    _patch_pp(monkeypatch, is_last=False)
+    assert save() is None  # not the last PP rank
+    _patch_pp(monkeypatch, is_last=True)
+    assert save() == 7
+    assert stub.save_calls == [(hidden, {}, 2, 2)]  # empty mm stays {}
+
+
+def test_materialize_requires_explicit_step_and_snapshot_req_ids():
+    r = _Runner()
+    stub = _CacheStub()
+    r.omni_prefix_cache = stub
+    assert r._prefix_cache_materialize(None, ["a"]) == (None, None)
+    assert stub.materialize_calls == []  # step_id None: nothing to consume
+    hidden = {"a": torch.zeros(1, 2)}
+    stub.outs = StageCacheOutputs(hidden_states=hidden, mm_outputs={})
+    assert r._prefix_cache_materialize(7, ["a"]) == (hidden, None)  # empty mm -> None
+    assert stub.materialize_calls == [(7, ["a"])]
diff --git a/tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json b/tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
index ffaaba436..6a3433dbe 100644
--- a/tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
@@ -54,7 +54,8 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": ["H100", "B200"]
+            "cuda": ["H100", "B200"],
+            "npu": "A3"
           },
           "num_cards": 2
         }
diff --git a/tests/dfx/perf/tests/test_minicpmo_4_5.json b/tests/dfx/perf/tests/test_minicpmo_4_5.json
index b384d61a0..7d7ca08ad 100644
--- a/tests/dfx/perf/tests/test_minicpmo_4_5.json
+++ b/tests/dfx/perf/tests/test_minicpmo_4_5.json
@@ -26,8 +26,8 @@
       {
         "dataset_name": "seed-tts",
         "dataset_path": "zhaochenyang20/seed-tts-eval",
-        "backend": "openai-realtime-tts",
-        "endpoint": "/v1/realtime",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
         "num_prompts": [
           32,
           64,
@@ -42,7 +42,73 @@
         "disable_shuffle": true,
         "trust_remote_code": true,
         "seed_tts_locale": "en",
-        "percentile-metrics": "ttft,e2el,audio_ttfp,audio_rtf,audio_duration"
+        "extra_body": {
+          "modalities": [
+            "text",
+            "audio"
+          ],
+          "chat_template_kwargs": {
+            "enable_thinking": false,
+            "use_tts_template": true
+          }
+        },
+        "percentile-metrics": "ttft,e2el,audio_ttfp,audio_rtf,audio_duration",
+        "baseline": {
+          "H100": {
+            "request_throughput": [
+              0.9731,
+              1.1986,
+              1.686
+            ],
+            "mean_ttft_ms": [
+              152.5665,
+              270.2559,
+              301.455
+            ],
+            "mean_e2el_ms": [
+              1027.2953,
+              3306.3735,
+              4686.5366
+            ],
+            "mean_audio_ttfp_ms": [
+              458.1553,
+              2030.2335,
+              2068.6233
+            ],
+            "mean_audio_rtf": [
+              0.2357,
+              0.791,
+              1.0324
+            ]
+          },
+          "A3": {
+            "request_throughput": [
+              0.5383,
+              0.6042,
+              0.7547
+            ],
+            "mean_ttft_ms": [
+              333.2633,
+              533.8656,
+              547.3388
+            ],
+            "mean_e2el_ms": [
+              1857.2154,
+              6600.5101,
+              10450.6811
+            ],
+            "mean_audio_ttfp_ms": [
+              986.4666,
+              3411.0754,
+              3352.7515
+            ],
+            "mean_audio_rtf": [
+              0.4423,
+              1.5734,
+              2.3024
+            ]
+          }
+        }
       }
     ]
   },
@@ -72,8 +138,8 @@
       {
         "dataset_name": "seed-tts",
         "dataset_path": "zhaochenyang20/seed-tts-eval",
-        "backend": "openai-realtime-tts",
-        "endpoint": "/v1/realtime",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
         "num_prompts": [
           32,
           64,
@@ -88,6 +154,16 @@
         "disable_shuffle": true,
         "trust_remote_code": true,
         "seed_tts_locale": "en",
+        "extra_body": {
+          "modalities": [
+            "text",
+            "audio"
+          ],
+          "chat_template_kwargs": {
+            "enable_thinking": false,
+            "use_tts_template": true
+          }
+        },
         "percentile-metrics": "ttft,e2el,audio_ttfp,audio_rtf,audio_duration"
       }
     ]
diff --git a/tests/dfx/perf/tests/test_minicpmo_4_5_ready.json b/tests/dfx/perf/tests/test_minicpmo_4_5_ready.json
index 4fd78d681..26dc54aab 100644
--- a/tests/dfx/perf/tests/test_minicpmo_4_5_ready.json
+++ b/tests/dfx/perf/tests/test_minicpmo_4_5_ready.json
@@ -26,8 +26,8 @@
       {
         "dataset_name": "seed-tts",
         "dataset_path": "zhaochenyang20/seed-tts-eval",
-        "backend": "openai-realtime-tts",
-        "endpoint": "/v1/realtime",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
         "num_prompts": [
           10,
           40
@@ -40,7 +40,41 @@
         "disable_shuffle": true,
         "trust_remote_code": true,
         "seed_tts_locale": "en",
-        "percentile-metrics": "ttft,e2el,audio_ttfp,audio_rtf,audio_duration"
+        "extra_body": {
+          "modalities": [
+            "text",
+            "audio"
+          ],
+          "chat_template_kwargs": {
+            "enable_thinking": false,
+            "use_tts_template": true
+          }
+        },
+        "percentile-metrics": "ttft,e2el,audio_ttfp,audio_rtf,audio_duration",
+        "baseline": {
+          "H100": {
+            "request_throughput": [
+              0.9731,
+              1.1986
+            ],
+            "mean_ttft_ms": [
+              152.5665,
+              270.2559
+            ],
+            "mean_e2el_ms": [
+              1027.2953,
+              3306.3735
+            ],
+            "mean_audio_ttfp_ms": [
+              458.1553,
+              2030.2335
+            ],
+            "mean_audio_rtf": [
+              0.2357,
+              0.791
+            ]
+          }
+        }
       }
     ]
   }
diff --git a/tests/dfx/perf/tests/test_runner_metadata.py b/tests/dfx/perf/tests/test_runner_metadata.py
index df99f090d..a0f966121 100644
--- a/tests/dfx/perf/tests/test_runner_metadata.py
+++ b/tests/dfx/perf/tests/test_runner_metadata.py
@@ -570,6 +570,7 @@ def test_omni_tpot_baseline_accepts_measured_finite_sample():
 @pytest.mark.parametrize(
     ("num_tpot_samples", "mean_tpot_ms", "match"),
     [
+        (None, 10.0, "no measurable TPOT samples"),
         (0, float("nan"), "no measurable TPOT samples"),
         (1, float("nan"), "mean_tpot_ms is not finite"),
     ],
@@ -577,14 +578,17 @@ def test_omni_tpot_baseline_accepts_measured_finite_sample():
 def test_omni_tpot_baseline_rejects_missing_or_nonfinite_sample(num_tpot_samples, mean_tpot_ms, match):
     from tests.dfx.perf.scripts.run_benchmark import assert_result
 
+    result = {
+        "completed": 1,
+        "Hardware": "H100",
+        "mean_tpot_ms": mean_tpot_ms,
+    }
+    if num_tpot_samples is not None:
+        result["num_tpot_samples"] = num_tpot_samples
+
     with pytest.raises(AssertionError, match=match):
         assert_result(
-            {
-                "completed": 1,
-                "Hardware": "H100",
-                "num_tpot_samples": num_tpot_samples,
-                "mean_tpot_ms": mean_tpot_ms,
-            },
+            result,
             {"baseline": {"H100": {"mean_tpot_ms": 20.0}}},
             1,
         )
diff --git a/tests/diffusion/ar_diffusion/test_capability_runner.py b/tests/diffusion/ar_diffusion/test_capability_runner.py
index 70166189b..d753efbf6 100644
--- a/tests/diffusion/ar_diffusion/test_capability_runner.py
+++ b/tests/diffusion/ar_diffusion/test_capability_runner.py
@@ -323,12 +323,18 @@ def test_lingbot_like_sink_survives_sliding_window_eviction():
     kv = runner.kv_cache
     assert kv is not None
 
-    for _ in range(8):
+    state = commit_one_frame(runner, "s1", "main")
+    sink_block = kv.block_table(state.adapter("main"))[0]
+    for _ in range(7):
         state = commit_one_frame(runner, "s1", "main")
 
-    table = kv.block_table(state.adapter("main"))
-    assert table[0] != kv.null_block_id
-    assert table[1] == kv.null_block_id
+    adapter = state.adapter("main")
+    table = kv.block_table(adapter)
+    assert len(table) == 6  # one sink + five recent frames
+    assert table[0] == sink_block
+    assert kv.null_block_id not in table
+    assert adapter.absolute_num_computed_tokens == 8 * BLOCK
+    assert adapter.num_computed_tokens == 6 * BLOCK
 
     ctx = state.get_kv_caches("main", seq_len=BLOCK, commit_current=False)[0].forward_ctx
     visible, _ = ctx.video_block_table(torch.device("cpu"))
diff --git a/tests/diffusion/ar_diffusion/test_kv_cache.py b/tests/diffusion/ar_diffusion/test_kv_cache.py
index 4d590e716..84908fef1 100644
--- a/tests/diffusion/ar_diffusion/test_kv_cache.py
+++ b/tests/diffusion/ar_diffusion/test_kv_cache.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for the AR-Diffusion KV cache helpers (Phase 1, PR-2).
 
 Covers the request adapter, the chunk-window spec/manager (registration + the
@@ -269,9 +270,14 @@ def test_compiled_paged_write_does_not_clone_the_pool():
     # drives the reinplace pass, so a drift here would silently test nothing.
     real_schema = torch.ops.vllm_omni.ar_diffusion_paged_write_attn.default._schema
     real_mutated = [arg.name for arg in real_schema.arguments if arg.alias_info and arg.alias_info.is_write]
-    assert real_mutated == ["key_pool", "value_pool"], (
+    # The staging buffers are mutated too when reuse_history_staging is on, but they are separate
+    # allocations and not what this test is about; the pools are what must not be cloned.
+    assert real_mutated[:2] == ["key_pool", "value_pool"], (
         f"the real paged-write op now mutates {real_mutated}; this test still models two pools"
     )
+    assert set(real_mutated) - {"key_pool", "value_pool"} <= {"stage_key", "stage_value"}, (
+        f"unexpected mutated argument in the real paged-write op: {real_mutated}"
+    )
 
     num_blocks, heads, dim = 8, 4, 16
     cache_shape = (num_blocks, BLOCK, heads, dim)
@@ -357,6 +363,7 @@ def _make_tiny_capacity_kv(
     available_bytes: int,
     gpu_memory_fraction: float = 1.0,
     model_owned_state_bytes_per_session: int = 0,
+    reuse_history_staging: bool = False,
 ) -> ARDiffusionKVCache:
     return ARDiffusionKVCache(
         ARDiffusionKVConfig(
@@ -365,6 +372,7 @@ def _make_tiny_capacity_kv(
             window_chunks=3,
             sink_chunks=3,
             gpu_memory_fraction=gpu_memory_fraction,
+            reuse_history_staging=reuse_history_staging,
         ),
         num_layers=1,
         num_kv_heads=1,
@@ -382,6 +390,33 @@ def _make_tiny_capacity_kv(
     )
 
 
+def test_history_staging_is_reserved_in_the_kv_budget(monkeypatch):
+    """The per-layer staging pair is worker-wide memory allocated after admission; the budget must hold it."""
+    monkeypatch.setenv("VLLM_OMNI_AR_DIFFUSION_KV_GATHER", "1")
+    # Same geometry as the capacity-two test: 192 bytes fits two sessions exactly without staging.
+    plain = _make_tiny_capacity_kv(requested_capacity=2, available_bytes=192)
+    assert plain.session_capacity == 2 and plain.history_staging_reserved_bytes == 0
+
+    staged = _make_tiny_capacity_kv(requested_capacity=2, available_bytes=192, reuse_history_staging=True)
+    # 2 (K, V) x 1 layer x (sink 3 + window 3 + one action-capacity block) tokens x 1 head x 1 dim x 4 bytes.
+    assert staged.history_staging_reserved_bytes == 2 * 1 * 7 * 1 * 1 * 4
+    # It comes out of the same budget, so the second session no longer fits.
+    assert staged.session_capacity == 1
+    assert staged.num_blocks_total * 8 + staged.history_staging_reserved_bytes <= 192
+
+    # Boundary: one session fits at 128 bytes without staging; with staging the same budget is rejected
+    # up front instead of failing on the first forward.
+    _make_tiny_capacity_kv(requested_capacity=1, available_bytes=128)
+    with pytest.raises(ValueError, match="cannot fit one session"):
+        _make_tiny_capacity_kv(requested_capacity=1, available_bytes=128, reuse_history_staging=True)
+
+
+def test_history_staging_is_not_reserved_when_the_gather_path_is_off(monkeypatch):
+    monkeypatch.delenv("VLLM_OMNI_AR_DIFFUSION_KV_GATHER", raising=False)
+    staged = _make_tiny_capacity_kv(requested_capacity=2, available_bytes=192, reuse_history_staging=True)
+    assert staged.history_staging_reserved_bytes == 0 and staged.session_capacity == 2
+
+
 def test_capacity_two_retains_both_windows_and_allocates_next_block():
     # LingBot-like single-branch geometry: page=8 bytes; capacity=2 requires
     # 17 managed + 3 scratch blocks, plus two 16-byte cross-attention
@@ -588,3 +623,70 @@ def test_non_contiguous_branch_indices_rejected():
             kv_branches=(ARDiffusionKVBranchSpec("main", 1),),
             session_capacity=1,
         )
+
+
+def test_staged_window_reuse_matches_a_full_gather():
+    """Reusing the staged history must be byte-identical to re-gathering the whole window.
+
+    This is the property the optimisation rests on: the leading blocks were staged by an earlier forward of
+    the same AR block, so skipping them can only be correct if what is already there equals what a fresh
+    gather would write. The test stages once, mutates only the current chunk's blocks in the pool (what a
+    later probe of the same block does), restages the tail alone, and compares against a full gather.
+    """
+    from vllm_omni.experimental.ar_diffusion.kv_cache.paged_attention import _stage_window
+
+    torch.manual_seed(0)
+    num_blocks, block_size, heads, dim = 6, 4, 2, 8
+    current_blocks = 2
+    key_cache = torch.randn(num_blocks, block_size, heads, dim)
+    value_cache = torch.randn(num_blocks, block_size, heads, dim)
+    block_ids = torch.tensor([5, 4, 3, 2, 1, 0])
+    stage_key = torch.zeros(num_blocks * block_size, heads, dim)
+    stage_value = torch.zeros(num_blocks * block_size, heads, dim)
+
+    _stage_window(stage_key, stage_value, key_cache, value_cache, block_ids, num_blocks, block_size, first_block=0)
+
+    # A later probe rewrites only the current chunk's blocks in the pool.
+    for slot in block_ids[num_blocks - current_blocks :]:
+        key_cache[slot] = torch.randn(block_size, heads, dim)
+        value_cache[slot] = torch.randn(block_size, heads, dim)
+
+    _stage_window(
+        stage_key,
+        stage_value,
+        key_cache,
+        value_cache,
+        block_ids,
+        num_blocks,
+        block_size,
+        first_block=num_blocks - current_blocks,
+    )
+
+    full_key = torch.zeros_like(stage_key)
+    full_value = torch.zeros_like(stage_value)
+    _stage_window(full_key, full_value, key_cache, value_cache, block_ids, num_blocks, block_size, first_block=0)
+
+    torch.testing.assert_close(stage_key, full_key, rtol=0, atol=0)
+    torch.testing.assert_close(stage_value, full_value, rtol=0, atol=0)
+
+
+def test_staged_window_tail_refresh_leaves_history_untouched():
+    """The tail restage must not write the history rows -- that is what makes it cheaper."""
+    from vllm_omni.experimental.ar_diffusion.kv_cache.paged_attention import _stage_window
+
+    torch.manual_seed(1)
+    num_blocks, block_size, heads, dim = 5, 4, 1, 4
+    key_cache = torch.randn(num_blocks, block_size, heads, dim)
+    value_cache = torch.randn(num_blocks, block_size, heads, dim)
+    block_ids = torch.arange(num_blocks)
+    stage_key = torch.full((num_blocks * block_size, heads, dim), -1.0)
+    stage_value = torch.full((num_blocks * block_size, heads, dim), -1.0)
+
+    _stage_window(
+        stage_key, stage_value, key_cache, value_cache, block_ids, num_blocks, block_size, first_block=num_blocks - 1
+    )
+
+    history_rows = (num_blocks - 1) * block_size
+    assert (stage_key[:history_rows] == -1.0).all(), "history rows were rewritten by a tail restage"
+    assert (stage_value[:history_rows] == -1.0).all()
+    torch.testing.assert_close(stage_key[history_rows:], key_cache[-1].reshape(block_size, heads, dim), rtol=0, atol=0)
diff --git a/tests/diffusion/ar_diffusion/test_kv_orchestration.py b/tests/diffusion/ar_diffusion/test_kv_orchestration.py
index 4482fa6fb..0c1c870bf 100644
--- a/tests/diffusion/ar_diffusion/test_kv_orchestration.py
+++ b/tests/diffusion/ar_diffusion/test_kv_orchestration.py
@@ -6,6 +6,7 @@ import torch
 
 from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
 from vllm_omni.experimental.ar_diffusion.kv_cache import ARDiffusionKVCache, ARDiffusionKVConfig
+from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 DIMS = dict(
@@ -108,3 +109,104 @@ def test_state_close_frees_both_branch_blocks():
     state.close()
     # All blocks returned — no leak across an evicted session.
     assert kv.manager.block_pool.get_num_free_blocks() == free_total
+
+
+@pytest.mark.parametrize(
+    "frames_per_call,block_size,max_model_len,num_calls",
+    [(1, 16, 113, 1000), (3, 16, 113, 1000), (3, 1560, 1 << 20, 241)],
+    ids=["single-frame", "three-frame", "lingbot-two-minutes"],
+)
+@pytest.mark.parametrize("sink_chunks,reset_at_boundary", [(0, False), (2, False), (0, True), (2, True)])
+def test_rollout_keeps_metadata_bounded(
+    frames_per_call, block_size, max_model_len, num_calls, sink_chunks, reset_at_boundary
+):
+    """Long rollouts retain exact global-position K/V with bounded storage indices."""
+    kv = ARDiffusionKVCache(
+        ARDiffusionKVConfig(
+            enable=True,
+            chunk_size=block_size,
+            window_chunks=3,
+            sink_chunks=sink_chunks,
+            reset_at_boundary=reset_at_boundary,
+        ),
+        num_layers=1,
+        num_kv_heads=1,
+        head_size=4,
+        dtype=torch.float32,
+        block_size=block_size,
+        max_model_len=max_model_len,
+        available_bytes=1 << 24,
+        kv_branches=(ARDiffusionKVBranchSpec("main", 0),),
+        session_capacity=1,
+        frames_per_block=frames_per_call,
+        device=torch.device("cpu"),
+    )
+    adapter = kv.begin_request("long-rollout")
+    state = ARDiffusionKVState(kv, "long-rollout", {"main": adapter}, num_layers=1)
+    free_total = kv.manager.block_pool.get_num_free_blocks()
+    pool_shape = kv.key_cache(0).shape
+    retained_frames = sink_chunks + (0 if reset_at_boundary else 3)
+    for call_index in range(num_calls):
+        start = call_index * frames_per_call * block_size
+        stop = start + frames_per_call * block_size
+        if frames_per_call == 1:
+            kv.allocate_chunk(adapter)
+            slots = kv.chunk_write_slots(adapter)
+        else:
+            context = state.get_kv_caches("main", seq_len=stop - start, commit_current=True)[0].forward_ctx
+            context.ensure_video_slots(torch.device("cpu"))
+            slots = context.current_video_slot_mapping
+        assert len(kv.block_table(adapter)) <= retained_frames + frames_per_call
+        values = torch.arange(start, stop, dtype=torch.float32).view(-1, 1, 1).expand(-1, 1, 4)
+        kv.key_cache(0).flatten(0, 1)[slots] = values
+        kv.value_cache(0).flatten(0, 1)[slots] = -values
+        if frames_per_call == 1:
+            kv.commit_chunk(adapter)
+        else:
+            state.commit_paged_context("main")
+            assert state._committed["main"] == stop
+        sink_end = min(stop, sink_chunks * block_size)
+        tail_start = stop if reset_at_boundary else max(sink_end, stop - 3 * block_size)
+        expected = torch.cat((torch.arange(sink_end), torch.arange(tail_start, stop))).float()
+        expected = expected.view(-1, 1, 1).expand(-1, 1, 4)
+        resident = kv.window_block_ids(adapter)
+        torch.testing.assert_close(kv.key_cache(0)[resident].flatten(0, 1), expected)
+        torch.testing.assert_close(kv.value_cache(0)[resident].flatten(0, 1), -expected)
+        assert adapter.completed_chunks * block_size == stop
+        assert adapter.absolute_num_computed_tokens == stop
+        assert len(kv.block_table(adapter)) <= retained_frames
+        assert adapter.num_computed_tokens <= retained_frames * block_size
+        assert kv.key_cache(0).shape == pool_shape
+        assert free_total - kv.manager.block_pool.get_num_free_blocks() == min(stop // block_size, retained_frames)
+    state.reset()
+    fresh = state.adapter("main")
+    assert fresh.compacted_tokens == fresh.absolute_num_computed_tokens == fresh.num_computed_tokens == 0
+    assert kv.block_table(fresh) == []
+    assert kv.manager.block_pool.get_num_free_blocks() == free_total
+    kv.allocate_chunk(fresh)
+    assert len(kv.chunk_write_slots(fresh)) == block_size
+    state.close()
+    assert kv.manager.block_pool.get_num_free_blocks() == free_total
+
+
+def test_compaction_offsets_are_request_local():
+    kv = make_cache()
+    free_total = kv.manager.block_pool.get_num_free_blocks()
+    first, second = kv.begin_request("first"), kv.begin_request("second")
+    for index in range(8):
+        kv.allocate_chunk(first)
+        kv.commit_chunk(first)
+        if index in (0, 4):
+            kv.allocate_chunk(second)
+            kv.commit_chunk(second)
+    assert first.absolute_num_computed_tokens == 8 * 16
+    assert first.compacted_tokens == 6 * 16
+    assert second.absolute_num_computed_tokens == 2 * 16
+    assert second.compacted_tokens == 0
+    assert first.num_computed_tokens == second.num_computed_tokens == 2 * 16
+    assert set(kv.block_table(first)).isdisjoint(kv.block_table(second))
+    kv.end_request(first)
+    kv.end_request(second)
+    group = kv.manager.coordinator.single_type_managers[0]
+    assert not group.req_to_blocks and not group.num_cached_block
+    assert kv.manager.block_pool.get_num_free_blocks() == free_total
diff --git a/tests/diffusion/ar_diffusion/test_paged_attention.py b/tests/diffusion/ar_diffusion/test_paged_attention.py
index 603a2a175..612c974ce 100644
--- a/tests/diffusion/ar_diffusion/test_paged_attention.py
+++ b/tests/diffusion/ar_diffusion/test_paged_attention.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Tests for AR-Diffusion paged self-attention contexts."""
 
 from __future__ import annotations
@@ -20,6 +21,8 @@ from vllm_omni.experimental.ar_diffusion.kv_cache import (
     ar_diffusion_paged_attention,
     paged_write_attn,
 )
+from vllm_omni.experimental.ar_diffusion.kv_cache import paged_attention as paged_attention_module
+from vllm_omni.experimental.ar_diffusion.kv_cache.config import KV_GATHER_ENV
 from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
@@ -32,8 +35,12 @@ POS = "positive"
 NEG = "negative"
 
 
-def make_state(*, num_layers=1, window_chunks=2, dtype=torch.float32, device=torch.device("cpu")):
-    cfg = ARDiffusionKVConfig(enable=True, chunk_size=BLOCK, window_chunks=window_chunks)
+def make_state(
+    *, num_layers=1, window_chunks=2, dtype=torch.float32, device=torch.device("cpu"), reuse_history_staging=False
+):
+    cfg = ARDiffusionKVConfig(
+        enable=True, chunk_size=BLOCK, window_chunks=window_chunks, reuse_history_staging=reuse_history_staging
+    )
     kv = ARDiffusionKVCache(
         cfg,
         num_layers=num_layers,
@@ -236,6 +243,86 @@ def test_paged_attention_matches_dense_reference_cpu(history_chunks, action_len,
     assert st.adapter(POS).completed_chunks == before + (1 if commit_current else 0)
 
 
+@pytest.mark.parametrize("history_chunks", [0, 1, 2, 3])
+def test_staged_reuse_refreshes_the_current_blocks_at_their_live_offset(monkeypatch, history_chunks):
+    """A second probe of the same AR block restages its current K/V where the table actually holds it.
+
+    The padded table always ends in at least one action-capacity block, and while the window is still
+    growing in unused window capacity too, so "the last current_blocks entries" is padding. The refresh
+    has to start right after the visible history: empty (window growing), partial, full, and after a slide.
+    """
+    monkeypatch.setenv(KV_GATHER_ENV, "1")
+    device = torch.device("cpu")
+    dtype = torch.float32
+    kv, st = make_state(dtype=dtype, device=device, window_chunks=2, reuse_history_staging=True)
+    if history_chunks:
+        _commit_video_span(kv, st, kv_branch=POS, n_chunks=history_chunks, dtype=dtype, device=device)
+
+    ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)[0].forward_ctx
+    ctx.ensure_video_slots(device)
+    key_cache, value_cache = kv.key_cache(0), kv.value_cache(0)
+
+    def probe(step: int):
+        # Each probe of the block writes new current K/V, then stages.
+        kv._k_pools[0][ctx.current_video_slot_mapping] = torch.full((BLOCK, N_HEADS, HEAD_DIM), float(step))
+        kv._v_pools[0][ctx.current_video_slot_mapping] = torch.full((BLOCK, N_HEADS, HEAD_DIM), -float(step))
+        # Store the metadata on the context the way prepare() does.
+        (ctx.block_table, ctx.query_start_loc, ctx.seq_lens, ctx.max_query_len, ctx.max_seq_len) = (
+            ctx.build_block_table(action_len=0, query_len=BLOCK, device=device)
+        )
+        block_table, max_seq_len = ctx.block_table, ctx.max_seq_len
+        ctx._prepare_history_staging(0)
+        n_blocks = max_seq_len // BLOCK
+        block_ids = block_table[0, :n_blocks].to(torch.long)
+        stage_k, stage_v = ctx.history_staging(0)
+        paged_attention_module._stage_window(
+            stage_k,
+            stage_v,
+            key_cache,
+            value_cache,
+            block_ids,
+            n_blocks,
+            BLOCK,
+            first_block=ctx.stage_first_block if ctx.reuse_history else 0,
+        )
+        full_k = key_cache.index_select(0, block_ids).reshape(n_blocks * BLOCK, N_HEADS, HEAD_DIM)
+        full_v = value_cache.index_select(0, block_ids).reshape(n_blocks * BLOCK, N_HEADS, HEAD_DIM)
+        return stage_k, stage_v, full_k, full_v, n_blocks
+
+    stage_k, stage_v, full_k, full_v, n_blocks = probe(1)
+    assert ctx.reuse_history is False
+    assert torch.equal(stage_k, full_k) and torch.equal(stage_v, full_v)
+
+    stage_k, stage_v, full_k, full_v, n_blocks = probe(2)
+    assert ctx.reuse_history is True
+    visible_history_blocks = min(history_chunks, 2 - 1)  # window of 2 blocks minus the current one
+    assert ctx.stage_first_block == visible_history_blocks
+    # The padded table is wider than the live window, so the end-of-table guess is not the offset.
+    assert n_blocks - 1 != ctx.stage_first_block
+    assert torch.equal(stage_k, full_k) and torch.equal(stage_v, full_v)
+
+
+@pytest.mark.parametrize("gather_enabled", [False, True])
+def test_staging_is_only_allocated_for_the_gather_path(monkeypatch, gather_enabled):
+    if gather_enabled:
+        monkeypatch.setenv(KV_GATHER_ENV, "1")
+    else:
+        monkeypatch.delenv(KV_GATHER_ENV, raising=False)
+    device = torch.device("cpu")
+    kv, st = make_state(device=device, reuse_history_staging=True)
+    # The manager owns the pairs and allocates them only when their consumer is on.
+    assert bool(kv.history_staging) is gather_enabled
+    ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)[0].forward_ctx
+    ctx.ensure_video_slots(device)
+    (ctx.block_table, ctx.query_start_loc, ctx.seq_lens, ctx.max_query_len, ctx.max_seq_len) = ctx.build_block_table(
+        action_len=0, query_len=BLOCK, device=device
+    )
+    ctx._prepare_history_staging(0)
+    assert ctx.staging_enabled is gather_enabled
+    stage_k, _ = ctx.history_staging(0)
+    assert (stage_k is not None) is gather_enabled
+
+
 @pytest.mark.skipif(not _gpu_flash_attn_usable(), reason="usable GPU FlashAttention is required")
 @pytest.mark.parametrize("history_chunks", [1, 3])
 @pytest.mark.parametrize("action_len", [0, 3])
@@ -376,13 +463,27 @@ def test_custom_op_registration_idempotent():
     assert hasattr(torch.ops.vllm_omni, "ar_diffusion_paged_write_attn")
 
 
-def test_custom_op_compiles_fullgraph_without_recompile_on_value_change():
+def test_custom_op_mutable_arguments_cannot_be_elided_as_defaults():
+    # Older PyTorch ADInplaceOrView handlers index positional mutable inputs
+    # directly. Default-valued trailing inputs can disappear before that handler.
+    schema = torch.ops.vllm_omni.ar_diffusion_paged_write_attn.default._schema
+    mutable = [arg for arg in schema.arguments if arg.alias_info is not None and arg.alias_info.is_write]
+    assert {arg.name for arg in mutable} == {"key_pool", "value_pool", "stage_key", "stage_value"}
+    assert all(not arg.has_default_value() for arg in mutable)
+
+
+@pytest.mark.parametrize("reuse_history_staging", [False, True])
+def test_custom_op_compiles_fullgraph_without_recompile_on_value_change(monkeypatch, reuse_history_staging):
     """The op must trace as one opaque node: fullgraph OK, and changed tensor
     VALUES (new slots / block ids) must not trigger recompilation."""
     import torch._dynamo
 
     device = torch.device("cpu")
-    kv, st = make_state(num_layers=2, window_chunks=2)
+    monkeypatch.setenv(KV_GATHER_ENV, "1")
+    kv, st = make_state(num_layers=2, window_chunks=2, reuse_history_staging=reuse_history_staging)
+    if reuse_history_staging:
+        # Hold the host-side staging offset fixed while table/slot values change.
+        _commit_video_span(kv, st, kv_branch=POS, n_chunks=2, dtype=torch.float32, device=device)
 
     def run_one_forward(commit):
         contexts = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=commit)
@@ -391,9 +492,8 @@ def test_custom_op_compiles_fullgraph_without_recompile_on_value_change():
         q = torch.randn(BLOCK, N_HEADS, HEAD_DIM)
         k = torch.randn(BLOCK, N_HEADS, HEAD_DIM)
         v = torch.randn(BLOCK, N_HEADS, HEAD_DIM)
-        # Both layers through ONE compiled fn: layer_idx is a tensor, so a
-        # different layer must NOT recompile (all 40 DiT blocks share the
-        # block-forward code object in production).
+        # Both layers use one compiled function; the tensor-valued layer index
+        # must not specialize it.
         for layer_ctx in contexts:
             out = compiled(layer_ctx.to_layer_inputs(), q, k, v)
         st.commit_paged_context(POS)
@@ -419,3 +519,52 @@ def test_custom_op_compiles_fullgraph_without_recompile_on_value_change():
         # Leave a clean dynamo state for later suites in the same pytest process
         # (e.g. model_executor transformers models).
         torch._dynamo.reset()
+
+
+@pytest.mark.skipif(not _gpu_flash_attn_usable(), reason="usable GPU FlashAttention is required")
+@pytest.mark.parametrize("history_chunks", [0, 1, 3])
+@pytest.mark.parametrize("action_len", [0, 3])
+def test_contiguous_kv_gather_path_matches_paged_path_gpu(monkeypatch, history_chunks, action_len):
+    """VLLM_OMNI_AR_DIFFUSION_KV_GATHER=1 gathers the visible blocks and runs varlen FA3 without a block table.
+
+    Covers an empty, partial and full window plus a partially filled action block:
+    the gather reads the tail-padding null block, so its (zeroed) rows must be masked.
+    """
+
+    torch.manual_seed(0)
+    device = torch.device("cuda")
+    dtype = torch.float16
+    kv, st = make_state(dtype=dtype, device=device, window_chunks=2)
+    if history_chunks:
+        _commit_video_span(kv, st, kv_branch=POS, n_chunks=history_chunks, dtype=dtype, device=device)
+
+    layer_ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)[0]
+    ctx = layer_ctx.forward_ctx
+    current_k = torch.randn(1, BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
+    current_v = torch.randn(1, BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
+    action_k = action_v = None
+    if action_len:
+        action_k = torch.randn(1, action_len, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
+        action_v = torch.randn(1, action_len, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
+    query = torch.randn(1, BLOCK + action_len, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
+    ctx.prepare(device=device, action_len=action_len, query_len=query.shape[1])
+    inputs = layer_ctx.to_layer_inputs()
+
+    def run() -> torch.Tensor:
+        return paged_write_attn(
+            inputs,
+            query[0],
+            current_k[0],
+            current_v[0],
+            action_k[0] if action_len else None,
+            action_v[0] if action_len else None,
+            HEAD_DIM**-0.5,
+        ).unsqueeze(0)
+
+    monkeypatch.delenv(KV_GATHER_ENV, raising=False)
+    paged = run()
+    monkeypatch.setenv(KV_GATHER_ENV, "1")
+    gathered = run()
+    assert torch.isfinite(gathered).all()
+    # Same kernel family on the same K/V: only accumulation order differs.
+    torch.testing.assert_close(gathered, paged, rtol=2e-3, atol=2e-3)
diff --git a/tests/diffusion/attention/test_flash_attn.py b/tests/diffusion/attention/test_flash_attn.py
index 183bbd94c..5dbd8d794 100644
--- a/tests/diffusion/attention/test_flash_attn.py
+++ b/tests/diffusion/attention/test_flash_attn.py
@@ -16,13 +16,14 @@ from unittest.mock import Mock
 import pytest
 import torch
 
+from tests.helpers.mark import hardware_test
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.backends.flash_attn import FlashAttentionImpl
 from vllm_omni.diffusion.attention.backends.sdpa import SDPAImpl
 from vllm_omni.diffusion.attention.backends.utils import fa  # noqa: E402
 from vllm_omni.platforms import current_omni_platform
 
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
 
 is_gpu = current_omni_platform.is_cuda_alike() or current_omni_platform.is_xpu()
 HAS_FLASH_ATTN = fa.HAS_FLASH_ATTN
@@ -42,10 +43,12 @@ flash_attn_func = fa.flash_attn_func  # noqa: N813
         (9, "4", frozenset((2, 3, 4)), 4),
     ],
 )
+@pytest.mark.cpu
 def test_versioned_flash_attention_selection(device_major, requested, supported, expected):
     assert fa._choose_vllm_flash_attn_version(device_major, requested, supported) == expected
 
 
+@pytest.mark.cpu
 def test_versioned_flash_attention_selection_rejects_invalid_or_unavailable_version():
     with pytest.raises(ValueError, match="must be 2, 3, or 4"):
         fa._choose_vllm_flash_attn_version(9, "5", frozenset((2, 3, 4)))
@@ -92,7 +95,8 @@ def pad_tensor(tensor: torch.Tensor, target_seq_len: int, pad_value: float = 0.0
     return torch.cat([tensor, padding], dim=1)
 
 
-@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires CUDA or XPU")
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires an accelerator")
 def test_padding_equivalence():
     """
     Case 1: Test that padded and unpadded inputs produce similar outputs.
@@ -185,7 +189,8 @@ def test_padding_equivalence():
     print("✓ Case 1 PASSED: Padded and unpadded outputs are very close!")
 
 
-@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires CUDA or XPU")
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires an accelerator")
 def test_fa_vs_sdpa():
     """
     Case 2: Compare FlashAttention and SDPA backends with padding.
@@ -302,7 +307,8 @@ def test_fa_vs_sdpa():
     print("✓ Case 2 PASSED: FA and SDPA outputs are very close!")
 
 
-@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires CUDA or XPU")
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires an accelerator")
 def test_flash_attn_func_preferred_over_varlen():
     """Test flash_attn_func availability and basic forward call."""
     if not HAS_FLASH_ATTN:
@@ -332,7 +338,8 @@ def test_flash_attn_func_preferred_over_varlen():
     print("✓ flash_attn_func forward works correctly!")
 
 
-@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires CUDA or XPU")
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires an accelerator")
 @pytest.mark.parametrize("k_len", [40, 256])
 def test_cross_attn_key_padding_vs_sdpa(k_len):
     """
@@ -390,6 +397,7 @@ def test_cross_attn_key_padding_vs_sdpa(k_len):
     print("✓ Case 3 PASSED: FA and SDPA cross-attention outputs are very close!")
 
 
+@pytest.mark.cpu
 def test_varlen_masked_routing_by_role(monkeypatch):
     """The unpad route is picked by role, not Q/K length equality; runs without a GPU."""
     calls = []
@@ -424,6 +432,7 @@ def test_varlen_masked_routing_by_role(monkeypatch):
     assert cu_seqlens_k.tolist() == [0, 2, 5]
 
 
+@pytest.mark.cpu
 def test_piecewise_flash_attn_uses_varlen_fallback(monkeypatch):
     calls = []
 
@@ -454,6 +463,7 @@ def test_piecewise_flash_attn_uses_varlen_fallback(monkeypatch):
     assert calls[0]["softmax_scale"] == 0.5
 
 
+@pytest.mark.cpu
 def test_packed_varlen_metadata_bypasses_mask_unpadding(monkeypatch):
     calls = []
 
@@ -486,6 +496,7 @@ def test_packed_varlen_metadata_bypasses_mask_unpadding(monkeypatch):
     assert calls[0][3]["max_seqlen_q"] == 6
 
 
+@pytest.mark.cpu
 def test_packed_varlen_metadata_must_be_complete(monkeypatch):
     monkeypatch.setattr(fa, "HAS_FLASH_ATTN", True)
     impl = FlashAttentionImpl(num_heads=2, head_size=4, softmax_scale=0.5, causal=False)
@@ -542,6 +553,7 @@ def _fake_torch_npu(monkeypatch, *, npu_fusion_attention=None):
 # --- Test group A: boundary resolution (_resolve_packed_seq_npu) -------------
 
 
+@pytest.mark.cpu
 def test_resolve_packed_seq_accepts_real_plus_pad_contract():
     impl = _npu_impl()
     q = torch.randn(1, 8, 2, 4)
@@ -551,6 +563,7 @@ def test_resolve_packed_seq_accepts_real_plus_pad_contract():
     assert impl._resolve_packed_seq_npu(q, q, extra) == ([5, 8], [5, 8])
 
 
+@pytest.mark.cpu
 def test_resolve_packed_seq_single_document_no_padding():
     impl = _npu_impl()
     q = torch.randn(1, 8, 2, 4)
@@ -574,6 +587,7 @@ def test_resolve_packed_seq_single_document_no_padding():
         "pad_longer_than_real",
     ],
 )
+@pytest.mark.cpu
 def test_resolve_packed_seq_rejects_malformed_metadata(case):
     """Any metadata outside the exact [real, pad] contract returns None so the
     caller falls back to the masked path."""
@@ -630,6 +644,7 @@ def _npu_impl_with_mocked_paths() -> tuple[FlashAttentionImpl, torch.Tensor]:
     return impl, sentinel
 
 
+@pytest.mark.cpu
 def test_npu_env_unset_uses_varlen(monkeypatch):
     monkeypatch.delenv("MINDIE_SD_FA_TYPE", raising=False)
     _fake_mindiesd(monkeypatch)
@@ -642,6 +657,7 @@ def test_npu_env_unset_uses_varlen(monkeypatch):
     impl._forward_prefix_kv_slice_npu.assert_not_called()
 
 
+@pytest.mark.cpu
 def test_npu_env_laser_uses_slice(monkeypatch):
     monkeypatch.setenv("MINDIE_SD_FA_TYPE", "ascend_laser_attention")
     _fake_mindiesd(monkeypatch)
@@ -655,6 +671,7 @@ def test_npu_env_laser_uses_slice(monkeypatch):
 
 
 @pytest.mark.parametrize("fa_type", ["prompt_flash_attn", "fused_attn_score", "ascend_laser_attenton", "garbage"])
+@pytest.mark.cpu
 def test_npu_env_non_laser_value_falls_back_to_varlen(monkeypatch, fa_type):
     """Locks in the CURRENT dispatch behavior (PR #5891).
 
@@ -675,6 +692,7 @@ def test_npu_env_non_laser_value_falls_back_to_varlen(monkeypatch, fa_type):
     impl._forward_prefix_kv_slice_npu.assert_not_called()
 
 
+@pytest.mark.cpu
 def test_npu_varlen_opt_in_unset_takes_mask_path(monkeypatch):
     """Models that do not set ``npu_attn_varlen`` (e.g. Wan/Cosmos) keep using
     the existing masked attention_forward path; the new branches are skipped."""
@@ -702,6 +720,7 @@ def test_npu_varlen_opt_in_unset_takes_mask_path(monkeypatch):
     ("query_length", "key_length", "expected_inner_precise"),
     [(4, 4, 0), (2, 4, 0), (4, 2, 2)],
 )
+@pytest.mark.cpu
 def test_npu_causal_uses_native_right_down_mode(
     monkeypatch,
     query_length,
@@ -746,6 +765,7 @@ def test_npu_causal_uses_native_right_down_mode(
     assert out is expected_out
 
 
+@pytest.mark.cpu
 def test_npu_causal_composes_explicit_keep_mask(monkeypatch):
     expected_out = torch.randn(1, 4, 2, 4)
     fusion_attention = Mock(return_value=(expected_out, None, None, None, 0, 0, 0))
@@ -782,6 +802,7 @@ def test_npu_causal_composes_explicit_keep_mask(monkeypatch):
     assert out is expected_out
 
 
+@pytest.mark.cpu
 def test_npu_noncausal_without_explicit_mask_stays_unmasked(monkeypatch):
     captured: dict = {}
 
@@ -800,6 +821,7 @@ def test_npu_noncausal_without_explicit_mask_stays_unmasked(monkeypatch):
 # --- Test group D: laser input pre-scaling in _forward_prefix_kv_slice_npu --
 
 
+@pytest.mark.cpu
 def test_prefix_kv_slice_applies_laser_input_scaling(monkeypatch):
     monkeypatch.setenv("MINDIE_SD_FA_TYPE", "ascend_laser_attention")
     captured: dict = {}
@@ -838,6 +860,7 @@ def test_prefix_kv_slice_applies_laser_input_scaling(monkeypatch):
     torch.testing.assert_close(out, torch.ones(1, 8, 2, 4) * 256.0)
 
 
+@pytest.mark.cpu
 def test_prefix_kv_slice_no_scaling_without_factor(monkeypatch):
     monkeypatch.setenv("MINDIE_SD_FA_TYPE", "ascend_laser_attention")
     captured: dict = {}
diff --git a/tests/diffusion/attention/test_mindie_public_integration.py b/tests/diffusion/attention/test_mindie_public_integration.py
new file mode 100644
index 000000000..c3df5351b
--- /dev/null
+++ b/tests/diffusion/attention/test_mindie_public_integration.py
@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Cross-repository CPU dispatch contracts, requiring the matching MindIE-SD source.
+
+Only native operators are replaced. Public adapters, rotations, layouts, padding,
+scale preparation, sequence metadata and output cropping execute their real code.
+Operator substitutes carry floating tensors; these are not numerical quantization tests.
+"""
+
+import importlib
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends import flash_attn, rainfusion_attn
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.platforms.npu.quant.kv_quant_npu import get_quant_attention_rotation
+
+mindiesd = pytest.importorskip("mindiesd")
+torch_npu = importlib.import_module("torch_npu")
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    "precision,batch,q_len,kv_len,q_heads",
+    [
+        ("fp8", 1, 130, 130, 2),
+        ("mxfp8", 1, 130, 130, 2),
+        ("mxfp4", 1, 130, 130, 2),
+        ("mxfp8", 2, 17, 8, 4),
+        ("mxfp8", 2, 8, 17, 4),
+    ],
+)
+@pytest.mark.parametrize("layout", ["BSND", "BNSD"])
+def test_omni_calls_real_dense_public_api(monkeypatch, precision, layout, batch, q_len, kv_len, q_heads):
+    assert callable(getattr(mindiesd, "quant_attention", None)), "MindIE-SD must export quant_attention"
+    monkeypatch.setattr(flash_attn, "current_omni_platform", SimpleNamespace(is_npu=lambda: True, device_name="npu"))
+    monkeypatch.setattr(flash_attn, "get_current_diffusion_config_or_none", lambda: None)
+    quantized_inputs = []
+
+    def dynamic_quant(tensor, **kwargs):
+        quantized_inputs.append((tensor.clone(), kwargs))
+        shape = list(tensor.shape)
+        axis = kwargs.get("axis", -1)
+        shape[axis] = max(1, shape[axis] // 32)
+        return tensor, torch.ones(shape, dtype=torch.uint8)
+
+    monkeypatch.setattr(torch_npu, "npu_dynamic_block_quant", dynamic_quant, raising=False)
+    monkeypatch.setattr(torch_npu, "npu_dynamic_mx_quant", dynamic_quant, raising=False)
+    execute = Mock(side_effect=lambda query, *args, **kwargs: (query, None))
+    metadata = Mock(return_value=torch.zeros(1, dtype=torch.int32))
+    if precision == "fp8":
+        monkeypatch.setattr(torch.ops.mindiesd, "fused_infer_attention_score_v2", execute, raising=False)
+    elif precision == "mxfp8":
+        monkeypatch.setattr(torch_npu, "npu_fused_infer_attention_score_v2", execute, raising=False)
+    else:
+        monkeypatch.setattr(torch.ops.mindiesd, "quant_flash_attn", execute, raising=False)
+        monkeypatch.setattr(torch.ops.mindiesd, "quant_flash_attn_metadata", metadata, raising=False)
+
+    query = torch.randn(batch, q_len, q_heads, 64, dtype=torch.bfloat16)
+    key = torch.randn(batch, kv_len, 2, 64, dtype=torch.bfloat16)
+    value = torch.randn_like(key)
+    if layout == "BNSD":
+        query, key, value = (tensor.transpose(1, 2) for tensor in (query, key, value))
+    impl = flash_attn.FlashAttentionImpl(
+        num_heads=q_heads,
+        head_size=64,
+        softmax_scale=0.37,
+        qkv_layout=layout,
+    )
+    output = impl.forward_npu(query, key, value, AttentionMetadata(extra={"kv_cache_dtype": precision}))
+    rotation = get_quant_attention_rotation(query.device, query.dtype, 64)
+    expected = query @ rotation
+    torch.testing.assert_close(output, expected)
+    assert output.shape == query.shape and len(quantized_inputs) == 3
+    execute.assert_called_once()
+    kwargs = execute.call_args.kwargs
+    assert kwargs["softmax_scale"] == 0.37
+    if precision == "fp8":
+        assert kwargs["input_layout"] == "BNSD"
+        assert quantized_inputs[0][0].shape == (2, 130, 64)
+        assert quantized_inputs[0][1]["row_block_size"] == 128
+    elif precision == "mxfp8":
+        args = execute.call_args.args
+        assert args[0].shape == (batch * q_len, q_heads, 64)
+        assert args[1].shape == args[2].shape == (batch * kv_len, 2, 64)
+        assert kwargs["input_layout"] == "TND"
+        assert kwargs["num_query_heads"] == q_heads and kwargs["num_key_value_heads"] == 2
+        assert kwargs["actual_seq_qlen"] == [q_len * (i + 1) for i in range(batch)]
+        assert kwargs["actual_seq_kvlen"] == [kv_len * (i + 1) for i in range(batch)]
+        assert [entry[1]["axis"] for entry in quantized_inputs] == [-1, -1, 0]
+    else:
+        seq_axis = 1 if layout == "BSND" else 2
+        assert quantized_inputs[0][0].shape[seq_axis] == 512
+        assert kwargs["seqused_q"].tolist() == kwargs["seqused_kv"].tolist() == [512]
+        assert kwargs["layout_q"] == kwargs["layout_out"] == layout
+        assert kwargs["q_dtype"] == torch_npu.float4_e2m1fn_x2
+        assert kwargs["q_descale_dtype"] == torch_npu.float8_e8m0fnu
+        assert execute.call_args.args[3].shape[:2] == (1, 2)
+        assert [entry[1]["axis"] for entry in quantized_inputs] == [-1, -1, seq_axis]
+        assert kwargs["metadata"] is metadata.return_value
+        metadata.assert_called_once()
+
+
+@pytest.mark.parametrize("precision", ["fp8", "mxfp4"])
+@pytest.mark.parametrize("length", [65, 600])
+def test_omni_calls_real_sparse_public_api(monkeypatch, precision, length):
+    rf = importlib.import_module("mindiesd.layers.flash_attn.sparse_flash_attn_rf_v3")
+    monkeypatch.setattr(flash_attn, "current_omni_platform", SimpleNamespace(is_npu=lambda: True, device_name="npu"))
+    for module in (flash_attn, rainfusion_attn):
+        monkeypatch.setattr(module, "get_current_diffusion_config_or_none", lambda: None)
+    rainfusion_attn._mindiesd_supports_precision.cache_clear()
+    monkeypatch.setattr(rf, "do_tensor_rearrange_only", lambda q, k, v, *a, **kw: (q, k, v))
+    monkeypatch.setattr(rf, "avgpool", lambda *a, **kw: torch.ones(1))
+    monkeypatch.setattr(rf, "_generate_mask_direct", lambda *a, **kw: torch.ones(1, 2, 8, 8))
+    monkeypatch.setattr(rf, "_bsa_inv_rearrange", lambda out, *a: out)
+
+    def quantize(tensor, **kwargs):
+        shape = list(tensor.shape)
+        axis = kwargs.get("axis", -1)
+        shape[axis] = max(1, shape[axis] // 32)
+        return tensor, torch.ones(shape, dtype=torch.uint8)
+
+    monkeypatch.setattr(torch_npu, "npu_dynamic_mx_quant", quantize, raising=False)
+    monkeypatch.setattr(torch_npu, "npu_dynamic_block_quant", quantize, raising=False)
+    execute = Mock(side_effect=lambda **kw: (torch.ones_like(kw["query"]), None))
+    monkeypatch.setattr(torch.ops.mindiesd, "block_sparse_attention", execute, raising=False)
+    query = torch.randn(1, length, 2, 64, dtype=torch.bfloat16)
+    impl = rainfusion_attn.RainFusionAttentionImpl(
+        num_heads=2,
+        head_size=64,
+        softmax_scale=0.37,
+        qkv_layout="BSND",
+        backend_kwargs={"sparsity": 0.8},
+    )
+    plan = rainfusion_attn.RainFusionPlan(used_len=length, prefix_len=0, latent_shape=(1, 1, length))
+    try:
+        output = impl._forward_sparse_npu(
+            query,
+            query,
+            query,
+            plan,
+            AttentionMetadata(extra={"kv_cache_dtype": precision}),
+        )
+    finally:
+        rainfusion_attn._mindiesd_supports_precision.cache_clear()
+    torch.testing.assert_close(output, torch.ones_like(query))
+    execute.assert_called_once()
+    kwargs = execute.call_args.kwargs
+    assert kwargs["actual_seq_lengths"] == kwargs["actual_seq_lengths_kv"] == [length]
+    assert kwargs["q_input_layout"] == "BNSD"
+    assert kwargs["block_sparse_mask"] is not None
+    if precision == "mxfp4":
+        assert kwargs["query"].shape[2] == (length + 63) // 64 * 64
+        assert kwargs["quant_mode"] == 2
+        assert kwargs["q_dtype"] == torch_npu.float4_e2m1fn_x2
+        assert kwargs["v_scale_dtype"] == torch_npu.float8_e8m0fnu
diff --git a/tests/diffusion/attention/test_mindie_runtime.py b/tests/diffusion/attention/test_mindie_runtime.py
new file mode 100644
index 000000000..40e51b21d
--- /dev/null
+++ b/tests/diffusion/attention/test_mindie_runtime.py
@@ -0,0 +1,323 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CPU contract tests for MindIE adapters; no NPU kernels are mocked in production."""
+
+import sys
+from types import ModuleType, SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention import layer as layer_mod
+from vllm_omni.diffusion.attention.backends import flash_attn, rainfusion_attn
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata, VideoTokenLayout
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+_DEFAULT_SKIP_STEPS = frozenset({0, 1, 38, 39})
+
+
+@pytest.fixture
+def runtime(monkeypatch):
+    mod = ModuleType("mindiesd")
+
+    def execute(q, k, v, *, precision, layout, scale, q_rot=None, k_rot=None):
+        return q
+
+    setattr(mod, "quant_attention", Mock(side_effect=execute))
+    monkeypatch.setitem(sys.modules, mod.__name__, mod)
+    for module in (flash_attn, layer_mod):
+        monkeypatch.setattr(module, "current_omni_platform", SimpleNamespace(is_npu=lambda: True, device_name="npu"))
+    monkeypatch.setattr(flash_attn, "get_current_diffusion_config_or_none", lambda: None)
+    monkeypatch.setattr(rainfusion_attn, "get_current_diffusion_config_or_none", lambda: None)
+    monkeypatch.setattr(rainfusion_attn, "is_forward_context_available", lambda: False)
+    supports_precision = rainfusion_attn._mindiesd_supports_precision
+    supports_precision.cache_clear()
+    yield mod
+    supports_precision.cache_clear()
+
+
+def flash(layout="BSND"):
+    return flash_attn.FlashAttentionImpl(
+        num_heads=2,
+        head_size=64,
+        softmax_scale=0.37,
+        qkv_layout=layout,
+    )
+
+
+def sparse(**kwargs):
+    return rainfusion_attn.RainFusionAttentionImpl(
+        num_heads=2,
+        head_size=64,
+        softmax_scale=0.37,
+        qkv_layout="BSND",
+        backend_kwargs={"sparsity": 0.8, **kwargs},
+    )
+
+
+def video_metadata(**extra):
+    return AttentionMetadata(
+        video_layout=VideoTokenLayout(prefix_len=0, latent_grid=(4, 32, 32), used_len=4096),
+        extra={"max_seqlen_q": 4096, **extra},
+    )
+
+
+@pytest.mark.parametrize("method", ["fp8", "mxfp8", "mxfp4"])
+@pytest.mark.parametrize("layout", [None, "BSND", "BNSD"])
+def test_exact_runtime_layout_scale_and_rotation(runtime, method, layout):
+    q = torch.randn(1, 128, 2, 64, dtype=torch.bfloat16)
+    if layout == "BNSD":
+        q = q.transpose(1, 2)
+    impl = flash(layout=layout)
+    metadata = AttentionMetadata(extra={"kv_cache_dtype": method})
+    assert impl.forward_npu(q, q, q, metadata) is q
+    args, kwargs = runtime.quant_attention.call_args
+    assert args[0] is q  # no unconditional transpose or extra quantization
+    assert kwargs["layout"] == (layout or "BSND") and kwargs["scale"] == 0.37 and kwargs["precision"] == method
+    assert "attn_mask" not in kwargs
+    from vllm_omni.platforms.npu.quant.kv_quant_npu import get_quant_attention_rotation
+
+    assert kwargs["q_rot"] is kwargs["k_rot"]
+    torch.testing.assert_close(kwargs["q_rot"], get_quant_attention_rotation(q.device, q.dtype, 64))
+
+
+def test_missing_runtime_requires_config_change(runtime):
+    q = torch.randn(1, 128, 2, 64, dtype=torch.bfloat16)
+    del runtime.quant_attention
+    with pytest.raises(ImportError, match="diffusion_kv_cache_dtype"):
+        flash().forward_npu(q, q, q, AttentionMetadata(extra={"kv_cache_dtype": "mxfp4"}))
+
+
+def test_operator_failure_never_falls_back(runtime):
+    q = torch.randn(1, 128, 2, 64, dtype=torch.bfloat16)
+    runtime.quant_attention.side_effect = RuntimeError("operator failure")
+    with pytest.raises(RuntimeError, match="operator failure"):
+        flash().forward_npu(q, q, q, AttentionMetadata(extra={"kv_cache_dtype": "mxfp4"}))
+    runtime.quant_attention.assert_called_once()
+
+
+@pytest.mark.parametrize("method", ["fp8", "mxfp8", "mxfp4"])
+def test_unsupported_shape_requires_config_change(runtime, method):
+    q = torch.randn(1, 128, 2, 96, dtype=torch.bfloat16)
+    with pytest.raises(ValueError, match="diffusion_kv_cache_dtype"):
+        flash().forward_npu(q, q, q, AttentionMetadata(extra={"kv_cache_dtype": method}))
+    runtime.quant_attention.assert_not_called()
+
+
+def test_packed_metadata_never_reaches_quant_runtime(runtime):
+    q = torch.randn(1, 128, 2, 64, dtype=torch.bfloat16)
+    metadata = AttentionMetadata(extra={"kv_cache_dtype": "mxfp8", "cu_seqlens_q": torch.tensor([0, 64, 128])})
+    with pytest.raises(ValueError, match="packed/varlen"):
+        flash().forward_npu(q, q, q, metadata)
+    runtime.quant_attention.assert_not_called()
+
+
+def make_layer(runtime, monkeypatch, method="mxfp8", skip_steps=_DEFAULT_SKIP_STEPS):
+    layer = object.__new__(layer_mod.Attention)
+    torch.nn.Module.__init__(layer)
+    layer.attention = flash()
+    layer.attn_backend = flash_attn.FlashAttentionBackend
+    layer._disable_kv_quant = False
+    layer.layer_idx = 3
+    cfg = SimpleNamespace(
+        diffusion_kv_cache_dtype=method,
+        diffusion_kv_cache_skip_step_indices=skip_steps,
+        diffusion_kv_cache_skip_layer_indices=None,
+        parallel_config=SimpleNamespace(ring_degree=1),
+    )
+    layer._init_kv_cache_quantization(cfg)
+    return layer
+
+
+@pytest.mark.parametrize("method", ["fp8", "mxfp8", "mxfp4"])
+def test_global_quant_method_is_published_per_forward(runtime, monkeypatch, method):
+    layer = make_layer(runtime, monkeypatch, method=method, skip_steps=None)
+    assert layer._with_kv_cache_dtype(None).extra["kv_cache_dtype"] == method
+
+
+@pytest.mark.parametrize("method", [None, "auto", "float"])
+def test_optout_without_quant_policy_keeps_metadata_unchanged(runtime, monkeypatch, method):
+    layer = make_layer(runtime, monkeypatch)
+    layer._disable_kv_quant = True
+    layer._init_kv_cache_quantization(
+        SimpleNamespace(
+            diffusion_kv_cache_dtype=method,
+            diffusion_kv_cache_skip_step_indices=None,
+            diffusion_kv_cache_skip_layer_indices=None,
+            parallel_config=SimpleNamespace(ring_degree=1),
+        )
+    )
+    source = video_metadata()
+    assert layer._with_kv_cache_dtype(source) is source
+
+
+def test_step_skip_is_request_local_and_cross_optout(runtime, monkeypatch):
+    layer = make_layer(runtime, monkeypatch)
+    ctx = SimpleNamespace(denoise_step_idx=0)
+    monkeypatch.setattr(layer_mod, "is_forward_context_available", lambda: True)
+    monkeypatch.setattr(layer_mod, "get_forward_context", lambda: ctx)
+    source = video_metadata()
+    for step in list(range(40)) * 2:
+        ctx.denoise_step_idx = step
+        resolved = layer._with_kv_cache_dtype(source)
+        assert resolved.extra["kv_cache_dtype"] == ("float" if step in (0, 1, 38, 39) else "mxfp8")
+        assert resolved.video_layout is source.video_layout
+    assert source.extra == {"max_seqlen_q": 4096}
+    layer._disable_kv_quant = True
+    assert layer._with_kv_cache_dtype(source).extra["kv_cache_dtype"] == "float"
+
+
+def test_ring_attention_is_rejected(runtime, monkeypatch):
+    layer = make_layer(runtime, monkeypatch)
+    cfg = SimpleNamespace(diffusion_kv_cache_dtype="mxfp8", parallel_config=SimpleNamespace(ring_degree=2))
+    with pytest.raises(ValueError, match="ring"):
+        layer._init_kv_cache_quantization(cfg)
+
+
+def test_sparse_tail_steps_and_dense_quant_dispatch(runtime, monkeypatch):
+    ctx = SimpleNamespace(denoise_step_idx=49, total_denoise_steps=50)
+    monkeypatch.setattr(rainfusion_attn, "is_forward_context_available", lambda: True)
+    monkeypatch.setattr(rainfusion_attn, "get_forward_context", lambda: ctx)
+    impl = sparse(start_step=2, end_step=2)
+    metadata = video_metadata(kv_cache_dtype="fp8")
+    assert impl._resolve_plan(metadata) is None
+    q = torch.randn(1, 4096, 2, 64, dtype=torch.bfloat16)
+    impl.forward_npu(q, q, q, metadata)
+    assert runtime.quant_attention.call_args.kwargs["precision"] == "fp8"
+
+
+@pytest.mark.parametrize("method", ["fp8", "mxfp4"])
+def test_sparse_quant_uses_public_runtime(runtime, monkeypatch, method):
+    runtime.sparse_attention = Mock(side_effect=lambda q, k, v, **kwargs: q)
+    monkeypatch.setattr(rainfusion_attn, "_mindiesd_supports_precision", lambda: True)
+    q = torch.randn(1, 4224, 2, 64, dtype=torch.bfloat16)
+    out = sparse().forward_npu(q, q, q, video_metadata(kv_cache_dtype=method))
+    # The sparse path reuses the query tail as the output padding instead of
+    # zero-filling a fresh buffer; rows past the 4096-row valid prefix are
+    # never read back downstream (the model unpads by cu_seqlens), so pin the
+    # passthrough rather than requiring zeros.
+    assert out.shape == q.shape and torch.equal(out[:, 4096:], q[:, 4096:])
+    kwargs = runtime.sparse_attention.call_args.kwargs
+    assert (kwargs["precision"], kwargs["sparse_type"], kwargs["inner_precise"]) == (method, "rf_v3", 4)
+    runtime.quant_attention.assert_not_called()
+
+
+def test_sparse_custom_mask_stays_dense(runtime):
+    metadata = AttentionMetadata(
+        attn_mask=torch.ones(1, 4096, dtype=torch.bool),
+        video_layout=VideoTokenLayout(prefix_len=0, latent_grid=(4, 32, 32)),
+        extra={"max_seqlen_q": 4096},
+    )
+    assert sparse()._resolve_plan(metadata) is None
+
+
+def test_sparse_model_padding_mask_is_equivalent_to_trimming(runtime):
+    metadata = video_metadata()
+    metadata.attn_mask = torch.arange(4224)[None] < 4096
+    assert sparse()._resolve_plan(metadata).used_len == 4096
+
+
+def test_bsa_operator_failure_never_retries(runtime, monkeypatch):
+    runtime.sparse_attention = Mock(side_effect=RuntimeError("BSA operator failure"))
+    monkeypatch.setattr(rainfusion_attn, "_mindiesd_supports_precision", lambda: True)
+    q = torch.randn(1, 4096, 2, 64, dtype=torch.bfloat16)
+    with pytest.raises(RuntimeError, match="BSA operator failure"):
+        sparse().forward_npu(q, q, q, video_metadata(kv_cache_dtype="mxfp4"))
+    runtime.sparse_attention.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    "method,shape,supports_precision,error",
+    [
+        ("mxfp8", (1, 4096, 2, 64), True, "sparse mxfp8 is not supported"),
+        ("mxfp4", (1, 4096, 2, 64), False, "explicitly support precision"),
+        ("fp8", (2, 4096, 2, 64), True, "batch size 1"),
+        ("fp8", (1, 4096, 2, 32), True, "power-of-two head dimension"),
+        ("mxfp4", (1, 4096, 2, 96), True, "power-of-two head dimension"),
+    ],
+)
+def test_invalid_sparse_quant_requires_config_change(runtime, monkeypatch, method, shape, supports_precision, error):
+    runtime.sparse_attention = Mock(side_effect=lambda q, k, v, **kwargs: q)
+    monkeypatch.setattr(rainfusion_attn, "_mindiesd_supports_precision", lambda: supports_precision)
+    q = torch.randn(shape, dtype=torch.bfloat16)
+    with pytest.raises(ValueError, match=error):
+        sparse().forward_npu(q, q, q, video_metadata(kv_cache_dtype=method))
+    runtime.sparse_attention.assert_not_called()
+
+
+def test_layer_selector_requires_index_except_cross_optout(runtime, monkeypatch):
+    layer = make_layer(runtime, monkeypatch)
+    layer.layer_idx = None
+    config = SimpleNamespace(
+        diffusion_kv_cache_dtype="mxfp8",
+        diffusion_kv_cache_skip_step_indices=None,
+        diffusion_kv_cache_skip_layer_indices={0, 3},
+        parallel_config=SimpleNamespace(ring_degree=1),
+    )
+    with pytest.raises(ValueError, match="parseable transformer block index"):
+        layer._init_kv_cache_quantization(config)
+    layer._disable_kv_quant = True
+    layer._init_kv_cache_quantization(config)
+    assert layer._with_kv_cache_dtype(None).extra["kv_cache_dtype"] == "float"
+
+
+@pytest.mark.parametrize("prefix", ["transformer.blocks.3.attn1", "transformer_2.blocks.3.attn1"])
+@pytest.mark.parametrize("method", ["fp8", "mxfp4"])
+def test_expert_layer_and_step_skip_remain_sparse(runtime, monkeypatch, prefix, method):
+    def execute(q, k, v, *, precision="bf16", **kwargs):
+        return q
+
+    runtime.sparse_attention = Mock(wraps=execute)
+    monkeypatch.setattr(rainfusion_attn, "_mindiesd_supports_precision", lambda: True)
+    layer = make_layer(runtime, monkeypatch)
+    layer.layer_idx = rainfusion_attn._try_extract_layer_index(prefix)
+    assert layer.layer_idx == 3
+    config = SimpleNamespace(
+        diffusion_kv_cache_dtype=method,
+        diffusion_kv_cache_skip_step_indices={0, 1, 38, 39},
+        diffusion_kv_cache_skip_layer_indices={3},
+        parallel_config=SimpleNamespace(ring_degree=1),
+    )
+    impl = sparse()
+    layer.attention = impl
+    layer.attn_backend = rainfusion_attn.RainFusionAttentionBackend
+    layer._init_kv_cache_quantization(config)
+    ctx = SimpleNamespace(denoise_step_idx=0)
+    monkeypatch.setattr(layer_mod, "is_forward_context_available", lambda: True)
+    monkeypatch.setattr(layer_mod, "get_forward_context", lambda: ctx)
+    source = video_metadata(kv_cache_dtype="mxfp8")
+    q = torch.randn(1, 4096, 2, 64, dtype=torch.bfloat16)
+    for layer_idx, step in ((3, 0), (3, 2), (4, 0), (4, 1), (4, 2), (4, 37), (4, 38), (4, 39), (4, 0)):
+        expected = "bf16" if layer_idx == 3 or step in (0, 1, 38, 39) else method
+        layer.layer_idx = layer_idx
+        ctx.denoise_step_idx = step
+        metadata = layer._with_kv_cache_dtype(source)
+        impl.forward_npu(q, q, q, metadata)
+        assert runtime.sparse_attention.call_args.kwargs["precision"] == expected
+    runtime.quant_attention.assert_not_called()
+    assert source.extra["kv_cache_dtype"] == "mxfp8"
+
+
+def test_custom_attention_initialization_keeps_upstream_optout(monkeypatch):
+    monkeypatch.setattr(layer_mod, "get_current_diffusion_config_or_none", lambda: None)
+    monkeypatch.setattr(layer_mod, "build_parallel_attention_strategy", lambda **kw: object())
+    monkeypatch.setattr(layer_mod, "NoParallelAttention", lambda: object())
+    custom = torch.nn.Identity()
+    layer = layer_mod.Attention(
+        num_heads=2,
+        head_size=64,
+        softmax_scale=0.125,
+        causal=False,
+        custom_attention=custom,
+        skip_sequence_parallel=True,
+    )
+    assert layer.attention is custom and layer._kv_cache_dtype is None
+
+
+def test_legacy_global_fp8_uses_implicit_bsnd(runtime):
+    q = torch.randn(1, 17, 2, 64, dtype=torch.bfloat16)
+    impl = flash(layout=None)
+    assert impl.forward_npu(q, q, q, AttentionMetadata(extra={"kv_cache_dtype": "fp8"})) is q
+    assert runtime.quant_attention.call_args.kwargs["layout"] == "BSND"
+    assert runtime.quant_attention.call_args.kwargs["precision"] == "fp8"
diff --git a/tests/diffusion/attention/test_rainfusion_plan.py b/tests/diffusion/attention/test_rainfusion_plan.py
index 5b5fcc405..f78866c31 100644
--- a/tests/diffusion/attention/test_rainfusion_plan.py
+++ b/tests/diffusion/attention/test_rainfusion_plan.py
@@ -133,18 +133,17 @@ def test_invalid_ref2va_video_spans_fall_back_to_dense():
     assert make_impl()._resolve_plan(AttentionMetadata(extra={"max_seqlen_q": 12000}, video_layout=layout)) is None
 
 
-def test_validate_available_rejects_legacy_mindiesd(monkeypatch):
+def test_validate_available_accepts_single_video_mindiesd(monkeypatch):
     mindiesd = types.ModuleType("mindiesd")
 
     def sparse_attention(query, key, value, **kwargs):
         return query
 
-    mindiesd.sparse_attention = sparse_attention
+    monkeypatch.setattr(mindiesd, "sparse_attention", sparse_attention, raising=False)
     monkeypatch.setitem(sys.modules, "mindiesd", mindiesd)
     monkeypatch.setattr("importlib.util.find_spec", lambda _: object())
 
-    with pytest.raises(ValueError, match="video_spans"):
-        RainFusionAttentionBackend.validate_available()
+    RainFusionAttentionBackend.validate_available()
 
 
 def test_validate_available_accepts_new_mindiesd(monkeypatch):
@@ -153,13 +152,25 @@ def test_validate_available_accepts_new_mindiesd(monkeypatch):
     def sparse_attention(query, key, value, *, video_spans=None, **kwargs):
         return query
 
-    mindiesd.sparse_attention = sparse_attention
+    monkeypatch.setattr(mindiesd, "sparse_attention", sparse_attention, raising=False)
     monkeypatch.setitem(sys.modules, "mindiesd", mindiesd)
     monkeypatch.setattr("importlib.util.find_spec", lambda _: object())
 
     RainFusionAttentionBackend.validate_available()
 
 
+def test_prefix_kv_slicing_contract_is_pinned():
+    # Regression pin for the #5543 packed-padding crash: reverting the flag
+    # would pass CI while reintroducing the ValueError for non-64-aligned
+    # requests. Both halves of the contract must hold together — the impl
+    # trims [real, pad] packed tensors to the valid prefix itself (so it may
+    # advertise prefix slicing) and it never reads attn_mask (so it must keep
+    # refusing one), which is what lets the model skip materializing the
+    # padding mask that _assert_metadata_compatible would reject.
+    assert RainFusionAttentionBackend.supports_prefix_kv_slicing is True
+    assert RainFusionAttentionBackend.supports_attention_mask() is False
+
+
 @pytest.mark.parametrize("grid", [(4, 24, 40), (1, 24, 40)])
 def test_short_video_stays_dense(grid):
     assert make_impl()._resolve_plan(make_metadata(grid)) is None
@@ -300,22 +311,21 @@ def _fake_mindiesd_module():
     import types
 
     fake = types.ModuleType("mindiesd")
-    fake.sparse_attention = lambda *args, **kwargs: None
+    setattr(fake, "sparse_attention", lambda *args, **kwargs: None)
     return fake
 
 
 def test_precision_non_bf16_requires_mindiesd_support():
-    """precision != bf16 against a mindiesd lacking the kwarg must raise RuntimeError."""
+    """Unsupported sparse precision must fail before any operator executes."""
     import sys
 
     impl = make_impl(precision="mix")
-    sys.modules["mindiesd"] = _fake_mindiesd_module()
-    try:
+    with mock.patch.dict(sys.modules, {"mindiesd": _fake_mindiesd_module()}):
         with mock.patch.object(rainfusion_attn, "_mindiesd_supports_precision", return_value=False):
-            with pytest.raises(RuntimeError, match="requires MindIE-SD"):
-                impl._forward_sparse_npu(None, None, None, None)
-    finally:
-        sys.modules.pop("mindiesd", None)
+            with pytest.raises(ValueError, match="explicitly support precision"):
+                impl._forward_sparse_npu(
+                    None, None, None, RainFusionPlan(prefix_len=0, used_len=8, latent_shape=[2, 2, 2])
+                )
 
 
 def test_precision_non_bf16_passes_gate_when_supported():
@@ -323,8 +333,7 @@ def test_precision_non_bf16_passes_gate_when_supported():
     import sys
 
     impl = make_impl(precision="mix")
-    sys.modules["mindiesd"] = _fake_mindiesd_module()
-    try:
+    with mock.patch.dict(sys.modules, {"mindiesd": _fake_mindiesd_module()}):
         with mock.patch.object(rainfusion_attn, "_mindiesd_supports_precision", return_value=True):
             # q/k/v shapes: [B, S, N, D]; plan geometry must match S.
             q = torch.randn(1, 8, 4, 128)
@@ -332,5 +341,3 @@ def test_precision_non_bf16_passes_gate_when_supported():
             # The gate must pass; the fake mindiesd returns None so no crash.
             out = impl._forward_sparse_npu(q, q, q, plan)
             assert out is None
-    finally:
-        sys.modules.pop("mindiesd", None)
diff --git a/tests/diffusion/diffusion_kv/test_block_tables.py b/tests/diffusion/diffusion_kv/test_block_tables.py
index aa8e07307..dbca89735 100644
--- a/tests/diffusion/diffusion_kv/test_block_tables.py
+++ b/tests/diffusion/diffusion_kv/test_block_tables.py
@@ -325,7 +325,7 @@ def _runner(
         model_config=SimpleNamespace(max_model_len=max_len),
         scheduler_config=SimpleNamespace(
             max_num_batched_tokens=max_num_batched_tokens,
-            max_num_seqs=max_num_seqs,
+            max_num_seqs=max_num_seqs * max_rows_per_request,
         ),
         parallel_config=SimpleNamespace(
             decode_context_parallel_size=cp_size,
@@ -403,7 +403,7 @@ def test_initialize_failure_does_not_publish_partial_cache_state(
     successful_init_cache = model_runner_backend_module.init_kv_cache
     vllm_config = SimpleNamespace(
         model_config=SimpleNamespace(max_model_len=16),
-        scheduler_config=SimpleNamespace(max_num_batched_tokens=32, max_num_seqs=1),
+        scheduler_config=SimpleNamespace(max_num_batched_tokens=32, max_num_seqs=2),
         parallel_config=SimpleNamespace(
             decode_context_parallel_size=1,
             cp_kv_cache_interleave_size=1,
@@ -445,7 +445,7 @@ def test_initialize_failure_does_not_publish_partial_cache_state(
     assert backend.block_tables is None
     assert backend.paged_attention_adapter is None
     assert backend._kv_cache_layer_adapters["layer-0"].kv_cache == "placeholder-0"
-    assert backend.vllm_config.scheduler_config.max_num_seqs == 1
+    assert backend.vllm_config.scheduler_config.max_num_seqs == 2
 
     monkeypatch.setattr(model_runner_backend_module, "init_kv_cache", successful_init_cache)
     backend.initialize_kv_cache(config)
diff --git a/tests/diffusion/diffusion_kv/test_initialization.py b/tests/diffusion/diffusion_kv/test_initialization.py
index b5f914b11..b9161ba92 100644
--- a/tests/diffusion/diffusion_kv/test_initialization.py
+++ b/tests/diffusion/diffusion_kv/test_initialization.py
@@ -58,6 +58,7 @@ def _od_config(**overrides):
         gpu_memory_utilization=0.9,
         kv_cache_memory_bytes=None,
         max_num_seqs=1,
+        diffusion_kv_max_rows_per_request=1,
         max_num_batched_tokens=64,
         num_gpus=1,
     )
diff --git a/tests/diffusion/diffusion_kv/test_kv_connector.py b/tests/diffusion/diffusion_kv/test_kv_connector.py
index 19847b3d5..7528a201e 100644
--- a/tests/diffusion/diffusion_kv/test_kv_connector.py
+++ b/tests/diffusion/diffusion_kv/test_kv_connector.py
@@ -1,16 +1,23 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+from contextlib import nullcontext
+from types import SimpleNamespace
 from unittest import mock
 
 import pytest
 import torch
 from vllm.config import KVTransferConfig
+from vllm.v1.core.kv_cache_manager import KVCacheBlocks
+from vllm.v1.outputs import KVConnectorOutput
 
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.diffusion_kv.kv_connector import (
+    KVTransferRegistrationError,
+    commit_kv_load,
     parse_kv_transfer_config,
     shutdown_kv_connector,
+    wait_for_kv_load,
 )
 from vllm_omni.diffusion.sched.base_scheduler import BaseScheduler
 from vllm_omni.diffusion.vllm_config import create_diffusion_vllm_config
@@ -138,3 +145,205 @@ def test_shutdown_kv_connector_is_idempotent() -> None:
 
     assert ensure_shutdown.call_count == 2
     scheduler_connector.shutdown.assert_called_once()
+
+
+def test_commit_aligns_cfg_transport_pages_without_extending_computed_prefix() -> None:
+    requests = tuple(
+        SimpleNamespace(
+            request_id=f"req/{sequence_id}",
+            kv_transfer_params={"num_transfer_tokens": 9},
+            num_tokens=16,
+            num_computed_tokens=0,
+        )
+        for sequence_id in range(2)
+    )
+    manager = SimpleNamespace(
+        get_blocks=lambda _request_id: KVCacheBlocks(([0, 1, 2, 3],)),
+        kv_cache_config=SimpleNamespace(kv_cache_groups=[SimpleNamespace(kv_cache_spec=SimpleNamespace(block_size=4))]),
+    )
+    connector = mock.Mock()
+
+    expected = commit_kv_load(connector, manager, requests, [7, 5])
+
+    assert expected == {"req/0", "req/1"}
+    calls = connector.update_state_after_alloc.call_args_list
+    assert [len(call.args[1].blocks[0]) for call in calls] == [3, 3]
+    assert [call.args[2] for call in calls] == [7, 5]
+    assert [request.num_computed_tokens for request in requests] == [7, 5]
+
+
+def test_wait_without_pending_load_uses_vllm_post_forward_once() -> None:
+    connector = mock.Mock()
+    output = mock.Mock(invalid_block_ids=set())
+    active_connector = mock.Mock(kv_connector=connector)
+    active_connector.post_forward.return_value = output
+    scheduler_output = SimpleNamespace(
+        kv_transfer_request_ids=set(),
+        finished_req_ids={"finished"},
+        kv_finished_request_ids={"finished/diffusion-kv/0", "finished/diffusion-kv/1"},
+    )
+
+    result = wait_for_kv_load(active_connector, scheduler_output, timeout=1.0)
+
+    assert result is output
+    active_connector.pre_forward.assert_called_once_with(scheduler_output)
+    active_connector.post_forward.assert_called_once_with({"finished/diffusion-kv/0", "finished/diffusion-kv/1"})
+    connector.get_finished.assert_not_called()
+
+
+def test_timeout_returns_partial_completion_without_releasing_pages():
+    active = mock.Mock()
+    active.kv_connector.get_finished.return_value = (set(), {"cfg0"})
+    active.kv_connector.get_block_ids_with_load_errors.return_value = set()
+    active.post_forward.return_value = KVConnectorOutput()
+    scheduled = SimpleNamespace(kv_transfer_request_ids={"cfg0", "cfg1"}, kv_finished_request_ids=set())
+    output = wait_for_kv_load(active, scheduled, timeout=0)
+    assert output.finished_recving == {"cfg0"}
+    active.kv_connector.request_finished.assert_not_called()
+    active.post_forward.assert_called_once_with(set())
+
+
+@pytest.fixture
+def cfg_registration():
+    requests = tuple(
+        SimpleNamespace(
+            request_id=f"cfg{i}",
+            status=None,
+            num_tokens=8,
+            kv_transfer_params={"num_transfer_tokens": 4, "transfer_id": "ticket", "do_remote_prefill": True},
+        )
+        for i in range(2)
+    )
+    manager = SimpleNamespace(
+        get_blocks=lambda _: KVCacheBlocks(([0, 1],)),
+        kv_cache_config=SimpleNamespace(kv_cache_groups=[SimpleNamespace(kv_cache_spec=SimpleNamespace(block_size=4))]),
+    )
+    return requests, manager
+
+
+def test_cfg_validation_is_atomic_before_connector_registration(cfg_registration):
+    requests, manager = cfg_registration
+    requests[1].kv_transfer_params["num_transfer_tokens"] = 9
+    connector = mock.Mock()
+    with pytest.raises(KVTransferRegistrationError, match="boundary"):
+        commit_kv_load(connector, manager, requests, [4, 4])
+    connector.update_state_after_alloc.assert_not_called()
+
+
+@pytest.mark.parametrize("fail_init", [False, True])
+def test_sp_connector_init_snapshots_topology_and_restores_model_tp(monkeypatch, fail_init):
+    import vllm.distributed.parallel_state as parallel_state
+
+    import vllm_omni.diffusion.diffusion_kv.kv_connector as module
+    import vllm_omni.diffusion.distributed.parallel_state as omni_parallel
+
+    tp = SimpleNamespace(world_size=1, rank_in_group=0)
+    sp = SimpleNamespace(world_size=2, rank_in_group=1)
+    monkeypatch.setattr(parallel_state, "_TP", tp)
+    monkeypatch.setattr(omni_parallel, "get_sp_group", lambda: sp)
+    snapshot: dict[str, int] = {}
+
+    def initialize(*args):
+        snapshot.update(
+            rank=parallel_state.get_tensor_model_parallel_rank(),
+            size=parallel_state.get_tensor_model_parallel_world_size(),
+        )
+        if fail_init:
+            raise RuntimeError("initialization failed")
+
+    monkeypatch.setattr(module, "ensure_kv_transfer_initialized", initialize)
+    config = SimpleNamespace(
+        kv_transfer_config=SimpleNamespace(kv_connector="MooncakeConnector", engine_id="dit"),
+        parallel_config=SimpleNamespace(prefill_context_parallel_size=2),
+    )
+    with pytest.raises(RuntimeError, match="initialization failed") if fail_init else nullcontext():
+        module.init_worker_kv_connector(config, object())
+    assert parallel_state._TP is tp
+    assert snapshot == {"rank": 1, "size": 2}
+
+
+def test_partial_mooncake_registration_is_replaced_by_empty_notifications(cfg_registration):
+    from vllm.distributed.kv_transfer.kv_connector.v1.mooncake.mooncake_connector import (
+        MooncakeConnector,
+        MooncakeConnectorScheduler,
+    )
+
+    scheduler = object.__new__(MooncakeConnectorScheduler)
+    scheduler.is_kv_producer = False
+    scheduler.is_kv_consumer = True
+    scheduler._reqs_need_recv = {}
+    connector = object.__new__(MooncakeConnector)
+    connector.connector_scheduler = scheduler
+    requests, manager = cfg_registration
+    for request in requests:
+        request.kv_transfer_params.update(remote_engine_id="ar", remote_bootstrap_addr="http://localhost:8998")
+
+    def register(request, blocks, count):
+        scheduler._reqs_need_recv[request.request_id] = (request, blocks)
+        request.kv_transfer_params["do_remote_prefill"] = False
+        if request.request_id == "cfg1":
+            raise RuntimeError("partial registration")
+
+    connector.update_state_after_alloc = register
+    with pytest.raises(KVTransferRegistrationError, match="partial registration"):
+        commit_kv_load(connector, manager, requests, [4, 4])
+    assert set(scheduler._reqs_need_recv) == {"cfg0", "cfg1"}
+    assert all(blocks == [] for _, blocks in scheduler._reqs_need_recv.values())
+    metadata = scheduler.build_connector_meta(None)
+    # Even partial registration failure sends every row in one per-rank batch,
+    # preserving the producer's complete fan-out count for the shared ticket.
+    assert set(metadata.reqs_to_recv["ar"]) == {"cfg0", "cfg1"}
+    assert all(
+        meta.transfer_id == "ticket" and meta.local_block_ids == [] for meta in metadata.reqs_to_recv["ar"].values()
+    )
+
+
+@pytest.mark.parametrize("timeout", [0, -1, float("inf"), "60"])
+def test_native_transfer_timeout_must_be_positive_finite(timeout):
+    with pytest.raises(ValueError, match="transfer_timeout"):
+        parse_kv_transfer_config(
+            {
+                **KV_TRANSFER_CONFIG,
+                "kv_connector_extra_config": {"transfer_timeout": timeout},
+            }
+        )
+
+
+def test_receive_completion_requires_all_ranks_across_polls():
+    from vllm_omni.diffusion.executor.abstract import DiffusionExecutor
+    from vllm_omni.diffusion.sched.interface import CachedRequestData, DiffusionSchedulerOutput
+
+    executor = SimpleNamespace(od_config=SimpleNamespace(num_gpus=2))
+    executor.collective_rpc = mock.Mock(
+        side_effect=[
+            [KVConnectorOutput(finished_recving={"cfg0", "cfg1"}), KVConnectorOutput(finished_recving={"cfg0"})],
+            [KVConnectorOutput(), KVConnectorOutput(finished_recving={"cfg1"})],
+        ]
+    )
+    scheduled = DiffusionSchedulerOutput(
+        step_id=0,
+        scheduled_new_reqs=[],
+        scheduled_cached_reqs=CachedRequestData.make_empty(),
+        finished_req_ids=set(),
+        num_running_reqs=0,
+        num_waiting_reqs=0,
+        kv_connector_metadata=object(),
+        kv_transfer_request_ids={"cfg0", "cfg1"},
+    )
+    result = DiffusionExecutor.prepare_kv_for_forward(executor, scheduled)
+    assert result.finished_recving == {"cfg0"}
+    scheduled.kv_transfer_request_ids = set()
+    result = DiffusionExecutor.prepare_kv_for_forward(executor, scheduled)
+    assert result.finished_recving == {"cfg1"}
+    assert not executor._kv_receive_completed_ranks
+
+
+def test_native_transfer_rejects_sleep_without_changing_legacy_sleep():
+    with pytest.raises(ValueError, match="registered pages must remain mapped"):
+        OmniDiffusionConfig.from_kwargs(
+            diffusion_kv_mode="paged_scheduler",
+            diffusion_kv_max_rows_per_request=2,
+            kv_transfer_config=dict(KV_TRANSFER_CONFIG),
+            enable_sleep_mode=True,
+        )
+    assert OmniDiffusionConfig.from_kwargs(enable_sleep_mode=True).enable_sleep_mode
diff --git a/tests/diffusion/diffusion_kv/test_metadata.py b/tests/diffusion/diffusion_kv/test_metadata.py
index 07e3eeb70..da9e7b331 100644
--- a/tests/diffusion/diffusion_kv/test_metadata.py
+++ b/tests/diffusion/diffusion_kv/test_metadata.py
@@ -61,13 +61,14 @@ class _MetadataScheduler(BaseScheduler):
 
 
 def test_scheduler_copies_opaque_params_to_sequence_requests() -> None:
-    params = {"transfer_id": "xfer-req-0", "do_remote_prefill": True}
+    params = {"transfer_id": "xfer-req-0", "do_remote_prefill": True, "num_transfer_tokens": 3}
     sequence = DiffusionKVRequest(
         "req-0/diffusion-kv/0",
         sequence_id=0,
         prefix_len=4,
         target_len=2,
         seq_len=6,
+        prompt_token_ids=[10, 11, 12, 13],
     )
     request = OmniDiffusionRequest(
         prompt="prompt",
@@ -83,6 +84,9 @@ def test_scheduler_copies_opaque_params_to_sequence_requests() -> None:
 
     assert state.diffusion_kv_requests[0].kv_transfer_params == params
     assert state.diffusion_kv_requests[0].kv_transfer_params is not params
+    assert sequence.prompt_token_ids == [10, 11, 12]
+    assert sequence.num_prompt_tokens == 3
+    assert sequence.seq_len == 6
 
 
 def test_diffusion_kv_metadata_uses_native_cache_group_block_ids() -> None:
diff --git a/tests/diffusion/diffusion_kv/test_mooncake_cfg_fanout.py b/tests/diffusion/diffusion_kv/test_mooncake_cfg_fanout.py
new file mode 100644
index 000000000..d9e66ddea
--- /dev/null
+++ b/tests/diffusion/diffusion_kv/test_mooncake_cfg_fanout.py
@@ -0,0 +1,204 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Exercise upstream Mooncake completion accounting without device/network I/O."""
+
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock
+
+import msgspec
+import pytest
+from vllm.distributed.kv_transfer.kv_connector.v1.mooncake import mooncake_connector as mc
+from vllm.v1.core.sched.scheduler import Scheduler
+from vllm.v1.outputs import KVConnectorOutput
+
+from vllm_omni.diffusion.diffusion_kv.kv_connector import install_mooncake_cfg_fanout
+from vllm_omni.worker.mixins import OmniWorkerMixin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.fixture
+def producer(monkeypatch):
+    worker = object.__new__(mc.MooncakeConnectorWorker)
+    worker.shutdown = Mock()  # No hardware constructor, sockets or listener thread.
+    worker.is_kv_consumer = False
+    worker.tp_rank, worker.tp_size = 0, 1
+    worker.transfer_topo = SimpleNamespace(handshake_target_ranks=lambda size: list(range(size)))
+    worker.reqs_need_send, worker.finished_sending_reqs = {}, set()
+    for name in (
+        "kv_caches_base_addr",
+        "block_len_per_layer",
+        "kv_block_len_per_layer",
+        "registered_layer_names",
+        "registered_layer_indices",
+        "registered_group_indices",
+    ):
+        setattr(worker, name, [])
+    worker._get_transfer_regions = Mock(return_value=[])
+    worker._producer_cache_is_replicated = Mock(return_value=False)
+    worker._encoder = msgspec.msgpack.Encoder()
+    worker._sender_executor = None
+    worker._send_blocks = Mock(return_value=0)
+    worker.xfer_stats = Mock()
+    worker._build_transfer_params = AsyncMock(return_value=([1], [2], [16], [], None))
+    monkeypatch.setattr(mc, "_align_transfer_regions", lambda *_: ([], [], None))
+    monkeypatch.setattr(mc, "_validate_asymmetric_region_lengths", lambda **_: None)
+    monkeypatch.setattr(mc.envs, "VLLM_MOONCAKE_ABORT_REQUEST_TIMEOUT", 0.05)
+    connector = object.__new__(mc.MooncakeConnector)
+    connector.connector_worker = worker
+    return connector
+
+
+async def register(worker, ticket):
+    worker.sender_loop = asyncio.get_running_loop()
+    for blocks in ([], [[10]]):
+        meta = mc.MooncakeConnectorMetadata()
+        meta.add_new_req(ticket, blocks, {"transfer_id": ticket}, load_remote_cache=False)
+        await worker.record_send_reqs(meta)
+    return worker.reqs_need_send[ticket]
+
+
+def packet(rank, ranks, tickets, empty=False):
+    return mc.MooncakeXferMetadata(
+        remote_hostname="localhost",
+        remote_port=1234 + rank,
+        remote_tp_size=ranks,
+        remote_tp_rank=rank,
+        req_blocks={
+            f"{ticket}/{row}": (ticket, [] if empty else [[100 + rank * 10 + row]])
+            for ticket, rows in tickets.items()
+            for row in range(rows)
+        },
+        kv_caches_base_addr=[],
+        block_lens=[],
+        kv_block_lens=[],
+    )
+
+
+async def send(worker, rank, ranks, tickets, empty=False):
+    sock = SimpleNamespace(send_multipart=AsyncMock())
+    await worker.send_kv_to_decode(str(rank).encode(), sock, packet(rank, ranks, tickets, empty))
+    return [
+        msgspec.msgpack.decode(c.args[0][1], type=mc.MooncakeXferResponse) for c in sock.send_multipart.call_args_list
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("rows", [1, 2])
+@pytest.mark.parametrize("ranks", [2, 4])
+@pytest.mark.parametrize("in_flight", [False, True])
+async def test_source_pages_wait_for_every_rank_and_row(producer, rows, ranks, in_flight):
+    worker = producer.connector_worker
+    entered, release = asyncio.Event(), asyncio.Event()
+    original = worker._build_transfer_params
+
+    async def plan(ready, meta, *regions):
+        if in_flight and meta.remote_tp_rank == ranks - 1:
+            entered.set()
+            await release.wait()
+        return await original(ready, meta, *regions)
+
+    worker._build_transfer_params = plan
+    install_mooncake_cfg_fanout(producer)
+    adapted = worker._build_transfer_params
+    install_mooncake_cfg_fanout(producer)
+    assert worker._build_transfer_params is adapted  # Do not multiply twice.
+    ticket = await register(worker, "request")
+    pending = asyncio.create_task(send(worker, ranks - 1, ranks, {"request": rows})) if in_flight else None
+    try:
+        if pending is not None:
+            await asyncio.wait_for(entered.wait(), 2)
+        for rank in range(ranks - 1):
+            await send(worker, rank, ranks, {"request": rows})
+            assert ticket.need_send == ranks * rows
+            assert ticket.sent == (rank + 1) * rows
+            assert worker.reqs_need_send["request"] is ticket
+            finished = await worker.fetch_finished_sending_reqs()
+            scheduler = SimpleNamespace(connector=None, requests={"request": object()}, _free_blocks=Mock())
+            Scheduler._update_from_kv_xfer_finished(scheduler, KVConnectorOutput(finished_sending=finished))
+            scheduler._free_blocks.assert_not_called()
+        release.set()
+        responses = (
+            await asyncio.wait_for(pending, 2) if pending else await send(worker, ranks - 1, ranks, {"request": rows})
+        )
+        assert sum(len(response.ok_reqs or []) for response in responses) == rows
+        assert all(not response.err_reqs for response in responses)
+        assert "request" not in worker.reqs_need_send
+        finished = await worker.fetch_finished_sending_reqs()
+        assert finished == {"request"}
+        Scheduler._update_from_kv_xfer_finished(scheduler, KVConnectorOutput(finished_sending=finished))
+        scheduler._free_blocks.assert_called_once()
+        assert not await worker.fetch_finished_sending_reqs()
+    finally:
+        release.set()
+        if pending is not None:
+            await asyncio.gather(pending, return_exceptions=True)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("empty", [False, True])
+@pytest.mark.parametrize("ranks", [1, 2])
+async def test_mixed_tickets_and_empty_block_notifications(producer, empty, ranks):
+    worker = producer.connector_worker
+    if empty:
+        worker._build_transfer_params.return_value = ([], [], [], [], None)
+    install_mooncake_cfg_fanout(producer)
+    single, cfg = await register(worker, "single"), await register(worker, "cfg")
+    await asyncio.gather(*(send(worker, rank, ranks, {"single": 1, "cfg": 2}, empty) for rank in range(ranks)))
+    assert (single.need_send, single.sent) == (ranks, ranks)
+    assert (cfg.need_send, cfg.sent) == (2 * ranks, 2 * ranks)
+    assert await worker.fetch_finished_sending_reqs() == {"single", "cfg"}
+    assert not worker.reqs_need_send
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("failure", ["row_count", "transport"])
+async def test_failed_rank_does_not_report_source_complete(producer, failure):
+    worker = producer.connector_worker
+    install_mooncake_cfg_fanout(producer)
+    ticket = await register(worker, "request")
+    await send(worker, 0, 2, {"request": 2})
+    if failure == "transport":
+        worker._send_blocks.return_value = -1
+    responses = await send(worker, 1, 2, {"request": 1 if failure == "row_count" else 2})
+    assert any(response.err_reqs for response in responses)
+    assert ticket.sent == 2 and ticket.need_send == 4 and ticket.sending == 0
+    assert worker.reqs_need_send["request"] is ticket
+    assert not await worker.fetch_finished_sending_reqs()
+    # Preserve upstream timeout cleanup after all in-flight writes have stopped.
+    ticket.expire_time = 0
+    assert await worker.fetch_finished_sending_reqs() == {"request"}
+    assert not worker.reqs_need_send
+
+
+def test_worker_installs_adapter_after_native_initialization(producer, monkeypatch):
+    import vllm.distributed.kv_transfer as kv_transfer
+
+    worker = producer.connector_worker
+    original = worker._build_transfer_params
+
+    class UpstreamWorker:
+        def initialize_from_config(self, config):
+            assert config == "config"
+            assert worker._build_transfer_params is original
+
+    class OmniWorker(OmniWorkerMixin, UpstreamWorker):
+        pass
+
+    monkeypatch.setattr(kv_transfer, "has_kv_transfer_group", lambda: True)
+    monkeypatch.setattr(kv_transfer, "get_kv_transfer_group", lambda: producer)
+    object.__new__(OmniWorker).initialize_from_config("config")
+    assert worker._build_transfer_params is not original
+
+
+@pytest.mark.parametrize("role", ["other_connector", "scheduler", "consumer"])
+def test_adapter_leaves_other_roles_untouched(producer, role):
+    worker = producer.connector_worker
+    original = worker._build_transfer_params
+    if role == "scheduler":
+        producer.connector_worker = None
+    elif role == "consumer":
+        worker.is_kv_consumer = True
+    install_mooncake_cfg_fanout(object() if role == "other_connector" else producer)
+    assert worker._build_transfer_params is original
diff --git a/tests/diffusion/diffusion_kv/test_paged_attention_adapter.py b/tests/diffusion/diffusion_kv/test_paged_attention_adapter.py
index 535c1b411..271f55ee8 100644
--- a/tests/diffusion/diffusion_kv/test_paged_attention_adapter.py
+++ b/tests/diffusion/diffusion_kv/test_paged_attention_adapter.py
@@ -94,7 +94,7 @@ class _FakeAttentionGroup:
         return self.builder
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(slots=True)
 class _FakeNativeMetadata:
     build_id: int
     causal: bool
@@ -102,6 +102,7 @@ class _FakeNativeMetadata:
     query_start_loc_cpu: torch.Tensor
     positions: torch.Tensor
     slot_mappings: torch.Tensor
+    max_num_splits: int = 0
 
 
 class _FakeLayer:
@@ -288,6 +289,8 @@ def test_omni_paged_backend_consumes_context_and_restores_diffusion_shape(
     assert output.shape == query.shape
     assert torch.equal(output, query)
     assert layer.calls[0][0].shape == (5, 2, 4)
+    assert layer.calls[0][1] is None
+    assert layer.calls[0][2] is None
     assert layer.native_events == ["update", "forward"]
     assert layer.calls[0][3] is events[0][2]
 
@@ -440,9 +443,7 @@ def test_platform_prewrite_updates_once_then_piecewise_reads_cache(monkeypatch:
 
 def test_omni_paged_backend_runs_hunyuan_piecewise_segments(monkeypatch: pytest.MonkeyPatch) -> None:
     adapter, _, layer, events = _make_adapter(monkeypatch)
-    # Exercise the Ascend-only homogeneous batch path. CUDA keeps its native
-    # output-buffer contract and is covered by the GPU adapter tests.
-    monkeypatch.setattr(adapter_module.current_omni_platform, "is_npu", lambda: True)
+    layer.impl.vllm_flash_attn_version = 2
     batch = adapter.prepare_batch(
         [
             DiffusionPagedAttentionRow(
@@ -499,10 +500,10 @@ def test_omni_paged_backend_runs_hunyuan_piecewise_segments(monkeypatch: pytest.
     assert torch.equal(layer.updates[0][0], key.reshape(12, 2, 4))
     assert torch.equal(layer.updates[0][1], value.reshape(12, 2, 4))
     assert [call[0].shape[0] for call in layer.calls] == [4, 6, 2]
-    assert [call[1].shape[0] for call in layer.calls] == [4, 6, 2]
-    assert [call[2].shape[0] for call in layer.calls] == [4, 6, 2]
+    assert all(call[1] is None and call[2] is None for call in layer.calls)
     assert all(call[3] is event[2] for call, event in zip(layer.calls, events[1:], strict=True))
     assert [metadata.build_id for metadata in context.piecewise_native_metadata] == [1, 2, 3]
+    assert [metadata.max_num_splits for metadata in context.piecewise_native_metadata] == [1, 1, 1]
 
     # The first metadata build is the normal whole-query path. Piecewise calls
     # then use causal [3, 5), full [5, 8), and causal [8, 9) segments.
@@ -539,6 +540,51 @@ def test_omni_paged_backend_runs_hunyuan_piecewise_segments(monkeypatch: pytest.
     ]
 
 
+def test_homogeneous_piecewise_packs_strided_query_only_per_segment(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    adapter, _, _, _ = _make_adapter(monkeypatch)
+    batch = adapter.prepare_batch(
+        [
+            DiffusionPagedAttentionRow(
+                request_id="req-0",
+                sequence_id=0,
+                query_len=6,
+                seq_len=9,
+                kv_start_pos=3,
+            ),
+            DiffusionPagedAttentionRow(
+                request_id="req-1",
+                sequence_id=1,
+                query_len=6,
+                seq_len=9,
+                kv_start_pos=3,
+            ),
+        ]
+    )
+    packed_qkv = torch.randn(2, 6, 3, 2, 4)
+    query, key, value = packed_qkv.unbind(dim=2)
+    assert not query.is_contiguous()
+    metadata = SimpleNamespace(
+        attn_mask=None,
+        full_attn_spans=[[(5, 8)], [(5, 8)]],
+        query_ranges=None,
+        extra={},
+    )
+
+    with adapter.activate(batch):
+        context = adapter.prepare_layer_context(
+            "layer-0",
+            query,
+            key,
+            value,
+            omni_attn_metadata=metadata,
+        )
+
+    assert not context.query.is_contiguous()
+    assert context.query.data_ptr() == query.data_ptr()
+
+
 def test_piecewise_metadata_snapshots_reused_native_scheduler_buffer(monkeypatch: pytest.MonkeyPatch) -> None:
     adapter, _, _, _ = _make_adapter(monkeypatch)
     shared_scheduler_metadata = torch.zeros(1, dtype=torch.int32)
@@ -1232,7 +1278,7 @@ def test_layer_adapter_accepts_platform_native_backend_and_uses_rank_local_heads
         ulysses_degree=2,
     )
 
-    assert selected_backends == [(adapter_module.AttentionBackendEnum.FLASH_ATTN, {}, 2)]
+    assert selected_backends == [(adapter_module.AttentionBackendEnum.FLASH_ATTN, {}, 1)]
     assert specialized_backends == [(native_backend, 2)]
     assert config.attention_config.backend is None
     assert config.attention_config.backend_per_kind is original_backend_per_kind
diff --git a/tests/diffusion/diffusion_kv/test_paged_attention_adapter_gpu.py b/tests/diffusion/diffusion_kv/test_paged_attention_adapter_gpu.py
index d890dcc7b..285fb2c96 100644
--- a/tests/diffusion/diffusion_kv/test_paged_attention_adapter_gpu.py
+++ b/tests/diffusion/diffusion_kv/test_paged_attention_adapter_gpu.py
@@ -43,8 +43,7 @@ class _SmokeDiffusionAttention(nn.Module):
         self.softmax_scale = _HEAD_SIZE**-0.5
 
 
-@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required for native paged attention")
-def test_adapter_executes_native_paged_attention_on_non_contiguous_blocks() -> None:
+def _native_adapter(num_rows: int = 1):
     device = torch.device("cuda", torch.accelerator.current_device_index())
     vllm_config = VllmConfig(
         cache_config=CacheConfig(
@@ -89,8 +88,8 @@ def test_adapter_executes_native_paged_attention_on_non_contiguous_blocks() -> N
 
     canonical_spec = native_layer.spec
     kv_cache_config = KVCacheConfig(
-        num_blocks=4,
-        kv_cache_tensors=[build_kv_cache_tensor(canonical_spec, 4, [_LAYER_NAME])],
+        num_blocks=4 * num_rows,
+        kv_cache_tensors=[build_kv_cache_tensor(canonical_spec, 4 * num_rows, [_LAYER_NAME])],
         kv_cache_groups=[
             KVCacheGroupSpec(
                 layer_names=[_LAYER_NAME],
@@ -120,14 +119,15 @@ def test_adapter_executes_native_paged_attention_on_non_contiguous_blocks() -> N
         )
         block_tables = BlockTables(
             block_sizes=[_BLOCK_SIZE],
-            max_num_reqs=1,
-            max_num_batched_tokens=32,
+            max_num_reqs=num_rows,
+            max_num_batched_tokens=32 * num_rows,
             max_num_blocks_per_group=[2],
             device=device,
             kernel_block_sizes=kernel_block_sizes,
         )
 
-    block_tables.append_block_ids(0, ([3, 1],), overwrite=True)
+    for row in range(num_rows):
+        block_tables.append_block_ids(row, ([4 * row + 3, 4 * row + 1],), overwrite=True)
     block_tables.apply_staged_writes()
     adapter = DiffusionPagedAttentionAdapter(
         vllm_config=vllm_config,
@@ -136,11 +136,17 @@ def test_adapter_executes_native_paged_attention_on_non_contiguous_blocks() -> N
         block_tables=block_tables,
         attn_groups=attn_groups,
         layers={_LAYER_NAME: native_layer},
-        resolve_row=lambda _request_id, _sequence_id, _context_id: DiffusionPagedAttentionRowBinding(
-            row_index=0,
+        resolve_row=lambda _request_id, sequence_id, _context_id: DiffusionPagedAttentionRowBinding(
+            row_index=sequence_id,
             max_seq_len=19,
         ),
     )
+    return adapter, diffusion_layer, device
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required for native paged attention")
+def test_adapter_executes_native_paged_attention_on_non_contiguous_blocks() -> None:
+    adapter, diffusion_layer, device = _native_adapter()
     prefix_batch = adapter.prepare_batch(
         [
             DiffusionPagedAttentionRow(
@@ -258,3 +264,48 @@ def test_adapter_executes_native_paged_attention_on_non_contiguous_blocks() -> N
     torch.testing.assert_close(prefix_output, prefix_reference, rtol=2e-2, atol=2e-2)
     torch.testing.assert_close(suffix_output, suffix_reference, rtol=2e-2, atol=2e-2)
     torch.testing.assert_close(piecewise_output, piecewise_reference, rtol=2e-2, atol=2e-2)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required for native paged attention")
+def test_hunyuan_homogeneous_cfg_paged_attention_graph_replay() -> None:
+    """Real paged kernels, strided QKV, mixed image spans and changed replay inputs."""
+    adapter, layer, device = _native_adapter(num_rows=2)
+    packed = torch.randn(2, 19, 3, _NUM_HEADS, _HEAD_SIZE, device=device, dtype=torch.float16)
+    query, key, value = packed.unbind(dim=2)
+    backend = FlashAttentionImpl(
+        num_heads=_NUM_HEADS, head_size=_HEAD_SIZE, softmax_scale=layer.softmax_scale, num_kv_heads=_NUM_HEADS
+    )
+    batch = adapter.prepare_batch(
+        [DiffusionPagedAttentionRow(request_id="cfg", sequence_id=i, query_len=19, seq_len=19) for i in range(2)]
+    )
+    metadata = AttentionMetadata(full_attn_spans=[[(5, 10)], [(5, 10)]])
+    with adapter.activate(batch):
+        context = adapter.prepare_layer_context(_LAYER_NAME, query, key, value, omni_attn_metadata=metadata)
+    assert context.piecewise_plan.homogeneous_batch_shape == (2, 19)
+    warmup = torch.cuda.Stream()
+    warmup.wait_stream(torch.cuda.current_stream())
+    with torch.cuda.stream(warmup):
+        for _ in range(3):
+            backend.forward_paged(context)
+    torch.cuda.current_stream().wait_stream(warmup)
+    graph = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(graph):
+        captured = backend.forward_paged(context)
+    output_ptr = captured.data_ptr()
+    mask = torch.ones(19, 19, device=device, dtype=torch.bool).tril()
+    mask[5:10, 5:10] = True
+    for _ in range(2):
+        packed.copy_(torch.randn_like(packed))
+        graph.replay()
+        actual = captured.clone()
+        eager = backend.forward_paged(context)
+        reference = F.scaled_dot_product_attention(
+            query.transpose(1, 2),
+            key.transpose(1, 2),
+            value.transpose(1, 2),
+            attn_mask=mask,
+            scale=layer.softmax_scale,
+        ).transpose(1, 2)
+        torch.testing.assert_close(actual.reshape_as(reference), reference, rtol=2e-2, atol=2e-2)
+        torch.testing.assert_close(actual, eager, rtol=2e-2, atol=2e-2)
+        assert captured.data_ptr() == output_ptr
diff --git a/tests/diffusion/diffusion_kv/test_spec_discovery.py b/tests/diffusion/diffusion_kv/test_spec_discovery.py
index 1ccef7a9f..f3db266a3 100644
--- a/tests/diffusion/diffusion_kv/test_spec_discovery.py
+++ b/tests/diffusion/diffusion_kv/test_spec_discovery.py
@@ -176,10 +176,11 @@ def test_worker_honors_explicit_kv_memory_budget(monkeypatch) -> None:
     profile_request = object()
 
     assert worker.determine_available_kv_memory(profile_request) == [4096]
-    worker.model_runner.profile_run.assert_called_once_with(profile_request)
+    worker.model_runner.profile_run.assert_not_called()
 
 
 def test_worker_treats_zero_kv_memory_budget_as_profiled_auto_sizing(monkeypatch) -> None:
+    monkeypatch.setattr(diffusion_worker_module, "current_omni_platform", SimpleNamespace(empty_cache=Mock()))
     worker = object.__new__(DiffusionWorker)
     worker.rank = 0
     worker.init_snapshot = SimpleNamespace(free_memory=900)
@@ -209,6 +210,7 @@ def test_worker_treats_zero_kv_memory_budget_as_profiled_auto_sizing(monkeypatch
 
 @pytest.mark.parametrize("non_kv_cache_memory", [750, 800])
 def test_worker_rejects_non_positive_profiled_kv_memory(monkeypatch, non_kv_cache_memory: int) -> None:
+    monkeypatch.setattr(diffusion_worker_module, "current_omni_platform", SimpleNamespace(empty_cache=Mock()))
     worker = object.__new__(DiffusionWorker)
     worker.rank = 0
     worker.init_snapshot = SimpleNamespace(free_memory=900)
@@ -245,6 +247,7 @@ def test_worker_rejects_non_positive_profiled_kv_memory(monkeypatch, non_kv_cach
 
 
 def test_worker_profiles_activation_headroom_instead_of_current_residency(monkeypatch) -> None:
+    monkeypatch.setattr(diffusion_worker_module, "current_omni_platform", SimpleNamespace(empty_cache=Mock()))
     worker = object.__new__(DiffusionWorker)
     worker.rank = 0
     worker.init_snapshot = SimpleNamespace(free_memory=1200)
@@ -310,3 +313,31 @@ def test_rank_probe_gathers_local_failure_before_raising(monkeypatch) -> None:
         )
 
     assert gathered == [(False, "ValueError: local failure")]
+
+
+def test_hunyuan_native_layer_identity_matches_ar_spec(monkeypatch):
+    import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_image3_transformer as hy3
+
+    monkeypatch.setattr(hy3, "get_tensor_model_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(hy3, "get_sequence_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(hy3, "get_allgather_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(hy3, "get_sequence_parallel_rank", lambda: 0)
+    monkeypatch.setattr(hy3, "QKVParallelLinear", lambda **_: nn.Identity())
+    monkeypatch.setattr(hy3, "RowParallelLinear", lambda **_: nn.Identity())
+    monkeypatch.setattr(hy3, "get_rope", lambda **_: nn.Identity())
+
+    # Only backend construction is fake; execute both HY3 constructors and the
+    # real runner spec-discovery path, including the actual Attention prefix.
+    def attention(**kwargs):
+        return _attention(enabled=kwargs.get("paged_kv_cache_role") is not None, prefix=kwargs["prefix"])
+
+    monkeypatch.setattr(hy3, "Attention", attention)
+    model = hy3.HunYuanAttention(
+        config=SimpleNamespace(num_key_value_heads=2, attention_head_dim=8),
+        hidden_size=16,
+        num_heads=2,
+        num_kv_heads=2,
+        prefix="layers.3.self_attn",
+    )
+    runner = _runner(model.image_attn.attn)
+    assert set(runner.get_kv_cache_spec()) == {"model.layers.3.self_attn.attn"}
diff --git a/tests/diffusion/distributed/test_comm.py b/tests/diffusion/distributed/test_comm.py
index effe2b541..21cb18821 100644
--- a/tests/diffusion/distributed/test_comm.py
+++ b/tests/diffusion/distributed/test_comm.py
@@ -461,3 +461,46 @@ def test_ring_p2p_parity(world_size: int, dtype: torch.dtype):
         device_kind="cuda",
         master_port=29501,
     )
+
+
+def _run_fused_qkv_matches_three_4d(
+    local_rank: int,
+    world_size: int,
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    """LingBot's fused (B, S/N, 3, H, D) exchange must equal three per-tensor 4D exchanges."""
+    from vllm_omni.diffusion.distributed.comm import all_to_all_5D
+
+    device = _worker_device(local_rank, device_kind)
+    if device_kind == "cuda":
+        current_omni_platform.set_device(device)
+    _init_worker(local_rank, world_size, master_port, device_kind)
+    initialize_model_parallel(ulysses_degree=world_size)
+    sp_group = get_sp_group().ulysses_group
+    try:
+        batch, seq_per_rank, heads, head_size = 1, 6, 4 * world_size, 8
+        # Distinguishable values: rank, q/k/v index, position, head, feature.
+        base = torch.arange(seq_per_rank * heads * head_size, dtype=torch.float32, device=device).reshape(
+            batch, seq_per_rank, heads, head_size
+        )
+        tensors = [base + 1000.0 * local_rank + 100000.0 * which for which in range(3)]
+        separate = [SeqAllToAll4D.apply(sp_group, t, 2, 1, False) for t in tensors]
+        fused = all_to_all_5D(torch.stack(tensors, dim=2), scatter_idx=3, gather_idx=1, group=sp_group)
+        assert fused.shape == (batch, seq_per_rank * world_size, 3, heads // world_size, head_size)
+        for which, expected in enumerate(separate):
+            assert torch.equal(fused.unbind(2)[which], expected), f"q/k/v index {which} differs on rank {local_rank}"
+    finally:
+        destroy_distributed_env()
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize("world_size", [2, 4])
+def test_fused_qkv_all_to_all_matches_three_4d_exchanges_cpu(world_size: int) -> None:
+    torch.multiprocessing.spawn(
+        _run_fused_qkv_matches_three_4d,
+        args=(world_size, "cpu", 29613),
+        nprocs=world_size,
+    )
diff --git a/tests/diffusion/distributed/test_parallel_state_sp_groups.py b/tests/diffusion/distributed/test_parallel_state_sp_groups.py
index c12882a22..0febb1925 100644
--- a/tests/diffusion/distributed/test_parallel_state_sp_groups.py
+++ b/tests/diffusion/distributed/test_parallel_state_sp_groups.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Unit tests for SP subgroup construction in parallel_state.py."""
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for SP subgroup construction for diffusion parallel state."""
 
 from __future__ import annotations
 
@@ -8,12 +8,55 @@ from types import SimpleNamespace
 
 import pytest
 import torch
+import vllm.distributed.parallel_state as vllm_parallel_state
 
+from tests.helpers.runtime import get_distributed_init_method
+from vllm_omni.diffusion.distributed import parallel_state as omni_parallel_state
 from vllm_omni.diffusion.distributed.parallel_state import RankGenerator, set_seq_parallel_pg
 
 pytestmark = [pytest.mark.diffusion, pytest.mark.parallel, pytest.mark.core_model, pytest.mark.cpu]
 
 
+def ensure_parallel_state_initialized():
+    """Ensure torch distributed is initialized and that all world / count vars are set."""
+    assert torch.distributed.is_initialized()
+    assert omni_parallel_state._WORLD is not None
+    assert vllm_parallel_state._WORLD is not None
+    assert vllm_parallel_state._NODE_COUNT is not None
+
+
+def ensure_parallel_state_not_initialized():
+    """Ensure torch distributed is not initialized and that all world / count vars are unset."""
+    assert not torch.distributed.is_initialized()
+    assert omni_parallel_state._WORLD is None
+    assert vllm_parallel_state._WORLD is None
+    assert vllm_parallel_state._NODE_COUNT is None
+
+
+def test_omni_manages_vllm_distributed_state(monkeypatch):
+    """Verify Omni initializes and tears down vLLM's distributed state properly.
+
+    This is a regression test for ensuring vLLM Omni also sets up vLLM's vars correctly
+    to avoid potential misalignment in cases where Omni uses vLLM's native coordinator,
+    e.g., MoE + diffusion.
+    """
+    ensure_parallel_state_not_initialized()
+    monkeypatch.setattr(omni_parallel_state.current_omni_platform, "get_device_count", lambda: 1)
+    monkeypatch.setattr(omni_parallel_state.current_omni_platform, "set_device", lambda _device: None)
+    omni_parallel_state.init_distributed_environment(
+        world_size=1,
+        rank=0,
+        local_rank=0,
+        distributed_init_method=get_distributed_init_method(),
+        backend="gloo",
+    )
+    try:
+        ensure_parallel_state_initialized()
+    finally:
+        omni_parallel_state.destroy_distributed_env()
+    ensure_parallel_state_not_initialized()
+
+
 def _fake_new_group_factory(created_groups: list[SimpleNamespace]):
     def _fake_new_group(ranks, *args, **kwargs):
         group = SimpleNamespace(ranks=list(ranks))
diff --git a/tests/diffusion/distributed/test_wan_spatial_shard.py b/tests/diffusion/distributed/test_wan_spatial_shard.py
index d8842ee3f..23c29c938 100644
--- a/tests/diffusion/distributed/test_wan_spatial_shard.py
+++ b/tests/diffusion/distributed/test_wan_spatial_shard.py
@@ -356,6 +356,94 @@ def test_attention_wrapper_rejects_spatial_extent_change(monkeypatch: pytest.Mon
         wan_spatial_shard._SPATIAL_SHARD_CONTEXT.reset(token)
 
 
+def _reference_conv_input(conv, x, cache_x):
+    """The conv input the previous implementation built: cat, F.pad, then halo_exchange."""
+    padding = list(conv._padding)
+    if cache_x is not None and padding[4] > 0:
+        x = torch.cat([cache_x, x], dim=2)
+        padding[4] -= cache_x.shape[2]
+    x = torch.nn.functional.pad(x, padding)
+    x_padded, _, _ = wan_spatial_shard.halo_exchange(
+        x, group=object(), halo_size=conv.halo_size, split_dim=conv.split_dim
+    )
+    return x_padded, x.shape[conv.split_tensor_dim]
+
+
+def _dist_conv(split_dim, kernel=(3, 3, 3), padding=(1, 1, 1)):
+    from diffusers.models.autoencoders.autoencoder_kl_wan import WanCausalConv3d
+
+    torch.manual_seed(0)
+    source = WanCausalConv3d(3, 4, kernel, padding=padding)
+    return source, wan_spatial_shard.WanDistCausalConv3d(source, object(), split_dim=split_dim)
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize("split_dim", ["width", "height"])
+@pytest.mark.parametrize("with_cache", [False, True])
+def test_single_pass_conv_input_matches_cat_pad_halo_on_one_rank(monkeypatch, split_dim, with_cache):
+    """One rank, halo-bearing kernel: same bytes as the previous cat -> F.pad -> halo_exchange path."""
+    monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 1))
+    _, conv = _dist_conv(split_dim)
+    x = torch.randn(1, 3, 2, 6, 8)
+    cache_x = torch.randn(1, 3, 2, 6, 8) if with_cache else None
+
+    expected, expected_extent = _reference_conv_input(conv, x, cache_x)
+    got, got_extent = conv._assemble_input(x, cache_x)
+
+    assert got.shape == expected.shape and got_extent == expected_extent
+    assert torch.equal(got, expected)
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_single_pass_conv_rejects_cache_longer_than_causal_padding():
+    _, conv = _dist_conv("width")
+    with pytest.raises(AssertionError, match="temporal cache exceeds"):
+        conv._assemble_input(torch.randn(1, 3, 2, 6, 8), torch.randn(1, 3, 3, 6, 8))
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize("split_dim", ["width", "height"])
+def test_single_pass_conv_without_a_halo_matches_the_stock_causal_conv(monkeypatch, split_dim):
+    """A kernel with no spatial extent along the split (the temporal conv) needs no halo and equals the stock conv."""
+    monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 1))
+    source, conv = _dist_conv(split_dim, kernel=(3, 1, 1), padding=(1, 0, 0))
+    x = torch.randn(1, 3, 2, 6, 8)
+    cache_x = torch.randn(1, 3, 2, 6, 8)
+
+    assert torch.equal(conv(x, cache_x), source(x, cache_x))
+    assert torch.equal(conv(x, None), source(x, None))
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize("split_dim", ["width", "height"])
+@pytest.mark.parametrize("rank", [0, 1])
+@pytest.mark.parametrize("kernel,padding", [((3, 3, 3), (1, 1, 1)), ((3, 1, 1), (0, 0, 0))])
+def test_single_pass_conv_input_matches_cat_pad_halo_on_two_ranks(monkeypatch, split_dim, rank, kernel, padding):
+    """Same bytes as cat -> F.pad -> halo_exchange, halos included, on either rank of a pair."""
+    monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (rank, 2))
+
+    def fake_p2p(*, rank, world_size, group, top_row_ref, bottom_row_ref, recv_top_buf, recv_bottom_buf):
+        # A neighbour's halo is whatever it sent; stand in with a marker derived from our own edge so
+        # both the reference and the single-pass path see the same exchange. Global edges stay zero.
+        recv_top_buf.copy_(top_row_ref * 0 + 7.0) if rank > 0 else recv_top_buf.zero_()
+        recv_bottom_buf.copy_(bottom_row_ref * 0 + 9.0) if rank < world_size - 1 else recv_bottom_buf.zero_()
+
+    monkeypatch.setattr(wan_spatial_shard, "_halo_exchange_p2p", fake_p2p)
+    _, conv = _dist_conv(split_dim, kernel=kernel, padding=padding)
+    x = torch.randn(1, 3, 1, 6, 8)
+    cache_x = torch.randn(1, 3, 2, 6, 8)
+
+    expected, expected_extent = _reference_conv_input(conv, x, cache_x)
+    got, got_extent = conv._assemble_input(x, cache_x)
+
+    assert got.shape == expected.shape and got_extent == expected_extent
+    assert torch.equal(got, expected)
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_halo_exchange_single_rank_noop(monkeypatch: pytest.MonkeyPatch):
diff --git a/tests/diffusion/kernels/mot/test_mot_linear.py b/tests/diffusion/kernels/mot/test_mot_linear.py
index 49622aecd..26c78aace 100644
--- a/tests/diffusion/kernels/mot/test_mot_linear.py
+++ b/tests/diffusion/kernels/mot/test_mot_linear.py
@@ -41,13 +41,13 @@ from vllm_omni.diffusion.distributed.parallel_state import (
     initialize_model_parallel,
     model_parallel_is_initialized,
 )
-from vllm_omni.diffusion.layers.mot.mot_qkv_parallel_linear import (
+from vllm_omni.diffusion.models.bagel.mot.mot_qkv_parallel_linear import (
     MoTQKVParallelLinear,
 )
-from vllm_omni.diffusion.layers.mot.mot_row_parallel_linear import (
+from vllm_omni.diffusion.models.bagel.mot.mot_row_parallel_linear import (
     MoTRowParallelLinear,
 )
-from vllm_omni.diffusion.layers.mot.ops.mot_gemm import (
+from vllm_omni.diffusion.models.bagel.mot.ops.mot_gemm import (
     get_best_mot_config,
 )
 
diff --git a/tests/diffusion/kernels/mot/test_mot_norm.py b/tests/diffusion/kernels/mot/test_mot_norm.py
index 1153f6112..5c9f1f62a 100644
--- a/tests/diffusion/kernels/mot/test_mot_norm.py
+++ b/tests/diffusion/kernels/mot/test_mot_norm.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # ruff: noqa: N803, E741
 """Layer-level correctness & performance test for MoTRMSNorm.
 
@@ -20,7 +23,7 @@ import torch
 from vllm import ir
 from vllm.config import VllmConfig, set_current_vllm_config
 
-from vllm_omni.diffusion.layers.mot.mot_layernorm import MoTRMSNorm
+from vllm_omni.diffusion.models.bagel.mot.mot_layernorm import MoTRMSNorm
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.gpu]
 
diff --git a/tests/diffusion/kernels/mot/test_mot_norm_npu.py b/tests/diffusion/kernels/mot/test_mot_norm_npu.py
index 928afc9fc..07774efa3 100644
--- a/tests/diffusion/kernels/mot/test_mot_norm_npu.py
+++ b/tests/diffusion/kernels/mot/test_mot_norm_npu.py
@@ -1,8 +1,11 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import pytest
 import torch
 
 import vllm_omni.diffusion.layers.custom_op as custom_op
-from vllm_omni.diffusion.layers.mot.mot_layernorm import MoTRMSNorm
+from vllm_omni.diffusion.models.bagel.mot.mot_layernorm import MoTRMSNorm
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
diff --git a/tests/diffusion/layers/test_custom_op.py b/tests/diffusion/layers/test_custom_op.py
index 9b4913730..724a8b87c 100644
--- a/tests/diffusion/layers/test_custom_op.py
+++ b/tests/diffusion/layers/test_custom_op.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for the CustomOp platform-dispatch base class."""
 
 import pytest
@@ -39,7 +39,7 @@ def test_forward_cuda_still_requires_an_implementation():
 
 def test_mot_rmsnorm_dispatches_on_xpu_without_an_override():
     """MoTRMSNorm relies on the inherited fallback (regression test)."""
-    from vllm_omni.diffusion.layers.mot.mot_layernorm import MoTRMSNorm
+    from vllm_omni.diffusion.models.bagel.mot.mot_layernorm import MoTRMSNorm
 
     assert "forward_xpu" not in MoTRMSNorm.__dict__
 
diff --git a/tests/diffusion/layers/test_fused_qk_norm_rope.py b/tests/diffusion/layers/test_fused_qk_norm_rope.py
index 84edce0dc..4f1ad82b4 100644
--- a/tests/diffusion/layers/test_fused_qk_norm_rope.py
+++ b/tests/diffusion/layers/test_fused_qk_norm_rope.py
@@ -173,3 +173,20 @@ def test_fused_qk_norm_rope_min_tokens_resolution(monkeypatch):
         monkeypatch.setenv(env, bad)
         with pytest.raises(ValueError, match=env):
             fused_qk_norm_rope_min_tokens(2048)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available() or not HAS_TRITON, reason="CUDA and Triton required")
+@pytest.mark.parametrize("interleaved", [False, True])
+def test_fused_qk_norm_rope_large_storage_offsets(interleaved):
+    """Only three tokens, but the last row lies beyond signed 32-bit indexing."""
+    from vllm_omni.diffusion.layers.fused_qk_norm_rope import fused_qk_norm_rope
+
+    # 4 GiB of backing storage; initialize only the three small visible rows.
+    q = torch.empty_strided((3, 1, 128), (2**30, 128, 1), device="cuda", dtype=torch.bfloat16)
+    q.fill_(1)
+    weight = torch.ones(128, device="cuda", dtype=torch.bfloat16)
+    table = torch.zeros(3, 96, device="cuda", dtype=torch.bfloat16)
+    table[:, :48] = 1
+    actual = fused_qk_norm_rope(q, q, weight, weight, table, _EPS, interleaved=interleaved)
+    for value in actual:
+        torch.testing.assert_close(value, torch.ones_like(value))
diff --git a/tests/diffusion/layers/test_fused_qk_rope.py b/tests/diffusion/layers/test_fused_qk_rope.py
new file mode 100644
index 000000000..c37075ba6
--- /dev/null
+++ b/tests/diffusion/layers/test_fused_qk_rope.py
@@ -0,0 +1,125 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+import torch
+from diffusers.models.embeddings import apply_rotary_emb
+from vllm.triton_utils import HAS_TRITON
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
+
+def test_fused_qk_rope_fake_and_cpu_eligibility():
+    from vllm_omni.diffusion.layers.fused_qk_rope import (
+        _fused_qk_rope_fake,
+        fused_qk_rope,
+        fused_qk_rope_supported,
+    )
+
+    q = torch.randn(2, 3, 4, 8, dtype=torch.bfloat16)
+    k = torch.randn_like(q)
+    cos = torch.randn(3, 8)
+    sin = torch.randn_like(cos)
+
+    fake_q, fake_k = _fused_qk_rope_fake(q, k, cos, sin)
+    assert fake_q.shape == q.shape and fake_q.dtype == q.dtype
+    assert fake_k.shape == k.shape and fake_k.dtype == k.dtype
+    assert not fused_qk_rope_supported(q, k, cos, sin)
+    with pytest.raises(ValueError, match="contiguous CUDA BF16"):
+        fused_qk_rope(q, k, cos, sin)
+
+
+def _cuda_inputs(batch: int, sequence: int, heads: int = 24, head_dim: int = 128):
+    q = torch.randn(batch, sequence, heads, head_dim, device="cuda", dtype=torch.bfloat16)
+    k = torch.randn_like(q)
+    # Deliberately do not repeat adjacent table columns.  Diffusers consumes
+    # full-width tables, so even and odd outputs may use different values.
+    cos = torch.randn(sequence, head_dim, device="cuda", dtype=torch.float32)
+    sin = torch.randn_like(cos)
+    return q, k, cos, sin
+
+
+def _reference(q, k, cos, sin):
+    rotary_emb = (cos, sin)
+    return (
+        apply_rotary_emb(q, rotary_emb, sequence_dim=1),
+        apply_rotary_emb(k, rotary_emb, sequence_dim=1),
+    )
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+@pytest.mark.parametrize("sequence", [512, 4096, 4608])
+def test_fused_qk_rope_is_bit_exact_at_longcat_production_shapes(sequence):
+    from vllm_omni.diffusion.layers.fused_qk_rope import _launch_fused_qk_rope, fused_qk_rope
+
+    torch.manual_seed(sequence)
+    with torch.inference_mode():
+        q, k, cos, sin = _cuda_inputs(1, sequence)
+        expected = _reference(q, k, cos, sin)
+        for actual in (
+            _launch_fused_qk_rope(q, k, cos, sin),
+            fused_qk_rope(q, k, cos, sin),
+        ):
+            assert torch.equal(actual[0], expected[0])
+            assert torch.equal(actual[1], expected[1])
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_fused_qk_rope_is_bit_exact_for_batch_and_full_width_odd_even_tables():
+    from vllm_omni.diffusion.layers.fused_qk_rope import fused_qk_rope
+
+    torch.manual_seed(11)
+    with torch.inference_mode():
+        q, k, cos, sin = _cuda_inputs(2, 17, heads=3)
+        assert not torch.equal(cos[:, ::2], cos[:, 1::2])
+        assert not torch.equal(sin[:, ::2], sin[:, 1::2])
+        expected = _reference(q, k, cos, sin)
+        actual = fused_qk_rope(q, k, cos, sin)
+
+    assert torch.equal(actual[0], expected[0])
+    assert torch.equal(actual[1], expected[1])
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_fused_qk_rope_rejects_noncontiguous_and_non_fp32_tables():
+    from vllm_omni.diffusion.layers.fused_qk_rope import fused_qk_rope_supported
+
+    q, k, cos, sin = _cuda_inputs(1, 8, heads=2)
+    q_noncontiguous = torch.randn(1, 8, 2, 256, device="cuda", dtype=torch.bfloat16)[..., ::2]
+    k_noncontiguous = torch.randn_like(q_noncontiguous)
+    cos_noncontiguous = torch.randn(8, 256, device="cuda")[:, ::2]
+    sin_noncontiguous = torch.randn(8, 256, device="cuda")[:, ::2]
+    with torch.inference_mode():
+        assert fused_qk_rope_supported(q, k, cos, sin)
+        assert not fused_qk_rope_supported(q_noncontiguous, k_noncontiguous, cos, sin)
+        assert not fused_qk_rope_supported(q, k, cos_noncontiguous, sin_noncontiguous)
+        assert not fused_qk_rope_supported(q, k, cos.to(torch.bfloat16), sin.to(torch.bfloat16))
+
+        q_wide = torch.randn(1, 8, 2, 256, device="cuda", dtype=torch.bfloat16)
+        k_wide = torch.randn_like(q_wide)
+        cos_wide = torch.randn(8, 256, device="cuda")
+        sin_wide = torch.randn_like(cos_wide)
+        assert not fused_qk_rope_supported(q_wide, k_wide, cos_wide, sin_wide)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_fused_qk_rope_custom_op_has_fullgraph_fake():
+    from vllm_omni.diffusion.layers.fused_qk_rope import fused_qk_rope
+
+    torch.manual_seed(29)
+    with torch.inference_mode():
+        q, k, cos, sin = _cuda_inputs(1, 19, heads=3)
+        expected = _reference(q, k, cos, sin)
+        compiled = torch.compile(fused_qk_rope, dynamic=True, fullgraph=True)
+        actual = compiled(q, k, cos, sin)
+
+    assert torch.equal(actual[0], expected[0])
+    assert torch.equal(actual[1], expected[1])
diff --git a/tests/diffusion/lora/test_loader.py b/tests/diffusion/lora/test_loader.py
index 4fd876937..a10d609d8 100644
--- a/tests/diffusion/lora/test_loader.py
+++ b/tests/diffusion/lora/test_loader.py
@@ -18,6 +18,7 @@ from vllm_omni.diffusion.lora.loader import (
     WanLoraLoaderMixin,
     _prepare_lora_delta,
     _remap_state_dict_keys,
+    _resolve_lora_compute_device,
 )
 
 HEAD_DIM = 24
@@ -521,3 +522,81 @@ def test_prepare_lora_delta_with_compute_device():
     assert delta is not None
     assert delta.shape == (HEAD_DIM, HEAD_DIM)
     assert len(used_keys) == 2
+
+
+def test_resolve_lora_compute_device_probes_unusable_accelerator(mocker: MockerFixture):
+    """cuda:N/npu:N may be reported without a physical device; the probe must reject it."""
+    mocker.patch(
+        "vllm_omni.diffusion.lora.loader.get_local_device",
+        return_value=torch.device("cuda:999"),
+    )
+    assert _resolve_lora_compute_device() is None
+
+
+def test_load_lora_into_module_cpu_weights_match_cpu_reference(mocker: MockerFixture):
+    """Regression test: params on CPU used to force compute_device=None and skip the
+    #7005 accelerator path. With an unusable accelerator, fusion must fall back to
+    CPU and still produce base + lora_B @ lora_A."""
+    pipeline = DummyPipeline(NUM_LAYERS, HEAD_DIM)
+    original_params = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+
+    lora_state_dict = make_lora_state_dict_for_module(pipeline.transformer)
+    lora_state_dict = _remap_state_dict_keys(lora_state_dict, [(".to_out.0.", ".to_out.")])
+
+    mocker.patch(
+        "vllm_omni.diffusion.lora.loader.get_local_device",
+        return_value=torch.device("cuda:999"),
+    )
+
+    used_keys = pipeline.load_lora_into_module(lora_state_dict, pipeline.transformer)
+    assert len(used_keys) > 0
+    assert not (set(lora_state_dict.keys()) - used_keys)
+
+    for name, param in pipeline.transformer.named_parameters():
+        if not name.endswith(".weight"):
+            continue
+        base_key = name[: -len(".weight")]
+        key_a = f"{base_key}.lora_A.weight"
+        key_b = f"{base_key}.lora_B.weight"
+        if key_a in lora_state_dict and key_b in lora_state_dict:
+            expected = original_params[name] + (
+                lora_state_dict[key_b].to(param.dtype) @ lora_state_dict[key_a].to(param.dtype)
+            )
+            assert_close(param, expected)
+
+
+def test_load_lora_into_module_forwards_usable_accel_device(mocker: MockerFixture):
+    """A usable accelerator must be forwarded as compute_device for CPU params.
+    A spy forces the actual math back onto CPU so the test runs without a device."""
+    fake_dev = torch.device("cuda:0")
+    mocker.patch(
+        "vllm_omni.diffusion.lora.loader._resolve_lora_compute_device",
+        return_value=fake_dev,
+    )
+
+    seen_devices = []
+    original = _prepare_lora_delta
+
+    def spy(state_dict, base_key, *args, **kwargs):
+        seen_devices.append(kwargs.get("compute_device"))
+        kwargs["compute_device"] = None
+        return original(state_dict, base_key, *args, **kwargs)
+
+    mocker.patch(
+        "vllm_omni.diffusion.lora.loader._prepare_lora_delta",
+        side_effect=spy,
+    )
+
+    pipeline = DummyPipeline(NUM_LAYERS, HEAD_DIM)
+    original_params = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+
+    lora_state_dict = make_lora_state_dict_for_module(pipeline.transformer)
+    lora_state_dict = _remap_state_dict_keys(lora_state_dict, [(".to_out.0.", ".to_out.")])
+
+    used_keys = pipeline.load_lora_into_module(lora_state_dict, pipeline.transformer)
+
+    # Every CPU param with a LoRA delta must have received the accelerator device.
+    assert seen_devices
+    assert all(d == fake_dev for d in seen_devices)
+    assert not (set(lora_state_dict.keys()) - used_keys)
+    assert_params_not_equal(pipeline.transformer, original_params)
diff --git a/tests/diffusion/model_loader/test_diffusers_loader.py b/tests/diffusion/model_loader/test_diffusers_loader.py
index c7a87ac34..8a2ee0900 100644
--- a/tests/diffusion/model_loader/test_diffusers_loader.py
+++ b/tests/diffusion/model_loader/test_diffusers_loader.py
@@ -1241,6 +1241,169 @@ def test_dlo_allgather_rejects_unvalidated_online_quant_method(monkeypatch):
         loader.load_model(load_device="cpu")
 
 
+def test_dlo_allgather_allows_unquantized_host_fallback():
+    """Host-loaded unquantized fallback layers are plain contiguous bf16 —
+    the same runtime layout DLO already shards on the ordinary path — so the
+    allowlist must not reject them."""
+    from vllm_omni.quantization.int8_config import UnquantizedHostLinearMethod
+
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2, bias=False)
+    model.transformer.quant_method = object.__new__(UnquantizedHostLinearMethod)
+
+    assert DiffusersPipelineLoader._unsupported_dlo_allgather_online_quant_methods(model) == ()
+
+
+def test_dlo_load_model_keeps_host_fallback_on_cpu_through_post_load_sweep(monkeypatch, mocker):
+    """Through load_model(): DLO + online quant must build the model inside
+    load_unquantizable_fallback_on_cpu(), and the over-wide fallback weight
+    must survive the post-load sweep (the _process_weights_after_loading pass
+    plus model.to("cpu")) as the same host tensor it was loaded into — never
+    bounced to the accelerator."""
+    import vllm_omni.diffusion.model_loader.diffusers_loader as loader_mod
+    from vllm_omni.quantization import int8_config
+    from vllm_omni.quantization.int8_config import (
+        NPU_QUANT_MATMUL_MAX_OUT_FEATURES,
+        DiffusionInt8Config,
+        NPUInt8OnlineLinearMethod,
+        UnquantizedHostLinearMethod,
+    )
+
+    # Same stand-in as TestHostFallbackLoading: the eager fallback delegates to
+    # UnquantizedLinearMethod, which reads the TP group.
+    mock_group = mocker.Mock()
+    mock_group.rank_in_group = 0
+    mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_world_size", return_value=1)
+    mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_rank", return_value=0)
+    mocker.patch("vllm.distributed.parallel_state.get_tp_group", return_value=mock_group)
+
+    od_config = _make_dlo_online_quant_config()
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+
+    out_features = NPU_QUANT_MATMUL_MAX_OUT_FEATURES + 1
+    built_with_ctx: list[bool] = []
+
+    def copy_loader(param, loaded_weight, *args, **kwargs):
+        param.data.copy_(loaded_weight)
+
+    def build_model(*_args, **_kwargs):
+        built_with_ctx.append(int8_config._LOAD_UNQUANTIZABLE_FALLBACK_ON_CPU.get())
+        quant_config = DiffusionInt8Config(is_checkpoint_int8_serialized=False, activation_scheme="dynamic")
+        method = NPUInt8OnlineLinearMethod(quant_config)
+        layer = nn.Module()
+        layer.quant_method = method
+        method.create_weights(
+            layer,
+            input_size_per_partition=8,
+            output_partition_sizes=[out_features],
+            input_size=8,
+            output_size=out_features,
+            params_dtype=torch.bfloat16,
+            weight_loader=copy_loader,
+        )
+        model = nn.Module()
+        model.transformer = layer
+        return model
+
+    def load_weights(_model, **_kwargs):
+        layer = _model.transformer
+        loaded = torch.arange(out_features * 8, dtype=torch.float32).reshape(out_features, 8).to(torch.bfloat16)
+        layer.weight.weight_loader(layer.weight, loaded)
+
+    loader._init_from_load_format = build_model  # type: ignore[method-assign]
+    loader.load_weights = load_weights  # type: ignore[method-assign]
+    loader._apply_skip_softmax_calibration = lambda _model: None  # type: ignore[method-assign]
+    monkeypatch.setattr(
+        loader_mod,
+        "build_checkpoint_mmap_plan",
+        lambda *_args, **_kwargs: HostWeightPlanResult(
+            None,
+            "online quantization requires the ordinary loader",
+        ),
+    )
+    # Diffusion DiT models have no vLLM Attention layers, so the upstream
+    # layerwise finalize is a no-op here; stub it to keep the real
+    # _process_weights_after_loading sweep CPU-only.
+    monkeypatch.setattr(
+        "vllm.model_executor.model_loader.reload.layerwise.finalize_layerwise_processing",
+        lambda *_args, **_kwargs: None,
+    )
+
+    model = loader.load_model(load_device="cpu", device=torch.device("cpu"))
+
+    # Construction ran inside load_unquantizable_fallback_on_cpu(), so the
+    # over-wide layer took the host-loading fallback...
+    assert built_with_ctx == [True]
+    assert type(model.transformer.quant_method) is UnquantizedHostLinearMethod
+    # ...and the real post-load sweep skipped it via the fully-loaded flag and
+    # model.to("cpu") left the loaded host tensor untouched.
+    assert model.transformer._already_called_process_weights_after_loading
+    assert model.transformer.weight.device.type == "cpu"
+    expected = torch.arange(out_features * 8, dtype=torch.float32).reshape(out_features, 8).to(torch.bfloat16)
+    assert torch.equal(model.transformer.weight, expected)
+
+
+@pytest.mark.parametrize(("offload_after_quant", "ctx_expected"), [(True, True), (False, False)])
+def test_hsdp_enters_host_fallback_context_only_when_offloading_after_quant(mocker, offload_after_quant, ctx_expected):
+    """The HSDP path must apply the same host-fallback bound as the ordinary
+    path: with a quant config it initializes on the accelerator, so the
+    load_unquantizable_fallback_on_cpu() context is what keeps over-wide
+    fallback weights off the device before sharding."""
+    import vllm_omni.diffusion.model_loader.diffusers_loader as loader_mod
+    from vllm_omni.diffusion.offloader.module_collector import PipelineModules
+    from vllm_omni.quantization import int8_config
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(
+            use_hsdp=True,
+            hsdp_replicate_size=1,
+            hsdp_shard_size=2,
+        ),
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    loader.quant_config = object()
+
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2, bias=False)
+    ctx_seen: list[bool] = []
+
+    def build_model(*_args, **_kwargs):
+        ctx_seen.append(int8_config._LOAD_UNQUANTIZABLE_FALLBACK_ON_CPU.get())
+        return model
+
+    loader._init_from_load_format = build_model  # type: ignore[method-assign]
+    loader.load_weights = lambda _model: None  # type: ignore[method-assign]
+    loader._process_weights_after_loading = lambda *_args: None  # type: ignore[method-assign]
+    mocker.patch.object(
+        loader_mod.ModuleDiscovery,
+        "discover",
+        return_value=PipelineModules(
+            dits=[model.transformer],
+            dit_names=["transformer"],
+            vaes=[],
+            encoders=[],
+            encoder_names=[],
+            resident_modules=[],
+            resident_names=[],
+        ),
+    )
+    mocker.patch(
+        "vllm_omni.diffusion.quantization.hsdp_fp8.prepare_fp8_layers_for_fsdp",
+        side_effect=lambda _model: None,
+    )
+    mocker.patch.object(
+        loader_mod,
+        "apply_hsdp_to_model",
+        side_effect=lambda *_args, **_kwargs: None,
+    )
+
+    loader._load_model_with_hsdp(torch.device("cpu"), offload_after_quant=offload_after_quant)
+
+    assert ctx_seen == [ctx_expected]
+
+
 def test_dlo_allgather_online_mxfp8_uses_ordinary_loader(monkeypatch):
     mxfp8_config = pytest.importorskip("vllm_omni.quantization.mxfp8_config")
     NPUMxfp8OnlineLinearMethod = mxfp8_config.NPUMxfp8OnlineLinearMethod
diff --git a/tests/diffusion/models/anima/__init__.py b/tests/diffusion/models/anima/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/tests/diffusion/models/anima/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
diff --git a/tests/diffusion/models/anima/test_anima.py b/tests/diffusion/models/anima/test_anima.py
new file mode 100644
index 000000000..124171c93
--- /dev/null
+++ b/tests/diffusion/models/anima/test_anima.py
@@ -0,0 +1,454 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import json
+from pathlib import Path
+from shutil import rmtree
+from types import SimpleNamespace
+
+import pytest
+import torch
+from safetensors.torch import save_file
+
+from tests.model_tests.diffusion.anima_builder import CHECKPOINT_FILENAME, tiny_anima_builder
+from vllm_omni.diffusion.attention import selector
+from vllm_omni.diffusion.attention.backends.sdpa import SDPABackend
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_qwenimage import DistributedAutoencoderKLQwenImage
+from vllm_omni.diffusion.models.anima import pipeline_anima
+from vllm_omni.diffusion.models.anima.anima_text_conditioner import AnimaTextConditioner
+from vllm_omni.diffusion.models.anima.anima_transformer import AnimaTransformer3DModel
+from vllm_omni.diffusion.models.anima.pipeline_anima import AnimaPipeline
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.mark.parametrize(
+    "offload_args",
+    [
+        {"enable_cpu_offload": True},
+        {"enable_layerwise_offload": True},
+        {"enable_distributed_layerwise_offload": True},
+        {"diffusion_offload_config": {"mode": "module", "components": ["dit"]}},
+        {
+            "diffusion_offload_config": {
+                "mode": "layer",
+                "components": ["dit"],
+                "layer_options": {"dit": {"weight_transfer": "rank-local"}},
+            }
+        },
+    ],
+)
+def test_native_anima_rejects_offload(offload_args):
+    config = OmniDiffusionConfig(model="anima.safetensors", **offload_args)
+    with pytest.raises(NotImplementedError, match="offload"):
+        AnimaPipeline(od_config=config, device=torch.device("cpu"))
+
+
+def test_native_anima_initializes_without_offload():
+    config = OmniDiffusionConfig(model="anima.safetensors")
+    AnimaPipeline(od_config=config, device=torch.device("cpu"))
+
+
+def test_anima_registration() -> None:
+    """The native Anima pipeline is registered and importable."""
+    from vllm_omni.diffusion.registry import DiffusionModelRegistry
+
+    assert DiffusionModelRegistry._try_load_model_cls("AnimaPipeline") is not None
+
+
+@pytest.mark.parametrize("model_class_name", ["AnimaPipeline", "AnimaModularPipeline"])
+def test_enrich_config_native_anima_checkpoint(tmp_path: Path, model_class_name: str) -> None:
+    """Native and reference Anima class names resolve to AnimaPipeline."""
+    dummy_checkpoint = tmp_path / "model.safetensors"
+    dummy_checkpoint.write_text("dummy")
+
+    config = OmniDiffusionConfig(
+        model=str(dummy_checkpoint),
+        model_class_name=model_class_name,
+    )
+    config.enrich_config()
+
+    assert config.diffusion_load_format == "default"
+    assert config.model_class_name == "AnimaPipeline"
+    assert config.diffusers_pipeline_cls is None
+
+
+def test_native_anima_component_paths_use_custom_pipeline_args() -> None:
+    """Anima resolves shared and component-specific paths from native args."""
+    pipeline = AnimaPipeline.__new__(AnimaPipeline)
+    pipeline.od_config = SimpleNamespace(
+        custom_pipeline_args={
+            "components_path": "/tmp/anima-components",
+            "vae_path": "/tmp/anima-vae",
+            "text_encoder_model": "/tmp/anima-text-encoder",
+        }
+    )
+
+    assert pipeline._component_path("vae", "/tmp/default") == "/tmp/anima-vae"
+    assert pipeline._component_path("text_encoder", "/tmp/default") == "/tmp/anima-text-encoder"
+    assert pipeline._component_path("tokenizer", "/tmp/default") == "/tmp/default"
+
+
+def test_native_anima_converts_original_cosmos_transformer_keys() -> None:
+    """Original Cosmos checkpoint names map to native module names."""
+    converted = AnimaPipeline._convert_original_transformer_state_dict(
+        {
+            "net.x_embedder.proj.1.weight": "patch",
+            "net.blocks.0.self_attn.q_proj.weight": "q",
+            "net.blocks.0.self_attn.q_norm.weight": "q_norm",
+            "net.blocks.0.mlp.layer1.weight": "mlp",
+            "net.final_layer.linear.weight": "out",
+            "net.accum_iteration": "drop",
+        }
+    )
+
+    assert converted == {
+        "patch_embed.proj.weight": "patch",
+        "transformer_blocks.0.attn1.to_q.weight": "q",
+        "transformer_blocks.0.attn1.norm_q.weight": "q_norm",
+        "transformer_blocks.0.ff.net.0.proj.weight": "mlp",
+        "proj_out.weight": "out",
+    }
+
+
+def test_native_anima_resolves_vae_scale_factor_from_loaded_vae() -> None:
+    """The loaded VAE determines the spatial scale factor."""
+    from vllm_omni.diffusion.models.anima.pipeline_anima import _anima_vae_scale_factor_from_vae
+
+    vae = SimpleNamespace(config=SimpleNamespace(spatial_compression_ratio=16))
+
+    assert _anima_vae_scale_factor_from_vae(vae) == 16
+
+
+@pytest.mark.parametrize("use_config_file", [False, True])
+def test_native_anima_loads_synthetic_checkpoint(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, use_config_file: bool
+) -> None:
+    """Native modules load exact weights from an Anima safetensors checkpoint."""
+    tiny_transformer_config = {
+        "in_channels": 1,
+        "out_channels": 1,
+        "num_attention_heads": 1,
+        "attention_head_dim": 12,
+        "num_layers": 1,
+        "mlp_ratio": 1.0,
+        "text_embed_dim": 4,
+        "adaln_lora_dim": 3,
+        "max_size": (1, 2, 2),
+        "patch_size": (1, 1, 1),
+        "rope_scale": (1.0, 1.0, 1.0),
+        "concat_padding_mask": True,
+        "extra_pos_embed_type": None,
+    }
+    tiny_text_conditioner_config = {
+        "source_dim": 4,
+        "target_dim": 4,
+        "model_dim": 4,
+        "num_layers": 1,
+        "num_attention_heads": 1,
+        "target_vocab_size": 8,
+        "min_sequence_length": 4,
+    }
+    if use_config_file:
+        (tmp_path / "anima.json").write_text(
+            json.dumps({"transformer": tiny_transformer_config, "text_conditioner": tiny_text_conditioner_config})
+        )
+    else:
+        monkeypatch.setattr(pipeline_anima, "ANIMA_TRANSFORMER_CONFIG", tiny_transformer_config)
+        monkeypatch.setattr(pipeline_anima, "ANIMA_TEXT_CONDITIONER_CONFIG", tiny_text_conditioner_config)
+
+    monkeypatch.setattr(selector, "_cached_get_backend_cls", lambda *_args, **_kwargs: SDPABackend)
+    transformer = AnimaTransformer3DModel(**tiny_transformer_config)
+    text_conditioner = AnimaTextConditioner(**tiny_text_conditioner_config)
+    transformer_state = {name: tensor.detach().clone() for name, tensor in transformer.state_dict().items()}
+    text_conditioner_state = {name: tensor.detach().clone() for name, tensor in text_conditioner.state_dict().items()}
+    checkpoint_state = {
+        **{f"transformer.{name}": tensor for name, tensor in transformer_state.items()},
+        **{f"text_conditioner.{name}": tensor for name, tensor in text_conditioner_state.items()},
+    }
+
+    checkpoint_path = tmp_path / "anima.safetensors"
+    save_file(checkpoint_state, str(checkpoint_path))
+
+    pipeline = AnimaPipeline.__new__(AnimaPipeline)
+    pipeline.od_config = SimpleNamespace(model=str(checkpoint_path), dtype=torch.float32)
+    pipeline.device = torch.device("cpu")
+
+    def assert_loaded(loaded_transformer, loaded_text_conditioner):
+        for name, tensor in transformer_state.items():
+            assert torch.equal(loaded_transformer.state_dict()[name], tensor)
+        for name, tensor in text_conditioner_state.items():
+            assert torch.equal(loaded_text_conditioner.state_dict()[name], tensor)
+
+    loaded_transformer, loaded_text_conditioner = pipeline._load_native_denoiser_components(dict(checkpoint_state))
+    assert_loaded(loaded_transformer, loaded_text_conditioner)
+
+    loaded_transformer, loaded_text_conditioner = pipeline._load_native_denoiser_components()
+    assert_loaded(loaded_transformer, loaded_text_conditioner)
+
+    if use_config_file:
+        tiny_transformer_config["num_layers"] = 2
+        (tmp_path / "anima.json").write_text(
+            json.dumps({"transformer": tiny_transformer_config, "text_conditioner": tiny_text_conditioner_config})
+        )
+        with pytest.raises(RuntimeError, match="Missing key"):
+            pipeline._load_native_denoiser_components()
+
+
+def test_tiny_anima_generates_images(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Load every saved component and exercise CFG, decoding, and multiple outputs on CPU."""
+    monkeypatch.setattr(selector, "_cached_get_backend_cls", lambda *_args, **_kwargs: SDPABackend)
+    monkeypatch.setattr(current_omni_platform, "is_available", lambda: False)
+    monkeypatch.setattr(
+        DistributedAutoencoderKLQwenImage,
+        "init_distributed",
+        lambda self: setattr(self, "distributed_executor", SimpleNamespace(parallel_size=1)),
+    )
+    model_dir = tiny_anima_builder()
+    try:
+        config = OmniDiffusionConfig(
+            model=str(Path(model_dir) / CHECKPOINT_FILENAME), model_class_name="AnimaPipeline", dtype=torch.float32
+        )
+        pipeline = AnimaPipeline(od_config=config, device=torch.device("cpu"))
+        pipeline.load_weights()
+        pipeline.eval()
+        outputs = []
+        with torch.inference_mode():
+            for _ in range(2):
+                request = OmniDiffusionRequest(
+                    prompt="Dummy prompt",
+                    request_id="tiny-anima",
+                    sampling_params=OmniDiffusionSamplingParams(
+                        height=32,
+                        width=32,
+                        num_inference_steps=2,
+                        guidance_scale=4.0,
+                        num_outputs_per_prompt=2,
+                        generator=torch.Generator(device="cpu").manual_seed(42),
+                    ),
+                )
+                outputs.append(pipeline(DiffusionRequestBatch([request]))[0].output)
+        assert outputs[0].shape == (2, 3, 32, 32)
+        assert torch.isfinite(outputs[0]).all()
+        assert torch.equal(outputs[0], outputs[1])
+        assert not torch.equal(outputs[0][0], outputs[0][1])
+    finally:
+        rmtree(model_dir)
+
+
+def test_native_anima_profiler_setup_is_deferred_and_idempotent(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Profiler targets are wrapped once, after deferred components are loaded."""
+    pipeline = AnimaPipeline.__new__(AnimaPipeline)
+    pipeline.od_config = SimpleNamespace(enable_diffusion_pipeline_profiler=True)
+    pipeline._profiler_initialized = False
+    pipeline.vae = SimpleNamespace(decode=lambda: "decoded")
+    pipeline.text_encoder = SimpleNamespace(forward=lambda: "encoded")
+
+    monkeypatch.setattr(current_omni_platform, "is_available", lambda: False)
+    pipeline._setup_profiler()
+    wrapped_decode = pipeline.vae.decode
+    wrapped_text_encoder = pipeline.text_encoder.forward
+    pipeline._setup_profiler()
+
+    assert pipeline.vae.decode is wrapped_decode
+    assert pipeline.text_encoder.forward is wrapped_text_encoder
+    assert pipeline.vae.decode() == "decoded"
+    assert pipeline.text_encoder.forward() == "encoded"
+    assert "AnimaPipeline.vae.decode" in pipeline.stage_durations
+    assert "AnimaPipeline.text_encoder.forward" in pipeline.stage_durations
+
+
+def _make_anima_forward_probe():
+    pipeline = AnimaPipeline.__new__(AnimaPipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.vae_scale_factor = 8
+    pipeline.transformer = SimpleNamespace(dtype=torch.float32)
+    pipeline.text_encoder = SimpleNamespace(dtype=torch.float32)
+    pipeline._current_timestep = None
+    pipeline._num_timesteps = 0
+    pipeline._guidance_scale = 0.0
+    captured = {}
+
+    def encode_prompt(**_kwargs):
+        return {
+            "qwen_prompt_embeds": torch.zeros(1, 2, 4),
+            "qwen_attention_mask": torch.ones(1, 2),
+            "t5_input_ids": torch.ones(1, 2, dtype=torch.long),
+            "t5_attention_mask": torch.ones(1, 2),
+            "negative_qwen_prompt_embeds": torch.zeros(1, 2, 4),
+            "negative_qwen_attention_mask": torch.ones(1, 2),
+            "negative_t5_input_ids": torch.ones(1, 2, dtype=torch.long),
+            "negative_t5_attention_mask": torch.ones(1, 2),
+        }
+
+    def condition_prompt_embeds(**_kwargs):
+        return torch.zeros(1, 2, 4)
+
+    def prepare_latents(**kwargs):
+        captured["prepare_latents"] = kwargs
+        return torch.zeros(1, 16, 1, kwargs["height"] // 8, kwargs["width"] // 8)
+
+    def diffuse(**kwargs):
+        captured["diffuse"] = kwargs
+        return kwargs["latents"]
+
+    pipeline.encode_prompt = encode_prompt
+    pipeline.condition_prompt_embeds = condition_prompt_embeds
+    pipeline.prepare_latents = prepare_latents
+    pipeline.prepare_timesteps = lambda **_kwargs: (torch.ones(1), 1)
+    pipeline.diffuse = diffuse
+
+    def decode_latents(latents, output_type="pil"):
+        captured["output_type"] = output_type
+        return DiffusionOutput(output=latents)
+
+    pipeline.decode_latents = decode_latents
+    return pipeline, captured
+
+
+def test_native_anima_forward_uses_official_default_resolution() -> None:
+    """Forward uses Anima's reference resolution when none is requested."""
+    pipeline, captured = _make_anima_forward_probe()
+    req = OmniDiffusionRequest(
+        prompt="a red cube",
+        sampling_params=OmniDiffusionSamplingParams(),
+        request_id="anima-defaults",
+    )
+
+    pipeline.forward(DiffusionRequestBatch([req]))
+
+    assert captured["prepare_latents"]["height"] == 1024
+    assert captured["prepare_latents"]["width"] == 1024
+
+
+def test_native_anima_forward_honors_sampling_output_type() -> None:
+    """Request-level output type controls Anima decoding."""
+    pipeline, captured = _make_anima_forward_probe()
+    req = OmniDiffusionRequest(
+        prompt="a red cube",
+        sampling_params=OmniDiffusionSamplingParams(output_type="latent"),
+        request_id="anima-output-type",
+    )
+
+    outputs = pipeline.forward(DiffusionRequestBatch([req]))
+
+    assert len(outputs) == 1
+    assert isinstance(outputs[0], DiffusionOutput)
+    assert outputs[0].output.shape == (1, 16, 1, 128, 128)
+    assert captured["output_type"] == "latent"
+
+
+@pytest.mark.parametrize("request_count", [0, 2])
+def test_native_anima_forward_rejects_non_single_request_batches(request_count: int) -> None:
+    pipeline, captured = _make_anima_forward_probe()
+    requests = [
+        OmniDiffusionRequest(
+            prompt="a red cube",
+            sampling_params=OmniDiffusionSamplingParams(),
+            request_id=f"anima-{index}",
+        )
+        for index in range(request_count)
+    ]
+
+    with pytest.raises(ValueError, match="supports one request per forward"):
+        pipeline.forward(DiffusionRequestBatch(requests))
+
+    assert captured == {}
+
+
+def test_native_anima_explicit_guidance_scale_drives_cfg_multiplier() -> None:
+    """An explicit guidance scale controls native classifier-free guidance."""
+    pipeline, captured = _make_anima_forward_probe()
+    req = OmniDiffusionRequest(
+        prompt="a red cube",
+        sampling_params=OmniDiffusionSamplingParams(guidance_scale=5.0),
+        request_id="anima-guidance",
+    )
+
+    pipeline.forward(DiffusionRequestBatch([req]))
+
+    assert captured["diffuse"]["do_true_cfg"] is True
+    assert captured["diffuse"]["true_cfg_scale"] == 5.0
+
+
+def test_native_anima_true_cfg_scale_overrides_guidance_multiplier() -> None:
+    """An explicit true-CFG scale overrides the guidance-scale multiplier."""
+    pipeline, captured = _make_anima_forward_probe()
+    req = OmniDiffusionRequest(
+        prompt="a red cube",
+        sampling_params=OmniDiffusionSamplingParams(guidance_scale=5.0, true_cfg_scale=3.0),
+        request_id="anima-true-cfg",
+    )
+
+    pipeline.forward(DiffusionRequestBatch([req]))
+
+    assert captured["diffuse"]["do_true_cfg"] is True
+    assert captured["diffuse"]["true_cfg_scale"] == 3.0
+
+
+def test_native_anima_cfg_equation() -> None:
+    """The denoising loop applies the standard true-CFG equation."""
+    pipeline = AnimaPipeline.__new__(AnimaPipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline._interrupt = False
+
+    class MockProgressBar:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            pass
+
+        def update(self):
+            pass
+
+    pipeline.progress_bar = lambda **_kwargs: MockProgressBar()
+
+    class MockTransformer:
+        dtype = torch.float32
+
+        def __call__(self, hidden_states, timestep, encoder_hidden_states, padding_mask, return_dict=False):
+            # Return double the encoder_hidden_states to simulate transformer output
+            return (encoder_hidden_states * 2.0,)
+
+    pipeline.transformer = MockTransformer()
+
+    class MockScheduler:
+        def set_begin_index(self, index):
+            pass
+
+        def step(self, noise_pred, t, latents, return_dict=False):
+            # Return the noise_pred itself to inspect it
+            return (noise_pred,)
+
+    pipeline.scheduler = MockScheduler()
+
+    prompt_embeds = torch.tensor([[[2.0, 3.0]]])
+    negative_prompt_embeds = torch.tensor([[[1.0, 2.0]]])
+    latents = torch.zeros(1, 16, 1, 16, 16)
+    padding_mask = torch.zeros(1, 1, 16, 16)
+    timesteps = torch.tensor([500.0])
+
+    # Cond = prompt_embeds * 2.0 = [4.0, 6.0]
+    # Uncond = negative_prompt_embeds * 2.0 = [2.0, 4.0]
+    # Expected noise_pred = uncond + true_cfg_scale * (cond - uncond)
+    #                     = [2.0, 4.0] + 4.0 * ([4.0, 6.0] - [2.0, 4.0])
+    #                     = [2.0, 4.0] + 4.0 * [2.0, 2.0]
+    #                     = [2.0, 4.0] + [8.0, 8.0] = [10.0, 12.0]
+    out_latents = pipeline.diffuse(
+        prompt_embeds=prompt_embeds,
+        negative_prompt_embeds=negative_prompt_embeds,
+        latents=latents,
+        padding_mask=padding_mask,
+        timesteps=timesteps,
+        do_true_cfg=True,
+        true_cfg_scale=4.0,
+    )
+
+    expected = torch.tensor([[[10.0, 12.0]]])
+    assert torch.allclose(out_latents, expected)
diff --git a/tests/diffusion/models/bagel/test_step_execution.py b/tests/diffusion/models/bagel/test_step_execution.py
index 40d4154e3..e5f8e5d5a 100644
--- a/tests/diffusion/models/bagel/test_step_execution.py
+++ b/tests/diffusion/models/bagel/test_step_execution.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Focused CPU tests for BAGEL step execution and packed batching."""
 
 from __future__ import annotations
@@ -18,12 +18,14 @@ from vllm_omni.diffusion.models.bagel.bagel_transformer import Bagel, NaiveCache
 from vllm_omni.diffusion.models.bagel.pipeline_bagel import (
     BagelGenParams,
     BagelPipeline,
+    _bagel_canvas_requested,
     get_bagel_pre_process_func,
 )
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched import StepScheduler
 from vllm_omni.diffusion.worker.input_batch import InputBatch
 from vllm_omni.diffusion.worker.utils import StepRequestState
+from vllm_omni.errors import OmniClientError
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -118,7 +120,7 @@ def test_bagel_step_preprocessor_separates_incompatible_cfg_settings(first_extra
     assert first.batch_compatibility_key != second.batch_compatibility_key
 
 
-def test_bagel_step_preprocessor_buckets_effective_img2img_sizes(tmp_path):
+def _pre_process_with_stub_checkpoint(tmp_path):
     (tmp_path / "config.json").write_text(
         '{"vae_config":{"downsample":8},"latent_patch_size":2,"max_latent_size":32}',
         encoding="utf-8",
@@ -131,9 +133,22 @@ def test_bagel_step_preprocessor_buckets_effective_img2img_sizes(tmp_path):
         '{"weight_map":{"latent_pos_embed.pos_embed":"ema.safetensors"}}',
         encoding="utf-8",
     )
-    pre_process = get_bagel_pre_process_func(
-        types.SimpleNamespace(model=str(tmp_path), revision=None, step_execution=True)
+    return get_bagel_pre_process_func(types.SimpleNamespace(model=str(tmp_path), revision=None, step_execution=True))
+
+
+def _edit_request(source_size, sampling_params, request_id="req"):
+    return OmniDiffusionRequest(
+        prompt={
+            "prompt": "edit this image",
+            "multi_modal_data": {"image": [Image.new("RGB", source_size)]},
+        },
+        sampling_params=sampling_params,
+        request_id=request_id,
     )
+
+
+def test_bagel_step_preprocessor_buckets_effective_img2img_sizes(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
     requests = [
         OmniDiffusionRequest(
             prompt={
@@ -163,6 +178,172 @@ def test_bagel_step_preprocessor_buckets_effective_img2img_sizes(tmp_path):
     assert schedule.num_waiting_reqs == 1
 
 
+def test_bagel_pre_process_keeps_explicitly_requested_canvas(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request((512, 1024), OmniDiffusionSamplingParams(num_inference_steps=2, height=1024, width=1024))
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (1024, 1024)
+    assert _bagel_canvas_requested(request.sampling_params)
+
+
+def test_bagel_pre_process_aligns_source_derived_canvas_for_size_auto(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request(
+        (500, 700),
+        OmniDiffusionSamplingParams(
+            num_inference_steps=2,
+            height=700,
+            width=500,
+            height_not_provided=True,
+            width_not_provided=True,
+        ),
+    )
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (704, 496)
+    assert not _bagel_canvas_requested(request.sampling_params)
+
+
+def test_bagel_pre_process_derives_canvas_when_caller_asked_for_none(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request((800, 400), OmniDiffusionSamplingParams(num_inference_steps=2))
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (400, 800)
+    assert (request.sampling_params.height_not_provided, request.sampling_params.width_not_provided) == (True, True)
+    assert not _bagel_canvas_requested(request.sampling_params)
+
+
+def test_bagel_pre_process_marks_kv_metadata_canvas_as_requested(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request(
+        (500, 700),
+        OmniDiffusionSamplingParams(
+            num_inference_steps=2,
+            height=700,
+            width=500,
+            height_not_provided=True,
+            width_not_provided=True,
+            kv_metadata={"image_shape": (1024, 1024)},
+        ),
+    )
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (1024, 1024)
+    assert (request.sampling_params.height_not_provided, request.sampling_params.width_not_provided) == (False, False)
+    assert _bagel_canvas_requested(request.sampling_params)
+
+
+def test_bagel_pre_process_prefers_explicit_canvas_over_kv_metadata(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request(
+        (1280, 720),
+        OmniDiffusionSamplingParams(
+            num_inference_steps=2,
+            height=1024,
+            width=1024,
+            kv_metadata={"image_shape": (576, 1024)},
+        ),
+    )
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (1024, 1024)
+    assert _bagel_canvas_requested(request.sampling_params)
+
+
+def test_bagel_pre_process_floors_unaligned_explicit_canvas_with_warning(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request(
+        (1280, 720),
+        OmniDiffusionSamplingParams(num_inference_steps=2, height=700, width=1000),
+    )
+
+    with patch("vllm_omni.diffusion.models.bagel.pipeline_bagel.logger.warning") as warning:
+        pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (688, 992)
+    assert _bagel_canvas_requested(request.sampling_params)
+    warning.assert_called_once()
+    assert "width 1000->992, height 700->688" in warning.call_args.args[-1]
+
+
+def test_bagel_pre_process_keeps_aligned_explicit_canvas_silent(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request(
+        (1280, 720),
+        OmniDiffusionSamplingParams(num_inference_steps=2, height=512, width=1024),
+    )
+
+    with patch("vllm_omni.diffusion.models.bagel.pipeline_bagel.logger.warning") as warning:
+        pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (512, 1024)
+    warning.assert_not_called()
+
+
+def test_bagel_pre_process_rejects_explicit_canvas_over_checkpoint_limit(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = _edit_request(
+        (1280, 720),
+        OmniDiffusionSamplingParams(num_inference_steps=2, height=512, width=2048),
+    )
+
+    with pytest.raises(OmniClientError, match="width=2048 exceeds the BAGEL checkpoint limit of 1024") as excinfo:
+        pre_process(request)
+
+    assert excinfo.value.status_code == 400
+
+
+def test_bagel_pre_process_aligns_text2img_canvas_too(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = OmniDiffusionRequest(
+        prompt="a cat",
+        sampling_params=OmniDiffusionSamplingParams(num_inference_steps=2, height=700, width=1000),
+        request_id="req",
+    )
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (688, 992)
+
+
+def test_bagel_pre_process_skips_canvas_alignment_for_text_output(tmp_path):
+    pre_process = _pre_process_with_stub_checkpoint(tmp_path)
+    request = OmniDiffusionRequest(
+        prompt={
+            "prompt": "describe this image",
+            "modalities": ["text"],
+            "multi_modal_data": {"image": [Image.new("RGB", (1280, 720))]},
+        },
+        sampling_params=OmniDiffusionSamplingParams(num_inference_steps=2, height=700, width=1000),
+        request_id="req",
+    )
+
+    pre_process(request)
+
+    assert (request.sampling_params.height, request.sampling_params.width) == (700, 1000)
+    assert request.use_step_execution is False
+
+
+@pytest.mark.parametrize(
+    ("sampling_kwargs", "requested"),
+    [
+        ({"height": 1024, "width": 1024}, True),
+        ({"height": 1024, "width": 512, "height_not_provided": True, "width_not_provided": True}, False),
+        ({}, False),
+    ],
+    ids=["explicit_size", "size_auto", "unset"],
+)
+def test_bagel_canvas_requested_separates_asked_for_from_derived(sampling_kwargs, requested):
+    assert _bagel_canvas_requested(OmniDiffusionSamplingParams(**sampling_kwargs)) is requested
+
+
 def _cache(length: int, value: float, num_layers: int = 1) -> NaiveCache:
     cache = NaiveCache(num_layers)
     if length:
diff --git a/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py b/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py
index 39c32a4df..4abd7ef9b 100644
--- a/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py
+++ b/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py
@@ -13,11 +13,13 @@ Two groups:
    CFG handling, and reshape logic can be verified numerically on CPU.
 """
 
+import os
 from types import SimpleNamespace
 
 import pytest
 import torch
 from torch import nn
+from transformers import Qwen3VLConfig
 
 from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig, TransformerConfig
 
@@ -56,9 +58,17 @@ def mock_dependencies(mocker, monkeypatch):
         f"{_MODULE}.FlowMatchEulerDiscreteScheduler.from_pretrained",
         lambda *a, **k: mock_scheduler,
     )
-    monkeypatch.setattr(
+    mllm_loader = mocker.patch(
         f"{_MODULE}.Qwen3VLForConditionalGeneration.from_pretrained",
-        lambda *a, **k: mllm_wrapper,
+        return_value=mllm_wrapper,
+    )
+    mllm_config_loader = mocker.patch(
+        f"{_MODULE}.Qwen3VLConfig.from_pretrained",
+        return_value=Qwen3VLConfig(),
+    )
+    mllm_builder = mocker.patch(
+        f"{_MODULE}.create_transformers_model_with_vllm_linears",
+        return_value=nn.Linear(1, 1),
     )
     monkeypatch.setattr(
         f"{_MODULE}.Qwen3VLProcessor.from_pretrained",
@@ -74,12 +84,17 @@ def mock_dependencies(mocker, monkeypatch):
     mock_transformer_cls.return_value = mock_transformer_instance
     monkeypatch.setattr(f"{_MODULE}.BooguImageTransformer2DModel", mock_transformer_cls)
 
-    # Treat the dummy model id as a local path: skips hub prefetch.
-    mocker.patch("os.path.exists", return_value=True)
+    # Treat only the dummy model id as local. Other filesystem checks (for
+    # example lazy imports in the quantization registry) must remain real.
+    path_exists = os.path.exists
+    mocker.patch("os.path.exists", side_effect=lambda path: str(path).startswith("dummy-boogu") or path_exists(path))
 
     return {
         "inner_encoder": inner_encoder,
         "mllm_wrapper": mllm_wrapper,
+        "mllm_loader": mllm_loader,
+        "mllm_config_loader": mllm_config_loader,
+        "mllm_builder": mllm_builder,
         "processor": mock_processor,
         "vae": mock_vae,
         "scheduler": mock_scheduler,
@@ -128,6 +143,9 @@ def test_constructor_wires_components(boogu_pipeline, mock_dependencies):
     assert boogu_pipeline.vae_scale_factor == 8
     assert boogu_pipeline.default_sample_size == 128
     assert hasattr(boogu_pipeline, "load_weights")
+    assert "quantization_config" not in mock_dependencies["mllm_loader"].call_args.kwargs
+    mock_dependencies["mllm_config_loader"].assert_not_called()
+    mock_dependencies["mllm_builder"].assert_not_called()
 
 
 def test_constructor_strips_mllm_lm_head(boogu_pipeline, mock_dependencies):
@@ -188,7 +206,7 @@ def test_constructor_weights_sources(boogu_pipeline):
     assert source.fall_back_to_pt is True
 
 
-def test_constructor_routes_only_transformer_config(mock_dependencies, mocker):
+def test_constructor_rejects_unsupported_mllm_quantization(mock_dependencies, mocker):
     from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
 
     from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import BooguImagePipeline
@@ -204,10 +222,143 @@ def test_constructor_routes_only_transformer_config(mock_dependencies, mocker):
             {"transformer": transformer_config, "mllm": encoder_config, "vae": None}
         ),
     )
+    with pytest.raises(ValueError, match="Boogu MLLM only supports FP8 quantization"):
+        BooguImagePipeline(od_config=od_config)
+    mock_dependencies["mllm_loader"].assert_not_called()
+    mock_dependencies["mllm_config_loader"].assert_not_called()
+
+
+@pytest.mark.parametrize(
+    ("quantization_config", "quantize_mllm"),
+    [
+        pytest.param("fp8", True, id="global-fp8"),
+        pytest.param({"mllm": {"method": "fp8"}, "transformer": {"method": "fp8"}}, True, id="mllm-and-dit-fp8"),
+        pytest.param({"mllm": None, "transformer": "fp8"}, False, id="dit-only-fp8"),
+    ],
+)
+def test_constructor_routes_mllm_quantization(mock_dependencies, quantization_config, quantize_mllm):
+    from transformers import AutoModel
+    from vllm.model_executor.layers.quantization.fp8 import Fp8Config
+    from vllm.model_executor.layers.quantization.online.base import OnlineQuantizationConfig
+    from vllm.model_executor.layers.quantization.utils.quant_utils import kFp8Static128BlockSym
+
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import BooguImagePipeline
+
+    od_config = OmniDiffusionConfig(
+        model="dummy-boogu",
+        revision="test-revision",
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.bfloat16,
+        quantization_config=quantization_config,
+    )
+    pipeline = BooguImagePipeline(od_config=od_config)
+
+    if quantize_mllm:
+        mock_dependencies["mllm_loader"].assert_not_called()
+        mock_dependencies["mllm_config_loader"].assert_called_once_with(
+            "dummy-boogu", subfolder="mllm", local_files_only=True, revision="test-revision"
+        )
+        builder = mock_dependencies["mllm_builder"]
+        builder.assert_called_once()
+        auto_cls, hf_config, online_quant_config = builder.call_args.args
+        assert auto_cls is AutoModel
+        assert hf_config is mock_dependencies["mllm_config_loader"].return_value
+        assert isinstance(online_quant_config, OnlineQuantizationConfig)
+        assert online_quant_config.args.linear.weight == kFp8Static128BlockSym
+        assert builder.call_args.kwargs == {
+            "dtype": torch.bfloat16,
+            "device": pipeline._execution_device,
+            "prefix": "mllm",
+            "skip_modules": ("mllm.visual",),
+        }
+        assert pipeline.mllm is builder.return_value
+        assert not pipeline.mllm.training
+        assert all(not parameter.requires_grad for parameter in pipeline.mllm.parameters())
+        transformer_source, mllm_source = pipeline.weights_sources
+        assert transformer_source.subfolder == "transformer"
+        assert mllm_source.model_or_path == "dummy-boogu"
+        assert mllm_source.subfolder == "mllm"
+        assert mllm_source.prefix == "mllm."
+        assert mllm_source.revision == "test-revision"
+    else:
+        assert "quantization_config" not in mock_dependencies["mllm_loader"].call_args.kwargs
+        assert pipeline.mllm is mock_dependencies["inner_encoder"]
+        mock_dependencies["mllm_config_loader"].assert_not_called()
+        mock_dependencies["mllm_builder"].assert_not_called()
+        assert [source.subfolder for source in pipeline.weights_sources] == ["transformer"]
+    assert isinstance(mock_dependencies["transformer_cls"].call_args.kwargs["quant_config"], Fp8Config)
+
+
+def test_constructor_preserves_mllm_ignored_layers(mock_dependencies):
+    from vllm.model_executor.layers.quantization.fp8 import Fp8Config
+
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import BooguImagePipeline
+
+    quant_config = Fp8Config(
+        ignored_layers=["mllm.language_model.layers.0.self_attn.q_proj", "transformer.blocks.0.attn.to_q"]
+    )
+    od_config = OmniDiffusionConfig(
+        model="dummy-boogu",
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.bfloat16,
+        quantization_config=quant_config,
+    )
     BooguImagePipeline(od_config=od_config)
-    kwargs = mock_dependencies["transformer_cls"].call_args.kwargs
-    assert kwargs["quant_config"] is transformer_config
-    assert kwargs["prefix"] == "transformer"
+
+    online_quant_config = mock_dependencies["mllm_builder"].call_args.args[2]
+    assert online_quant_config.ignored_layers == quant_config.ignored_layers
+
+
+def test_constructor_preserves_serialized_mllm_quantization(mock_dependencies):
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import BooguImagePipeline
+
+    mock_dependencies["mllm_config_loader"].return_value = Qwen3VLConfig(
+        quantization_config={"quant_method": "fp8", "modules_to_not_convert": ["model.visual"]}
+    )
+    od_config = OmniDiffusionConfig(
+        model="dummy-boogu-fp8",
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.bfloat16,
+        quantization_config="fp8",
+    )
+    pipeline = BooguImagePipeline(od_config=od_config)
+
+    # No override: HF reads the serialized checkpoint's scales and skip list.
+    assert "quantization_config" not in mock_dependencies["mllm_loader"].call_args.kwargs
+    assert pipeline.mllm is mock_dependencies["inner_encoder"]
+    mock_dependencies["mllm_builder"].assert_not_called()
+    assert [source.subfolder for source in pipeline.weights_sources] == ["transformer"]
+
+
+def test_load_weights_maps_mllm_and_preserves_transformer():
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import BooguImagePipeline
+
+    pipeline = object.__new__(BooguImagePipeline)
+    nn.Module.__init__(pipeline)
+    pipeline.mllm = nn.ModuleDict(
+        {
+            "language_model": nn.Linear(2, 2, bias=False),
+            "visual": nn.Linear(2, 2, bias=False),
+        }
+    )
+    pipeline.transformer = nn.Linear(2, 2, bias=False)
+    language_weight = torch.full((2, 2), 1.0)
+    visual_weight = torch.full((2, 2), 2.0)
+    transformer_weight = torch.full((2, 2), 3.0)
+
+    loaded = pipeline.load_weights(
+        [
+            ("mllm.lm_head.weight", torch.full((2, 2), 9.0)),
+            ("mllm.model.language_model.weight", language_weight),
+            ("mllm.model.visual.weight", visual_weight),
+            ("transformer.weight", transformer_weight),
+        ]
+    )
+
+    assert loaded == {"mllm.language_model.weight", "mllm.visual.weight", "transformer.weight"}
+    torch.testing.assert_close(pipeline.mllm["language_model"].weight, language_weight)
+    torch.testing.assert_close(pipeline.mllm["visual"].weight, visual_weight)
+    torch.testing.assert_close(pipeline.transformer.weight, transformer_weight)
 
 
 @pytest.mark.parametrize(
diff --git a/tests/diffusion/models/ernie_image/test_ernie_image_fused_rope.py b/tests/diffusion/models/ernie_image/test_ernie_image_fused_rope.py
new file mode 100644
index 000000000..b73804433
--- /dev/null
+++ b/tests/diffusion/models/ernie_image/test_ernie_image_fused_rope.py
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+import torch
+from vllm.triton_utils import HAS_TRITON
+
+from tests.helpers.mark import hardware_test
+from vllm_omni.diffusion.models.ernie_image.ernie_image_transformer import _apply_rotary_emb
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
+
+@pytest.fixture(autouse=True)
+def reset_fused_rope_state():
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    fused_rope._FAILED_KEYS.clear()
+    yield
+    fused_rope._FAILED_KEYS.clear()
+
+
+def _inputs(shape: tuple[int, int, int, int]):
+    batch, sequence, _, head_dim = shape
+    torch.manual_seed(17)
+    query = torch.randn(shape, device="cuda", dtype=torch.bfloat16)
+    key = torch.randn_like(query)
+    freqs_cos = torch.randn(
+        batch,
+        sequence,
+        head_dim // 2,
+        device="cuda",
+        dtype=torch.float32,
+    )
+    freqs_sin = torch.randn_like(freqs_cos)
+    return query, key, freqs_cos, freqs_sin
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="NVIDIA CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (1, 1, 1, 128),
+        (2, 257, 7, 128),
+        (2, 4608, 32, 128),
+    ],
+)
+def test_fused_qk_rope_is_bit_exact(shape):
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    query, key, freqs_cos, freqs_sin = _inputs(shape)
+    with torch.inference_mode():
+        expected_query = _apply_rotary_emb(query, freqs_cos, freqs_sin)
+        expected_key = _apply_rotary_emb(key, freqs_cos, freqs_sin)
+        actual = fused_rope.try_fused_qk_rotary_emb(query, key, freqs_cos, freqs_sin)
+
+    assert actual is not None
+    actual_query, actual_key = actual
+    assert torch.equal(actual_query, expected_query)
+    assert torch.equal(actual_key, expected_key)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="NVIDIA CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_launch_failure_disables_runtime_key(monkeypatch):
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    query, key, freqs_cos, freqs_sin = _inputs((1, 17, 3, 128))
+    launch_count = 0
+
+    def failing_launch(*args):
+        nonlocal launch_count
+        launch_count += 1
+        raise RuntimeError("injected launch failure")
+
+    monkeypatch.setattr(
+        fused_rope,
+        "_launch_fused_qk_rotary_emb",
+        failing_launch,
+    )
+    with torch.inference_mode():
+        for _ in range(2):
+            assert fused_rope.try_fused_qk_rotary_emb(query, key, freqs_cos, freqs_sin) is None
+    assert launch_count == 1
+    assert len(fused_rope._FAILED_KEYS) == 1
+
+
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+def test_failed_runtime_key_cache_is_bounded():
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    for index in range(fused_rope._FAILED_KEYS_MAX_SIZE + 1):
+        fused_rope._record_failed_runtime_key((index,))
+
+    assert len(fused_rope._FAILED_KEYS) == fused_rope._FAILED_KEYS_MAX_SIZE
+    assert (0,) not in fused_rope._FAILED_KEYS
+    assert (fused_rope._FAILED_KEYS_MAX_SIZE,) in fused_rope._FAILED_KEYS
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="NVIDIA CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_compile_path_does_not_launch_fused_kernel(monkeypatch):
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    query, key, freqs_cos, freqs_sin = _inputs((1, 17, 3, 128))
+    monkeypatch.setattr(torch.compiler, "is_compiling", lambda: True)
+
+    def unexpected_launch(*args):
+        raise AssertionError("compile path must remain native")
+
+    monkeypatch.setattr(
+        fused_rope,
+        "_launch_fused_qk_rotary_emb",
+        unexpected_launch,
+    )
+    with torch.inference_mode():
+        assert fused_rope.try_fused_qk_rotary_emb(query, key, freqs_cos, freqs_sin) is None
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="NVIDIA CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+@pytest.mark.parametrize("requires_grad_input", ["query", "key", "cos", "sin"])
+def test_gradient_inputs_do_not_launch_fused_kernel(monkeypatch, requires_grad_input):
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    values = list(_inputs((1, 17, 3, 128)))
+    input_index = {"query": 0, "key": 1, "cos": 2, "sin": 3}[requires_grad_input]
+    values[input_index].requires_grad_(True)
+
+    def unexpected_launch(*args):
+        raise AssertionError("autograd inputs must remain on the native path")
+
+    monkeypatch.setattr(
+        fused_rope,
+        "_launch_fused_qk_rotary_emb",
+        unexpected_launch,
+    )
+    assert (
+        fused_rope.try_fused_qk_rotary_emb(
+            *values,
+        )
+        is None
+    )
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="NVIDIA CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_mismatched_key_dtype_or_device_does_not_launch(monkeypatch):
+    from vllm_omni.diffusion.models.ernie_image import fused_rope
+
+    query, key, freqs_cos, freqs_sin = _inputs((1, 17, 3, 128))
+
+    def unexpected_launch(*args):
+        raise AssertionError("mismatched Q/K inputs must remain native")
+
+    monkeypatch.setattr(
+        fused_rope,
+        "_launch_fused_qk_rotary_emb",
+        unexpected_launch,
+    )
+    for unsupported_key in (key.float(), key.cpu()):
+        assert (
+            fused_rope.try_fused_qk_rotary_emb(
+                query,
+                unsupported_key,
+                freqs_cos,
+                freqs_sin,
+            )
+            is None
+        )
diff --git a/tests/diffusion/models/ernie_image/test_ernie_image_rope.py b/tests/diffusion/models/ernie_image/test_ernie_image_rope.py
index 22d8efaad..34beb69f9 100644
--- a/tests/diffusion/models/ernie_image/test_ernie_image_rope.py
+++ b/tests/diffusion/models/ernie_image/test_ernie_image_rope.py
@@ -1,8 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import pytest
 import torch
 
 from vllm_omni.diffusion.models.ernie_image.ernie_image_transformer import (
     ErnieImageEmbedND3,
+    _apply_qk_rotary_emb,
     _apply_rotary_emb,
     rope,
 )
@@ -185,3 +189,30 @@ class TestErnieImageRopePositionEmbedding:
         out_diffusers = x * cos_ + rotated * sin_
 
         assert torch.allclose(out_vllm, out_diffusers, atol=1e-6), "vllm-omni and diffusers outputs should match"
+
+    def test_apply_qk_rotary_emb_uses_native_fallback(self, monkeypatch):
+        """Unsupported routes preserve both existing eager calls exactly."""
+        from vllm_omni.diffusion.models.ernie_image import (
+            ernie_image_transformer,
+        )
+
+        B, S, H, D = 2, 17, 3, 128
+        query = torch.randn(B, S, H, D)
+        key = torch.randn(B, S, H, D)
+        freqs_cos = torch.randn(B, S, D // 2)
+        freqs_sin = torch.randn(B, S, D // 2)
+        monkeypatch.setattr(
+            ernie_image_transformer,
+            "try_fused_qk_rotary_emb",
+            lambda *args: None,
+        )
+
+        actual_query, actual_key = _apply_qk_rotary_emb(query, key, freqs_cos, freqs_sin)
+        assert torch.equal(
+            actual_query,
+            _apply_rotary_emb(query, freqs_cos, freqs_sin),
+        )
+        assert torch.equal(
+            actual_key,
+            _apply_rotary_emb(key, freqs_cos, freqs_sin),
+        )
diff --git a/tests/diffusion/models/hunyuan_image3/test_diffusion_kv_request.py b/tests/diffusion/models/hunyuan_image3/test_diffusion_kv_request.py
index 2a17cd691..af9a41dfc 100644
--- a/tests/diffusion/models/hunyuan_image3/test_diffusion_kv_request.py
+++ b/tests/diffusion/models/hunyuan_image3/test_diffusion_kv_request.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from types import SimpleNamespace
 
@@ -362,6 +362,20 @@ def test_prepared_model_inputs_match_local_tokenization(
     local_inputs = pipeline.prepare_model_inputs(**common_kwargs)
     prepared_inputs = pipeline.prepare_model_inputs(**common_kwargs, prepared_layout=prepared_layout)
 
+    if with_reference_image:
+        # Preparation runs without a forward context. Coverage must come from
+        # the scheduler metadata copied onto this request, including every CFG row.
+        reused = pipeline.prepare_model_inputs(
+            **common_kwargs, prepared_layout=prepared_layout, kv_computed_tokens=(5,) * len(prefix_lens)
+        )
+        assert reused["cond_vae_images"] is None and reused["cond_vit_images"] is None
+        partial = pipeline.prepare_model_inputs(
+            **common_kwargs,
+            prepared_layout=prepared_layout,
+            kv_computed_tokens=(5,) * (len(prefix_lens) - 1) + (4,),
+        )
+        assert partial["cond_vae_images"] is not None and partial["cond_vit_images"] is not None
+
     comparable_fields = (
         "input_ids",
         "position_ids",
@@ -474,3 +488,33 @@ def test_paged_preprocess_attaches_layout_and_scheduler_kv_requests(monkeypatch)
         (12, 17, 32)
     ]
     assert len(tokenizer.calls) == 1
+
+
+@pytest.mark.parametrize("transfer_tokens, expected", [(9, [7, 5]), (4, [4, 4])])
+def test_cfg_rows_preserve_reusable_token_ids_and_native_transfer_boundary(transfer_tokens, expected):
+    from vllm_omni.diffusion.diffusion_kv.kv_connector import prepare_kv_requests
+
+    tokenizer, image_processor = _components([12, 14])
+    request = _request(guidance_scale=5.0)
+    layout = _prepare(request, tokenizer, image_processor)
+    layout.tokenizer_output.think_recaption_end_pos = [[7], [5]]
+    layout.tokenizer_output.uncond_cfg_start_pos = [[None], [5]]
+    rows = build_hunyuan_diffusion_kv_requests(request, layout)
+    assert [row.prompt_token_ids for row in rows] == [
+        layout.tokenizer_output.tokens[0, :7].tolist(),
+        layout.tokenizer_output.tokens[1, :5].tolist(),
+    ]
+    prepare_kv_requests(rows, {"num_transfer_tokens": transfer_tokens})
+    assert [row.num_prompt_tokens for row in rows] == expected
+    assert all(row.kv_transfer_params["num_transfer_tokens"] == transfer_tokens for row in rows)
+    layout.tokenizer_output.uncond_cfg_start_pos = [[5]]
+    with pytest.raises(ValueError, match="one boundary per CFG row"):
+        build_hunyuan_diffusion_kv_requests(request, layout)
+
+
+@pytest.mark.parametrize("computed, expected", [((8, 8), True), ((8, 5), False), ((0, 0), False), ((), False)])
+def test_native_image_reuse_requires_coverage_in_every_cfg_row(computed, expected):
+    from vllm_omni.diffusion.models.hunyuan_image3.request_layout import native_kv_covers_cond_images
+
+    output = TokenizerEncodeOutput(joint_image_slices=[[slice(2, 8)], [slice(2, 6)]])
+    assert native_kv_covers_cond_images(output, computed) is expected
diff --git a/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_sampler.py b/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_sampler.py
index 34f86347a..eeb14421f 100644
--- a/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_sampler.py
+++ b/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_sampler.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for HunyuanImage3 AR sampler logic (stage transitions,
 ratio restriction, comprehension blocking)."""
 
@@ -21,6 +21,10 @@ RATIO_END = 210
 RATIO_OTHER_START = 220
 RATIO_OTHER_END = 223
 TIMESTEP = 224
+CFG = 110
+IMG_TOK = 111
+JOINT_SEP = 112
+EOI = 113
 
 
 class FakeSamplerModel:
@@ -47,10 +51,13 @@ class FakeSamplerModel:
             self._stage_transitions[END_OF_THINK] = [RECAPTION]
             self._stage_transitions[END_OF_RECAPTION] = [ANSWER, BOI, SIZE_TOKEN]
 
-        self._blocked_token_ids: set[int] = set()
-        if is_comprehension:
-            self._blocked_token_ids.update([BOI, SIZE_TOKEN])
-            self._blocked_token_ids.update(self._all_ratio_ids)
+        # Mirrors the model: the blocklist is always built so generation-mode
+        # engines can apply it to per-request comprehension rows (#6088).
+        self._cfg_token_id = CFG
+        self._blocked_token_ids: set[int] = {BOI, EOI, SIZE_TOKEN, CFG, IMG_TOK, TIMESTEP, JOINT_SEP}
+        self._blocked_token_ids.update(self._all_ratio_ids)
+        self._blocked_token_ids_tensor = None
+        self._sampler = None
 
     # Bind the real methods from the model class.
     from vllm_omni.model_executor.models.hunyuan_image3.hunyuan_image3 import (
@@ -59,6 +66,8 @@ class FakeSamplerModel:
 
     _get_forced_token = _Real._get_forced_token
     _apply_ratio_restriction = _Real._apply_ratio_restriction
+    _row_is_comprehension = staticmethod(_Real._row_is_comprehension)
+    sample = _Real.sample
 
 
 class FakeTokenEmbedding:
@@ -250,3 +259,114 @@ class TestForceEosAfterRatio:
         assert logits[0, EOS].item() == 0
         non_eos_max = logits[0, :EOS].max().item()
         assert non_eos_max == min_score
+
+
+class _RecordingSampler:
+    """Stub sampler: returns the (mutated) logits so tests can assert on them."""
+
+    def __call__(self, *, logits, sampling_metadata):
+        return logits
+
+
+def _metadata(output_token_ids):
+    from types import SimpleNamespace
+
+    return SimpleNamespace(output_token_ids=output_token_ids)
+
+
+class TestPerRequestTaskMode:
+    """Generation-mode engines must honor per-request comprehension rows (#6088).
+
+    A text chat (I2T/T2T) served by an AR+DiT deployment is marked with
+    extra_args={"ar_task_mode": "comprehension"}; its rows get the stateless
+    image-token blocking instead of stage-transition forcing, while untagged
+    rows keep the generation behavior.
+    """
+
+    VOCAB = 300
+
+    def _run(self, model, histories, per_req_extra_args):
+        logits = torch.zeros(len(histories), self.VOCAB)
+        logits[:, 50] = 7.0  # ordinary text token, must survive comprehension
+        model._sampler = _RecordingSampler()
+        out = model.sample(logits, _metadata(histories), per_req_extra_args=per_req_extra_args)
+        return out
+
+    def test_comprehension_row_skips_forcing_and_blocks_image_tokens(self):
+        model = FakeSamplerModel(is_comprehension=False)
+        min_score = torch.finfo(torch.float32).min
+
+        logits = self._run(
+            model,
+            histories=[[END_OF_THINK], [END_OF_THINK]],
+            per_req_extra_args=[{"ar_task_mode": "comprehension"}, None],
+        )
+
+        # Row 0 (comprehension): no </think> -> <recaption> forcing (ordinary
+        # text token survives, which a force-fill would have erased) and every
+        # DiT scaffold token is masked.
+        assert logits[0, 50].item() == 7.0
+        for tid in (BOI, EOI, SIZE_TOKEN, CFG, IMG_TOK, TIMESTEP, JOINT_SEP, RATIO_START, RATIO_OTHER_START):
+            assert logits[0, tid].item() == min_score, f"token {tid} not blocked"
+
+        # Row 1 (generation): forced to <recaption> exactly as before.
+        assert logits[1, RECAPTION].item() == 0
+        assert logits[1, 50].item() == min_score
+
+    def test_no_extra_args_keeps_generation_behavior(self):
+        model = FakeSamplerModel(is_comprehension=False)
+        min_score = torch.finfo(torch.float32).min
+
+        logits = self._run(model, histories=[[END_OF_THINK]], per_req_extra_args=None)
+
+        assert logits[0, RECAPTION].item() == 0
+        assert logits[0, 50].item() == min_score
+
+    def test_empty_or_foreign_extra_args_keeps_generation_behavior(self):
+        model = FakeSamplerModel(is_comprehension=False)
+
+        logits = self._run(
+            model,
+            histories=[[END_OF_THINK], [END_OF_THINK]],
+            per_req_extra_args=[{}, {"other_key": 1}],
+        )
+
+        assert logits[0, RECAPTION].item() == 0
+        assert logits[1, RECAPTION].item() == 0
+
+    def test_comprehension_row_without_trigger_history(self):
+        model = FakeSamplerModel(is_comprehension=False)
+        min_score = torch.finfo(torch.float32).min
+
+        logits = self._run(
+            model,
+            histories=[[1, 2, 3]],
+            per_req_extra_args=[{"ar_task_mode": "comprehension"}],
+        )
+
+        assert logits[0, 50].item() == 7.0
+        assert logits[0, CFG].item() == min_score
+
+    def test_static_comprehension_engine_blocks_cfg(self):
+        model = FakeSamplerModel(is_comprehension=True)
+        min_score = torch.finfo(torch.float32).min
+
+        logits = self._run(model, histories=[[1, 2]], per_req_extra_args=None)
+
+        for tid in (BOI, EOI, SIZE_TOKEN, CFG, IMG_TOK, TIMESTEP, JOINT_SEP):
+            assert logits[0, tid].item() == min_score
+        assert logits[0, 50].item() == 7.0
+
+    def test_extra_args_shorter_than_batch_defaults_to_generation(self):
+        model = FakeSamplerModel(is_comprehension=False)
+
+        logits = self._run(
+            model,
+            histories=[[END_OF_THINK], [END_OF_THINK]],
+            per_req_extra_args=[{"ar_task_mode": "comprehension"}],
+        )
+        min_score = torch.finfo(torch.float32).min
+
+        assert logits[0, 50].item() == 7.0  # tagged row: comprehension
+        assert logits[1, RECAPTION].item() == 0  # missing entry: generation
+        assert logits[1, 50].item() == min_score
diff --git a/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py b/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py
index 65fc0e67b..db48175c3 100644
--- a/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py
+++ b/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py
@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import math
 from contextlib import ExitStack, contextmanager
+from types import SimpleNamespace
 from unittest.mock import patch
 
 import pytest
@@ -143,6 +144,104 @@ def test_cache_manager_registers_attention_without_adding_dense_state() -> None:
     assert mgr.state_dict() == {}
 
 
+def test_cache_manager_initializes_with_quantization_skip_layers(monkeypatch):
+    import vllm_omni.diffusion.attention.layer as layer
+    from vllm_omni.diffusion.config import set_current_diffusion_config
+    from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_image3_transformer import ImageKVCacheManager
+
+    config = SimpleNamespace(
+        diffusion_attention_config=None,
+        parallel_config=SimpleNamespace(ring_degree=1),
+        diffusion_kv_cache_dtype="auto",
+        diffusion_kv_cache_skip_layer_indices={3},
+    )
+    monkeypatch.setattr(layer, "get_attn_backend_for_role", lambda **_: (layer.SDPABackend, None))
+    monkeypatch.setattr(layer, "build_parallel_attention_strategy", lambda **_: object())
+    with patched_mgr_env(), set_current_diffusion_config(config):
+        # Keep the real Attention constructor and its skip-layer validation.
+        with patch(f"{_TRANSFORMER_MODULE}.Attention", layer.Attention):
+            mgr = ImageKVCacheManager(
+                num_heads=NUM_HEADS,
+                num_kv_heads=NUM_KV_HEADS,
+                head_dim=HEAD_DIM,
+                scaling=SCALING,
+                prefix="model.layers.3.self_attn",
+            )
+    assert mgr.attn.layer_idx == 3
+    assert not mgr.attn._should_apply_kv_cache_quant()
+
+
+@pytest.mark.parametrize("first_step", [True, False])
+def test_native_connector_keeps_imported_prefix_in_paged_attention(first_step) -> None:
+    from vllm_omni.diffusion.forward_context import override_paged_kv_adapter, set_forward_context
+
+    mgr = _make_cache_mgr()
+    mgr.attn.paged_kv_active = True
+    query_len, prefix_len = IMAGE_TOKEN_LEN, 19
+    key, value = _make_known_kv(2 * query_len)
+    spans = [[(prefix_len, prefix_len + query_len)]] * 2
+    with (
+        set_forward_context(),
+        override_paged_kv_adapter(object()),
+        patch.object(mgr, "_forward_dense_legacy", side_effect=AssertionError("dense KV path")),
+        patch(f"{_TRANSFORMER_MODULE}.repeat_kv", side_effect=AssertionError("KV head expansion")),
+        patch(f"{_TRANSFORMER_MODULE}.get_paged_kv_computed_tokens", return_value=(prefix_len, prefix_len)),
+    ):
+        _call_mgr(
+            mgr,
+            2,
+            query_len,
+            prefix_len + query_len,
+            key,
+            value,
+            first_step=first_step,
+            full_attn_spans=spans,
+        )
+    assert len(mgr.attn.paged_calls) == 1
+    assert mgr.attn.paged_calls[0][1].shape == (2, query_len, NUM_KV_HEADS, HEAD_DIM)
+    assert mgr.attn.paged_metadata[0].attn_mask is None
+    assert mgr.attn.paged_metadata[0].full_attn_spans == spans
+    assert mgr.image_kv_cache_map is None
+    assert not hasattr(mgr, "_materialize_paged_prefix")
+
+
+def test_legacy_tensor_prefix_still_uses_dense_cache_and_reuse() -> None:
+    mgr = _make_cache_mgr()
+    prefix_len, prompt_len = 3, 2
+    imported = _make_known_kv(prefix_len, base=10.0)
+    mgr._injected_ar_kv = [imported]
+    first_len = prompt_len + IMAGE_TOKEN_LEN
+    key, value = _make_known_kv(first_len, base=20.0)
+    with (
+        patch.object(mgr, "_forward_paged", side_effect=AssertionError("legacy entered paged path")),
+    ):
+        _call_mgr(
+            mgr,
+            1,
+            first_len,
+            prefix_len + first_len,
+            key,
+            value,
+            first_step=True,
+            gen_timestep_scatter_index=_gen_timestep_index(1, prompt_len),
+        )
+        assert mgr.image_kv_cache_map is not None
+        assert mgr.image_kv_cache_map[0].shape[1] == prefix_len + prompt_len
+        next_key, next_value = _make_known_kv(IMAGE_TOKEN_LEN, base=30.0)
+        _call_mgr(
+            mgr,
+            1,
+            IMAGE_TOKEN_LEN,
+            prefix_len + first_len,
+            next_key,
+            next_value,
+            position_ids=torch.arange(prefix_len + prompt_len, prefix_len + first_len).unsqueeze(0),
+        )
+    assert len(mgr.attn.calls) == 2
+    assert not mgr.attn.paged_calls
+    assert mgr.attn.calls[-1][1].shape == (1, prefix_len + first_len, NUM_HEADS, HEAD_DIM)
+
+
 def test_scheduler_paged_kv_runs_piecewise_for_first_and_later_steps() -> None:
     from vllm_omni.diffusion.forward_context import override_paged_kv_adapter, set_forward_context
 
diff --git a/tests/diffusion/models/lingbot_world/test_lingbot_world_actions.py b/tests/diffusion/models/lingbot_world/test_lingbot_world_actions.py
index e26e44c2c..c0e8ce6a7 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_actions.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_actions.py
@@ -12,6 +12,7 @@ from vllm_omni.diffusion.models.lingbot_world.actions import (
     LINGBOT_CAMERA_ACTION_SCHEMA,
     LINGBOT_CAMERA_TRAJECTORY_SCHEMA,
     LingBotCameraControlReducer,
+    camera_trajectory_from_absolute_pose,
     integrate_lingbot_camera_actions,
     parse_lingbot_camera_action_frames,
     parse_lingbot_camera_action_script,
@@ -212,6 +213,11 @@ def test_action_integrator_matches_lingbot_motion_and_calibration() -> None:
         torch.tensor([500.0, 500.0, 208.0, 120.0]),
     )
 
+    with pytest.raises(ValueError, match="resolution must be positive"):
+        camera_trajectory_from_absolute_pose(trajectory.poses[:1], width=0, height=480)
+    with pytest.raises(ValueError, match=r"\[frames, 4, 4\]"):
+        camera_trajectory_from_absolute_pose(torch.zeros(4, 4), width=832, height=480)
+
 
 @pytest.mark.parametrize(
     ("data", "message"),
diff --git a/tests/diffusion/models/lingbot_world/test_lingbot_world_attention.py b/tests/diffusion/models/lingbot_world/test_lingbot_world_attention.py
index 3d883414e..7e12b3db3 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_attention.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_attention.py
@@ -74,6 +74,17 @@ def _install_vllm_stubs() -> None:
         _SeqAllToAll4D,
     )
 
+    def _all_to_all_5D(value, scatter_idx=3, gather_idx=1, group=None, use_sync=False):
+        # Single-rank stub: the fused q/k/v exchange is the identity when N == 1.
+        del scatter_idx, gather_idx, group, use_sync
+        return value
+
+    setattr(
+        sys.modules["vllm_omni.diffusion.distributed.comm"],
+        "all_to_all_5D",
+        _all_to_all_5D,
+    )
+
     def get_sp_group():
         return SimpleNamespace(
             ulysses_world_size=1,
@@ -588,26 +599,7 @@ def test_tp_rmsnorm_weight_loader_selects_rank_shard(monkeypatch: pytest.MonkeyP
     torch.testing.assert_close(norm.weight, torch.tensor([30.0, 40.0]))
 
 
-def test_single_token_text_kv_shard_owns_compact_storage(monkeypatch):
-    module = _load_module()
-    monkeypatch.setattr(
-        module,
-        "get_sp_group",
-        lambda: SimpleNamespace(
-            ulysses_world_size=2,
-            ulysses_rank=1,
-            ulysses_group=None,
-        ),
-    )
-    attention = module.LingBotCrossAttention(dim=8, num_heads=4)
-    full = torch.arange(8, dtype=torch.float32).reshape(1, 1, 4, 2)
-    shard = attention.shard_kv_heads(full)
-    torch.testing.assert_close(shard, full[:, :, 2:], rtol=0, atol=0)
-    assert shard.is_contiguous()
-    assert shard.untyped_storage().nbytes() == shard.numel() * shard.element_size()
-
-
-@pytest.mark.parametrize("attention_class", ["LingBotSelfAttention", "LingBotCrossAttention"])
+@pytest.mark.parametrize("attention_class", ["LingBotSelfAttention"])
 def test_ulysses_rejects_non_divisible_head_count(monkeypatch, attention_class):
     module = _load_module()
     monkeypatch.setattr(
@@ -621,3 +613,35 @@ def test_ulysses_rejects_non_divisible_head_count(monkeypatch, attention_class):
     )
     with pytest.raises(ValueError, match="heads must be divisible"):
         getattr(module, attention_class)(dim=8, num_heads=4)
+
+
+def test_supplied_camera_modulation_matches_computing_it_inline() -> None:
+    """Passing a prebuilt modulation must be arithmetically identical to letting the block build its own."""
+    module = _load_module()
+    torch.manual_seed(0)
+    block = module.LingBotAttentionBlock(dim=4, num_heads=2, prefix="blocks.0")
+    camera = torch.randn(1, 3, 4)
+
+    scale, shift = block.camera_modulation(camera)
+    inline_scale, inline_shift = block.camera_modulation(camera)
+
+    torch.testing.assert_close(scale, inline_scale, rtol=0, atol=0)
+    torch.testing.assert_close(shift, inline_shift, rtol=0, atol=0)
+
+
+def test_the_camera_modulation_reads_only_the_camera_tokens() -> None:
+    """The reuse window is only sound because the modulation depends on nothing else that varies per forward."""
+    module = _load_module()
+    torch.manual_seed(0)
+    block = module.LingBotAttentionBlock(dim=4, num_heads=2, prefix="blocks.0")
+    camera = torch.randn(1, 3, 4)
+
+    first = block.camera_modulation(camera)
+    # Same camera, different everything else a forward would carry: the modulation cannot move.
+    second = block.camera_modulation(camera.clone())
+
+    torch.testing.assert_close(first[0], second[0], rtol=0, atol=0)
+    torch.testing.assert_close(first[1], second[1], rtol=0, atol=0)
+    # A different camera must move it, or the cache key would be hiding a real dependency.
+    other = block.camera_modulation(camera + 1)
+    assert not torch.equal(first[0], other[0])
diff --git a/tests/diffusion/models/lingbot_world/test_lingbot_world_camera.py b/tests/diffusion/models/lingbot_world/test_lingbot_world_camera.py
index 9cb67a142..98da24c7a 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_camera.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_camera.py
@@ -422,7 +422,17 @@ def test_build_plucker_embedding_uses_framewise_deltas_for_rotations_and_transla
     torch.testing.assert_close(result[2, 3:, 0, 1], expected_direction)
 
 
-def test_build_plucker_embedding_normalizes_framewise_translation_by_max_norm() -> None:
+@pytest.mark.parametrize(
+    ("translation_scale", "expected_origins"),
+    [
+        (None, [[0.0, 0.0, 0.0], [0.3, 0.4, 0.0], [0.6, 0.8, 0.0]]),
+        (0.05, [[0.0, 0.0, 0.0], [60.0, 80.0, 0.0], [120.0, 160.0, 0.0]]),
+    ],
+)
+def test_build_plucker_embedding_normalizes_framewise_translation_by_max_norm(
+    translation_scale: float | None,
+    expected_origins: list[list[float]],
+) -> None:
     poses = torch.eye(4).repeat(3, 1, 1)
     poses[:, :3, 3] = torch.tensor(
         [
@@ -440,10 +450,37 @@ def test_build_plucker_embedding_normalizes_framewise_translation_by_max_norm()
         target_width=1,
         device=torch.device("cpu"),
         dtype=torch.float32,
+        translation_scale=translation_scale,
     )
 
-    expected_origins = torch.tensor([[0.0, 0.0, 0.0], [0.3, 0.4, 0.0], [0.6, 0.8, 0.0]])
-    torch.testing.assert_close(result[:, :3, 0, 0], expected_origins)
+    torch.testing.assert_close(result[:, :3, 0, 0], torch.tensor(expected_origins))
+
+    from vllm_omni.diffusion.models.lingbot_world.actions import LINGBOT_CONTROLLER_TRANSLATION_UNIT
+
+    if translation_scale != LINGBOT_CONTROLLER_TRANSLATION_UNIT:
+        return
+    # Fixed controller unit keeps relative speed; max-norm would collapse both to 1.
+    slow = torch.eye(4).repeat(2, 1, 1)
+    slow[1, 2, 3] = 0.005
+    fast = torch.eye(4).repeat(2, 1, 1)
+    fast[1, 2, 3] = 0.5
+    kwargs = dict(
+        height=1,
+        width=1,
+        target_height=1,
+        target_width=1,
+        device=torch.device("cpu"),
+        dtype=torch.float32,
+        translation_scale=LINGBOT_CONTROLLER_TRANSLATION_UNIT,
+    )
+    slow_origin = build_plucker_embedding(_trajectory(slow), **kwargs)[1, :3, 0, 0]
+    fast_origin = build_plucker_embedding(_trajectory(fast), **kwargs)[1, :3, 0, 0]
+    torch.testing.assert_close(slow_origin, torch.tensor([0.0, 0.0, 0.1]))
+    torch.testing.assert_close(fast_origin, torch.tensor([0.0, 0.0, 10.0]))
+    wasd = torch.eye(4).repeat(2, 1, 1)
+    wasd[1, 2, 3] = LINGBOT_CONTROLLER_TRANSLATION_UNIT
+    wasd_origin = build_plucker_embedding(_trajectory(wasd), **kwargs)[1, :3, 0, 0]
+    torch.testing.assert_close(wasd_origin, torch.tensor([0.0, 0.0, 1.0]))
 
 
 def test_build_plucker_embedding_interpolates_raw_poses_before_framewise_conversion() -> None:
diff --git a/tests/diffusion/models/lingbot_world/test_lingbot_world_transformer.py b/tests/diffusion/models/lingbot_world/test_lingbot_world_transformer.py
index 96c0b37f1..e11c34e35 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_transformer.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_transformer.py
@@ -837,6 +837,9 @@ def _rollout(model, mode, dtype, batch):
             frames_per_block=_FRAMES,
             max_scratch_tokens_per_branch=_FRAMES * _TOKENS_PER_FRAME,
             cross_attention_lengths={"text": 5},
+            # Cross-attention keeps every local head on every SP rank, so its pool is wider than the
+            # self-attention share above.
+            cross_attention_kv_heads={"text": model.blocks[0].cross_attn.num_local_heads},
             device=device,
         )
         state = ARDiffusionKVState(kv, "numeric", {"main": kv.begin_request("numeric")}, num_layers=_LAYERS)
@@ -896,7 +899,6 @@ def _worker(rank, world_size, sp_size, tp_size, mode, dtype, batch, rendezvous):
     from vllm_omni.diffusion.distributed.parallel_state import (
         destroy_distributed_env,
         destroy_model_parallel,
-        get_sp_group,
         init_distributed_environment,
         initialize_model_parallel,
     )
@@ -948,11 +950,10 @@ def _worker(rank, world_size, sp_size, tp_size, mode, dtype, batch, rendezvous):
                         bound = 1e-5 if dtype == torch.float32 else 1e-2
                         error = (result - expected).double().norm() / expected.double().norm()
                         assert error <= bound, f"rank={rank}, TP{tp} SP{sp}: relative L2 {error.item():.3g} > {bound}"
-                        local_heads = _HEADS // tp // sp
-                        first = (
-                            get_tensor_model_parallel_rank() * (_HEADS // tp)
-                            + get_sp_group().ulysses_rank * local_heads
-                        )
+                        # Cross-attention K/V is replicated across the Ulysses group, not split over it, so
+                        # every SP rank holds its whole TP shard of heads. Only TP slices the cache now.
+                        local_heads = _HEADS // tp
+                        first = get_tensor_model_parallel_rank() * local_heads
                         for (k, v), (ek, ev) in zip(cross, expected_cross, strict=True):
                             tolerance = 1e-5 if dtype == torch.float32 else 2e-2
                             torch.testing.assert_close(
@@ -1033,3 +1034,56 @@ def test_temporal_rope_extension_keeps_spatial_limit():
         model._rotary_embedding(
             frames=3, height=17, width=1, start_frame=16, dtype=torch.float32, device=torch.device("cpu")
         )
+
+
+@pytest.mark.cpu
+def test_the_camera_injector_runs_once_per_held_cache_and_gives_the_same_output() -> None:
+    """Two forwards sharing one caller-held cache: the injector runs once per block, outputs unchanged."""
+    module = attention_tests._load_module()
+    model = _tiny_model(module, num_layers=2).eval()
+    hidden_states = torch.randn(1, 36, 1, 4, 4)
+    timestep = torch.tensor([1.0])
+    encoder_hidden_states = torch.randn(1, 3, 6)
+    camera_hidden_states = torch.randn(1, 6 * 8 * 8, 1, 4, 4)
+
+    def run(cache, camera_cache=None):
+        return model(
+            hidden_states,
+            timestep,
+            encoder_hidden_states,
+            camera_hidden_states,
+            cache=cache,
+            start_frame=0,
+            update_cache=False,
+            camera_modulation_cache=camera_cache,
+        )
+
+    # Baseline: no cache, so every forward rebuilds the injector in every block.
+    uncached_first = run(_cache(module, model))
+    uncached_second = run(_cache(module, model))
+    injector_calls = [attention_tests._record_outputs(block.cam_injector_layer1) for block in model.blocks]
+    held = module.CameraModulationCache()
+    cached_first = run(_cache(module, model), held)
+    cached_second = run(_cache(module, model), held)
+
+    # One build per block for both forwards, instead of one per block per forward.
+    assert [len(calls) for calls in injector_calls] == [1, 1]
+    torch.testing.assert_close(cached_first, uncached_first, rtol=0, atol=0)
+    torch.testing.assert_close(cached_second, uncached_second, rtol=0, atol=0)
+
+
+@pytest.mark.cpu
+def test_timestep_projection_is_staged_into_one_static_buffer_per_shape() -> None:
+    """Two forwards' projections land in the same buffer; the blocks never see the fresh per-forward tensor."""
+    module = attention_tests._load_module()
+    model = _tiny_model(module, num_layers=1).eval()
+    first = torch.randn(1, 8, 6, model.dim)
+    second = torch.randn(1, 8, 6, model.dim)
+
+    staged_first = model._stage_timestep_projection(first)
+    assert staged_first is not first and torch.equal(staged_first, first)
+    staged_second = model._stage_timestep_projection(second)
+    assert staged_second is staged_first and torch.equal(staged_second, second)
+    # A different shape gets its own buffer; the first one is kept.
+    other = model._stage_timestep_projection(torch.randn(1, 4, 6, model.dim))
+    assert other is not staged_first and len(model._timestep_projection_buffers) == 2
diff --git a/tests/diffusion/models/lingbot_world/test_pipeline_lingbot_world.py b/tests/diffusion/models/lingbot_world/test_pipeline_lingbot_world.py
index 9d5e958c5..1ccc7aadc 100644
--- a/tests/diffusion/models/lingbot_world/test_pipeline_lingbot_world.py
+++ b/tests/diffusion/models/lingbot_world/test_pipeline_lingbot_world.py
@@ -4,11 +4,13 @@
 from __future__ import annotations
 
 import gc
+import os
 import weakref
 from pathlib import Path
 from threading import Lock
 from types import SimpleNamespace
 
+import numpy as np
 import pytest
 import torch
 from diffusers.utils.torch_utils import randn_tensor as _diffusers_randn_tensor
@@ -18,6 +20,7 @@ from torch import nn
 import vllm_omni.diffusion.models.lingbot_world.dmd_block as lingbot_dmd_block
 import vllm_omni.diffusion.models.lingbot_world.pipeline as lingbot_pipeline
 from tests.diffusion.models.wan2_2.conftest import noop_progress_bar
+from vllm_omni.diffusion.interaction.modality_handlers.camera import CameraSession
 from vllm_omni.diffusion.models.interface import SupportsStepExecution, supports_step_execution
 from vllm_omni.diffusion.models.lingbot_world.actions import (
     integrate_lingbot_camera_actions,
@@ -28,6 +31,7 @@ from vllm_omni.diffusion.models.lingbot_world.camera import (
 )
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.utils import StepRequestState
+from vllm_omni.experimental.ar_diffusion.capability import supports_chunk_step_grouping
 from vllm_omni.experimental.ar_diffusion.tick_protocol import (
     ARDiffusionControlInput,
     ARDiffusionTickRequest,
@@ -126,6 +130,10 @@ class _RecordingTransformer(nn.Module):
             sink_size=3,
         )
         self.blocks = nn.ModuleList([nn.Identity(), nn.Identity()])
+        for block in self.blocks:
+            # The spec reads head geometry from both attentions; cross-attention keeps every local head.
+            block.self_attn = SimpleNamespace(num_sp_heads=2)
+            block.cross_attn = SimpleNamespace(num_local_heads=2)
         self.calls: list[dict] = []
         self.cache_allocations: list[dict] = []
         self.raise_on_call = raise_on_call
@@ -145,6 +153,7 @@ class _RecordingTransformer(nn.Module):
             "cache_id": id(kwargs["cache"]),
             "start_frame": kwargs["start_frame"],
             "update_cache": kwargs["update_cache"],
+            "camera_cache": kwargs.get("camera_modulation_cache"),
         }
         self.calls.append(call)
         if self.raise_on_call == len(self.calls):
@@ -411,8 +420,10 @@ def _stub_pipeline_dependencies(monkeypatch: pytest.MonkeyPatch) -> None:
             intrinsics=value.intrinsics[:num_frames],
         )
 
-    def build_plucker_embedding(value, *, height, width, target_height, target_width, device, dtype):
-        del target_height, target_width
+    def build_plucker_embedding(
+        value, *, height, width, target_height, target_width, device, dtype, translation_scale=None
+    ):
+        del target_height, target_width, translation_scale
         frames = value.poses.shape[0]
         data = torch.arange(frames * 6 * height * width, device=device, dtype=torch.float32)
         return data.reshape(frames, 6, height, width).to(dtype=dtype)
@@ -531,14 +542,15 @@ def test_ar_diffusion_capability_uses_transformer_local_head_geometry() -> None:
     assert spec.sink_frames == 3
     assert [(branch.name, branch.local_index) for branch in spec.kv_branches] == [("main", 0)]
     assert spec.cross_attention_lengths == {"text": 512}
-    # One condition block, committed + pending encoder caches, and decoder state.
+    # One condition block, committed + pending encoder caches, the session's
+    # cached prompt embedding (512 tokens x text_dim 8 x fp32), and decoder state.
     # The stub encoder retains 2 RGB frames at 16x16 and 2 feature frames at 2x2.
     encoder_bytes = (2 * 3 * 16 * 16 + 2 * 16 * 2 * 2) * 4
-    assert spec.model_owned_state_bytes_per_session == 960 + 2 * encoder_bytes + 2_421_248
+    assert spec.model_owned_state_bytes_per_session == 960 + 384 + 2 * encoder_bytes + 2_421_248
 
 
 def test_session_admission_accounts_for_the_streaming_decoder_cache() -> None:
-    """Admission includes encoder state even when the decoder cannot stream."""
+    """Admission includes encoder state and the prompt embedding even when the decoder cannot stream."""
     module = _load_pipeline_module()
 
     def spec_pipeline():
@@ -557,13 +569,29 @@ def test_session_admission_accounts_for_the_streaming_decoder_cache() -> None:
     # than the image condition alone could account for.
     assert widened - small > 2_000_000
 
-    # Removing decoder support leaves the condition and both encoder histories.
+    # Removing decoder support leaves the condition, both encoder histories and
+    # the prompt-embedding cache.
     bare = spec_pipeline()
     for attribute in ("decoder", "post_quant_conv"):
         if hasattr(bare.vae, attribute):
             delattr(bare.vae, attribute)
     bare.vae._cached_conv_counts.pop("decoder")
-    assert bare.ar_diffusion_kv_cache_spec().model_owned_state_bytes_per_session == 960 + 2 * 6_656
+    assert bare.ar_diffusion_kv_cache_spec().model_owned_state_bytes_per_session == 960 + 384 + 2 * 6_656
+
+
+@pytest.mark.parametrize("sp_size", [1, 4])
+def test_session_admission_budgets_camera_modulation_per_rank(sp_size: int) -> None:
+    pipeline = _pipeline(_load_pipeline_module())
+    pipeline._ar_height, pipeline._ar_width = 480, 832
+    pipeline.od_config.parallel_config.ulysses_degree = sp_size
+    pipeline.transformer.config.num_layers = 40
+    pipeline.transformer.config.num_attention_heads = 40
+    pipeline.transformer.config.attention_head_dim = 128
+    pipeline.transformer._dtype = torch.bfloat16
+    forty_layers = pipeline.ar_diffusion_kv_cache_spec().model_owned_state_bytes_per_session
+    pipeline.transformer.config.num_layers = 1
+    one_layer = pipeline.ar_diffusion_kv_cache_spec().model_owned_state_bytes_per_session
+    assert forty_layers - one_layer == 2 * 39 * (4680 // sp_size) * 5120 * 2
 
 
 def test_preprocess_materializes_external_inputs_before_worker_execution(tmp_path: Path) -> None:
@@ -1330,10 +1358,34 @@ def test_first_frame_condition_and_camera_fold_match_transformer_contract() -> N
     assert expected_camera.shape == (1, 384, 3, 2, 2)
 
 
-def test_fixed_dmd_transition_and_cache_commit_trace() -> None:
+@pytest.mark.parametrize("value", ["true", "false", 1, 0, None])
+def test_reuse_last_step_kv_rejects_non_boolean_config(value: object) -> None:
+    config = _od_config()
+    config.model_config["lingbot_reuse_last_step_kv"] = value
+    with pytest.raises(ValueError, match="lingbot_reuse_last_step_kv must be a bool"):
+        _pipeline(_load_pipeline_module(), od_config=config)
+
+
+def test_reuse_last_step_kv_is_fixed_per_instance(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("VLLM_OMNI_LINGBOT_REUSE_LAST_STEP_KV", "1")
+    module = _load_pipeline_module()
+    config = _od_config()
+    config.model_config["lingbot_reuse_last_step_kv"] = True
+    reuse = _pipeline(module, od_config=config)
+    default = _pipeline(module)
+    config.model_config["lingbot_reuse_last_step_kv"] = False
+    assert reuse._dmd_blocks.reuse_last_step_kv is True
+    assert default._dmd_blocks.reuse_last_step_kv is False
+    assert reuse._dmd_blocks is reuse._dmd_blocks
+
+
+@pytest.mark.parametrize("reuse_last_step_kv", [False, True])
+def test_fixed_dmd_transition_and_cache_commit_trace(reuse_last_step_kv: bool) -> None:
     module = _load_pipeline_module()
     transformer = _RecordingTransformer()
-    pipeline = _pipeline(module, transformer=transformer)
+    config = _od_config()
+    config.model_config["lingbot_reuse_last_step_kv"] = reuse_last_step_kv
+    pipeline = _pipeline(module, transformer=transformer, od_config=config)
 
     result = pipeline(_request())
 
@@ -1355,14 +1407,18 @@ def test_fixed_dmd_transition_and_cache_commit_trace() -> None:
             current = x0
     torch.testing.assert_close(result.output, current)
 
+    expected_timesteps = [timestep for timestep, _ in warped_schedule]
+    if not reuse_last_step_kv:
+        expected_timesteps.append(0.0)
     torch.testing.assert_close(
-        torch.cat([call["timestep"] for call in transformer.calls]),
-        torch.tensor([*(timestep for timestep, _ in warped_schedule), 0.0]),
+        torch.cat([call["timestep"] for call in transformer.calls]), torch.tensor(expected_timesteps)
     )
-    assert [call["update_cache"] for call in transformer.calls] == [False, False, False, False, True]
-    assert [call["start_frame"] for call in transformer.calls] == [0, 0, 0, 0, 0]
+    commit_flags = [False] * (len(expected_timesteps) - 1) + [True]
+    assert [call["update_cache"] for call in transformer.calls] == commit_flags
+    assert [call["start_frame"] for call in transformer.calls] == [0] * len(expected_timesteps)
     assert len({call["cache_id"] for call in transformer.calls}) == 1
-    torch.testing.assert_close(transformer.calls[-1]["hidden_states"][:, :16], result.output)
+    committed_latent = result.output + warped_schedule[-1][1] if reuse_last_step_kv else result.output
+    torch.testing.assert_close(transformer.calls[-1]["hidden_states"][:, :16], committed_latent)
 
 
 @pytest.mark.parametrize(
@@ -1669,7 +1725,6 @@ def test_typed_ticks_generate_one_global_block_and_return_standard_metadata(
         "applied_event_ids": [1],
     }
     assert pipeline._ar_sessions["world-1"].next_chunk_index == 2
-    assert pipeline._ar_sessions["world-1"].prompt == "enter the snowy valley"
     assert pipeline._ar_sessions["world-1"].camera_tail is not None
     assert pipeline._ar_sessions["world-1"].camera_tail.poses.shape == (1, 4, 4)
     expected_generator = torch.Generator(device="cpu").manual_seed(17)
@@ -1783,6 +1838,7 @@ def test_first_typed_yaw_action_uses_pre_action_identity_anchor(
         target_width=16,
         device=torch.device("cpu"),
         dtype=torch.float32,
+        translation_scale=None,  # None for camera_actions / action_script input (using max-norm)
     )[1:]
 
     assert not torch.equal(action_embedding, neutral_embedding)
@@ -1842,8 +1898,11 @@ def test_typed_ticks_keep_bounded_encoder_state_beyond_ten_chunks(
         pipeline(_request(sampling=sampling))
 
     assert pipeline.vae.encode_inputs == []
-    assert [video.shape[2] for video in pipeline.vae.encoder.inputs] == [1] + [4] * 32
+    # The stub encoder's history settles after its second block; the nine
+    # blocks after that reuse the settled condition without an encode.
+    assert [video.shape[2] for video in pipeline.vae.encoder.inputs] == [1] + [4] * 5
     assert all(torch.count_nonzero(video) == 0 for video in pipeline.vae.encoder.inputs[1:])
+    assert pipeline._ar_sessions["world-1"].condition_fixed_point is not None
     encoder_cache = pipeline._ar_sessions["world-1"].encoder_cache
     assert sum(t.numel() * t.element_size() for t in encoder_cache) == pipeline._condition_encoder_cache_bytes()
     assert pipeline.vae._enc_feat_map == ["module-owned"]
@@ -1939,6 +1998,76 @@ def test_condition_continues_real_causal_vae_beyond_initial_horizon(
     assert pipeline._ar_sessions == {}
 
 
+def test_condition_encoder_stops_at_its_fixed_point_and_restarts_with_the_session(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Once a block returns the history it was given, later blocks reuse the condition without encoding.
+
+    The whole-clip encode is the reference for every block, so reusing the
+    stored condition is only allowed to be a speedup, never a change.
+    """
+    pipeline = _tiny_condition_pipeline(monkeypatch)
+    pipeline._ar_diffusion_kv_state = object()
+    blocks = 12
+    inputs = pipeline._parse_request(_request(sampling=_SamplingParams(num_frames=(blocks * 3 - 1) * 4 + 1)))
+    with torch.inference_mode():
+        expected = pipeline._prepare_condition(inputs, dtype=torch.float32)
+    encoder_calls = []
+    original_encoder = pipeline.vae.encoder.forward
+
+    def encoder(*args, **kwargs):
+        encoder_calls.append(len(seen))
+        return original_encoder(*args, **kwargs)
+
+    seen: list[torch.Tensor] = []
+
+    def generate_block(**kwargs):
+        index = len(seen) % blocks
+        torch.testing.assert_close(
+            kwargs["condition"], expected[:, :, index * 3 : (index + 1) * 3], rtol=1e-6, atol=1e-6
+        )
+        seen.append(kwargs["condition"])
+        return torch.zeros_like(kwargs["condition"][:, :16])
+
+    monkeypatch.setattr(pipeline.vae.encoder, "forward", encoder)
+    monkeypatch.setattr(pipeline, "_generate_block", generate_block)
+
+    def tick(index):
+        pipeline(_request(sampling=_SamplingParams(extra_args=_tick_extra_args(chunk_index=index))))
+
+    settled_at = None
+    for index in range(blocks):
+        tick(index)
+        state = pipeline._ar_sessions["world-1"]
+        if settled_at is None and state.condition_fixed_point is not None:
+            settled_at = index
+        assert state.pending_encoder_cache is None and state.encoder_cache is not None
+    assert settled_at is not None and 0 < settled_at < blocks - 1, settled_at
+    # Three encoder passes per encoded block, none once the fixed point is stored.
+    assert encoder_calls == [index for index in range(settled_at + 1) for _ in range(3)]
+    # The stored condition is the session's own, not shared with the callers.
+    assert all(seen[settled_at] is not later for later in seen[settled_at + 1 :])
+
+    # A session restarted from chunk 0 encodes again from the source image.
+    pipeline.reset_ar_diffusion_session("world-1")
+    tick(0)
+    state = pipeline._ar_sessions["world-1"]
+    assert state.condition_fixed_point is None
+    assert encoder_calls[-3:] == [blocks] * 3
+
+
+def test_condition_encoder_fixed_point_is_released_with_the_session(monkeypatch: pytest.MonkeyPatch) -> None:
+    pipeline = _tiny_condition_pipeline(monkeypatch)
+    pipeline._ar_diffusion_kv_state = object()
+    monkeypatch.setattr(pipeline, "_generate_block", lambda **kwargs: torch.zeros_like(kwargs["condition"][:, :16]))
+    for index in range(8):
+        pipeline(_request(sampling=_SamplingParams(extra_args=_tick_extra_args(chunk_index=index))))
+    state = pipeline._ar_sessions["world-1"]
+    assert state.condition_fixed_point is not None
+    pipeline.close_ar_diffusion_session("world-1")
+    assert state.condition_fixed_point is None and state.encoder_cache is None
+
+
 def test_condition_encoder_interleaving_retry_and_reset(monkeypatch: pytest.MonkeyPatch) -> None:
     pipeline = _tiny_condition_pipeline(monkeypatch)
     pipeline._ar_diffusion_kv_state = object()
@@ -2015,6 +2144,7 @@ def test_stepwise_failed_chunk_releases_pending_encoder_on_close(monkeypatch: py
     transformer.raise_on_call = 1
     with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
         pipeline.prepare_encode(state)
+        pipeline.prepare_next_chunk(state)
         session = pipeline._ar_sessions[state.request_id]
         assert session.encoder_cache is None and session.pending_encoder_cache is not None
         with pytest.raises(RuntimeError, match="forced transformer failure"):
@@ -2037,6 +2167,7 @@ def test_stateful_condition_rejects_tiled_encoder(monkeypatch: pytest.MonkeyPatc
             state = _stepwise_state()
             with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
                 pipeline.prepare_encode(state)
+                pipeline.prepare_next_chunk(state)
     assert pipeline.vae.encoder.inputs == []
     assert all(s.encoder_cache is None and s.pending_encoder_cache is None for s in pipeline._ar_sessions.values())
 
@@ -2168,11 +2299,14 @@ def _stepwise_state(
 def _run_stepwise(pipeline, state):
     outputs = []
     pipeline.prepare_encode(state)
+    pipeline.prepare_next_chunk(state)
     while not state.request_denoise_completed:
         noise = pipeline.denoise_step(None, states=[state])
         pipeline.step_scheduler(state, noise)
         if state.chunk_denoise_completed:
             outputs.append(pipeline.post_decode(state))
+            if not state.request_denoise_completed:
+                pipeline.prepare_next_chunk(state)
     return outputs
 
 
@@ -2186,6 +2320,7 @@ def _stepwise_chunks(pipeline, state, ar_state):
     """
     with pipeline.bind_ar_diffusion_state(state.request_id, ar_state):
         pipeline.prepare_encode(state)
+        pipeline.prepare_next_chunk(state)
     while not state.request_denoise_completed:
         output = None
         with pipeline.bind_ar_diffusion_state(state.request_id, ar_state):
@@ -2193,10 +2328,46 @@ def _stepwise_chunks(pipeline, state, ar_state):
             pipeline.step_scheduler(state, noise)
             if state.chunk_denoise_completed:
                 output = pipeline.post_decode(state)
+                if not state.request_denoise_completed:
+                    pipeline.prepare_next_chunk(state)
         if output is not None:
             yield output
 
 
+def test_stepwise_block_shares_one_camera_cache_across_its_five_forwards() -> None:
+    """The four probes and the commit of one stepwise block reuse one camera cache; the next block gets its own.
+
+    Request mode creates one cache per loop; the stepwise path's forwards are
+    separate scheduler steps, so the pipeline holds the block's cache and
+    passes it to each one.
+    """
+    module = _load_pipeline_module()
+    transformer = _RecordingTransformer()
+    pipeline = _pipeline(module, transformer=transformer)
+    pipeline._ar_height = 16
+    pipeline._ar_width = 16
+    state = _stepwise_state(num_frames=21)
+    state.sampling.output_type = "latent"
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+        outputs = _run_stepwise(pipeline, state)
+
+    assert len(outputs) == 2 and len(transformer.calls) == 10
+    caches = [call["camera_cache"] for call in transformer.calls]
+    assert all(c is not None for c in caches)
+    assert len({id(c) for c in caches[:5]}) == 1 and len({id(c) for c in caches[5:]}) == 1
+    assert caches[0] is not caches[5]
+    # The block's cache does not outlive its commit.
+    assert "camera_cache" not in state.extra
+
+
+def test_pipeline_declares_chunk_step_grouping() -> None:
+    """A realtime block's probes and commit may run without a scheduler cycle between them."""
+    module = _load_pipeline_module()
+    assert module.LingBotWorldCausalDMDPipeline.supports_chunk_step_grouping is True
+    assert supports_chunk_step_grouping(_pipeline(module))
+
+
 def test_pipeline_declares_step_execution_support() -> None:
     module = _load_pipeline_module()
     pipeline = _pipeline(module)
@@ -2246,10 +2417,13 @@ def test_forward_rejects_a_stepwise_camera_action_script(extra_args) -> None:
         pipeline(_request(sampling=sampling))
 
 
-def test_stepwise_progress_metadata_and_commit_trace() -> None:
+@pytest.mark.parametrize("reuse_last_step_kv", [False, True])
+def test_stepwise_progress_metadata_and_commit_trace(reuse_last_step_kv: bool) -> None:
     module = _load_pipeline_module()
     transformer = _RecordingTransformer()
-    pipeline = _pipeline(module, transformer=transformer)
+    config = _od_config()
+    config.model_config["lingbot_reuse_last_step_kv"] = reuse_last_step_kv
+    pipeline = _pipeline(module, transformer=transformer, od_config=config)
     pipeline._ar_height = 16
     pipeline._ar_width = 16
     state = _stepwise_state(num_frames=21)
@@ -2263,8 +2437,9 @@ def test_stepwise_progress_metadata_and_commit_trace() -> None:
     assert [output.chunk_index for output in outputs] == [0, 1]
     assert all(output.total_chunks == 2 for output in outputs)
     assert outputs[-1].finished is True
-    assert [call["update_cache"] for call in transformer.calls] == [False, False, False, False, True] * 2
-    assert [call["start_frame"] for call in transformer.calls] == [0] * 5 + [3] * 5
+    calls_per_chunk = 4 if reuse_last_step_kv else 5
+    assert [call["update_cache"] for call in transformer.calls] == ([False] * (calls_per_chunk - 1) + [True]) * 2
+    assert [call["start_frame"] for call in transformer.calls] == [0] * calls_per_chunk + [3] * calls_per_chunk
     assert fake.commits == ["main", "main"]
     for chunk_index, output in enumerate(outputs):
         metadata = output.output["metadata"]["ar_diffusion"]
@@ -2325,7 +2500,10 @@ def test_stepwise_matches_tick_transformer_trace_and_latents(num_chunks) -> None
         torch.testing.assert_close(step_call["camera_hidden_states"], tick_call["camera_hidden_states"])
     assert stepwise_state.extra["condition"].shape[2] == 3
     assert pipeline.vae.encode_inputs == []
-    assert [video.shape[2] for video in pipeline.vae.encoder.inputs] == ([1] + [4] * (num_chunks * 3 - 1)) * 2
+    # The stub encoder's history settles after its second block, so both
+    # modes encode two blocks and reuse the settled condition after that.
+    encoded_blocks = min(num_chunks, 2)
+    assert [video.shape[2] for video in pipeline.vae.encoder.inputs] == ([1] + [4] * (encoded_blocks * 3 - 1)) * 2
     assert stepwise_fake.commits == ["main"] * num_chunks
     assert len(stepwise_outputs) == num_chunks and stepwise_outputs[-1].finished
     assert pipeline.vae.decode_inputs == []
@@ -2394,21 +2572,16 @@ def test_stepwise_emits_latents_without_touching_the_vae() -> None:
     assert pipeline.vae.decode_inputs == []
 
 
-def _capture_video_processor(monkeypatch) -> list[tuple[tuple[int, ...], str]]:
-    """Record what reaches postprocess_video, and name each chunk's output."""
-    import diffusers.video_processor as video_processor_module
+def _capture_pixel_conversion(monkeypatch) -> list[tuple[int, ...]]:
+    """Record each decoded block reaching the uint8 conversion, and name its output."""
+    module = _load_pipeline_module()
+    processed: list[tuple[int, ...]] = []
 
-    processed: list[tuple[tuple[int, ...], str]] = []
+    def uint8_frames(video):
+        processed.append(tuple(video.shape))
+        return f"frames-{len(processed)}"
 
-    class VideoProcessor:
-        def __init__(self, *, vae_scale_factor):
-            assert vae_scale_factor == 8
-
-        def postprocess_video(self, video, *, output_type):
-            processed.append((tuple(video.shape), output_type))
-            return f"frames-{len(processed)}"
-
-    monkeypatch.setattr(video_processor_module, "VideoProcessor", VideoProcessor)
+    monkeypatch.setattr(module, "_uint8_frames", uint8_frames)
     return processed
 
 
@@ -2422,7 +2595,7 @@ def _streaming_pipeline(module):
 def test_stepwise_decodes_each_chunk_for_streaming_consumers(monkeypatch) -> None:
     """A non-latent request must stream pixels under the primary "video" key."""
     module = _load_pipeline_module()
-    processed = _capture_video_processor(monkeypatch)
+    processed = _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     state = _stepwise_state(num_frames=21)
     state.sampling.output_type = "np"
@@ -2431,7 +2604,7 @@ def test_stepwise_decodes_each_chunk_for_streaming_consumers(monkeypatch) -> Non
     with pipeline.bind_ar_diffusion_state(state.request_id, fake):
         outputs = _run_stepwise(pipeline, state)
 
-    assert [output_type for _, output_type in processed] == ["np", "np"]
+    assert processed == [(1, 3, 9, 16, 16), (1, 3, 12, 16, 16)]
     assert [output.output["payload"] for output in outputs] == [{"video": "frames-1"}, {"video": "frames-2"}]
     # Identity metadata survives the switch to pixel output.
     assert [output.output["metadata"]["ar_diffusion"]["chunk_index"] for output in outputs] == [0, 1]
@@ -2445,7 +2618,7 @@ def test_stepwise_chunks_continue_one_sessions_temporal_decode(monkeypatch) -> N
     the same latents would: 9 frames, then 12.
     """
     module = _load_pipeline_module()
-    processed = _capture_video_processor(monkeypatch)
+    processed = _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     state = _stepwise_state(num_frames=21)
     state.sampling.output_type = "np"
@@ -2454,7 +2627,7 @@ def test_stepwise_chunks_continue_one_sessions_temporal_decode(monkeypatch) -> N
     with pipeline.bind_ar_diffusion_state(state.request_id, fake):
         _run_stepwise(pipeline, state)
 
-    assert [shape for shape, _ in processed] == [(1, 3, 9, 16, 16), (1, 3, 12, 16, 16)]
+    assert processed == [(1, 3, 9, 16, 16), (1, 3, 12, 16, 16)]
     # One opening frame for the session, not one per chunk.
     assert pipeline.vae.decoder.first_chunk_flags == [True] + [False] * 5
     # The whole-clip decode path is not involved, and the module-owned cache
@@ -2463,10 +2636,68 @@ def test_stepwise_chunks_continue_one_sessions_temporal_decode(monkeypatch) -> N
     assert pipeline.vae._feat_map == ["module-owned"]
 
 
+def test_prepare_next_chunk_rejects_live_camera_with_scripted_paths() -> None:
+    """Scripted/cached camera must not silently ignore mid-generation camera events."""
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module, transformer=_RecordingTransformer())
+    pipeline._ar_height = 16
+    pipeline._ar_width = 16
+
+    # Scenario 1, input pre-scripted camera trajectory via action_script
+    state = _stepwise_state(num_frames=21)
+    with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+        pipeline.prepare_encode(state)
+        assert state.extra.get("camera_action_script") is not None
+        state.interaction_sessions["camera"] = CameraSession(has_received_input=True)
+        with pytest.raises(ValueError, match="camera_action_script"):
+            pipeline.prepare_next_chunk(state)
+
+    # Scenario 2, input pre-scripted camera trajectory via embedding cache
+    poses = torch.eye(4).repeat(21, 1, 1)
+    trajectory = _CameraTrajectory(
+        poses=poses,
+        intrinsics=torch.tensor([[100.0, 100.0, 8.0, 8.0]]).repeat(21, 1),
+    )
+    state = _stepwise_state(num_frames=21)
+    state.sampling.extra_args["_lingbot_camera_trajectory"] = trajectory
+    state.sampling.extra_args.pop("_lingbot_camera_action_script")
+    with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):  # pyright: ignore[reportArgumentType]
+        pipeline.prepare_encode(state)
+        assert state.extra.get("camera_embedding_cache") is not None
+        state.interaction_sessions["camera"] = CameraSession(has_received_input=True)
+        with pytest.raises(ValueError, match="camera_embedding_cache"):
+            pipeline.prepare_next_chunk(state)
+
+
+def test_peek_chunk_media_matches_streaming_decoder_frame_counts(monkeypatch) -> None:
+    """Camera timelines must track the streaming decoder's 9-then-12 media counts."""
+    module = _load_pipeline_module()
+    _capture_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
+    state = _stepwise_state(num_frames=21)
+    state.sampling.output_type = "np"
+    state.sampling.fps = 16.0
+    fake = _FakeARState(state.request_id)
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, fake):
+        pipeline.prepare_encode(state)
+        first = pipeline.peek_chunk_media(state)
+        assert (first.num_media_frames, first.fps, first.num_latent_frames) == (9, 16.0, 3)
+
+        pipeline.prepare_next_chunk(state)
+        while not state.chunk_denoise_completed:
+            noise = pipeline.denoise_step(None, states=[state])
+            pipeline.step_scheduler(state, noise)
+        pipeline.post_decode(state)
+
+        second = pipeline.peek_chunk_media(state)
+        assert (second.num_media_frames, second.fps, second.num_latent_frames) == (12, 16.0, 3)
+
+
 def test_streaming_decode_state_is_owned_by_the_session(monkeypatch) -> None:
     """Decoder state is keyed by request id and released with the AR session."""
     module = _load_pipeline_module()
-    _capture_video_processor(monkeypatch)
+    _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     state = _stepwise_state(request_id="req-stream", num_frames=21)
     state.sampling.output_type = "np"
@@ -2490,7 +2721,7 @@ def test_streaming_decode_state_is_owned_by_the_session(monkeypatch) -> None:
 def test_streaming_decode_state_is_dropped_on_session_reset(monkeypatch) -> None:
     """A reset session must not resume the temporal context it just abandoned."""
     module = _load_pipeline_module()
-    _capture_video_processor(monkeypatch)
+    _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     state = _stepwise_state(request_id="req-reset", num_frames=21)
     state.sampling.output_type = "np"
@@ -2514,7 +2745,7 @@ def test_streaming_decode_keeps_interleaved_sessions_isolated(monkeypatch) -> No
     interleaving the scheduler actually produces.
     """
     module = _load_pipeline_module()
-    processed = _capture_video_processor(monkeypatch)
+    processed = _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     states = []
     for request_id in ("req-a", "req-b"):
@@ -2547,7 +2778,7 @@ def test_streaming_decode_keeps_interleaved_sessions_isolated(monkeypatch) -> No
     assert pipeline.vae.decoder.first_chunk_flags == (
         [True, False, False] + [True, False, False] + [False] * 3 + [False] * 3
     )
-    assert [shape for shape, _ in processed] == [
+    assert processed == [
         (1, 3, 9, 16, 16),
         (1, 3, 9, 16, 16),
         (1, 3, 12, 16, 16),
@@ -2558,7 +2789,7 @@ def test_streaming_decode_keeps_interleaved_sessions_isolated(monkeypatch) -> No
 def test_streaming_decode_failure_drops_the_half_advanced_cache(monkeypatch) -> None:
     """A failed chunk must not leave a cache a later chunk would continue from."""
     module = _load_pipeline_module()
-    _capture_video_processor(monkeypatch)
+    _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     state = _stepwise_state(request_id="req-boom", num_frames=21)
     state.sampling.output_type = "np"
@@ -2592,13 +2823,14 @@ def test_streaming_decode_receives_rescaled_latents(monkeypatch) -> None:
     never reaches, so this asserts on what ``post_quant_conv`` received.
     """
     module = _load_pipeline_module()
-    _capture_video_processor(monkeypatch)
+    _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     state = _stepwise_state(num_frames=21)
     state.sampling.output_type = "np"
 
     with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
         pipeline.prepare_encode(state)
+        pipeline.prepare_next_chunk(state)
         while not state.chunk_denoise_completed:
             pipeline.step_scheduler(state, pipeline.denoise_step(None, states=[state]))
         model_space = state.latents.clone()
@@ -2624,7 +2856,7 @@ def test_streaming_decode_is_reported_to_the_profiler(monkeypatch) -> None:
     perf regression in the streaming decoder would be too.
     """
     module = _load_pipeline_module()
-    _capture_video_processor(monkeypatch)
+    _capture_pixel_conversion(monkeypatch)
     pipeline = _pipeline(
         module,
         transformer=_RecordingTransformer(),
@@ -2652,21 +2884,18 @@ def test_streaming_decode_is_reported_to_the_profiler(monkeypatch) -> None:
 def test_streaming_decode_falls_back_when_the_vae_would_tile(monkeypatch) -> None:
     """Tiled decode drives its own cache, so a tiling shape keeps per-chunk decode."""
     module = _load_pipeline_module()
-    processed = _capture_video_processor(monkeypatch)
+    processed = _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     # A latent of 2x2 exceeds a one-latent-cell tile, so vae.decode would tile.
     _enable_vae_tiling(pipeline, tile_sample_min=8)
-    outputs = [
-        pipeline._decode_chunk_to_pixels(torch.zeros(1, 16, 3, 2, 2), output_type="np", session_id="tiled")
-        for _ in range(2)
-    ]
+    outputs = [pipeline._decode_chunk_to_pixels(torch.zeros(1, 16, 3, 2, 2), session_id="tiled") for _ in range(2)]
 
     # One whole-clip decode per AR block, each seeing only that block's frames.
     assert [tuple(latents.shape) for latents in pipeline.vae.decode_inputs] == [(1, 16, 3, 2, 2)] * 2
     assert pipeline.vae.decoder.first_chunk_flags == []
     assert pipeline._streaming_decode_states == {}
     # Nine frames per chunk instead of 9 then 12: the frame loss being removed.
-    assert [shape for shape, _ in processed] == [(1, 3, 9, 16, 16), (1, 3, 9, 16, 16)]
+    assert processed == [(1, 3, 9, 16, 16), (1, 3, 9, 16, 16)]
     assert outputs == ["frames-1", "frames-2"]
 
 
@@ -2678,7 +2907,7 @@ def test_streaming_decode_survives_tiling_enabled_below_the_tile_threshold(monke
     on a configuration that would never have tiled.
     """
     module = _load_pipeline_module()
-    processed = _capture_video_processor(monkeypatch)
+    processed = _capture_pixel_conversion(monkeypatch)
     pipeline = _streaming_pipeline(module)
     # A 2x2 latent is within a tile this size, so vae.decode would not tile.
     _enable_vae_tiling(pipeline, tile_sample_min=256)
@@ -2690,7 +2919,7 @@ def test_streaming_decode_survives_tiling_enabled_below_the_tile_threshold(monke
 
     assert pipeline.vae.decode_inputs == []
     assert pipeline.vae.decoder.first_chunk_flags == [True] + [False] * 5
-    assert [shape for shape, _ in processed] == [(1, 3, 9, 16, 16), (1, 3, 12, 16, 16)]
+    assert processed == [(1, 3, 9, 16, 16), (1, 3, 12, 16, 16)]
 
 
 def test_registry_and_model_exports_resolve_official_pipeline_class_name() -> None:
@@ -2833,3 +3062,193 @@ def test_stepwise_requests_with_the_same_prompt_share_one_encode() -> None:
 
     assert encoded == ["move through the room"]
     assert states[0].prompt_embeds is states[1].prompt_embeds
+
+
+def test_session_text_caches_publish_key_only_after_a_successful_build() -> None:
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module)
+    state = module._LingBotARSessionState()
+    invalidations: list[bool] = []
+    fail_next = {"raise": False}
+
+    def fake_text_caches(prompt_embeds, *, invalidate):
+        invalidations.append(invalidate)
+        if fail_next["raise"]:
+            fail_next["raise"] = False
+            raise RuntimeError("injected failure inside _ar_text_caches")
+        return ["caches"]
+
+    pipeline._ar_text_caches = fake_text_caches
+    embeds = torch.ones(1, 512, 8)
+    caches = lambda prompt, length=512, e=embeds: pipeline._session_text_caches(  # noqa: E731
+        e, prompt=prompt, max_sequence_length=length, session_state=state
+    )
+
+    # First build of a session: runner state is empty -> no invalidation, key published.
+    caches("A")
+    assert invalidations == [False] and state.text_cache_key == ("A", 512, str(embeds.dtype))
+    assert state.text_cache_dirty is False
+    # Same inputs: reuse without invalidation.
+    caches("A")
+    assert invalidations == [False, False]
+    # Regression (Codex review): B's build fails after invalidating -> no key is
+    # left behind, so retrying A must invalidate again instead of consuming
+    # partial/mixed K/V.
+    fail_next["raise"] = True
+    with pytest.raises(RuntimeError, match="injected failure"):
+        caches("B")
+    assert state.text_cache_key is None and state.text_cache_dirty is True
+    caches("A")
+    assert invalidations[-2:] == [True, True] and state.text_cache_key == ("A", 512, str(embeds.dtype))
+    assert state.text_cache_dirty is False
+    # The key covers every embedding-defining input: same text, other length or dtype -> rebuild.
+    caches("A", length=256)
+    caches("A", e=embeds.to(torch.bfloat16))
+    assert invalidations[-2:] == [True, True]
+
+
+# ---------------------------------------------------------------------------
+# a source image is decoded once while the file behind it is unchanged
+# ---------------------------------------------------------------------------
+
+
+def _write_png(path, colour=(10, 20, 30)):
+    Image.new("RGB", (64, 64), colour).save(path)
+    return path
+
+
+def _counting_decode(module):
+    """Replace the file decode with a counter, so the tests measure decodes rather than pixels."""
+    decoded: list[str] = []
+    original = module._decode_source_image_file
+
+    def decode(path):
+        decoded.append(os.fspath(path))
+        return Image.new("RGB", (64, 64), (1, 2, 3))
+
+    module._decode_source_image_file = decode
+    return decoded, original
+
+
+def test_the_same_source_image_is_decoded_once(tmp_path: Path) -> None:
+    module = _load_pipeline_module()
+    module._decode_source_image_fingerprinted.cache_clear()
+    path = _write_png(tmp_path / "frame.png")
+    decoded, original = _counting_decode(module)
+    try:
+        first = module._load_source_image(path)
+        second = module._load_source_image(path)
+        assert decoded == [os.fspath(os.path.realpath(path))] or len(decoded) == 1
+        # Every caller owns its copy: mutating one must not reach the next caller or the cache.
+        assert first is not second
+        first.putpixel((0, 0), (255, 255, 255))
+        assert module._load_source_image(path).getpixel((0, 0)) == (1, 2, 3)
+        assert len(decoded) == 1
+    finally:
+        module._decode_source_image_file = original
+        module._decode_source_image_fingerprinted.cache_clear()
+
+
+def test_a_rewritten_source_image_is_decoded_again(tmp_path: Path) -> None:
+    module = _load_pipeline_module()
+    module._decode_source_image_fingerprinted.cache_clear()
+    path = _write_png(tmp_path / "frame.png")
+    decoded, original = _counting_decode(module)
+    try:
+        module._load_source_image(path)
+        module._load_source_image(path)
+        assert len(decoded) == 1
+        # Same path, different bytes: the mtime/size in the key must force a fresh decode.
+        os.utime(path, ns=(0, 0))
+        _write_png(path, colour=(200, 100, 50))
+        module._load_source_image(path)
+        assert len(decoded) == 2
+    finally:
+        module._decode_source_image_file = original
+        module._decode_source_image_fingerprinted.cache_clear()
+
+
+def test_an_image_rewritten_during_the_decode_is_never_cached(tmp_path: Path) -> None:
+    module = _load_pipeline_module()
+    module._decode_source_image_fingerprinted.cache_clear()
+    path = _write_png(tmp_path / "frame.png")
+    decoded: list[str] = []
+    original = module._decode_source_image_file
+
+    def decode_then_rewrite(p):
+        decoded.append(os.fspath(p))
+        _write_png(path, colour=(len(decoded), 0, 0))
+        os.utime(path, ns=(len(decoded) * 1_000_000, len(decoded) * 1_000_000))
+        return Image.new("RGB", (64, 64), (1, 2, 3))
+
+    module._decode_source_image_file = decode_then_rewrite
+    try:
+        module._load_source_image(path)
+        # The entry is keyed by the fingerprint taken before the decode, which the rewrite invalidated: the
+        # next call must decode again rather than serve the image that was decoded mid-rewrite.
+        module._load_source_image(path)
+        assert len(decoded) == 2
+    finally:
+        module._decode_source_image_file = original
+        module._decode_source_image_fingerprinted.cache_clear()
+
+
+def test_an_unstattable_path_keeps_upstream_validation(tmp_path: Path) -> None:
+    module = _load_pipeline_module()
+    module._decode_source_image_fingerprinted.cache_clear()
+    missing = tmp_path / "does-not-exist.png"
+    # The uncached path owns the error contract; caching must not change which exception a caller sees.
+    with pytest.raises(ValueError):
+        module._load_source_image(missing)
+    assert module._decode_source_image_fingerprinted.cache_info().currsize == 0
+
+
+def test_the_text_cache_is_sized_by_cross_attention_heads_not_the_self_attention_share() -> None:
+    """Cross-attention replicates heads per rank, so its pool must not inherit the self-attention head count."""
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module)
+    pipeline.transformer.blocks[0].self_attn = SimpleNamespace(num_sp_heads=1)
+    pipeline.transformer.blocks[0].cross_attn = SimpleNamespace(num_local_heads=4)
+
+    spec = pipeline.ar_diffusion_kv_cache_spec()
+
+    assert spec.num_kv_heads == 1
+    assert spec.cross_attention_kv_heads == {"text": 4}
+    assert spec.cross_attention_lengths == {"text": 512}
+
+
+@pytest.mark.parametrize("output_type", ["np", "pil"])
+def test_streamed_chunk_is_uint8_frames_whatever_pixel_output_type_was_asked(monkeypatch, output_type) -> None:
+    """A realtime tick delivers (F, H, W, 3) uint8 for every pixel output type; only latent differs."""
+    module = _load_pipeline_module()
+    pipeline = _streaming_pipeline(module)
+    state = _stepwise_state(num_frames=21)
+    state.sampling.output_type = output_type
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+        outputs = _run_stepwise(pipeline, state)
+
+    videos = [output.output["payload"]["video"] for output in outputs]
+    assert [type(video) for video in videos] == [np.ndarray, np.ndarray]
+    assert [video.dtype for video in videos] == [np.uint8, np.uint8]
+    assert [video.shape for video in videos] == [(9, 16, 16, 3), (12, 16, 16, 3)]
+
+
+def test_uint8_frames_match_the_pil_conversion_byte_for_byte() -> None:
+    """The device-side conversion is the PIL path's arithmetic, so the bytes are the same."""
+    from diffusers.video_processor import VideoProcessor
+
+    module = _load_pipeline_module()
+    generator = torch.Generator().manual_seed(7)
+    # Cover the clamp on both sides and values that sit exactly on rounding edges.
+    video = torch.rand(1, 3, 5, 8, 8, generator=generator) * 2.4 - 1.2
+    video[0, :, 0, 0, :4] = torch.tensor([-1.0, 1.0, 0.0, 1 / 255 - 1.0])
+
+    reference = VideoProcessor(vae_scale_factor=8).postprocess_video(video, output_type="pil")[0]
+    expected = np.stack([np.asarray(frame) for frame in reference])
+
+    frames = module._uint8_frames(video)
+
+    assert frames.dtype == np.uint8 and frames.shape == (5, 8, 8, 3)
+    assert frames.flags["C_CONTIGUOUS"]
+    np.testing.assert_array_equal(frames, expected)
diff --git a/tests/diffusion/models/longcat_image/test_longcat_image_transformer.py b/tests/diffusion/models/longcat_image/test_longcat_image_transformer.py
new file mode 100644
index 000000000..51cedbb8f
--- /dev/null
+++ b/tests/diffusion/models/longcat_image/test_longcat_image_transformer.py
@@ -0,0 +1,239 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from contextlib import nullcontext
+from types import SimpleNamespace
+
+import pytest
+import torch
+from diffusers.models.embeddings import apply_rotary_emb
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.fixture(autouse=True)
+def _clear_qk_rope_signature_caches():
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    longcat._FAILED_QK_ROPE_SIGNATURES.clear()
+    yield
+    longcat._FAILED_QK_ROPE_SIGNATURES.clear()
+
+
+def _inputs(sequence: int = 5, head_dim: int = 8):
+    q = torch.randn(2, sequence, 3, head_dim, dtype=torch.bfloat16)
+    k = torch.randn_like(q)
+    cos = torch.randn(sequence, head_dim)
+    sin = torch.randn_like(cos)
+    return q, k, (cos, sin)
+
+
+def _reference(q, k, rotary_emb):
+    return (
+        apply_rotary_emb(q, rotary_emb, sequence_dim=1),
+        apply_rotary_emb(k, rotary_emb, sequence_dim=1),
+    )
+
+
+def test_prepare_rotary_emb_resolves_threshold_once_only_when_enabled(monkeypatch):
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    calls = 0
+
+    def resolve(default):
+        nonlocal calls
+        calls += 1
+        assert default == 512
+        return 37
+
+    monkeypatch.setattr(longcat, "fused_qk_norm_rope_min_tokens", resolve)
+    txt_cos, txt_sin = torch.randn(2, 8), torch.randn(2, 8)
+    img_cos, img_sin = torch.randn(3, 8), torch.randn(3, 8)
+    native = longcat._prepare_rotary_emb(txt_cos, txt_sin, img_cos, img_sin, enable_fusion=False)
+    fused = longcat._prepare_rotary_emb(txt_cos, txt_sin, img_cos, img_sin, enable_fusion=True)
+
+    assert calls == 1
+    assert len(native) == 2
+    assert len(fused) == 3 and fused[2] == 37
+    assert torch.equal(native[0], fused[0])
+    assert torch.equal(native[1], fused[1])
+
+
+@pytest.mark.parametrize(
+    ("mode", "sp_size"),
+    [
+        ("unsupported", 1),
+        ("compile", 1),
+        ("grad", 1),
+        ("capture", 1),
+        ("sequence_parallel", 2),
+        ("below_threshold", 1),
+    ],
+)
+def test_qk_rope_non_eager_modes_use_exact_original_path(monkeypatch, mode, sp_size):
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    torch.manual_seed(1)
+    q, k, rotary_emb = _inputs()
+    expected = _reference(q, k, rotary_emb)
+    monkeypatch.setattr(torch.compiler, "is_compiling", lambda: mode == "compile")
+    monkeypatch.setattr(torch.cuda, "is_current_stream_capturing", lambda: mode == "capture")
+    monkeypatch.setattr(longcat, "fused_qk_rope_supported", lambda *args: mode != "unsupported")
+    monkeypatch.setattr(
+        longcat,
+        "fused_qk_rope",
+        lambda *args: (_ for _ in ()).throw(AssertionError("fallback called fused op")),
+    )
+
+    context = nullcontext() if mode == "grad" else torch.no_grad()
+    min_tokens = q.shape[0] * q.shape[1] + 1 if mode == "below_threshold" else 0
+    with context:
+        actual = longcat._apply_qk_rope(q, k, rotary_emb, sp_size, min_tokens)
+
+    assert torch.equal(actual[0], expected[0])
+    assert torch.equal(actual[1], expected[1])
+
+
+def test_qk_rope_eligible_path_skips_runtime_parity_check(monkeypatch):
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    torch.manual_seed(2)
+    monkeypatch.setattr(torch.compiler, "is_compiling", lambda: False)
+    monkeypatch.setattr(torch.cuda, "is_current_stream_capturing", lambda: False)
+    monkeypatch.setattr(longcat, "fused_qk_rope_supported", lambda *args: True)
+    fused_calls = 0
+
+    def fused(query, key, cos, sin):
+        nonlocal fused_calls
+        fused_calls += 1
+        return query + 1, key + 2
+
+    monkeypatch.setattr(
+        longcat,
+        "_apply_qk_rope_reference",
+        lambda *args: (_ for _ in ()).throw(AssertionError("eligible path ran the native parity check")),
+    )
+    monkeypatch.setattr(longcat, "fused_qk_rope", fused)
+
+    with torch.no_grad():
+        q, k, rotary_emb = _inputs()
+        actual = longcat._apply_qk_rope(q, k, rotary_emb, 1, 0)
+
+    assert fused_calls == 1
+    assert torch.equal(actual[0], q + 1)
+    assert torch.equal(actual[1], k + 2)
+
+
+def test_qk_rope_launch_failure_permanently_falls_back(monkeypatch):
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    torch.manual_seed(3)
+    monkeypatch.setattr(torch.compiler, "is_compiling", lambda: False)
+    monkeypatch.setattr(torch.cuda, "is_current_stream_capturing", lambda: False)
+    monkeypatch.setattr(longcat, "fused_qk_rope_supported", lambda *args: True)
+    fused_calls = 0
+
+    def broken_fused(query, key, cos, sin):
+        nonlocal fused_calls
+        fused_calls += 1
+        raise RuntimeError("kernel failed")
+
+    monkeypatch.setattr(longcat, "fused_qk_rope", broken_fused)
+    q, k, rotary_emb = _inputs()
+    expected = _reference(q, k, rotary_emb)
+    with torch.no_grad():
+        first = longcat._apply_qk_rope(q, k, rotary_emb, 1, 0)
+        second = longcat._apply_qk_rope(q, k, rotary_emb, 1, 0)
+
+    assert fused_calls == 1
+    assert len(longcat._FAILED_QK_ROPE_SIGNATURES) == 1
+    for actual in (first, second):
+        assert torch.equal(actual[0], expected[0])
+        assert torch.equal(actual[1], expected[1])
+
+
+def test_failed_qk_rope_signature_cache_is_bounded():
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    for index in range(longcat._FAILED_QK_ROPE_SIGNATURES_MAX_SIZE + 1):
+        longcat._record_failed_qk_rope_signature((index,))
+
+    assert len(longcat._FAILED_QK_ROPE_SIGNATURES) == longcat._FAILED_QK_ROPE_SIGNATURES_MAX_SIZE
+    assert (0,) not in longcat._FAILED_QK_ROPE_SIGNATURES
+    assert (longcat._FAILED_QK_ROPE_SIGNATURES_MAX_SIZE,) in longcat._FAILED_QK_ROPE_SIGNATURES
+
+
+class _FakeQKV(torch.nn.Module):
+    def __init__(self, heads: int, head_dim: int) -> None:
+        super().__init__()
+        self.num_heads = heads
+        self.num_kv_heads = heads
+        self.width = heads * head_dim
+
+    def forward(self, x):
+        return torch.cat((x, x + 1, x + 2), dim=-1), None
+
+
+class _AddNorm(torch.nn.Module):
+    def __init__(self, value: float) -> None:
+        super().__init__()
+        self.value = value
+
+    def forward(self, x):
+        return x + self.value
+
+
+class _CaptureAttention(torch.nn.Module):
+    def forward(self, query, key, value, metadata=None):
+        del key, value, metadata
+        return query
+
+
+class _PassthroughLinear(torch.nn.Module):
+    def forward(self, x):
+        return x, None
+
+
+def test_dual_attention_keeps_native_norm_and_text_image_concat_order(monkeypatch):
+    from vllm_omni.diffusion.models.longcat_image import longcat_image_transformer as longcat
+
+    attention = longcat.LongCatImageAttention.__new__(longcat.LongCatImageAttention)
+    torch.nn.Module.__init__(attention)
+    attention.parallel_config = SimpleNamespace(sequence_parallel_size=1)
+    attention.head_dim = 4
+    attention.added_kv_proj_dim = 8
+    attention.to_qkv = _FakeQKV(2, 4)
+    attention.add_kv_proj = _FakeQKV(2, 4)
+    attention.norm_q = _AddNorm(10)
+    attention.norm_k = _AddNorm(20)
+    attention.norm_added_q = _AddNorm(100)
+    attention.norm_added_k = _AddNorm(200)
+    attention.attn = _CaptureAttention()
+    attention.to_out = _PassthroughLinear()
+    attention.to_add_out = _PassthroughLinear()
+
+    captured = []
+
+    def paired(query, key, rotary_emb, sp_size, min_tokens):
+        captured.append((query.clone(), key.clone(), rotary_emb, sp_size, min_tokens))
+        return query, key
+
+    monkeypatch.setattr(longcat, "_apply_qk_rope", paired)
+    image = torch.randn(1, 3, 8)
+    text = torch.randn(1, 2, 8)
+    rotary_pair = (torch.randn(5, 4), torch.randn(5, 4))
+    rotary_emb = (*rotary_pair, 0)
+    image_out, text_out = attention(image, text, rotary_emb)
+
+    image_q = image.unflatten(-1, (2, 4))
+    text_q = text.unflatten(-1, (2, 4))
+    expected_q = torch.cat((text_q + 100, image_q + 10), dim=1)
+    expected_k = torch.cat((text_q + 1 + 200, image_q + 1 + 20), dim=1)
+    assert len(captured) == 1
+    assert torch.equal(captured[0][0], expected_q)
+    assert torch.equal(captured[0][1], expected_k)
+    assert captured[0][2][0] is rotary_pair[0]
+    assert captured[0][2][1] is rotary_pair[1]
+    assert captured[0][3:] == (1, 0)
+    assert image_out.shape == image.shape
+    assert text_out.shape == text.shape
diff --git a/tests/diffusion/models/magi2/test_native_compile_cuda.py b/tests/diffusion/models/magi2/test_native_compile_cuda.py
index 1db394750..f6f87f0d1 100644
--- a/tests/diffusion/models/magi2/test_native_compile_cuda.py
+++ b/tests/diffusion/models/magi2/test_native_compile_cuda.py
@@ -14,12 +14,13 @@ from tests.diffusion.models.magi2.test_native_packing import (
 )
 from tests.helpers.mark import hardware_marks
 from vllm_omni.diffusion.models.magi2.sampler_magi2 import CFGConfig
+from vllm_omni.platforms import current_omni_platform
 
 pytestmark = [
     pytest.mark.diffusion,
     pytest.mark.core_model,
     *hardware_marks(res={"cuda": "L4"}, num_cards=1),
-    pytest.mark.skipif(not torch.cuda.is_available(), reason="requires CUDA"),
+    pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="requires CUDA"),
 ]
 
 
diff --git a/tests/diffusion/models/magi2/test_native_dlo_allgather.py b/tests/diffusion/models/magi2/test_native_dlo_allgather.py
index 9bea5dc30..5cfaabf3f 100644
--- a/tests/diffusion/models/magi2/test_native_dlo_allgather.py
+++ b/tests/diffusion/models/magi2/test_native_dlo_allgather.py
@@ -36,6 +36,7 @@ from vllm_omni.diffusion.offloader.distributed_layerwise_backend import (
     DistributedLayerwiseOffloadBackend,
     DistributedLayerwiseOffloadHook,
 )
+from vllm_omni.diffusion.offloader.plan_resolver import ResolvedComponent
 
 
 @dataclass(frozen=True)
@@ -46,12 +47,6 @@ class _WeightSourceStub:
     prefix: str
 
 
-@dataclass(frozen=True)
-class _PipelineModulesStub:
-    dits: list[nn.Module]
-    dit_names: list[str]
-
-
 _WORLD_SIZE = 4
 pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
 
@@ -189,7 +184,7 @@ def _load_mmap_transform_and_reconstruct(
         backend._mmap_transforms_by_tensor_id = {}
         backend._load_weights_via_mmap(
             pipeline,
-            _PipelineModulesStub(dits=[target], dit_names=["transformer"]),
+            (ResolvedComponent(path="transformer", module=target, selected=True),),
             plan_result.plan,
         )
 
diff --git a/tests/diffusion/models/magi2/test_native_preview.py b/tests/diffusion/models/magi2/test_native_preview.py
index 9167d72ee..10458c493 100644
--- a/tests/diffusion/models/magi2/test_native_preview.py
+++ b/tests/diffusion/models/magi2/test_native_preview.py
@@ -90,6 +90,21 @@ def test_hsdp_policy_shards_individual_preview_layers():
     assert not condition("pre_adapter", model.pre_adapter)
 
 
+def test_layerwise_offload_contract() -> None:
+    from vllm_omni.diffusion.offloader import get_blocks_from_dit
+
+    model = Magi2PreviewTransformer(_tiny_config(num_layers=2))
+
+    assert model._layerwise_offload_blocks_attrs == ["block"]
+    assert "block" in dict(model.named_children())
+    assert list(model.block) == list(model.block.layers)
+    assert model.layers is model.block.layers
+
+    attr_names, blocks = get_blocks_from_dit(model)
+    assert attr_names == ["block"]
+    assert blocks == list(model.block.layers)
+
+
 def test_data_proxy_keeps_output_layout_request_scoped() -> None:
     proxy = Magi2DataProxy(Magi2PreviewDataProxyConfig(time_channel_dim=0))
 
diff --git a/tests/diffusion/models/mammoth_moda2/test_pipeline_mammothmoda2_dit.py b/tests/diffusion/models/mammoth_moda2/test_pipeline_mammothmoda2_dit.py
new file mode 100644
index 000000000..776ca5bc6
--- /dev/null
+++ b/tests/diffusion/models/mammoth_moda2/test_pipeline_mammothmoda2_dit.py
@@ -0,0 +1,392 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig, TransformerConfig
+from vllm_omni.diffusion.models.mammoth_moda2 import pipeline_mammothmoda2_dit
+from vllm_omni.diffusion.models.mammoth_moda2.pipeline_mammothmoda2_dit import (
+    MammothModa2DiTPipeline,
+    _build_mammoth_config,
+    _root_weight_source,
+)
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _raw_config() -> dict:
+    return {
+        "model_type": "mammothmoda2",
+        "llm_config": {
+            "model_type": "mammothmoda2_qwen2_5_vl",
+            "text_config": {
+                "model_type": "mammothmoda2_qwen2_5_vl_text",
+                "hidden_size": 8,
+                "gen_vocab_start_index": 100,
+            },
+        },
+        "gen_vae_config": {"block_out_channels": [8, 8]},
+        "gen_dit_config": {"hidden_size": 8, "in_channels": 4},
+    }
+
+
+def _od_config() -> OmniDiffusionConfig:
+    return OmniDiffusionConfig(
+        model="/models/MammothModa2-Preview",
+        model_class_name="MammothModa2DiTPipeline",
+        tf_model_config=TransformerConfig.from_dict(_raw_config()),
+    )
+
+
+def test_build_mammoth_config_uses_shared_transformer_projection() -> None:
+    config = _build_mammoth_config(_od_config())
+    assert config.model_type == "mammothmoda2"
+    assert config.get_text_config().hidden_size == 8
+    assert config.gen_dit_config == {"hidden_size": 8, "in_channels": 4}
+
+
+def test_build_mammoth_config_rejects_empty_shared_projection() -> None:
+    config = _od_config()
+    config.tf_model_config = TransformerConfig()
+    with pytest.raises(ValueError, match="root checkpoint config"):
+        _build_mammoth_config(config)
+
+
+def test_root_weight_source_loads_combined_checkpoint_once() -> None:
+    source = _root_weight_source(_od_config())
+    assert source.model_or_path == "/models/MammothModa2-Preview"
+    assert source.subfolder is None
+    assert source.prefix == ""
+    assert source.fall_back_to_pt is True
+
+
+def test_root_weight_source_forwards_revision() -> None:
+    config = _od_config()
+    config.revision = "rev-7"
+    assert _root_weight_source(config).revision == "rev-7"
+
+
+def test_pipeline_declares_native_components_and_single_request_mode_only() -> None:
+    assert MammothModa2DiTPipeline._dit_modules == ["gen_transformer"]
+    assert MammothModa2DiTPipeline._encoder_modules == ["gen_image_condition_refiner"]
+    assert MammothModa2DiTPipeline._vae_modules == ["gen_vae"]
+    assert MammothModa2DiTPipeline.supports_request_batch is False
+    assert MammothModa2DiTPipeline.supports_step_execution is False
+
+
+def test_mammoth_postprocess_denormalizes_nonnegative_raw_vae_output() -> None:
+    factory = getattr(pipeline_mammothmoda2_dit, "get_mammoth_moda2_post_process_func", None)
+    assert factory is not None
+
+    images = factory(_od_config())(torch.zeros(1, 3, 2, 2))
+
+    assert len(images) == 1
+    assert images[0].getpixel((0, 0)) == (128, 128, 128)
+
+
+def test_mammoth_postprocess_is_registered() -> None:
+    from vllm_omni.diffusion.registry import _DIFFUSION_POST_PROCESS_FUNCS
+
+    assert _DIFFUSION_POST_PROCESS_FUNCS["MammothModa2DiTPipeline"] == "get_mammoth_moda2_post_process_func"
+
+
+def test_root_weight_source_rejects_missing_model_path() -> None:
+    config = _od_config()
+    config.model = None
+    with pytest.raises(ValueError, match="model path"):
+        _root_weight_source(config)
+
+
+def _pipeline_shell() -> MammothModa2DiTPipeline:
+    pipeline = object.__new__(MammothModa2DiTPipeline)
+    nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.config = _build_mammoth_config(_od_config())
+    pipeline._llm_hidden_size = 8
+    return pipeline
+
+
+def _batch(
+    *,
+    request_id: str = "req-7",
+    prompt: object | None = None,
+    sampling: OmniDiffusionSamplingParams | None = None,
+) -> DiffusionRequestBatch:
+    if prompt is None:
+        prompt = {
+            "prompt": "",
+            "height": 32,
+            "width": 48,
+            "additional_information": {
+                "full_hidden_states": torch.arange(32, dtype=torch.float32).reshape(4, 8),
+                "full_token_ids": [10, 11, 100, 101],
+                "answer_start_index": 2,
+            },
+        }
+    if sampling is None:
+        sampling = OmniDiffusionSamplingParams(
+            height=32,
+            width=48,
+            seed=42,
+            guidance_scale=4.0,
+            num_inference_steps=7,
+            extra_args={"cfg_range": [0.2, 0.8]},
+        )
+    return DiffusionRequestBatch([OmniDiffusionRequest(prompt=prompt, sampling_params=sampling, request_id=request_id)])
+
+
+def test_parse_request_uses_standard_sampling_fields() -> None:
+    parsed = _pipeline_shell()._parse_request(_batch())
+    assert parsed.request_id == "req-7"
+    assert (parsed.height, parsed.width) == (32, 48)
+    assert parsed.num_inference_steps == 7
+    assert parsed.text_guidance_scale == 4.0
+    assert parsed.cfg_range == (0.2, 0.8)
+    assert parsed.seed == 42
+    assert parsed.answer_start_index == 2
+
+
+def test_parse_request_prefers_legacy_sampling_overrides() -> None:
+    sampling = OmniDiffusionSamplingParams(
+        guidance_scale=3.0,
+        num_inference_steps=5,
+        seed=9,
+        extra_args={"text_guidance_scale": 6.0, "num_inference_steps": 11, "cfg_range": [0.0, 0.5]},
+    )
+    parsed = _pipeline_shell()._parse_request(_batch(sampling=sampling))
+    assert parsed.text_guidance_scale == 6.0
+    assert parsed.num_inference_steps == 11
+    assert parsed.cfg_range == (0.0, 0.5)
+
+
+def test_parse_request_falls_back_to_request_level_sampling_values() -> None:
+    prompt = _batch().prompts[0]
+    prompt["additional_information"].update(
+        text_guidance_scale=[1.5],
+        num_inference_steps=[3],
+        cfg_range=[0.25, 0.75],
+    )
+
+    parsed = _pipeline_shell()._parse_request(_batch(prompt=prompt, sampling=OmniDiffusionSamplingParams()))
+
+    assert parsed.text_guidance_scale == 1.5
+    assert parsed.num_inference_steps == 3
+    assert parsed.cfg_range == (0.25, 0.75)
+
+
+def test_parse_request_standard_fields_precede_request_level_fallbacks() -> None:
+    prompt = _batch().prompts[0]
+    prompt["additional_information"].update(
+        text_guidance_scale=[1.5],
+        num_inference_steps=[3],
+    )
+    sampling = OmniDiffusionSamplingParams(guidance_scale=4.0, num_inference_steps=7)
+
+    parsed = _pipeline_shell()._parse_request(_batch(prompt=prompt, sampling=sampling))
+
+    assert parsed.text_guidance_scale == 4.0
+    assert parsed.num_inference_steps == 7
+
+
+def test_parse_request_rejects_multiple_requests_and_outputs() -> None:
+    pipeline = _pipeline_shell()
+    batch = _batch()
+    batch.requests.append(_batch(request_id="req-8").requests[0])
+    with pytest.raises(ValueError, match="exactly one request"):
+        pipeline._parse_request(batch)
+    with pytest.raises(ValueError, match="num_outputs_per_prompt=1"):
+        pipeline._parse_request(_batch(sampling=OmniDiffusionSamplingParams(num_outputs_per_prompt=2)))
+
+
+@pytest.mark.parametrize(
+    ("cfg_range", "message"),
+    [
+        ([0.5], "two values"),
+        ([-0.1, 0.5], "0 <= start <= end <= 1"),
+        ([0.7, 0.2], "0 <= start <= end <= 1"),
+        ([0.2, 1.1], "0 <= start <= end <= 1"),
+    ],
+)
+def test_parse_request_rejects_invalid_cfg_range(cfg_range, message) -> None:
+    batch = _batch(sampling=OmniDiffusionSamplingParams(extra_args={"cfg_range": cfg_range}))
+    with pytest.raises(ValueError, match=message):
+        _pipeline_shell()._parse_request(batch)
+
+
+def test_parse_request_requires_real_ar_conditions() -> None:
+    with pytest.raises(ValueError, match="req-missing"):
+        _pipeline_shell()._parse_request(_batch(request_id="req-missing", prompt={"prompt": "draw a cat"}))
+
+
+def test_parse_request_rejects_hidden_state_token_count_mismatch() -> None:
+    batch = _batch()
+    batch.prompts[0]["additional_information"]["full_hidden_states"] = torch.zeros(3, 8)
+    with pytest.raises(ValueError, match="hidden-state/token-count mismatch"):
+        _pipeline_shell()._parse_request(batch)
+
+
+@pytest.mark.parametrize(
+    ("height", "width", "message"),
+    [
+        (0, 32, "Invalid image size"),
+        (32, -1, "Invalid image size"),
+        (30, 32, "multiples of 16"),
+        (32, 31, "multiples of 16"),
+    ],
+)
+def test_parse_request_rejects_invalid_dimensions(height, width, message) -> None:
+    batch = _batch()
+    batch.prompts[0].update(height=height, width=width)
+    with pytest.raises(ValueError, match=message):
+        _pipeline_shell()._parse_request(batch)
+
+
+def test_parse_request_rejects_explicit_zero_steps() -> None:
+    with pytest.raises(ValueError, match="num_inference_steps must be positive"):
+        _pipeline_shell()._parse_request(_batch(sampling=OmniDiffusionSamplingParams(num_inference_steps=0)))
+
+
+@pytest.mark.parametrize(("standard_steps", "expected_steps"), [(7, 7), (None, 50)])
+def test_parse_request_falls_through_null_legacy_step_count(standard_steps, expected_steps) -> None:
+    sampling = OmniDiffusionSamplingParams(num_inference_steps=standard_steps, extra_args={"num_inference_steps": None})
+    parsed = _pipeline_shell()._parse_request(_batch(sampling=sampling))
+    assert parsed.num_inference_steps == expected_steps
+
+
+@pytest.mark.parametrize(("standard_guidance", "expected_guidance"), [(4.0, 4.0), (None, 9.0)])
+def test_parse_request_falls_through_null_legacy_guidance(standard_guidance, expected_guidance) -> None:
+    sampling = OmniDiffusionSamplingParams(guidance_scale=standard_guidance, extra_args={"text_guidance_scale": None})
+    parsed = _pipeline_shell()._parse_request(_batch(sampling=sampling))
+    assert parsed.text_guidance_scale == expected_guidance
+
+
+def test_parse_request_defaults_null_cfg_range() -> None:
+    sampling = OmniDiffusionSamplingParams(extra_args={"cfg_range": None})
+    parsed = _pipeline_shell()._parse_request(_batch(sampling=sampling))
+    assert parsed.cfg_range == (0.0, 1.0)
+
+
+@pytest.mark.parametrize("generators", [[], [torch.Generator(), torch.Generator()]])
+def test_parse_request_rejects_invalid_generator_list_cardinality(generators) -> None:
+    sampling = OmniDiffusionSamplingParams(generator=generators)
+    with pytest.raises(ValueError, match="exactly one generator.*req-generators"):
+        _pipeline_shell()._parse_request(_batch(request_id="req-generators", sampling=sampling))
+
+
+def test_parse_request_synthesizes_dummy_ar_conditions() -> None:
+    batch = _batch(
+        request_id="dummy_req_id",
+        prompt={"prompt": "dummy run"},
+        sampling=OmniDiffusionSamplingParams(height=512, width=512, seed=1, guidance_scale=0.0, num_inference_steps=2),
+    )
+    parsed = _pipeline_shell()._parse_request(batch)
+    assert parsed.full_hidden_states.shape == (2, 8)
+    assert parsed.full_token_ids == [0, 100]
+    assert parsed.answer_start_index == 1
+
+
+@dataclass
+class _FakeTransformerConfig:
+    in_channels: int = 4
+
+
+@dataclass
+class _FakeTimeCaptionEmbed:
+    image_embedder: nn.Module | None = None
+
+
+class _FakeTransformer(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.anchor = nn.Parameter(torch.zeros(1))
+        self.config = _FakeTransformerConfig()
+        self.time_caption_embed = _FakeTimeCaptionEmbed()
+        self.calls = 0
+
+    def forward(self, *, hidden_states, **kwargs):
+        self.calls += 1
+        return torch.zeros_like(hidden_states)
+
+
+@dataclass
+class _FakeVaeConfig:
+    scaling_factor: float | None = None
+    shift_factor: float | None = None
+
+
+class _FakeVae(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.anchor = nn.Parameter(torch.zeros(1))
+        self.config = _FakeVaeConfig()
+
+    def decode(self, latents, return_dict=False):
+        assert return_dict is False
+        return (torch.zeros(1, 3, 32, 48, dtype=latents.dtype),)
+
+
+class _FakeScheduler:
+    def __init__(self) -> None:
+        self.timesteps = torch.tensor([])
+        self.requested_steps = None
+
+    def set_timesteps(self, *, num_inference_steps, device, num_tokens):
+        self.requested_steps = num_inference_steps
+        self.timesteps = torch.arange(num_inference_steps, device=device, dtype=torch.float32)
+
+    def step(self, model_pred, timestep, latents, return_dict=False):
+        assert return_dict is False
+        return (latents - model_pred,)
+
+
+def test_forward_returns_diffusion_output_with_request_sampling(mocker) -> None:
+    pipeline = _pipeline_shell()
+    pipeline.gen_transformer = _FakeTransformer()
+    pipeline.gen_image_condition_refiner = None
+    pipeline.gen_vae = _FakeVae()
+    pipeline.gen_freqs_cis = torch.zeros(1)
+    scheduler = _FakeScheduler()
+    captured = {}
+
+    def fake_randn_tensor(shape, *, generator, device, dtype):
+        captured["shape"] = shape
+        captured["seed"] = generator.initial_seed()
+        return torch.zeros(shape, device=device, dtype=dtype)
+
+    module = "vllm_omni.diffusion.models.mammoth_moda2.pipeline_mammothmoda2_dit"
+    mocker.patch(f"{module}.FlowMatchEulerDiscreteScheduler", return_value=scheduler)
+    mocker.patch(f"{module}.randn_tensor", side_effect=fake_randn_tensor)
+    result = pipeline.forward(
+        _batch(
+            sampling=OmniDiffusionSamplingParams(
+                height=32, width=48, seed=42, guidance_scale=1.0, num_inference_steps=2
+            )
+        )
+    )
+
+    assert isinstance(result, DiffusionOutput)
+    assert result.output.shape == (1, 3, 32, 48)
+    assert captured["shape"] == (1, 4, 4, 6)
+    assert captured["seed"] == 42
+    assert scheduler.requested_steps == 2
+    assert pipeline.gen_transformer.calls == 2
+
+
+def test_forward_rejects_missing_visual_tokens_before_model_access() -> None:
+    prompt = {
+        "prompt": "",
+        "additional_information": {
+            "full_hidden_states": torch.zeros(3, 8),
+            "full_token_ids": [10, 11, 12],
+            "answer_start_index": 2,
+        },
+    }
+    with pytest.raises(ValueError, match="no visual-token hidden states.*req-empty"):
+        _pipeline_shell().forward(_batch(request_id="req-empty", prompt=prompt))
diff --git a/tests/diffusion/models/minimax_h3/test_fasth3_checkpoint.py b/tests/diffusion/models/minimax_h3/test_fasth3_checkpoint.py
new file mode 100644
index 000000000..9a530bf90
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_fasth3_checkpoint.py
@@ -0,0 +1,679 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Iterable
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, DiffusionParallelConfig, OmniDiffusionConfig
+from vllm_omni.diffusion.models.minimax_h3.fasth3_checkpoint import (
+    FASTH3_BASE_MODEL,
+    FASTH3_V2_BASE_SCHEDULE,
+    FASTH3_V2_MODEL_ID,
+    FastH3CheckpointSpec,
+)
+from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+    MiniMaxH3DiTArchConfig,
+    MiniMaxH3DiTModel,
+)
+from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    resolve_minimax_h3_diffusion_model_path,
+)
+from vllm_omni.diffusion.sched.sigma_schedule import DMD2SigmaSchedule
+from vllm_omni.errors import OmniClientError
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.lora.request import LoRARequest
+from vllm_omni.model_executor.models.minimax_h3.checkpoint import (
+    is_minimax_h3_modular,
+    resolve_minimax_h3_model_root,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def _fastvideo_metadata() -> dict[str, object]:
+    """Return the release-owned metadata read from fastvideo_inference.json."""
+    return {
+        "model_id": FASTH3_V2_MODEL_ID,
+        "schema_version": "fasth3-inference-contract-v1",
+        "dmd_denoising_steps": [999, 874, 749, 624, 500, 375, 250, 125],
+        "transformer_forwards": 8,
+        "video_scheduler_shift": 10.0,
+        "audio_scheduler_shift": 3.0,
+        "guidance_scale": 1.0,
+        "attention_backend": "VIDEO_SPARSE_ATTN_H3",
+        "vsa_sparsity": 0.8,
+        "vsa_tile_size": 64,
+        "task": "t2av",
+    }
+
+
+def _sampling(
+    *,
+    num_inference_steps: int | str | None = 8,
+    guidance_scale: float | None = 1.0,
+    extra_args: dict[str, object] | None = None,
+    lora_request: LoRARequest | None = None,
+    timesteps: torch.Tensor | None = None,
+    sigmas: list[float] | None = None,
+) -> OmniDiffusionSamplingParams:
+    return OmniDiffusionSamplingParams(
+        # Keep the string form to exercise malformed client input validation.
+        num_inference_steps=num_inference_steps,  # type: ignore[arg-type]
+        guidance_scale=guidance_scale,
+        extra_args=extra_args or {},
+        lora_request=lora_request,
+        timesteps=timesteps,
+        sigmas=sigmas,
+    )
+
+
+def _od_config(
+    *,
+    backend: str = "FASTVIDEO_VSA",
+    topk: int | None = None,
+    per_role: dict[str, AttentionSpec] | None = None,
+    lora_path: str | None = None,
+    ring_degree: int = 1,
+    allgather_degree: int = 1,
+) -> OmniDiffusionConfig:
+    attention_config = AttentionConfig(
+        default=AttentionSpec(backend=backend, fastvideo_vsa_topk=topk),
+        per_role=per_role or {},
+    )
+    return OmniDiffusionConfig(
+        diffusion_attention_config=attention_config,
+        lora_path=lora_path,
+        parallel_config=DiffusionParallelConfig(ring_degree=ring_degree, allgather_degree=allgather_degree),
+    )
+
+
+def test_v2_release_has_nine_sigma_nodes_and_eight_intervals():
+    assert FASTH3_V2_BASE_SCHEDULE.base_schedule == (
+        0.999,
+        0.874,
+        0.749,
+        0.624,
+        0.5,
+        0.375,
+        0.25,
+        0.125,
+        0.0,
+    )
+    assert len(FASTH3_V2_BASE_SCHEDULE.base_schedule) == 9
+    assert FASTH3_V2_BASE_SCHEDULE.num_inference_steps == 8
+    assert FASTH3_V2_BASE_SCHEDULE.shifted_sigmas(10.0) == pytest.approx(
+        [
+            0.9998999099189271,
+            0.985788405143244,
+            0.9675752486758817,
+            0.94316807738815,
+            0.9090909090909091,
+            0.8571428571428571,
+            0.7692307692307693,
+            0.5882352941176471,
+            0.0,
+        ],
+        abs=1e-12,
+    )
+    assert FASTH3_V2_BASE_SCHEDULE.shifted_sigmas(3.0) == pytest.approx(
+        [
+            0.9996664442961973,
+            0.9541484716157204,
+            0.8995196156925539,
+            0.8327402135231315,
+            0.75,
+            0.6428571428571429,
+            0.5,
+            0.3,
+            0.0,
+        ],
+        abs=1e-12,
+    )
+
+
+def test_fastvideo_metadata_builds_release_sampling_metadata():
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+
+    assert spec.vsa_sparsity == 0.8
+    assert spec.release_metadata() == {
+        "partition": "fl2va",
+        "tasks": ["t2va"],
+        "sigma_shift_scales": {"video": 10.0, "audio": 3.0},
+        "base_schedule": list(FASTH3_V2_BASE_SCHEDULE.base_schedule),
+    }
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    [
+        ("model_id", "FastVideo/FastH3-other"),
+        ("schema_version", "fasth3-inference-contract-v0"),
+        ("dmd_denoising_steps", [999, 749, 500, 250]),
+        ("transformer_forwards", 4),
+        ("video_scheduler_shift", 12.0),
+        ("audio_scheduler_shift", 4.0),
+        ("guidance_scale", 2.0),
+        ("attention_backend", "FLASH_ATTN"),
+        ("vsa_sparsity", 0.9),
+        ("vsa_tile_size", 32),
+        ("task", "t2va"),
+    ],
+)
+def test_fastvideo_metadata_rejects_contract_drift(field, value):
+    metadata = _fastvideo_metadata()
+    metadata[field] = value
+
+    with pytest.raises(ValueError, match=field):
+        FastH3CheckpointSpec.from_metadata(metadata)
+
+
+def test_fastvideo_metadata_rejects_missing_contract_field():
+    metadata = _fastvideo_metadata()
+    metadata.pop("task")
+
+    with pytest.raises(ValueError, match="task"):
+        FastH3CheckpointSpec.from_metadata(metadata)
+
+
+def test_legacy_h3_metadata_is_not_treated_as_fastvideo_release():
+    with pytest.raises(ValueError, match="model_id"):
+        FastH3CheckpointSpec.from_metadata(
+            {
+                "schema_version": 1,
+                "partition": "fl2va",
+                "tasks": ["t2va", "fl2va"],
+                "sigma_shift_scales": {"video": 12.0, "audio": 3.0},
+            }
+        )
+
+
+def test_v2_serving_contract_accepts_backend_selected_for_h3_self_role():
+    config = _od_config(
+        backend="TORCH_SDPA",
+        per_role={"self": AttentionSpec(backend="FASTVIDEO_VSA")},
+    )
+    FastH3CheckpointSpec.from_metadata(_fastvideo_metadata()).check_serving_contract(
+        partition="fl2va", od_config=config
+    )
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "partition", "match"),
+    [
+        ({}, "ref2va", "task-type fl2va"),
+        ({"lora_path": "/tmp/adapter"}, "fl2va", "LoRA"),
+        ({"backend": "TORCH_SDPA"}, "fl2va", "FASTVIDEO_VSA"),
+        ({"topk": 2}, "fl2va", "fixed fastvideo_vsa_topk"),
+        ({"ring_degree": 2}, "fl2va", "local attention"),
+        ({"allgather_degree": 2}, "fl2va", "local attention"),
+    ],
+)
+def test_v2_serving_contract_rejects_incompatible_runtime(kwargs, partition, match):
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    with pytest.raises(ValueError, match=match):
+        spec.check_serving_contract(partition=partition, od_config=_od_config(**kwargs))
+
+
+def test_v2_serving_contract_reads_a_per_role_fixed_topk_override():
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    config = _od_config(
+        per_role={"self": AttentionSpec(backend="FASTVIDEO_VSA", fastvideo_vsa_topk=1)},
+    )
+    with pytest.raises(ValueError, match="fixed fastvideo_vsa_topk"):
+        spec.check_serving_contract(partition="fl2va", od_config=config)
+
+
+def test_v2_request_contract_accepts_omitted_steps_and_default_shifts():
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    spec.check_request(_sampling(num_inference_steps=None))
+    spec.check_request(_sampling(extra_args={"flow_shift": 10, "audio_flow_shift": 3}, guidance_scale=1))
+
+
+@pytest.mark.parametrize(
+    "sampling",
+    [
+        _sampling(num_inference_steps=None),
+        _sampling(timesteps=torch.tensor([0.9, 0.5, 0.0])),
+        _sampling(sigmas=[1.0, 0.5, 0.0]),
+    ],
+)
+def test_v2_step_execution_requires_pinned_count_and_schedule(sampling):
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    with pytest.raises(OmniClientError, match="step execution"):
+        spec.check_request(sampling, step_execution=True)
+
+
+def test_v2_step_execution_accepts_only_explicit_pinned_count():
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    spec.check_request(_sampling(num_inference_steps=8), step_execution=True)
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "match"),
+    [
+        ({"num_inference_steps": 7}, "num_inference_steps=8"),
+        ({"num_inference_steps": 9}, "num_inference_steps=8"),
+        ({"num_inference_steps": "8"}, "num_inference_steps=8"),
+        ({"extra_args": {"flow_shift": 9}}, "flow_shift=10"),
+        ({"extra_args": {"audio_flow_shift": 4}}, "audio_flow_shift=3"),
+        ({"extra_args": {"flow_shift": "bad"}}, "flow_shift=10"),
+        ({"guidance_scale": 2.0}, "guidance_scale=1"),
+        (
+            {"lora_request": LoRARequest(lora_name="test", lora_int_id=1, lora_path="/tmp/test.safetensors")},
+            "per-request LoRA",
+        ),
+    ],
+)
+def test_v2_request_contract_rejects_sampling_drift(kwargs, match):
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    with pytest.raises(OmniClientError, match=match):
+        spec.check_request(_sampling(**kwargs))
+
+
+def test_resolve_native_vaes_uses_pinned_revision_and_only_vae_patterns(tmp_path, monkeypatch):
+    model_root = tmp_path / "FastH3"
+    model_root.mkdir()
+    revision = "base-revision-123"
+    (model_root / "provenance.json").write_text(
+        json.dumps({"base_model": f"hf://{FASTH3_BASE_MODEL}@{revision}"}),
+        encoding="utf-8",
+    )
+    snapshot = tmp_path / "hf-snapshot"
+    calls: dict[str, object] = {}
+
+    def fake_download(**kwargs: object) -> str:
+        calls.update(kwargs)
+        snapshot.mkdir()
+        return str(snapshot)
+
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.models.minimax_h3.fasth3_checkpoint.download_weights_from_hf_specific",
+        fake_download,
+    )
+
+    result = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata()).resolve_native_vaes(model_root)
+
+    assert result == snapshot / "FL2VA"
+    assert calls == {
+        "model_name_or_path": FASTH3_BASE_MODEL,
+        "cache_dir": None,
+        "allow_patterns": ["FL2VA/video_vae/**", "FL2VA/audio_vae/**"],
+        "revision": revision,
+        "require_all": True,
+    }
+    assert sorted(path.name for path in model_root.iterdir()) == ["provenance.json"]
+    assert not (model_root / "model_index.json").exists()
+    assert not (model_root / "conversion.json").exists()
+
+
+@pytest.mark.parametrize(
+    "base_model",
+    [
+        "MiniMaxAI/MiniMax-H3@main",
+        "hf://MiniMaxAI/MiniMax-H3@",
+        "hf://Other/MiniMax-H3@revision",
+        "",
+        None,
+    ],
+)
+def test_resolve_native_vaes_rejects_unpinned_provenance(tmp_path, base_model):
+    model_root = tmp_path / "FastH3"
+    model_root.mkdir()
+    (model_root / "provenance.json").write_text(json.dumps({"base_model": base_model}), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="provenance"):
+        FastH3CheckpointSpec.from_metadata(_fastvideo_metadata()).resolve_native_vaes(model_root)
+
+
+def test_modular_local_model_root_uses_text_encoder_without_partition_files(tmp_path):
+    root = tmp_path / "FastH3"
+    (root / "text_encoder").mkdir(parents=True)
+    (root / "text_encoder" / "config.json").write_text("{}", encoding="utf-8")
+    (root / "modular_model_index.json").write_text(
+        json.dumps({"_class_name": "MiniMaxH3ModularPipeline"}),
+        encoding="utf-8",
+    )
+
+    assert is_minimax_h3_modular(str(root)) is True
+    assert resolve_minimax_h3_model_root(str(root), None, "fl2va") == str(root / "text_encoder")
+    assert not (root / "FL2VA").exists()
+
+
+def test_modular_hub_model_root_downloads_only_text_encoder(monkeypatch, tmp_path):
+    from vllm_omni.model_executor.models.minimax_h3 import checkpoint as checkpoint_module
+
+    snapshot = tmp_path / "modular-snapshot"
+    calls: dict[str, object] = {}
+
+    def fake_index(model: str, *, revision: str | None = None) -> dict[str, str]:
+        assert model == "FastVideo/FastVideo-FastH3-8-Step-V2"
+        assert revision == "release-revision"
+        return {"_class_name": "MiniMaxH3ModularPipeline"}
+
+    def fake_download(**kwargs: object) -> str:
+        calls.update(kwargs)
+        snapshot.mkdir()
+        return str(snapshot)
+
+    monkeypatch.setattr(checkpoint_module, "get_diffusion_model_index", fake_index)
+    monkeypatch.setattr(checkpoint_module, "download_weights_from_hf_specific", fake_download)
+
+    result = resolve_minimax_h3_model_root(
+        "FastVideo/FastVideo-FastH3-8-Step-V2",
+        "release-revision",
+        "fl2va",
+    )
+
+    assert result == str(snapshot / "text_encoder")
+    assert calls == {
+        "model_name_or_path": "FastVideo/FastVideo-FastH3-8-Step-V2",
+        "cache_dir": None,
+        "allow_patterns": ["text_encoder/**"],
+        "revision": "release-revision",
+        "require_all": True,
+    }
+
+
+def test_native_hub_model_with_modular_class_keeps_partition_layout(monkeypatch):
+    from vllm_omni.model_executor.models.minimax_h3 import checkpoint as checkpoint_module
+
+    monkeypatch.setattr(
+        checkpoint_module,
+        "get_diffusion_model_index",
+        lambda _model, *, revision=None: {"_class_name": "MiniMaxH3ModularPipeline"},
+    )
+
+    assert checkpoint_module.is_minimax_h3_modular("MiniMaxAI/MiniMax-H3") is False
+
+
+def test_native_local_model_root_keeps_partition_layout(tmp_path):
+    root = tmp_path / "MiniMax-H3"
+    (root / "FL2VA" / "text_encoder").mkdir(parents=True)
+    (root / "FL2VA" / "text_encoder" / "config.json").write_text("{}", encoding="utf-8")
+
+    assert is_minimax_h3_modular(str(root)) is False
+    assert resolve_minimax_h3_model_root(str(root), None, "fl2va") == str(root / "FL2VA" / "text_encoder")
+
+
+def test_diffusion_resolver_returns_local_modular_root_without_partition_files(tmp_path):
+    root = tmp_path / "FastH3"
+    root.mkdir()
+    (root / "modular_model_index.json").write_text(
+        json.dumps({"_class_name": "MiniMaxH3ModularPipeline"}),
+        encoding="utf-8",
+    )
+
+    assert resolve_minimax_h3_diffusion_model_path(str(root), None, "fl2va") == str(root)
+    assert not (root / "FL2VA").exists()
+    assert not (root / "Ref2VA").exists()
+
+
+def test_diffusion_resolver_hub_modular_downloads_transformer_contract_only(monkeypatch, tmp_path):
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as pipeline_module
+
+    snapshot = tmp_path / "modular-snapshot"
+    calls: dict[str, object] = {}
+
+    def fake_modular(_model: str, _revision: str | None = None) -> bool:
+        return True
+
+    def fake_download(**kwargs: object) -> str:
+        calls.update(kwargs)
+        snapshot.mkdir()
+        return str(snapshot)
+
+    monkeypatch.setattr(pipeline_module, "is_minimax_h3_modular", fake_modular)
+    monkeypatch.setattr(pipeline_module, "download_weights_from_hf_specific", fake_download)
+
+    result = resolve_minimax_h3_diffusion_model_path(
+        "FastVideo/FastVideo-FastH3-8-Step-V2", "release-revision", "fl2va"
+    )
+
+    assert result == str(snapshot)
+    assert calls == {
+        "model_name_or_path": "FastVideo/FastVideo-FastH3-8-Step-V2",
+        "cache_dir": None,
+        "allow_patterns": [
+            "modular_model_index.json",
+            "fastvideo_inference.json",
+            "provenance.json",
+            "transformer/**",
+        ],
+        "revision": "release-revision",
+        "require_all": True,
+    }
+    patterns = calls["allow_patterns"]
+    assert isinstance(patterns, list)
+    assert all("video_vae" not in pattern and "audio_vae" not in pattern for pattern in patterns)
+
+
+def test_diffusers_arch_config_normalizes_all_aliases():
+    arch = MiniMaxH3DiTArchConfig.from_mapping(
+        {
+            "num_refiner_layers": 3,
+            "ffn_dim": 12,
+            "in_channels": 4,
+            "audio_in_channels": 6,
+            "freq_dim": 8,
+            "time_embed_hidden_dim": 10,
+            "rope_freq_dim": 5,
+            "patch_size": [1, 2, 2],
+        }
+    )
+
+    assert arch.token_refiner_num_layers == 3
+    assert arch.ffn_hidden_size == 12
+    assert arch.latents_dim == 4
+    assert arch.audio_latents_dim == 6
+    assert arch.timestep_input_dim == 8
+    assert arch.time_embed_hidden_size == 10
+    assert arch.rope_inv_freq_len == 5
+    assert arch.patch_size == (1, 2, 2)
+
+
+class _WeightTarget(nn.Module):
+    def __init__(self, shape: tuple[int, ...], loader: Callable[..., None]) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.zeros(shape))
+        self.weight.weight_loader = loader
+
+
+class _PipelineLoadTransformer(nn.Module):
+    def __init__(self, loaded: set[str]) -> None:
+        super().__init__()
+        self.arch = MiniMaxH3DiTArchConfig(num_layers=1)
+        self._loaded = loaded
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        list(weights)
+        return self._loaded
+
+    def post_load_weights(self) -> None:
+        pass
+
+
+def test_pipeline_load_weights_rejects_missing_fast_h3_compression_gate():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    nn.Module.__init__(pipeline)
+    pipeline.transformer = _PipelineLoadTransformer({"blocks.0.attn.qkv_proj.weight"})
+    pipeline.video_vae = None
+    pipeline.audio_vae = None
+    pipeline._fasth3 = None
+    pipeline._fasth3_checkpoint = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+
+    with pytest.raises(ValueError, match="missing compression gates"):
+        pipeline.load_weights([("transformer.blocks.0.attn.qkv_proj.weight", torch.zeros(1))])
+
+
+def _load_fixture(
+    *, diffusers_weights: bool
+) -> tuple[MiniMaxH3DiTModel, list[tuple[str | None, torch.Tensor]], list[tuple[int, torch.Tensor]]]:
+    model = object.__new__(MiniMaxH3DiTModel)
+    nn.Module.__init__(model)
+    model.arch = MiniMaxH3DiTArchConfig(
+        num_layers=1,
+        hidden_size=3,
+        num_attention_heads=2,
+        attention_head_dim=2,
+        ffn_hidden_size=6,
+        rope_inv_freq_len=2,
+    )
+    model._diffusers_weights = diffusers_weights
+    model._rope_theta = 10000.0
+    qkv_calls: list[tuple[str | None, torch.Tensor]] = []
+    fc1_calls: list[tuple[int, torch.Tensor]] = []
+
+    def qkv_loader(param: nn.Parameter, loaded_weight: torch.Tensor, shard_id: str | None = None) -> None:
+        if shard_id is None:
+            assert loaded_weight.shape == (12, 3)
+            param.data.copy_(loaded_weight)
+            qkv_calls.append((None, loaded_weight.clone()))
+            return
+        assert loaded_weight.shape == (4, 3)
+        assert shard_id in {"q", "k", "v"}
+        offset = {"q": 0, "k": 4, "v": 8}[shard_id]
+        param.data[offset : offset + 4].copy_(loaded_weight)
+        qkv_calls.append((shard_id, loaded_weight.clone()))
+
+    def fc1_loader(param: nn.Parameter, loaded_weight: torch.Tensor, shard_id: int) -> None:
+        assert loaded_weight.shape == (3, 3)
+        param.data[shard_id * 3 : (shard_id + 1) * 3].copy_(loaded_weight)
+        fc1_calls.append((shard_id, loaded_weight.clone()))
+
+    model.blocks = nn.ModuleList([nn.Module()])
+    model.blocks[0].attn = nn.Module()
+    model.blocks[0].attn.qkv_proj = _WeightTarget((12, 3), qkv_loader)
+    model.blocks[0].mlp = nn.Module()
+    model.blocks[0].mlp.fc1 = _WeightTarget((6, 3), fc1_loader)
+    model.rope = nn.Module()
+    model.rope.register_buffer("inv_freq", torch.zeros(2))
+    return model, qkv_calls, fc1_calls
+
+
+def test_diffusers_load_weights_uses_shape_aware_qkv_and_mlp_slices():
+    model, qkv_calls, fc1_calls = _load_fixture(diffusers_weights=True)
+    q = torch.arange(12, dtype=torch.float32).reshape(4, 3) + 10
+    k = torch.arange(12, dtype=torch.float32).reshape(4, 3) + 100
+    v = torch.arange(12, dtype=torch.float32).reshape(4, 3) + 200
+    mlp = torch.arange(18, dtype=torch.float32).reshape(6, 3) + 300
+
+    loaded = model.load_weights(
+        [
+            ("transformer_blocks.0.attn.to_q.weight", q),
+            ("transformer_blocks.0.attn.to_k.weight", k),
+            ("transformer_blocks.0.attn.to_v.weight", v),
+            ("transformer_blocks.0.ff.net.0.proj.weight", mlp),
+        ]
+    )
+
+    assert loaded == {
+        "blocks.0.attn.qkv_proj.weight",
+        "blocks.0.mlp.fc1.weight",
+        "rope.inv_freq",
+    }
+    assert [shard_id for shard_id, _ in qkv_calls] == ["q", "k", "v"]
+    assert [shard_id for shard_id, _ in fc1_calls] == [0, 1]
+    torch.testing.assert_close(model.blocks[0].attn.qkv_proj.weight, torch.cat((q, k, v)))
+    torch.testing.assert_close(model.blocks[0].mlp.fc1.weight, torch.cat((mlp[3:], mlp[:3])))
+    torch.testing.assert_close(
+        model.rope.inv_freq,
+        1.0 / (10000.0 ** (torch.arange(0, 4, 2, dtype=torch.float32) / 4)),
+        rtol=0,
+        atol=0,
+    )
+
+
+def test_native_load_weights_keeps_grouped_qkv_and_gate_first_layouts():
+    model, qkv_calls, fc1_calls = _load_fixture(diffusers_weights=False)
+    grouped_qkv = torch.arange(36, dtype=torch.float32).reshape(12, 3)
+    fc1 = torch.arange(18, dtype=torch.float32).reshape(6, 3)
+
+    loaded = model.load_weights(
+        [
+            ("blocks.0.attn.qkv_proj.weight", grouped_qkv),
+            ("blocks.0.mlp.fc1.weight", fc1),
+        ]
+    )
+
+    expected_qkv = torch.cat(
+        (
+            grouped_qkv[:2],
+            grouped_qkv[6:8],
+            grouped_qkv[2:4],
+            grouped_qkv[8:10],
+            grouped_qkv[4:6],
+            grouped_qkv[10:],
+        )
+    )
+    assert loaded == {"blocks.0.attn.qkv_proj.weight", "blocks.0.mlp.fc1.weight"}
+    assert [shard_id for shard_id, _ in qkv_calls] == [None]
+    assert [shard_id for shard_id, _ in fc1_calls] == [0, 1]
+    torch.testing.assert_close(model.blocks[0].attn.qkv_proj.weight, expected_qkv)
+    torch.testing.assert_close(model.blocks[0].mlp.fc1.weight, fc1)
+    assert torch.equal(model.rope.inv_freq, torch.zeros(2))
+
+
+def test_diffusers_load_weights_rejects_unknown_name():
+    model, _, _ = _load_fixture(diffusers_weights=True)
+
+    with pytest.raises(ValueError, match="unsupported Diffusers H3 weight"):
+        model.load_weights([("transformer_blocks.0.attn.not_a_projection.weight", torch.zeros(4, 3))])
+
+
+def test_diffusers_load_weights_rejects_duplicate_source_name():
+    model, _, _ = _load_fixture(diffusers_weights=True)
+    weight = torch.zeros(4, 3)
+
+    with pytest.raises(ValueError, match="duplicate Diffusers H3 weight"):
+        model.load_weights(
+            [
+                ("transformer_blocks.0.attn.to_q.weight", weight),
+                ("transformer_blocks.0.attn.to_q.weight", weight),
+            ]
+        )
+
+
+def test_diffusers_load_weights_rejects_incomplete_qkv_group():
+    model, _, _ = _load_fixture(diffusers_weights=True)
+
+    with pytest.raises(ValueError, match="incomplete Diffusers H3 QKV"):
+        model.load_weights(
+            [
+                ("transformer_blocks.0.attn.to_q.weight", torch.zeros(4, 3)),
+                ("transformer_blocks.0.attn.to_k.weight", torch.zeros(4, 3)),
+            ]
+        )
+
+
+def test_diffusers_load_weights_rejects_missing_compression_gate_parameter():
+    model, _, _ = _load_fixture(diffusers_weights=True)
+
+    with pytest.raises(ValueError, match="has no model parameter"):
+        model.load_weights([("transformer_blocks.0.attn.to_gate_compress.weight", torch.zeros(4, 3))])
+
+
+def test_resolve_sigma_positions_uses_release_metadata_schedule():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    nn.Module.__init__(pipeline)
+    pipeline._fasth3 = None
+    pipeline._lora_sigma_schedules = {}
+    spec = FastH3CheckpointSpec.from_metadata(_fastvideo_metadata())
+    pipeline._base_schedule_by_partition = {
+        "fl2va": DMD2SigmaSchedule.from_metadata(spec.release_metadata()),
+    }
+
+    positions, steps = pipeline._resolve_sigma_positions("t2va", _sampling())
+    assert positions == FASTH3_V2_BASE_SCHEDULE.base_schedule
+    assert steps == 8 == len(positions) - 1
+    with pytest.raises(OmniClientError, match="must be 8"):
+        pipeline._resolve_sigma_positions("t2va", _sampling(num_inference_steps=9))
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_collectives.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_collectives.py
index 9d44bf445..796c6d93f 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_collectives.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_collectives.py
@@ -87,7 +87,8 @@ def _collective_worker(rank, rendezvous, backend):
         sampling = OmniDiffusionSamplingParams(
             height=32, width=32, num_frames=96, extra_args={"task": "t2va", "aspect_ratio": "1:1"}
         )
-        text_conditioning = model._prepare_local_conditioning({"prompt": "test"}, sampling)
+        text_conditioning, window_text = model._prepare_local_conditioning({"prompt": "test"}, sampling)
+        assert window_text is None
         torch.testing.assert_close(text_conditioning.hidden_states, torch.full_like(text_conditioning.hidden_states, 2))
         assert text_conditioning.visual_condition is None
 
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_continuation.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_continuation.py
new file mode 100644
index 000000000..7c20cff08
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_continuation.py
@@ -0,0 +1,231 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.minimax_h3.continuation import (
+    diffuse_continuation,
+    plan_continuation_windows,
+    resolve_continuation,
+)
+from vllm_omni.diffusion.models.minimax_h3.packed_sequence import minimax_h3_packed_sequence_ref2va_blocks
+from vllm_omni.errors import OmniClientError
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.mark.parametrize("vary_prompts", [False, True])
+@pytest.mark.parametrize("total,window", [(1807, 277), (1807, 243), (124, 277)])
+def test_continuation_retains_prefix_and_global_stereo_timeline(total, window, vary_prompts):
+    audio_t = round(total * 40 / 24)
+    source = torch.arange(2 * audio_t * 32).reshape(2, audio_t, 32).float()
+    calls = []
+    plan = plan_continuation_windows(total, window, 22)
+    texts = [(torch.full((3 + i, 8), float(i)), torch.ones(3 + i, dtype=torch.long)) for i in range(len(plan))]
+
+    def sample(**kw):
+        calls.append(kw)
+        t = kw["latent_t"]
+        if vary_prompts:
+            assert kw["text_embeddings"] is texts[len(calls) - 1][0]
+            assert kw["text_tags"] is texts[len(calls) - 1][1]
+            assert kw["media_time_origin"] == len(texts[-1][0])
+        # Different constants expose replacement of an old prefix or an
+        # accidental append of the hidden overlap.
+        video = torch.full((1, 24, t, 2, 2), float(len(calls)))
+        audio = kw["locked_audio_rows"].reshape(2, kw["audio_t"], 32).permute(0, 2, 1)
+        if len(calls) > 1:
+            assert torch.all(kw["visual_condition"] == len(calls) - 1)
+            assert kw["ref_blocks"][-1]["kind"] == "latent_guide"
+        return video, audio
+
+    kwargs = dict(
+        num_frames=total,
+        latent_t=(total - 5) // 17 * 5 + 2,
+        latent_h=2,
+        latent_w=2,
+        audio_t=audio_t,
+        locked_audio_rows=source.reshape(-1, 32),
+    )
+    video, audio = diffuse_continuation(
+        sample, kwargs, window_frames=window, overlap_frames=22, text_conditioning=texts if vary_prompts else None
+    )
+    torch.testing.assert_close(audio, source.permute(0, 2, 1))
+    plan = plan_continuation_windows(total, window, 22)
+    assert [call["temporal_offset"] for call in calls] == pytest.approx([part.start * 40 / 24 for part in plan])
+    offset = 0
+    for i, part in enumerate(plan):
+        new_frames = part.end - part.start - part.overlap
+        count = (new_frames - 5) // 17 * 5 + 2 if i == 0 else new_frames // 17 * 5
+        assert torch.all(video[:, :, offset : offset + count] == i + 1)
+        offset += count
+    assert offset == video.shape[2] == kwargs["latent_t"]
+
+
+@pytest.mark.parametrize("temporal_offset", [0.0, 425.0, 221 * 40 / 24])
+def test_latent_guide_shares_target_clock_and_remains_condition_only(temporal_offset):
+    packed = minimax_h3_packed_sequence_ref2va_blocks(
+        temporal_offset=temporal_offset,
+        text_len=3,
+        latent_t=12,
+        latent_h=4,
+        latent_w=4,
+        audio_t=68,
+        ref_blocks=[
+            {"kind": "image", "latent_h": 4, "latent_w": 4},
+            {"kind": "latent_guide", "latent_t": 7, "latent_h": 4, "latent_w": 4, "ref_audio_t": 37},
+        ],
+    )
+    pos = packed["img_position_ids"]
+    visual = packed["img_pos"]
+    target = visual[packed["update_mask"]]
+    guide = visual[~packed["update_mask"]][4:]
+    torch.testing.assert_close(pos[guide], pos[target[:28]])
+    audio = packed["audio_pos"]
+    guide_audio = audio[~packed["audio_update_mask"]].reshape(2, 37)
+    target_audio = audio[packed["audio_update_mask"]].reshape(2, 68)
+    torch.testing.assert_close(pos[guide_audio], pos[target_audio[:, :37]])
+    assert pos[target[0], 0] == pytest.approx(4 + temporal_offset)
+    torch.testing.assert_close(pos[:3, 0], torch.arange(3, dtype=torch.float64))
+    assert torch.all(pos[3:7, 0] == 3)  # static reference image stays fixed
+
+
+@pytest.mark.parametrize(
+    "extra,step",
+    [
+        ({"long_video_mode": "bad"}, False),
+        ({"long_video_mode": "continuation"}, True),
+        ({"long_video_mode": "continuation", "continuation_overlap_frames": 23}, False),
+        ({"long_video_mode": "continuation", "continuation_window_frames": True}, False),
+        ({"long_video_mode": "continuation", "continuation_overlap_frames": 277}, False),
+    ],
+)
+def test_invalid_continuation_options(extra, step):
+    with pytest.raises(OmniClientError):
+        resolve_continuation(extra, task="ref2va", step_execution=step)
+
+
+def test_global_offset_moves_temporal_references_but_not_images_or_padding():
+    kwargs = dict(
+        text_len=3,
+        latent_t=12,
+        latent_h=4,
+        latent_w=4,
+        audio_t=68,
+        ref_blocks=[
+            {"kind": "image", "latent_h": 4, "latent_w": 4},
+            {"kind": "audio", "ref_audio_t": 3},
+            {"kind": "video_audio", "ref_audio_t": 2, "latent_t": 2, "latent_h": 4, "latent_w": 4},
+            {"kind": "image", "latent_h": 4, "latent_w": 4},
+            {"kind": "latent_guide", "ref_audio_t": 37, "latent_t": 7, "latent_h": 4, "latent_w": 4},
+        ],
+    )
+    base = minimax_h3_packed_sequence_ref2va_blocks(**kwargs)
+    shifted = minimax_h3_packed_sequence_ref2va_blocks(**kwargs, temporal_offset=425.0)
+    moving = base["image_mask"] | base["audio_mask"]
+    moving[3:7] = False  # first static image
+    moving[25:29] = False  # static image after temporal references
+    delta = shifted["img_position_ids"] - base["img_position_ids"]
+    torch.testing.assert_close(delta[:, 0], moving.double() * 425)
+    assert torch.count_nonzero(delta[:, 1:]) == 0
+    for key, value in base.items():
+        if isinstance(value, torch.Tensor) and key != "img_position_ids":
+            torch.testing.assert_close(shifted[key], value)
+
+
+def test_long_ref2va_defaults_to_continuation_with_explicit_full_opt_out():
+    assert resolve_continuation({"long_video": True}, task="ref2va", step_execution=False) == (277, 22)
+    assert resolve_continuation({}, task="ref2va", step_execution=False) is None
+    assert (
+        resolve_continuation({"long_video": True, "long_video_mode": "full"}, task="ref2va", step_execution=False)
+        is None
+    )
+
+
+def test_different_chunk_prompt_lengths_keep_the_same_media_clock():
+    kwargs = dict(
+        latent_t=7,
+        latent_h=4,
+        latent_w=4,
+        audio_t=37,
+        ref_blocks=[{"kind": "image", "latent_h": 4, "latent_w": 4}],
+        media_time_origin=20,
+    )
+    first = minimax_h3_packed_sequence_ref2va_blocks(text_len=3, **kwargs)
+    second = minimax_h3_packed_sequence_ref2va_blocks(text_len=15, temporal_offset=425, **kwargs)
+    for key, mask in (("img_pos", "update_mask"), ("audio_pos", "audio_update_mask")):
+        a = first["img_position_ids"][first[key][first[mask]]]
+        b = second["img_position_ids"][second[key][second[mask]]]
+        torch.testing.assert_close(b[:, 0] - a[:, 0], torch.full_like(a[:, 0], 425))
+        torch.testing.assert_close(b[:, 1:], a[:, 1:])
+
+
+@pytest.mark.parametrize("prompt_count", [None, 7, 6])
+def test_request_encodes_only_window_prompts_and_prepares_references_once(monkeypatch, prompt_count):
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+    from vllm_omni.model_executor.models.minimax_h3.conditioning import MiniMaxH3EncoderMediaConditioning
+
+    pipeline = object.__new__(module.MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.load_text_encoder = True
+    pipeline.device = torch.device("cpu")
+    pipeline.od_config = None
+    pipeline._active_turbo_spec = lambda sampling: None
+    pipeline._has_active_native_lora = lambda sampling: False
+    pipeline._resolve_task = lambda *args, **kwargs: "ref2va"
+    encoded, prepared_inputs, encoded_media = [], [], []
+    prepare = module.prepare_encoder_inputs
+
+    def prepare_once(*args, **kwargs):
+        result = prepare(*args, **kwargs)
+        prepared_inputs.append(result)
+        return result
+
+    def encode_text(prepared):
+        encoded.append(prepared)
+        return torch.full((3, 5120), len(encoded), dtype=torch.bfloat16), torch.zeros(3, dtype=torch.long)
+
+    def encode_media(media):
+        encoded_media.append(media)
+        return MiniMaxH3EncoderMediaConditioning(
+            task=media.task,
+            height=media.height,
+            width=media.width,
+            num_frames=media.num_frames,
+            latent_t=media.latent_t,
+            audio_t=media.audio_t,
+        )
+
+    monkeypatch.setattr(module, "prepare_encoder_inputs", prepare_once)
+    pipeline.encode_prompt = encode_text
+    pipeline._encode_local_media = encode_media
+    pipeline._prepare_encoder_conditioning_inputs = lambda conditioning, sampling: {
+        "text_embeddings": conditioning.hidden_states,
+        "continuation": (277, 22),
+        "num_frames": conditioning.num_frames,
+        "task": conditioning.task,
+    }
+    extra = {"task": "ref2va", "long_video": True, "duration": 75}
+    if prompt_count is not None:
+        extra["continuation_prompts"] = [f"window {i}" for i in range(prompt_count)]
+    sampling = OmniDiffusionSamplingParams(width=64, height=64, fps=24, extra_args=extra)
+    request = {"prompt": "main prompt", "multi_modal_data": {"image": Image.new("RGB", (256, 256))}}
+    if prompt_count == 6:
+        with pytest.raises(OmniClientError, match="exactly 7"):
+            pipeline._prepare_request_inputs(request, sampling)
+        assert not encoded and not encoded_media
+        return
+    context = pipeline._prepare_request_inputs(request, sampling)
+    assert [item.prompt for item in encoded] == extra.get("continuation_prompts", ["main prompt"])
+    assert len(prepared_inputs) == len(encoded_media) == 1
+    assert all(item.media is prepared_inputs[0].media for item in encoded)
+    if prompt_count is not None:
+        texts = context["continuation_text_conditioning"]
+        assert len(texts) == 7
+        assert texts[0][0] is context["text_embeddings"]
+        assert [int(hidden[0, 0]) for hidden, _ in texts] == list(range(1, 8))
+    else:
+        assert "continuation_text_conditioning" not in context
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
index 4b6fc0d88..8cc3f1a9e 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
@@ -3,7 +3,7 @@
 
 import json
 import sys
-from contextlib import contextmanager
+from contextlib import contextmanager, nullcontext
 from multiprocessing.reduction import ForkingPickler
 from types import SimpleNamespace
 from typing import Any, TypeVar
@@ -282,15 +282,44 @@ def test_encoder_task_validation_and_transformer_routing():
     assert pipeline._resolve_task(None, {"image": object()}) == "fl2va"
     assert pipeline._resolve_task(None, {"audio": object()}) == "ref2va"
     assert pipeline._resolve_task(None, {"video": object()}) == "ref2va"
+    assert pipeline._resolve_task(None, {"audio": object()}, audio_mode="lock_source") == "t2va"
+    assert (
+        pipeline._resolve_task(
+            None,
+            {"image": object(), "audio": object()},
+            audio_mode="lock_source",
+        )
+        == "fl2va"
+    )
+    assert (
+        pipeline._resolve_task(
+            None,
+            {"video": object(), "audio": object()},
+            audio_mode="lock_source",
+        )
+        == "ref2va"
+    )
     fl2v_spec = _turbo_spec("minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors")
     ref2v_spec = _turbo_spec("minimax_h3_ref2v_turbo_8step_v1.0_768p_bf16.safetensors")
     assert pipeline._resolve_task("fl2va", {"image": object()}, turbo_spec=fl2v_spec) == "fl2va"
     with pytest.raises(OmniClientError, match="serves"):
         pipeline._resolve_task("ref2va", {}, turbo_spec=fl2v_spec)
     assert pipeline._resolve_task("ref2va", {"image": object()}, turbo_spec=ref2v_spec) == "ref2va"
+    pipeline.partition = "fl2va"
+    pipeline.supported_tasks = frozenset({"t2va", "fl2va"})
+    assert pipeline._resolve_task(None, {"audio": object()}, audio_mode="lock_source") == "t2va"
+    assert (
+        pipeline._resolve_task(
+            None,
+            {"image": object(), "audio": object()},
+            audio_mode="lock_source",
+        )
+        == "fl2va"
+    )
     pipeline.partition = "ref2va"
     pipeline.supported_tasks = frozenset({"ref2va"})
     assert pipeline._resolve_task("ref2va") == "ref2va"
+    assert pipeline._resolve_task(None, {"audio": object()}, audio_mode="lock_source") == "ref2va"
 
     pipeline.partition = "combined"
     pipeline.supported_tasks = frozenset({"t2va", "fl2va", "ref2va"})
@@ -423,6 +452,7 @@ def test_pipeline_loads_task_selected_components_with_encoder_ownership(
     assert pipeline.partition == expected_partition
     assert pipeline.supported_tasks == expected_tasks
     assert len(created["dit"]) == expected_dits
+    assert all(kwargs["diffusers_weights"] is False for _, kwargs in created["dit"])
     component_path = tmp_path / component_partition
     assert created["video_vae"] == [str(component_path / "video_vae")]
     assert created["audio_vae"] == [str(component_path / "audio_vae")]
@@ -1041,6 +1071,56 @@ def test_packed_attention_rejects_backends_without_multi_doc_capability(backend_
         )
 
 
+def test_rainfusion_packed_padding_stays_mask_free_on_unaligned_lengths():
+    """Regression for the #5543 follow-up crash fixed in #7235.
+
+    MiniMax-H3 pads every packed request to a multiple of 64 rows, so any
+    non-64-aligned length reaches this path with used < packed_total. Before
+    RAINFUSION_ATTN advertised supports_prefix_kv_slicing, the model built a
+    padding mask here that _assert_metadata_compatible then rejected at the
+    first sparse layer. This drives the real backend class (not a fake flag)
+    through the packed path; both the sparse dispatch and the dense fallback
+    share this metadata construction and neither ever reads attn_mask.
+    """
+    from vllm_omni.diffusion.attention.backends.rainfusion_attn import (
+        RainFusionAttentionBackend,
+    )
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3Attention,
+    )
+
+    class FakeAttention(torch.nn.Module):
+        attn_backend = RainFusionAttentionBackend
+
+        def __init__(self):
+            super().__init__()
+            self.metadata = None
+
+        def forward(self, query, key, value, metadata):
+            self.metadata = metadata
+            return query
+
+    attention = object.__new__(MiniMaxH3Attention)
+    torch.nn.Module.__init__(attention)
+    attention.attention = FakeAttention()
+    q = torch.randn(8, 2, 4)
+
+    attention._run_packed_attention(
+        q,
+        q,
+        q,
+        # One request: 5 valid rows padded to the 8-row alignment boundary.
+        cu_seqlens=torch.tensor([0, 5, 8], dtype=torch.int32),
+        max_seqlen=5,
+        packed_total=8,
+    )
+
+    metadata = attention.attention.metadata
+    assert metadata is not None
+    assert metadata.attn_mask is None
+    assert metadata.extra["valid_kv_length"] == 5
+
+
 def test_reference_image_resize_contract():
     from PIL import Image
 
@@ -1099,6 +1179,7 @@ def test_minimax_h3_advertises_the_official_ref2va_image_limit():
     from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
 
     assert get_diffusion_model_metadata("MiniMaxH3Pipeline").max_multimodal_image_inputs == 9
+    assert get_diffusion_model_metadata("MiniMaxH3Pipeline").supports_latent_mask_editing
 
 
 def test_text_attention_routes_local_gqa_heads_through_sdpa_helper(monkeypatch):
@@ -2756,41 +2837,63 @@ def test_dit_encoder_selection_keeps_vae_resident():
     component.offload_to_cpu.assert_not_called()
 
 
-def test_keyframe_encode_pins_and_restores_cudnn_settings():
+@pytest.mark.parametrize(
+    ("capability", "allow_tf32"),
+    [((8, 6), True), ((9, 0), False), ((10, 0), True), ((10, 3), True), (None, True)],
+)
+@pytest.mark.parametrize("initial_tf32", [False, True])
+@pytest.mark.parametrize("fail_encode", [False, True])
+def test_keyframe_encode_pins_and_restores_cudnn_settings(
+    monkeypatch, capability, allow_tf32, initial_tf32, fail_encode
+):
+    from vllm.platforms.interface import DeviceCapability
+
     from vllm_omni.diffusion.models.minimax_h3.vae import (
         _minimax_h3_keyframe_encode_context,
     )
+    from vllm_omni.platforms import current_omni_platform
+
+    def get_capability(device_id):
+        assert device_id == 1
+        return DeviceCapability(*capability) if capability is not None else None
+
+    monkeypatch.setattr(current_omni_platform, "is_cuda", lambda: True)
+    monkeypatch.setattr(current_omni_platform, "get_device_capability", get_capability)
 
     cudnn = torch.backends.cudnn
-    original = (
-        cudnn.enabled,
-        cudnn.benchmark,
-        cudnn.deterministic,
-        cudnn.allow_tf32,
-    )
-    try:
-        cudnn.enabled = False
-        cudnn.benchmark = True
-        cudnn.deterministic = False
-        cudnn.allow_tf32 = False
-
-        with _minimax_h3_keyframe_encode_context(torch.device("cuda")):
+    with cudnn.flags(enabled=False, benchmark=True, deterministic=False, allow_tf32=initial_tf32):
+        error_context = pytest.raises(RuntimeError, match="encode failed") if fail_encode else nullcontext()
+        with error_context, _minimax_h3_keyframe_encode_context(torch.device("cuda:1")):
             assert cudnn.enabled
             assert not cudnn.benchmark
             assert cudnn.deterministic
-            assert cudnn.allow_tf32
+            assert cudnn.allow_tf32 is allow_tf32
+            if fail_encode:
+                raise RuntimeError("encode failed")
 
         assert not cudnn.enabled
         assert cudnn.benchmark
         assert not cudnn.deterministic
-        assert not cudnn.allow_tf32
-    finally:
-        (
-            cudnn.enabled,
-            cudnn.benchmark,
-            cudnn.deterministic,
-            cudnn.allow_tf32,
-        ) = original
+        assert cudnn.allow_tf32 is initial_tf32
+
+
+def test_keyframe_encode_cpu_keeps_cudnn_settings(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3.vae import (
+        _minimax_h3_keyframe_encode_context,
+    )
+    from vllm_omni.platforms import current_omni_platform
+
+    def unexpected_capability_query(device_id):
+        pytest.fail("CPU keyframe encode must not query CUDA capability")
+
+    monkeypatch.setattr(current_omni_platform, "get_device_capability", unexpected_capability_query)
+    cudnn = torch.backends.cudnn
+    with cudnn.flags(enabled=False, benchmark=True, deterministic=False, allow_tf32=False):
+        with _minimax_h3_keyframe_encode_context(torch.device("cpu")):
+            assert not cudnn.enabled
+            assert cudnn.benchmark
+            assert not cudnn.deterministic
+            assert not cudnn.allow_tf32
 
 
 @pytest.mark.parametrize("fail_encode", [False, True])
@@ -2851,15 +2954,17 @@ def test_decode_to_mp4_batches_consumer_transfers(monkeypatch):
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
 
     class FakeEncoder:
-        instances = []
+        instances: list["FakeEncoder"] = []
 
         def __init__(self, **kwargs):
             self.pushes = []
             self.kwargs = kwargs
             self.__class__.instances.append(self)
 
-        def push(self, frames):
+        def push(self, frames, *, on_consumed=None):
             self.pushes.append(np.array(frames, copy=True))
+            if on_consumed is not None:
+                on_consumed()
 
         def finish(self):
             return b"mp4"
@@ -2872,6 +2977,8 @@ def test_decode_to_mp4_batches_consumer_transfers(monkeypatch):
             return torch.zeros(1, 1, 2)
 
     class FakeVideoVAE:
+        chunk_value_range = (0.0, 1.0)
+
         def decode_with_chunks(self, latent, *, on_chunk):
             for value in (0.0, 0.25, 0.5):
                 on_chunk(torch.full((1, 3, 3, 2, 2), value))
@@ -2883,7 +2990,7 @@ def test_decode_to_mp4_batches_consumer_transfers(monkeypatch):
     pipeline.device = torch.device("cpu")
     monkeypatch.setattr(mod.MiniMaxH3Pipeline, "_uses_manual_component_offload", lambda self, component: False)
     monkeypatch.setattr(
-        "vllm_omni.diffusion.utils.media_utils.ChunkedMP4Encoder",
+        "vllm_omni.diffusion.utils.chunked_video.ChunkedMP4Encoder",
         FakeEncoder,
     )
 
@@ -2903,19 +3010,90 @@ def test_decode_to_mp4_batches_consumer_transfers(monkeypatch):
     assert encoder.pushes[1].shape == (3, 2, 2, 3)
 
 
+def _peer_rank_preencode_pipeline(monkeypatch):
+    """An H3 pipeline whose video VAE is a distributed rank that owns no output.
+
+    Every rank of the VAE group must call ``decode_with_chunks`` to keep the
+    temporal collectives in lockstep, but only the owner receives chunks, so a
+    peer's callback is never invoked.
+    """
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
+
+    class FakeAudioVAE:
+        def decode_latent(self, latent):
+            return torch.zeros(1, 1, 2)
+
+    class PeerRankVideoVAE:
+        chunk_value_range = (0.0, 1.0)
+
+        def decode_with_chunks(self, latent, *, on_chunk):
+            del latent, on_chunk
+
+    pipeline = object.__new__(mod.MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.audio_vae = FakeAudioVAE()
+    pipeline.video_vae = PeerRankVideoVAE()
+    pipeline.device = torch.device("cpu")
+    pipeline.od_config = SimpleNamespace()
+    monkeypatch.setattr(mod.MiniMaxH3Pipeline, "_uses_manual_component_offload", lambda self, component: False)
+    return pipeline
+
+
+def test_peer_vae_rank_returns_no_preencoded_output_instead_of_failing(monkeypatch):
+    """A rank that owns no output must not turn its silence into a request error."""
+    pipeline = _peer_rank_preencode_pipeline(monkeypatch)
+
+    output = pipeline.decode_to_mp4(torch.zeros(1), torch.zeros(1), height=2, width=2)
+
+    assert output == b""
+
+
+def test_peer_vae_rank_post_decode_reaches_post_processing(monkeypatch):
+    """The real H3 post_decode chain, not just the shared consumer, tolerates a peer rank."""
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
+    from vllm_omni.diffusion.worker.utils import StepRequestState
+
+    pipeline = _peer_rank_preencode_pipeline(monkeypatch)
+    monkeypatch.setattr(pipeline, "_unpack_denoised_rows", lambda *args, **kwargs: (torch.zeros(1), torch.zeros(1)))
+    state = StepRequestState(
+        request_id="peer-rank",
+        sampling=SimpleNamespace(num_outputs_per_prompt=1),
+        prompt="a prompt",
+    )
+    state.latents = torch.zeros(1)
+    state.extra[mod._STEP_BRANCH] = object()
+    state.extra[mod._STEP_AUDIO_ROWS] = torch.zeros(1)
+    state.extra[mod._STEP_SHAPE] = {
+        "latent_t": 1,
+        "latent_h": 1,
+        "latent_w": 1,
+        "audio_t": 1,
+        "height": 2,
+        "width": 2,
+        "preencode_mp4": True,
+    }
+
+    output = pipeline.post_decode(state)
+
+    assert output.output == (b"", None)
+    assert mod._minimax_h3_post_process(output.output)["video"] == [b""]
+
+
 def test_request_video_codec_options_reach_the_preencoded_mp4_encoder(monkeypatch):
     """A client's encoder options must survive the worker-side pre-encode path."""
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
 
     class FakeEncoder:
-        instances = []
+        instances: list["FakeEncoder"] = []
 
         def __init__(self, **kwargs):
             self.kwargs = kwargs
             self.__class__.instances.append(self)
 
-        def push(self, frames):
+        def push(self, frames, *, on_consumed=None):
             del frames
+            if on_consumed is not None:
+                on_consumed()
 
         def finish(self):
             return b"mp4"
@@ -2928,6 +3106,8 @@ def test_request_video_codec_options_reach_the_preencoded_mp4_encoder(monkeypatc
             return torch.zeros(1, 1, 2)
 
     class FakeVideoVAE:
+        chunk_value_range = (0.0, 1.0)
+
         def decode_with_chunks(self, latent, *, on_chunk):
             on_chunk(torch.zeros(1, 3, 1, 2, 2))
 
@@ -2937,7 +3117,7 @@ def test_request_video_codec_options_reach_the_preencoded_mp4_encoder(monkeypatc
     pipeline.video_vae = FakeVideoVAE()
     pipeline.device = torch.device("cpu")
     monkeypatch.setattr(mod.MiniMaxH3Pipeline, "_uses_manual_component_offload", lambda self, component: False)
-    monkeypatch.setattr("vllm_omni.diffusion.utils.media_utils.ChunkedMP4Encoder", FakeEncoder)
+    monkeypatch.setattr("vllm_omni.diffusion.utils.chunked_video.ChunkedMP4Encoder", FakeEncoder)
 
     pipeline.decode_to_mp4(
         torch.zeros(1),
@@ -3010,3 +3190,19 @@ def test_video_codec_options_are_normalized_for_the_encoder():
     assert normalize_video_codec_options(None) is None
     with pytest.raises(ValueError, match="video_codec_options"):
         normalize_video_codec_options("preset=ultrafast")
+
+
+@pytest.mark.parametrize("duration", [60, 75])
+def test_long_video_shape_requires_explicit_opt_in(duration):
+    from vllm_omni.errors import OmniClientError
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import resolve_minimax_h3_shape
+
+    sampling = OmniDiffusionSamplingParams(width=960, height=544, fps=24, extra_args={"duration": duration})
+    with pytest.raises(OmniClientError, match="15"):
+        resolve_minimax_h3_shape("ref2va", sampling, None)
+    sampling.extra_args["long_video"] = True
+    _, _, frames, video_t, audio_t = resolve_minimax_h3_shape("ref2va", sampling, None)
+    assert frames >= duration * 24 and frames % 17 == 5
+    assert video_t == (frames - 5) // 17 * 5 + 2
+    assert audio_t == round(frames / 24 * 40)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_fasth3.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_fasth3.py
index 5c874ff02..c89c37db9 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_fasth3.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_fasth3.py
@@ -262,7 +262,10 @@ def test_a_vsa_variant_is_recognised_by_its_compression_gates(tmp_path):
 
 def test_a_tensor_naming_no_h3_parameter_is_an_error(tmp_path):
     path = tmp_path / "fasth3" / "adapter_model.safetensors"
-    _write_adapter(path, tensors={"transformer_blocks.0.attn.norm_q.lora_A.weight": torch.ones((_RANK, _HIDDEN))})
+    _write_adapter(
+        path,
+        tensors={"transformer_blocks.0.attn.not_a_projection.lora_A.weight": torch.ones((_RANK, _HIDDEN))},
+    )
     # Dropping it silently would load a model that is not the distilled student.
     with pytest.raises(FastH3AdapterError, match="name no known"):
         _load(path.parent)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_latent_edit_pipeline.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_latent_edit_pipeline.py
new file mode 100644
index 000000000..2de255886
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_latent_edit_pipeline.py
@@ -0,0 +1,259 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Pipeline-level MiniMax H3 latent initialization tests."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_prepare_edit_video_clones_the_last_frame_with_lossless_rgb(monkeypatch, tmp_path):
+    from vllm_omni.model_executor.models.minimax_h3 import reference_video
+
+    source = tmp_path / "source.webm"
+    commands: list[list[str]] = []
+    monkeypatch.setattr(
+        reference_video,
+        "_probe_video",
+        lambda _path: {"frame_count": 12, "audio_codecs": ("opus",)},
+    )
+    monkeypatch.setattr(
+        reference_video.subprocess,
+        "run",
+        lambda command, **_kwargs: commands.append(command),
+    )
+
+    prepared = reference_video.prepare_edit_video(
+        source,
+        target_width=448,
+        target_height=256,
+        target_frame_count=73,
+        workdir=str(tmp_path / "prepared"),
+    )
+
+    assert prepared["input_has_audio"] is True
+    assert prepared["frame_count"] == 73
+    command = commands[0]
+    assert command[command.index("-vf") + 1].endswith("tpad=stop_mode=clone:stop=-1")
+    assert command[command.index("-c:v") + 1] == "libx264rgb"
+    assert command[command.index("-pix_fmt") + 1] == "rgb24"
+
+
+@pytest.mark.parametrize("source_audio", [None, "override.wav"])
+def test_encoder_preparation_routes_edit_sources_without_qwen_inputs(
+    monkeypatch,
+    tmp_path,
+    source_audio,
+):
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+
+    latent_t, audio_t = 7, 37
+    video_clean = torch.full((42, 96), 3.0)
+    audio_source = torch.zeros(4, 32)
+    audio_source[:, 0] = torch.tensor([1.0, 2.0, 11.0, 12.0])
+    waveform = torch.zeros(3_200)
+    frames = torch.zeros(22, 64, 96, 3, dtype=torch.uint8).numpy()
+    calls: dict[str, Any] = {}
+
+    def prepare_video(value, **kwargs):
+        calls["prepare"] = (value, kwargs)
+        return {
+            "original_path": "source.mov",
+            "prepared_path": str(tmp_path / "prepared.mp4"),
+            "input_has_audio": True,
+        }
+
+    def load_video_audio(value, **kwargs):
+        calls["video_audio"] = (value, kwargs)
+        return waveform, 32_000
+
+    def load_audio_file(value):
+        calls["audio_file"] = value
+        return waveform, 32_000
+
+    class VideoVAE:
+        def encode_video(self, value):
+            calls["video_encode_shape"] = value.shape
+            return video_clean.clone(), (latent_t, 4, 6)
+
+    class AudioVAE:
+        def encode_waveform(self, value, sample_rate):
+            calls["audio_encode"] = (value.shape, sample_rate)
+            return audio_source.clone(), 2
+
+    monkeypatch.setattr(processing, "resolve_minimax_h3_shape", lambda *_args: (64, 96, 22, latent_t, audio_t))
+    monkeypatch.setattr(processing, "prepare_edit_video", prepare_video)
+    monkeypatch.setattr(processing, "load_video_frames", lambda _path: frames)
+    monkeypatch.setattr(processing, "load_video_audio", load_video_audio)
+    monkeypatch.setattr(processing, "load_audio_file", load_audio_file)
+
+    prepared = processing.prepare_encoder_inputs(
+        {
+            "prompt": "edit the clip",
+            "multi_modal_data": {
+                "source_video": "source.mov",
+                "source_audio": source_audio,
+                "video_noise_mask": torch.zeros(1, 1, latent_t, 4, 6),
+                "audio_noise_mask": torch.tensor([0.0, 0.5, *([0.0] * (audio_t - 2))]).reshape(1, 1, -1),
+            },
+        },
+        SimpleNamespace(extra_args={"task": "t2va"}),
+    )
+    media = type(prepared.media).from_mm_tensors(
+        prepared.media.to_mm_tensors(),
+        prepared.media.to_metadata(),
+    )
+    conditioning = processing.encode_media(
+        media,
+        video_vae=VideoVAE(),
+        audio_vae=AudioVAE(),
+        emit_conditioning=True,
+    )
+
+    assert prepared.images == []
+    assert prepared.qwen_videos == []
+    assert prepared.condition_labels == []
+    assert prepared.media.images == ()
+    assert prepared.media.videos == ()
+    assert calls["prepare"][0] == "source.mov"
+    assert calls["prepare"][1]["target_width"] == 96
+    assert calls["prepare"][1]["target_height"] == 64
+    assert calls["prepare"][1]["target_frame_count"] == 22
+    if source_audio is None:
+        assert calls["video_audio"] == (
+            "source.mov",
+            {"duration_seconds": pytest.approx(22 / 24)},
+        )
+        assert "audio_file" not in calls
+    else:
+        assert calls["audio_file"] == "override.wav"
+        assert "video_audio" not in calls
+
+    assert conditioning is not None
+    torch.testing.assert_close(conditioning.video_edit_clean_rows, video_clean)
+    assert conditioning.video_edit_mask.shape == (latent_t, 4, 6)
+    torch.testing.assert_close(conditioning.video_edit_mask, torch.zeros(latent_t, 4, 6))
+    assert conditioning.audio_edit_source_t == 2
+    assert conditioning.audio_edit_mask.shape == (2, audio_t)
+    torch.testing.assert_close(
+        conditioning.audio_edit_clean_rows[:, 0],
+        torch.tensor([1.0, 2.0, *([0.0] * (audio_t - 2)), 11.0, 12.0, *([0.0] * (audio_t - 2))]),
+    )
+    torch.testing.assert_close(
+        conditioning.audio_edit_mask,
+        torch.tensor([0.0, 0.5, *([0.0] * (audio_t - 2))]).repeat(2, 1),
+    )
+
+    from vllm_omni.model_executor.models.minimax_h3.conditioning import (
+        MiniMaxH3EncoderConditioning,
+        MiniMaxH3TextConditioning,
+    )
+
+    combined = MiniMaxH3EncoderConditioning.from_components(
+        MiniMaxH3TextConditioning(
+            torch.zeros(1, 5120, dtype=torch.bfloat16),
+            torch.ones(1, dtype=torch.int64),
+        ),
+        conditioning,
+    )
+    round_trip = MiniMaxH3EncoderConditioning.from_omni_payload(combined.to_omni_payload())
+    torch.testing.assert_close(round_trip.video_edit_clean_rows, video_clean)
+    torch.testing.assert_close(round_trip.video_edit_mask, torch.zeros(latent_t, 4, 6))
+    torch.testing.assert_close(round_trip.audio_edit_clean_rows, conditioning.audio_edit_clean_rows)
+    torch.testing.assert_close(
+        round_trip.audio_edit_mask,
+        torch.tensor([0.0, 0.5, *([0.0] * (audio_t - 2))]).repeat(2, 1),
+    )
+    assert round_trip.audio_edit_source_t == 2
+
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.default_video_shift = 12.0
+    pipeline.default_audio_shift = 3.0
+    pipeline.od_config = SimpleNamespace(step_execution=False)
+    pipeline._fasth3 = None
+    pipeline._active_turbo_spec = lambda _sampling: None
+    pipeline._has_active_native_lora = lambda _sampling: False
+    pipeline._resolve_task = lambda task, **_kwargs: task
+    pipeline._resolve_sigma_positions = lambda _task, _sampling: (None, 3)
+    pipeline._quality_policy = SimpleNamespace(resolve=lambda **_kwargs: SimpleNamespace(cache_dit=None))
+    pipeline._cache_dit_runtime = SimpleNamespace(prepare=lambda _plan: None)
+    context = pipeline._prepare_encoder_conditioning_inputs(
+        round_trip,
+        SimpleNamespace(extra_args={}, quality=None, seed=17, num_outputs_per_prompt=1),
+    )
+    torch.testing.assert_close(context["video_edit_clean_rows"], video_clean)
+    torch.testing.assert_close(context["video_edit_mask_rows"], torch.zeros(42))
+    assert context["video_edit_restore_mask_rows"].shape == (42, 96)
+    torch.testing.assert_close(
+        context["audio_edit_mask_rows"],
+        torch.tensor([0.0, 0.5, *([1.0] * (audio_t - 2))]).repeat(2),
+    )
+    torch.testing.assert_close(context["audio_edit_mask_rows"], context["audio_edit_restore_mask_rows"])
+
+
+def _build_inputs(*, video_mask: torch.Tensor, audio_mask: torch.Tensor):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    latent_t, latent_h, latent_w, audio_t = 2, 4, 6, 3
+    video_clean = torch.linspace(-1.0, 1.0, latent_t * (latent_h // 2) * (latent_w // 2) * 96).reshape(-1, 96)
+    audio_clean = torch.linspace(-0.5, 0.5, audio_t * 2 * 32).reshape(-1, 32)
+    inputs = pipeline._build_denoise_inputs(
+        task="t2va",
+        text_embeddings=torch.zeros(2, 4),
+        text_tags=torch.ones(2, dtype=torch.long),
+        seed=17,
+        latent_t=latent_t,
+        latent_h=latent_h,
+        latent_w=latent_w,
+        audio_t=audio_t,
+        num_frames=22,
+        num_steps=3,
+        video_shift=12.0,
+        audio_shift=3.0,
+        base_schedule=None,
+        visual_condition=None,
+        visual_condition_shape=None,
+        audio_condition=None,
+        ref_audio_t=None,
+        video_edit_clean_rows=video_clean,
+        video_edit_mask_rows=video_mask,
+        video_edit_restore_mask_rows=video_mask,
+        audio_edit_clean_rows=audio_clean,
+        audio_edit_mask_rows=audio_mask,
+        audio_edit_restore_mask_rows=audio_mask,
+    )
+    return pipeline, inputs, video_clean, audio_clean
+
+
+def test_build_denoise_inputs_uses_h3_source_anchors():
+    pipeline, inputs, video_clean, audio_clean = _build_inputs(
+        video_mask=torch.zeros(12),
+        audio_mask=torch.zeros(6),
+    )
+    video_edit = inputs["video_edit"]
+    audio_edit = inputs["audio_edit"]
+    assert video_edit is not None and audio_edit is not None
+    initial_video, _ = pipeline._initial_noise(
+        seed=17,
+        latent_t=2,
+        latent_h=4,
+        latent_w=6,
+        audio_t=3,
+    )
+    torch.testing.assert_close(video_edit.clean_rows, video_clean)
+    torch.testing.assert_close(video_edit.anchor_rows, 0.999 * video_clean + 0.001 * initial_video)
+    torch.testing.assert_close(audio_edit.clean_rows, audio_clean)
+    torch.testing.assert_close(audio_edit.anchor_rows, audio_clean)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_latent_mask.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_latent_mask.py
new file mode 100644
index 000000000..91665454f
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_latent_mask.py
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Focused CPU tests for MiniMax H3 latent-mask editing."""
+
+from __future__ import annotations
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_video_full_grid_quantization_and_cell_level_restore():
+    from vllm_omni.diffusion.models.minimax_h3.latent_mask import minimax_h3_video_edit_masks
+
+    shape = dict(latent_t=2, latent_h=4, latent_w=6)
+    full = torch.arange(48, dtype=torch.float32).reshape(2, 4, 6) / 48
+    cells = full.reshape(2, 2, 2, 3, 2).permute(0, 1, 3, 2, 4)
+    parsed = minimax_h3_video_edit_masks(full, **shape)
+    expected_model = torch.ceil(cells.amax(dim=(3, 4)).reshape(-1) * 256) / 256
+    expected_restore = cells.unsqueeze(3).expand(2, 2, 3, 24, 2, 2).reshape(12, 96)
+    torch.testing.assert_close(parsed.model_mask_rows, expected_model)
+    torch.testing.assert_close(parsed.restore_mask_rows, expected_restore)
+
+
+def test_audio_grid_uses_channel_major_order_and_preserves_raw_values():
+    from vllm_omni.diffusion.models.minimax_h3.latent_mask import minimax_h3_audio_edit_masks
+
+    grid = torch.tensor([[0.0, 0.1, 1.0], [0.25, 0.5, 0.75]])
+    expected = grid.flatten()
+    parsed = minimax_h3_audio_edit_masks(grid, audio_t=3)
+    torch.testing.assert_close(parsed.model_mask_rows, torch.ceil(expected * 256) / 256)
+    torch.testing.assert_close(parsed.restore_mask_rows, expected)
+
+
+def test_zero_fractional_one_semantics_and_cell_level_restore():
+    from vllm_omni.diffusion.models.minimax_h3.latent_mask import (
+        MiniMaxH3LatentEdit,
+        minimax_h3_video_edit_masks,
+    )
+
+    clean = torch.full((3, 2), 10.0)
+    anchor = torch.tensor([[8.0, 8.0], [6.0, 6.0], [4.0, 4.0]])
+    state = torch.tensor([[2.0, 2.0], [4.0, 4.0], [6.0, 6.0]])
+    velocity = torch.full((3, 2), 2.0)
+    mask = torch.tensor([0.0, 0.5, 1.0])
+    edit = MiniMaxH3LatentEdit.from_rows(clean, anchor, mask, mask)
+    assert edit is not None
+
+    model_rows, target_timesteps = edit.prepare(state, 0.25, 0.999, sigma=0.75)
+    torch.testing.assert_close(model_rows, torch.lerp(anchor, state, mask[:, None]))
+    torch.testing.assert_close(
+        target_timesteps,
+        torch.tensor([0.999, 0.625, 0.25]),
+    )
+    predicted = model_rows + 0.75 * velocity * mask[:, None]
+    torch.testing.assert_close(edit.x0(model_rows, velocity, 0.25), torch.lerp(clean, predicted, mask[:, None]))
+
+    # A single active cell drives the full model token, while raw restoration
+    # preserves the other three cells independently in every packed channel.
+    parsed = minimax_h3_video_edit_masks(
+        torch.tensor([[[1.0, 0.0], [0.0, 0.0]]]),
+        latent_t=1,
+        latent_h=2,
+        latent_w=2,
+    )
+    restore = torch.tensor([1.0, 0.0, 0.0, 0.0]).repeat(24).reshape(1, 96)
+    torch.testing.assert_close(parsed.model_mask_rows, torch.ones(1))
+    torch.testing.assert_close(parsed.restore_mask_rows, restore)
+
+    cell_edit = MiniMaxH3LatentEdit.from_rows(
+        torch.full((1, 96), 10.0),
+        torch.full((1, 96), 8.0),
+        parsed.model_mask_rows,
+        parsed.restore_mask_rows,
+    )
+    assert cell_edit is not None
+    cell_state = torch.full((1, 96), 2.0)
+    cell_velocity = torch.full((1, 96), 4.0)
+    expected = torch.where(restore.bool(), cell_state + 0.75 * cell_velocity, cell_edit.clean_rows)
+    torch.testing.assert_close(cell_edit.x0(cell_state, cell_velocity, 0.25), expected)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_long_video_limits.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_long_video_limits.py
new file mode 100644
index 000000000..31a14c7cb
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_long_video_limits.py
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Duration limits apply before encoding and to transported encoder payloads."""
+
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+import torch
+from PIL import Image
+
+from vllm_omni.errors import OmniClientError
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
+    prepare_encoder_inputs,
+    resolve_minimax_h3_shape,
+)
+from vllm_omni.model_executor.models.minimax_h3.long_video import validate_encoded_frame_limit
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.mark.parametrize("mode,limit", [("full", 30), ("continuation", 300), (None, 300)])
+@pytest.mark.parametrize("input_kind", ["duration", "duration_seconds", "target", "num_frames"])
+def test_long_video_limits_cover_all_duration_inputs(mode, limit, input_kind):
+    extra: dict[str, Any] = {"long_video": True}
+    if mode is not None:
+        extra["long_video_mode"] = mode
+    sampling = OmniDiffusionSamplingParams(width=64, height=64, fps=24, extra_args=extra)
+
+    def set_duration(seconds):
+        if input_kind == "target":
+            extra["target"] = {"duration_seconds": seconds}
+        elif input_kind == "num_frames":
+            sampling.num_frames = seconds * 24
+        else:
+            extra[input_kind] = seconds
+
+    set_duration(limit)
+    _, _, frames, _, _ = resolve_minimax_h3_shape("ref2va", sampling, None)
+    assert frames >= limit * 24
+    validate_encoded_frame_limit(extra, "ref2va", frames)
+    with pytest.raises(OmniClientError, match="request limit"):
+        validate_encoded_frame_limit(extra, "ref2va", frames + 17)
+    set_duration(limit + 1)
+    with pytest.raises(OmniClientError, match="duration"):
+        resolve_minimax_h3_shape("ref2va", sampling, None)
+
+
+@pytest.mark.parametrize("task", ["t2va", "fl2va", "ref2va"])
+def test_full_mode_rejects_300_seconds_and_accepts_comparison(task):
+    sampling = OmniDiffusionSamplingParams(
+        width=64,
+        height=64,
+        fps=24,
+        extra_args={"long_video": True, "long_video_mode": "full", "duration": 300, "aspect_ratio": "1:1"},
+    )
+    image = Image.new("RGB", (64, 64)) if task == "fl2va" else None
+    with pytest.raises(OmniClientError, match="30"):
+        resolve_minimax_h3_shape(task, sampling, image)
+    sampling.extra_args["duration"] = 20
+    assert resolve_minimax_h3_shape(task, sampling, image)[2] == 481
+
+
+@pytest.mark.parametrize("mode", ["full", "continuation"])
+def test_mode_alone_does_not_bypass_long_video_opt_in(mode):
+    sampling = OmniDiffusionSamplingParams(
+        width=64,
+        height=64,
+        extra_args={"long_video_mode": mode, "duration": 20},
+    )
+    with pytest.raises(OmniClientError, match="15"):
+        resolve_minimax_h3_shape("ref2va", sampling, None)
+
+
+@pytest.mark.parametrize("kind", ["video", "audio"])
+def test_continuation_edit_rejected_before_loading_source(kind):
+    sampling = OmniDiffusionSamplingParams(
+        width=64,
+        height=64,
+        extra_args={"long_video": True, "task": "ref2va", "duration": 20},
+    )
+    with pytest.raises(OmniClientError, match="continuation does not support latent-mask editing"):
+        prepare_encoder_inputs(
+            {
+                "prompt": "test",
+                "multi_modal_data": {
+                    "image": Image.new("RGB", (64, 64)),
+                    f"source_{kind}": "must-not-be-loaded",
+                    f"{kind}_noise_mask": 0.5,
+                },
+            },
+            sampling,
+        )
+
+
+def test_locked_audio_rejects_audio_edit_before_loading_source():
+    sampling = OmniDiffusionSamplingParams(
+        width=64,
+        height=64,
+        extra_args={"task": "t2va", "aspect_ratio": "1:1", "audio_mode": "lock_source"},
+    )
+    with pytest.raises(OmniClientError, match="cannot be combined"):
+        prepare_encoder_inputs(
+            {
+                "prompt": "test",
+                "multi_modal_data": {
+                    "audio": (torch.zeros(8000), 8000),
+                    "source_audio": "must-not-be-loaded",
+                    "audio_noise_mask": 0.5,
+                },
+            },
+            sampling,
+        )
+
+
+@pytest.mark.parametrize("kind", ["video", "audio"])
+def test_external_encoder_cannot_bypass_continuation_edit_validation(kind):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(step_execution=False)
+    conditioning = SimpleNamespace(
+        task="ref2va",
+        num_frames=481,
+        video_edit_clean_rows=torch.zeros(1) if kind == "video" else None,
+        audio_edit_clean_rows=torch.zeros(1) if kind == "audio" else None,
+    )
+    sampling = OmniDiffusionSamplingParams(extra_args={"long_video": True})
+    with pytest.raises(OmniClientError, match="continuation does not support latent-mask editing"):
+        pipeline._prepare_encoder_conditioning_inputs(conditioning, sampling)
+
+
+def test_external_encoder_cannot_bypass_full_duration_limit():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(step_execution=False)
+    sampling = OmniDiffusionSamplingParams(extra_args={"long_video": True, "long_video_mode": "full"})
+    with pytest.raises(OmniClientError, match="30-second request limit"):
+        pipeline._prepare_encoder_conditioning_inputs(SimpleNamespace(task="ref2va", num_frames=7213), sampling)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_modulation.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_modulation.py
index 7fde01354..df3b22689 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_modulation.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_modulation.py
@@ -190,3 +190,31 @@ def test_fused_modulation_preserves_bf16_residual_boundary() -> None:
     )
 
     assert torch.equal(modulated_out, expected)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+@pytest.mark.parametrize("fused_gate", [False, True])
+def test_fused_modulation_keeps_fp32_affine_intermediates(fused_gate: bool) -> None:
+    device = current_omni_platform.get_torch_device()
+    rows, hidden_size = 2, 5376
+    x = torch.ones(rows, hidden_size, device=device, dtype=torch.bfloat16)
+    weight = torch.full((hidden_size,), 1.125, device=device, dtype=x.dtype)
+    shift = torch.zeros(1, hidden_size, device=device, dtype=x.dtype)
+    scale = torch.full_like(shift, 0.09375)
+    indices = torch.zeros(rows, device=device, dtype=torch.int64)
+    eps = 1e-6
+    if fused_gate:
+        residual, actual = indexed_gate_rms_norm_scale_shift(
+            x, torch.zeros_like(shift), x, weight, shift, scale, indices, eps
+        )
+        assert torch.equal(residual, x)
+    else:
+        actual = rms_norm_indexed_scale_shift(x, weight, shift, scale, indices, eps)
+
+    # Without the RMS epsilon, 1.125 * 1.09375 = 1.23046875 is exactly
+    # halfway between two BF16 values. FP32 normalization keeps the epsilon
+    # and rounds down to 1.2265625. Premature BF16 rounding drops the epsilon
+    # and instead rounds the tie up to 1.234375, changing every output row.
+    assert torch.equal(actual, torch.full_like(x, 1.2265625))
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_offload.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_offload.py
index 24206952d..824ad2c63 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_offload.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_offload.py
@@ -86,6 +86,7 @@ def test_decode_releases_only_audio_before_return(monkeypatch):
         audio_vae=Mock(decode_latent=Mock(return_value=audio)),
         _component_on_device=lambda component: nullcontext(),
         _offload_model_cpu_stage_output=Mock(side_effect=lambda value: value),
+        _release_stage_cache=Mock(),
     )
     monkeypatch.setattr(
         module.current_omni_platform,
@@ -152,6 +153,7 @@ def test_forward_releases_video_after_quantization_and_before_next_seed(monkeypa
         diffuse=diffuse,
         decode=decode,
         _offload_model_cpu_stage_output=_recording_release(events, releases),
+        _release_stage_cache=lambda: None,
     )
     request = SimpleNamespace(prompts=["a prompt"], sampling_params=SimpleNamespace())
 
@@ -201,6 +203,7 @@ def test_forward_drops_the_decoded_video_before_the_next_seed_diffuses(monkeypat
         diffuse=diffuse,
         decode=decode,
         _offload_model_cpu_stage_output=lambda value: value.clone(),
+        _release_stage_cache=lambda: None,
     )
     request = SimpleNamespace(prompts=["a prompt"], sampling_params=SimpleNamespace())
 
@@ -231,6 +234,7 @@ def test_post_decode_releases_video_after_quantization(monkeypatch):
         _unpack_denoised_rows=lambda *args, **kwargs: (torch.zeros(1), torch.zeros(1)),
         decode=decode,
         _offload_model_cpu_stage_output=_recording_release(events, releases),
+        _release_stage_cache=lambda: None,
     )
     state = SimpleNamespace(
         latents=torch.zeros(1),
@@ -529,7 +533,7 @@ def test_h3_model_cpu_offload_shares_embedded_and_standalone_audio_scope(monkeyp
     torch.nn.Module.__init__(pipeline)
     pipeline.audio_vae = Mock()
     pipeline._model_cpu_offload_modules = [pipeline.audio_vae]
-    events = []
+    events: list[tuple] = []
 
     @contextmanager
     def record_component(value):
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py
index 92bd09ac2..e1f83fd01 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from types import SimpleNamespace
 from unittest.mock import Mock
@@ -41,7 +42,7 @@ class _FakeAttention(nn.Module):
         super().__init__()
 
 
-def _small_od_config():
+def _small_od_config(*, class_name=None):
     arch = {
         "num_layers": 1,
         "token_refiner_num_layers": 1,
@@ -60,6 +61,8 @@ def _small_od_config():
         "final_adaln_out_features": 2 * 8,
         "rope_inv_freq_len": 2,
     }
+    if class_name is not None:
+        arch["_class_name"] = class_name
     return SimpleNamespace(
         tf_model_config=arch,
         parallel_config=SimpleNamespace(ulysses_degree=1),
@@ -133,6 +136,24 @@ def test_fp8_scope_and_prefix_propagation(monkeypatch):
     )
 
 
+def test_explicit_native_weight_format_overrides_diffusers_class_name(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import minimax_h3_transformer as h3
+
+    monkeypatch.setattr(h3, "ColumnParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "MergedColumnParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "QKVParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "RowParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "Attention", _FakeAttention)
+    monkeypatch.setattr(h3, "get_tensor_model_parallel_world_size", lambda: 1)
+
+    model = h3.MiniMaxH3DiTModel(
+        _small_od_config(class_name="MiniMaxH3Transformer3DModel"),
+        diffusers_weights=False,
+    )
+
+    assert model._diffusers_weights is False
+
+
 class _WeightTarget(nn.Module):
     def __init__(self, loader):
         super().__init__()
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py
index ba0e0ddf5..3beda5acc 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py
@@ -187,8 +187,14 @@ def test_minimax_h3_quantization_quality(config: QualityTestConfig):
         "model": model_ref,
         "enforce_eager": True,
         # The fused BF16 baseline only fits on H100-80GB with encoder TP.
-        "stage_0_tensor_parallel_size": 2,
+        # This test loads the direct FL2VA diffusion pipeline (not the
+        # disaggregated two-stage MiniMax-H3 pipeline), so configure both the
+        # DiT world and the Qwen3-VL encoder TP explicitly.
+        "tensor_parallel_size": 2,
+        "text_encoder_tp_size": 2,
         "vae_use_tiling": True,
+        # MiniMax H3's VAE is implemented by code shipped with the checkpoint.
+        "trust_remote_code": True,
     }
 
     omni_bl = Omni(**common_kwargs)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_step_execution.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_step_execution.py
index e202c0d0e..bebc5a06f 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_step_execution.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_step_execution.py
@@ -27,6 +27,9 @@ class _SegmentMeanModel:
     assignment shows up as a numeric difference instead of passing silently.
     """
 
+    def __init__(self):
+        self.calls: list[dict[str, torch.Tensor]] = []
+
     def __call__(self, **kwargs):
         x = kwargs["x"][0]
         audio_x = kwargs["audio_x"][0]
@@ -45,6 +48,14 @@ class _SegmentMeanModel:
             pooled_audio[start:stop] = audio_x[start:stop].mean(dim=0, keepdim=True)
 
         row_timesteps = kwargs["unique_timesteps"][kwargs["inverse_indices"]].unsqueeze(-1)
+        self.calls.append(
+            {
+                "video_rows": x[img_pos].clone(),
+                "audio_rows": audio_x[audio_pos].clone(),
+                "video_timesteps": row_timesteps[img_pos, 0].clone(),
+                "audio_timesteps": row_timesteps[audio_pos, 0].clone(),
+            }
+        )
         video = (pooled_video + 0.5 * x + row_timesteps)[img_pos]
         audio = (pooled_audio + 0.5 * audio_x + row_timesteps)[audio_pos]
         if not kwargs.get("skip_mask_out_condition", False):
@@ -156,9 +167,77 @@ def test_step_execution_matches_request_mode_denoise_loop():
     torch.testing.assert_close(state.extra[mod._STEP_AUDIO_ROWS], reference_audio)
 
 
-def test_batched_step_execution_matches_independent_requests():
+def test_step_execution_matches_request_mode_with_latent_edits():
+    """Masked model rows, row timesteps, and scheduler math match both paths."""
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
+    from vllm_omni.diffusion.models.minimax_h3.denoise_loop import minimax_h3_denoise_loop
+    from vllm_omni.diffusion.models.minimax_h3.latent_mask import MiniMaxH3LatentEdit
+
+    model = _SegmentMeanModel()
+    branch, video_rows, audio_rows = _make_branch(text_len=9, latent_t=2, latent_h=4, latent_w=6, audio_t=3, seed=51)
+    sigmas_video = _sigmas(5, 12.0)
+    sigmas_audio = _sigmas(5, 3.0)
+    video_clean = torch.linspace(-1.0, 1.0, video_rows.numel()).reshape_as(video_rows)
+    audio_clean = torch.linspace(1.0, -1.0, audio_rows.numel()).reshape_as(audio_rows)
+    video_mask = torch.linspace(0.0, 1.0, video_rows.shape[0])
+    video_edit = MiniMaxH3LatentEdit.from_rows(
+        video_clean,
+        0.999 * video_clean + 0.001 * video_rows,
+        video_mask,
+        video_mask,
+    )
+    audio_mask = torch.tensor([0.0, 0.2, 0.4, 0.6, 0.8, 1.0])
+    audio_edit = MiniMaxH3LatentEdit.from_rows(
+        audio_clean,
+        audio_clean,
+        audio_mask,
+        audio_mask,
+    )
+
+    reference_video, reference_audio = minimax_h3_denoise_loop(
+        model=model,
+        positive=branch,
+        initial_video_rows=video_rows,
+        initial_audio_rows=audio_rows,
+        keyframe_cond_rows=None,
+        video_edit=video_edit,
+        audio_edit=audio_edit,
+        sigmas_video=sigmas_video,
+        sigmas_audio=sigmas_audio,
+        device=torch.device("cpu"),
+    )
+    request_first_call = model.calls[0]
+    torch.testing.assert_close(request_first_call["video_rows"], video_edit.model_rows(video_rows))
+    torch.testing.assert_close(request_first_call["audio_rows"], audio_edit.model_rows(audio_rows))
+    torch.testing.assert_close(
+        request_first_call["video_timesteps"],
+        video_edit.target_timesteps(1.0 - sigmas_video[0], 0.999, sigma=sigmas_video[0]),
+    )
+    torch.testing.assert_close(
+        request_first_call["audio_timesteps"],
+        audio_edit.target_timesteps(1.0 - sigmas_audio[0], 1.0, sigma=sigmas_audio[0]),
+    )
+    model.calls.clear()
+
+    state = _make_state("req-edit", model, branch, video_rows, audio_rows, sigmas_video, sigmas_audio)
+    state.extra[mod._STEP_VIDEO_EDIT] = video_edit
+    state.extra[mod._STEP_AUDIO_EDIT] = audio_edit
+    pipeline = _step_pipeline(model)
+    while not state.denoise_completed:
+        velocity = pipeline.denoise_step(SimpleNamespace(states=(state,)), states=[state])
+        pipeline.step_scheduler(state, velocity)
+
+    for name, expected in request_first_call.items():
+        torch.testing.assert_close(model.calls[0][name], expected)
+    torch.testing.assert_close(state.latents, reference_video)
+    torch.testing.assert_close(state.extra[mod._STEP_AUDIO_ROWS], reference_audio)
+
+
+@pytest.mark.parametrize("lock_audio", [False, True])
+def test_batched_step_execution_matches_independent_requests(lock_audio):
     """Two co-batched requests must land where they would have landed alone."""
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
+    from vllm_omni.diffusion.models.minimax_h3.latent_mask import MiniMaxH3LatentEdit
 
     model = _SegmentMeanModel()
     specs = [
@@ -171,20 +250,40 @@ def test_batched_step_execution_matches_independent_requests():
 
     pipeline = _step_pipeline(model)
 
+    def make_state(request_id: str, index: int):
+        branch, video_rows, audio_rows = _make_branch(**specs[index])
+        sigmas_video, sigmas_audio = schedules[index]
+        state = _make_state(request_id, model, branch, video_rows, audio_rows, sigmas_video, sigmas_audio)
+        video_mask = torch.linspace(0.1 * index, 0.8 + 0.1 * index, video_rows.shape[0])
+        video_edit = MiniMaxH3LatentEdit.from_rows(
+            torch.full_like(video_rows, 10.0 + index),
+            torch.full_like(video_rows, 20.0 + index),
+            video_mask,
+            video_mask,
+        )
+        audio_mask = torch.linspace(0.2 - 0.1 * index, 1.0 - 0.1 * index, audio_rows.shape[0])
+        audio_edit = MiniMaxH3LatentEdit.from_rows(
+            torch.full_like(audio_rows, 30.0 + index),
+            torch.full_like(audio_rows, 40.0 + index),
+            audio_mask,
+            audio_mask,
+        )
+        state.extra[mod._STEP_VIDEO_EDIT] = video_edit
+        if lock_audio and index == 0:
+            branch.locked_audio_rows = audio_rows.clone()
+        else:
+            state.extra[mod._STEP_AUDIO_EDIT] = audio_edit
+        return state
+
     alone: list[tuple[torch.Tensor, torch.Tensor]] = []
-    for spec, (sigmas_video, sigmas_audio) in zip(specs, schedules):
-        branch, video_rows, audio_rows = _make_branch(**spec)
-        state = _make_state("solo", model, branch, video_rows, audio_rows, sigmas_video, sigmas_audio)
+    for index in range(len(specs)):
+        state = make_state("solo", index)
         while not state.denoise_completed:
             pipeline.step_scheduler(state, pipeline.denoise_step(SimpleNamespace(states=(state,)), states=[state]))
         alone.append((state.latents, state.extra[mod._STEP_AUDIO_ROWS]))
 
-    states = []
-    for index, (spec, (sigmas_video, sigmas_audio)) in enumerate(zip(specs, schedules)):
-        branch, video_rows, audio_rows = _make_branch(**spec)
-        if index == 0:
-            assert branch.used_len == branch.seq_len
-        states.append(_make_state(f"req-{index}", model, branch, video_rows, audio_rows, sigmas_video, sigmas_audio))
+    states = [make_state(f"req-{index}", index) for index in range(len(specs))]
+    assert states[0].extra[mod._STEP_BRANCH].used_len == states[0].extra[mod._STEP_BRANCH].seq_len
 
     active = list(states)
     while active:
@@ -291,6 +390,8 @@ def test_prepare_encode_seeds_runner_visible_state(monkeypatch, batch_frames):
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
 
     branch, video_rows, audio_rows = _make_branch(text_len=9, latent_t=2, latent_h=4, latent_w=6, audio_t=3, seed=8)
+    video_edit = object()
+    audio_edit = object()
     sigmas_video = _sigmas(6, 12.0)
     sigmas_audio = _sigmas(6, 3.0)
     context = {
@@ -326,6 +427,8 @@ def test_prepare_encode_seeds_runner_visible_state(monkeypatch, batch_frames):
             "audio_rows": audio_rows,
             "cond_anchor": None,
             "audio_anchor": None,
+            "video_edit": video_edit,
+            "audio_edit": audio_edit,
             "sigmas_video": sigmas_video,
             "sigmas_audio": sigmas_audio,
         },
@@ -347,6 +450,8 @@ def test_prepare_encode_seeds_runner_visible_state(monkeypatch, batch_frames):
     assert state.do_true_cfg is False
     torch.testing.assert_close(state.current_timestep, torch.tensor(1.0 - sigmas_video[0]))
     assert state.extra[mod._STEP_BRANCH] is branch
+    assert state.extra[mod._STEP_VIDEO_EDIT] is video_edit
+    assert state.extra[mod._STEP_AUDIO_EDIT] is audio_edit
     assert state.extra[mod._STEP_SHAPE]["height"] == 96
 
     pipeline.od_config = SimpleNamespace()
@@ -450,3 +555,33 @@ def test_packed_batch_rejects_backends_that_cannot_isolate_requests(attention):
     from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
 
     assert MiniMaxH3Pipeline._packed_batch_supported(_FakeTransformer([attention])) is False
+
+
+def test_locked_driving_audio_is_clean_and_unchanged_during_denoising():
+    from vllm_omni.diffusion.models.minimax_h3.denoise_loop import minimax_h3_denoise_loop
+
+    branch, video, audio = _make_branch(text_len=3, latent_t=2, latent_h=2, latent_w=2, audio_t=3, seed=7)
+    branch.locked_audio_rows = audio.clone()
+    seen = []
+
+    def model(**kwargs):
+        positions = kwargs["audio_pos_info"]["position_ids"]
+        times = kwargs["unique_timesteps"][kwargs["inverse_indices"]]
+        torch.testing.assert_close(times[positions], torch.ones_like(times[positions]))
+        torch.testing.assert_close(kwargs["audio_x"][0, positions], audio)
+        seen.append(True)
+        return torch.ones_like(video), torch.ones_like(audio)
+
+    result_video, result_audio = minimax_h3_denoise_loop(
+        model=model,
+        positive=branch,
+        initial_video_rows=video,
+        initial_audio_rows=audio,
+        keyframe_cond_rows=None,
+        sigmas_video=[1.0, 0.5, 0.0],
+        sigmas_audio=[1.0, 0.25, 0.0],
+        device=torch.device("cpu"),
+    )
+    assert len(seen) == 2
+    torch.testing.assert_close(result_audio, audio)
+    assert not torch.equal(result_video, video)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_decode_revert.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_decode_revert.py
new file mode 100644
index 000000000..805770c19
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_decode_revert.py
@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CPU tests for in-place decode revert and stage-boundary cache release.
+
+``_revert_decoded_inplace`` must be numerically identical to the checkpoint's
+``revert_tensor`` (denormalize → clamp → rearrange) with zero whole-video
+copies, and ``_release_stage_cache`` must force the allocator-cache release
+(or fall back to a plain empty_cache when no component cache exists).
+"""
+
+import pytest
+import torch
+
+import vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 as pipeline_module
+from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+from vllm_omni.diffusion.models.minimax_h3.vae import MiniMaxH3VideoVAE
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+DENORM_MEAN = (-2.11628412, -2.03571429, -1.80444444)  # -imagenet_mean/std
+DENORM_STD = (4.36681223, 4.46428571, 4.44444444)  # 1/imagenet_std
+
+
+class _FakeDenormalize:
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+
+class _FakeProcessor:
+    def __init__(self):
+        self.transform_rev = _FakeDenormalize(DENORM_MEAN, DENORM_STD)
+        self.use_3d_conv = True
+        self.revert_calls = 0
+
+    def revert_tensor(self, tensor):
+        self.revert_calls += 1
+        return _legacy_revert(tensor)
+
+
+class _FakeCheckpointModel:
+    def __init__(self):
+        self.processor = _FakeProcessor()
+
+
+def _vae(model=None):
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    vae.model = model if model is not None else _FakeCheckpointModel()
+    return vae
+
+
+def _legacy_revert(tensor: torch.Tensor) -> torch.Tensor:
+    """The checkpoint's revert_tensor, op for op, on the CPU (B == 1)."""
+    if tensor.ndim == 4:
+        tensor = tensor.unsqueeze(2)
+    assert tensor.ndim == 5
+    # Normalize runs on the (b t) c h w rearrangement; at B == 1 that is a
+    # view of (B, C, T, H, W), so the per-channel broadcast is equivalent.
+    mean = torch.tensor(DENORM_MEAN).view(1, 3, 1, 1, 1)
+    std = torch.tensor(DENORM_STD).view(1, 3, 1, 1, 1)
+    tensor = (tensor - mean) / std
+    return tensor.clamp(0, 1)
+
+
+def test_revert_inplace_matches_legacy_bitwise():
+    decoded = torch.randn(1, 3, 7, 6, 8).clamp_(-3, 3)
+    expected = _legacy_revert(decoded.clone())
+    out = _vae()._revert_decoded_inplace(decoded.clone())
+    assert out.shape == expected.shape == (1, 3, 7, 6, 8)
+    assert torch.equal(out, expected)
+
+
+def test_revert_inplace_mutates_without_extra_copies():
+    decoded = torch.randn(1, 3, 5, 4, 4)
+    out = _vae()._revert_decoded_inplace(decoded)
+    assert out is decoded  # in-place: no whole-video copy materializes
+    assert out.is_contiguous()
+
+
+def test_revert_inplace_unsqueezes_4d_input():
+    # 4-D decoded tensors follow the (B, C, H, W) image contract: unsqueeze(2)
+    # lands T=1, matching the checkpoint's revert_tensor branch.
+    decoded = torch.randn(1, 3, 6, 8)
+    expected = _legacy_revert(decoded.clone())
+    out = _vae()._revert_decoded_inplace(decoded.clone())
+    assert torch.equal(out, expected)
+
+
+def test_revert_inplace_falls_back_without_contract():
+    vae = _vae()
+    vae.model.processor.transform_rev = type("Empty", (), {})()
+    decoded = torch.randn(1, 3, 5, 4, 4)
+    out = vae._revert_decoded_inplace(decoded)
+    assert vae.model.processor.revert_calls == 1
+    assert torch.equal(out, _legacy_revert(decoded))
+
+
+def test_revert_inplace_falls_back_on_bad_arity():
+    vae = _vae()
+    vae.model.processor.transform_rev = _FakeDenormalize((0.5, 0.5), (1.0, 1.0, 1.0))
+    vae._revert_decoded_inplace(torch.randn(1, 3, 5, 4, 4))
+    assert vae.model.processor.revert_calls == 1
+
+
+class _RecordingCache:
+    def __init__(self):
+        self.calls = []
+
+    def release_if_needed(self, *, force=False):
+        self.calls.append(force)
+        return True
+
+
+def _pipeline():
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    pipeline._dlo_component_cache = None
+    return pipeline
+
+
+def test_stage_cache_release_forces_component_cache():
+    pipeline = _pipeline()
+    cache = _RecordingCache()
+    pipeline._dlo_component_cache = cache
+    pipeline._release_stage_cache()
+    assert cache.calls == [True]
+
+
+def test_stage_cache_release_falls_back_to_empty_cache(monkeypatch):
+    released = []
+    monkeypatch.setattr(
+        pipeline_module.current_omni_platform,
+        "empty_cache",
+        lambda: released.append(True),
+        raising=True,
+    )
+    pipeline = _pipeline()
+    pipeline._release_stage_cache()
+    assert released == [True]
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_encode_prep.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_encode_prep.py
new file mode 100644
index 000000000..3e597f09a
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_encode_prep.py
@@ -0,0 +1,243 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CPU tests for the streaming uint8 preparation in the MiniMax-H3 video VAE.
+
+``_stream_prepare_video_tensor`` must be numerically identical to the
+checkpoint's whole-video numpy path (``convert_numpy_to_tensor`` →
+``transform_tensor`` → ``transpose``) while padding on the host, so the
+device-side copies never materialize.
+"""
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.minimax_h3.vae import MiniMaxH3VideoVAE
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+CLIP_LENGTH = 4
+
+
+class _FakeNormalize:
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+
+class _FakeProcessor:
+    # Read by the stream prep via getattr(..., False); annotation only so
+    # tests can attach it per case.
+    isolated_last_frame: bool
+
+    def __init__(self):
+        self.transform = _FakeNormalize(IMAGENET_MEAN, IMAGENET_STD)
+
+
+class _FakeCheckpointModel:
+    def __init__(self, **overrides):
+        self.clip_length = CLIP_LENGTH
+        self.isolated_first_frame = False
+        self.frame_pre_padding = 0
+        self.processor = _FakeProcessor()
+        for key, value in overrides.items():
+            setattr(self, key, value)
+
+
+def _vae(model=None):
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    vae.model = model if model is not None else _FakeCheckpointModel()
+    return vae
+
+
+def _legacy_reference(frames: np.ndarray) -> torch.Tensor:
+    """The checkpoint's numpy path, op for op, on the CPU.
+
+    convert_numpy_to_tensor: astype(fp32) → permute → ÷255
+    transform_tensor: Normalize = (x - mean) / std
+    encode_videos: transpose(0, 1)
+    """
+    tensor = torch.from_numpy(frames.astype(np.float32)).permute(0, 3, 1, 2)
+    tensor = tensor / 255.0
+    mean = torch.tensor(IMAGENET_MEAN).view(1, 3, 1, 1)
+    std = torch.tensor(IMAGENET_STD).view(1, 3, 1, 1)
+    tensor = (tensor - mean) / std
+    return tensor.transpose(0, 1).contiguous()
+
+
+def _video(num_frames, height=6, width=8, seed=0):
+    rng = np.random.default_rng(seed)
+    return rng.integers(0, 256, size=(num_frames, height, width, 3), dtype=np.uint8)
+
+
+def _pad_frames(frames: np.ndarray, pad: int) -> np.ndarray:
+    if not pad:
+        return frames
+    return np.concatenate([frames, np.repeat(frames[-1:], pad, axis=0)])
+
+
+def test_stream_prep_matches_legacy_path_bitwise():
+    frames = _video(10)
+    out = _vae()._stream_prepare_video_tensor(frames, torch.device("cpu"))
+    assert out is not None
+    assert out.shape == (3, 12, 6, 8)  # pad = (0 - 10) % 4 == 2
+    assert out.dtype == torch.float32
+    assert torch.equal(out, _legacy_reference(_pad_frames(frames, 2)))
+
+
+def test_stream_prep_isolated_first_frame_without_last_frame_skips_pad():
+    # Asymmetric checkpoint (isolated first frame, no isolated last frame):
+    # trim-stable lengths are k*clip + 0, which never satisfy the
+    # encode_temporal offset of 1, so the remote re-pads through its own
+    # whole-video cat regardless. Padding here would only upload frames the
+    # remote trim discards, so the legacy frame count is kept.
+    model = _FakeCheckpointModel(isolated_first_frame=True)
+    frames = _video(10)
+    out = _vae(model)._stream_prepare_video_tensor(frames, torch.device("cpu"))
+    assert out is not None
+    assert out.shape[1] == 10
+    assert torch.equal(out, _legacy_reference(frames))
+
+
+def test_stream_prep_symmetric_isolated_frames_pad_to_trim_stable():
+    # isolated first + last frames: offset == tail % clip == 1, so padding
+    # to the next trim-stable length makes the remote trim a no-op and keeps
+    # encode_temporal from re-padding: T=10, clip=4, tail=1 → 3*4+1 == 13.
+    model = _FakeCheckpointModel(isolated_first_frame=True)
+    model.processor.isolated_last_frame = True
+    frames = _video(10)
+    out = _vae(model)._stream_prepare_video_tensor(frames, torch.device("cpu"))
+    assert out is not None
+    assert out.shape[1] == 13
+    assert out.shape[1] % 4 == 1
+    assert torch.equal(out, _legacy_reference(_pad_frames(frames, 3)))
+
+
+def test_stream_prep_uses_processor_align_when_available():
+    calls = []
+
+    class _AlignedProcessor(_FakeProcessor):
+        def align_video_length(self, video_length, mode="pad", granularity="chunk"):
+            calls.append((video_length, mode, granularity))
+            return 5
+
+    model = _FakeCheckpointModel()
+    model.processor = _AlignedProcessor()
+    frames = _video(10)
+    out = _vae(model)._stream_prepare_video_tensor(frames, torch.device("cpu"))
+    assert out is not None
+    assert calls == [(10, "pad", "chunk")]
+    assert out.shape[1] == 15
+    assert torch.equal(out, _legacy_reference(_pad_frames(frames, 5)))
+
+
+def test_stream_prep_pads_with_last_frame():
+    frames = _video(2)  # pad = (0 - 2) % 4 == 2
+    out = _vae()._stream_prepare_video_tensor(frames, torch.device("cpu"))
+    padded = np.concatenate([frames, np.repeat(frames[-1:], 2, axis=0)])
+    assert torch.equal(out, _legacy_reference(padded))
+
+
+def test_stream_prep_aligned_input_needs_no_pad():
+    frames = _video(8)  # 8 % 4 == 0
+    out = _vae()._stream_prepare_video_tensor(frames, torch.device("cpu"))
+    assert out.shape[1] == 8
+    assert torch.equal(out, _legacy_reference(frames))
+
+
+@pytest.mark.parametrize(
+    "frames",
+    [
+        _video(5).astype(np.float32),  # not uint8
+        _video(5)[:, :, :, :1],  # single channel
+        np.zeros((5, 6, 8, 4), dtype=np.uint8),  # four channels
+        np.zeros((5, 6, 8), dtype=np.uint8),  # missing channel axis
+        np.zeros((0, 6, 8, 3), dtype=np.uint8),  # empty
+    ],
+)
+def test_stream_prep_rejects_unsupported_inputs(frames):
+    assert _vae()._stream_prepare_video_tensor(frames, torch.device("cpu")) is None
+
+
+@pytest.mark.parametrize(
+    "model",
+    [
+        _FakeCheckpointModel(clip_length=None),
+        _FakeCheckpointModel(clip_length=0),
+        type("NoProcessor", (), {"clip_length": CLIP_LENGTH})(),
+        type(
+            "NoTransform",
+            (),
+            {"clip_length": CLIP_LENGTH, "processor": type("P", (), {})()},
+        )(),
+    ],
+)
+def test_stream_prep_rejects_missing_checkpoint_contract(model):
+    frames = _video(5)
+    assert _vae(model)._stream_prepare_video_tensor(frames, torch.device("cpu")) is None
+
+
+def test_stream_prep_rejects_bad_norm_arity():
+    model = _FakeCheckpointModel()
+    model.processor.transform = _FakeNormalize((0.5, 0.5), IMAGENET_STD)
+    assert _vae(model)._stream_prepare_video_tensor(_video(5), torch.device("cpu")) is None
+
+
+class _RecordingModel(_FakeCheckpointModel):
+    """Feeds encode_video a well-shaped latent and records its input."""
+
+    def __init__(self):
+        super().__init__()
+        self.received = None
+        self.latent = torch.randn(1, 4, 3, 4, 4)  # (B, C, T', H', W'), even H/W
+
+    def encode_videos(self, videos, use_fp16_latent=False, **kwargs):
+        self.received = videos
+        assert use_fp16_latent is True
+        return [self.latent]
+
+
+def _vae_for_encode_video():
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    vae.model = _RecordingModel()
+    vae.device_module = torch
+    vae.config_dict = {
+        "latent_channels": 4,
+        "latents_mean": [0.0] * 4,
+        "latents_std": [1.0] * 4,
+    }
+    # A plain tensor (not nn.Parameter): nn.Module.__setattr__ refuses
+    # Parameters on instances built via object.__new__.
+    vae._dummy_parameter = torch.zeros(1, dtype=torch.float32)
+    vae.parameters = lambda: iter([vae._dummy_parameter])
+    return vae
+
+
+def test_encode_video_streams_uint8_numpy(monkeypatch):
+    monkeypatch.delenv("VLLM_OMNI_VAE_ENCODE_LEGACY_PREP", raising=False)
+    vae = _vae_for_encode_video()
+    rows, shape = vae.encode_video(_video(10))
+    assert isinstance(vae.model.received, list)
+    assert isinstance(vae.model.received[0], torch.Tensor)
+    assert vae.model.received[0].shape == (3, 12, 6, 8)
+    assert rows.shape[0] == shape[0] * shape[1] * shape[2] // 4  # patchify rows
+
+
+def test_encode_video_legacy_env_escapes_to_checkpoint_path(monkeypatch):
+    monkeypatch.setenv("VLLM_OMNI_VAE_ENCODE_LEGACY_PREP", "1")
+    vae = _vae_for_encode_video()
+    frames = _video(10)
+    vae.encode_video(frames)
+    assert vae.model.received is frames  # untouched numpy, checkpoint converts
+
+
+def test_encode_video_falls_back_when_preparation_unsupported(monkeypatch):
+    monkeypatch.delenv("VLLM_OMNI_VAE_ENCODE_LEGACY_PREP", raising=False)
+    vae = _vae_for_encode_video()
+    vae.model.clip_length = None  # contract not discoverable
+    frames = _video(10)
+    vae.encode_video(frames)
+    assert vae.model.received is frames
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_split_residency.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_split_residency.py
new file mode 100644
index 000000000..166f43538
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_split_residency.py
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CPU tests for the split encoder/decoder residency of the MiniMax-H3 VAE.
+
+The encode half (CNN encoder + quant_conv) and the decode half
+(post_quant_conv + ViT decoder) stage independently: loading one half must
+rebind only its own parameters while the other half stays on its pinned
+CPU master.
+"""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.diffusion.models.minimax_h3.vae import (
+    MiniMaxH3VideoVAE,
+    _VideoVAEPartProxy,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+class _FakeRemoteModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.encoder = nn.Linear(8, 8)
+        self.quant_conv = nn.Linear(4, 4)
+        self.post_quant_conv = nn.Linear(4, 4)
+        self.decoder = nn.Linear(16, 16)
+
+
+class _FakeRemote(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = _FakeRemoteModel()
+
+
+def _vae() -> MiniMaxH3VideoVAE:
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    nn.Module.__init__(vae)  # bare instance: enable Module attribute assignment
+    vae._device_target = torch.device("cpu")
+    vae.remote = _FakeRemote()
+    vae.model = vae.remote.model
+    vae._stager = None
+    vae._encoder_stager = None
+    vae._decoder_stager = None
+    vae._build_residency_stagers(torch.device("cpu"))
+    vae.encoder_component = _VideoVAEPartProxy(vae, "encoder")
+    vae.decoder_component = _VideoVAEPartProxy(vae, "decoder")
+    return vae
+
+
+def _ptr(param: torch.nn.Parameter) -> int:
+    return param.untyped_storage().data_ptr()
+
+
+def test_split_stagers_snapshot_disjoint_halves():
+    vae = _vae()
+    enc_master = _ptr(vae.model.encoder.weight)
+    dec_master = _ptr(vae.model.decoder.weight)
+    pqc_master = _ptr(vae.model.post_quant_conv.weight)
+    assert enc_master != dec_master
+
+    vae._load_part_to_device("encoder")
+    # The encoder half is rebound to freshly allocated staging storage...
+    assert _ptr(vae.model.encoder.weight) != enc_master
+    assert _ptr(vae.model.quant_conv.weight) != enc_master
+    # ...while every decode-half tensor stays on its own CPU master.
+    assert _ptr(vae.model.decoder.weight) == dec_master
+    assert _ptr(vae.model.post_quant_conv.weight) == pqc_master
+
+    vae._offload_part_to_cpu("encoder")
+    assert _ptr(vae.model.encoder.weight) == enc_master
+
+
+def test_part_load_is_idempotent_and_independent():
+    vae = _vae()
+    vae._load_part_to_device("decoder")
+    staged_ptr = _ptr(vae.model.decoder.weight)
+    vae._load_part_to_device("decoder")
+    assert _ptr(vae.model.decoder.weight) == staged_ptr
+    vae._offload_part_to_cpu("decoder")
+
+
+def test_whole_component_load_and_offload_cover_both_halves():
+    vae = _vae()
+    enc_master = _ptr(vae.model.encoder.weight)
+    dec_master = _ptr(vae.model.decoder.weight)
+    vae.load_to_device()
+    assert _ptr(vae.model.encoder.weight) != enc_master
+    assert _ptr(vae.model.decoder.weight) != dec_master
+    vae.offload_to_cpu()
+    assert _ptr(vae.model.encoder.weight) == enc_master
+    assert _ptr(vae.model.decoder.weight) == dec_master
+
+
+def test_part_values_survive_a_load_offload_cycle():
+    vae = _vae()
+    expected = vae.model.encoder.weight.detach().clone()
+    vae._load_part_to_device("encoder")
+    assert torch.equal(vae.model.encoder.weight.detach(), expected)
+    vae._offload_part_to_cpu("encoder")
+    assert torch.equal(vae.model.encoder.weight.detach(), expected)
+
+
+def test_proxy_routes_to_the_matching_half():
+    vae = _vae()
+    enc_master = _ptr(vae.model.encoder.weight)
+    dec_master = _ptr(vae.model.decoder.weight)
+    vae.encoder_component.load_to_device()
+    assert _ptr(vae.model.encoder.weight) != enc_master
+    assert _ptr(vae.model.decoder.weight) == dec_master
+    vae.encoder_component.offload_to_cpu()
+    assert _ptr(vae.model.encoder.weight) == enc_master
+
+
+def test_proxy_does_not_register_the_adapter_as_submodule():
+    vae = _vae()
+    proxy = vae.encoder_component
+    assert proxy._vae is vae
+    # The back-reference must not recurse through module traversal.
+    assert all(child is not vae for child in proxy.children())
+    assert len(list(proxy.parameters())) == 0
+
+
+def test_component_on_device_unwraps_proxy_for_sequential_offload(monkeypatch):
+    """Model-level CPU offload hooks the real video_vae, never the part
+    proxies: _component_on_device must hand the hooked module to the
+    sequential context, or _get_sequential_offload_hook raises on the
+    hook-less proxy on the first encode/decode of every request."""
+    from contextlib import contextmanager
+
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as pipeline_module
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    vae = _vae()
+    seen: list[nn.Module] = []
+
+    @contextmanager
+    def fake_sequential_offload_component(component):
+        seen.append(component)
+        yield
+
+    monkeypatch.setattr(pipeline_module, "sequential_offload_component", fake_sequential_offload_component)
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    nn.Module.__init__(pipeline)
+    pipeline._model_cpu_offload_modules = [vae]
+
+    with pipeline._component_on_device(vae.encoder_component):
+        pass
+    with pipeline._component_on_device(vae.decoder_component):
+        pass
+    # A plain component passes through unchanged.
+    with pipeline._component_on_device(vae):
+        pass
+    # Mocks auto-create any attribute, so the unwrap must be a type check:
+    # a Mock component must reach the sequential context as itself.
+    mock_vae = Mock()
+    pipeline._model_cpu_offload_modules = [mock_vae]
+    with pipeline._component_on_device(mock_vae):
+        pass
+
+    assert seen == [vae, vae, vae, mock_vae]
+
+
+def test_sequential_offload_target_is_the_hooked_module():
+    from vllm_omni.diffusion.offloader.sequential_backend import _get_sequential_offload_hook
+
+    vae = _vae()
+    proxy = vae.encoder_component
+    # The pre-fix failure mode: the proxy carries no hook registry.
+    with pytest.raises(RuntimeError, match="no sequential offload hook"):
+        _get_sequential_offload_hook(proxy)
+    assert proxy.sequential_offload_target is vae
+
+
+def test_cache_retention_forwarded_to_both_stagers():
+    vae = _vae()
+    cache = object()
+    vae.set_omni_component_cache(cache)
+    assert vae._encoder_stager.cache_retention is cache
+    assert vae._decoder_stager.cache_retention is cache
+
+
+def test_unknown_part_raises():
+    vae = _vae()
+    with pytest.raises(ValueError, match="unknown video VAE part"):
+        vae._part_stager("middle")
+
+
+def test_missing_checkpoint_structure_falls_back_to_whole_stager():
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    nn.Module.__init__(vae)
+    vae._device_target = torch.device("cpu")
+
+    class BareRemote(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.model = nn.Linear(4, 4)  # no encoder/decoder submodules
+
+    vae.remote = BareRemote()
+    vae.model = vae.remote.model
+    vae._stager = None
+    vae._encoder_stager = None
+    vae._decoder_stager = None
+    vae._build_residency_stagers(torch.device("cpu"))
+    assert vae._stager is not None
+    assert vae._encoder_stager is None
+    assert vae._decoder_stager is None
+    # Part loads fall back to the whole-module stager.
+    vae._load_part_to_device("decoder")
+    assert vae._stager.loaded
+    vae._offload_part_to_cpu("decoder")
+    assert not vae._stager.loaded
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_temporal_patches.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_temporal_patches.py
new file mode 100644
index 000000000..8ba8199a1
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_temporal_patches.py
@@ -0,0 +1,335 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CPU tests for the temporal VAE forks and the uint8 output transfer.
+
+The encode fork must feed bit-identical frames to the checkpoint's chunk
+loop (padding moves from a whole-video cat into the tail chunk), the decode
+fork must produce the same video as the legacy fp32-buffer chain
+(revert -> clamp -> *255 -> round -> uint8), and the output transfer must
+match the previous ``.to(uint8, contiguous)`` conversion.
+"""
+
+from typing import Any, cast
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    _prepare_minimax_h3_video_output,
+)
+from vllm_omni.diffusion.models.minimax_h3.vae_temporal import (
+    _decode_temporal_streaming_uint8,
+    _encode_temporal_tail_pad,
+    install_temporal_stream_patches,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+CLIP = 4
+
+
+# ---------------------------------------------------------------------------
+# encode_temporal fork
+# ---------------------------------------------------------------------------
+
+
+class _EncodeModel:
+    """Minimal stand-in implementing the checkpoint's encode_temporal."""
+
+    # Attached per test case as capability probes for the install checks;
+    # annotations only, the fork must keep working when they are absent.
+    encode_temporal: Any
+    _decode_temporal_streaming: Any
+    processor: Any
+
+    def __init__(self, *, isolated_first=False, isolated_last=False, key_frame=False, frame_drop=0):
+        self.clip_length = CLIP
+        self.isolated_first_frame = isolated_first
+        self.frame_pre_padding = 0
+        self.isolated_key_frame = key_frame
+        self.token_drop = 0
+        self.isolated_last_frame = isolated_last
+        self.frame_drop = frame_drop
+        self.encoded = []
+
+    def _adaptive_encode(self, clip):
+        self.encoded.append(clip.clone())
+        return clip  # identity: z_list entries are the clips themselves
+
+    def reference_encode_temporal(self, x):
+        """The checkpoint's original: whole-video pad, then chunk."""
+        offset_frame = 1 if self.isolated_first_frame and self.frame_pre_padding == 0 else 0
+        if x.shape[2] % self.clip_length != offset_frame:
+            pad_size = (offset_frame - x.shape[2]) % self.clip_length
+            pad_frames = x[:, :, -1:].repeat(1, 1, pad_size, 1, 1)
+            x = torch.cat([x, pad_frames], dim=2)
+        num_chunks = (x.shape[2] - offset_frame) // self.clip_length
+        z_list = []
+        for i in range(num_chunks):
+            start_idx = i * self.clip_length + offset_frame
+            end_idx = (i + 1) * self.clip_length + offset_frame
+            clip_x = x[:, :, start_idx:end_idx, :, :]
+            if self.isolated_key_frame:
+                key_frame = clip_x[:, :, :1, :, :]
+                z_key = self._adaptive_encode(key_frame)
+                if clip_x.shape[2] > 1:
+                    z_video = self._adaptive_encode(clip_x[:, :, 1:, :, :])
+                    z = torch.cat([z_key, z_video], dim=2)
+                else:
+                    z = z_key
+            else:
+                z = self._adaptive_encode(clip_x)
+            z_list.append(z)
+        z = torch.cat(z_list, dim=2)
+        if self.token_drop > 0:
+            z = z[:, :, : -self.token_drop]
+        if self.isolated_first_frame:
+            z_first = self._adaptive_encode(x[:, :, :1, :, :])
+            z = torch.cat([z_first, z], dim=2)
+        if self.isolated_last_frame:
+            frame_num = x.shape[2]
+            last_idx = frame_num - self.frame_drop + offset_frame
+            z_last = self._adaptive_encode(x[:, :, last_idx : last_idx + 1, :, :])
+            z = torch.cat([z, z_last], dim=2)
+        return z
+
+
+def _video_x(t, c=3, h=4, w=4):
+    return torch.arange(t * c * h * w, dtype=torch.float32).reshape(1, c, t, h, w) / 255.0
+
+
+@pytest.mark.parametrize("num_frames", [8, 10, 11, 13])
+@pytest.mark.parametrize(
+    "flags",
+    [
+        {},
+        {"isolated_first": True},
+        {"isolated_last": True},
+        {"isolated_first": True, "isolated_last": True},
+        {"key_frame": True},
+    ],
+)
+def test_encode_fork_matches_whole_video_pad_bitwise(num_frames, flags):
+    x = _video_x(num_frames)
+    ref_model = _EncodeModel(**flags)
+    expected = ref_model.reference_encode_temporal(x.clone())
+    # Empty-slice encodes (out-of-range isolated-last indexes are no-ops in
+    # the checkpoint) carry no content; compare only real calls.
+    ref_calls = [c.clone() for c in ref_model.encoded if c.shape[2] > 0]
+
+    fork_model = _EncodeModel(**flags)
+    out = _encode_temporal_tail_pad(fork_model, x.clone())
+
+    assert out.shape == expected.shape
+    assert torch.equal(out, expected)
+    assert len(fork_model.encoded) == len(ref_calls)
+    for got, want in zip(fork_model.encoded, ref_calls):
+        assert torch.equal(got, want)
+
+
+def test_encode_fork_avoids_whole_video_pad_for_misaligned_input():
+    # 375 frames with an asymmetric config (isolated last frame only):
+    # the checkpoint always pads (375 % 17 != 0); the fork must encode the
+    # tail chunk with an in-chunk pad instead of concatenating the video.
+    model = _EncodeModel(isolated_last=True, frame_drop=16)
+    model.clip_length = 17
+    x = _video_x(375, c=1, h=2, w=2)
+    _encode_temporal_tail_pad(model, x)
+    # 375 % 17 == 1 → pad 16 inside the tail chunk; the isolated last frame
+    # resolves to the final real frame (pad frames replicate it).
+    assert len(model.encoded) == (375 // 17) + 1 + 1
+    assert torch.equal(model.encoded[-1].flatten(), x[:, :, -1:, :, :].flatten())
+
+
+# ---------------------------------------------------------------------------
+# _decode_temporal_streaming uint8 fork
+# ---------------------------------------------------------------------------
+
+DENORM_MEAN = (-2.11628412, -2.03571429, -1.80444444)
+DENORM_STD = (4.36681223, 4.46428571, 4.44444444)
+
+
+class _FakeDenorm:
+    def __init__(self):
+        self.mean = DENORM_MEAN
+        self.std = DENORM_STD
+
+
+class _FakeProcessor:
+    def __init__(self):
+        self.transform_rev = _FakeDenorm()
+
+
+class _DecodeModel:
+    """Minimal stand-in for the checkpoint's streaming decode contract."""
+
+    def __init__(self, *, token_drop=0, frame_overlap=0):
+        self.tokens_chunk_size = 2
+        self.vae_ratio_t = 1
+        self.token_overlap = 1 if token_drop else 0
+        self.token_drop = token_drop
+        self.frame_pre_padding = 0
+        self.frame_overlap = frame_overlap
+        self.processor = _FakeProcessor()
+
+    def _adaptive_decode(self, clip_z):
+        # Deterministic pseudo-decode: map latent tokens to frames 1:1.
+        return torch.sin(clip_z * 3.0)
+
+    def blend(self, a, b, overlap, dim=-3):
+        return (a + b) / 2.0
+
+    def _decode_temporal_pad_frames(self, z, pad_tokens):
+        return int(pad_tokens)
+
+    def _decode_temporal_output_frame_plan(self, z, z_head, z_tail, num_chunks, pad_tokens):
+        total = num_chunks * self.tokens_chunk_size * self.vae_ratio_t
+        if z_head is not None:
+            total += 1
+        if z_tail is not None:
+            total += 1
+        if self.token_drop > 0:
+            total += self.frame_overlap
+        return int(total), int(pad_tokens), int(total - pad_tokens)
+
+    def legacy_streaming(self, z, z_head, z_tail, num_chunks, pad_tokens, temporal_cat_dtype):
+        """The checkpoint's original: accumulate in the cat dtype, quantize later."""
+        total_frames, _, output_frames = self._decode_temporal_output_frame_plan(
+            z, z_head, z_tail, num_chunks, pad_tokens
+        )
+        chunk_dec = self.tokens_chunk_size * self.vae_ratio_t
+        split_count = int(self.token_drop > 0) + 1
+        dec = None
+        dec_overlap = None
+        write_pos = 0
+
+        def write_part(part):
+            nonlocal dec, write_pos
+            if dec is None:
+                out_shape = list(part.shape)
+                out_shape[2] = output_frames
+                dec = torch.empty(out_shape, dtype=part.dtype)
+            n = min(part.shape[2], dec.shape[2] - write_pos)
+            if n > 0:
+                dec[:, :, write_pos : write_pos + n].copy_(part[:, :, :n])
+                write_pos += n
+
+        for i in range(num_chunks):
+            t_start = i * self.tokens_chunk_size
+            t_end = t_start + self.tokens_chunk_size + self.token_overlap
+            clip_z = z[:, :, t_start:t_end]
+            clip_dec = self._adaptive_decode(clip_z)
+            if temporal_cat_dtype is not None and clip_dec.dtype != temporal_cat_dtype:
+                clip_dec = clip_dec.to(temporal_cat_dtype)
+            for j in range(split_count):
+                chunk = clip_dec[:, :, j * chunk_dec : min(j * chunk_dec + chunk_dec, clip_dec.shape[2])]
+                if j == 0:
+                    if dec_overlap is not None:
+                        chunk = self.blend(dec_overlap, chunk, self.frame_overlap, dim=-3)
+                        dec_overlap = None
+                    write_part(chunk)
+                else:
+                    dec_overlap = chunk.contiguous()
+            if i == num_chunks - 1 and dec_overlap is not None:
+                write_part(dec_overlap)
+                dec_overlap = None
+        # Legacy post-decode chain: revert in place in the decoded dtype, then
+        # the adapter's ``frames.float()`` before the pipeline's quantizer.
+        assert dec is not None
+        mean = torch.tensor(DENORM_MEAN, dtype=dec.dtype).view(1, 3, 1, 1, 1)
+        std = torch.tensor(DENORM_STD, dtype=dec.dtype).view(1, 3, 1, 1, 1)
+        dec.sub_(mean).div_(std).clamp_(0.0, 1.0)
+        dec = dec.float()
+        dec.mul_(255.0).round_()
+        return dec.to(torch.uint8)
+
+
+@pytest.mark.parametrize("token_drop,frame_overlap", [(0, 0), (1, 1)])
+@pytest.mark.parametrize("temporal_cat_dtype", [None, torch.float16, torch.bfloat16])
+def test_decode_fork_matches_legacy_chain_bitwise(token_drop, frame_overlap, temporal_cat_dtype):
+    # The quantizer must see FP32 no matter the cat dtype: the legacy adapter
+    # returned frames.float() before the pipeline multiplied and rounded, so
+    # an fp16/bf16 cat dtype only narrows denormalization, never the rounding.
+    torch.manual_seed(0)
+    tokens = 2 * 2 + (1 if token_drop else 0)  # num_chunks * tokens_chunk_size
+    z = torch.randn(1, 3, tokens, 4, 4)
+    legacy = _DecodeModel(token_drop=token_drop, frame_overlap=frame_overlap)
+    expected = legacy.legacy_streaming(z.clone(), None, None, 2, 0, temporal_cat_dtype)
+
+    fork = _DecodeModel(token_drop=token_drop, frame_overlap=frame_overlap)
+    out = _decode_temporal_streaming_uint8(fork, z.clone(), None, None, 2, 0, temporal_cat_dtype)
+    assert out.dtype == torch.uint8
+    assert out.shape == expected.shape
+    assert torch.equal(out, expected)
+
+
+def test_decode_fork_rejects_empty_plan():
+    model = _DecodeModel()
+    model.tokens_chunk_size = 0
+    with pytest.raises(ValueError, match="non-positive output_frames"):
+        _decode_temporal_streaming_uint8(model, torch.randn(1, 3, 0, 4, 4), None, None, 0, 0, None)
+
+
+# ---------------------------------------------------------------------------
+# install + escape hatch
+# ---------------------------------------------------------------------------
+
+
+def test_install_binds_both_forks():
+    model = _EncodeModel()
+    # cast(Any, ...) keeps mypy from narrowing the probes to the lambda type,
+    # which has no __func__ for the bound-method assertions below.
+    model.encode_temporal = cast(Any, lambda x: x)  # placeholder for the capability check
+    model._decode_temporal_streaming = cast(Any, lambda *a: None)
+    model.processor = _FakeProcessor()
+    install_temporal_stream_patches(model)
+    assert model.encode_temporal.__func__ is _encode_temporal_tail_pad
+    assert model._decode_temporal_streaming.__func__ is _decode_temporal_streaming_uint8
+
+
+def test_install_skips_decode_fork_without_denorm_contract():
+    model = _EncodeModel()
+    model.encode_temporal = cast(Any, lambda x: x)
+    model._decode_temporal_streaming = cast(Any, lambda *a: None)
+    install_temporal_stream_patches(model)  # no processor -> keep original
+    assert model.encode_temporal.__func__ is _encode_temporal_tail_pad
+    assert not hasattr(model._decode_temporal_streaming, "__func__")
+
+
+def test_install_respects_legacy_env(monkeypatch):
+    monkeypatch.setenv("VLLM_OMNI_VAE_LEGACY_TEMPORAL", "1")
+    model = _EncodeModel()
+    install_temporal_stream_patches(model)
+    assert not hasattr(getattr(model, "encode_temporal", None), "__func__")
+
+
+# ---------------------------------------------------------------------------
+# _prepare_minimax_h3_video_output
+# ---------------------------------------------------------------------------
+
+
+def test_prepare_output_matches_previous_conversion():
+    video = torch.randn(1, 3, 4, 6, 8).clamp_(-1, 2)
+    legacy = (
+        video.detach()
+        .float()
+        .clamp(0, 1)
+        .mul(255)
+        .round()
+        .permute(0, 2, 3, 4, 1)
+        .to(dtype=torch.uint8, memory_format=torch.contiguous_format)
+    )
+    out = _prepare_minimax_h3_video_output(video.clone())
+    assert out.dtype == torch.uint8
+    assert out.shape == (1, 4, 6, 8, 3)
+    assert out.is_contiguous()
+    assert torch.equal(out, legacy)
+
+
+def test_prepare_output_uint8_passthrough():
+    video = torch.randint(0, 256, (1, 3, 4, 6, 8), dtype=torch.uint8)
+    out = _prepare_minimax_h3_video_output(video)
+    assert out.dtype == torch.uint8
+    assert out.is_contiguous()
+    assert torch.equal(out, video.permute(0, 2, 3, 4, 1).contiguous())
diff --git a/tests/diffusion/models/pi05/__init__.py b/tests/diffusion/models/pi05/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/tests/diffusion/models/pi05/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
diff --git a/tests/diffusion/models/pi05/test_pi05_parity.py b/tests/diffusion/models/pi05/test_pi05_parity.py
new file mode 100644
index 000000000..fb30cb445
--- /dev/null
+++ b/tests/diffusion/models/pi05/test_pi05_parity.py
@@ -0,0 +1,500 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""π0.5 parity against LeRobot.
+
+Reference: **lerobot 0.6.1**, transformers 5.5.4, torch 2.11.0+cpu. The oracle
+is LeRobot's own code, so a later version changing its π0.5 implementation
+fails this without anything here regressing — diff ``policies/pi05/`` first.
+
+Compares final action chunks under fixed noise: float32 exactly, bfloat16
+against LeRobot's own bfloat16 layout within ``BF16_ATOL``.
+
+Needs a separate ``lerobot[pi]`` venv (its dependencies conflict with
+vllm-omni's) with the vllm-omni ``pi05`` package importable::
+
+    python -m pytest tests/diffusion/models/pi05/test_pi05_parity.py -v -s
+
+Skips itself when LeRobot is absent. ``PI05_PARITY_MODEL_PATH`` points at a
+local checkpoint to skip the HF download.
+"""
+
+from __future__ import annotations
+
+import copy
+import importlib.util
+import os
+
+import pytest
+import torch
+
+# local_model: needs real weights + a lerobot venv, so it runs locally rather
+# than in the ready-CI. Additionally gated on lerobot being importable.
+_HAS_LEROBOT = importlib.util.find_spec("lerobot") is not None
+
+# cpu: the comparison runs on CPU in float32 so both implementations see
+# identical numerics; local_model: it needs a lerobot venv that CI does not have.
+pytestmark = [pytest.mark.local_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+# ─── Config (fixed; matches LeRobot defaults for a π0.5 checkpoint) ────
+DEVICE = "cpu"
+DTYPE_STR = "float32"
+ATOL = 1e-4
+BF16_ATOL = 5e-2  # measured 2.95e-2, reproducible; margin is for version drift
+NUM_STEPS = 10
+BATCH_SIZE = 2
+ACTION_DIM = 32
+STATE_DIM = 32
+ACTION_HORIZON = 50
+MAX_TOKEN_LEN = 200  # π0 uses 48
+NUM_STATE_BINS = 256
+
+MODEL_PATH = os.environ.get("PI05_PARITY_MODEL_PATH", "lerobot/pi05_base")
+
+CAMERAS = ("base_0_rgb", "left_wrist_0_rgb", "right_wrist_0_rgb")
+
+
+def _resolve_checkpoint_dir() -> str:
+    if os.path.isdir(MODEL_PATH):
+        return MODEL_PATH
+    from huggingface_hub import snapshot_download
+
+    return snapshot_download(repo_id=MODEL_PATH, repo_type="model")
+
+
+# ─── Dummy dataset stats ──────────────────────────────────────────────
+def _dummy_dataset_stats() -> dict:
+    """Identity-ish stats. π0.5 normalizes with QUANTILES by default, so q01/q99
+    carry the load here where π0's mean/std would.
+
+    Using dummy stats means this test needs no checkpoint with real
+    ``norm_stats`` — it verifies numerical equivalence, not calibration.
+    """
+    return {
+        "observation.state": {
+            "mean": torch.zeros(STATE_DIM),
+            "std": torch.ones(STATE_DIM),
+            "q01": -torch.ones(STATE_DIM),
+            "q99": torch.ones(STATE_DIM),
+        },
+        "action": {
+            "mean": torch.zeros(ACTION_DIM),
+            "std": torch.ones(ACTION_DIM),
+            "q01": -torch.ones(ACTION_DIM),
+            "q99": torch.ones(ACTION_DIM),
+        },
+        "images": {
+            cam: {
+                "mean": torch.zeros(3, 224, 224),
+                "std": torch.ones(3, 224, 224),
+                "q01": torch.zeros(3, 224, 224),
+                "q99": torch.ones(3, 224, 224),
+            }
+            for cam in CAMERAS
+        },
+    }
+
+
+def _create_dummy_batch(batch_size: int = BATCH_SIZE, num_views: int = 3, device: str = DEVICE) -> dict:
+    """Reproducible dummy inputs — identical across both implementations."""
+    g = torch.Generator(device="cpu").manual_seed(0)
+    prompt = "Pick up the red block and place it in the bin"
+    batch = {
+        "observation.state": torch.randn(batch_size, STATE_DIM, generator=g, dtype=torch.float32).to(device),
+        "action": torch.randn(batch_size, ACTION_HORIZON, ACTION_DIM, generator=g, dtype=torch.float32).to(device),
+        "task": [prompt for _ in range(batch_size)],
+    }
+    for cam in CAMERAS[:num_views]:
+        batch[f"observation.images.{cam}"] = torch.rand(batch_size, 3, 224, 224, generator=g, dtype=torch.float32).to(
+            device
+        )
+    return batch
+
+
+# ─── Instantiation ────────────────────────────────────────────────────
+def _instantiate_lerobot(use_relative_actions: bool = False, action_feature_names=None, dtype: str = DTYPE_STR):
+    from lerobot.policies.pi05 import PI05Policy
+    from lerobot.policies.pi05.processor_pi05 import make_pi05_pre_post_processors
+
+    policy = PI05Policy.from_pretrained(MODEL_PATH, strict=True, dtype=dtype)
+    policy.to(DEVICE)
+    policy.config.device = DEVICE
+    policy.config.use_relative_actions = use_relative_actions
+    if action_feature_names is not None:
+        # Must land on the config *before* the processors are built:
+        # make_pi05_pre_post_processors captures action_feature_names into
+        # RelativeActionsProcessorStep at construction time, and its _build_mask
+        # treats ``action_names is None`` as "shift every dim" — including the
+        # gripper that relative_exclude_joints is supposed to hold back. Setting
+        # it afterwards leaves the step with the all-True mask and silently
+        # compares two different transforms.
+        policy.config.action_feature_names = action_feature_names
+    policy.eval()
+
+    pre, post = make_pi05_pre_post_processors(config=policy.config, dataset_stats=_dummy_dataset_stats())
+    return policy, pre, post
+
+
+def _instantiate_vllm_omni(
+    use_relative_actions: bool = False,
+    action_feature_names=None,
+    dtype: str = DTYPE_STR,
+):
+    """Build the vllm-omni π0.5 model in isolation (no pipeline, no engine)."""
+    from vllm_omni.diffusion.models.pi05 import Pi05Config, Pi05ForActionPrediction
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import _set_inference_dtype
+
+    cfg = Pi05Config(
+        max_action_dim=ACTION_DIM,
+        max_state_dim=STATE_DIM,
+        chunk_size=ACTION_HORIZON,
+        num_inference_steps=NUM_STEPS,
+        tokenizer_max_length=MAX_TOKEN_LEN,
+        state_num_bins=NUM_STATE_BINS,
+        dtype=dtype,
+        use_relative_actions=use_relative_actions,
+        relative_exclude_joints=["gripper"] if action_feature_names else [],
+        action_feature_names=action_feature_names,
+    )
+    model = Pi05ForActionPrediction(cfg)
+    _set_inference_dtype(model, getattr(torch, dtype))
+    model.to(device=DEVICE)
+    _load_lerobot_weights(model)
+    model.eval()
+    return model, cfg
+
+
+def _load_lerobot_weights(model):
+    import safetensors.torch
+
+    path = os.path.join(_resolve_checkpoint_dir(), "model.safetensors")
+    state = safetensors.torch.load_file(path)
+    filled = model.load_weights(list(state.items()))
+    assert filled, "no weights were loaded — the remap rules are broken"
+
+
+def _extract_lerobot_model_inputs(lerobot_policy, processed_batch):
+    """Mimic what ``PI05Policy.predict_action_chunk`` feeds into
+    ``self.model.sample_actions``. Using these *exact* tensors for vllm-omni
+    means any divergence must come from the core model, not preprocessing.
+
+    Note π0.5 has no ``prepare_state`` step: the state is already inside
+    ``lang_tokens``.
+    """
+    from lerobot.utils.constants import (
+        OBS_LANGUAGE_ATTENTION_MASK,
+        OBS_LANGUAGE_TOKENS,
+    )
+
+    images, img_masks = lerobot_policy._preprocess_images(processed_batch)
+    return images, img_masks, processed_batch[OBS_LANGUAGE_TOKENS], processed_batch[OBS_LANGUAGE_ATTENTION_MASK]
+
+
+def _make_fixed_noise(batch_size: int, device: str) -> torch.Tensor:
+    g = torch.Generator(device="cpu").manual_seed(42)
+    return torch.randn(batch_size, ACTION_HORIZON, ACTION_DIM, generator=g, dtype=torch.float32).to(device)
+
+
+# ─── Main parity test ─────────────────────────────────────────────────
+@pytest.mark.skipif(not _HAS_LEROBOT, reason="lerobot not installed (run in a lerobot venv).")
+@pytest.mark.parametrize("num_views", [1, 2, 3])
+def test_pi05_vllm_omni_vs_lerobot(num_views):
+    lerobot_policy, lerobot_pre, _ = _instantiate_lerobot()
+    omni_model, _ = _instantiate_vllm_omni()
+
+    raw_batch = _create_dummy_batch(num_views=num_views)
+    processed = lerobot_pre(copy.deepcopy(raw_batch))
+    images, img_masks, lang_tokens, lang_masks = _extract_lerobot_model_inputs(lerobot_policy, processed)
+    noise = _make_fixed_noise(raw_batch["observation.state"].shape[0], DEVICE)
+
+    # The input contract: 256 tokens per view + a constant 200 text tokens.
+    assert lang_tokens.shape[1] == MAX_TOKEN_LEN, "π0.5 must pad text to exactly 200 tokens"
+
+    with torch.no_grad():
+        lerobot_actions = lerobot_policy.model.sample_actions(
+            images, img_masks, lang_tokens, lang_masks, noise=noise, num_steps=NUM_STEPS
+        )
+        omni_actions = omni_model.sample_actions(
+            images=images,
+            image_masks=img_masks,
+            lang_tokens=lang_tokens,
+            lang_masks=lang_masks,
+            noise=noise,
+            num_steps=NUM_STEPS,
+        )
+
+    diff = (lerobot_actions.float() - omni_actions.float()).abs()
+    print(f"[parity] views={num_views} |Δ| max={diff.max().item():.2e} mean={diff.mean().item():.2e}")
+    if not torch.allclose(lerobot_actions.float(), omni_actions.float(), atol=ATOL):
+        _diagnose_divergence(lerobot_policy.model, omni_model, images, img_masks, lang_tokens, lang_masks, noise)
+    assert torch.allclose(lerobot_actions.float(), omni_actions.float(), atol=ATOL), (
+        f"actions differ beyond atol={ATOL}; max_diff={diff.max().item():.2e}"
+    )
+
+
+@pytest.mark.skipif(not _HAS_LEROBOT, reason="lerobot not installed (run in a lerobot venv).")
+def test_pi05_bfloat16_matches_lerobot_bfloat16():
+    """Both sides in bfloat16, so this compares implementations rather than
+    measuring bfloat16's drift from float32."""
+    # LeRobot applies the layout in PaliGemmaWithExpertModel.__init__ from
+    # config.dtype, so the policy must be built as bfloat16 rather than cast after.
+    lerobot_policy, lerobot_pre, _ = _instantiate_lerobot(dtype="bfloat16")
+
+    omni_model, _ = _instantiate_vllm_omni(dtype="bfloat16")
+
+    raw_batch = _create_dummy_batch(num_views=3)
+    processed = lerobot_pre(copy.deepcopy(raw_batch))
+    images, img_masks, lang_tokens, lang_masks = _extract_lerobot_model_inputs(lerobot_policy, processed)
+    noise = _make_fixed_noise(raw_batch["observation.state"].shape[0], DEVICE)
+
+    with torch.no_grad():
+        lerobot_actions = lerobot_policy.model.sample_actions(
+            images, img_masks, lang_tokens, lang_masks, noise=noise, num_steps=NUM_STEPS
+        )
+        omni_actions = omni_model.sample_actions(
+            images=images,
+            image_masks=img_masks,
+            lang_tokens=lang_tokens,
+            lang_masks=lang_masks,
+            noise=noise,
+            num_steps=NUM_STEPS,
+        )
+
+    diff = (lerobot_actions.float() - omni_actions.float()).abs()
+    print(f"[parity] bfloat16 |Δ| max={diff.max().item():.2e} mean={diff.mean().item():.2e}")
+    assert torch.allclose(lerobot_actions.float(), omni_actions.float(), atol=BF16_ATOL), (
+        f"bfloat16 actions differ beyond atol={BF16_ATOL}; max_diff={diff.max().item():.2e}"
+    )
+
+
+@pytest.mark.skipif(not _HAS_LEROBOT, reason="lerobot not installed (run in a lerobot venv).")
+def test_pi05_prompt_parity():
+    """π0.5's state is carried as prompt tokens, so the tokenized prompt is
+    itself part of the contract. A bin-index mismatch here (e.g. from running
+    the discretizer before the normalizer) would otherwise only surface as a
+    small, plausible-looking action difference.
+    """
+    from transformers import AutoTokenizer
+
+    from vllm_omni.diffusion.models.pi05.processor_pi05 import (
+        apply_norm,
+        build_norm_stats,
+        build_pi05_prompt,
+        tokenize_prompt,
+    )
+
+    lerobot_policy, lerobot_pre, _ = _instantiate_lerobot()
+    raw_batch = _create_dummy_batch(batch_size=1)
+    processed = lerobot_pre(copy.deepcopy(raw_batch))
+
+    from lerobot.utils.constants import OBS_LANGUAGE_TOKENS
+
+    lerobot_tokens = processed[OBS_LANGUAGE_TOKENS][0]
+
+    stats = _dummy_dataset_stats()["observation.state"]
+    norm = build_norm_stats({"state": {"q01": stats["q01"], "q99": stats["q99"]}}, "state")
+    normalized = apply_norm(raw_batch["observation.state"][0].float(), norm)
+    prompt = build_pi05_prompt(
+        task=raw_batch["task"][0],
+        normalized_state=normalized.numpy(),
+        state_num_bins=NUM_STATE_BINS,
+    )
+    tokenizer = AutoTokenizer.from_pretrained("google/paligemma-3b-pt-224", padding_side="right")
+    ids, _ = tokenize_prompt(tokenizer, prompt, MAX_TOKEN_LEN)
+
+    assert len(ids) == MAX_TOKEN_LEN
+    assert torch.equal(torch.tensor(ids), lerobot_tokens.cpu()), "π0.5 prompt tokens diverge from LeRobot"
+
+
+@pytest.mark.skipif(not _HAS_LEROBOT, reason="lerobot not installed (run in a lerobot venv).")
+@pytest.mark.parametrize("state_dim", [7, STATE_DIM])
+def test_pi05_prompt_parity_across_state_widths(state_dim):
+    """``pi05_base`` declares a 32-dim state, which is exactly ``max_state_dim``,
+    so the full-policy parity above cannot tell padding apart from the real
+    width. This drives LeRobot's tokenizer step directly, at both widths.
+    """
+    from lerobot.lerobot_types import TransitionKey
+    from lerobot.policies.pi05.processor_pi05 import Pi05PrepareStateTokenizerProcessorStep
+    from lerobot.utils.constants import OBS_STATE
+
+    from vllm_omni.diffusion.models.pi05.processor_pi05 import build_pi05_prompt
+
+    g = torch.Generator().manual_seed(state_dim)
+    state = torch.randn(state_dim, generator=g, dtype=torch.float32)
+    task = "pick up the red block"
+
+    step = Pi05PrepareStateTokenizerProcessorStep(max_state_dim=STATE_DIM)
+    transition = step(
+        {
+            TransitionKey.OBSERVATION: {OBS_STATE: state.unsqueeze(0)},
+            TransitionKey.COMPLEMENTARY_DATA: {"task": [task]},
+        }
+    )
+    lerobot_prompt = transition[TransitionKey.COMPLEMENTARY_DATA]["task"][0]
+
+    prompt = build_pi05_prompt(task=task, normalized_state=state.numpy())
+
+    assert prompt == lerobot_prompt
+    assert len(prompt.split("State: ")[1].split(";")[0].split()) == state_dim
+
+
+@pytest.mark.skipif(not _HAS_LEROBOT, reason="lerobot not installed (run in a lerobot venv).")
+@pytest.mark.parametrize(
+    "lerobot_mode,stats,ours,state,state_dim",
+    [
+        ("MEAN_STD", {"mean": [0.0], "std": [1e-7]}, {"mode": "mean_std", "mean": [0.0], "std": [1e-7]}, [1e-7], 1),
+        ("QUANTILES", {"q01": [0.0], "q99": [1e-7]}, {"mode": "quantile", "q01": [0.0], "q99": [1e-7]}, [1e-7], 1),
+        ("QUANTILES", {"q01": [2.0], "q99": [2.0]}, {"mode": "quantile", "q01": [2.0], "q99": [2.0]}, [2.0], 1),
+        (
+            "QUANTILES",
+            {"q01": [0.0] * 4, "q99": [10.0] * 4},
+            {"mode": "quantile", "q01": [0.0] * 4, "q99": [10.0] * 4},
+            [-10.0, 0.0, 5.0, 20.0],
+            4,
+        ),
+        (
+            "MEAN_STD",
+            {"mean": [1.0, 2.0], "std": [0.5, 4.0]},
+            {"mode": "mean_std", "mean": [1.0, 2.0], "std": [0.5, 4.0]},
+            [3.0, -6.0],
+            2,
+        ),
+        ("MIN_MAX", {"min": [-1.0], "max": [3.0]}, {"mode": "min_max", "min": [-1.0], "max": [3.0]}, [2.0], 1),
+    ],
+)
+def test_pi05_state_normalization_parity(lerobot_mode, stats, ours, state, state_dim):
+    """State normalization against LeRobot's ``NormalizerProcessorStep``.
+
+    The full-policy parity test feeds both sides stats with a wide range, so it
+    cannot see the denominator rule. A wrongly normalized state still discretizes
+    into a well-formed prompt: for ``q01=0, q99=1e-7`` a threshold substitution
+    moves the state token from bin 255 to bin 0.
+    """
+    from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
+    from lerobot.processor.normalize_processor import NormalizerProcessorStep
+    from lerobot.utils.constants import OBS_STATE
+
+    from vllm_omni.diffusion.models.pi05.processor_pi05 import apply_norm, build_norm_stats
+
+    step = NormalizerProcessorStep(
+        features={OBS_STATE: PolicyFeature(type=FeatureType.STATE, shape=(state_dim,))},
+        norm_map={FeatureType.STATE: getattr(NormalizationMode, lerobot_mode)},
+        stats={OBS_STATE: {k: torch.tensor(v, dtype=torch.float32) for k, v in stats.items()}},
+    )
+    expected = step._apply_transform(
+        torch.tensor(state, dtype=torch.float32), OBS_STATE, FeatureType.STATE, inverse=False
+    )
+
+    actual = apply_norm(torch.tensor(state, dtype=torch.float32), build_norm_stats({"state": ours}, "state"))
+
+    assert torch.allclose(actual, expected, atol=1e-6)
+
+
+@pytest.mark.skipif(not _HAS_LEROBOT, reason="lerobot not installed (run in a lerobot venv).")
+def test_pi05_relative_actions_parity():
+    """With ``use_relative_actions=True`` the checkpoint's norm_stats live in
+    relative space, so the post-pipeline must add the raw state back. Compares
+    the full pre → model → post path against LeRobot's."""
+    from lerobot.utils.constants import (
+        OBS_LANGUAGE_ATTENTION_MASK,
+        OBS_LANGUAGE_TOKENS,
+    )
+
+    from vllm_omni.diffusion.models.pi05.processor_pi05 import (
+        Pi05RelativeActions,
+        apply_norm,
+        build_norm_stats,
+    )
+
+    action_names = [f"joint_{i}" for i in range(ACTION_DIM - 1)] + ["gripper"]
+    lerobot_policy, lerobot_pre, lerobot_post = _instantiate_lerobot(
+        use_relative_actions=True, action_feature_names=action_names
+    )
+    omni_model, cfg = _instantiate_vllm_omni(use_relative_actions=True, action_feature_names=action_names)
+
+    raw_batch = _create_dummy_batch()
+    processed = lerobot_pre(copy.deepcopy(raw_batch))
+    images, img_masks = lerobot_policy._preprocess_images(processed)
+    lang_tokens = processed[OBS_LANGUAGE_TOKENS]
+    lang_masks = processed[OBS_LANGUAGE_ATTENTION_MASK]
+    noise = _make_fixed_noise(raw_batch["observation.state"].shape[0], DEVICE)
+
+    with torch.no_grad():
+        lerobot_actions = lerobot_post(
+            lerobot_policy.model.sample_actions(
+                images, img_masks, lang_tokens, lang_masks, noise=noise, num_steps=NUM_STEPS
+            )
+        )
+        omni_raw = omni_model.sample_actions(
+            images=images,
+            image_masks=img_masks,
+            lang_tokens=lang_tokens,
+            lang_masks=lang_masks,
+            noise=noise,
+            num_steps=NUM_STEPS,
+        )
+
+    rel = Pi05RelativeActions(
+        enabled=True,
+        exclude_joints=cfg.relative_exclude_joints,
+        action_names=action_names,
+        max_action_dim=ACTION_DIM,
+    )
+    omni_actions = apply_norm(omni_raw, build_norm_stats(cfg.norm_stats, "action"), inverse=True)
+    # Per-sample reference state, matching LeRobot: its
+    # RelativeActionsProcessorStep caches the whole (B, D) state on the input
+    # side and shifts each sample by its own row. Passing a single row here
+    # would shift every sample by sample 0's state, which only agrees for B=1.
+    omni_actions = rel.to_absolute(omni_actions, raw_batch["observation.state"])
+
+    lerobot_actions = torch.as_tensor(lerobot_actions).float()
+    assert torch.allclose(lerobot_actions, omni_actions.float(), atol=ATOL), (
+        "relative-action path diverges from LeRobot; "
+        f"max_diff={(lerobot_actions - omni_actions.float()).abs().max().item():.2e}"
+    )
+
+
+# ─── Per-stage divergence diagnostics ─────────────────────────────────
+@torch.no_grad()
+def _diagnose_divergence(lerobot_flow_model, omni_model, images, img_masks, lang_tokens, lang_masks, noise):
+    """Localize a numerical mismatch to a specific stage:
+    1. Prefix embeddings (SigLIP / embed_tokens / projector) — image vs lang.
+    2. Prefix KV cache layer 0 — PaliGemma LM attention.
+    3. The AdaRMS timestep conditioning vector.
+    4. A single denoise_step velocity at t=1.0 — action expert forward.
+    """
+    from vllm_omni.diffusion.models.pi05.modeling_pi05 import (
+        make_att_2d_masks,
+        prepare_attention_masks_4d,
+    )
+
+    lr_embs, lr_pad, lr_att = lerobot_flow_model.embed_prefix(images, img_masks, lang_tokens, lang_masks)
+    sg_embs, sg_pad, sg_att = omni_model.embed_prefix(images, img_masks, lang_tokens, lang_masks)
+    print(f"[diag] prefix_embs max|Δ| = {(lr_embs.float() - sg_embs.float()).abs().max().item():.2e}")
+    print(f"[diag] prefix_pad_masks equal: {torch.equal(lr_pad, sg_pad)}")
+
+    img_len = 256 * len(images)
+    print(f"[diag]   image slice max|Δ| = {(lr_embs[:, :img_len] - sg_embs[:, :img_len]).abs().max().item():.2e}")
+    print(f"[diag]   lang  slice max|Δ| = {(lr_embs[:, img_len:] - sg_embs[:, img_len:]).abs().max().item():.2e}")
+
+    prefix_att_4d = prepare_attention_masks_4d(make_att_2d_masks(sg_pad, sg_att))
+    prefix_pos = torch.cumsum(sg_pad, dim=1) - 1
+    _, sg_kv = omni_model.paligemma_with_expert.forward(
+        attention_mask=prefix_att_4d,
+        position_ids=prefix_pos,
+        past_key_values=None,
+        inputs_embeds=[sg_embs, None],
+        use_cache=True,
+    )
+
+    t = torch.ones(noise.shape[0], dtype=torch.float32)
+    sg_cond = omni_model.embed_timestep(t)
+    print(f"[diag] adarms cond: shape={tuple(sg_cond.shape)} mean={sg_cond.mean().item():+.4f}")
+
+    sg_vt = omni_model.denoise_step(sg_pad, sg_kv, noise, t)
+    print(f"[diag] denoise_step(t=1) v_t mean={sg_vt.mean().item():+.6f}")
+
+
+if __name__ == "__main__":
+    test_pi05_vllm_omni_vs_lerobot(3)
diff --git a/tests/diffusion/models/pi05/test_pi05_units.py b/tests/diffusion/models/pi05/test_pi05_units.py
new file mode 100644
index 000000000..26671a59c
--- /dev/null
+++ b/tests/diffusion/models/pi05/test_pi05_units.py
@@ -0,0 +1,1107 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CPU unit tests for the π0.5 VLA model.
+
+Deliberately lightweight: config plumbing and the checkpoint-boundary rule, the
+state discretization path, relative actions, and the weight-load remap. Runs on
+CPU with no weights and no lerobot. The full LeRobot parity check lives in
+``tests/diffusion/models/pi05/test_pi05_parity.py``.
+
+Most assertions here guard *silent* failure modes — cases where the wrong
+behaviour still produces a well-shaped, finite action chunk:
+
+  * normalization must run before state discretization;
+  * the normalization mode comes from the checkpoint, since π0.5 defaults to
+    quantile where π0 defaults to ``mean_std``;
+  * relative-action checkpoints must be honoured, and an unresolvable
+    ``relative_exclude_joints`` must raise rather than silently make every
+    dimension relative;
+  * MEM / RTC checkpoints must be rejected rather than served incorrectly.
+
+    pytest tests/diffusion/models/pi05/test_pi05_units.py -v
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.pi05 import modeling_pi05
+from vllm_omni.diffusion.models.pi05.config import (
+    Pi05Config,
+    UnsupportedCheckpointCapabilityError,
+    load_lerobot_norm_stats,
+    resolve_excluded_action_indices,
+)
+from vllm_omni.diffusion.models.pi05.modeling_pi05 import (
+    GemmaVariantConfig,
+    Pi05AdaRMSNorm,
+    Pi05ForActionPrediction,
+    create_sinusoidal_pos_embedding,
+    get_gemma_config,
+    make_att_2d_masks,
+)
+from vllm_omni.diffusion.models.pi05.processor_pi05 import (
+    Pi05ImageProcessor,
+    Pi05Processor,
+    Pi05RelativeActions,
+    _assemble_model_inputs,
+    apply_norm,
+    as_state_vector,
+    build_norm_stats,
+    build_pi05_prompt,
+    discretize_state,
+    resize_with_pad,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+# ----------------------------------------------------------------------------
+# Pi05Config dataclass + checkpoint resolver
+# ----------------------------------------------------------------------------
+_LEROBOT_CFG: dict[str, Any] = {
+    "type": "pi05",
+    "paligemma_variant": "gemma_2b",
+    "action_expert_variant": "gemma_300m",
+    "chunk_size": 50,
+    "max_action_dim": 32,
+    "max_state_dim": 32,
+    "num_inference_steps": 10,
+    "image_resolution": [224, 224],
+    "tokenizer_max_length": 200,
+    "dtype": "float32",
+    "input_features": {
+        "observation.images.base_0_rgb": {"type": "VISUAL", "shape": [3, 224, 224]},
+        "observation.images.left_wrist_0_rgb": {"type": "VISUAL", "shape": [3, 224, 224]},
+        "observation.images.right_wrist_0_rgb": {"type": "VISUAL", "shape": [3, 224, 224]},
+        "observation.state": {"type": "STATE", "shape": [32]},
+    },
+    "output_features": {"action": {"type": "ACTION", "shape": [32]}},
+}
+
+_EXPECTED_CAMERA_ORDER = [
+    "observation.images.base_0_rgb",
+    "observation.images.left_wrist_0_rgb",
+    "observation.images.right_wrist_0_rgb",
+]
+
+_ACTION_NAMES = ["joint_0", "joint_1", "joint_2", "joint_3", "joint_4", "joint_5", "gripper"]
+
+
+def test_config_parses_lerobot_pi05_json():
+    """``_LEROBOT_CFG`` mirrors the runtime keys of a real checkpoint."""
+    c = Pi05Config.from_model_config(_LEROBOT_CFG)
+    assert c.tokenizer_max_length == 200
+    assert c.state_num_bins == 256
+    assert c.image_feature_keys == _EXPECTED_CAMERA_ORDER
+    assert c.image_resolution == (224, 224)
+
+
+def test_config_rejects_wrong_model_type():
+    with pytest.raises(ValueError, match="type='pi05'"):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, type="pi0"))
+
+
+def test_config_rejects_unsupported_partial_action_chunk():
+    with pytest.raises(UnsupportedCheckpointCapabilityError, match="n_action_steps"):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, n_action_steps=10))
+
+
+@pytest.mark.parametrize(
+    "key,value",
+    [
+        ("output_features", {"action": {"type": "ACTION", "shape": [33]}}),
+        ("input_features", {**_LEROBOT_CFG["input_features"], "observation.state": {"type": "STATE", "shape": [33]}}),
+    ],
+    ids=["action", "state"],
+)
+def test_config_rejects_a_schema_wider_than_the_model(key, value):
+    """``max_action_dim`` / ``max_state_dim`` are the widths the weights were
+    built for, so a wider checkpoint schema cannot be served."""
+    with pytest.raises(ValueError, match="over max_state_dim"):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, **{key: value}))
+
+
+@pytest.mark.parametrize(
+    "key,value,attribute",
+    [
+        ("output_features", {"action": {"type": "ACTION", "shape": [7]}}, "action_dim"),
+        (
+            "input_features",
+            {**_LEROBOT_CFG["input_features"], "observation.state": {"type": "STATE", "shape": [7]}},
+            "state_dim",
+        ),
+    ],
+    ids=["action", "state"],
+)
+def test_config_derives_the_real_width_from_the_schema(key, value, attribute):
+    """The declared width decides how many values reach the prompt and how many
+    columns come back, so a 7-joint checkpoint must not be padded out to 32."""
+    config = Pi05Config.from_model_config(dict(_LEROBOT_CFG, **{key: value}))
+    assert getattr(config, attribute) == 7
+
+
+def test_config_rejects_inconsistent_openpi_metadata():
+    with pytest.raises(ValueError, match="policy_server_config.action_dim"):
+        Pi05Config.from_model_config(
+            dict(
+                _LEROBOT_CFG,
+                output_features={"action": {"type": "ACTION", "shape": [7]}},
+                policy_server_config={"action_dim": 32},
+            )
+        )
+
+
+def test_config_non_square_resolution_raises():
+    with pytest.raises(ValueError):
+        Pi05Config(image_resolution=(224, 256))
+
+
+@pytest.mark.parametrize("key", ["max_cameras", "num_inference_steps"])
+def test_config_rejects_counts_below_one(key):
+    """``build_model_inputs`` emits one image slot per camera and the Euler loop
+    steps ``-1 / num_inference_steps``; neither is defined at zero."""
+    with pytest.raises(ValueError, match=f"{key} must be at least 1"):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, **{key: 0}))
+
+
+@pytest.mark.parametrize("key", ["state", "action"])
+def test_config_rejects_norm_stats_that_do_not_match_the_declared_width(key):
+    """A checkpoint's statistics and its feature schema come from different
+    files, so they can disagree."""
+    stats = {key: {"mode": "quantile", "q01": [0.0] * 2, "q99": [1.0] * 2}}
+    with pytest.raises(ValueError, match=rf"norm_stats\[{key}\]\[q01\] has 2 entries, expected 32"):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, norm_stats=stats))
+
+
+# ----------------------------------------------------------------------------
+# LeRobot normalization-stats sidecar
+# ----------------------------------------------------------------------------
+# LeRobot keeps stats out of config.json: policy_preprocessor.json holds the
+# structure and one safetensors file per stateful step holds the numbers.
+def _normalized(raw, stats):
+    """The serving path's state normalization, without the pipeline."""
+    return apply_norm(torch.as_tensor(raw, dtype=torch.float32), build_norm_stats({"state": stats}, "state")).numpy()
+
+
+def _write_lerobot_checkpoint(
+    tmp_path,
+    *,
+    norm_map: dict[str, str] | None = None,
+    stats: dict[str, dict[str, list[float]]] | None = None,
+    write_state_file: bool = True,
+) -> str:
+    """Write a minimal LeRobot-shaped checkpoint dir; return its path."""
+    import json as _json
+
+    import safetensors.torch as _st
+
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    state_file = "policy_preprocessor_step_3_normalizer_processor.safetensors"
+    step: dict = {
+        "registry_name": "normalizer_processor",
+        "config": {
+            "eps": 1e-08,
+            "features": {},
+            "norm_map": norm_map if norm_map is not None else {"STATE": "QUANTILES", "ACTION": "QUANTILES"},
+        },
+    }
+    if write_state_file:
+        step["state_file"] = state_file
+        flat = {
+            f"{feature}.{stat}": torch.tensor(values, dtype=torch.float32)
+            for feature, entry in (stats or {}).items()
+            for stat, values in entry.items()
+        }
+        _st.save_file(flat, str(tmp_path / state_file))
+
+    (tmp_path / "policy_preprocessor.json").write_text(
+        _json.dumps({"name": "policy_preprocessor", "steps": [step]}), encoding="utf-8"
+    )
+    (tmp_path / "config.json").write_text(_json.dumps(_config_for(stats)), encoding="utf-8")
+    return str(tmp_path)
+
+
+def _config_for(stats: dict | None) -> dict:
+    """``_LEROBOT_CFG`` with the state/action widths the stats actually cover."""
+    if not stats:
+        return _LEROBOT_CFG
+    config = dict(_LEROBOT_CFG)
+    state = next(iter(stats.get("observation.state", {}).values()), None)
+    action = next(iter(stats.get("action", {}).values()), None)
+    if state is not None:
+        features = dict(config["input_features"])
+        features["observation.state"] = {"type": "STATE", "shape": [len(state)]}
+        config["input_features"] = features
+    if action is not None:
+        config["output_features"] = {"action": {"type": "ACTION", "shape": [len(action)]}}
+    return config
+
+
+# A LeRobot state_dict carries every stat compute_stats emits, not just the two
+# the norm_map selects.
+_FULL_DATASET_STATS = {
+    "observation.state": {
+        "mean": [10.0, 20.0],
+        "std": [1.0, 2.0],
+        "min": [-5.0, -5.0],
+        "max": [5.0, 5.0],
+        "q01": [-1.0, -2.0],
+        "q99": [1.0, 2.0],
+    },
+    "action": {
+        "mean": [0.5, 0.5],
+        "std": [0.1, 0.1],
+        "min": [-1.0, -1.0],
+        "max": [1.0, 1.0],
+        "q01": [-0.25, -0.5],
+        "q99": [0.25, 0.5],
+    },
+}
+
+
+@pytest.mark.parametrize(
+    "declared,expected",
+    [
+        ("QUANTILES", {"mode": "quantile", "q01": [-1.0, -2.0], "q99": [1.0, 2.0]}),
+        ("MEAN_STD", {"mode": "mean_std", "mean": [10.0, 20.0], "std": [1.0, 2.0]}),
+        ("IDENTITY", None),
+    ],
+)
+def test_load_lerobot_norm_stats_takes_the_mode_from_norm_map(tmp_path, declared, expected):
+    """The regression guard. ``_FULL_DATASET_STATS`` carries all six statistics,
+    as a real state_dict does, so an implementation that sniffed the present keys
+    would answer mean_std for every case here. Only norm_map distinguishes them.
+    """
+    path = _write_lerobot_checkpoint(
+        tmp_path, norm_map={"STATE": declared, "ACTION": "QUANTILES"}, stats=_FULL_DATASET_STATS
+    )
+    stats = load_lerobot_norm_stats(path)
+
+    if expected is None:
+        assert "state" not in stats
+    else:
+        assert stats["state"] == expected
+    assert stats["action"]["mode"] == "quantile"
+
+
+@pytest.mark.parametrize("shape", ["no_sidecar", "no_state_file"])
+def test_load_lerobot_norm_stats_absent_stats_are_none(tmp_path, shape):
+    """``lerobot/pi05_base`` is the second shape: a normalizer step with no
+    stats attached. Neither is an error — the client is then expected to send an
+    already-normalized state."""
+    if shape == "no_sidecar":
+        path = str(tmp_path)
+    else:
+        path = _write_lerobot_checkpoint(tmp_path, write_state_file=False)
+
+    assert load_lerobot_norm_stats(path) is None
+
+
+def test_load_lerobot_norm_stats_missing_declared_state_file_raises(tmp_path):
+    path = _write_lerobot_checkpoint(tmp_path, stats=_FULL_DATASET_STATS)
+    (tmp_path / "policy_preprocessor_step_3_normalizer_processor.safetensors").unlink()
+
+    with pytest.raises(FileNotFoundError, match="normalizer state"):
+        load_lerobot_norm_stats(path)
+
+
+def test_pipeline_rejects_missing_model_weights_before_initialization(tmp_path):
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import Pi05Pipeline
+
+    pipeline = object.__new__(Pi05Pipeline)
+    pipeline.model_dir = str(tmp_path)
+
+    with pytest.raises(FileNotFoundError, match="model.safetensors"):
+        pipeline._initialize_model()
+
+
+def test_build_config_merges_the_deploy_yaml_over_the_checkpoint(tmp_path):
+    """The deploy yaml carries the runtime knobs and the checkpoint carries the
+    feature schema and the stats. Both have to land on one config."""
+    from types import SimpleNamespace
+
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import Pi05Pipeline
+
+    pipeline = object.__new__(Pi05Pipeline)
+    pipeline.model_dir = _write_lerobot_checkpoint(tmp_path, stats=_FULL_DATASET_STATS)
+
+    config = pipeline._build_config(SimpleNamespace(model_config={"type": "pi05", "num_inference_steps": 4}))
+
+    assert config.num_inference_steps == 4
+    assert (config.state_dim, config.action_dim) == (2, 2)
+    assert config.image_feature_keys == _EXPECTED_CAMERA_ORDER
+    assert config.norm_stats["state"]["mode"] == "quantile"
+
+
+class _WideActionModel:
+    """Stands in for the 3.6B model, which is the one collaborator here that is
+    genuinely expensive to build. It returns the padded ``max_action_dim`` width
+    the real model emits, so the assertion is about the pipeline's cropping."""
+
+    def __init__(self, chunk_size: int, max_action_dim: int):
+        self._shape = (1, chunk_size, max_action_dim)
+
+    def sample_actions(self, **kwargs):
+        del kwargs
+        return torch.ones(self._shape)
+
+
+def test_pipeline_crops_actions_to_checkpoint_output_schema(monkeypatch):
+    from vllm_omni.diffusion.models.pi05 import pipeline_pi05
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    config = Pi05Config.from_model_config(
+        dict(_LEROBOT_CFG, output_features={"action": {"type": "ACTION", "shape": [7]}})
+    )
+    pipeline = object.__new__(pipeline_pi05.Pi05Pipeline)
+    pipeline.config = config
+    pipeline.tokenizer = object()
+    pipeline._device = torch.device("cpu")
+    pipeline.processor = Pi05Processor(config, object(), torch.device("cpu"))
+    pipeline.model = _WideActionModel(config.chunk_size, config.max_action_dim)
+    monkeypatch.setattr(
+        pipeline.processor,
+        "build_model_inputs",
+        lambda robot_obs: ([torch.empty(0)], [torch.empty(0)], torch.empty(0), torch.empty(0)),
+    )
+    request = OmniDiffusionRequest(
+        prompt="",
+        sampling_params=OmniDiffusionSamplingParams(
+            extra_args={"robot_obs": {"state": np.zeros(config.max_state_dim)}},
+        ),
+        request_id="crop-test",
+    )
+
+    result = pipeline.forward(request)
+
+    assert result.output["actions"].shape == (config.chunk_size, 7)
+
+
+def test_load_lerobot_norm_stats_unknown_mode_raises(tmp_path):
+    """Fail loud: an unreproducible mode served anyway is silently wrong."""
+    path = _write_lerobot_checkpoint(
+        tmp_path, norm_map={"STATE": "SOMETHING_NEW", "ACTION": "QUANTILES"}, stats=_FULL_DATASET_STATS
+    )
+    with pytest.raises(ValueError, match="SOMETHING_NEW"):
+        load_lerobot_norm_stats(path)
+
+
+def test_from_pretrained_backfills_sidecar_stats(tmp_path):
+    """End to end: the stats reach norm_stats without any deploy yaml."""
+    path = _write_lerobot_checkpoint(tmp_path, stats=_FULL_DATASET_STATS)
+    config = Pi05Config.from_pretrained(path)
+
+    assert config.norm_stats["state"]["mode"] == "quantile"
+    assert config.norm_stats["action"]["mode"] == "quantile"
+
+
+def test_from_pretrained_does_not_override_explicit_norm_stats(tmp_path):
+    """config.json wins over the sidecar, matching LeRobot's override rule."""
+    import json as _json
+
+    path = _write_lerobot_checkpoint(tmp_path, stats=_FULL_DATASET_STATS)
+    explicit = {"state": {"mode": "min_max", "min": [0.0] * 32, "max": [1.0] * 32}}
+    (tmp_path / "config.json").write_text(_json.dumps({**_LEROBOT_CFG, "norm_stats": explicit}), encoding="utf-8")
+
+    assert Pi05Config.from_pretrained(path).norm_stats == explicit
+
+
+# ----------------------------------------------------------------------------
+# Checkpoint boundary: declared-but-unconsumed capabilities must raise
+# ----------------------------------------------------------------------------
+@pytest.mark.parametrize(
+    "key,value",
+    [
+        ("use_visual_memory", True),
+        ("use_proprioceptive_memory", True),
+        ("rtc_config", {"mode": "trained", "inference_delay": 2}),
+        ("n_obs_steps", 6),
+    ],
+)
+def test_config_rejects_unsupported_capability(key, value):
+    """MEM and RTC change what a correct action chunk looks like and are not
+    visible in the weights. Serving such a checkpoint must fail loudly."""
+    with pytest.raises(UnsupportedCheckpointCapabilityError, match=key):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, **{key: value}))
+
+
+# ----------------------------------------------------------------------------
+# Relative actions
+# ----------------------------------------------------------------------------
+def test_relative_actions_without_action_names_raises():
+    """``action_feature_names`` is populated from dataset metadata at training
+    time. There is no dataset at serving time, so a relative-action checkpoint
+    that omits it cannot resolve ``relative_exclude_joints`` and must fail."""
+    with pytest.raises(UnsupportedCheckpointCapabilityError, match="action_feature_names"):
+        Pi05Config.from_model_config(dict(_LEROBOT_CFG, use_relative_actions=True, action_feature_names=None))
+
+
+def test_relative_actions_empty_exclude_list_needs_no_action_names():
+    c = Pi05Config.from_model_config(dict(_LEROBOT_CFG, use_relative_actions=True, relative_exclude_joints=[]))
+    assert c.use_relative_actions
+
+
+def test_resolve_excluded_action_indices_unresolvable_raises():
+    with pytest.raises(UnsupportedCheckpointCapabilityError):
+        resolve_excluded_action_indices(["no_such_joint"], _ACTION_NAMES)
+
+
+def _relative_step(enabled=True):
+    return Pi05RelativeActions(
+        enabled=enabled,
+        exclude_joints=["gripper"],
+        action_names=_ACTION_NAMES,
+        max_action_dim=32,
+    )
+
+
+def test_relative_mask_excludes_gripper_and_padding():
+    rel = _relative_step()
+    assert rel.relative_mask[0]
+    assert not rel.relative_mask[6], "gripper must stay absolute"
+    assert not rel.relative_mask[len(_ACTION_NAMES) :].any(), "padded dims carry no signal"
+    assert rel.num_relative_dims == 6
+
+
+def test_relative_absolute_round_trip_is_exact():
+    """The two directions are one object precisely so they cannot disagree."""
+    rel = _relative_step()
+    g = torch.Generator().manual_seed(0)
+    actions = torch.randn(1, 50, 32, generator=g)
+    state = torch.randn(32, generator=g)
+    assert torch.allclose(rel.to_absolute(rel.to_relative(actions, state), state), actions, atol=1e-6)
+
+
+def test_relative_rejects_mismatched_action_dim():
+    rel = _relative_step()
+    with pytest.raises(ValueError, match="max_action_dim"):
+        rel.to_absolute(torch.zeros(1, 4, 8), torch.zeros(32))
+
+
+# ----------------------------------------------------------------------------
+# State discretization — π0.5's defining input path
+# ----------------------------------------------------------------------------
+def test_discretize_underflows_to_minus_one_and_saturates_at_the_top():
+    """Out-of-range input is asymmetric, and that asymmetry is LeRobot's.
+
+    ``np.digitize`` returns 0 for anything below the first bin edge, so the
+    ``- 1`` makes a below-range state land in bin ``-1``; above-range input
+    saturates at ``num_bins - 1`` on its own. The checkpoint was trained with
+    ``" -1"`` in the state prompt for under-range dims, so clipping that to 0
+    would change the tokens the model sees — LeRobot parity catches it.
+    """
+    out = discretize_state(np.array([-9.0, 9.0], dtype=np.float32), num_bins=256)
+    assert out.tolist() == [-1, 255]
+
+
+def test_normalize_state_does_not_clip_out_of_range():
+    """The parity-critical contract: normalization is affine and nothing else.
+
+    Clamping to [-1, 1] here would hide an under-range dimension from
+    ``discretize_state``, turning LeRobot's ``-1`` bin into ``0`` and changing
+    the state tokens in the prompt. LeRobot applies
+    ``2.0 * (x - q01) / (q99 - q01) - 1.0`` with no clip.
+    """
+    stats = {"q01": [0.0] * 32, "q99": [10.0] * 32}
+    out = _normalized([-10.0, 20.0] + [5.0] * 30, stats)
+    assert out[0] == pytest.approx(-3.0)  # would be -1.0 if clipped
+    assert out[1] == pytest.approx(3.0)  # would be 1.0 if clipped
+    # and the under-range dim must reach the -1 bin end to end
+    assert discretize_state(out, num_bins=256)[0] == -1
+
+
+def test_prompt_serializes_the_declared_state_width():
+    """LeRobot's tokenizer step discretizes the state at its real width and
+    never pads to ``max_state_dim``."""
+    prompt = build_pi05_prompt(task="x", normalized_state=np.zeros(7, dtype=np.float32))
+    bins = prompt.split("State: ")[1].split(";")[0].split()
+    assert len(bins) == 7
+
+
+def test_prompt_template_matches_lerobot():
+    prompt = build_pi05_prompt(
+        task="  pick_up the red\nblock ",
+        normalized_state=np.zeros(4, dtype=np.float32),
+    )
+    assert prompt.startswith("Task: pick up the red block, State: ")
+    assert prompt.endswith(";\nAction: ")
+
+
+# ----------------------------------------------------------------------------
+# Input contract: fixed camera slots x 256 tokens + constant 200 text tokens
+# ----------------------------------------------------------------------------
+@pytest.mark.parametrize("views,expected", [(1, 456), (2, 712), (3, 968)])
+def test_prefix_length_is_fixed_by_max_cameras(views, expected):
+    """``max_cameras × 256`` image tokens plus a constant ``tokenizer_max_length``.
+
+    The text segment is padded to its maximum and the camera slots are padded to
+    ``max_cameras``, so the prefix shape does not vary with the request — only
+    the attention mask does.
+    """
+    keys = _EXPECTED_CAMERA_ORDER[:views]
+    config = Pi05Config(max_cameras=views, tokenizer_max_length=200, image_feature_keys=keys)
+    observation = {
+        "state": np.zeros(32, dtype=np.float32),
+        "images": {key: np.zeros((4, 4, 3), dtype=np.uint8) for key in keys},
+    }
+
+    images, masks, lang_tokens, _ = _assemble_model_inputs(
+        observation, config, _FakeTokenizer(), torch.device("cpu"), None
+    )
+
+    assert len(images) == views
+    assert all(bool(mask) for mask in masks)
+    assert lang_tokens.shape[-1] == 200
+    assert 256 * len(images) + lang_tokens.shape[-1] == expected
+
+
+# ----------------------------------------------------------------------------
+# Shared math helpers (same contracts as π0)
+# ----------------------------------------------------------------------------
+def test_gemma_variant_dims():
+    vlm = get_gemma_config("gemma_2b")
+    assert (vlm.width, vlm.depth, vlm.mlp_dim, vlm.num_kv_heads, vlm.head_dim) == (2048, 18, 16384, 1, 256)
+    expert = get_gemma_config("gemma_300m")
+    assert (expert.width, expert.depth, expert.mlp_dim) == (1024, 18, 4096)
+
+
+def test_sinusoidal_embedding_shape_and_oddity():
+    out = create_sinusoidal_pos_embedding(torch.tensor([0.0, 1.0]), 64)
+    assert out.shape == (2, 64)
+    with pytest.raises(ValueError):
+        create_sinusoidal_pos_embedding(torch.tensor([0.0]), 63)
+
+
+def test_make_att_2d_masks_respects_padding():
+    pad = torch.tensor([[True, True, False]])
+    att = torch.tensor([[0, 0, 0]])
+    out = make_att_2d_masks(pad, att)
+    assert not out[0, :, 2].any()
+
+
+def test_build_norm_stats_rejects_unknown_mode():
+    with pytest.raises(ValueError, match="Unsupported normalization mode"):
+        build_norm_stats({"action": {"mode": "qunatile"}}, "action")
+
+
+@pytest.mark.parametrize(
+    "entry",
+    [
+        {"mode": "mean_std", "mean": [0.0]},
+        {"mode": "min_max", "min": [0.0]},
+        {"mode": "quantile", "q01": [0.0]},
+    ],
+)
+def test_build_norm_stats_rejects_incomplete_stats(entry):
+    with pytest.raises(ValueError, match="requires"):
+        build_norm_stats({"action": entry}, "action")
+
+
+def test_normalize_quantile_round_trip_and_padded_tail():
+    stats = build_norm_stats({"action": {"q01": [0.0, 0.0], "q99": [2.0, 4.0]}}, "action")
+    x = torch.tensor([[0.5, -0.5, 7.0]])  # third entry is padding beyond the stats
+    back = apply_norm(apply_norm(x, stats), stats, inverse=True)
+    assert torch.allclose(back, x, atol=1e-5)
+    assert back[0, 2] == 7.0, "padded tail must pass through untouched"
+
+
+# ----------------------------------------------------------------------------
+# Image processor
+# ----------------------------------------------------------------------------
+@pytest.mark.parametrize("value,expected", [(0.0, -1.0), (0.25, -0.5), (1.0, 1.0)])
+@pytest.mark.parametrize("container", ["numpy", "torch"])
+def test_float_image_uses_lerobot_zero_one_domain(value, expected, container):
+    if container == "numpy":
+        image = np.full((4, 4, 3), value, dtype=np.float32)
+    else:
+        image = torch.full((3, 4, 4), value, dtype=torch.float32)
+
+    out = Pi05ImageProcessor(image_size=4).preprocess_single(image)
+
+    assert out.shape == (1, 3, 4, 4)
+    assert torch.allclose(out, torch.full_like(out, expected))
+
+
+@pytest.mark.parametrize("bad", [-0.01, 1.01, np.nan, np.inf])
+@pytest.mark.parametrize("container", ["numpy", "torch"])
+def test_float_image_rejects_values_outside_lerobot_domain(bad, container):
+    if container == "numpy":
+        image = np.full((4, 4, 3), bad, dtype=np.float32)
+    else:
+        image = torch.full((3, 4, 4), bad, dtype=torch.float32)
+
+    with pytest.raises(ValueError):
+        Pi05ImageProcessor(image_size=4).preprocess_single(image)
+
+
+def test_resize_with_pad_pads_with_minus_one():
+    out = resize_with_pad(torch.zeros(1, 3, 100, 200), 224, 224)
+    assert out.shape == (1, 3, 224, 224)
+    assert out[0, 0, 0, 0] == -1.0
+
+
+class _FakeTokenizer:
+    def __call__(self, text, **kwargs):
+        del text
+        length = kwargs["max_length"]
+        return {"input_ids": [0] * length, "attention_mask": [1] * length}
+
+
+@pytest.mark.parametrize("explicit_none", [False, True])
+def test_build_model_inputs_preserves_missing_middle_camera_slot(explicit_none):
+    config = Pi05Config(image_feature_keys=_EXPECTED_CAMERA_ORDER, max_cameras=3)
+    images = {
+        _EXPECTED_CAMERA_ORDER[0]: np.zeros((4, 4, 3), dtype=np.uint8),
+        _EXPECTED_CAMERA_ORDER[2]: np.full((4, 4, 3), 255, dtype=np.uint8),
+    }
+    if explicit_none:
+        images[_EXPECTED_CAMERA_ORDER[1]] = None
+    observation = {
+        "images": images,
+        "state": np.zeros(32, dtype=np.float32),
+    }
+
+    slots, masks, _, _ = _assemble_model_inputs(observation, config, _FakeTokenizer(), torch.device("cpu"), None)
+
+    assert [bool(mask.item()) for mask in masks] == [True, False, True]
+    torch.testing.assert_close(slots[0], torch.full_like(slots[0], -1.0))
+    torch.testing.assert_close(slots[1], torch.full_like(slots[1], -1.0))
+    torch.testing.assert_close(slots[2], torch.full_like(slots[2], 1.0))
+
+
+def test_build_model_inputs_requires_configured_camera():
+    config = Pi05Config(image_feature_keys=_EXPECTED_CAMERA_ORDER)
+    observation = {
+        "unknown_camera": np.zeros((4, 4, 3), dtype=np.uint8),
+        "state": np.zeros(32, dtype=np.float32),
+    }
+    with pytest.raises(ValueError, match="configured camera"):
+        _assemble_model_inputs(observation, config, _FakeTokenizer(), torch.device("cpu"), None)
+
+
+# ----------------------------------------------------------------------------
+# Model behaviour + weight-load remap (tiny action dims; full Gemma backbone)
+# ----------------------------------------------------------------------------
+# Module *structure* (no ``state_proj``, ``time_mlp_{in,out}`` widths, AdaRMS on
+# the expert norms but not the prefix) is not asserted here: ``load_weights``
+# audits every model parameter against the checkpoint and raises on a missing,
+# unmatched or π0-shaped key, so a structural drift fails loudly at load time
+# rather than silently. ``test_pi0_shaped_keys_are_not_silently_loaded`` guards
+# that audit, and ``test_pi05_parity.py`` is the numerical oracle.
+# Both Gemma towers keep their real widths but drop from 18 layers to 2 for
+# every test in this section. Nothing here depends on depth: the weight remap
+# matches by name, and the AR mask, prefix length and ODE determinism are
+# shape-driven. Full-scale numerical correctness is ``test_pi05_parity.py``'s
+# job, against the real checkpoint.
+#
+# Two dimensions must NOT be shrunk, both because something outside these
+# configs is sized against them:
+#
+# * ``width`` — the vision tower's ``multi_modal_projector`` projects image
+#   embeddings to the PaliGemma text width so the two can be concatenated.
+#   Narrowing the text tower alone makes that concat fail.
+# * the vision tower itself — So400m/14 on 224x224 is what yields exactly 256
+#   tokens per view, which ``test_prefix_length_and_valid_len_for_each_view_count``
+#   exists to verify.
+#
+# Depths are equal across the two towers on purpose: the action expert runs
+# layer-by-layer alongside the VLM, so a mismatch would not be a valid model.
+_SHRUNK_GEMMA = {
+    "gemma_2b": GemmaVariantConfig(2048, 2, 1024, 8, 1, 256),
+    "gemma_300m": GemmaVariantConfig(1024, 2, 512, 8, 1, 256),
+}
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _shrink_gemma_backbones():
+    """Patch the module-level lookup ``Pi05ForActionPrediction.__init__`` calls."""
+    patch = pytest.MonkeyPatch()
+    patch.setattr(modeling_pi05, "get_gemma_config", lambda variant: _SHRUNK_GEMMA[variant])
+    yield
+    patch.undo()
+
+
+def _tiny_pi05_model():
+    """A fresh model. Use for tests that load weights or otherwise mutate it."""
+    return Pi05ForActionPrediction(Pi05Config(max_action_dim=8, max_state_dim=8, chunk_size=4, n_action_steps=4))
+
+
+@pytest.fixture(scope="module")
+def tiny_model():
+    """Shared read-only model, so the tests that only inspect it pay for one
+    construction between them rather than one each."""
+    return _tiny_pi05_model()
+
+
+@pytest.fixture(autouse=True)
+def _silence_pi05_loader():
+    logging.getLogger("vllm_omni.diffusion.models.pi05.modeling_pi05").setLevel(logging.CRITICAL)
+    yield
+
+
+@pytest.mark.slow
+def test_suffix_has_no_state_token(tiny_model):
+    """π0's suffix is ``[state, actions...]`` with AR mask ``[1, 1, 0...]``;
+    π0.5's is actions only with ``[1, 0...]``."""
+    embs, pad, att, cond = tiny_model.embed_suffix(torch.randn(1, 4, 8), torch.tensor([1.0]))
+    assert embs.shape[1] == 4
+    assert att[0].tolist() == [1, 0, 0, 0]
+    assert cond.shape == (1, tiny_model.expert_width)
+
+
+# Not marked slow: constructs one small norm layer, no backbone.
+def test_adarms_norm_returns_gate_only_when_conditioned():
+    norm = Pi05AdaRMSNorm(8, cond_dim=4)
+    out, gate = norm(torch.randn(1, 3, 8), torch.randn(1, 4))
+    assert gate is not None and gate.shape == (1, 1, 8)
+
+    plain = Pi05AdaRMSNorm(8, cond_dim=None)
+    out, gate = plain(torch.randn(1, 3, 8))
+    assert gate is None
+
+
+@pytest.mark.slow
+def test_lm_head_remap_to_embed_tokens():
+    model = _tiny_pi05_model()
+    target = "paligemma_with_expert.paligemma.model.language_model.embed_tokens.weight"
+    payload = torch.full(dict(model.named_parameters())[target].shape, 0.5)
+    model.load_weights([("model.paligemma_with_expert.paligemma.lm_head.weight", payload)], strict=False)
+    assert torch.allclose(dict(model.named_parameters())[target], payload)
+
+
+@pytest.mark.slow
+def test_pi0_shaped_keys_are_not_silently_loaded():
+    """A π0 checkpoint pointed at the π0.5 class would leave the AdaRMS expert
+    randomly initialized. ``state_proj`` is the tell."""
+    model = _tiny_pi05_model()
+    with pytest.raises(RuntimeError, match="π0-shaped"):
+        model.load_weights([("model.state_proj.weight", torch.zeros(1024, 8))])
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("num_real_views", [1, 2, 3])
+def test_prefix_length_is_fixed_and_valid_len_tracks_masks(num_real_views, tiny_model):
+    """The deployed model has three slots; only their validity varies."""
+    live_text = 120
+    images = [torch.zeros(1, 3, 224, 224) for _ in range(3)]
+    masks = [torch.tensor([index < num_real_views]) for index in range(3)]
+    lang = torch.zeros(1, 200, dtype=torch.long)
+    lang_mask = torch.zeros(1, 200, dtype=torch.bool)
+    lang_mask[:, :live_text] = True
+
+    embs, pad_masks, _ = tiny_model.embed_prefix(images, masks, lang, lang_mask)
+    assert embs.shape[1] == 256 * 3 + 200
+    assert int(pad_masks.sum()) == 256 * num_real_views + live_text
+
+
+@pytest.mark.slow
+def test_sample_actions_shape_and_determinism(tiny_model):
+    """Flow matching is an ODE: fixed noise must give a bit-identical chunk."""
+    model = tiny_model.eval()
+    images = [torch.zeros(1, 3, 224, 224) for _ in range(3)]
+    masks = [torch.tensor([True]), torch.tensor([False]), torch.tensor([False])]
+    lang = torch.zeros(1, 200, dtype=torch.long)
+    lang_mask = torch.ones(1, 200, dtype=torch.bool)
+    noise = torch.randn(1, 4, 8, generator=torch.Generator().manual_seed(42))
+
+    with torch.no_grad():
+        a1 = model.sample_actions(
+            images=images, image_masks=masks, lang_tokens=lang, lang_masks=lang_mask, noise=noise, num_steps=2
+        )
+        a2 = model.sample_actions(
+            images=images, image_masks=masks, lang_tokens=lang, lang_masks=lang_mask, noise=noise, num_steps=2
+        )
+    assert a1.shape == (1, 4, 8)
+    assert torch.isfinite(a1).all()
+    assert torch.equal(a1, a2)
+
+
+@pytest.mark.slow
+def test_sample_actions_uses_request_generator(tiny_model):
+    model = tiny_model.eval()
+    images = [torch.zeros(1, 3, 224, 224) for _ in range(3)]
+    masks = [torch.tensor([True]), torch.tensor([False]), torch.tensor([False])]
+    lang = torch.zeros(1, 200, dtype=torch.long)
+    lang_mask = torch.ones(1, 200, dtype=torch.bool)
+
+    def run(seed):
+        return model.sample_actions(
+            images=images,
+            image_masks=masks,
+            lang_tokens=lang,
+            lang_masks=lang_mask,
+            num_steps=2,
+            generator=torch.Generator().manual_seed(seed),
+        )
+
+    with torch.no_grad():
+        first = run(42)
+        repeated = run(42)
+        different = run(43)
+
+    assert torch.equal(first, repeated)
+    assert not torch.equal(first, different)
+
+
+# ----------------------------------------------------------------------------
+# Serving dtype
+# ----------------------------------------------------------------------------
+# The check that decides what runs lives on the pipeline, not on Pi05Config:
+# Pi05Config.dtype records what the checkpoint declares and never reaches a
+# cast, while _initialize_model casts using the top-level OmniDiffusionConfig.
+@pytest.mark.parametrize(
+    "declared,expected",
+    [
+        ("float32", torch.float32),
+        ("bfloat16", torch.bfloat16),
+        (torch.float32, torch.float32),
+        (torch.bfloat16, torch.bfloat16),
+    ],
+)
+def test_resolve_dtype_accepts_supported_serving_dtypes(declared, expected):
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import Pi05Pipeline
+
+    assert Pi05Pipeline._resolve_dtype(OmniDiffusionConfig(dtype=declared)) is expected
+
+
+@pytest.mark.parametrize("declared", ["float16", "fp16", torch.float16])
+def test_resolve_dtype_rejects_unvalidated_dtypes(declared):
+    """float16 resolves to a real torch dtype, so a permissive lookup would run
+    the model in a precision nothing here has been checked in.
+
+    Only dtypes that survive ``OmniDiffusionConfig`` normalization are worth
+    asserting on: it maps a string it does not recognize onto bfloat16 with a
+    warning, so e.g. ``"float64"`` never reaches this guard as float64.
+    """
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import Pi05Pipeline
+
+    with pytest.raises(ValueError, match="Unsupported π0.5 dtype"):
+        Pi05Pipeline._resolve_dtype(OmniDiffusionConfig(dtype=declared))
+
+
+def test_bfloat16_layout_is_applied_before_checkpoint_load(monkeypatch, tmp_path):
+    """Checkpoint tensors must be copied directly into their final dtypes.
+
+    LeRobot casts only the inner PaliGemma/expert module; the outer action and
+    time projections remain float32. The layout is established before loading
+    so float32-retained weights never pass through bfloat16.
+    """
+    from vllm_omni.diffusion.models.pi05 import pipeline_pi05
+
+    class _TinyPi05(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.paligemma_with_expert = torch.nn.Module()
+            self.paligemma_with_expert.backbone = torch.nn.Linear(2, 2)
+            self.paligemma_with_expert.vision_tower = torch.nn.Linear(2, 2)
+            self.paligemma_with_expert.input_layernorm = torch.nn.LayerNorm(2)
+            self.paligemma_with_expert.register_buffer("floating_buffer", torch.ones(1))
+            self.action_in_proj = torch.nn.Linear(2, 2)
+            self.action_out_proj = torch.nn.Linear(2, 2)
+            self.time_mlp_in = torch.nn.Linear(2, 2)
+            self.time_mlp_out = torch.nn.Linear(2, 2)
+
+    # DiffusersLoader constructs custom pipelines under the requested default
+    # dtype. Start fully in bfloat16 to verify that the helper restores every
+    # float32-retained tensor rather than relying on the construction default.
+    model = _TinyPi05().to(dtype=torch.bfloat16)
+    observed_dtypes = {}
+
+    def fake_load_checkpoint(_self, model_to_load):
+        observed_dtypes.update({name: param.dtype for name, param in model_to_load.named_parameters()})
+
+    (tmp_path / "model.safetensors").touch()
+    pipeline = object.__new__(pipeline_pi05.Pi05Pipeline)
+    pipeline.model_dir = str(tmp_path)
+    pipeline.config = object()
+    pipeline._device = torch.device("cpu")
+    pipeline._torch_dtype = torch.bfloat16
+    monkeypatch.setattr(pipeline_pi05, "Pi05ForActionPrediction", lambda _config: model)
+    monkeypatch.setattr(pipeline_pi05.Pi05Pipeline, "_load_checkpoint", fake_load_checkpoint)
+
+    initialized = pipeline._initialize_model()
+
+    assert observed_dtypes["paligemma_with_expert.backbone.weight"] is torch.bfloat16
+    assert model.paligemma_with_expert.floating_buffer.dtype is torch.bfloat16
+    for name in (
+        "paligemma_with_expert.vision_tower.weight",
+        "paligemma_with_expert.input_layernorm.weight",
+        "action_in_proj.weight",
+        "action_out_proj.weight",
+        "time_mlp_in.weight",
+        "time_mlp_out.weight",
+    ):
+        assert observed_dtypes[name] is torch.float32
+    assert initialized is model
+    assert not initialized.training
+
+
+@pytest.mark.slow
+def test_bfloat16_runs_and_tracks_float32(tiny_model):
+    """bfloat16 is a supported serving dtype, so it has to produce a usable
+    chunk — and one that still resembles float32.
+
+    The bound is deliberately loose. This is not a parity check (bfloat16
+    deviates from float32 by ~1-2% of the action range on the real checkpoint,
+    which is why recipes/lerobot/Pi05.md tells operators to validate it on their
+    own task). What it catches is gross breakage: a cast that silently did not
+    happen, activations overflowing to inf, or a dtype mismatch that would make
+    the two outputs unrelated.
+    """
+    import copy
+
+    images = [torch.zeros(1, 3, 224, 224) for _ in range(3)]
+    masks = [torch.tensor([True]), torch.tensor([False]), torch.tensor([False])]
+    lang = torch.zeros(1, 200, dtype=torch.long)
+    lang_mask = torch.ones(1, 200, dtype=torch.bool)
+    noise = torch.randn(1, 4, 8, generator=torch.Generator().manual_seed(7))
+
+    def run(model, dtype):
+        with torch.no_grad():
+            return model.sample_actions(
+                images=[img.to(dtype) for img in images],
+                image_masks=masks,
+                lang_tokens=lang,
+                lang_masks=lang_mask,
+                noise=noise.to(dtype),
+                num_steps=2,
+            ).float()
+
+    reference = run(tiny_model.eval(), torch.float32)
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import _set_inference_dtype
+
+    bf16_model = copy.deepcopy(tiny_model).eval()
+    _set_inference_dtype(bf16_model, torch.bfloat16)
+
+    # The cast actually happened — otherwise everything below passes trivially.
+    assert any(param.dtype is torch.bfloat16 for param in bf16_model.parameters())
+    assert bf16_model.action_in_proj.weight.dtype is torch.float32
+    assert bf16_model.action_out_proj.weight.dtype is torch.float32
+    assert bf16_model.time_mlp_in.weight.dtype is torch.float32
+    assert bf16_model.time_mlp_out.weight.dtype is torch.float32
+
+    actual = run(bf16_model, torch.bfloat16)
+    assert actual.shape == reference.shape
+    assert torch.isfinite(actual).all()
+
+    scale = float(reference.abs().max())
+    assert float((actual - reference).abs().max()) < max(0.5 * scale, 1e-2)
+
+
+# ----------------------------------------------------------------------------
+# State normalization runs π0's stats path
+# ----------------------------------------------------------------------------
+@pytest.mark.parametrize(
+    "stats,state,expected",
+    [
+        # A denominator that is small but not zero. ``normalize`` divides by
+        # ``std + eps``; replacing a small std with 1.0 would be a different map.
+        ({"mode": "mean_std", "mean": [0.0], "std": [1e-7]}, [1e-7], 1e-7 / (1e-7 + 1e-8)),
+        ({"mode": "quantile", "q01": [0.0], "q99": [1e-7]}, [1e-7], 1.0),
+        ({"mode": "quantile", "q01": [0.0], "q99": [1e-9]}, [1e-9], 1.0),
+        # An exactly zero range maps the bound to -1 instead of dividing by zero.
+        ({"mode": "quantile", "q01": [2.0], "q99": [2.0]}, [2.0], -1.0),
+    ],
+)
+def test_normalize_state_uses_the_shared_denominator_rule(stats, state, expected):
+    """State normalization and action unnormalization are the same affine map,
+    so a narrow range keeps producing LeRobot's answer."""
+    assert _normalized(state, stats)[0] == pytest.approx(expected, rel=1e-5)
+
+
+# ----------------------------------------------------------------------------
+# State wire contract
+# ----------------------------------------------------------------------------
+@pytest.mark.parametrize("bad", [float("nan"), float("inf"), float("-inf")])
+def test_state_rejects_non_finite_values(bad):
+    """``np.digitize`` maps nan and inf to the top bin and -inf to -1, all legal
+    state tokens, so a dead sensor would reach the model as an ordinary prompt."""
+    with pytest.raises(ValueError, match="NaN or Inf"):
+        as_state_vector([0.0, bad], 2)
+
+
+def test_state_rejects_a_multi_row_matrix():
+    """Flattening would read a (2, 16) request as a 32-value state."""
+    with pytest.raises(ValueError, match=r"\(D,\) or \(1, D\)"):
+        as_state_vector(np.zeros((2, 16), dtype=np.float32), 32)
+
+
+# ----------------------------------------------------------------------------
+# Per-request denoising steps reach the model
+# ----------------------------------------------------------------------------
+class _SpyModel:
+    """Records the ``num_steps`` ``forward`` hands to ``sample_actions``."""
+
+    def __init__(self):
+        self.seen: list = []
+        self.generators: list = []
+
+    def sample_actions(self, *, images, image_masks, lang_tokens, lang_masks, num_steps, generator):
+        del images, image_masks, lang_tokens, lang_masks
+        self.seen.append(num_steps)
+        self.generators.append(generator)
+        return torch.zeros(1, 50, 32)
+
+
+def _spy_pipeline(spy: _SpyModel):
+    from vllm_omni.diffusion.models.pi05.pipeline_pi05 import Pi05Pipeline
+
+    pipeline = object.__new__(Pi05Pipeline)
+    pipeline.config = Pi05Config.from_model_config(_LEROBOT_CFG)
+    pipeline.tokenizer = _FakeTokenizer()
+    pipeline._device = torch.device("cpu")
+    pipeline.model = spy
+    pipeline.processor = Pi05Processor(pipeline.config, _FakeTokenizer(), torch.device("cpu"))
+    return pipeline
+
+
+def _spy_request(num_inference_steps, generator=None):
+    params = type("_Params", (), {})()
+    params.extra_args = {
+        "robot_obs": {
+            "state": np.zeros(32, dtype=np.float32),
+            "images": {key: np.zeros((4, 4, 3), dtype=np.uint8) for key in _EXPECTED_CAMERA_ORDER},
+        }
+    }
+    params.num_inference_steps = num_inference_steps
+    params.generator = generator
+    request = type("_Request", (), {})()
+    request.sampling_params = params
+    return request
+
+
+@pytest.mark.parametrize("requested", [None, 2, 25])
+def test_request_denoising_steps_reach_sample_actions(requested):
+    """The OpenPI E2E cannot see this: a pipeline that ignored the override and
+    ran the static default would still return a finite chunk of the right shape."""
+    spy = _SpyModel()
+    output = _spy_pipeline(spy).forward(_spy_request(requested))
+
+    assert spy.seen == [requested]
+    assert output.output["actions"].shape == (50, 32)
+
+
+def test_request_generator_reaches_sample_actions():
+    generator = torch.Generator().manual_seed(42)
+    spy = _SpyModel()
+
+    _spy_pipeline(spy).forward(_spy_request(2, generator))
+
+    assert spy.generators == [generator]
+
+
+@pytest.mark.parametrize("bad", [0, -1, 2.5, True, "4"])
+def test_request_denoising_steps_must_be_a_positive_integer(bad):
+    spy = _SpyModel()
+    with pytest.raises(ValueError, match="num_inference_steps must be a positive integer"):
+        _spy_pipeline(spy).forward(_spy_request(bad))
+    assert spy.seen == []
diff --git a/tests/diffusion/models/qwen_image/test_qwen_image_fused_qk_norm_rope.py b/tests/diffusion/models/qwen_image/test_qwen_image_fused_qk_norm_rope.py
index 2f10ea33e..16dc85115 100644
--- a/tests/diffusion/models/qwen_image/test_qwen_image_fused_qk_norm_rope.py
+++ b/tests/diffusion/models/qwen_image/test_qwen_image_fused_qk_norm_rope.py
@@ -11,7 +11,6 @@ import torch.nn as nn
 
 from vllm_omni.diffusion.layers.rope import RotaryEmbedding
 from vllm_omni.diffusion.models.qwen_image.qwen_image_transformer import (
-    _apply_qwen_image_rotary_emb,
     _qwen_image_qk_norm_rope,
 )
 
@@ -73,22 +72,28 @@ def _make_input(
     return QwenImageQKInput(q=q, k=k, norm_q=norm_q, norm_k=norm_k, freqs=freqs)
 
 
-def _reference(data: QwenImageQKInput) -> tuple[torch.Tensor, torch.Tensor]:
+def _eager_rotary(data: QwenImageQKInput) -> tuple[torch.Tensor, torch.Tensor]:
     q = data.norm_q(data.q)
     k = data.norm_k(data.k)
-    if data.q.device.type == "cuda":
-        return (
-            _apply_qwen_image_rotary_emb(q, data.freqs),
-            _apply_qwen_image_rotary_emb(k, data.freqs),
-        )
-
     rope = RotaryEmbedding(is_neox_style=False)
     cos = data.freqs.real.to(data.q.dtype)
     sin = data.freqs.imag.to(data.q.dtype)
     return rope(q, cos, sin), rope(k, cos, sin)
 
 
-def _run(data: QwenImageQKInput) -> tuple[torch.Tensor, torch.Tensor]:
+def _fp32_complex_rotary(x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
+    """Local copy of the old CUDA helper; fused kernel still tracks this math."""
+    paired = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2))
+    return torch.view_as_real(paired * freqs.unsqueeze(1)).flatten(3).to(x.dtype)
+
+
+def _fused_kernel_reference(data: QwenImageQKInput) -> tuple[torch.Tensor, torch.Tensor]:
+    q = data.norm_q(data.q)
+    k = data.norm_k(data.k)
+    return _fp32_complex_rotary(q, data.freqs), _fp32_complex_rotary(k, data.freqs)
+
+
+def _run(data: QwenImageQKInput, *, use_fused: bool = True) -> tuple[torch.Tensor, torch.Tensor]:
     return _qwen_image_qk_norm_rope(
         data.q,
         data.k,
@@ -97,6 +102,7 @@ def _run(data: QwenImageQKInput) -> tuple[torch.Tensor, torch.Tensor]:
         data.freqs,
         RotaryEmbedding(is_neox_style=False),
         EPS,
+        use_fused=use_fused,
     )
 
 
@@ -110,8 +116,8 @@ def test_qwen_image_qk_norm_rope_cuda_fp32_fallback_matches_reference():
         packed_qkv_view=True,
     )
 
-    actual_q, actual_k = _run(data)
-    expected_q, expected_k = _reference(data)
+    actual_q, actual_k = _run(data, use_fused=False)
+    expected_q, expected_k = _eager_rotary(data)
 
     torch.testing.assert_close(actual_q, expected_q, atol=1e-5, rtol=1e-5)
     torch.testing.assert_close(actual_k, expected_k, atol=1e-5, rtol=1e-5)
@@ -127,8 +133,8 @@ def test_qwen_image_qk_norm_rope_cuda_fp16_fallback_matches_reference():
         packed_qkv_view=True,
     )
 
-    actual_q, actual_k = _run(data)
-    expected_q, expected_k = _reference(data)
+    actual_q, actual_k = _run(data, use_fused=False)
+    expected_q, expected_k = _eager_rotary(data)
 
     torch.testing.assert_close(actual_q, expected_q, atol=1e-3, rtol=1e-3)
     torch.testing.assert_close(actual_k, expected_k, atol=1e-3, rtol=1e-3)
@@ -150,7 +156,7 @@ def test_qwen_image_fused_qk_norm_rope_cuda_matches_fp32_rope_reference(
     )
 
     actual_q, actual_k = _run(data)
-    expected_q, expected_k = _reference(data)
+    expected_q, expected_k = _fused_kernel_reference(data)
 
     torch.testing.assert_close(actual_q, expected_q, atol=0.0625, rtol=0.02)
     torch.testing.assert_close(actual_k, expected_k, atol=0.0625, rtol=0.02)
diff --git a/tests/diffusion/models/qwen_image/test_qwen_image_pipeline_device.py b/tests/diffusion/models/qwen_image/test_qwen_image_pipeline_device.py
new file mode 100644
index 000000000..7f0ce51c8
--- /dev/null
+++ b/tests/diffusion/models/qwen_image/test_qwen_image_pipeline_device.py
@@ -0,0 +1,131 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Encoder/VAE placement under cpu_offload; DiT follows the loader device context."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+from torch import nn
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+_DEVICE_STACK: list[str] = ["cpu"]
+_REAL_TORCH_DEVICE = torch.device
+
+
+class _FakeDevice:
+    def __init__(self, type_: str):
+        self.type = type_
+        self.index = 0
+
+    def __enter__(self):
+        _DEVICE_STACK.append(self.type)
+        return self
+
+    def __exit__(self, *args):
+        _DEVICE_STACK.pop()
+        return False
+
+
+def _fake_torch_device(spec):
+    if isinstance(spec, _FakeDevice):
+        return spec
+    if isinstance(spec, _REAL_TORCH_DEVICE):
+        return _FakeDevice(spec.type)
+    return _FakeDevice(str(spec).split(":")[0])
+
+
+class _RecordingTransformer(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.probe_device_type = _DEVICE_STACK[-1]
+
+
+class _MoveableModule(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.placed_device = _FakeDevice("cpu")
+        self.weight = nn.Parameter(torch.zeros(1))
+
+    def to(self, device, *args, **kwargs):
+        if isinstance(device, _FakeDevice):
+            self.placed_device = device
+        elif isinstance(device, _REAL_TORCH_DEVICE):
+            self.placed_device = _FakeDevice(device.type)
+        else:
+            self.placed_device = _FakeDevice(str(device).split(":")[0])
+        return self
+
+    @property
+    def temperal_downsample(self):
+        return [True, True, True]
+
+
+def _run_pipeline_init(monkeypatch, *, enable_cpu_offload, loader_device):
+    import vllm_omni.diffusion.models.qwen_image.pipeline_qwen_image as pipe_mod
+    from vllm_omni.diffusion.models.qwen_image.pipeline_qwen_image import QwenImagePipeline
+
+    enc = _MoveableModule()
+    vae = _MoveableModule()
+    _DEVICE_STACK.clear()
+    _DEVICE_STACK.append(loader_device)
+
+    monkeypatch.setattr(pipe_mod, "get_local_device", lambda: _REAL_TORCH_DEVICE("cuda"))
+    monkeypatch.setattr(pipe_mod.torch, "device", _fake_torch_device)
+    monkeypatch.setattr(pipe_mod, "prefetch_subfolders", lambda *a, **k: None)
+    monkeypatch.setattr(pipe_mod, "get_transformer_config_kwargs", lambda *a, **k: {})
+    monkeypatch.setattr(pipe_mod, "QwenImageTransformer2DModel", _RecordingTransformer)
+    monkeypatch.setattr(
+        pipe_mod.FlowMatchEulerDiscreteScheduler,
+        "from_pretrained",
+        classmethod(lambda cls, *a, **k: MagicMock()),
+    )
+    monkeypatch.setattr(
+        pipe_mod.Qwen2Tokenizer,
+        "from_pretrained",
+        classmethod(lambda cls, *a, **k: MagicMock()),
+    )
+
+    def _prefetch(factory, *args, **kwargs):
+        subfolder = kwargs.get("subfolder")
+        if subfolder == "text_encoder":
+            return enc
+        if subfolder == "vae":
+            return vae
+        raise AssertionError(f"unexpected prefetch subfolder={subfolder!r}")
+
+    monkeypatch.setattr(pipe_mod, "from_pretrained_with_prefetch", _prefetch)
+    monkeypatch.setattr(
+        QwenImagePipeline,
+        "setup_diffusion_pipeline_profiler",
+        lambda self, **kwargs: None,
+    )
+
+    od_config = SimpleNamespace(
+        model="/tmp/unused-qwen-image",
+        parallel_config=SimpleNamespace(),
+        tf_model_config={},
+        quantization_config=None,
+        enable_cpu_offload=enable_cpu_offload,
+        enable_diffusion_pipeline_profiler=False,
+    )
+    return QwenImagePipeline(od_config=od_config)
+
+
+def test_pipeline_cpu_offload_parks_encoder_vae_on_cpu(monkeypatch):
+    """#7555: cpu_offload keeps BF16 encoder/VAE off the GPU during DiT init."""
+    pipe = _run_pipeline_init(monkeypatch, enable_cpu_offload=True, loader_device="cuda")
+    assert pipe.text_encoder.placed_device.type == "cpu"
+    assert pipe.vae.placed_device.type == "cpu"
+    assert pipe.transformer.probe_device_type == "cuda"
+
+
+def test_pipeline_dit_follows_loader_cpu_without_override(monkeypatch):
+    """Layerwise / HSDP: DiT must not be forced onto CUDA by the pipeline."""
+    pipe = _run_pipeline_init(monkeypatch, enable_cpu_offload=False, loader_device="cpu")
+    assert pipe.transformer.probe_device_type == "cpu"
+    assert pipe.text_encoder.placed_device.type == "cuda"
+    assert pipe.vae.placed_device.type == "cuda"
diff --git a/tests/diffusion/models/qwen_image/test_qwen_image_rope_utils.py b/tests/diffusion/models/qwen_image/test_qwen_image_rope_utils.py
index 4f3a81491..3fd141dc1 100644
--- a/tests/diffusion/models/qwen_image/test_qwen_image_rope_utils.py
+++ b/tests/diffusion/models/qwen_image/test_qwen_image_rope_utils.py
@@ -3,37 +3,12 @@ import torch
 
 from vllm_omni.diffusion.models.qwen_image.qwen_image_transformer import (
     QwenEmbedRope,
-    _apply_qwen_image_rotary_emb,
 )
 from vllm_omni.diffusion.models.qwen_image.rope_utils import txt_seq_lens_from_embeds
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
-@pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
-@pytest.mark.parametrize("noncontiguous", [False, True])
-def test_qwen_rotary_preserves_frequency_precision(dtype, noncontiguous):
-    from diffusers.models.transformers.transformer_qwenimage import apply_rotary_emb_qwen
-
-    generator = torch.Generator().manual_seed(42)
-    x = torch.randn(2, 17, 3, 128, generator=generator).to(dtype)
-    if noncontiguous:
-        x = x.transpose(1, 2).contiguous().transpose(1, 2)
-    angles = torch.randn(17, 64, generator=generator)
-    freqs = torch.polar(torch.ones_like(angles), angles)
-    expected = apply_rotary_emb_qwen(x, freqs, use_real=False)
-    actual = _apply_qwen_image_rotary_emb(x, freqs)
-    assert actual.dtype == dtype
-    assert actual.shape == x.shape
-    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
-
-    if dtype == torch.bfloat16:
-        # A regression to early BF16 frequency rounding must be observable.
-        rounded_freqs = torch.complex(freqs.real.to(dtype).float(), freqs.imag.to(dtype).float())
-        rounded = _apply_qwen_image_rotary_emb(x, rounded_freqs)
-        assert not torch.equal(actual, rounded)
-
-
 def test_txt_seq_lens_from_embeds_uses_padded_width_not_valid_token_count():
     prompt_embeds = torch.zeros(2, 64, 8)
     prompt_embeds_mask = torch.zeros(2, 64, dtype=torch.bool)
diff --git a/tests/diffusion/models/wan2_2/test_create_transformer_quant.py b/tests/diffusion/models/wan2_2/test_create_transformer_quant.py
index bb95363fd..b01f275eb 100644
--- a/tests/diffusion/models/wan2_2/test_create_transformer_quant.py
+++ b/tests/diffusion/models/wan2_2/test_create_transformer_quant.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for transformer quant-config auto-detection.
 
 The loader path at pipeline_wan2_2.py carries two quantization contracts:
@@ -27,6 +27,7 @@ from types import SimpleNamespace
 import pytest
 
 import vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 as wan22_module
+from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import create_transformer_from_config
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
@@ -381,3 +382,213 @@ def test_pipeline_cascade_mxfp4_dualscale_each_transformer_gets_correct_ignored_
 
     # od_config must remain unchanged — _create_transformer does not modify it.
     assert od_config.quantization_config is None
+
+
+def _construct_quantized_pipeline(pipeline_kind, active, disk_quant_config, tmp_path, monkeypatch):
+    import json
+
+    import torch
+
+    import vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_i2v as i2v_module
+    import vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_vace as vace_module
+
+    monkeypatch.setattr("vllm_omni.platforms.current_omni_platform.is_npu", lambda: True)
+    for component in ("transformer", "transformer_2"):
+        directory = tmp_path / component
+        directory.mkdir()
+        config = dict(_MIN_CFG)
+        expert_quant_config = (
+            disk_quant_config[0 if component == "transformer" else 1]
+            if isinstance(disk_quant_config, tuple)
+            else disk_quant_config
+        )
+        if expert_quant_config is not None:
+            config["quantization_config"] = expert_quant_config
+        (directory / "config.json").write_text(json.dumps(config))
+    (tmp_path / "model_index.json").write_text(json.dumps({"transformer_2": ["diffusers", "WanTransformer3DModel"]}))
+
+    class FakeComponent(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.config = SimpleNamespace(scale_factor_temporal=4, scale_factor_spatial=8)
+
+    class FakeTransformer(FakeComponent):
+        def __init__(self, quant_config=None, **kwargs):
+            super().__init__()
+            self.received_quant_config = quant_config
+
+    for module in (wan22_module, i2v_module):
+        monkeypatch.setattr(module, "get_local_device", lambda: torch.device("cpu"))
+        monkeypatch.setattr(module, "prefetch_subfolders", lambda *args, **kwargs: None)
+        monkeypatch.setattr(module, "from_pretrained_with_prefetch", lambda *args, **kwargs: FakeComponent())
+    monkeypatch.setattr(wan22_module, "WanTransformer3DModel", FakeTransformer)
+    monkeypatch.setattr(vace_module, "WanVACETransformer3DModel", FakeTransformer)
+    pipeline_cls = {
+        "t2v": wan22_module.Wan22Pipeline,
+        "i2v": i2v_module.Wan22I2VPipeline,
+        "vace": vace_module.Wan22VACEPipeline,
+    }[pipeline_kind]
+    monkeypatch.setattr(pipeline_cls, "setup_diffusion_pipeline_profiler", lambda *args, **kwargs: None)
+    od_config = OmniDiffusionConfig(
+        model=str(tmp_path),
+        model_class_name=pipeline_cls.__name__,
+        dtype=torch.bfloat16,
+        quantization_config=active,
+        boundary_ratio=0.875,
+        flow_shift=12.0,
+        enable_diffusion_pipeline_profiler=False,
+    )
+    od_config.enrich_config()
+    pipeline = pipeline_cls(od_config=od_config)
+    return pipeline
+
+
+@pytest.mark.parametrize("pipeline_kind", ["t2v", "i2v", "vace"])
+@pytest.mark.parametrize("method, flag", [("mxfp4", "is_checkpoint_mxfp4_serialized")])
+@pytest.mark.parametrize("offline", [False, True])
+def test_pipeline_constructor_routes_each_expert_quantization(
+    pipeline_kind, method, flag, offline, tmp_path, monkeypatch, mocker
+):
+    """Run the actual pipeline constructors, expert factories and quant-method dispatch."""
+    from vllm.model_executor.layers.linear import LinearBase, UnquantizedLinearMethod
+
+    from vllm_omni.quantization import build_quant_config
+
+    active = build_quant_config(
+        {
+            "transformer": {
+                "method": method,
+                "w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"],
+                "w4a8_fallback_steps": [0, 1],
+            },
+            "transformer_2": {
+                "method": method,
+                "w4a8_fallback_layers": ["blocks.11.attn1.to_qkv"],
+                "w4a8_fallback_steps": [],
+            },
+        }
+    )
+    disk_quant_config = None
+    if offline:
+        disk_quant_config = {
+            "quant_method": method,
+            flag: True,
+            "ignored_layers": ["blocks.12.ffn.net_2"],
+            "w4a8_fallback_layers": ["blocks.9.attn1.to_qkv"],
+            "w4a8_fallback_steps": [9],
+        }
+    pipeline = _construct_quantized_pipeline(pipeline_kind, active, disk_quant_config, tmp_path, monkeypatch)
+    for index, transformer in enumerate((pipeline.transformer, pipeline.transformer_2)):
+        received = transformer.received_quant_config
+        assert received.get_name() == method
+        assert getattr(received, flag) == offline
+        assert received.w4a8_fallback_steps == ([0, 1] if index == 0 else [])
+        selected = f"blocks.{10 + index}.attn1.to_qkv"
+        other = f"blocks.{11 - index}.attn1.to_qkv"
+        assert received.w4a8_fallback_layers == [selected]
+        assert received.get_quant_method(mocker.Mock(spec=LinearBase), selected).is_w4a8_fallback_layer
+        assert not received.get_quant_method(mocker.Mock(spec=LinearBase), other).is_w4a8_fallback_layer
+        if offline:
+            assert isinstance(
+                received.get_quant_method(mocker.Mock(spec=LinearBase), "blocks.12.ffn.net_2"), UnquantizedLinearMethod
+            )
+    assert pipeline.od_config.quantization_config is active
+
+
+@pytest.mark.parametrize("explicit_none", [False, True])
+def test_pipeline_disabled_component_requires_unquantized_checkpoint(explicit_none, monkeypatch):
+    from vllm_omni.quantization import build_quant_config
+
+    FakeTransformer, captured = _make_fake_transformer()
+    monkeypatch.setattr(wan22_module, "WanTransformer3DModel", FakeTransformer)
+    components = {"transformer": {"method": "mxfp4"}, "transformer_2": None} if explicit_none else {"vae": None}
+    active = build_quant_config(components)
+    pipeline = _FakePipeline(OmniDiffusionConfig(model="", quantization_config=active))
+    pipeline._create_transformer(_MIN_CFG, component="transformer_2")
+    assert captured[-1].get("quant_config") is None
+    with pytest.raises(ValueError, match="disabled for component 'transformer_2'"):
+        pipeline._create_transformer(
+            {**_MIN_CFG, "quantization_config": {"quant_method": "mxfp4", "is_checkpoint_mxfp4_serialized": True}},
+            component="transformer_2",
+        )
+
+
+def test_pipeline_component_default_reaches_expert_factory(monkeypatch):
+    from vllm_omni.quantization import build_quant_config
+
+    FakeTransformer, captured = _make_fake_transformer()
+    monkeypatch.setattr(wan22_module, "WanTransformer3DModel", FakeTransformer)
+    active = build_quant_config({"default": {"method": "mxfp4", "w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"]}})
+    pipeline = _FakePipeline(OmniDiffusionConfig(model="", quantization_config=active))
+    pipeline._create_transformer(_MIN_CFG, component="transformer_2")
+    assert captured[-1]["quant_config"] is active.default_config
+
+
+@pytest.mark.parametrize("pipeline_kind", ["t2v", "i2v", "vace"])
+@pytest.mark.parametrize(
+    "configured_expert, with_default",
+    [
+        ("transformer", False),
+        ("transformer", True),
+        ("transformer_2", False),
+        ("transformer_2", True),
+    ],
+)
+def test_pipeline_partial_expert_config_does_not_match_sibling(
+    pipeline_kind, configured_expert, with_default, tmp_path, monkeypatch
+):
+    from vllm_omni.quantization import build_quant_config
+
+    component_spec = {
+        configured_expert: {"method": "mxfp4", "w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"]},
+    }
+    if with_default:
+        component_spec["default"] = {"method": "mxfp4", "w4a8_fallback_layers": ["blocks.11.attn1.to_qkv"]}
+    active = build_quant_config(component_spec)
+    pipeline = _construct_quantized_pipeline(pipeline_kind, active, None, tmp_path, monkeypatch)
+    sibling = "transformer_2" if configured_expert == "transformer" else "transformer"
+    selected = getattr(pipeline, configured_expert).received_quant_config
+    other = getattr(pipeline, sibling).received_quant_config
+    assert selected is active.component_configs[configured_expert]
+    assert other is active.default_config
+    if with_default:
+        assert other.w4a8_fallback_layers == ["blocks.11.attn1.to_qkv"]
+    else:
+        assert other is None
+
+
+@pytest.mark.parametrize("pipeline_kind", ["t2v", "i2v", "vace"])
+@pytest.mark.parametrize("different_ignored_layers", [False, True])
+def test_enriched_auto_quantization_preserves_each_expert_policy(
+    pipeline_kind, different_ignored_layers, tmp_path, monkeypatch
+):
+    """Startup auto-detection must not turn the first expert into a user override."""
+    high = {
+        "quant_method": "mxfp4",
+        "is_checkpoint_mxfp4_serialized": True,
+        "ignored_layers": ["blocks.0.ffn.net_2"],
+        "w4a8_fallback_steps": [],
+        "w4a8_fallback_layers": [],
+        "mxfp4_scale_alg": 0,
+        "require_smooth_scale": False,
+    }
+    low = {
+        **high,
+        "ignored_layers": ["blocks.1.ffn.net_2"] if different_ignored_layers else high["ignored_layers"],
+        "w4a8_fallback_steps": [37],
+        "w4a8_fallback_layers": ["blocks.11.attn1.to_qkv"],
+        "mxfp4_scale_alg": 2,
+        "require_smooth_scale": True,
+    }
+    pipeline = _construct_quantized_pipeline(pipeline_kind, None, (high, low), tmp_path, monkeypatch)
+    assert pipeline.od_config.quantization_config is not None  # enrich_config really detected the first expert.
+    for transformer, expected in [(pipeline.transformer, high), (pipeline.transformer_2, low)]:
+        config = transformer.received_quant_config
+        for policy in (
+            "ignored_layers",
+            "w4a8_fallback_steps",
+            "w4a8_fallback_layers",
+            "mxfp4_scale_alg",
+            "require_smooth_scale",
+        ):
+            assert getattr(config, policy) == expected[policy], policy
diff --git a/tests/diffusion/models/wan2_2/test_wan22_chunked_mp4.py b/tests/diffusion/models/wan2_2/test_wan22_chunked_mp4.py
new file mode 100644
index 000000000..2855bf6fb
--- /dev/null
+++ b/tests/diffusion/models/wan2_2/test_wan22_chunked_mp4.py
@@ -0,0 +1,165 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import io
+from types import SimpleNamespace
+
+import av
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.wan2_2.chunked_mp4 import (
+    WAN_DEFAULT_OUTPUT_FPS,
+    resolve_wan_output_fps,
+    resolve_wan_preencode_batch_frames,
+    resolve_wan_preencode_mp4,
+    resolve_wan_video_codec_options,
+    wan_preencoded_mp4_payload,
+)
+from vllm_omni.diffusion.utils.chunked_video import decode_to_mp4
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+class _FakeWanVAE:
+    """Publish temporal chunks the way the Wan VAE seam does."""
+
+    chunk_value_range = (-1.0, 1.0)
+
+    def __init__(self, *, batch: int, chunks: int, frames_per_chunk: int, height: int, width: int):
+        self.batch = batch
+        self.chunks = chunks
+        self.frames_per_chunk = frames_per_chunk
+        self.height = height
+        self.width = width
+        self.chunk_calls = 0
+
+    def decode_with_chunks(self, latents, *, on_chunk):
+        del latents
+        assert on_chunk is not None
+        for index in range(self.chunks):
+            self.chunk_calls += 1
+            value = -1.0 + 2.0 * index / max(self.chunks - 1, 1)
+            on_chunk(torch.full((self.batch, 3, self.frames_per_chunk, self.height, self.width), value))
+
+
+def _decoded_frame_count(data: bytes) -> int:
+    with av.open(io.BytesIO(data)) as container:
+        return sum(1 for _ in container.decode(video=0))
+
+
+def test_decode_wan_latents_to_mp4_emits_one_playable_mp4_per_batch_entry():
+    vae = _FakeWanVAE(batch=2, chunks=6, frames_per_chunk=2, height=16, width=32)
+
+    videos = decode_to_mp4(vae, torch.zeros(1), fps=24, batch_frames=4)
+
+    assert len(videos) == 2
+    for data in videos:
+        assert data[:4] and _decoded_frame_count(data) == 12
+
+
+def test_decode_wan_latents_to_mp4_coalesces_transfers_without_losing_frames():
+    """batch_frames only changes how many transfers carry the same frames."""
+    unbatched = _FakeWanVAE(batch=1, chunks=8, frames_per_chunk=1, height=16, width=32)
+    batched = _FakeWanVAE(batch=1, chunks=8, frames_per_chunk=1, height=16, width=32)
+
+    per_chunk = decode_to_mp4(unbatched, torch.zeros(1), fps=24, batch_frames=1)
+    coalesced = decode_to_mp4(batched, torch.zeros(1), fps=24, batch_frames=4)
+
+    assert _decoded_frame_count(per_chunk[0]) == _decoded_frame_count(coalesced[0]) == 8
+
+
+def test_decode_wan_latents_to_mp4_returns_nothing_for_a_rank_without_output():
+    class SilentVAE:
+        chunk_value_range = (-1.0, 1.0)
+
+        def decode_with_chunks(self, latents, *, on_chunk):
+            del latents, on_chunk
+
+    assert decode_to_mp4(SilentVAE(), torch.zeros(1), fps=24) == []
+
+
+def test_decode_wan_latents_to_mp4_rejects_a_non_positive_batch():
+    with pytest.raises(ValueError, match="batch_frames"):
+        decode_to_mp4(
+            _FakeWanVAE(batch=1, chunks=1, frames_per_chunk=1, height=16, width=16), None, fps=24, batch_frames=0
+        )
+
+
+def test_decode_wan_latents_to_mp4_rejects_a_vae_without_the_capability():
+    class PlainVAE:
+        chunk_value_range = (-1.0, 1.0)
+
+        def decode(self, z, return_dict=True):
+            del z, return_dict
+
+    with pytest.raises(TypeError, match="chunked VAE decode capability"):
+        decode_to_mp4(PlainVAE(), torch.zeros(1), fps=24)
+
+
+def test_preencode_flag_is_off_unless_the_request_asks_for_it():
+    assert resolve_wan_preencode_mp4(SimpleNamespace(extra_args=None), output_type="np") is False
+    assert resolve_wan_preencode_mp4(SimpleNamespace(extra_args={}), output_type="np") is False
+    assert resolve_wan_preencode_mp4(SimpleNamespace(extra_args={"preencode_mp4": True}), output_type="np") is True
+
+
+def test_preencode_rejects_combinations_it_cannot_serve():
+    interpolating = SimpleNamespace(extra_args={"preencode_mp4": True}, enable_frame_interpolation=True)
+    with pytest.raises(ValueError, match="enable_frame_interpolation"):
+        resolve_wan_preencode_mp4(interpolating, output_type="np")
+
+    with pytest.raises(ValueError, match="output_type"):
+        resolve_wan_preencode_mp4(SimpleNamespace(extra_args={"preencode_mp4": True}), output_type="pil")
+
+
+def test_output_fps_mirrors_the_serving_fallback():
+    assert resolve_wan_output_fps(SimpleNamespace(fps=16)) == 16
+    assert resolve_wan_output_fps(SimpleNamespace(fps=[16])) == 16
+    assert resolve_wan_output_fps(SimpleNamespace(fps=None)) == WAN_DEFAULT_OUTPUT_FPS
+    assert resolve_wan_output_fps(SimpleNamespace()) == WAN_DEFAULT_OUTPUT_FPS
+
+
+def test_codec_options_reach_the_encoder_as_strings():
+    params = SimpleNamespace(extra_args={"video_codec_options": {"preset": "ultrafast", "threads": 0}})
+    assert resolve_wan_video_codec_options(params) == {"preset": "ultrafast", "threads": "0"}
+    assert resolve_wan_video_codec_options(SimpleNamespace(extra_args={})) == {"preset": "ultrafast", "threads": "0"}
+    assert resolve_wan_video_codec_options(SimpleNamespace(extra_args={"video_codec_options": None})) is None
+    assert resolve_wan_video_codec_options(SimpleNamespace(extra_args={"video_codec_options": {}})) == {}
+
+
+def test_preencoded_payload_passes_bytes_through_and_ignores_tensors():
+    assert wan_preencoded_mp4_payload(torch.zeros(1, 3, 2, 4, 4)) is None
+    assert wan_preencoded_mp4_payload([b"one", b"two"]) == {"payload": {"video": [b"one", b"two"]}, "metadata": {}}
+    assert wan_preencoded_mp4_payload(b"one") == {"payload": {"video": [b"one"]}, "metadata": {}}
+
+
+@pytest.mark.parametrize("value", [1, 5, 33])
+def test_request_batch_threshold_controls_transfers_without_losing_frames(monkeypatch, value):
+    from vllm_omni.diffusion.utils import chunked_video
+
+    transfers = []
+    quantize = chunked_video.quantize_chunk
+
+    def capture(chunk, value_range):
+        transfers.append(chunk.shape[2])
+        return quantize(chunk, value_range)
+
+    monkeypatch.setattr(chunked_video, "quantize_chunk", capture)
+    params = SimpleNamespace(extra_args={"preencode_mp4": True, "preencode_batch_frames": value})
+    vae = _FakeWanVAE(batch=1, chunks=4, frames_per_chunk=3, height=16, width=32)
+    videos = decode_to_mp4(vae, torch.zeros(1), fps=24, batch_frames=resolve_wan_preencode_batch_frames(params))
+
+    assert transfers == {1: [3, 3, 3, 3], 5: [6, 6], 33: [12]}[value]
+    assert _decoded_frame_count(videos[0]) == 12
+
+
+@pytest.mark.parametrize("value", [0, -1, True, 1.5, "17", None])
+def test_request_batch_threshold_rejects_invalid_values(value):
+    with pytest.raises(ValueError, match="preencode_batch_frames"):
+        resolve_wan_preencode_batch_frames(SimpleNamespace(extra_args={"preencode_batch_frames": value}))
+
+
+def test_request_batch_threshold_preserves_model_defaults():
+    params = SimpleNamespace(extra_args=None)
+    assert resolve_wan_preencode_batch_frames(params) == 17
+    assert resolve_wan_preencode_batch_frames(params, default=1) == 1
diff --git a/tests/diffusion/models/wan2_2/test_wan22_mindie_metadata.py b/tests/diffusion/models/wan2_2/test_wan22_mindie_metadata.py
new file mode 100644
index 000000000..c316a207d
--- /dev/null
+++ b/tests/diffusion/models/wan2_2/test_wan22_mindie_metadata.py
@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Wan integration contracts required by quantized dense/sparse attention."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.wan2_2.wan2_2_transformer import WanTransformerBlock
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def test_block_publishes_unpadded_grid_without_partial_packed_metadata():
+    block = object.__new__(WanTransformerBlock)
+    torch.nn.Module.__init__(block)
+    block.scale_shift_table = torch.zeros(1, 6, 4)
+    block.norm1 = lambda x, *a: x
+    block.norm2 = lambda x: x
+    block.norm3 = lambda x, *a: x
+    block.attn1 = Mock(side_effect=lambda x, *a: torch.zeros_like(x))
+    block.attn2 = Mock(side_effect=lambda x, *a: torch.zeros_like(x))
+    block.ffn = lambda x: torch.zeros_like(x)
+    # Local SP tokens include alignment padding; grid describes the full valid video.
+    x = torch.zeros(1, 1152, 4)
+    block(
+        x,
+        x,
+        torch.zeros(1, 6, 4),
+        None,
+        hidden_states_mask=torch.ones(1, 1152, dtype=torch.bool),
+        vsa_dit_seq_shape=(5, 16, 27),
+    )
+    metadata = block.attn1.call_args.args[2]
+    assert metadata.video_layout.latent_grid == (5, 16, 27)
+    assert metadata.video_layout.used_len == 2160
+    assert metadata.video_layout.prefix_len == 0
+    assert "max_seqlen_q" not in metadata.extra  # CUDA must not infer incomplete packed varlen.
+    assert block.attn2.call_args.args[2] is None
diff --git a/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py b/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
index 526eeeb15..58a5e961b 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
@@ -20,9 +20,11 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
 
 @pytest.fixture(autouse=True)
-def _cpu_platform(monkeypatch):
+def _cpu_pipeline_runtime(monkeypatch):
+    # These lightweight pipelines have no accelerator or distributed groups.
     module = importlib.import_module("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2")
     monkeypatch.setattr(module.current_omni_platform, "is_available", lambda: False)
+    monkeypatch.setattr("vllm_omni.diffusion.distributed.parallel_state._PP", SimpleNamespace(world_size=1))
 
 
 class _StubTransformer(nn.Module):
@@ -477,6 +479,100 @@ def test_diffuse_runs_prediction_and_scheduler_for_each_timestep() -> None:
     assert torch.equal(result, torch.full_like(latents, 10.0))
 
 
+@pytest.mark.parametrize("fail_first_request", [False, True])
+def test_runner_publishes_wan_step_context_across_requests(fail_first_request, monkeypatch):
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.forward_context import (
+        ForwardContext,
+        get_forward_context,
+        is_forward_context_available,
+        override_forward_context,
+    )
+    from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
+    from vllm_omni.quantization.mxfp4_config import _is_w4a8_fallback_step
+
+    contexts: list[ForwardContext] = []
+    events = []
+
+    class InjectedPredictionError(Exception):
+        pass
+
+    class RecordingTransformer(_StubTransformer):
+        def __init__(self, expert):
+            super().__init__()
+            self.expert = expert
+
+        def forward(self, hidden_states, encoder_hidden_states, **kwargs):
+            context = get_forward_context()
+            assert context is contexts[-1]
+            request_index = len(contexts) - 1
+            step = context.denoise_step_idx
+            positive = bool(encoder_hidden_states[0, 0, 0] > 0)
+            events.append((request_index, step, self.expert, positive, _is_w4a8_fallback_step([0, 2])))
+            if fail_first_request and request_index == 0 and step == 1 and not positive:
+                raise InjectedPredictionError
+            return (torch.ones_like(hidden_states) * (1 if positive else -1),)
+
+    def encode_prompt(**kwargs):
+        context = get_forward_context()
+        assert context.denoise_step_idx is None
+        contexts.append(context)
+        embeds = torch.ones(1, 8, 8)
+        return embeds, -embeds
+
+    pipeline = _make_pipeline()
+    pipeline.transformer = RecordingTransformer("high")
+    pipeline.transformer_2 = RecordingTransformer("low")
+    pipeline.scheduler = _StubScheduler([900, 500, 100])
+    monkeypatch.setattr(pipeline, "encode_prompt", encode_prompt)
+    monkeypatch.setattr(pipeline, "scheduler_step_maybe_with_cfg", lambda pred, t, latents, cfg: latents)
+
+    # Use the real runner context manager, Wan forward/diffuse, and CFG
+    # dispatch. Only model computation, scheduler math and unrelated KV I/O
+    # are replaced; no test code publishes a denoise step.
+    runner = object.__new__(DiffusionModelRunner)
+    runner.pipeline = pipeline
+    runner.od_config = OmniDiffusionConfig(model="", dtype=torch.float32)
+    runner.vllm_config = None
+    runner.cache_backend = None
+    monkeypatch.setattr(runner, "_prepare_request_for_forward", lambda *args, **kwargs: None)
+    with override_forward_context(None):
+        for request_index in range(2):
+            request = OmniDiffusionRequest(
+                prompt="a fox walks",
+                request_id=f"request-{request_index}",
+                sampling_params=OmniDiffusionSamplingParams(
+                    num_frames=1, num_inference_steps=3, guidance_scale=2.0, output_type="latent"
+                ),
+            )
+
+            def execute():
+                return runner._execute_request_list(
+                    [request],
+                    od_config=runner.od_config,
+                    allow_single_output=True,
+                    require_request_batch_support=False,
+                    record_name="test_wan_step_context",
+                    record_output_peak_memory=False,
+                )
+
+            if fail_first_request and request_index == 0:
+                with pytest.raises(InjectedPredictionError):
+                    execute()
+            else:
+                execute()
+            assert not is_forward_context_available()
+
+    assert len(contexts) == 2 and contexts[0] is not contexts[1]
+    expected = [
+        (request, step, "high" if step == 0 else "low", positive, step in (0, 2))
+        for request in range(2)
+        for step in range(2 if fail_first_request and request == 0 else 3)
+        for positive in (True, False)
+    ]
+    assert events == expected
+
+
 class _StubDMDScheduler:
     def __init__(self) -> None:
         self.predict_clean_calls: list[tuple[float, float, float]] = []
diff --git a/tests/diffusion/models/wan2_2/test_wan22_quant_config_propagation.py b/tests/diffusion/models/wan2_2/test_wan22_quant_config_propagation.py
index b14059933..6ed3e5f81 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_quant_config_propagation.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_quant_config_propagation.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for Wan2.2 quant_config propagation through transformer creation.
 
 Tests cover:
@@ -196,7 +196,7 @@ class TestPatchWanRmsNorm:
     """Test that patch_wan_rms_norm doesn't raise on concurrent module registration."""
 
     def test_patches_modules_with_wan_rms_norm(self):
-        from vllm_omni.diffusion.layers.norm import RMSNormVAE
+        from vllm_omni.diffusion.models.wan2_2.norm import RMSNormVAE
         from vllm_omni.diffusion.models.wan2_2.patch_diffusers import patch_wan_rms_norm
 
         # Create a fake module that has WanRMS_norm
diff --git a/tests/diffusion/models/wan2_2/test_wan22_s2v_pipeline.py b/tests/diffusion/models/wan2_2/test_wan22_s2v_pipeline.py
index 94f8b86fd..a36f3a6a5 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_s2v_pipeline.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_s2v_pipeline.py
@@ -2,6 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from types import SimpleNamespace
+from typing import Any
 from unittest.mock import MagicMock, patch
 
 import numpy as np
@@ -43,7 +44,7 @@ def test_s2v_constructor_preserves_unshifted_endpoints(configured_shift: float |
 
 
 def _make_s2v_sampling(**overrides):
-    values: dict[str, object] = {
+    values: dict[str, Any] = {
         "height": 16,
         "width": 16,
         "num_frames": 8,
@@ -647,3 +648,245 @@ def test_s2v_pipeline_hsdp_forward_complete_process():
     assert video.shape[1] == 3  # channels
     assert audio_waveform is not None
     assert audio_sr == 16000
+
+
+def _make_s2v_preencode_pipeline() -> Wan22S2VPipeline:
+    """Build the same stub pipeline the batching test drives, for preencode runs."""
+    pipeline = object.__new__(Wan22S2VPipeline)
+    nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.transformer = MagicMock()
+    pipeline.transformer.dtype = torch.float32
+    # A fresh iterator per call: the clip loop reads this once per clip.
+    pipeline.transformer.parameters.side_effect = lambda: iter([torch.zeros(1, dtype=torch.float32)])
+    pipeline.transformer.casual_audio_encoder = None
+    pipeline.transformer.encode_audio.side_effect = lambda audio, _motion: {"audio_emb": audio}
+    pipeline.vae = MagicMock()
+    pipeline.vae.dtype = torch.float32
+    # The shared consumer reads the published pixel range off the VAE.
+    pipeline.vae.chunk_value_range = (-1.0, 1.0)
+    # One decoded clip: [B, C, T, H, W] for a batch of four (2 requests x 2 outputs).
+    pipeline.vae.decode.return_value = (torch.zeros(4, 3, 8, 16, 16),)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        parallel_config=SimpleNamespace(use_hsdp=False),
+    )
+    pipeline.scheduler = MagicMock(timesteps=torch.tensor([1.0]))
+    pipeline._flow_shift = 3.0
+    pipeline.vae_scale_factor_spatial = 8
+    pipeline.resolution_divisor = 16
+    pipeline.motion_frames = 7
+    pipeline.drop_first_motion = True
+    pipeline._DEFAULT_INFER_FRAMES = 8
+    pipeline._guidance_scale = None
+    pipeline._num_timesteps = None
+    pipeline.check_inputs = lambda *args, **kwargs: None
+    pipeline.encode_prompt = MagicMock(return_value=(torch.zeros(4, 2, 3), torch.ones(4, 2, 3)))
+    pipeline.encode_audio = MagicMock(return_value=(torch.zeros(1, 1, 2, 8), 1, 8))
+    pipeline.encode_ref_image = MagicMock(return_value=torch.zeros(1, 16, 1, 2, 2))
+    pipeline.prepare_motion_latents = MagicMock(
+        side_effect=lambda pixels, **_: torch.zeros(pixels.shape[0], 16, 2, 2, 2)
+    )
+    pipeline._denormalize_latents = lambda latents: latents
+    pipeline.diffuse = MagicMock(side_effect=lambda **kwargs: kwargs["latents"])
+    return pipeline
+
+
+def _make_s2v_preencode_batch(audio_a, audio_b, **sampling_overrides) -> DiffusionRequestBatch:
+    image = PIL.Image.new("RGB", (16, 16))
+    return DiffusionRequestBatch(
+        requests=[
+            SimpleNamespace(
+                request_id="a",
+                prompt={"prompt": "first", "multi_modal_data": {"image": image, "audio": audio_a}},
+                sampling_params=_make_s2v_sampling(
+                    num_outputs_per_prompt=2,
+                    latents=torch.zeros(2, 16, 2, 2, 2),
+                    output_type="np",
+                    **sampling_overrides,
+                ),
+            ),
+            SimpleNamespace(
+                request_id="b",
+                prompt={"prompt": "second", "multi_modal_data": {"image": image, "audio": audio_b}},
+                sampling_params=_make_s2v_sampling(
+                    num_outputs_per_prompt=2,
+                    latents=torch.ones(2, 16, 2, 2, 2),
+                    output_type="np",
+                    **sampling_overrides,
+                ),
+            ),
+        ]
+    )
+
+
+def _decode_mp4(data: bytes):
+    """Return (video frame count, first audio samples) for one encoded container."""
+    import io
+
+    import av
+
+    with av.open(io.BytesIO(data)) as container:
+        frames = sum(1 for _ in container.decode(video=0))
+    with av.open(io.BytesIO(data)) as container:
+        assert container.streams.audio, "the worker must mux the waveform into the container"
+        samples = np.concatenate(
+            [frame.to_ndarray().reshape(-1) for frame in container.decode(audio=0)][:4],
+        )
+    return frames, samples
+
+
+@pytest.mark.parametrize("batch_frames", [1, 1000])
+def test_s2v_preencode_returns_playable_mp4_bytes_per_request(monkeypatch, batch_frames) -> None:
+    """The clip loop hands finished clips to the encoder instead of concatenating."""
+    pipeline = _make_s2v_preencode_pipeline()
+    # Two clips, so the autoregressive motion feedback runs between pushes.
+    pipeline.encode_audio = MagicMock(return_value=(torch.zeros(1, 1, 2, 8), 2, 16))
+    audio_a = np.zeros(16000, dtype=np.float32)
+    audio_b = np.full(16000, 0.5, dtype=np.float32)
+    batch = _make_s2v_preencode_batch(
+        audio_a, audio_b, extra_args={"preencode_mp4": True, "preencode_batch_frames": batch_frames}
+    )
+    from vllm_omni.diffusion.utils import chunked_video
+
+    transfers = []
+    quantize = chunked_video.quantize_chunk
+
+    def capture(chunk, value_range):
+        transfers.append(chunk.shape[2])
+        return quantize(chunk, value_range)
+
+    monkeypatch.setattr(chunked_video, "quantize_chunk", capture)
+
+    with patch("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v.current_omni_platform") as platform:
+        platform.is_available.return_value = False
+        outputs = pipeline.forward(batch)
+
+    assert len(outputs) == 2
+    assert pipeline.vae.decode.call_count == 2, "both clips must reach the encoder"
+    assert len(transfers) == (2 if batch_frames == 1 else 1)
+
+    decoded = []
+    for request_output in outputs:
+        # Two outputs per prompt, each already a complete container.
+        assert isinstance(request_output.output, list)
+        assert len(request_output.output) == 2
+        for data in request_output.output:
+            assert isinstance(data, bytes)
+            frames, samples = _decode_mp4(data)
+            assert frames > 0
+            decoded.append(samples)
+
+    # Four entries: request a's waveform for its two outputs, then request b's.
+    # A silent and a non-silent waveform must not land on the same request.
+    assert np.abs(decoded[0]).max() == pytest.approx(0.0, abs=1e-3)
+    assert np.abs(decoded[1]).max() == pytest.approx(0.0, abs=1e-3)
+    assert np.abs(decoded[2]).max() > 0.1
+    assert np.abs(decoded[3]).max() > 0.1
+
+
+def test_s2v_preencode_aborts_encoders_when_a_later_clip_fails(monkeypatch) -> None:
+    """A failure after the first push must not strand encoder worker threads."""
+    pipeline = _make_s2v_preencode_pipeline()
+    pipeline.encode_audio = MagicMock(return_value=(torch.zeros(1, 1, 2, 8), 2, 16))
+    batch = _make_s2v_preencode_batch(
+        np.zeros(16000, dtype=np.float32),
+        np.ones(16000, dtype=np.float32),
+        extra_args={"preencode_mp4": True, "preencode_batch_frames": 1},
+    )
+    sessions = []
+
+    from vllm_omni.diffusion.utils.chunked_video import ChunkedVideoMP4Session
+
+    def capture_session(**kwargs):
+        session = ChunkedVideoMP4Session(**kwargs)
+        sessions.append(session)
+        return session
+
+    def fail_on_second_clip(**kwargs):
+        if pipeline.vae.decode.call_count:
+            raise RuntimeError("second clip failed")
+        return kwargs["latents"]
+
+    pipeline.diffuse = fail_on_second_clip
+    monkeypatch.setattr("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v.ChunkedVideoMP4Session", capture_session)
+
+    with patch("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v.current_omni_platform") as platform:
+        platform.is_available.return_value = False
+        with pytest.raises(RuntimeError, match="second clip failed"):
+            pipeline.forward(batch)
+
+    assert len(sessions) == 1
+    assert len(sessions[0]._encoders) == 4
+    assert all(not encoder._thread.is_alive() for encoder in sessions[0]._encoders)
+
+
+def test_s2v_preencode_skips_encoding_on_a_vae_patch_parallel_peer(monkeypatch) -> None:
+    """A peer still receives every clip for the motion loop but encodes none of them."""
+    pipeline = _make_s2v_preencode_pipeline()
+    pipeline.encode_audio = MagicMock(return_value=(torch.zeros(1, 1, 2, 8), 2, 16))
+    # A peer's patch-parallel decode returns an empty placeholder.
+    pipeline.vae.decode.return_value = (torch.empty(0),)
+    pipeline.vae._vae_pp_group = object()
+    broadcasts = []
+    monkeypatch.setattr(
+        "torch.distributed.broadcast",
+        lambda tensor, src, group: broadcasts.append(tensor.zero_()),
+    )
+    batch = _make_s2v_preencode_batch(
+        np.zeros(16000, dtype=np.float32),
+        np.ones(16000, dtype=np.float32),
+        extra_args={"preencode_mp4": True, "preencode_batch_frames": 1},
+    )
+    sessions = []
+
+    from vllm_omni.diffusion.utils.chunked_video import ChunkedVideoMP4Session
+
+    def capture_session(**kwargs):
+        session = ChunkedVideoMP4Session(**kwargs)
+        sessions.append(session)
+        return session
+
+    monkeypatch.setattr("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v.ChunkedVideoMP4Session", capture_session)
+
+    with patch("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v.current_omni_platform") as platform:
+        platform.is_available.return_value = False
+        outputs = pipeline.forward(batch)
+
+    assert len(broadcasts) == 2, "the peer must still join the broadcast for both clips"
+    # Once for the initial motion latents, once more from the peer's broadcast clip.
+    assert pipeline.prepare_motion_latents.call_count == 2, "the motion loop still consumes the peer's frames"
+    assert sessions[0]._encoders == []
+    assert [request_output.output for request_output in outputs] == [[], []]
+
+
+@pytest.mark.parametrize("output_type", ["pil", "pt", "latent"])
+def test_s2v_preencode_rejects_request_output_types_it_cannot_serve(output_type) -> None:
+    """Pre-encoding returns MP4 bytes, so a request asking for frames must fail."""
+    pipeline = _make_s2v_preencode_pipeline()
+    batch = _make_s2v_preencode_batch(
+        np.zeros(16000, dtype=np.float32),
+        np.ones(16000, dtype=np.float32),
+        extra_args={"preencode_mp4": True},
+    )
+    for request in batch.requests:
+        request.sampling_params.output_type = output_type
+
+    with pytest.raises(ValueError, match="output_type"):
+        pipeline.forward(batch)
+
+
+def test_s2v_preencode_keeps_the_full_decode_path_untouched() -> None:
+    """Without the flag the loop still returns the (video, audio, rate) tuple."""
+    pipeline = _make_s2v_preencode_pipeline()
+    audio_a = np.zeros(16000, dtype=np.float32)
+    audio_b = np.ones(16000, dtype=np.float32)
+    batch = _make_s2v_preencode_batch(audio_a, audio_b)
+
+    with patch("vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v.current_omni_platform") as platform:
+        platform.is_available.return_value = False
+        outputs = pipeline.forward(batch)
+
+    assert outputs[0].output[0].shape[0] == 2
+    np.testing.assert_array_equal(outputs[0].output[1], audio_a)
+    np.testing.assert_array_equal(outputs[1].output[1], audio_b)
diff --git a/tests/diffusion/offloader/test_diffusion_cpu_offload.py b/tests/diffusion/offloader/test_diffusion_cpu_offload.py
index 205fad8fd..873f355c9 100644
--- a/tests/diffusion/offloader/test_diffusion_cpu_offload.py
+++ b/tests/diffusion/offloader/test_diffusion_cpu_offload.py
@@ -16,7 +16,7 @@ from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.platforms import current_omni_platform
 
 AUDIO_MODEL: dict[str, dict[str, int | None]] = {
-    "stabilityai/stable-audio-open-1.0": {"cuda": 100, "rocm": None},
+    "stabilityai/stable-audio-open-1.0": {"cuda": 150, "rocm": None},
 }
 
 IMAGE_MODELS: dict[str, dict[str, int | None]] = {
@@ -35,6 +35,11 @@ MODEL_MARKS = {
 
 _GATED_MODELS = {"stabilityai/stable-audio-open-1.0"}
 
+# Models whose thresholds are calibrated against max_memory_allocated. All
+# other models keep asserting on the polled device-wide figure until their
+# thresholds have been re-measured on that metric on both CUDA and ROCm.
+_ALLOCATED_THRESHOLD_MODELS = {"stabilityai/stable-audio-open-1.0"}
+
 
 AUDIO_MODEL_PARAMS: dict[str, dict[str, Any]] = {
     "runner_params": {},
@@ -50,7 +55,7 @@ IMAGE_MODEL_PARAMS: dict[str, dict[str, Any]] = {
 }
 
 
-def inference(model_name: str, offload: bool = True) -> tuple[float, Any]:
+def inference(model_name: str, offload: bool = True) -> tuple[float, float, Any]:
     gc.collect()
     current_omni_platform.empty_cache()
     device_index = current_omni_platform.current_device()
@@ -81,12 +86,17 @@ def inference(model_name: str, offload: bool = True) -> tuple[float, Any]:
             ),
         )
     peak = monitor.peak_used_mb
+    # Exact in-process peak of live tensors. Unlike the polled device-wide
+    # figure above, this excludes caching-allocator slack and CUDA context,
+    # which differ between the offload and no-offload paths (the offload hook
+    # calls empty_cache() on every swap) and drift between runs.
+    peak_allocated = current_omni_platform.max_memory_allocated(device=device_index) / (1024**2)
     monitor.stop()
 
     gc.collect()
     current_omni_platform.empty_cache()
 
-    return peak, output
+    return peak, peak_allocated, output
 
 
 def check_audio_determinism(audio1, audio2, atol=1e-2):
@@ -112,9 +122,9 @@ def check_audio_determinism(audio1, audio2, atol=1e-2):
 )
 def test_cpu_offload_diffusion_model(model_name: str):
     try:
-        offload_peak_memory, output_offload = inference(model_name, offload=True)
+        offload_peak_memory, offload_peak_allocated, output_offload = inference(model_name, offload=True)
         cleanup_dist_env_and_memory()
-        no_offload_peak_memory, output_no_offload = inference(model_name, offload=False)
+        no_offload_peak_memory, no_offload_peak_allocated, output_no_offload = inference(model_name, offload=False)
     except ValueError as exc:
         # omni_snapshot_download wraps GatedRepoError in a ValueError; skip instead of failing.
         if "Access to model" in str(exc) and "is restricted" in str(exc):
@@ -125,16 +135,14 @@ def test_cpu_offload_diffusion_model(model_name: str):
         pytest.fail(f"Inference failed: {exc}")
     except Exception:
         pytest.fail("Inference failed")
-    print(f"Offload peak memory: {offload_peak_memory} MB")
-    print(f"No offload peak memory: {no_offload_peak_memory} MB")
+    print(f"Offload peak memory: {offload_peak_memory} MB (allocated: {offload_peak_allocated:.1f} MB)")
+    print(f"No offload peak memory: {no_offload_peak_memory} MB (allocated: {no_offload_peak_allocated:.1f} MB)")
 
     if model_name == "stabilityai/stable-audio-open-1.0":
         audio_offload = output_offload[0].multimodal_output.get("audio")
         audio_no_offload = output_no_offload[0].multimodal_output.get("audio")
         check_audio_determinism(audio_offload, audio_no_offload, atol=1e-2)
 
-    # Set platform-specific VRAM saving thresholds to account
-    # for varying runtime memory overhead and fragmentation between CUDA and ROCm.
     is_rocm = torch.version.hip is not None
     platform = "rocm" if is_rocm else "cuda"
     threshold = MODELS[model_name][platform]
@@ -142,7 +150,22 @@ def test_cpu_offload_diffusion_model(model_name: str):
         pytest.skip(f"Threshold not defined for {platform} on {model_name}")
     assert threshold is not None
 
-    assert offload_peak_memory + threshold < no_offload_peak_memory, (
-        f"Offload peak memory {offload_peak_memory} MB should be less than "
-        f"no offload peak memory {no_offload_peak_memory} MB by {threshold} MB"
-    )
+    if model_name in _ALLOCATED_THRESHOLD_MODELS:
+        # Threshold is a lower bound on the peak *allocated* saving, i.e. the
+        # weights the offloader keeps off-GPU at the moment of peak usage
+        # (stable-audio: the fp16 T5 encoder, ~209 MB). max_memory_allocated
+        # is used instead of the polled device-wide figure because the latter
+        # includes caching-allocator slack that differs between the two paths
+        # and drifts by tens of MB between runs.
+        assert offload_peak_allocated + threshold < no_offload_peak_allocated, (
+            f"Offload peak allocated memory {offload_peak_allocated:.1f} MB should be less than "
+            f"no offload peak allocated memory {no_offload_peak_allocated:.1f} MB by {threshold} MB"
+        )
+    else:
+        # Threshold is calibrated against the polled device-wide figure and
+        # accounts for runtime memory overhead and fragmentation differences
+        # between CUDA and ROCm.
+        assert offload_peak_memory + threshold < no_offload_peak_memory, (
+            f"Offload peak memory {offload_peak_memory} MB should be less than "
+            f"no offload peak memory {no_offload_peak_memory} MB by {threshold} MB"
+        )
diff --git a/tests/diffusion/offloader/test_distributed_layerwise_backend.py b/tests/diffusion/offloader/test_distributed_layerwise_backend.py
index c24639434..fed60be1f 100644
--- a/tests/diffusion/offloader/test_distributed_layerwise_backend.py
+++ b/tests/diffusion/offloader/test_distributed_layerwise_backend.py
@@ -32,6 +32,7 @@ from vllm_omni.diffusion.model_loader.host_weight_plan import (
     TensorBinding,
     build_checkpoint_mmap_plan,
 )
+from vllm_omni.diffusion.offloader import plan_resolver
 from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
 from vllm_omni.diffusion.offloader.block_discovery import (
     get_blocks_attr_names,
@@ -52,7 +53,7 @@ from vllm_omni.diffusion.offloader.offload_plan import (
     OffloadPlan,
     get_offload_plan,
 )
-from vllm_omni.diffusion.offloader.plan_resolver import resolve_offload_plan
+from vllm_omni.diffusion.offloader.plan_resolver import ResolvedComponent, resolve_offload_plan
 from vllm_omni.diffusion.offloader.startup import OffloadStartupState, attach_offload_startup_state
 from vllm_omni.host_weight_runtime import MappedHostRegion
 from vllm_omni.platforms import current_omni_platform
@@ -1235,6 +1236,78 @@ class _MmapPostLoadPipeline(nn.Module):
 
 
 class TestMmapWeightLoading:
+    @pytest.mark.parametrize("initial_device", ["cpu", "meta"])
+    @pytest.mark.parametrize("use_allgather", [False, True])
+    def test_mmap_keeps_undeclared_nested_blocks_streamed(
+        self, tmp_path, patched_offload_runtime, monkeypatch, initial_device, use_allgather
+    ):
+        class Refiner(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.layers = nn.ModuleList([nn.Linear(2, 2), nn.Linear(2, 2)])
+
+            def forward(self, x):
+                for block in self.layers:
+                    x = block(x)
+                return x
+
+        class Transformer(nn.Module):
+            _layerwise_offload_blocks_attrs = ["blocks"]
+
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([nn.Linear(2, 2), nn.Linear(2, 2)])
+                self.refiner = Refiner()
+
+            def forward(self, x):
+                x = self.refiner(x)
+                for block in self.blocks:
+                    x = block(x)
+                return x
+
+        pipeline = nn.Module()
+        pipeline.transformer = Transformer()
+        weights = {name: param.detach().clone() for name, param in pipeline.named_parameters()}
+        x = torch.randn(1, 2)
+        with torch.no_grad():
+            expected = pipeline.transformer(x)
+        checkpoint_file = tmp_path / "model.safetensors"
+        save_file(weights, str(checkpoint_file))
+        # Exercise the real mmap path with a small model instead of allocating
+        # the 1 GiB needed to trigger the production compatibility threshold.
+        monkeypatch.setattr(plan_resolver, "_NESTED_OFFLOAD_THRESHOLD_MB", 0)
+        if initial_device == "meta":
+            pipeline.transformer.to_empty(device="meta")
+        plan = HostWeightPlan(
+            backing_kind="checkpoint_mmap",
+            bindings={name: TensorBinding(checkpoint_key=name, file_path=str(checkpoint_file)) for name in weights},
+        )
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(
+                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
+                pin_cpu_memory=False,
+                dlo_use_allgather=use_allgather,
+            ),
+            torch.device("cpu"),
+            host_weight_plan=plan,
+        )
+
+        for _ in range(2):
+            try:
+                backend.enable(pipeline)
+                assert len(backend._all_hook_groups) == 2
+                with torch.no_grad():
+                    torch.testing.assert_close(pipeline.transformer(x), expected)
+            finally:
+                backend.disable()
+            for name, parameter in pipeline.named_parameters():
+                assert not parameter.is_meta
+                torch.testing.assert_close(parameter, weights[name])
+            for module in pipeline.modules():
+                registry = getattr(module, "_hook_registry", None)
+                if registry is not None:
+                    assert registry.get_hook("distributed_layerwise_offload") is None
+
     def test_runs_model_post_load_hook(self, tmp_path, patched_offload_runtime):
         pipeline = _MmapPostLoadPipeline()
         weights = {name: torch.ones(param.shape, dtype=torch.bfloat16) for name, param in pipeline.named_parameters()}
@@ -1250,10 +1323,7 @@ class TestMmapWeightLoading:
             ),
             torch.device("cpu"),
         )
-        modules = SimpleNamespace(
-            dits=[pipeline.transformer],
-            dit_names=["transformer"],
-        )
+        dits = (ResolvedComponent(path="transformer", module=pipeline.transformer, selected=True),)
         plan = HostWeightPlan(
             backing_kind="checkpoint_mmap",
             bindings={
@@ -1265,7 +1335,7 @@ class TestMmapWeightLoading:
             },
         )
 
-        backend._load_weights_via_mmap(pipeline, modules, plan)
+        backend._load_weights_via_mmap(pipeline, dits, plan)
 
         assert pipeline.transformer.post_load_calls == 1
         assert pipeline.transformer.time_embedder.weight.dtype == torch.float32
@@ -1717,6 +1787,128 @@ class TestOffloadPlan:
         for name, parameter in pipeline.named_parameters():
             torch.testing.assert_close(parameter, expected_parameters[name])
 
+    @pytest.mark.parametrize("shared_owner", ["parent", "encoder", "sibling"])
+    def test_nested_duplicate_ownership_is_rejected_before_any_hook(self, patched_offload_runtime, shared_owner):
+        class Pipeline(nn.Module):
+            _offload_plan = OffloadPlan(
+                offload_submodules={"refiner": "blocks", "other_refiner": "blocks"},
+                encoder_block_attrs={"text_encoder": ("encoder.block",)},
+            )
+
+            def __init__(self):
+                super().__init__()
+                self.transformer = _SingleBlockModel(num_blocks=2)
+                self.transformer.refiner = _SingleBlockModel(num_blocks=2)
+                self.transformer.other_refiner = _SingleBlockModel(num_blocks=2)
+                self.text_encoder = _PlainEncoder()
+                owners = {
+                    "parent": self.transformer.blocks,
+                    "encoder": self.text_encoder.encoder.block,
+                    "sibling": self.transformer.other_refiner.blocks,
+                }
+                self.transformer.refiner.blocks = owners[shared_owner]
+
+        pipeline = Pipeline()
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE, pin_cpu_memory=False),
+            torch.device("cpu"),
+        )
+        storage = {name: parameter.data_ptr() for name, parameter in pipeline.named_parameters()}
+        try:
+            with pytest.raises(ValueError, match="claimed by both"):
+                backend.enable(pipeline)
+            assert not backend.enabled
+            assert not backend._all_hook_groups
+            assert {name: parameter.data_ptr() for name, parameter in pipeline.named_parameters()} == storage
+            assert not getattr(pipeline.text_encoder, "_omni_layerwise_enabled", False)
+            for module in pipeline.modules():
+                assert getattr(module, "_hook_registry", None) is None
+        finally:
+            backend.disable()
+
+    def test_unstageable_submodule_is_rejected_before_any_hook(self, patched_offload_runtime):
+        """Plan-dependent rejection happens before earlier components are hooked."""
+
+        class Pipeline(nn.Module):
+            _offload_plan = OffloadPlan(
+                offload_submodules={"refiner": "missing"},
+                encoder_component_types={"text_encoder": "text_encoder"},
+                encoder_block_attrs={"text_encoder": ("encoder.block",)},
+            )
+
+            def __init__(self):
+                super().__init__()
+                self.transformer = _SingleBlockModel(num_blocks=2)
+                # Declared for submodule offload but without a block list or the
+                # load_to_device/offload_to_cpu lifecycle.
+                self.transformer.refiner = nn.Linear(2, 2)
+                self.text_encoder = _PlainEncoder()
+
+        pipeline = Pipeline()
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE, pin_cpu_memory=False),
+            torch.device("cpu"),
+        )
+
+        # Storage identity proves the encoder was never staged and rolled back.
+        encoder_storage = [block.weight.data_ptr() for block in pipeline.text_encoder.encoder.block]
+
+        with pytest.raises(ValueError, match="must implement load_to_device"):
+            backend.enable(pipeline)
+
+        assert not backend.enabled
+        assert [block.weight.data_ptr() for block in pipeline.text_encoder.encoder.block] == encoder_storage
+        assert not getattr(pipeline.text_encoder, "_omni_layerwise_enabled", False)
+        for block in pipeline.transformer.blocks:
+            assert getattr(block, "_hook_registry", None) is None
+
+    def test_undeclared_submodule_block_scan_warns(self, patched_offload_runtime, monkeypatch):
+        """The size-triggered attribute scan still works and is deprecated."""
+
+        class Refiner(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.layers = nn.ModuleList([nn.Linear(2, 2), nn.Linear(2, 2)])
+
+        class Transformer(nn.Module):
+            _layerwise_offload_blocks_attrs = ["blocks"]
+
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([nn.Linear(2, 2), nn.Linear(2, 2)])
+                self.refiner = Refiner()
+
+        class Pipeline(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.transformer = Transformer()
+
+        warnings: list[str] = []
+
+        class _Recorder:
+            def warning(self, message, *args):
+                warnings.append(message % args if args else message)
+
+            def __getattr__(self, _name):
+                return lambda *args, **kwargs: None
+
+        monkeypatch.setattr(plan_resolver, "logger", _Recorder())
+        monkeypatch.setattr(plan_resolver, "_NESTED_OFFLOAD_THRESHOLD_MB", 0)
+        plan_resolver._warn_nested_block_scan.cache_clear()
+        plan_resolver._warn_legacy_discovery.cache_clear()
+        pipeline = Pipeline()
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE, pin_cpu_memory=False),
+            torch.device("cpu"),
+        )
+
+        backend.enable(pipeline)
+
+        assert len(backend._all_hook_groups) == 2
+        assert sum("OffloadPlan.offload_submodules" in message for message in warnings) == 1
+
+        backend.disable()
+
 
 class TestMmapValidation:
     """Tests for loader preflight and backend plan realization."""
@@ -2101,7 +2293,7 @@ class TestMmapValidation:
             ),
             torch.device("cpu"),
         )
-        modules = SimpleNamespace(dits=[pipeline.transformer], dit_names=["transformer"])
+        dits = (ResolvedComponent(path="transformer", module=pipeline.transformer, selected=True),)
         result = build_checkpoint_mmap_plan(
             pipeline,
             dit_modules=(("transformer", pipeline.transformer),),
@@ -2113,7 +2305,7 @@ class TestMmapValidation:
         )
 
         assert result.plan is not None
-        backend._load_weights_via_mmap(pipeline, modules, result.plan)
+        backend._load_weights_via_mmap(pipeline, dits, result.plan)
         assert pipeline.transformer.validate_called, "validate_loaded_weights should be called"
 
 
diff --git a/tests/diffusion/quantization/test_int8_config.py b/tests/diffusion/quantization/test_int8_config.py
index f706cc68b..6eba09c21 100644
--- a/tests/diffusion/quantization/test_int8_config.py
+++ b/tests/diffusion/quantization/test_int8_config.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for Int8 quantization config."""
 
 import pytest
@@ -12,7 +12,7 @@ from vllm_omni.platforms import current_omni_platform
 from vllm_omni.quantization import build_quant_config
 from vllm_omni.quantization.factory import SUPPORTED_QUANTIZATION_METHODS
 
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
 npu_available = pytest.mark.skipif(not current_omni_platform.is_npu(), reason="NPU platform not available.")
 
@@ -248,6 +248,124 @@ class TestNPUQuantMatmulShapeFallback:
         assert layer.quant_method is method
 
 
+class TestHostFallbackLoading:
+    """Over-wide fallback layers load straight into host memory when the loader
+    will offload the model back to CPU after online quantization (DLO).
+
+    Without the context the eager path is preserved: the fallback weight is a
+    real tensor created at construction time.
+    """
+
+    @pytest.fixture(autouse=True)
+    def _mock_tp(self, mocker):
+        # Same stand-in as TestNPUQuantMatmulShapeFallback: the eager fallback
+        # delegates to UnquantizedLinearMethod, which reads the TP group.
+        mock_group = mocker.Mock()
+        mock_group.rank_in_group = 0
+        mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_world_size", return_value=1)
+        mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_rank", return_value=0)
+        mocker.patch("vllm.distributed.parallel_state.get_tp_group", return_value=mock_group)
+
+    @pytest.fixture
+    def quant_config(self):
+        from vllm_omni.quantization.int8_config import DiffusionInt8Config
+
+        return DiffusionInt8Config(is_checkpoint_int8_serialized=False, activation_scheme="dynamic")
+
+    def _make_over_wide_layer(self, quant_config, weight_loader):
+        from vllm_omni.quantization.int8_config import (
+            NPU_QUANT_MATMUL_MAX_OUT_FEATURES,
+            NPUInt8OnlineLinearMethod,
+        )
+
+        out_features = NPU_QUANT_MATMUL_MAX_OUT_FEATURES + 1
+        method = NPUInt8OnlineLinearMethod(quant_config)
+        layer = Module()
+        layer.quant_method = method
+        method.create_weights(
+            layer,
+            input_size_per_partition=8,
+            output_partition_sizes=[out_features],
+            input_size=8,
+            output_size=out_features,
+            params_dtype=torch.bfloat16,
+            weight_loader=weight_loader,
+        )
+        return layer, out_features
+
+    @staticmethod
+    def _loaded_values(out_features):
+        return torch.arange(out_features * 8, dtype=torch.float32).reshape(out_features, 8).to(torch.bfloat16)
+
+    def test_fallback_without_context_keeps_eager_weights(self, quant_config):
+        layer, _ = self._make_over_wide_layer(quant_config, lambda param, loaded_weight, *a, **k: None)
+
+        assert type(layer.quant_method) is UnquantizedLinearMethod
+        assert layer.weight.device.type != "meta"
+
+    def test_fallback_under_context_defers_weight_to_meta(self, quant_config):
+        from vllm_omni.quantization.int8_config import (
+            UnquantizedHostLinearMethod,
+            load_unquantizable_fallback_on_cpu,
+        )
+
+        with load_unquantizable_fallback_on_cpu():
+            layer, _ = self._make_over_wide_layer(quant_config, lambda param, loaded_weight, *a, **k: None)
+
+        assert isinstance(layer.quant_method, UnquantizedHostLinearMethod)
+        assert layer.quant_method.uses_meta_device
+        assert layer.weight.device.type == "meta"
+
+    def test_fallback_weight_loads_straight_to_cpu(self, quant_config):
+        from vllm_omni.quantization.int8_config import load_unquantizable_fallback_on_cpu
+
+        def copy_loader(param, loaded_weight, *args, **kwargs):
+            param.data.copy_(loaded_weight)
+
+        with load_unquantizable_fallback_on_cpu():
+            layer, out_features = self._make_over_wide_layer(quant_config, copy_loader)
+
+        loaded = self._loaded_values(out_features)
+        layer.weight.weight_loader(layer.weight, loaded)
+
+        assert layer.weight.device.type == "cpu"
+        assert torch.equal(layer.weight, loaded)
+        # Marks the post-load sweep to skip the layer instead of bouncing the
+        # host tensor to the accelerator and back for a no-op process call.
+        assert layer._already_called_process_weights_after_loading
+
+    def test_chunked_load_marks_completion_only_when_full(self, quant_config):
+        from vllm_omni.quantization.int8_config import load_unquantizable_fallback_on_cpu
+
+        state = {"offset": 0}
+
+        def half_loader(param, loaded_weight, *args, **kwargs):
+            start = state["offset"]
+            param.data[start : start + loaded_weight.shape[0]].copy_(loaded_weight)
+            state["offset"] += loaded_weight.shape[0]
+
+        with load_unquantizable_fallback_on_cpu():
+            layer, out_features = self._make_over_wide_layer(quant_config, half_loader)
+
+        loaded = self._loaded_values(out_features)
+        halves = loaded.chunk(2, dim=0)
+        layer.weight.weight_loader(layer.weight, halves[0])
+        assert not getattr(layer, "_already_called_process_weights_after_loading", False)
+
+        layer.weight.weight_loader(layer.weight, halves[1])
+        assert layer._already_called_process_weights_after_loading
+        assert torch.equal(layer.weight, loaded)
+
+    def test_context_does_not_leak(self, quant_config):
+        from vllm_omni.quantization.int8_config import load_unquantizable_fallback_on_cpu
+
+        with load_unquantizable_fallback_on_cpu():
+            pass
+        layer, _ = self._make_over_wide_layer(quant_config, lambda param, loaded_weight, *a, **k: None)
+
+        assert type(layer.quant_method) is UnquantizedLinearMethod
+
+
 class TestOffloadAfterQuant:
     def test_only_methods_advertising_the_capability_are_asked(self):
         from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
diff --git a/tests/diffusion/quantization/test_mxfp4_checkpoint.py b/tests/diffusion/quantization/test_mxfp4_checkpoint.py
new file mode 100644
index 000000000..e183df078
--- /dev/null
+++ b/tests/diffusion/quantization/test_mxfp4_checkpoint.py
@@ -0,0 +1,294 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CPU coverage for MXFP4 checkpoint loading and the W4A8 dtype contract."""
+
+import sys
+from types import ModuleType
+
+import pytest
+import torch
+from vllm.config.load import LoadConfig
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.forward_context import (
+    ForwardContext,
+    override_forward_context,
+    set_forward_context_denoise_step_idx,
+)
+from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
+from vllm_omni.quantization.mxfp4_config import (
+    DiffusionMXFP4Config,
+    DiffusionMXFP4DualScaleMixedConfig,
+    NPUMxfp4DualScaleLinearMethod,
+    NPUMxfp4LinearMethod,
+    NPUMxfp4OnlineLinearMethod,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+@pytest.fixture(autouse=True)
+def _patch_tp_state(monkeypatch):
+    monkeypatch.setattr("vllm.model_executor.parameter.get_tensor_model_parallel_rank", lambda: 0)
+    monkeypatch.setattr("vllm.model_executor.parameter.get_tensor_model_parallel_world_size", lambda: 1)
+
+
+class _CheckpointLayer(torch.nn.Module):
+    def __init__(self, method, dtype=torch.bfloat16):
+        super().__init__()
+        method.create_weights(
+            self,
+            input_size_per_partition=512,
+            output_partition_sizes=[2],
+            input_size=512,
+            output_size=2,
+            params_dtype=dtype,
+            weight_loader=default_weight_loader,
+        )
+
+    def load_weights(self, weights):
+        params = dict(self.named_parameters())
+        loaded = set()
+        for name, value in weights:
+            if name in params:
+                params[name].weight_loader(params[name], value)
+                loaded.add(name)
+        return loaded
+
+
+def _load_checkpoint(layer, config, weights, monkeypatch):
+    od_config = OmniDiffusionConfig(model="", dtype=torch.bfloat16, quantization_config=config)
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    loader.counter_before_loading_weights = 0.0
+    monkeypatch.setattr(loader, "get_all_weights", lambda model: iter(weights.items()))
+    loader.load_weights(layer)
+
+
+@pytest.mark.parametrize("serialized", [False, True])
+def test_single_scale_requires_checkpoint_scale_only_when_serialized(serialized, monkeypatch):
+    config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=serialized)
+    # Exercise the shared implementation directly as well as the online MRO
+    # below: checkpoint requirements must follow the configured storage mode.
+    layer = _CheckpointLayer(NPUMxfp4LinearMethod(config))
+    weights = {"weight": torch.ones((2, 512), dtype=torch.bfloat16)}
+    if serialized:
+        with pytest.raises(ValueError, match="Required weights.*weight_scale"):
+            _load_checkpoint(layer, config, weights, monkeypatch)
+    else:
+        _load_checkpoint(layer, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("scale_alg", [0, 2])
+def test_online_mxfp4_loads_bf16_checkpoint_without_scale(scale_alg, monkeypatch):
+    config = DiffusionMXFP4Config(mxfp4_scale_alg=scale_alg)
+    method = NPUMxfp4OnlineLinearMethod(config)
+    layer = _CheckpointLayer(method)
+    assert set(dict(layer.named_parameters())) == {"weight"}
+    assert layer.weight.is_meta
+
+    weight = torch.arange(1024, dtype=torch.bfloat16).reshape(2, 512)
+    packed_weight = torch.zeros((2, 256), dtype=torch.uint8)
+    generated_scale = torch.full((2, 16), 127, dtype=torch.uint8)
+    quantized_inputs = []
+
+    def quantize(value, **kwargs):
+        quantized_inputs.append(value.clone())
+        expected = dict(dst_type="fp4", axis=-1, block_size=32, round_mode="rint", scale_alg=scale_alg)
+        if scale_alg == 2:
+            expected["dst_type_max"] = 7.25
+        assert kwargs == expected
+        return packed_weight, generated_scale
+
+    # Keep real creation, lazy loading, processing, and strict loader checks;
+    # substitute only the device quantization operator for this CPU test.
+    npu = ModuleType("torch_npu")
+    npu.__dict__.update(float4_e2m1fn_x2="fp4", npu_dynamic_mx_quant=quantize)
+    monkeypatch.setitem(sys.modules, "torch_npu", npu)
+    _load_checkpoint(layer, config, {"weight": weight}, monkeypatch)
+
+    assert len(quantized_inputs) == 1
+    torch.testing.assert_close(quantized_inputs[0], weight, rtol=0, atol=0)
+    torch.testing.assert_close(layer.weight, packed_weight, rtol=0, atol=0)
+    torch.testing.assert_close(layer.weight_scale, generated_scale.reshape(2, 8, 2), rtol=0, atol=0)
+    assert not getattr(layer.weight_scale, "is_checkpoint_required", False)
+    method.process_weights_after_loading(layer)
+    assert len(quantized_inputs) == 1
+
+
+@pytest.mark.parametrize("require_smooth", [False, True])
+@pytest.mark.parametrize("has_smooth", [False, True])
+def test_single_scale_checkpoint_smooth_default_and_required(require_smooth, has_smooth, monkeypatch):
+    config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True, require_smooth_scale=require_smooth)
+    layer = _CheckpointLayer(NPUMxfp4LinearMethod(config))
+    weights = {name: torch.ones_like(param) for name, param in layer.named_parameters()}
+    scale = torch.linspace(0.5, 3.0, 512)
+    if has_smooth:
+        weights["mul_scale"] = scale
+    else:
+        weights.pop("mul_scale")
+
+    if require_smooth and not has_smooth:
+        with pytest.raises(ValueError, match="mul_scale"):
+            _load_checkpoint(layer, config, weights, monkeypatch)
+    else:
+        _load_checkpoint(layer, config, weights, monkeypatch)
+        torch.testing.assert_close(layer.mul_scale, scale if has_smooth else torch.ones(512), rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("bad_scale", ["shape", "name"])
+def test_declared_single_scale_smooth_rejects_malformed_checkpoint(bad_scale, monkeypatch):
+    config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True, require_smooth_scale=True)
+    layer = _CheckpointLayer(NPUMxfp4LinearMethod(config))
+    weights = {name: torch.ones_like(param) for name, param in layer.named_parameters()}
+    if bad_scale == "shape":
+        weights["mul_scale"] = torch.ones(511)
+        with pytest.raises(AssertionError):
+            _load_checkpoint(layer, config, weights, monkeypatch)
+    else:
+        weights["multiply_scale"] = weights.pop("mul_scale")
+        with pytest.raises(ValueError, match="mul_scale"):
+            _load_checkpoint(layer, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("required", [False, True])
+@pytest.mark.parametrize("bad_value", [float("nan"), float("inf"), 0.0, -1.0])
+def test_single_scale_rejects_invalid_smooth_values(required, bad_value, monkeypatch):
+    config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True, require_smooth_scale=required)
+    layer = _CheckpointLayer(NPUMxfp4LinearMethod(config))
+    weights = {name: torch.ones_like(param) for name, param in layer.named_parameters()}
+    weights["mul_scale"][7] = bad_value
+    with pytest.raises(ValueError, match="finite, strictly positive"):
+        _load_checkpoint(layer, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("bad_scale", [torch.ones(512, dtype=torch.int32), torch.ones(1, 512)])
+def test_single_scale_rejects_invalid_smooth_type_or_rank(bad_scale, monkeypatch):
+    config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True)
+    layer = _CheckpointLayer(NPUMxfp4LinearMethod(config))
+    weights = {name: torch.ones_like(param) for name, param in layer.named_parameters()}
+    weights["mul_scale"] = bad_scale
+    with pytest.raises(ValueError, match="one-dimensional floating-point"):
+        _load_checkpoint(layer, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("bad_value", [1e10, 1e-10])
+def test_single_scale_rejects_smooth_overflow_or_underflow_after_cast(bad_value, monkeypatch):
+    config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True)
+    method = NPUMxfp4LinearMethod(config)
+    layer = _CheckpointLayer(method, torch.float16)
+    layer.mul_scale.data.fill_(bad_value)
+    # Validation must fail before any device packing or GEMM.
+    monkeypatch.setitem(sys.modules, "torch_npu", ModuleType("torch_npu"))
+    with pytest.raises(ValueError, match="finite, strictly positive"):
+        method.process_weights_after_loading(layer)
+
+
+@pytest.mark.parametrize(
+    ("mode", "missing"),
+    [
+        ("single", "weight"),
+        ("single", "weight_scale"),
+        ("dual", "weight"),
+        ("dual", "weight_scale"),
+        ("dual", "weight_dual_scale"),
+        ("dual", "mul_scale"),
+    ],
+)
+def test_offline_mxfp4_required_tensors_do_not_use_legacy_scale_tolerance(mode, missing, monkeypatch):
+    if mode == "single":
+        config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True)
+        method = NPUMxfp4LinearMethod(config)
+    else:
+        config = DiffusionMXFP4DualScaleMixedConfig(is_checkpoint_serialized=True)
+        method = NPUMxfp4DualScaleLinearMethod(config)
+    layer = _CheckpointLayer(method)
+    weights = {name: torch.ones_like(param) for name, param in layer.named_parameters() if name != missing}
+    with pytest.raises(ValueError, match=missing):
+        _load_checkpoint(layer, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("rank", [0, 1])
+def test_single_scale_smooth_uses_real_row_parallel_loader(rank):
+    from vllm.model_executor.layers.linear import RowParallelLinear
+
+    layer = _CheckpointLayer(NPUMxfp4LinearMethod(DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True)))
+    layer.tp_rank = rank
+    checkpoint_scale = torch.arange(1024, dtype=torch.float32)
+    RowParallelLinear.weight_loader(layer, layer.mul_scale, checkpoint_scale)
+    torch.testing.assert_close(layer.mul_scale, checkpoint_scale[rank * 512 : (rank + 1) * 512], rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float16])
+@pytest.mark.parametrize("fallback", [False, True])
+@pytest.mark.parametrize("with_bias", [False, True])
+@pytest.mark.parametrize("scale_alg", [0, 2])
+def test_single_scale_smooth_precedes_quantization_and_preserves_output(
+    dtype, fallback, with_bias, scale_alg, monkeypatch
+):
+    config = DiffusionMXFP4Config(
+        is_checkpoint_mxfp4_serialized=True, w4a8_fallback_steps=[0], mxfp4_scale_alg=scale_alg
+    )
+    method = NPUMxfp4LinearMethod(config)
+    layer = _CheckpointLayer(method, dtype)
+    weights = {
+        "weight": torch.linspace(-0.5, 1.5, 1024, dtype=dtype).reshape(2, 512),
+        "weight_scale": torch.full((2, 16), 127, dtype=torch.uint8),
+        "mul_scale": torch.linspace(0.5, 3.0, 512),
+    }
+    _load_checkpoint(layer, config, weights, monkeypatch)
+    x = torch.linspace(-1.0, 2.0, 3072, dtype=dtype).reshape(2, 3, 512)
+    bias = torch.tensor([0.5, -1.0], dtype=dtype) if with_bias else None
+    quantized_inputs = []
+
+    # Only the two device operators are substituted. Exercise real apply(),
+    # step selection, Smooth multiplication, bias handling, and reshape logic.
+    npu = ModuleType("torch_npu")
+
+    def quantize(value, **kwargs):
+        quantized_inputs.append(value.clone())
+        expected = dict(
+            dst_type=torch.float8_e4m3fn if fallback else "fp4",
+            axis=-1,
+            block_size=32,
+            round_mode="rint",
+            scale_alg=0 if fallback else scale_alg,
+        )
+        if not fallback and scale_alg == 2:
+            expected["dst_type_max"] = 7.25
+        assert kwargs == expected
+        return value, torch.ones((6, 16), dtype=torch.uint8)
+
+    def matmul(x_q, weight, weight_scale, *, bias, output_dtype, **kwargs):
+        if fallback:
+            assert output_dtype == torch.bfloat16
+            if bias is not None:
+                assert bias.dtype == output_dtype
+                assert bias.shape == (1, 2)
+        result = x_q.float() @ weight.float()
+        if bias is not None:
+            result += bias.float()
+        return result.to(output_dtype)
+
+    npu.__dict__.update(
+        float8_e4m3fn=torch.float8_e4m3fn,
+        float8_e8m0fnu=torch.uint8,
+        float4_e2m1fn_x2="fp4",
+        npu_dynamic_mx_quant=quantize,
+        npu_quant_matmul=matmul,
+    )
+    monkeypatch.setitem(sys.modules, "torch_npu", npu)
+    with override_forward_context(ForwardContext()):
+        set_forward_context_denoise_step_idx(0 if fallback else 1)
+        result = method.apply(layer, x, bias)
+
+    expected_input = x.reshape(-1, 512) * weights["mul_scale"].to(dtype)
+    assert len(quantized_inputs) == 1
+    torch.testing.assert_close(quantized_inputs[0], expected_input, rtol=0, atol=0)
+    expected = expected_input.float() @ weights["weight"].float().T
+    if bias is not None:
+        expected += bias.float()
+    if fallback:
+        expected = expected.bfloat16()
+    torch.testing.assert_close(result, expected.to(dtype).reshape(2, 3, 2), rtol=0, atol=0)
+    assert result.dtype == dtype
diff --git a/tests/diffusion/quantization/test_mxfp4_config.py b/tests/diffusion/quantization/test_mxfp4_config.py
index 240ee2509..c51b2013b 100644
--- a/tests/diffusion/quantization/test_mxfp4_config.py
+++ b/tests/diffusion/quantization/test_mxfp4_config.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Tests for MXFP4 quantization configs and the MXFP4 DualScale + BF16 mixed config."""
 
 import pytest
@@ -27,12 +27,42 @@ def test_mxfp4_config_get_name():
     assert DiffusionMXFP4Config.get_name() == "mxfp4"
 
 
+@pytest.mark.parametrize("value", [True, False, None, "2", 2.0, 1, -1, 3])
+def test_mxfp4_scale_alg_rejects_invalid_values(value):
+    from vllm_omni.quantization import build_quant_config
+
+    with pytest.raises(ValueError, match="mxfp4_scale_alg"):
+        build_quant_config({"method": "mxfp4", "mxfp4_scale_alg": value})
+
+
+@pytest.mark.parametrize("runtime_alg", [0, 2])
+@pytest.mark.parametrize("serialized", [False, True])
+def test_runtime_algorithm_survives_offline_storage_rebuild(runtime_alg, serialized):
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
+
+    active = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=serialized, mxfp4_scale_alg=runtime_alg)
+    resolved = resolve_quant_config_from_disk(
+        active,
+        {
+            "quant_method": "mxfp4",
+            "is_checkpoint_mxfp4_serialized": True,
+            "mxfp4_scale_alg": 2,
+            "ignored_layers": ["proj_out"],
+        },
+    )
+    assert resolved.is_checkpoint_mxfp4_serialized
+    assert resolved.mxfp4_scale_alg == runtime_alg
+    assert resolved.w4a8_fallback_layers == resolved.w4a8_fallback_steps == []
+
+
 def test_mxfp4_config_from_config_defaults():
     from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
 
     cfg = DiffusionMXFP4Config.from_config({})
     assert cfg.is_checkpoint_mxfp4_serialized is False
     assert cfg.ignored_layers == []
+    assert cfg.w4a8_fallback_layers == []
 
 
 def test_mxfp4_config_from_config_serialized():
@@ -42,6 +72,98 @@ def test_mxfp4_config_from_config_serialized():
     assert cfg.is_checkpoint_mxfp4_serialized is True
 
 
+def test_mxfp4_config_requires_offline_smooth():
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
+
+    values = {"is_checkpoint_mxfp4_serialized": True, "require_smooth_scale": True}
+    assert DiffusionMXFP4Config.from_config(values).require_smooth_scale
+    assert build_quant_config({"method": "mxfp4", **values}).require_smooth_scale
+    with pytest.raises(ValueError, match="offline"):
+        build_quant_config({"method": "mxfp4", "require_smooth_scale": True})
+    with pytest.raises(ValueError, match="boolean"):
+        DiffusionMXFP4Config.from_config({**values, "require_smooth_scale": "false"})
+
+
+@pytest.mark.parametrize("serialized", [False, True])
+def test_mxfp4_disk_smooth_requirement_preserves_step_policy(serialized):
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
+
+    active = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=serialized, w4a8_fallback_steps=[1])
+    resolved = resolve_quant_config_from_disk(
+        active,
+        {
+            "quant_method": "mxfp4",
+            "is_checkpoint_mxfp4_serialized": True,
+            "require_smooth_scale": True,
+        },
+    )
+    assert resolved.require_smooth_scale
+    assert resolved.is_checkpoint_mxfp4_serialized
+    assert resolved.w4a8_fallback_steps == [1]
+
+
+@pytest.mark.parametrize("disk_requirement", [None, False, True])
+def test_mxfp4_expert_rebuild_cannot_weaken_explicit_smooth_requirement(disk_requirement):
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
+
+    active = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True, require_smooth_scale=True)
+    disk = {
+        "quant_method": "mxfp4",
+        "is_checkpoint_mxfp4_serialized": True,
+        "ignored_layers": ["blocks.0.attn2.to_q"],
+    }
+    if disk_requirement is not None:
+        disk["require_smooth_scale"] = disk_requirement
+    resolved = resolve_quant_config_from_disk(active, disk)
+    assert resolved.require_smooth_scale
+    assert resolved.ignored_layers == disk["ignored_layers"]
+
+
+@pytest.mark.parametrize("disk_qc", ["mxfp4", {"quant_method": "mxfp4"}])
+def test_mxfp4_method_only_disk_config_preserves_caller_layer_policy(disk_qc):
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
+
+    active = DiffusionMXFP4Config(
+        ignored_layers=["blocks.0.attn2.to_q"],
+        w4a8_fallback_steps=[1],
+        w4a8_fallback_layers=["blocks.1.attn1.to_qkv"],
+    )
+
+    resolved = resolve_quant_config_from_disk(active, disk_qc)
+
+    assert resolved is active
+    assert resolved.ignored_layers == ["blocks.0.attn2.to_q"]
+    assert resolved.w4a8_fallback_steps == [1]
+    assert resolved.w4a8_fallback_layers == ["blocks.1.attn1.to_qkv"]
+
+
+def test_quantization_disk_string_rejects_mismatched_active_method():
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    active = build_quant_config("mxfp4")
+
+    with pytest.raises(ValueError, match="mxfp4_dualscale.*active quantization config is 'mxfp4'"):
+        resolve_quant_config_from_disk(active, "mxfp4_dualscale")
+
+
+def test_quantization_disk_string_accepts_equivalent_method_alias():
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    class ActiveAliasConfig:
+        @staticmethod
+        def get_name() -> str:
+            return "inc"
+
+    active = ActiveAliasConfig()
+
+    assert resolve_quant_config_from_disk(active, "auto-round") is active
+
+
 def test_mxfp4_config_from_config_ignored_layers():
     from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
 
@@ -57,6 +179,202 @@ def test_mxfp4_config_from_config_modules_to_not_convert_fallback():
     assert cfg.ignored_layers == ["proj_out"]
 
 
+@pytest.mark.parametrize("serialized", [False, True])
+@pytest.mark.parametrize(
+    "policy",
+    [
+        {"w4a8_fallback_steps": [0]},
+        {"w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"]},
+        {"w4a8_fallback_steps": [1], "w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"]},
+    ],
+)
+def test_dualscale_rejects_w4a8_configuration(serialized, policy):
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4DualScaleMixedConfig
+
+    config = {"quant_method": "mxfp4_dualscale", "is_checkpoint_serialized": serialized, **policy}
+    with pytest.raises(ValueError, match="does not support W4A8"):
+        DiffusionMXFP4DualScaleMixedConfig(is_checkpoint_serialized=serialized, **policy)
+    with pytest.raises(ValueError, match="does not support W4A8"):
+        DiffusionMXFP4DualScaleMixedConfig.from_config(config)
+    with pytest.raises(ValueError, match="does not support W4A8"):
+        build_quant_config({"transformer": config})
+    with pytest.raises(ValueError, match="does not support W4A8"):
+        resolve_quant_config_from_disk(None, config)
+
+
+@pytest.mark.parametrize("method", ["mxfp4", "mxfp4_dualscale"])
+@pytest.mark.parametrize("steps", [[-1], [True], [1.5], ["2"], "0,2", (0, 2)])
+def test_mxfp4_rejects_invalid_fallback_steps(method, steps):
+    from vllm_omni.quantization import build_quant_config
+
+    with pytest.raises(ValueError, match="non-negative integer"):
+        build_quant_config({"method": method, "w4a8_fallback_steps": steps})
+
+
+def test_mxfp4_fallback_steps_follow_request_context():
+    from vllm_omni.diffusion.forward_context import (
+        ForwardContext,
+        override_forward_context,
+        set_forward_context_denoise_step_idx,
+    )
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.mxfp4_config import _is_w4a8_fallback_step
+
+    steps = [2, 0, 2]
+    cfg = build_quant_config({"method": "mxfp4", "w4a8_fallback_steps": steps})
+    steps.append(1)
+    assert cfg.w4a8_fallback_steps == [0, 2]
+    with override_forward_context(None):
+        assert not _is_w4a8_fallback_step([])
+        with pytest.raises(RuntimeError, match="publishes its denoise step"):
+            _is_w4a8_fallback_step(cfg.w4a8_fallback_steps)
+        for _request in range(2):
+            with override_forward_context(ForwardContext()):
+                for step, expected in [(0, True), (1, False), (2, True), (3, False)]:
+                    set_forward_context_denoise_step_idx(step)
+                    # Both CFG passes and both experts read the same index.
+                    assert [_is_w4a8_fallback_step(cfg.w4a8_fallback_steps) for _cfg_pass in range(2)] == [
+                        expected,
+                        expected,
+                    ]
+        with pytest.raises(RuntimeError, match="publishes its denoise step"):
+            _is_w4a8_fallback_step(cfg.w4a8_fallback_steps)
+
+
+@pytest.mark.parametrize("method,flag", [("mxfp4", "is_checkpoint_mxfp4_serialized")])
+@pytest.mark.parametrize("steps", [[], [0, 2]])
+@pytest.mark.parametrize("already_serialized", [False, True])
+def test_mxfp4_disk_rebuild_preserves_runtime_fallback(method, flag, steps, already_serialized):
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    layers = ["blocks.10.attn1.to_qkv"] if steps else []
+    active = build_quant_config(
+        {
+            "method": method,
+            flag: already_serialized,
+            "w4a8_fallback_steps": steps,
+            "w4a8_fallback_layers": layers,
+        }
+    )
+    # Separate experts may have distinct high precision layers. Both must
+    # retain the requested step policy during online/offline reconciliation.
+    for ignored in [["blocks.0.attn1.to_q"], ["blocks.1.attn1.to_q"]]:
+        resolved = resolve_quant_config_from_disk(
+            active,
+            {
+                "quant_method": method,
+                flag: True,
+                "ignored_layers": ignored,
+                "w4a8_fallback_steps": [9],
+                "w4a8_fallback_layers": ["blocks.9.ffn.net_2"],
+            },
+        )
+        assert getattr(resolved, flag)
+        assert resolved.ignored_layers == ignored
+        assert resolved.w4a8_fallback_steps == steps
+        assert resolved.w4a8_fallback_layers == layers
+    assert active.ignored_layers == []
+
+
+@pytest.mark.parametrize(
+    "runtime_policy",
+    [{}, {"w4a8_fallback_steps": [1]}, {"w4a8_fallback_layers": ["blocks.10.attn1.to_qkv"]}],
+)
+def test_mxfp4_explicit_omission_disables_saved_policies_for_both_experts(runtime_policy):
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    active = build_quant_config({"method": "mxfp4", **runtime_policy})
+    resolved_experts = []
+    for ignored in (["blocks.0.attn2.to_q"], ["blocks.1.ffn.net_2"]):
+        disk = {
+            "quant_method": "mxfp4",
+            "is_checkpoint_mxfp4_serialized": True,
+            "ignored_layers": ignored,
+            "w4a8_fallback_steps": [9],
+            "w4a8_fallback_layers": ["blocks.9.ffn.net_2"],
+        }
+        resolved = resolve_quant_config_from_disk(active, disk)
+        assert resolved.w4a8_fallback_steps == runtime_policy.get("w4a8_fallback_steps", [])
+        assert resolved.w4a8_fallback_layers == runtime_policy.get("w4a8_fallback_layers", [])
+        assert resolved.ignored_layers == ignored
+        detected = resolve_quant_config_from_disk(None, disk)
+        assert detected.w4a8_fallback_steps == [9]
+        assert detected.w4a8_fallback_layers == ["blocks.9.ffn.net_2"]
+        resolved_experts.append(resolved)
+    assert resolved_experts[0] is not resolved_experts[1]
+    assert active.is_checkpoint_mxfp4_serialized is False
+    assert active.ignored_layers == []
+
+
+@pytest.mark.parametrize(
+    "method,flag", [("mxfp4", "is_checkpoint_mxfp4_serialized"), ("mxfp4_dualscale", "is_checkpoint_serialized")]
+)
+def test_serialized_mxfp4_disk_omission_clears_active_ignored_layers(method, flag):
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    active_spec = {
+        "method": method,
+        flag: True,
+        "ignored_layers": ["blocks.0.attn2.to_q"],
+        "w4a8_fallback_steps": [1] if method == "mxfp4" else [],
+        "w4a8_fallback_layers": ["blocks.1.attn1.to_qkv"] if method == "mxfp4" else [],
+    }
+    if method == "mxfp4":
+        active_spec["require_smooth_scale"] = True
+    active = build_quant_config(active_spec)
+
+    resolved = resolve_quant_config_from_disk(active, {"quant_method": method, flag: True})
+
+    assert resolved is not active
+    assert resolved.ignored_layers == []
+    assert resolved.w4a8_fallback_steps == active.w4a8_fallback_steps
+    assert resolved.w4a8_fallback_layers == active.w4a8_fallback_layers
+    if method == "mxfp4":
+        assert resolved.require_smooth_scale
+
+
+@pytest.mark.parametrize(
+    "method,flag", [("mxfp4", "is_checkpoint_mxfp4_serialized"), ("mxfp4_dualscale", "is_checkpoint_serialized")]
+)
+@pytest.mark.parametrize("with_active", [False, True])
+def test_serialized_mxfp4_disk_uses_modules_to_not_convert(method, flag, with_active):
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    active = None
+    disk_steps = [9] if method == "mxfp4" else []
+    active_steps = [1] if method == "mxfp4" else []
+    expected_steps = disk_steps
+    if with_active:
+        active = build_quant_config(
+            {
+                "method": method,
+                flag: True,
+                "ignored_layers": ["blocks.0.attn2.to_q"],
+                "w4a8_fallback_steps": active_steps,
+            }
+        )
+        expected_steps = active_steps
+
+    resolved = resolve_quant_config_from_disk(
+        active,
+        {
+            "quant_method": method,
+            flag: True,
+            "modules_to_not_convert": ["blocks.2.ffn.net_2"],
+            "w4a8_fallback_steps": disk_steps,
+        },
+    )
+
+    assert resolved.ignored_layers == ["blocks.2.ffn.net_2"]
+    assert resolved.w4a8_fallback_steps == expected_steps
+
+
 # ---------------------------------------------------------------------------
 # build_quant_config integration
 # ---------------------------------------------------------------------------
@@ -594,18 +912,31 @@ def test_rocm_online_dispatch_returns_rocm_method(_rocm_platform, monkeypatch):
     assert isinstance(method, ROCmMxfp4OnlineLinearMethod)
 
 
-def test_rocm_ignored_layer_returns_unquantized(_rocm_platform, monkeypatch):
+@pytest.mark.parametrize("steps", [[], [0, 2]])
+def test_rocm_ignored_layer_returns_unquantized(_rocm_platform, monkeypatch, steps):
     """A prefix in ignored_layers must return UnquantizedLinearMethod before the gfx950 probe."""
     from vllm.model_executor.layers.linear import UnquantizedLinearMethod
 
     from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
 
     _patch_gcn_arch(monkeypatch, "gfx950:sramecc+:xnack-")
-    cfg = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=False, ignored_layers=["proj_out"])
+    cfg = DiffusionMXFP4Config(
+        is_checkpoint_mxfp4_serialized=False, ignored_layers=["proj_out"], w4a8_fallback_steps=steps
+    )
 
     assert isinstance(cfg.get_quant_method(_fake_linear_layer(), "proj_out"), UnquantizedLinearMethod)
 
 
+def test_rocm_rejects_w4a8_step_fallback(_rocm_platform, monkeypatch):
+    from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
+
+    _patch_gcn_arch(monkeypatch, "gfx950:sramecc+:xnack-")
+    cfg = DiffusionMXFP4Config(w4a8_fallback_steps=[0, 2])
+
+    with pytest.raises(NotImplementedError, match="only supported on NPU"):
+        cfg.get_quant_method(_fake_linear_layer(), "blocks.0.attn1.to_q")
+
+
 def test_rocm_non_gfx950_raises(_rocm_platform, monkeypatch):
     """MXFP4 on ROCm requires gfx950; any other arch must raise."""
     from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config
@@ -652,3 +983,221 @@ def test_rocm_create_weights_row_parallel_tp2(_rocm_platform):
     assert layer.weight.shape == (_TP2_N, _TP2_K // _TP2)
     assert layer.input_size_per_partition == _TP2_K // _TP2
     assert layer.output_size_per_partition == _TP2_N
+
+
+@pytest.mark.parametrize("method", ["mxfp4", "mxfp4_dualscale"])
+@pytest.mark.parametrize("layers", ["blocks.1.attn1.to_qkv", [1], [True], [""], [" a"], ["blocks.*"], ["a..b"]])
+def test_mxfp4_rejects_invalid_fallback_layers(method, layers):
+    from vllm_omni.quantization import build_quant_config
+
+    with pytest.raises(ValueError, match="exact runtime Linear paths"):
+        build_quant_config({"method": method, "w4a8_fallback_layers": layers})
+
+
+@pytest.mark.parametrize("method", ["mxfp4"])
+def test_mxfp4_layer_policy_from_checkpoint_and_component_config(method):
+    from vllm_omni.quantization import build_quant_config
+    from vllm_omni.quantization.component_config import resolve_component_quant_config
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    names = ["blocks.10.attn1.to_qkv", "blocks.10.attn1.to_qkv"]
+    components = build_quant_config(
+        {"transformer": {"method": method, "w4a8_fallback_layers": names}, "transformer_2": {"method": method}}
+    )
+    names.append("blocks.11.attn1.to_qkv")
+    assert resolve_component_quant_config(components, "transformer").w4a8_fallback_layers == [names[0]]
+    assert resolve_component_quant_config(components, "transformer_2").w4a8_fallback_layers == []
+    detected = resolve_quant_config_from_disk(None, {"quant_method": method, "w4a8_fallback_layers": [names[0]]})
+    assert detected.w4a8_fallback_layers == [names[0]]
+    assert type(detected).from_config({"w4a8_fallback_layers": [names[0]]}).w4a8_fallback_layers == [names[0]]
+
+
+@pytest.mark.parametrize(
+    "kind, serialized_flag",
+    [("mxfp4", "is_checkpoint_mxfp4_serialized")],
+)
+@pytest.mark.parametrize("offline", [False, True])
+@pytest.mark.parametrize("scale_alg", [0, 2])
+def test_mxfp4_layer_and_step_union_routes_actual_methods(
+    kind, serialized_flag, offline, scale_alg, monkeypatch, mocker
+):
+    from vllm.model_executor.layers.linear import LinearBase, UnquantizedLinearMethod
+
+    from vllm_omni.diffusion.forward_context import ForwardContext, override_forward_context
+    from vllm_omni.quantization import build_quant_config, mxfp4_config
+
+    monkeypatch.setattr(mxfp4_config.current_omni_platform, "is_npu", lambda: True)
+    selected = "blocks.10.attn1.to_qkv"
+    other = "blocks.11.attn2.to_q"
+    preserved = "blocks.12.ffn.net_2"
+    config = build_quant_config(
+        {
+            "method": kind,
+            "mxfp4_scale_alg": scale_alg,
+            serialized_flag: offline,
+            "w4a8_fallback_layers": [selected, preserved],
+            "ignored_layers": [preserved],
+            "w4a8_fallback_steps": [1],
+        }
+    )
+    # Real config dispatch creates separate methods for selected and other layers.
+    linear = mocker.Mock(spec=LinearBase)
+    assert isinstance(config.get_quant_method(linear, preserved), UnquantizedLinearMethod)
+    x = torch.ones(2, 64, dtype=torch.bfloat16)
+    layer = torch.nn.Module()
+    for name in ("weight", "weight_scale", "mul_scale"):
+        layer.register_buffer(name, torch.ones(64, dtype=x.dtype))
+    calls = []
+
+    def record_a8(*args):
+        calls.append("A8")
+        return x
+
+    def record_a4(*args):
+        calls.append("A4")
+        return x
+
+    monkeypatch.setattr(mxfp4_config, "_npu_w4a8_matmul", record_a8)
+    for name in (selected, other):
+        method = config.get_quant_method(linear, name)
+        assert method.is_w4a8_fallback_layer == (name == selected)
+        scales = (x, x)
+        monkeypatch.setattr(method, "_quantize_activation", lambda *args: scales)
+        monkeypatch.setattr(method, "_quant_matmul", record_a4)
+        for step in (0, 1, 2):
+            with override_forward_context(ForwardContext(denoise_step_idx=step)):
+                method.apply(layer, x)
+    assert calls == ["A8", "A8", "A8", "A4", "A8", "A4"]
+    # A permanently selected layer works without a request context, even if steps are also configured.
+    with override_forward_context(None):
+        config.get_quant_method(linear, selected).apply(layer, x)
+    assert calls[-1] == "A8"
+
+
+@pytest.mark.parametrize("online", [False, True])
+@pytest.mark.parametrize("selected", [False, True])
+@pytest.mark.parametrize("scale_alg", [0, 2])
+def test_single_scale_prepares_one_weight_for_both_activation_precisions(online, selected, scale_alg, monkeypatch):
+    import sys
+    from types import SimpleNamespace
+
+    from vllm_omni.diffusion.forward_context import ForwardContext, override_forward_context
+    from vllm_omni.quantization import mxfp4_config
+
+    monkeypatch.setattr(torch.Tensor, "npu", lambda self: self, raising=False)
+    prepared = []
+    packed = []
+
+    def quantize(x, **kwargs):
+        prepared.append(kwargs)
+        return x.to(torch.int8), torch.full((x.shape[0], 2), 127, dtype=torch.uint8)
+
+    def pack(x, dtype):
+        packed.append(x)
+        return x.to(dtype)
+
+    fake_npu = SimpleNamespace(
+        float4_e2m1fn_x2=torch.int8,
+        float8_e8m0fnu=torch.uint8,
+        float8_e4m3fn=torch.float8_e4m3fn,
+        npu_dtype_cast=pack,
+        npu_dynamic_mx_quant=quantize,
+    )
+    monkeypatch.setitem(sys.modules, "torch_npu", fake_npu)
+    config = mxfp4_config.DiffusionMXFP4Config(
+        is_checkpoint_mxfp4_serialized=not online,
+        w4a8_fallback_layers=["blocks.0.attn1.to_qkv"] if selected else [],
+        w4a8_fallback_steps=[1],
+        mxfp4_scale_alg=scale_alg,
+    )
+    cls = mxfp4_config.NPUMxfp4OnlineLinearMethod if online else mxfp4_config.NPUMxfp4LinearMethod
+    method = cls(config, prefix="blocks.0.attn1.to_qkv")
+    layer = torch.nn.Linear(64, 2, bias=False, dtype=torch.bfloat16)
+    layer.orig_dtype = torch.bfloat16
+    if not online:
+        layer.register_parameter("weight_scale", torch.nn.Parameter(torch.full((2, 2), 127, dtype=torch.uint8), False))
+        layer.register_parameter("mul_scale", torch.nn.Parameter(torch.linspace(0.5, 2, 64), False))
+    method.process_weights_after_loading(layer)
+    pointers = (layer.weight.data_ptr(), layer.weight_scale.data_ptr())
+    method.process_weights_after_loading(layer)
+    assert len(prepared) == int(online)
+    expected = dict(dst_type=torch.int8, axis=-1, block_size=32, round_mode="rint", scale_alg=scale_alg)
+    if scale_alg == 2:
+        expected["dst_type_max"] = 7.25
+    assert prepared == ([expected] if online else [])
+    assert len(packed) == int(not online)
+    branches = []
+
+    def a4(x_q, x_scale, target, bias, dtype):
+        assert (target.weight.data_ptr(), target.weight_scale.data_ptr()) == pointers
+        branches.append("A4")
+        return torch.zeros(x_q.shape[0], 2, dtype=dtype)
+
+    def a8(x, weight, scale, bias, dtype):
+        assert (weight.data_ptr(), scale.data_ptr()) == pointers
+        branches.append("A8")
+        return torch.zeros(x.shape[0], 2, dtype=dtype)
+
+    monkeypatch.setattr(method, "_quant_matmul", a4)
+    monkeypatch.setattr(mxfp4_config, "_npu_w4a8_matmul", a8)
+    monkeypatch.setattr(method, "_quantize_activation", lambda x: (x, x))
+    monkeypatch.setattr(fake_npu, "npu_dynamic_mx_quant", lambda *a, **kw: pytest.fail("weight requantization"))
+    monkeypatch.setattr(fake_npu, "npu_dtype_cast", lambda *a, **kw: pytest.fail("weight repacking"))
+    for step in (0, 1, 2):
+        with override_forward_context(ForwardContext(denoise_step_idx=step)):
+            method.apply(layer, torch.ones(2, 64, dtype=torch.bfloat16))
+    assert branches == (["A8"] * 3 if selected else ["A4", "A8", "A4"])
+    assert (layer.weight.data_ptr(), layer.weight_scale.data_ptr()) == pointers
+    assert set(layer.state_dict()) == (
+        {"weight", "weight_scale"} if online else {"weight", "weight_scale", "mul_scale"}
+    )
+    assert not hasattr(layer, "w4a8_weight")
+    assert not hasattr(layer, "w4a8_weight_scale")
+
+
+@pytest.mark.parametrize("online", [False, True])
+def test_dualscale_without_fallback_keeps_original_a4_path(online, monkeypatch):
+    import sys
+    from types import SimpleNamespace
+
+    from vllm_omni.quantization import mxfp4_config
+
+    monkeypatch.setattr(torch.Tensor, "npu", lambda self: self, raising=False)
+    original_ones = torch.ones
+    monkeypatch.setattr(torch, "ones", lambda *args, **kw: original_ones(*args, **{**kw, "device": "cpu"}))
+    calls = []
+
+    def quantize_dual(x, **kw):
+        calls.append(kw.get("smooth_scale"))
+        return x.to(torch.int8), torch.ones(x.shape[0], 1), torch.ones(x.shape[0], 16, dtype=torch.uint8)
+
+    fake_npu = SimpleNamespace(
+        float4_e2m1fn_x2=torch.int8,
+        npu_dtype_cast=lambda x, dtype: x.to(dtype),
+        npu_format_cast=lambda x, *args, **kw: x,
+        npu_dynamic_dual_level_mx_quant=quantize_dual,
+    )
+    monkeypatch.setitem(sys.modules, "torch_npu", fake_npu)
+    config = mxfp4_config.DiffusionMXFP4DualScaleMixedConfig(
+        is_checkpoint_serialized=not online, w4a8_fallback_steps=[], w4a8_fallback_layers=[]
+    )
+    cls = mxfp4_config.NPUMxfp4DualScaleOnlineLinearMethod if online else mxfp4_config.NPUMxfp4DualScaleLinearMethod
+    method = cls(config)
+    layer = torch.nn.Module()
+    layer.input_size_per_partition = 512
+    for name, value in {
+        "weight": torch.ones(2, 512, dtype=torch.bfloat16),
+        "weight_scale": torch.full((2, 16), 127, dtype=torch.uint8),
+        "weight_dual_scale": torch.ones(2, 1, 1),
+        "mul_scale": torch.ones(512),
+    }.items():
+        layer.register_parameter(name, torch.nn.Parameter(value, requires_grad=False))
+    method.process_weights_after_loading(layer)
+    method.process_weights_after_loading(layer)
+    assert len(calls) == int(online)
+    assert set(layer.state_dict()) == {"weight", "weight_scale", "weight_dual_scale", "mul_scale"}
+    assert not hasattr(layer, "w4a8_weight")
+    monkeypatch.setattr(method, "_quant_matmul", lambda *args: torch.zeros(2, 2, dtype=torch.bfloat16))
+    method.apply(layer, torch.ones(2, 512, dtype=torch.bfloat16))
+    assert len(calls) == 1 + int(online)
+    torch.testing.assert_close(calls[-1], layer.mul_scale)
diff --git a/tests/diffusion/quantization/test_mxfp8_config.py b/tests/diffusion/quantization/test_mxfp8_config.py
index cc34fb232..7c3745d4b 100644
--- a/tests/diffusion/quantization/test_mxfp8_config.py
+++ b/tests/diffusion/quantization/test_mxfp8_config.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Tests for MXFP8 quantization config and linear method dispatch.
 
 Coverage:
@@ -9,11 +9,13 @@ Coverage:
 - Weight / scale shape-transform arithmetic from process_weights_after_loading (CPU)
 - build_quant_config integration
 - MXFP8_QUANT_CONFIG structure as the auto-detection contract
+- Offload-after-quant capability of the shared online-method mixin (CPU)
 """
 
 import pytest
 import torch
 from pytest_mock import MockerFixture
+from torch.nn import Module
 from vllm.model_executor.layers.linear import LinearBase, UnquantizedLinearMethod
 
 from vllm_omni.platforms import current_omni_platform
@@ -335,3 +337,99 @@ def test_supported_methods_include_mxfp8():
     from vllm_omni.quantization import SUPPORTED_QUANTIZATION_METHODS
 
     assert "mxfp8" in SUPPORTED_QUANTIZATION_METHODS
+
+
+# ---------------------------------------------------------------------------
+# Offload-after-quant capability (CPU, no NPU ops)
+# ---------------------------------------------------------------------------
+
+
+class TestOffloadAfterQuant:
+    """Online MXFP methods advertise ``supports_offload_after_quant`` so the
+    diffusion loader can stream each layer back to host memory right after it
+    is quantized, instead of accumulating the whole model on the accelerator
+    until the final ``model.to("cpu")``.
+
+    The capability lives on ``_LazyWeightMixin``, which is shared by all
+    online MXFP8/MXFP4 methods, so pinning it here covers mxfp4 too.
+    """
+
+    @pytest.fixture(autouse=True)
+    def _mock_tp(self, mocker: MockerFixture):
+        # create_weights resolves the TP group while computing per-partition
+        # shapes; these tests never initialize torch.distributed.
+        mock_group = mocker.Mock()
+        mock_group.rank_in_group = 0
+        mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_world_size", return_value=1)
+        mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_rank", return_value=0)
+        mocker.patch("vllm.distributed.parallel_state.get_tp_group", return_value=mock_group)
+
+    def _make_method(self):
+        from vllm_omni.quantization.mxfp8_config import (
+            DiffusionMXFP8Config,
+            NPUMxfp8OnlineLinearMethod,
+        )
+
+        return NPUMxfp8OnlineLinearMethod(DiffusionMXFP8Config(is_checkpoint_mxfp8_serialized=False))
+
+    def test_only_methods_advertising_the_capability_are_asked(self):
+        from vllm_omni.diffusion.model_loader.diffusers_loader import (
+            DiffusersPipelineLoader,
+        )
+
+        class MetaDeviceOnlyMethod:
+            """Stands in for upstream online FP8: lazy, but no offload hook."""
+
+            uses_meta_device = True
+
+        model = torch.nn.Sequential(Module(), Module())
+        lazy_mxfp8 = self._make_method()
+        model[0].quant_method = lazy_mxfp8
+        model[1].quant_method = MetaDeviceOnlyMethod()
+
+        marked = DiffusersPipelineLoader._request_offload_after_quant(model)
+
+        assert marked == 1
+        assert lazy_mxfp8._offload_after_quant
+
+    def _load_layer_in_one_chunk(self, method, layer):
+        method.create_weights(
+            layer,
+            input_size_per_partition=8,
+            output_partition_sizes=[4],
+            input_size=8,
+            output_size=4,
+            params_dtype=torch.bfloat16,
+            weight_loader=lambda param, loaded_weight, *args, **kwargs: param.copy_(loaded_weight),
+        )
+        full_weight = torch.randn(4, 8, dtype=torch.bfloat16)
+        layer.weight.weight_loader(layer.weight, full_weight)
+
+    def test_finished_layer_returns_to_cpu_when_enabled(self, mocker: MockerFixture):
+        method = self._make_method()
+        method.enable_offload_after_quant()
+        mocker.patch.object(method, "process_weights_after_loading")
+
+        layer = Module()
+        moved_to = []
+        layer.to = lambda device, *args, **kwargs: moved_to.append(device)  # type: ignore[method-assign]
+
+        self._load_layer_in_one_chunk(method, layer)
+
+        method.process_weights_after_loading.assert_called_once_with(layer)
+        assert layer._already_called_process_weights_after_loading
+        assert moved_to == ["cpu"]
+
+    def test_finished_layer_stays_put_by_default(self, mocker: MockerFixture):
+        method = self._make_method()
+        mocker.patch.object(method, "process_weights_after_loading")
+
+        layer = Module()
+        moved_to = []
+        layer.to = lambda device, *args, **kwargs: moved_to.append(device)  # type: ignore[method-assign]
+
+        self._load_layer_in_one_chunk(method, layer)
+
+        method.process_weights_after_loading.assert_called_once_with(layer)
+        assert layer._already_called_process_weights_after_loading
+        assert moved_to == []
diff --git a/tests/diffusion/quantization/test_quantization_fp8.py b/tests/diffusion/quantization/test_quantization_fp8.py
index 5aa7faaa6..9f41a6a89 100644
--- a/tests/diffusion/quantization/test_quantization_fp8.py
+++ b/tests/diffusion/quantization/test_quantization_fp8.py
@@ -414,18 +414,16 @@ def test_quantization_key_maps_to_quantization_config():
 
 
 @hardware_test(res={"cuda": ["L4", "B200"]})
-def test_quantization_config_key_takes_priority():
-    """When both 'quantization' and 'quantization_config' are set,
-    'quantization_config' takes priority."""
+def test_quantization_and_quantization_config_conflict():
+    """Two explicit quantization sources are rejected instead of silently merged."""
     from vllm_omni.diffusion.data import OmniDiffusionConfig
 
-    config = OmniDiffusionConfig.from_kwargs(
-        model="test",
-        quantization="fp8",
-        quantization_config={"method": "fp8", "activation_scheme": "static"},
-    )
-    assert config.quantization_config is not None
-    assert config.quantization_config.activation_scheme == "static"
+    with pytest.raises(ValueError, match=r"quantization.*quantization_config"):
+        OmniDiffusionConfig.from_kwargs(
+            model="test",
+            quantization="fp8",
+            quantization_config={"method": "fp8", "activation_scheme": "static"},
+        )
 
 
 @hardware_test(res={"cuda": ["L4", "B200"]})
diff --git a/tests/diffusion/quantization/test_wan_mxfp4_loading.py b/tests/diffusion/quantization/test_wan_mxfp4_loading.py
new file mode 100644
index 000000000..fc7a43d43
--- /dev/null
+++ b/tests/diffusion/quantization/test_wan_mxfp4_loading.py
@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Exercise Wan's real name mapping and vLLM's QKV parameter loaders on CPU."""
+
+import pytest
+import torch
+from vllm.config.load import LoadConfig
+from vllm.model_executor.layers.linear import QKVParallelLinear
+
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
+from vllm_omni.diffusion.models.wan2_2.wan2_2_transformer import WanTransformer3DModel
+from vllm_omni.quantization.mxfp4_config import DiffusionMXFP4Config, DiffusionMXFP4DualScaleMixedConfig
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+@pytest.fixture(autouse=True)
+def _patch_tp_state(monkeypatch):
+    monkeypatch.setattr("vllm.model_executor.parameter.get_tensor_model_parallel_rank", lambda: 0)
+    monkeypatch.setattr("vllm.model_executor.parameter.get_tensor_model_parallel_world_size", lambda: 1)
+    monkeypatch.setattr("vllm_omni.platforms.current_omni_platform.is_npu", lambda: True)
+    prefix = "vllm_omni.diffusion.models.wan2_2.wan2_2_transformer"
+    monkeypatch.setattr(f"{prefix}.get_tensor_model_parallel_rank", lambda: 0)
+    monkeypatch.setattr(f"{prefix}.get_tensor_model_parallel_world_size", lambda: 1)
+
+
+class _WanCheckpoint(torch.nn.Module):
+    load_weights = WanTransformer3DModel.load_weights
+    _log_w4a8_fallback_load_summary = WanTransformer3DModel._log_w4a8_fallback_load_summary
+
+    def __init__(self, config, *, num_blocks=1):
+        super().__init__()
+        blocks = []
+        for block_idx in range(num_blocks):
+            block = torch.nn.Module()
+            block.attn1 = torch.nn.Module()
+            block.attn1.to_qkv = QKVParallelLinear(
+                hidden_size=512,
+                head_size=32,
+                total_num_heads=4,
+                bias=False,
+                params_dtype=torch.bfloat16,
+                quant_config=config,
+                prefix=f"blocks.{block_idx}.attn1.to_qkv",
+                disable_tp=True,
+            )
+            blocks.append(block)
+        self.blocks = torch.nn.ModuleList(blocks)
+
+
+def _checkpoint(mode, fused):
+    if mode == "single":
+        config = DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True, require_smooth_scale=True)
+    elif mode == "dual":
+        config = DiffusionMXFP4DualScaleMixedConfig(is_checkpoint_serialized=True)
+    else:
+        config = None
+    model = _WanCheckpoint(config)
+    weights = {}
+    expected = {}
+    for name, param in model.named_parameters():
+        suffix = name.rsplit(".", 1)[1]
+        output_dim = getattr(param, "output_dim", None)
+        if output_dim is None:
+            value = torch.full_like(param, 2.5)
+            shards = [value] * 3
+        else:
+            parts = param.chunk(3, dim=output_dim)
+            shards = [
+                torch.full_like(part, (121 if suffix == "weight_scale" else 1) + i) for i, part in enumerate(parts)
+            ]
+            value = torch.cat(shards, dim=output_dim)
+        expected[name] = value
+        if fused:
+            weights[name] = value
+        else:
+            for shard_id, shard in zip(("q", "k", "v"), shards):
+                weights[f"blocks.0.attn1.to_{shard_id}.{suffix}"] = shard
+    return model, config, weights, expected
+
+
+def _load(model, config, weights, monkeypatch):
+    loader = DiffusersPipelineLoader(
+        LoadConfig(), OmniDiffusionConfig(model="", dtype=torch.bfloat16, quantization_config=config)
+    )
+    loader.counter_before_loading_weights = 0.0
+    monkeypatch.setattr(loader, "get_all_weights", lambda model: iter(weights.items()))
+    loader.load_weights(model)
+
+
+@pytest.mark.parametrize("mode", ["single", "dual", "bf16"])
+@pytest.mark.parametrize("fused", [False, True])
+def test_wan_qkv_loads_actual_weights_and_scales(mode, fused, monkeypatch):
+    model, config, weights, expected = _checkpoint(mode, fused)
+    _load(model, config, weights, monkeypatch)
+    for name, param in model.named_parameters():
+        torch.testing.assert_close(param, expected[name], rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("mode", ["single", "dual", "bf16"])
+def test_wan_incomplete_qkv_weight_is_not_marked_fully_loaded(mode, monkeypatch):
+    model, config, weights, _ = _checkpoint(mode, fused=False)
+    weights.pop("blocks.0.attn1.to_k.weight")
+    weights.pop("blocks.0.attn1.to_v.weight")
+    with pytest.raises(ValueError, match="to_qkv.weight"):
+        _load(model, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("mode", ["single", "dual"])
+def test_wan_incomplete_qkv_scale_is_not_marked_fully_loaded(mode, monkeypatch):
+    model, config, weights, _ = _checkpoint(mode, fused=False)
+    weights.pop("blocks.0.attn1.to_k.weight_scale")
+    weights.pop("blocks.0.attn1.to_v.weight_scale")
+    with pytest.raises(ValueError, match="to_qkv.weight_scale"):
+        _load(model, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("mode", ["single", "dual"])
+@pytest.mark.parametrize("reverse", [False, True])
+def test_wan_split_qkv_rejects_different_smooth_scales(mode, reverse, monkeypatch):
+    model, config, weights, _ = _checkpoint(mode, fused=False)
+    weights["blocks.0.attn1.to_k.mul_scale"] = weights["blocks.0.attn1.to_k.mul_scale"] * 2
+    if reverse:
+        weights = dict(reversed(weights.items()))
+    with pytest.raises(ValueError, match="must share the same Smooth tensor"):
+        _load(model, config, weights, monkeypatch)
+
+
+@pytest.mark.parametrize("name", ["to_q.missing", "to_qkv.missing", "to_qkv_extra.weight", "to_query.weight"])
+def test_wan_unknown_qkv_key_is_not_reported_as_loaded(name):
+    model, _, _, _ = _checkpoint("single", fused=True)
+    loaded = model.load_weights([(f"blocks.0.attn1.{name}", torch.ones(2))])
+    assert loaded == set()
+
+
+@pytest.mark.parametrize("fused", [False, True])
+def test_wan_single_scale_rejects_relabelled_dualscale_checkpoint(fused, monkeypatch):
+    model, config, weights, _ = _checkpoint("single", fused=fused)
+    projection = "to_qkv" if fused else "to_q"
+    weights[f"blocks.0.attn1.{projection}.weight_dual_scale"] = torch.ones(128, 1, 1)
+    with pytest.raises(ValueError, match="cannot load DualScale tensor"):
+        _load(model, config, weights, monkeypatch)
+
+
+def test_wan_layer_policy_validates_runtime_qkv_and_bf16_override():
+    config = DiffusionMXFP4Config(w4a8_fallback_layers=["blocks.0.attn1.to_qkv"])
+    model = _WanCheckpoint(config)
+    # Uses the same validation called at the end of WanTransformer3DModel construction.
+    WanTransformer3DModel._validate_w4a8_fallback_layers(model, config)
+    for bad in ("blocks.0.attn1.to_q", "blocks.0.attn1", "blocks.99.attn1.to_qkv", "transformer.blocks.0.attn1.to_qkv"):
+        config.w4a8_fallback_layers = [bad]
+        with pytest.raises(ValueError, match="exact runtime Linear paths"):
+            WanTransformer3DModel._validate_w4a8_fallback_layers(model, config)
+
+
+def test_wan_layer_policy_defers_only_other_pp_stage_paths():
+    from vllm.model_executor.models.utils import PPMissingLayer
+
+    config = DiffusionMXFP4Config(w4a8_fallback_layers=["blocks.0.attn1.to_qkv", "blocks.1.attn1.to_qkv"])
+    model = _WanCheckpoint(config)
+    model.blocks.append(PPMissingLayer())
+    WanTransformer3DModel._validate_w4a8_fallback_layers(model, config)
+    config.w4a8_fallback_layers = ["blocks.1"]
+    with pytest.raises(ValueError, match="exact runtime Linear paths"):
+        WanTransformer3DModel._validate_w4a8_fallback_layers(model, config)
+
+
+@pytest.mark.parametrize("is_checkpoint_serialized", [False, True], ids=["online", "offline"])
+def test_loader_logs_wan_expert_summaries_after_weight_processing(is_checkpoint_serialized, mocker):
+    selected = "blocks.0.attn1.to_qkv"
+    bf16 = "blocks.1.attn1.to_qkv"
+    transformer_config = DiffusionMXFP4Config(
+        is_checkpoint_mxfp4_serialized=is_checkpoint_serialized,
+        w4a8_fallback_layers=[selected],
+    )
+    transformer_2_config = DiffusionMXFP4Config(
+        is_checkpoint_mxfp4_serialized=is_checkpoint_serialized,
+        ignored_layers=[bf16],
+        w4a8_fallback_layers=[selected, bf16],
+    )
+    pipeline = torch.nn.Module()
+    pipeline.transformer = _WanCheckpoint(transformer_config)
+    pipeline.transformer_2 = _WanCheckpoint(transformer_2_config, num_blocks=2)
+    WanTransformer3DModel._validate_w4a8_fallback_layers(pipeline.transformer, transformer_config)
+    WanTransformer3DModel._validate_w4a8_fallback_layers(pipeline.transformer_2, transformer_2_config)
+
+    loader = DiffusersPipelineLoader(
+        LoadConfig(),
+        OmniDiffusionConfig(model="", dtype=torch.bfloat16, quantization_config=transformer_config),
+    )
+    events = []
+    summaries = []
+
+    def process_weights(model, _target_device):
+        events.append("process")
+        for module in model.modules():
+            method = getattr(module, "quant_method", None)
+            if getattr(method, "is_w4a8_fallback_layer", False):
+                module._already_called_process_weights_after_loading = True
+
+    def capture_summary(message, *args):
+        rendered = message % args
+        summaries.append(rendered)
+        events.append(f"summary:{args[0]}")
+
+    loader._init_from_load_format = lambda *_args, **_kwargs: pipeline  # type: ignore[method-assign]
+    loader.load_weights = lambda _model: events.append("load")  # type: ignore[method-assign]
+    loader._process_weights_after_loading = process_weights  # type: ignore[method-assign]
+    loader._apply_skip_softmax_calibration = lambda _model: None  # type: ignore[method-assign]
+    mocker.patch(
+        "vllm_omni.diffusion.models.wan2_2.wan2_2_transformer.logger.info",
+        side_effect=capture_summary,
+    )
+
+    assert loader.load_model(load_device="cpu") is pipeline
+    assert events == ["load", "process", "summary:transformer", "summary:transformer_2"]
+    assert "component=transformer; selected=1 ['transformer.blocks.0.attn1.to_qkv']" in summaries[0]
+    assert "BF16 overrides=0 []" in summaries[0]
+    assert "weight/A8 processing state=ready (1/1 selected layers processed)" in summaries[0]
+    assert "component=transformer_2; selected=1 ['transformer_2.blocks.0.attn1.to_qkv']" in summaries[1]
+    assert "BF16 overrides=1 ['transformer_2.blocks.1.attn1.to_qkv']" in summaries[1]
+    assert "weight/A8 processing state=ready (1/1 selected layers processed)" in summaries[1]
+
+
+def test_wan_load_summary_does_not_claim_unprocessed_layer_is_ready(mocker):
+    selected = "blocks.0.attn1.to_qkv"
+    config = DiffusionMXFP4Config(w4a8_fallback_layers=[selected])
+    model = _WanCheckpoint(config)
+    WanTransformer3DModel._validate_w4a8_fallback_layers(model, config)
+    logger_info = mocker.patch("vllm_omni.diffusion.models.wan2_2.wan2_2_transformer.logger.info")
+
+    WanTransformer3DModel._log_w4a8_fallback_load_summary(model, "transformer")
+
+    message, *args = logger_info.call_args.args
+    rendered = message % tuple(args)
+    assert "weight/A8 processing state=not-ready (0/1 selected layers processed)" in rendered
diff --git a/tests/diffusion/streaming_interactive_generation/test_camera_interaction.py b/tests/diffusion/streaming_interactive_generation/test_camera_interaction.py
new file mode 100644
index 000000000..2c61aa805
--- /dev/null
+++ b/tests/diffusion/streaming_interactive_generation/test_camera_interaction.py
@@ -0,0 +1,434 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Tests for camera interaction handlers and coordinator registration."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.interaction.coordinator import InteractionCoordinator
+from vllm_omni.diffusion.interaction.mixin import InteractionMixin
+from vllm_omni.diffusion.interaction.modality_handlers.camera import CameraSession, SE3DeltaCameraHandler
+from vllm_omni.diffusion.interaction.modality_handlers.prompt import PromptSession
+from vllm_omni.diffusion.interaction.registry import STRUCTURED_HANDLER_REGISTRY
+from vllm_omni.diffusion.interaction.types import ChunkMediaSpec, resolve_event_frame_offset
+from vllm_omni.diffusion.worker.utils import StepRequestState
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+_FORWARD_VELOCITY = {
+    "mode": "velocity",
+    "data": {"translation": [0.0, 0.0, 0.05], "rotation": [0.0, 0.0, 0.0, 1.0]},
+}
+
+
+class _FakePromptPipeline(InteractionMixin):
+    """Minimal pipeline stub with prompt-update support."""
+
+    def __init__(self) -> None:
+        self.device = torch.device("cpu")
+        self.transformer = SimpleNamespace(dtype=torch.float32)
+        self.encode_prompt = MagicMock(return_value=(torch.full((1, 4, 2), 2.0), None))
+        self._interaction_coordinator = None
+
+    def peek_chunk_media(self, state: StepRequestState) -> ChunkMediaSpec:
+        del state
+        return ChunkMediaSpec(num_media_frames=8, fps=16.0, num_latent_frames=8)
+
+
+class _FakeLingBotPipeline(InteractionMixin):
+    """Minimal pipeline stub for LingBot camera registration."""
+
+    def __init__(self) -> None:
+        self._interaction_coordinator = None
+
+    def peek_chunk_media(self, state: StepRequestState) -> ChunkMediaSpec:
+        del state
+        return ChunkMediaSpec(num_media_frames=3, fps=3.0, num_latent_frames=3)
+
+
+def _make_state(*, request_id: str = "req-1") -> StepRequestState:
+    state = StepRequestState(
+        request_id=request_id,
+        sampling=SimpleNamespace(num_outputs_per_prompt=1, max_sequence_length=226),  # pyright: ignore[reportArgumentType]
+        prompt="hello",
+    )
+    state.prompt_embeds = torch.zeros(1, 4, 2)
+    state.extra = {}
+    return state
+
+
+def _boundary_at(previous_boundary_at: float | None, num_frames: int, fps: float) -> float:
+    if previous_boundary_at is None:
+        return 0.0
+    if fps <= 0:
+        return previous_boundary_at
+    return previous_boundary_at + num_frames / fps
+
+
+class TestCoordinatorResolution:
+    def test_helios_has_prompt_but_no_camera(self) -> None:
+        pipeline = _FakePromptPipeline()
+        od_config = SimpleNamespace(model_class_name="HeliosPipeline")
+        coordinator = InteractionCoordinator.build(pipeline, od_config)
+
+        assert coordinator.has_modality("prompt")
+        assert not coordinator.has_modality("camera")
+        assert "camera" not in STRUCTURED_HANDLER_REGISTRY["HeliosPipeline"]
+
+    def test_lingbot_registers_se3_camera_handler(self) -> None:
+        pipeline = _FakeLingBotPipeline()
+        od_config = SimpleNamespace(model_class_name="LingBotWorldCausalDMDPipeline")
+        coordinator = InteractionCoordinator.build(pipeline, od_config)
+
+        assert coordinator.has_modality("camera")
+        handler = coordinator.get_handler("camera")
+        assert isinstance(handler, SE3DeltaCameraHandler)
+        assert handler.lazy_initialize_session is False
+
+    def test_non_lazy_camera_apply_creates_session_without_enqueue(self) -> None:
+        """Camera apply must run before any enqueue to materialize identity poses."""
+        pipeline = _FakeLingBotPipeline()
+        od_config = SimpleNamespace(model_class_name="LingBotWorldCausalDMDPipeline")
+        coordinator = InteractionCoordinator.build(pipeline, od_config)
+        state = _make_state()
+
+        assert "camera" not in state.interaction_sessions
+        meta = coordinator.maybe_prepare_initial_session(state, pipeline)
+        session = state.interaction_sessions["camera"]
+        assert isinstance(session, CameraSession)
+        assert session.last_absolute_poses is not None
+        assert session.last_absolute_poses.shape == (3, 4, 4)
+        assert meta.started_event_ids == []
+        assert meta.active_event_ids == []
+
+    def test_lazy_prompt_apply_skips_without_enqueue(self) -> None:
+        pipeline = _FakePromptPipeline()
+        od_config = SimpleNamespace(model_class_name="HeliosPipeline")
+        coordinator = InteractionCoordinator.build(pipeline, od_config)
+        state = _make_state()
+
+        meta = coordinator.apply_at_chunk_boundary(state, boundary_at=0.0, chunk_index=0)
+        assert "prompt" not in state.interaction_sessions
+        assert meta.started_event_ids == []
+        assert meta.active_event_ids == []
+        assert meta.completed_event_ids == []
+
+        initial = coordinator.maybe_prepare_initial_session(state, pipeline)
+        assert "prompt" not in state.interaction_sessions
+        assert initial.started_event_ids == []
+
+    def test_unsupported_modality_includes_model_context(self) -> None:
+        pipeline = _FakePromptPipeline()
+        od_config = SimpleNamespace(model_class_name="HeliosPipeline")
+        coordinator = InteractionCoordinator.build(pipeline, od_config)
+
+        with pytest.raises(ValueError, match="HeliosPipeline"):
+            coordinator.enqueue(
+                _make_state(),
+                modality="camera",
+                event_id="cam-1",
+                received_at=0.0,
+                payload=_FORWARD_VELOCITY,
+                transition_chunks=None,
+            )
+
+    def test_enqueue_parts_rejects_unsupported_modality_atomically(self) -> None:
+        """Unsupported tracks in a composite event must not mutate any queues."""
+        pipeline = _FakePromptPipeline()
+        od_config = SimpleNamespace(model_class_name="HeliosPipeline")
+        coordinator = InteractionCoordinator.build(pipeline, od_config)
+        state = _make_state()
+        coordinator.enqueue(
+            state,
+            modality="prompt",
+            event_id="prior",
+            received_at=0.0,
+            payload={"prompt": "already-queued"},
+            transition_chunks=1,
+        )
+        prior_session = state.interaction_sessions["prompt"]
+        assert isinstance(prior_session, PromptSession)
+        prior = prior_session.pending_event
+        assert prior is not None
+        pipeline.encode_prompt.reset_mock()
+
+        with pytest.raises(ValueError, match="camera"):
+            coordinator.enqueue_parts(
+                state,
+                parts=[
+                    ("prompt", {"prompt": "should-not-replace"}),
+                    ("camera", _FORWARD_VELOCITY),
+                ],
+                event_id="composite-bad",
+                received_at=1.0,
+                transition_chunks=2,
+            )
+
+        pipeline.encode_prompt.assert_not_called()
+        pending = prior_session.pending_event
+        assert pending is not None
+        assert pending.event_id == "prior"
+        assert pending.prompt == "already-queued"
+        assert "camera" not in state.interaction_sessions
+
+        # Invalid camera payload must also fail before any track is queued.
+        dual = InteractionCoordinator(
+            {
+                "prompt": coordinator.get_handler("prompt"),
+                "camera": SE3DeltaCameraHandler(),
+            },
+            model_class_name="HeliosPipeline",
+        )
+        pipeline.encode_prompt.reset_mock()
+        with pytest.raises(ValueError, match="actions"):
+            dual.enqueue_parts(
+                state,
+                parts=[
+                    ("prompt", {"prompt": "should-not-replace"}),
+                    ("camera", {"mode": "velocity", "data": {"actions": ["w"]}}),
+                ],
+                event_id="composite-bad-payload",
+                received_at=2.0,
+                transition_chunks=2,
+            )
+        pipeline.encode_prompt.assert_not_called()
+        pending = prior_session.pending_event
+        assert pending is not None
+        assert pending.event_id == "prior"
+        assert pending.prompt == "already-queued"
+        assert "camera" not in state.interaction_sessions
+
+
+class TestCameraHandlers:
+    def test_rejects_wasd_actions_payload(self) -> None:
+        handler = SE3DeltaCameraHandler()
+        state = _make_state()
+        with pytest.raises(ValueError, match="actions"):
+            handler.enqueue(
+                state,
+                event_id="cam-wasd",
+                received_at=0.0,
+                payload={"mode": "velocity", "data": {"actions": ["w"]}},
+                transition_chunks=None,
+            )
+
+    def test_target_transition_progress_and_se3_projection(self) -> None:
+        handler = SE3DeltaCameraHandler()
+        state = _make_state()
+        handler.enqueue(
+            state,
+            event_id="cam-1",
+            received_at=0.0,
+            payload={
+                "mode": "target",
+                "data": {"translation": [0.0, 0.0, 3.0], "rotation": [0.0, 0.0, 0.0, 1.0]},
+            },
+            transition_chunks=2,
+        )
+
+        meta = handler.apply_at_chunk_boundary(
+            state,
+            chunk_index=0,
+            num_media_frames=4,
+            fps=16.0,
+            boundary_at=0.25,
+        )
+        session = state.interaction_sessions["camera"]
+        assert isinstance(session, CameraSession)
+        assert session.last_absolute_poses is not None
+        assert meta is not None
+        assert meta.started_event_ids == ["cam-1"]
+        assert meta.active_event_ids == ["cam-1"]
+        assert meta.completed_event_ids == []
+        assert session.last_absolute_poses.shape == (4, 4, 4)
+
+        meta2 = handler.apply_at_chunk_boundary(
+            state,
+            chunk_index=1,
+            num_media_frames=4,
+            fps=16.0,
+            boundary_at=0.5,
+        )
+        assert meta2 is not None
+        assert meta2.started_event_ids == []
+        assert meta2.active_event_ids == []
+        assert meta2.completed_event_ids == ["cam-1"]
+        assert session.active_event is None
+        assert session.current_pose.translation[2] == pytest.approx(3.0)
+        assert session.last_absolute_poses is not None
+        assert session.last_absolute_poses.shape == (4, 4, 4)
+
+    def test_single_chunk_target_completes_once(self) -> None:
+        handler = SE3DeltaCameraHandler()
+        # Include a non-power-of-two frame count (7) so float reciprocal drift
+        # would previously miss the final snap / completion ack.
+        for num_frames in (8, 7):
+            state = _make_state()
+            handler.enqueue(
+                state,
+                event_id="cam-fast",
+                received_at=0.0,
+                payload={
+                    "mode": "target",
+                    "data": {"translation": [1.0, 0.0, 0.0], "rotation": [0.0, 0.0, 0.0, 1.0]},
+                },
+                transition_chunks=1,
+            )
+            meta = handler.apply_at_chunk_boundary(
+                state,
+                chunk_index=0,
+                num_media_frames=num_frames,
+                fps=16.0,
+                boundary_at=0.5,
+            )
+            assert meta is not None
+            assert meta.started_event_ids == ["cam-fast"]
+            assert meta.active_event_ids == []
+            assert meta.completed_event_ids == ["cam-fast"]
+
+            meta2 = handler.apply_at_chunk_boundary(
+                state,
+                chunk_index=1,
+                num_media_frames=num_frames,
+                fps=16.0,
+                boundary_at=1.0,
+            )
+            assert meta2 is not None
+            assert meta2.started_event_ids == []
+            assert meta2.active_event_ids == []
+            assert meta2.completed_event_ids == []
+            session = state.interaction_sessions["camera"]
+            assert isinstance(session, CameraSession)
+            assert session.current_pose.translation[0] == pytest.approx(1.0)
+
+    def test_velocity_composes_structural_se3_delta(self) -> None:
+        handler = SE3DeltaCameraHandler()
+        state = _make_state()
+        handler.enqueue(
+            state,
+            event_id="vel-1",
+            received_at=0.0,
+            payload=_FORWARD_VELOCITY,
+            transition_chunks=None,
+        )
+
+        meta0 = handler.apply_at_chunk_boundary(state, chunk_index=0, num_media_frames=3, fps=16.0, boundary_at=0.0)
+        assert meta0 is not None
+        assert meta0.started_event_ids == ["vel-1"]
+        assert meta0.active_event_ids == ["vel-1"]
+        session = state.interaction_sessions["camera"]
+        assert isinstance(session, CameraSession)
+        assert session.current_pose.translation[2] == pytest.approx(0.15)
+        assert session.last_absolute_poses is not None
+        assert session.last_absolute_poses.shape == (3, 4, 4)
+        torch.testing.assert_close(
+            session.last_absolute_poses[0, :3, 3],
+            torch.tensor([0.0, 0.0, 0.05], dtype=torch.float64),
+            atol=1e-6,
+            rtol=0,
+        )
+        torch.testing.assert_close(
+            session.last_absolute_poses[1, :3, 3],
+            torch.tensor([0.0, 0.0, 0.10], dtype=torch.float64),
+            atol=1e-6,
+            rtol=0,
+        )
+
+        meta1 = handler.apply_at_chunk_boundary(state, chunk_index=1, num_media_frames=2, fps=16.0, boundary_at=0.125)
+        assert meta1 is not None
+        assert meta1.active_event_ids == ["vel-1"]
+        assert session.current_pose.translation[2] == pytest.approx(0.25)
+
+    def test_velocity_completed_when_replaced_by_target(self) -> None:
+        handler = SE3DeltaCameraHandler()
+        state = _make_state()
+        handler.enqueue(
+            state,
+            event_id="vel-1",
+            received_at=0.0,
+            payload=_FORWARD_VELOCITY,
+            transition_chunks=None,
+        )
+        meta0 = handler.apply_at_chunk_boundary(
+            state,
+            chunk_index=0,
+            num_media_frames=2,
+            fps=16.0,
+            boundary_at=0.0,
+        )
+        assert meta0 is not None
+        assert meta0.active_event_ids == ["vel-1"]
+
+        handler.enqueue(
+            state,
+            event_id="tgt-1",
+            received_at=0.1,
+            payload={
+                "mode": "target",
+                "data": {"translation": [0.0, 0.0, 0.0], "rotation": [0.0, 0.0, 0.0, 1.0]},
+            },
+            transition_chunks=0,
+        )
+        meta1 = handler.apply_at_chunk_boundary(
+            state,
+            chunk_index=1,
+            num_media_frames=2,
+            fps=16.0,
+            boundary_at=0.125,
+        )
+        assert meta1 is not None
+        assert meta1.started_event_ids == ["tgt-1"]
+        assert "vel-1" in meta1.completed_event_ids
+        assert meta1.active_event_ids == []
+
+    def test_same_chunk_velocity_then_target_by_frame_offset(self) -> None:
+        handler = SE3DeltaCameraHandler()
+        state = _make_state()
+        fps = 10.0
+        boundary = 0.0
+        handler.enqueue(
+            state,
+            event_id="vel",
+            received_at=0.0,
+            payload=_FORWARD_VELOCITY,
+            transition_chunks=None,
+        )
+        handler.enqueue(
+            state,
+            event_id="tgt",
+            received_at=0.5,
+            payload={
+                "mode": "target",
+                "data": {"translation": [0.0, 0.0, 0.0], "rotation": [0.0, 0.0, 0.0, 1.0]},
+            },
+            transition_chunks=0,
+        )
+        state.interaction_sessions["camera"].last_boundary_at = boundary
+        meta = handler.apply_at_chunk_boundary(
+            state,
+            chunk_index=0,
+            num_media_frames=10,
+            fps=fps,
+            boundary_at=_boundary_at(boundary, 10, fps),
+        )
+        assert meta is not None
+        assert meta.started_event_ids == ["vel", "tgt"]
+        assert meta.completed_event_ids == ["vel", "tgt"]
+        assert meta.active_event_ids == []
+        session = state.interaction_sessions["camera"]
+        assert isinstance(session, CameraSession)
+        assert session.active_event is None
+        assert session.current_pose.translation[2] == pytest.approx(0.0)
+
+
+class TestResolveEventFrameOffset:
+    def test_clamps_and_floors(self) -> None:
+        assert resolve_event_frame_offset(received_at=0.0, previous_boundary_at=None, num_frames=8, fps=16.0) == 0
+        assert resolve_event_frame_offset(received_at=0.1, previous_boundary_at=0.0, num_frames=8, fps=16.0) == 1
+        assert resolve_event_frame_offset(received_at=10.0, previous_boundary_at=0.0, num_frames=8, fps=16.0) == 7
+        assert resolve_event_frame_offset(received_at=-1.0, previous_boundary_at=0.0, num_frames=8, fps=16.0) == 0
diff --git a/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py b/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py
index 7780f0475..d3b46a00d 100644
--- a/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py
+++ b/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py
@@ -78,7 +78,7 @@ def _make_diffusion_request_state(*, request_id: str = "req-1", fps: int | None
         prompt="hello",
     )
     state.prompt_embeds = torch.zeros(1, 4, 2)
-    state.extra = {"window_num_frames": 8}
+    state.extra = {"window_num_frames": 8, "num_latent_frames_per_chunk": 3}
     return state
 
 
@@ -109,7 +109,12 @@ def _make_diffusion_model_runner(
     # instances; unit tests of submit_interaction stub this. Stepwise path tests
     # rebind to the real method.
     runner._supports_step_mode = lambda: True
-    runner._interaction_coordinator = None
+    # Mirror load_model: coordinator is always present once the runner is "loaded".
+    # Build now so handlers capture the pipeline's current encode_prompt (tests may
+    # rebind the mock before calling this helper).
+    runner._interaction_coordinator = InteractionCoordinator.build(pipeline, runner.od_config)
+    if hasattr(pipeline, "_interaction_coordinator"):
+        pipeline._interaction_coordinator = runner._interaction_coordinator
     return runner
 
 
@@ -155,6 +160,7 @@ class TestPromptUpdateExecution:
             supports_step_execution = True
 
         runner = _make_diffusion_model_runner(pipeline=_UnsupportedPipeline())
+        runner.state_cache["req-1"] = _make_diffusion_request_state()
         with pytest.raises(ValueError, match="not supported"):
             runner.submit_interaction("req-1", _prompt_interaction())
 
@@ -168,25 +174,98 @@ class TestPromptUpdateExecution:
         "interaction",
         [
             {},
-            {"multi_modal_data": {"camera": {"type": "pose"}}},
-            {"event": {"prompt": "updated", "multi_modal_data": {"camera": {"type": "pose"}}}},
-            {"event": {"prompt": "updated", "multi_modal_data": {}}},
-            {"event": {"prompt": "updated", "multi_modal_data": None}},
-            {"event": {"prompt": "updated", "multi_modal_data": "bad"}},
+            {"event_id": "bad", "event": {"multi_modal_data": {}}},
+            {"event_id": "bad", "event": {"multi_modal_data": None}},
+            {"event_id": "bad", "event": {"prompt": "updated", "multi_modal_data": "bad"}},
+            {
+                "event_id": "cam-only",
+                "event": {
+                    "multi_modal_data": {
+                        "camera": {
+                            "mode": "velocity",
+                            "data": {"translation": [0.0, 0.0, 0.05], "rotation": [0.0, 0.0, 0.0, 1.0]},
+                        },
+                    }
+                },
+            },
+            {
+                "event_id": "cam-and-prompt",
+                "event": {
+                    "prompt": "updated",
+                    "multi_modal_data": {
+                        "camera": {
+                            "mode": "velocity",
+                            "data": {"translation": [0.0, 0.0, 0.05], "rotation": [0.0, 0.0, 0.0, 1.0]},
+                        },
+                    },
+                },
+            },
         ],
     )
-    def test_runner_interaction_rejects_structural_payloads_until_implemented(
+    def test_runner_rejects_unsupported_interactions(
         self,
         pipeline: HeliosPipeline,
         interaction: dict[str, Any],
     ) -> None:
-        """Unsupported interaction dict shapes are preserved to and rejected by the runner."""
+        """Helios has no camera handler; malformed / unsupported payloads are rejected."""
         runner = _make_diffusion_model_runner(pipeline=pipeline)
-        runner.state_cache["req-1"] = _make_diffusion_request_state()
+        state = _make_diffusion_request_state()
+        runner.state_cache["req-1"] = state
 
-        with pytest.raises(NotImplementedError, match="Only text-only prompt update interactions"):
+        with pytest.raises((ValueError, KeyError, AttributeError, TypeError)):
             runner.submit_interaction("req-1", cast(Any, interaction))
 
+        # Rejected composite/malformed events must leave interaction queues unchanged.
+        pipeline.encode_prompt.assert_not_called()  # pyright: ignore[reportAttributeAccessIssue]
+        assert "prompt" not in state.interaction_sessions
+        assert "camera" not in state.interaction_sessions
+
+    def test_rejected_composite_leaves_existing_prompt_queue_unchanged(
+        self,
+        pipeline: HeliosPipeline,
+    ) -> None:
+        """Helios must not apply a composite prompt when camera modality is unsupported."""
+        runner = _make_diffusion_model_runner(pipeline=pipeline)
+        state = _make_diffusion_request_state()
+        runner.state_cache["req-1"] = state
+        runner.submit_interaction("req-1", _prompt_interaction("already-queued", event_id="prior"))
+        session = state.interaction_sessions["prompt"]
+        assert isinstance(session, PromptSession)
+        prior = session.pending_event
+        assert prior is not None
+        assert prior.event_id == "prior"
+        pipeline.encode_prompt.reset_mock()  # pyright: ignore[reportAttributeAccessIssue]
+
+        with pytest.raises(ValueError, match="camera"):
+            runner.submit_interaction(
+                "req-1",
+                cast(
+                    Any,
+                    {
+                        "event_id": "cam-and-prompt",
+                        "event": {
+                            "prompt": "should-not-replace",
+                            "multi_modal_data": {
+                                "camera": {
+                                    "mode": "velocity",
+                                    "data": {
+                                        "translation": [0.0, 0.0, 0.05],
+                                        "rotation": [0.0, 0.0, 0.0, 1.0],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ),
+            )
+
+        pipeline.encode_prompt.assert_not_called()  # pyright: ignore[reportAttributeAccessIssue]
+        pending = session.pending_event
+        assert pending is not None
+        assert pending.event_id == "prior"
+        assert pending.prompt == "already-queued"
+        assert "camera" not in state.interaction_sessions
+
     @pytest.mark.parametrize("model_class_name", ["HeliosPipeline", "HeliosPyramidPipeline"])
     def test_coordinator_registers_prompt_for_helios_aliases(
         self,
@@ -367,7 +446,11 @@ class TestPromptUpdateExecution:
                         f"that use the chunk media timeline, got {fps!r} "
                         f"(request_id={state.request_id!r})"
                     )
-                return ChunkMediaSpec(num_frames=int(state.extra["window_num_frames"]), fps=float(fps))
+                return ChunkMediaSpec(
+                    num_media_frames=int(state.extra["window_num_frames"]),
+                    fps=float(fps),
+                    num_latent_frames=int(state.extra["window_num_frames"]),
+                )
 
             def prepare_encode(self, state: StepRequestState) -> StepRequestState:
                 state.prompt_embeds = torch.zeros(1, 4, 2)
diff --git a/tests/diffusion/test_diffusion_config_propagation.py b/tests/diffusion/test_diffusion_config_propagation.py
index 23ff796e2..7421dfb79 100644
--- a/tests/diffusion/test_diffusion_config_propagation.py
+++ b/tests/diffusion/test_diffusion_config_propagation.py
@@ -11,6 +11,7 @@ import pytest
 import torch
 
 from vllm_omni.config.config_factory import StageConfigFactory
+from vllm_omni.config.omni_config import extract_diffusion_stage_config_kwargs
 from vllm_omni.diffusion.data import (
     DiffusionParallelConfig,
     OmniDiffusionConfig,
@@ -25,6 +26,12 @@ from vllm_omni.diffusion.model_metadata import (
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+@pytest.fixture(autouse=True)
+def _local_model_paths(monkeypatch):
+    # These tests exercise config transport, not model repository resolution.
+    monkeypatch.setattr("vllm_omni.diffusion.data.get_model_path", lambda model, revision: model)
+
+
 def _roundtrip_diffusion_config(**kwargs) -> OmniDiffusionConfig:
     """Simulate the real path: create_default_diffusion → OmniDiffusionConfig.
 
@@ -34,7 +41,8 @@ def _roundtrip_diffusion_config(**kwargs) -> OmniDiffusionConfig:
     """
     stages = StageConfigFactory.create_default_diffusion(kwargs)
     engine_args = dict(stages[0]["engine_args"])
-    return OmniDiffusionConfig.from_kwargs(**engine_args)
+    diffusion_kwargs = extract_diffusion_stage_config_kwargs(engine_args, stage_id=0)
+    return OmniDiffusionConfig(**{name: value for name, value in diffusion_kwargs.items() if value is not None})
 
 
 class TestParallelConfigPropagation:
@@ -51,9 +59,7 @@ class TestParallelConfigPropagation:
         stages = StageConfigFactory.create_default_diffusion({"parallel_config": pc, "model": "x"})
         assert stages[0]["runtime"]["devices"] == "0,1,2,3"
 
-        # Let __post_init__ reconstruct from dict (real code path)
-        ea = dict(stages[0]["engine_args"])
-        od = OmniDiffusionConfig.from_kwargs(**ea)
+        od = _roundtrip_diffusion_config(parallel_config=pc, model="x")
         assert od.parallel_config.tensor_parallel_size == 4
         assert od.parallel_config.world_size == 4
 
@@ -187,6 +193,17 @@ class TestCreateDefaultDiffusion:
         assert od.max_num_batched_tokens == 2048
         assert od.max_model_len == 4096
 
+    @pytest.mark.parametrize(
+        ("field_name", "value"),
+        [
+            ("enable_sleep_mod", None),
+            ("enable_lora", True),
+        ],
+    )
+    def test_unowned_raw_field_is_rejected(self, field_name, value):
+        with pytest.raises(ValueError, match=field_name):
+            StageConfigFactory.create_default_diffusion({"model": "x", field_name: value})
+
 
 def test_qwen_image_edit_plus_sets_generic_multimodal_limit():
     od_config = OmniDiffusionConfig(model="Qwen/Qwen-Image-Edit-2511", model_class_name="QwenImageEditPlusPipeline")
diff --git a/tests/diffusion/test_diffusion_engine_rpc_routing.py b/tests/diffusion/test_diffusion_engine_rpc_routing.py
index 119939ae2..bb64e5f01 100644
--- a/tests/diffusion/test_diffusion_engine_rpc_routing.py
+++ b/tests/diffusion/test_diffusion_engine_rpc_routing.py
@@ -474,12 +474,13 @@ async def test_cancelled_future_does_not_kill_busy_loop():
 
 
 @pytest.mark.asyncio
-async def test_native_kv_reservation_error_wakes_stream_without_killing_busy_loop():
+@pytest.mark.parametrize("error_type", [ValueError, RuntimeError])
+async def test_native_kv_reservation_error_wakes_stream_without_killing_busy_loop(error_type):
     loop = asyncio.get_running_loop()
     engine = _make_engine_with_loop(loop)
 
     def fail_reservation(*args, **kwargs):
-        raise RuntimeError("native allocation bug")
+        raise error_type("native allocation bug")
 
     engine.scheduler._diffusion_kv_manager = SimpleNamespace(
         has_request=lambda request_id: False,
diff --git a/tests/diffusion/test_diffusion_model_runner.py b/tests/diffusion/test_diffusion_model_runner.py
index 69a9e4395..f5e4aaa2c 100644
--- a/tests/diffusion/test_diffusion_model_runner.py
+++ b/tests/diffusion/test_diffusion_model_runner.py
@@ -431,7 +431,13 @@ def test_update_states_carries_prepared_layout() -> None:
     request.prepared_layout = prepared_layout
     scheduler_output = SimpleNamespace(
         finished_req_ids=set(),
-        scheduled_new_reqs=[SimpleNamespace(request_id=request.request_id, req=request)],
+        scheduled_new_reqs=[
+            SimpleNamespace(
+                request_id=request.request_id,
+                req=request,
+                diffusion_kv_metadata=None,
+            )
+        ],
         scheduled_cached_reqs=SimpleNamespace(request_ids=[]),
     )
 
diff --git a/tests/diffusion/test_diffusion_scheduler.py b/tests/diffusion/test_diffusion_scheduler.py
index 20a2f0384..38da458b0 100644
--- a/tests/diffusion/test_diffusion_scheduler.py
+++ b/tests/diffusion/test_diffusion_scheduler.py
@@ -11,6 +11,7 @@ import torch
 import vllm.v1.core.single_type_kv_cache_manager as native_kv_managers
 from pytest_mock import MockerFixture
 from vllm.v1.kv_cache_interface import FullAttentionSpec, KVCacheConfig, KVCacheGroupSpec
+from vllm.v1.outputs import KVConnectorOutput
 
 from tests.helpers.kv_layout import build_kv_cache_tensor
 from vllm_omni.diffusion.data import DiffusionOutput, DiffusionRequestAbortedError
@@ -136,6 +137,55 @@ def _attach_diffusion_kv(request: OmniDiffusionRequest, *, seq_len: int = 8) ->
     )
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("scheduler_cls", [RequestScheduler, StepScheduler])
+@pytest.mark.parametrize("failure", ["timeout", "registration"])
+async def test_single_native_kv_failure_reaches_output_stream(mocker, scheduler_cls, failure):
+    from vllm_omni.diffusion.diffusion_kv.kv_connector import KVTransferRegistrationError
+
+    scheduler = scheduler_cls()
+    _initialize_paged_scheduler(scheduler, max_num_seqs=1)
+    connector = mocker.Mock()
+    connector.get_num_new_matched_tokens.return_value = (4, True)
+    connector.request_finished.return_value = (False, None)
+    scheduler._kv_connector = connector
+    request = _make_request("failed")
+    _attach_diffusion_kv(request)
+    request.diffusion_kv_requests[0].prompt_token_ids = [1, 2, 3, 4]
+    request.kv_transfer_params = {"num_transfer_tokens": 4, "do_remote_prefill": True}
+    scheduler.add_request(request)
+    if failure == "registration":
+        mocker.patch(
+            "vllm_omni.diffusion.sched.base_scheduler.commit_kv_load",
+            side_effect=KVTransferRegistrationError("registration failed"),
+        )
+    engine = object.__new__(DiffusionEngine)
+    engine.scheduler = scheduler
+    engine.od_config = SimpleNamespace(diffusion_kv_mode=DiffusionKVCacheMode.PAGED_SCHEDULER)
+    engine.execution_mode = (
+        DiffusionExecutionMode.STEP_BATCH if scheduler_cls is StepScheduler else DiffusionExecutionMode.REQUEST_BATCH
+    )
+    engine.abort_queue = queue.Queue()
+    engine._cv = threading.Condition()
+    engine.main_loop = asyncio.get_running_loop()
+    stream = asyncio.Queue()
+    engine._out_streams = {"failed": stream}
+    engine.executor = mocker.Mock()
+    engine.executor.prepare_kv_for_forward.return_value = KVConnectorOutput()
+    scheduled = scheduler.schedule()
+    engine._prepare_kv_for_forward(scheduled)
+    assert scheduled.scheduled_request_ids == []
+    output = BatchRunnerOutput.from_list([])
+    finished = scheduler.update_from_output(scheduled, output)
+    engine._emit_outputs(finished, scheduled.scheduled_request_ids, output)
+    terminal = await asyncio.wait_for(stream.get(), timeout=1)
+    assert terminal.finished
+    assert terminal.error == ("Timed out receiving diffusion KV" if failure == "timeout" else "registration failed")
+    assert scheduler.get_request_state("failed") is None
+    # Reporting failure must not recycle pages that the sender can still write.
+    assert scheduler._diffusion_kv_manager.has_request("failed") == (failure == "timeout")
+
+
 class _StubScheduler:
     def __init__(self, request: OmniDiffusionRequest, output) -> None:
         self._request = request
@@ -602,16 +652,22 @@ class TestRequestScheduler:
         assert sched_output.finished_req_ids == {"impossible"}
         assert _new_ids(sched_output) == ["schedulable"]
 
-    def test_diffusion_kv_internal_allocation_error_finishes_request(self, monkeypatch) -> None:
+    def test_diffusion_kv_internal_allocation_error_is_request_scoped(self, monkeypatch) -> None:
         _initialize_paged_scheduler(self.scheduler)
         request = _make_request("native-error")
         _attach_diffusion_kv(request)
         self.scheduler.add_request(request)
         manager = self.scheduler._diffusion_kv_manager
         assert manager is not None
+        reserve_request = manager.reserve_request
+        next_request = _make_request("after-error")
+        _attach_diffusion_kv(next_request)
+        self.scheduler.add_request(next_request)
 
         def raise_native_error(*args, **kwargs):
-            raise ValueError("native allocation bug")
+            if args[0] == "native-error":
+                raise ValueError("native allocation bug")
+            return reserve_request(*args, **kwargs)
 
         monkeypatch.setattr(
             manager,
@@ -619,14 +675,150 @@ class TestRequestScheduler:
             raise_native_error,
         )
 
-        sched_output = self.scheduler.schedule()
-
+        output = self.scheduler.schedule()
         state = self.scheduler.get_request_state("native-error")
-        assert state is not None
         assert state.status == DiffusionRequestStatus.FINISHED_ERROR
         assert state.error == "native allocation bug"
-        assert sched_output.finished_req_ids == {"native-error"}
-        assert sched_output.scheduled_request_ids == []
+        assert output.finished_req_ids == {"native-error"}
+        assert _new_ids(output) == ["after-error"]
+        assert not manager.has_request("native-error")
+
+    @pytest.mark.parametrize("action", ["abort", "timeout", "preempt"])
+    def test_diffusion_kv_loading_defers_free_and_blocks_preempt(self, mocker: MockerFixture, action: str) -> None:
+        _initialize_paged_scheduler(self.scheduler, num_blocks=5)
+        connector = mocker.Mock()
+        connector.get_num_new_matched_tokens.return_value = (4, True)
+        connector.request_finished.return_value = (False, None)
+        self.scheduler._kv_connector = connector
+        request = _make_request("loading")
+        request.diffusion_kv_requests = tuple(
+            DiffusionKVRequest(
+                f"loading/diffusion-kv/{i}",
+                sequence_id=i,
+                prefix_len=4,
+                target_len=4,
+                seq_len=8,
+                prompt_token_ids=[1, 2, 3, 4],
+            )
+            for i in range(2)
+        )
+        request.kv_transfer_params = {"num_transfer_tokens": 4, "do_remote_prefill": True}
+        manager = self.scheduler._diffusion_kv_manager
+        assert manager is not None
+        pool = manager.native_manager.block_pool
+        initial_free_blocks = pool.get_num_free_blocks()
+        self.scheduler.add_request(request)
+        scheduled = self.scheduler.schedule()
+        internal_ids = {f"loading/diffusion-kv/{i}" for i in range(2)}
+        assert scheduled.kv_transfer_request_ids == internal_ids
+        assert pool.get_num_free_blocks() == initial_free_blocks - 4
+        metadata = manager.get_metadata("loading")
+        state = self.scheduler.get_request_state("loading")
+        free_request = mocker.spy(manager, "free_request")
+
+        if action == "abort":
+            self.scheduler.finish_requests("loading", DiffusionRequestStatus.FINISHED_ABORTED)
+        elif action == "timeout":
+            assert self.scheduler.fail_incomplete_kv_loads(internal_ids) == {"loading"}
+            assert state.error == "Timed out receiving diffusion KV"
+        if action != "preempt":
+            assert state.is_finished()
+            assert self.scheduler.pop_request_state("loading") is state
+            with pytest.raises(ValueError, match="already active"):
+                self.scheduler.add_request(request)
+            assert self.scheduler.get_diffusion_kv_cleanup_targets(["loading"]) == []
+
+        # Empty, unrelated, and partial completion retain both CFG rows even
+        # after the frontend has consumed and popped the terminal request.
+        for finished in (set(), {"other/diffusion-kv/0"}, {"loading/diffusion-kv/0"}):
+            self.scheduler.update_kv_connector_output(KVConnectorOutput(finished_recving=finished))
+            assert "loading" in self.scheduler._kv_loading_request_ids
+            assert self.scheduler.preempt_request("loading") is False
+            assert not self.scheduler.completed_kv_drains()
+            assert manager.has_request("loading")
+            assert manager.get_metadata("loading") == metadata
+            assert pool.get_num_free_blocks() == initial_free_blocks - 4
+            free_request.assert_not_called()
+            connector.request_finished.assert_not_called()
+
+        # CFG completion may arrive in different polls, after rank aggregation.
+        self.scheduler.update_kv_connector_output(KVConnectorOutput(finished_recving={"loading/diffusion-kv/1"}))
+        assert "loading" not in self.scheduler._kv_loading_request_ids
+        if action == "preempt":
+            assert self.scheduler.preempt_request("loading") is True
+            assert state.status == DiffusionRequestStatus.PREEMPTED
+            assert manager.get_metadata("loading") == metadata
+            self.scheduler.finish_requests("loading", DiffusionRequestStatus.FINISHED_ABORTED)
+        else:
+            assert self.scheduler.completed_kv_drains() == {"loading"}
+            assert self.scheduler.get_diffusion_kv_cleanup_targets(["loading"]) == [
+                ("loading", metadata.allocation_generation)
+            ]
+            self.scheduler.release_kv_drains({"loading"})
+        assert not self.scheduler._running and not self.scheduler._waiting
+        assert self.scheduler._kv_finished_request_ids == internal_ids
+        assert connector.request_finished.call_count == 2
+        free_request.assert_called_once_with("loading")
+        assert not manager.has_request("loading")
+        assert pool.get_num_free_blocks() == initial_free_blocks
+
+    @pytest.mark.parametrize("cancel", [False, True])
+    def test_engine_timeout_keeps_serving_and_reclaims_late_receive(self, mocker, cancel):
+        _initialize_paged_scheduler(self.scheduler, num_blocks=16, max_num_seqs=2)
+        connector = mocker.Mock()
+        connector.get_num_new_matched_tokens.return_value = (4, True)
+        connector.request_finished.return_value = (False, None)
+        self.scheduler._kv_connector = connector
+        for rid in ("slow", "ready"):
+            req = _make_request(rid)
+            _attach_diffusion_kv(req)
+            req.diffusion_kv_requests[0].prompt_token_ids = [1, 2, 3, 4]
+            req.kv_transfer_params = {"num_transfer_tokens": 4, "do_remote_prefill": True}
+            self.scheduler.add_request(req)
+        scheduled = self.scheduler.schedule()
+        engine = object.__new__(DiffusionEngine)
+        engine.scheduler = self.scheduler
+        engine.od_config = SimpleNamespace(diffusion_kv_mode=DiffusionKVCacheMode.PAGED_SCHEDULER)
+        engine.abort_queue = queue.Queue()
+        engine._cv = threading.Condition()
+        if cancel:
+            engine.abort_queue.put("slow")
+        engine.executor = mocker.Mock()
+        engine.executor.prepare_kv_for_forward.side_effect = [
+            KVConnectorOutput(finished_recving={"ready/diffusion-kv/0"}),
+            KVConnectorOutput(finished_recving={"slow/diffusion-kv/0"}),
+        ]
+        fail_engine = mocker.patch.object(engine, "_fail_engine")
+        engine._prepare_kv_for_forward(scheduled)
+        assert scheduled.scheduled_request_ids == ["ready"]
+        assert scheduled.finished_req_ids == {"slow"}
+        expected_status = DiffusionRequestStatus.FINISHED_ABORTED if cancel else DiffusionRequestStatus.FINISHED_ERROR
+        assert self.scheduler.get_request_state("slow").status == expected_status
+        assert self.scheduler._diffusion_kv_manager.has_request("slow")
+        engine._remove_diffusion_kv_requests(["slow"])
+        engine.executor.remove_diffusion_kv_requests.assert_not_called()
+        self.scheduler.pop_request_state("slow")
+        generation = self.scheduler._kv_request_generations["slow"]
+        engine._prepare_kv_for_forward(self.scheduler.schedule())
+        engine.executor.remove_diffusion_kv_requests.assert_called_once_with([("slow", generation)])
+        assert not self.scheduler._diffusion_kv_manager.has_request("slow")
+        assert self.scheduler._diffusion_kv_manager.has_request("ready")
+        fail_engine.assert_not_called()
+
+    def test_slow_kv_match_does_not_block_later_request(self, mocker):
+        _initialize_paged_scheduler(self.scheduler, max_num_seqs=2)
+        connector = mocker.Mock()
+        connector.get_num_new_matched_tokens.side_effect = lambda req, _: (
+            (None, False) if req.request_id.startswith("slow/") else (0, False)
+        )
+        self.scheduler._kv_connector = connector
+        for rid in ("slow", "ready"):
+            request = _make_request(rid)
+            _attach_diffusion_kv(request)
+            self.scheduler.add_request(request)
+        output = self.scheduler.schedule()
+        assert _new_ids(output) == ["ready"]
+        assert list(self.scheduler._waiting) == ["slow"]
 
     def test_diffusion_kv_preemption_retains_allocation(self) -> None:
         _initialize_paged_scheduler(self.scheduler, num_blocks=3)
diff --git a/tests/diffusion/test_diffusion_step_pipeline.py b/tests/diffusion/test_diffusion_step_pipeline.py
index 28bba6e4d..0b22f6411 100644
--- a/tests/diffusion/test_diffusion_step_pipeline.py
+++ b/tests/diffusion/test_diffusion_step_pipeline.py
@@ -103,6 +103,78 @@ class _StepPipeline:
         return DiffusionOutput(output=torch.tensor([state.step_index], dtype=torch.float32))
 
 
+class _ChunkedStepPipeline(_StepPipeline):
+    """Streaming stub: two chunks of two denoise steps each, one decode per chunk."""
+
+    supports_chunk_step_grouping = False
+
+    def prepare_encode(self, state, **kwargs):
+        del kwargs
+        self.prepare_calls += 1
+        state.timesteps = [torch.tensor(10), torch.tensor(5), torch.tensor(10), torch.tensor(5)]
+        state.latents = torch.tensor([0.0])
+        state.prompt_embeds = torch.tensor([[0.0, 0.0], [1.0, 1.0]])
+        state.chunk_num_steps = 2
+        state.total_chunks = 2
+        state.chunk_index = 0
+        state.step_in_chunk = 0
+        return state
+
+    def step_scheduler(self, state, noise_pred, **kwargs):
+        del noise_pred, kwargs
+        self.scheduler_calls += 1
+        state.step_in_chunk += 1
+        state.step_index = state.step_in_chunk
+
+    def post_decode(self, state, **kwargs):
+        del kwargs
+        self.decode_calls += 1
+        result = DiffusionOutput(output=torch.tensor([float(state.chunk_index)]))
+        state.chunk_index += 1
+        state.step_in_chunk = 0
+        return result
+
+
+class _BatchDependentChunkPipeline(_ChunkedStepPipeline):
+    """Streaming stub whose noise depends on the batch's latents and timesteps, so a stale batch shows."""
+
+    def __init__(self):
+        super().__init__()
+        self.seen: list[tuple[float, float]] = []
+
+    def prepare_encode(self, state, **kwargs):
+        super().prepare_encode(state, **kwargs)
+        state.latents = torch.tensor([1.0])
+        return state
+
+    def denoise_step(self, input_batch, **kwargs):
+        self.denoise_calls += 1
+        latent = float(input_batch.latents.reshape(-1)[0])
+        timestep = float(input_batch.timesteps.reshape(-1)[0])
+        self.seen.append((latent, timestep))
+        return torch.full((input_batch.latents.shape[0], 1), latent + timestep)
+
+    def step_scheduler(self, state, noise_pred, **kwargs):
+        del kwargs
+        self.scheduler_calls += 1
+        state.latents = state.latents + noise_pred.reshape(-1)[0]
+        state.step_in_chunk += 1
+        state.step_index = state.step_in_chunk
+
+    def post_decode(self, state, **kwargs):
+        self.final_latent = state.latents.reshape(-1)[0].clone()
+        return super().post_decode(state, **kwargs)
+
+
+class _FailsMidChunkPipeline(_ChunkedStepPipeline):
+    """Streaming stub whose second denoise step of the first chunk raises."""
+
+    def step_scheduler(self, state, noise_pred, **kwargs):
+        super().step_scheduler(state, noise_pred, **kwargs)
+        if state.chunk_index == 0 and state.step_in_chunk == 2:
+            raise RuntimeError("boom mid chunk")
+
+
 class _PerRequestErrorStepPipeline(_StepPipeline):
     def prepare_encode(self, state, **kwargs):
         if state.prompt == "fail-prepare":
@@ -327,8 +399,9 @@ def _make_vllm_config():
 
 def _make_runner(
     diffusion_kv_mode: DiffusionKVCacheMode = DiffusionKVCacheMode.DENSE_LEGACY,
+    runner_cls: type[DiffusionModelRunner] = DiffusionModelRunner,
 ):
-    runner = object.__new__(DiffusionModelRunner)
+    runner = object.__new__(runner_cls)
     runner.vllm_config = _make_vllm_config()
     runner.od_config = SimpleNamespace(
         cache_backend=None,
@@ -511,6 +584,37 @@ def test_input_batch_cached_repack_keeps_static_prompt_fields_for_same_compositi
     torch.testing.assert_close(repacked.prompt_embeds, torch.ones(1, 2, 3))
 
 
+@pytest.mark.cpu
+def test_make_batch_identity_mapping_never_reads_the_device_tensor_back(monkeypatch):
+    """The default index mapping is built on the host; reading it back from the device would sync every step."""
+
+    def forbidden(self, *args, **kwargs):
+        raise AssertionError("make_batch read a tensor back to the host")
+
+    monkeypatch.setattr(torch.Tensor, "tolist", forbidden)
+    monkeypatch.setattr(torch.Tensor, "cpu", forbidden)
+    states = [_make_input_batch_state("req-1", 1.0), _make_input_batch_state("req-2", 2.0)]
+
+    batch = InputBatch.make_batch(states)
+    repacked = InputBatch.make_batch(states, cached_batch=batch)
+
+    assert repacked is batch
+    assert list(batch.idx_mapping_np) == [0, 1]
+    assert batch.idx_mapping.dtype is torch.int32 and batch.idx_mapping.shape == (2,)
+    assert batch.request_ids == ["req-1", "req-2"]
+
+
+@pytest.mark.cpu
+def test_make_batch_explicit_mapping_still_selects_and_orders_states():
+    states = [_make_input_batch_state("req-1", 1.0), _make_input_batch_state("req-2", 2.0)]
+
+    batch = InputBatch.make_batch(states, idx_mapping=torch.tensor([1, 0]))
+
+    assert batch.request_ids == ["req-2", "req-1"]
+    assert list(batch.idx_mapping_np) == [1, 0]
+    torch.testing.assert_close(batch.latents, torch.tensor([[2.0], [1.0]]))
+
+
 @pytest.mark.cpu
 def test_step_profiler_reports_denoise_step_as_diffuse():
     pipeline = _AutoDenoiseProfilerPipeline()
@@ -628,6 +732,146 @@ class TestRunner:
         assert runner.pipeline.scheduler_calls == 2
         assert runner.pipeline.decode_calls == 1
 
+    @staticmethod
+    def _make_grouping_runner(pipeline, *, grouping: bool):
+        """An AR runner without KV (so it inherits the stepwise entry) over a streaming stub pipeline."""
+        from vllm_omni.experimental.ar_diffusion.runner import ARDiffusionModelRunner
+
+        runner = _make_runner(runner_cls=ARDiffusionModelRunner)
+        runner.od_config.streaming_output = True
+        runner.kv_cache = None
+        runner.pipeline = pipeline
+        runner.pipeline.supports_chunk_step_grouping = grouping
+        return runner
+
+    @staticmethod
+    def _drive_to_completion(runner, num_steps=4):
+        outputs = [runner.execute_stepwise(_make_scheduler_output(_make_step_request(num_steps)))]
+        step = 1
+        while not outputs[-1].get_request_output("req-1").finished:
+            outputs.append(runner.execute_stepwise(_make_cached_scheduler_output(step_id=step)))
+            step += 1
+        return [o.get_request_output("req-1") for o in outputs]
+
+    @pytest.mark.parametrize("grouping", [False, True])
+    def test_ar_runner_runs_every_step_of_a_chunk_in_one_call_when_the_pipeline_declares_it(
+        self, monkeypatch, grouping
+    ):
+        """With the capability declared, one AR runner call drives a whole chunk; the outputs are the same either way."""
+        runner = self._make_grouping_runner(_ChunkedStepPipeline(), grouping=grouping)
+        monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+        denoise_calls_after_each_call = []
+        original = runner.execute_stepwise
+
+        def counting(scheduler_output):
+            output = original(scheduler_output)
+            denoise_calls_after_each_call.append(runner.pipeline.denoise_calls)
+            return output
+
+        runner.execute_stepwise = counting
+
+        per_call = self._drive_to_completion(runner)
+
+        # Chunk outputs, and the steps they were emitted at, are identical.
+        emitted = [(o.step_index, float(o.result.output[0])) for o in per_call if o.result is not None]
+        assert emitted == [(2, 0.0), (2, 1.0)]
+        assert per_call[-1].finished is True
+        assert runner.pipeline.denoise_calls == 4 and runner.pipeline.scheduler_calls == 4
+        assert runner.pipeline.decode_calls == 2
+        assert runner.pipeline.prepare_calls == 1
+        # One call per chunk with the capability, one per step without; a
+        # grouped call never crosses into the next chunk.
+        assert denoise_calls_after_each_call == ([2, 4] if grouping else [1, 2, 3, 4])
+        assert "req-1" not in runner.state_cache
+
+    def test_ar_runner_continues_a_grouped_chunk_as_a_cached_request(self, monkeypatch):
+        """The first step admits the new request; every further step of the chunk is a cached-request continuation."""
+        runner = self._make_grouping_runner(_ChunkedStepPipeline(), grouping=True)
+        monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+        seen = []
+        original_core = DiffusionModelRunner._execute_stepwise_core
+
+        def recording_core(self_, scheduler_output, **kwargs):
+            seen.append(scheduler_output)
+            return original_core(self_, scheduler_output, **kwargs)
+
+        monkeypatch.setattr(DiffusionModelRunner, "_execute_stepwise_core", recording_core)
+
+        first = runner.execute_stepwise(_make_scheduler_output(_make_step_request(4), finished_req_ids={"old"}))
+
+        assert first.get_request_output("req-1").result is not None
+        assert runner.pipeline.prepare_calls == 1
+        assert len(seen) == 2
+        assert [n.request_id for n in seen[0].scheduled_new_reqs] == ["req-1"]
+        continuation = seen[1]
+        assert continuation.scheduled_new_reqs == []
+        assert continuation.scheduled_cached_reqs.request_ids == ["req-1"]
+        assert continuation.finished_req_ids == set()
+        assert continuation.kv_prefetch_job is None and continuation.kv_connector_metadata is None
+        assert continuation.step_id == seen[0].step_id
+
+    def test_ar_runner_grouped_steps_see_the_same_inputs_as_per_step_calls(self, monkeypatch):
+        """Every grouped step sees the latents and timestep step_scheduler just advanced, exactly as per-step calls do."""
+        finals = {}
+        seen = {}
+        for grouping in (False, True):
+            runner = self._make_grouping_runner(_BatchDependentChunkPipeline(), grouping=grouping)
+            monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+            self._drive_to_completion(runner)
+            finals[grouping] = float(runner.pipeline.final_latent)
+            seen[grouping] = runner.pipeline.seen
+
+        # 1 -> +(1+10)=12 -> +(12+5)=29 -> +(29+10)=68 -> +(68+5)=141 in both modes.
+        assert seen[False] == [(1.0, 10.0), (12.0, 5.0), (29.0, 10.0), (68.0, 5.0)]
+        assert seen[True] == seen[False]
+        assert finals[True] == finals[False] == 141.0
+
+    def test_ar_runner_grouped_chunk_stops_at_a_failing_step_and_drops_the_state(self, monkeypatch):
+        """A failure mid-chunk ends the grouped call with that step's error; nothing runs after it."""
+        runner = self._make_grouping_runner(_FailsMidChunkPipeline(), grouping=True)
+        monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+
+        output = runner.execute_stepwise(_make_scheduler_output(_make_step_request(4)))
+
+        failed = output.get_request_output("req-1")
+        assert failed.finished is True
+        assert failed.result is not None and "boom mid chunk" in failed.result.error
+        assert runner.pipeline.denoise_calls == 2 and runner.pipeline.decode_calls == 0
+        assert "req-1" not in runner.state_cache
+
+    def test_ar_runner_fails_a_chunk_that_never_advances(self, monkeypatch):
+        pipeline = _ChunkedStepPipeline()
+        monkeypatch.setattr(pipeline, "step_scheduler", lambda *args, **kwargs: None)
+        runner = self._make_grouping_runner(pipeline, grouping=True)
+        monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+        output = runner.execute_stepwise(_make_scheduler_output(_make_step_request(4)))
+        failed = output.get_request_output("req-1")
+        assert failed.finished
+        assert "within 2 denoise steps" in failed.result.error
+        assert pipeline.denoise_calls == 2
+        assert "req-1" not in runner.state_cache
+
+    def test_base_runner_never_groups_and_the_ar_policy_needs_capability_streaming_and_one_request(self, monkeypatch):
+        """The shared runner is one step per call; the AR runner groups only a lone streaming request that declares it."""
+        base = _make_runner()
+        base.od_config.streaming_output = True
+        base.pipeline = _ChunkedStepPipeline()
+        base.pipeline.supports_chunk_step_grouping = True
+        monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+        first = DiffusionModelRunner.execute_stepwise(base, _make_scheduler_output(_make_step_request(4)))
+        assert first.get_request_output("req-1").result is None and base.pipeline.denoise_calls == 1
+
+        ar = self._make_grouping_runner(_ChunkedStepPipeline(), grouping=False)
+        one = _make_cached_scheduler_output()
+        two = _make_batch_scheduler_output([_make_step_request(4), _make_step_request(4)])
+        two.scheduled_new_reqs[1].request_id = two.scheduled_new_reqs[1].req.request_id = "req-2"
+        assert ar._groups_chunk_steps(one) is False  # no capability declared
+        ar.pipeline.supports_chunk_step_grouping = True
+        assert ar._groups_chunk_steps(one) is True
+        assert ar._groups_chunk_steps(two) is False  # not for a batch
+        ar.od_config.streaming_output = False
+        assert ar._groups_chunk_steps(one) is False  # not without streaming output
+
     def test_stepwise_output_includes_stage_and_peak_metrics(self, monkeypatch):
         runner = _make_runner()
         runner.pipeline = _ProfilingStepPipeline()
@@ -780,6 +1024,65 @@ class TestRunner:
         assert runner.pipeline.denoise_calls == 0
         assert runner.state_cache == {}
 
+    def test_peer_prepare_encode_failure_skips_interaction_session_initialization(self, monkeypatch):
+        """One rank's failure in ``_prepare_batch_inputs -> prepare_encode`` must be handled before all ranks initialize interaction sessions.
+
+        ``maybe_prepare_initial_session`` calls ``synchronized_monotonic_time()``
+        (a broadcast). If this rank's ``prepare_encode`` succeeded while a peer
+        failed, entering that broadcast while the peer enters the failure
+        all-reduce would hang.
+        """
+        from unittest.mock import MagicMock
+
+        from vllm_omni.diffusion.interaction.types import ChunkMediaSpec, InteractionChunkMetadata
+
+        class _InteractionStepPipeline(_StepPipeline):
+            def __init__(self):
+                super().__init__()
+                self.prepare_next_chunk_calls = 0
+
+            def peek_chunk_media(self, state):
+                del state
+                return ChunkMediaSpec(num_media_frames=8, fps=16.0, num_latent_frames=8)
+
+            def apply_interaction_at_chunk_boundary(self, state):
+                del state
+
+            def prepare_next_chunk(self, state):
+                del state
+                self.prepare_next_chunk_calls += 1
+
+        runner = _make_runner()
+        pipeline = _InteractionStepPipeline()
+        runner.pipeline = pipeline
+        coordinator = MagicMock()
+        coordinator.maybe_prepare_initial_session.return_value = InteractionChunkMetadata(
+            started_event_ids=[],
+            active_event_ids=[],
+            completed_event_ids=[],
+        )
+        runner._interaction_coordinator = coordinator
+        monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+        # Peer failed during prepare_encode; this rank's local encode succeeds.
+        monkeypatch.setattr(
+            model_runner_module,
+            "_dit_any_rank_failed",
+            lambda local_failed: True,
+        )
+
+        req = _make_step_request(num_inference_steps=1)
+        result = DiffusionModelRunner.execute_stepwise(runner, _make_scheduler_output(req))
+
+        output = result.get_request_output("req-1")
+        assert output.finished is True
+        assert output.result is not None
+        assert "another DiT rank" in (output.result.error or "")
+        assert pipeline.prepare_calls == 1
+        coordinator.maybe_prepare_initial_session.assert_not_called()
+        assert pipeline.prepare_next_chunk_calls == 0
+        assert pipeline.denoise_calls == 0
+        assert runner.state_cache == {}
+
     def test_receives_kv_payload_before_prepare_encode(self, monkeypatch):
         runner = _make_runner()
         captured: dict[str, object] = {}
diff --git a/tests/diffusion/test_multiproc_engine_concurrency.py b/tests/diffusion/test_multiproc_engine_concurrency.py
index ade8d8fa7..50fca3ea8 100644
--- a/tests/diffusion/test_multiproc_engine_concurrency.py
+++ b/tests/diffusion/test_multiproc_engine_concurrency.py
@@ -835,11 +835,18 @@ class TestWorkerProcRpcRankStatus:
 
     def test_execute_rpc_returns_rank_status_envelope(self, monkeypatch):
         proc = self._make_worker_proc()
+        cpu_group = object()
 
         monkeypatch.setattr(torch.distributed, "is_initialized", lambda: True)
         monkeypatch.setattr(torch.distributed, "get_world_size", lambda: 2)
+        monkeypatch.setattr(
+            diffusion_worker_module,
+            "get_world_group",
+            lambda: SimpleNamespace(cpu_group=cpu_group),
+        )
 
-        def _all_gather_object(out, local):
+        def _all_gather_object(out, local, *, group):
+            assert group is cpu_group
             out[0] = local
             out[1] = {
                 "rank": 1,
diff --git a/tests/diffusion/test_worker_wrapper_base.py b/tests/diffusion/test_worker_wrapper_base.py
index 709fc7283..fb765e8fd 100644
--- a/tests/diffusion/test_worker_wrapper_base.py
+++ b/tests/diffusion/test_worker_wrapper_base.py
@@ -100,6 +100,28 @@ class TestWorkerWrapperBaseInitialization:
             skip_load_model=False,
         )
 
+    def test_custom_pipeline_args_without_pipeline_class_loads_normally(self, mocker: MockerFixture, mock_od_config):
+        """Test native pipeline args do not trigger custom pipeline re-initialization."""
+        custom_args = {"components_path": "/tmp/anima-components"}
+        mock_worker_init = mocker.patch.object(DiffusionWorker, "__init__", return_value=None)
+
+        wrapper = WorkerWrapperBase(
+            gpu_id=0,
+            od_config=mock_od_config,
+            base_worker_class=DiffusionWorker,
+            custom_pipeline_args=custom_args,
+        )
+
+        assert wrapper.worker_extension_cls is None
+        assert CustomPipelineWorkerExtension not in wrapper.worker.__class__.__bases__
+        assert not hasattr(wrapper.worker, "re_init_pipeline")
+        mock_worker_init.assert_called_once_with(
+            local_rank=0,
+            rank=0,
+            od_config=mock_od_config,
+            skip_load_model=False,
+        )
+
 
 # -------------------------------------------------------------------------
 # Tests: Worker Extension Functionality
@@ -476,6 +498,12 @@ class TestCustomPipelineWorkerExtension:
             custom_pipeline_args=custom_args,
         )
 
+        mock_worker_class.assert_called_once_with(
+            local_rank=0,
+            rank=0,
+            od_config=mock_od_config,
+            skip_load_model=True,
+        )
         # Verify re_init_pipeline was called with custom_pipeline_args
         mock_worker_instance.re_init_pipeline.assert_called_once_with(custom_args)
 
diff --git a/tests/diffusion/utils/test_chunked_transfer.py b/tests/diffusion/utils/test_chunked_transfer.py
new file mode 100644
index 000000000..1a8c52eb5
--- /dev/null
+++ b/tests/diffusion/utils/test_chunked_transfer.py
@@ -0,0 +1,261 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Ownership and backpressure contract for chunk transfers to the host.
+
+The ring hands a chunk one reusable host slot for its whole trip. Getting the
+release point wrong is silent: a slot reused while its copy is still landing,
+or while an encoder still holds a view of it, corrupts frames rather than
+raising. These cover the release point, the backpressure it creates, and the
+escape path out of a wait.
+"""
+
+from __future__ import annotations
+
+import threading
+
+import numpy as np
+import pytest
+import torch
+
+from tests.helpers.mark import hardware_test
+from vllm_omni.diffusion.utils.chunked_video import (
+    ChunkedVideoMP4Session,
+    ChunkLease,
+    PinnedChunkRing,
+    quantize_chunk,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def _frames(value: int = 7, *, batch: int = 1) -> torch.Tensor:
+    """One quantized ``BTHWC`` chunk, the shape the ring transfers."""
+    return torch.full((batch, 2, 4, 6, 3), value, dtype=torch.uint8)
+
+
+def _cpu_ring(depth: int) -> PinnedChunkRing:
+    return PinnedChunkRing(depth=depth, device=torch.device("cpu"))
+
+
+def test_slot_returns_only_after_its_last_reader():
+    """Each batch entry reads the same buffer, so one release must not free it."""
+    ring = _cpu_ring(2)
+    lease = ring.transfer(_frames(batch=3), readers=3)
+
+    assert ring.slots_in_use == 1
+    view = lease.wait()
+    assert view.shape == (3, 2, 4, 6, 3)
+    # Waiting is not consuming: an encoder still holds a view of this buffer.
+    assert ring.slots_in_use == 1
+
+    lease.release()
+    lease.release()
+    assert ring.slots_in_use == 1
+
+    lease.release()
+    assert ring.slots_in_use == 0
+    # A late extra release must not free the slot a second time.
+    lease.release()
+    assert ring.slots_in_use == 0
+
+
+def test_transfer_waits_for_a_slot_instead_of_growing_the_pool():
+    """Depth is the bound on in-flight host buffers, so a full ring blocks."""
+    ring = _cpu_ring(1)
+    held = ring.transfer(_frames(1), readers=1)
+    second: list[object] = []
+
+    def take_a_slot() -> None:
+        second.append(ring.transfer(_frames(2), readers=1))
+
+    waiter = threading.Thread(target=take_a_slot)
+    waiter.start()
+    waiter.join(timeout=0.3)
+    assert waiter.is_alive(), "a full ring must not hand out a second slot"
+
+    held.wait()
+    held.release()
+    waiter.join(timeout=5)
+    assert not waiter.is_alive()
+    assert ring.slots_in_use == 1
+    assert ring.stats.slot_wait_seconds > 0
+
+
+def test_abort_wakes_a_transfer_waiting_for_a_slot():
+    """A dead consumer must surface as an error, not as a stuck producer."""
+    ring = _cpu_ring(1)
+    ring.transfer(_frames(), readers=1)
+    failures: list[BaseException] = []
+
+    def take_a_slot() -> None:
+        try:
+            ring.transfer(_frames(), readers=1)
+        except BaseException as exc:  # noqa: BLE001
+            failures.append(exc)
+
+    waiter = threading.Thread(target=take_a_slot)
+    waiter.start()
+    waiter.join(timeout=0.3)
+    assert waiter.is_alive()
+
+    ring.abort(RuntimeError("encoder died"))
+    waiter.join(timeout=5)
+    assert [str(exc) for exc in failures] == ["encoder died"]
+    # Later transfers stay failed rather than silently resuming.
+    with pytest.raises(RuntimeError, match="encoder died"):
+        ring.transfer(_frames(), readers=1)
+
+
+def test_encoder_releases_the_chunk_it_was_reading_when_muxing_fails(monkeypatch):
+    """A failed mux abandons the frame generator, which still owns a lent slot."""
+    from vllm_omni.diffusion.utils import media_utils
+
+    released: list[int] = []
+
+    def exploding_mux(frames, **kwargs):
+        # Read into the chunk, so the generator is suspended inside it.
+        next(iter(frames))
+        raise RuntimeError("mux failed")
+
+    monkeypatch.setattr(media_utils, "mux_av_video_audio_bytes", exploding_mux)
+    encoder = media_utils.ChunkedMP4Encoder(width=6, height=4, fps=24)
+    encoder.push(np.zeros((2, 4, 6, 3), dtype=np.uint8), on_consumed=lambda: released.append(1))
+
+    with pytest.raises(RuntimeError, match="mux failed"):
+        encoder.finish()
+
+    assert released == [1], "the abandoned generator must not keep holding its chunk"
+
+
+class _RecordingEncoder:
+    """Stands in for one batch entry's encoder, honouring the release contract."""
+
+    instances: list[_RecordingEncoder] = []
+
+    def __init__(self, **kwargs):
+        self.pushes: list[int] = []
+        self.released = 0
+        self.fail_on_push = False
+        self.__class__.instances.append(self)
+
+    def push(self, frames, *, on_consumed=None):
+        if self.fail_on_push:
+            if on_consumed is not None:
+                on_consumed()
+                self.released += 1
+            raise RuntimeError("encoder rejected the chunk")
+        self.pushes.append(int(frames[0, 0, 0, 0]))
+        if on_consumed is not None:
+            on_consumed()
+            self.released += 1
+
+    def finish(self) -> bytes:
+        return b"mp4"
+
+    def abort(self) -> None:
+        return None
+
+
+@pytest.fixture
+def recording_encoders(monkeypatch):
+    _RecordingEncoder.instances = []
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.utils.chunked_video.ChunkedMP4Encoder",
+        _RecordingEncoder,
+    )
+    return _RecordingEncoder.instances
+
+
+def _push_ramp(session: ChunkedVideoMP4Session, values: list[int]) -> None:
+    for value in values:
+        session.push(torch.full((1, 3, 1, 4, 6), value / 255.0))
+
+
+def test_session_feeds_chunks_in_producer_order(recording_encoders):
+    """Copies complete in issue order, and the encoder must see that order."""
+    session = ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24)
+    _push_ramp(session, [10, 20, 30, 40])
+
+    assert session.finish() == [b"mp4"]
+    assert recording_encoders[0].pushes == [10, 20, 30, 40]
+
+
+def test_session_returns_the_slot_when_an_encoder_rejects_a_chunk(recording_encoders):
+    """A rejected chunk must not strand the buffer it was lent."""
+    session = ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24, transfer_slots=1)
+    session.push(torch.zeros(1, 3, 1, 4, 6))
+    recording_encoders[0].fail_on_push = True
+
+    with pytest.raises(RuntimeError, match="rejected"):
+        session.push(torch.zeros(1, 3, 1, 4, 6))
+
+    assert session.ring is not None
+    assert session.ring.slots_in_use == 0
+
+
+def test_session_abort_releases_every_slot_still_in_flight(recording_encoders):
+    """Teardown returns the pool even when nothing consumed the chunks."""
+    session = ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24, transfer_slots=2)
+    session.push(torch.zeros(1, 3, 1, 4, 6))
+
+    session.abort()
+
+    assert session.ring is not None
+    assert session.ring.slots_in_use == 0
+
+
+def test_session_gets_its_slot_back_after_a_real_encoder_failure():
+    """A real libx264 error must not strand the producer on the slot it lent."""
+    session = ChunkedVideoMP4Session(
+        value_range=(0.0, 1.0),
+        fps=24,
+        transfer_slots=1,
+        video_codec_options={"preset": "invalid-preset"},
+    )
+    failures: list[BaseException] = []
+
+    def produce() -> None:
+        try:
+            for _ in range(4):
+                session.push(torch.zeros(1, 3, 1, 16, 16))
+            session.finish()
+        except BaseException as exc:  # noqa: BLE001
+            failures.append(exc)
+
+    producer = threading.Thread(target=produce, daemon=True)
+    producer.start()
+    producer.join(timeout=30)
+    # With one slot, a lease the failed encoder never released leaves the
+    # producer waiting on the ring forever instead of seeing the codec error.
+    assert not producer.is_alive(), "the producer stalled on a slot the failed encoder kept"
+    assert len(failures) == 1
+
+    session.abort()
+    assert session.ring is not None
+    assert session.ring.slots_in_use == 0
+
+
+@hardware_test(res={"cuda": ["H100", "B200"]})
+def test_device_chunks_land_intact_through_the_pinned_ring():
+    """On an accelerator the copy is deferred, so its event must order the read."""
+    if not torch.accelerator.is_available():
+        pytest.skip("no accelerator available")
+
+    device = torch.device(torch.accelerator.current_accelerator().type, 0)
+    ring = PinnedChunkRing(depth=2, device=device)
+    pending: list[tuple[int, ChunkLease]] = []
+    for step in range(6):
+        value = 10 * step + 1
+        # Quantize on the compute stream immediately before handing the chunk
+        # over: without the source-ready event the copy would race this work.
+        chunk = torch.full((1, 3, 2, 4, 6), value / 255.0, device=device)
+        pending.append((value, ring.transfer(quantize_chunk(chunk, (0.0, 1.0)), readers=1)))
+        if len(pending) == 2:
+            for expected, lease in pending:
+                assert int(lease.wait()[0, 0, 0, 0, 0]) == expected
+                lease.release()
+            pending.clear()
+
+    assert ring.stats.transfers == 6
+    assert ring.stats.peak_slots_in_use == 2
+    assert ring.stats.peak_pending_bytes == 2 * 2 * 4 * 6 * 3
diff --git a/tests/diffusion/utils/test_chunked_video.py b/tests/diffusion/utils/test_chunked_video.py
new file mode 100644
index 000000000..849b49290
--- /dev/null
+++ b/tests/diffusion/utils/test_chunked_video.py
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import io
+
+import av
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.diffusion.utils.chunked_video import (
+    ChunkedVideoMP4Session,
+    chunk_to_uint8_frames,
+    decode_to_mp4,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+class _FakeVAE:
+    """Publish committed chunks the way a chunked-decode VAE does."""
+
+    def __init__(self, value_range, *, batch=1, chunks=4, frames=2, height=16, width=32):
+        self.chunk_value_range = value_range
+        self._shape = (batch, 3, frames, height, width)
+        self._chunks = chunks
+
+    def decode_with_chunks(self, z, *, on_chunk):
+        del z
+        low, high = self.chunk_value_range
+        for index in range(self._chunks):
+            value = low + (high - low) * index / max(self._chunks - 1, 1)
+            on_chunk(torch.full(self._shape, value))
+
+
+def _decoded(data: bytes):
+    with av.open(io.BytesIO(data)) as container:
+        return np.stack([f.to_ndarray(format="rgb24") for f in container.decode(video=0)])
+
+
+def test_quantization_maps_each_producer_range_onto_the_same_pixels():
+    """A model's published range is what makes chunks comparable across models."""
+    wan = torch.tensor([-1.0, 0.0, 1.0]).view(1, 1, 3, 1, 1).expand(1, 3, 3, 1, 1)
+    h3 = torch.tensor([0.0, 0.5, 1.0]).view(1, 1, 3, 1, 1).expand(1, 3, 3, 1, 1)
+
+    from_wan = chunk_to_uint8_frames(wan.contiguous(), (-1.0, 1.0))
+    from_h3 = chunk_to_uint8_frames(h3.contiguous(), (0.0, 1.0))
+
+    # Same physical pixels, different published ranges.
+    assert np.array_equal(from_wan, from_h3)
+    assert from_wan.reshape(-1, 3)[:, 0].tolist() == [0, 128, 255]
+
+
+def test_quantization_rejects_a_degenerate_range():
+    with pytest.raises(ValueError, match="increasing"):
+        chunk_to_uint8_frames(torch.zeros(1, 3, 1, 2, 2), (1.0, 1.0))
+
+
+@pytest.mark.parametrize("value_range", [(-1.0, 1.0), (0.0, 1.0)])
+def test_decode_to_mp4_drives_any_declared_range(value_range):
+    videos = decode_to_mp4(_FakeVAE(value_range), torch.zeros(1), fps=24, batch_frames=4)
+
+    assert len(videos) == 1
+    assert _decoded(videos[0]).shape[0] == 8
+
+
+def test_decode_to_mp4_emits_one_container_per_batch_entry():
+    videos = decode_to_mp4(_FakeVAE((-1.0, 1.0), batch=3), torch.zeros(1), fps=24)
+
+    assert len(videos) == 3
+    assert all(_decoded(v).shape[0] == 8 for v in videos)
+
+
+def test_decode_to_mp4_rejects_a_vae_without_the_capability():
+    class PlainVAE:
+        def decode(self, z):
+            del z
+
+    with pytest.raises(TypeError, match="chunked VAE decode capability"):
+        decode_to_mp4(PlainVAE(), torch.zeros(1), fps=24)
+
+
+def test_decode_to_mp4_returns_nothing_for_a_rank_without_output():
+    class SilentVAE:
+        chunk_value_range = (-1.0, 1.0)
+
+        def decode_with_chunks(self, z, *, on_chunk):
+            del z, on_chunk
+
+    assert decode_to_mp4(SilentVAE(), torch.zeros(1), fps=24) == []
+
+
+def test_session_crops_the_decoder_padding_away():
+    session = ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24, crop=(8, 16))
+    session.push(torch.zeros(1, 3, 4, 16, 32))
+
+    assert _decoded(session.finish()[0]).shape[1:3] == (8, 16)
+
+
+def test_session_muxes_one_waveform_per_batch_entry():
+    audio = [np.zeros(8000, dtype=np.float32), np.full(8000, 0.5, dtype=np.float32)]
+    session = ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24, audio_waveforms=audio, audio_sample_rate=16000)
+    session.push(torch.zeros(2, 3, 4, 16, 16))
+
+    for data in session.finish():
+        with av.open(io.BytesIO(data)) as container:
+            assert container.streams.audio
+
+
+def test_session_rejects_a_waveform_count_that_does_not_match_the_batch():
+    session = ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24, audio_waveforms=[np.zeros(8000, dtype=np.float32)])
+    with pytest.raises(ValueError, match="one audio waveform per batch entry"):
+        session.push(torch.zeros(2, 3, 4, 16, 16))
+
+
+def test_session_rejects_a_non_positive_batch():
+    with pytest.raises(ValueError, match="batch_frames"):
+        ChunkedVideoMP4Session(value_range=(0.0, 1.0), fps=24, batch_frames=0)
diff --git a/tests/distributed/omni_connectors/test_nixl_connector.py b/tests/distributed/omni_connectors/test_nixl_connector.py
index 77a2f2909..5e5fc3ed6 100644
--- a/tests/distributed/omni_connectors/test_nixl_connector.py
+++ b/tests/distributed/omni_connectors/test_nixl_connector.py
@@ -317,6 +317,7 @@ def copying_native_agent(consumer, monkeypatch):
 
 
 @pytest.mark.parametrize("case", ["empty", "all_empty", "mixed", "scalar", "structured_empty", "structured_mixed"])
+@pytest.mark.usefixtures("reliable_claim_queries")
 def test_zero_byte_leaves_roundtrip_without_native_descriptors(producer, consumer, copying_native_agent, case):
     empty = torch.empty((2, 0, 3), dtype=torch.float64)
     other = torch.empty((0,), dtype=torch.int64)
diff --git a/tests/e2e/accuracy/minicpmo_4_5/test_minicpmo_4_5.py b/tests/e2e/accuracy/minicpmo_4_5/test_minicpmo_4_5.py
index ad659541d..acf717e42 100644
--- a/tests/e2e/accuracy/minicpmo_4_5/test_minicpmo_4_5.py
+++ b/tests/e2e/accuracy/minicpmo_4_5/test_minicpmo_4_5.py
@@ -3,7 +3,7 @@
 """MiniCPM-o 4.5 Daily-Omni + Seed-TTS accuracy regression coverage.
 
 Daily-Omni settings follow the MiniCPM interleaved AV recipe that reaches
-~78% overall accuracy on Daily-Omni (``minicpm-interleave``, ``temperature=0``,
+~77% overall accuracy on Daily-Omni (``minicpm-interleave``, ``temperature=0``,
 text modalities, and server ``--interleave-mm-strings`` + 1fps / 128-frame
 media-io kwargs, also pinned in ``minicpmo_4_5.yaml``).
 """
@@ -48,7 +48,12 @@ _RESULT_DIR = Path(
     )
 )
 
-_MIN_DAILY_OMNI_ACCURACY = 0.78
+# The 0.78 gate (934/1197) sits 1 item above the observed NPU mean
+# (~933/1197) and inside the observed 932~940 spread, so it flips nightly -
+# 3 failures in the latest 7 dated NPU nightlies (#6887). 0.77 (922/1197)
+# sits 10 items below the observed minimum (932) while still failing a
+# >=1pp real accuracy regression.
+_MIN_DAILY_OMNI_ACCURACY = 0.77
 _MAX_SEED_TTS_MEAN_WER = 0.05
 # Match the validated Daily-Omni client body from daily_omni_bench.sh.
 _DAILY_EXTRA_BODY = {
diff --git a/tests/e2e/accuracy/qwen3_omni/qwen3_omni_acc_bench_core.py b/tests/e2e/accuracy/qwen3_omni/qwen3_omni_acc_bench_core.py
index d612b96a5..a900e43d5 100644
--- a/tests/e2e/accuracy/qwen3_omni/qwen3_omni_acc_bench_core.py
+++ b/tests/e2e/accuracy/qwen3_omni/qwen3_omni_acc_bench_core.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Shared helpers for Qwen3-Omni Daily-Omni / Seed-TTS ``vllm bench serve --omni`` accuracy runs.
+"""Shared helpers for Omni Daily-Omni / Seed-TTS / Video-MME ``vllm bench serve --omni`` accuracy runs.
 
 Local dataset paths are **optional**. When ``VLLM_DAILY_OMNI_QA_JSON`` + ``VLLM_DAILY_OMNI_VIDEO_DIR``
 point to existing files, those are used with inline video. Otherwise the benchmark falls back to
@@ -10,6 +10,10 @@ bench request that needs media downloads ``Videos.tar`` from the Hub when no vid
 Similarly for Seed-TTS: a local directory wins; otherwise ``--dataset-path`` uses the Hub id
 and ``huggingface_hub.snapshot_download`` inside ``resolve_seed_tts_root`` pulls files on demand.
 
+Video-MME follows the same pattern: an existing local directory via ``VLLM_VIDEOMME_DATASET_PATH`` /
+``VIDEOMME_ROOT`` (or ``--videomme-dataset-path`` / ``--dataset-path``) wins; otherwise the Hub id
+``lmms-eval/Video-MME`` is used and ``resolve_videomme_root`` downloads parquet + video archives.
+
 Use :func:`build_acc_benchmark_cli_argv` to assemble ``argv`` for a live Omni server (host/port/model
 and small bench defaults) before ``parse_args`` / ``run_acc_benchmark`` in the accuracy driver.
 """
@@ -26,6 +30,7 @@ from typing import Any, Protocol
 
 DEFAULT_DAILY_OMNI_HF_REPO = "liarliar/Daily-Omni"
 DEFAULT_SEED_TTS_HF_REPO = "zhaochenyang20/seed-tts-eval"
+DEFAULT_VIDEOMME_HF_REPO = "lmms-eval/Video-MME"
 
 
 class OmniBenchServerEndpoint(Protocol):
@@ -41,6 +46,7 @@ def build_acc_benchmark_cli_argv(
     *,
     skip_seed: bool,
     skip_daily: bool,
+    skip_videomme: bool = True,
     num_prompts: int | None = None,
     max_concurrency: int | None = None,
 ) -> list[str]:
@@ -50,6 +56,9 @@ def build_acc_benchmark_cli_argv(
     ``--num-prompts`` / ``--max-concurrency`` defaults (overridable via ``ACC_BENCH_NUM_PROMPTS`` /
     ``ACC_BENCH_MAX_CONCURRENCY``), and when Daily-Omni runs adds ``--daily-omni-repo`` so Hub QA
     matches :func:`daily_omni_bench_argv` once ``run_acc_benchmark`` mirrors ``--daily-omni-repo`` into env.
+
+    Video-MME is **opt-in** (``skip_videomme=True`` by default) so existing Daily-Omni / Seed-TTS
+    callers stay unchanged; pass ``skip_videomme=False`` (emits ``--run-videomme``) to enable it.
     """
     n_prompts = int(os.environ.get("ACC_BENCH_NUM_PROMPTS", "2000")) if num_prompts is None else int(num_prompts)
     n_conc = int(os.environ.get("ACC_BENCH_MAX_CONCURRENCY", "10")) if max_concurrency is None else int(max_concurrency)
@@ -72,6 +81,12 @@ def build_acc_benchmark_cli_argv(
         argv.append("--skip-seed-tts")
     if skip_daily:
         argv.append("--skip-daily-omni")
+    if skip_videomme:
+        argv.append("--skip-videomme")
+    else:
+        argv.append("--run-videomme")
+        repo = os.environ.get("VLLM_VIDEOMME_REPO", DEFAULT_VIDEOMME_HF_REPO).strip() or DEFAULT_VIDEOMME_HF_REPO
+        argv.extend(["--videomme-repo", repo])
     return argv
 
 
@@ -101,6 +116,28 @@ def daily_omni_bench_argv() -> list[str]:
     ]
 
 
+def videomme_bench_argv() -> list[str]:
+    """CLI args for Video-MME (after ``vllm bench serve --omni``).
+
+    Same local-vs-Hub rule as :func:`seed_tts_bench_argv`:
+
+    * If ``VLLM_VIDEOMME_DATASET_PATH`` / ``VIDEOMME_ROOT`` names an existing directory,
+      use that local mirror as ``--dataset-path``.
+    * Otherwise pass the Hub id (``VLLM_VIDEOMME_REPO`` / ``lmms-eval/Video-MME``); the child
+      bench downloads via ``huggingface_hub.snapshot_download``.
+    """
+    source = (
+        os.environ.get("VLLM_VIDEOMME_DATASET_PATH", "").strip()
+        or os.environ.get("VIDEOMME_ROOT", "").strip()
+        or os.environ.get("VLLM_VIDEOMME_REPO", "").strip()
+        or DEFAULT_VIDEOMME_HF_REPO
+    )
+    path = Path(source).expanduser()
+    if path.is_dir():
+        source = str(path.resolve())
+    return ["--dataset-name", "videomme", "--dataset-path", source]
+
+
 def seed_tts_bench_argv(*, locale: str = "en") -> list[str]:
     """CLI args for Seed-TTS (after ``vllm bench serve --omni``)."""
     dp = os.environ.get("VLLM_SEED_TTS_DATASET_PATH", "").strip()
diff --git a/tests/e2e/accuracy/qwen3_omni/run_qwen_omni_acc_benchmark.py b/tests/e2e/accuracy/qwen3_omni/run_qwen_omni_acc_benchmark.py
index 2bacfa798..fab9ea590 100644
--- a/tests/e2e/accuracy/qwen3_omni/run_qwen_omni_acc_benchmark.py
+++ b/tests/e2e/accuracy/qwen3_omni/run_qwen_omni_acc_benchmark.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Accuracy (and light perf) checks for Qwen3-Omni via ``vllm bench serve --omni``.
 
 The standalone CLI uses small ``--num-prompts`` / ``--max-concurrency`` defaults suitable for
@@ -11,6 +12,9 @@ H100 / MI325) because they launch the live Omni server inside the test.
    run **fails** if accuracy is strictly below **0.69** (``--min-daily-omni-accuracy`` / ``ACC_BENCH_MIN_DAILY_OMNI_ACCURACY``).
 2. **Seed-TTS** — ``seed-tts-eval``-style metrics when ``--seed-tts-wer-eval`` is used
    (WER / SIM / UTMOS keys from :func:`compute_seed_tts_wer_metrics`).
+3. **Video-MME** — opt-in via ``--run-videomme`` (skipped by default so Daily-Omni / Seed-TTS callers
+   stay unchanged). MiniCPM-o 4.5 reports **70.4** on Video-MME (w/o subs); the default floor is
+   **0.68** (``--min-videomme-accuracy`` / ``ACC_BENCH_MIN_VIDEOMME_ACCURACY``).
 
 Prerequisites
 -------------
@@ -21,7 +25,8 @@ Prerequisites
   On L4 you may need a smaller checkpoint, quantization, or tighter engine flags; this script
   only drives the **client** benchmark.
 
-* ``vllm`` CLI from **vLLM-Omni** (so ``bench serve`` registers ``daily-omni`` / ``seed-tts``).
+* ``vllm`` CLI from **vLLM-Omni** (so ``bench serve`` registers ``daily-omni`` / ``seed-tts`` /
+  ``videomme``).
 
 * **Daily-Omni** — if local ``qa.json`` + ``Videos/`` are not both provided (CLI or matching env),
   the client passes ``--dataset-path`` with a Hub id (default ``liarliar/Daily-Omni``). The **child**
@@ -35,6 +40,12 @@ Prerequisites
 
     pip install 'vllm-omni[dev]'
 
+* **Video-MME** — by default ``--dataset-path`` is the Hub id ``lmms-eval/Video-MME`` (override with
+  ``--videomme-repo`` / ``VLLM_VIDEOMME_REPO``). The child bench downloads parquet + video archives via
+  ``huggingface_hub.snapshot_download``. Pass an existing local root with ``--videomme-dataset-path`` /
+  ``VLLM_VIDEOMME_DATASET_PATH`` / ``VIDEOMME_ROOT`` to skip the Hub download. For CI servers without
+  ``--allowed-local-media-path``, pass ``--videomme-inline-local-video``.
+
 Examples
 --------
 Pytest (same checks; needs a running server)::
@@ -55,6 +66,24 @@ Skip one suite, tighten gates::
         --skip-daily-omni \\
         --max-seed-tts-mean-wer 0.35 \\
         --min-seed-tts-mean-sim 0.75
+
+MiniCPM-o Video-MME (w/o subs). Start the server with the 96-image stage 0
+limit first; replace /path/to/Video-MME with the local dataset root::
+
+    vllm serve openbmb/MiniCPM-o-4_5 --omni \\
+        --allowed-local-media-path /path/to/Video-MME \\
+        --stage-overrides '{"0":{"limit_mm_per_prompt":{"image":96,"audio":64,"video":1}}}'
+
+Then run the opt-in evaluation in another terminal::
+
+    python tests/e2e/accuracy/qwen3_omni/run_qwen_omni_acc_benchmark.py \\
+        --model openbmb/MiniCPM-o-4_5 \\
+        --videomme-dataset-path /path/to/Video-MME \\
+        --skip-daily-omni --skip-seed-tts --run-videomme \\
+        --videomme-pack-mode minicpm-frames \\
+        --videomme-max-frames 96 \\
+        --temperature 0 --output-len 128 \\
+        --min-videomme-accuracy 0.68
 """
 
 from __future__ import annotations
@@ -75,6 +104,7 @@ from tests.e2e.accuracy.qwen3_omni.qwen3_omni_acc_bench_core import (
     load_benchmark_result,
     run_vllm_bench_subprocess,
     seed_tts_bench_argv,
+    videomme_bench_argv,
 )
 
 _REPO_ROOT = Path(__file__).resolve().parents[4]
@@ -102,6 +132,42 @@ def _validate_daily_omni(result: dict[str, Any], *, min_accuracy: float | None)
     return errs
 
 
+def _validate_videomme(result: dict[str, Any], *, min_accuracy: float | None) -> list[str]:
+    errs: list[str] = []
+    acc = result.get("videomme_accuracy")
+    if acc is None:
+        errs.append("Missing videomme_accuracy (wrong dataset or no gold-evaluated rows).")
+        return errs
+    ev = int(result.get("videomme_evaluated_ok", 0) or 0)
+    if ev <= 0:
+        errs.append("videomme_evaluated_ok is 0; no successful MCQ rows to score.")
+    failed = int(result.get("videomme_request_failed", 0) or 0)
+    if failed > 0:
+        errs.append(
+            f"videomme_request_failed={failed}; the accuracy gate requires every "
+            "gold-labeled request to complete HTTP successfully "
+            "(videomme_accuracy excludes HTTP failures)."
+        )
+    submitted = int(result.get("videomme_submitted", 0) or 0)
+    unique = int(result.get("videomme_unique_question_ids", 0) or 0)
+    if submitted <= 0 or unique != submitted:
+        errs.append(
+            f"Video-MME coverage is incomplete: submitted={submitted}, unique={unique}; "
+            "the accuracy gate requires distinct questions, not oversampled replacements."
+        )
+    skipped = int(result.get("videomme_skipped_rows", 0) or 0)
+    if skipped:
+        errs.append(
+            f"videomme_skipped_rows={skipped}; fix missing or unreadable source rows before accuracy evaluation."
+        )
+    no_gold = int(result.get("videomme_no_gold", 0) or 0)
+    if no_gold:
+        errs.append(f"videomme_no_gold={no_gold}; every submitted question must have a gold answer.")
+    if min_accuracy is not None and float(acc) + 1e-12 < float(min_accuracy):
+        errs.append(f"videomme_accuracy={acc:.6f} < --min-videomme-accuracy={min_accuracy}")
+    return errs
+
+
 def _validate_seed_tts(
     result: dict[str, Any],
     *,
@@ -130,7 +196,7 @@ def _validate_seed_tts(
 
 
 def sync_dataset_env_from_ns(ns: argparse.Namespace) -> None:
-    """Mirror CLI path flags into env vars read by ``daily_omni_bench_argv`` / ``seed_tts_bench_argv``."""
+    """Mirror CLI path flags into env vars read by dataset ``*_bench_argv`` helpers."""
     repo = getattr(ns, "daily_omni_repo", None)
     if repo is not None and str(repo).strip():
         os.environ["VLLM_DAILY_OMNI_REPO"] = str(repo).strip()
@@ -138,6 +204,14 @@ def sync_dataset_env_from_ns(ns: argparse.Namespace) -> None:
         os.environ["VLLM_DAILY_OMNI_QA_JSON"] = str(Path(ns.daily_omni_qa_json).expanduser().resolve())
     if ns.daily_omni_video_dir is not None:
         os.environ["VLLM_DAILY_OMNI_VIDEO_DIR"] = str(Path(ns.daily_omni_video_dir).expanduser().resolve())
+    vm_repo = getattr(ns, "videomme_repo", None)
+    if vm_repo is not None and str(vm_repo).strip():
+        os.environ["VLLM_VIDEOMME_REPO"] = str(vm_repo).strip()
+    vm_path = getattr(ns, "videomme_dataset_path", None)
+    if vm_path is not None and str(vm_path).strip():
+        raw = str(vm_path).strip()
+        p = Path(raw).expanduser()
+        os.environ["VLLM_VIDEOMME_DATASET_PATH"] = str(p.resolve()) if p.exists() and p.is_dir() else raw
     if ns.seed_tts_dataset_path is not None:
         # ``--seed-tts-dataset-path`` accepts either a local directory or a
         # Hugging Face repo id. Only resolve to an absolute filesystem path
@@ -157,6 +231,9 @@ def _preserve_benchmark_dataset_env() -> Any:
         "VLLM_DAILY_OMNI_REPO",
         "VLLM_DAILY_OMNI_QA_JSON",
         "VLLM_DAILY_OMNI_VIDEO_DIR",
+        "VLLM_VIDEOMME_REPO",
+        "VLLM_VIDEOMME_DATASET_PATH",
+        "VIDEOMME_ROOT",
         "VLLM_SEED_TTS_DATASET_PATH",
         "SEED_TTS_ROOT",
     )
@@ -225,6 +302,46 @@ def run_daily_omni(ns: argparse.Namespace, vllm: str) -> Path:
     return out
 
 
+def run_videomme(ns: argparse.Namespace, vllm: str) -> Path:
+    ns.result_dir.mkdir(parents=True, exist_ok=True)
+    tag = datetime.now().strftime("%Y%m%d-%H%M%S")
+    result_filename = f"omni_acc_videomme_{tag}.json"
+    extra = json.loads(ns.videomme_extra_body_json)
+    argv = (
+        _build_common_args(ns, result_filename=result_filename)
+        + videomme_bench_argv()
+        + [
+            "--disable-shuffle",
+            "--videomme-pack-mode",
+            ns.videomme_pack_mode,
+            "--videomme-duration",
+            ns.videomme_duration,
+            "--extra-body",
+            json.dumps(extra, ensure_ascii=False, separators=(",", ":")),
+        ]
+    )
+    if ns.videomme_max_frames is not None:
+        argv.extend(["--videomme-max-frames", str(int(ns.videomme_max_frames))])
+    if ns.videomme_use_subtitle:
+        argv.append("--videomme-use-subtitle")
+    if ns.videomme_inline_local_video:
+        argv.append("--videomme-inline-local-video")
+    if ns.videomme_save_eval_items:
+        argv.append("--videomme-save-eval-items")
+    if ns.videomme_video_dir is not None:
+        argv.extend(["--videomme-video-dir", str(Path(ns.videomme_video_dir).expanduser().resolve())])
+    if ns.videomme_parquet is not None:
+        argv.extend(["--videomme-parquet", str(Path(ns.videomme_parquet).expanduser().resolve())])
+    if ns.videomme_subtitle_dir is not None:
+        argv.extend(["--videomme-subtitle-dir", str(Path(ns.videomme_subtitle_dir).expanduser().resolve())])
+    print("\n$", vllm, *argv, "\n", flush=True)
+    run_vllm_bench_subprocess(vllm, argv)
+    out = Path(ns.result_dir) / result_filename
+    if not out.is_file():
+        raise FileNotFoundError(f"Expected result JSON at {out}")
+    return out
+
+
 def run_seed_tts(ns: argparse.Namespace, vllm: str) -> Path:
     ns.result_dir.mkdir(parents=True, exist_ok=True)
     tag = datetime.now().strftime("%Y%m%d-%H%M%S")
@@ -312,6 +429,20 @@ def build_arg_parser() -> argparse.ArgumentParser:
 
     p.add_argument("--skip-daily-omni", action="store_true")
     p.add_argument("--skip-seed-tts", action="store_true")
+    # Video-MME is opt-in: default skip=True so existing Daily-Omni / Seed-TTS callers stay unchanged.
+    p.set_defaults(skip_videomme=True)
+    p.add_argument(
+        "--skip-videomme",
+        action="store_true",
+        dest="skip_videomme",
+        help="Skip Video-MME (default).",
+    )
+    p.add_argument(
+        "--run-videomme",
+        action="store_false",
+        dest="skip_videomme",
+        help="Enable the Video-MME accuracy suite.",
+    )
 
     p.add_argument(
         "--daily-omni-repo",
@@ -358,6 +489,87 @@ def build_arg_parser() -> argparse.ArgumentParser:
         "Default baseline 0.69; override with env ACC_BENCH_MIN_DAILY_OMNI_ACCURACY or pass 0 to disable the floor.",
     )
 
+    p.add_argument(
+        "--videomme-repo",
+        type=str,
+        default=None,
+        help="Hugging Face dataset id for Video-MME Hub mode (sets VLLM_VIDEOMME_REPO). "
+        "Default when no local path is set: lmms-eval/Video-MME. "
+        "Ignored when a local --videomme-dataset-path / VLLM_VIDEOMME_DATASET_PATH is used.",
+    )
+    p.add_argument(
+        "--videomme-dataset-path",
+        type=str,
+        default=None,
+        help="Optional local Video-MME root (parquet + videos). Existing directories skip the Hub "
+        "download; Hub ids are also accepted and passed through as --dataset-path. "
+        "Sets VLLM_VIDEOMME_DATASET_PATH.",
+    )
+    p.add_argument(
+        "--videomme-parquet",
+        type=Path,
+        default=None,
+        help="Optional explicit path to videomme/test-*.parquet.",
+    )
+    p.add_argument(
+        "--videomme-video-dir",
+        type=Path,
+        default=None,
+        help="Optional explicit directory of extracted Video-MME videos.",
+    )
+    p.add_argument(
+        "--videomme-subtitle-dir",
+        type=Path,
+        default=None,
+        help="Optional subtitle directory (used with --videomme-use-subtitle).",
+    )
+    p.add_argument(
+        "--videomme-pack-mode",
+        choices=("minicpm-frames", "minicpm-interleave", "video_url"),
+        default="minicpm-frames",
+        help="Video-MME multimodal pack recipe (OmniEvalKit MiniCPM default: minicpm-frames).",
+    )
+    p.add_argument(
+        "--videomme-max-frames",
+        type=int,
+        default=None,
+        help="Override max sampled frames (OmniEvalKit: 96 for minicpm-frames, 64 for interleave).",
+    )
+    p.add_argument(
+        "--videomme-duration",
+        choices=("all", "short", "medium", "long"),
+        default="all",
+        help="Filter Video-MME by duration bucket (default: all).",
+    )
+    p.add_argument(
+        "--videomme-use-subtitle",
+        action="store_true",
+        help="Prepend subtitle text to the user prompt (Video-MME w/ subs).",
+    )
+    p.add_argument(
+        "--videomme-inline-local-video",
+        action="store_true",
+        help="Embed frames/audio as base64 data URLs (no --allowed-local-media-path on the server).",
+    )
+    p.add_argument(
+        "--videomme-extra-body-json",
+        default='{"modalities":["text"],"chat_template_kwargs":{"enable_thinking":false}}',
+        help="JSON merged into each chat request for Video-MME.",
+    )
+    p.add_argument(
+        "--videomme-save-eval-items",
+        action="store_true",
+        help="Include per-request Video-MME accuracy rows in the saved JSON.",
+    )
+    p.add_argument(
+        "--min-videomme-accuracy",
+        type=float,
+        default=float((os.environ.get("ACC_BENCH_MIN_VIDEOMME_ACCURACY") or "0.68").strip() or "0.68"),
+        help="Fail when videomme_accuracy is strictly below this threshold (0–1). "
+        "Default 0.68 (~2pp under MiniCPM-o 4.5 reported 70.4 w/o subs); "
+        "override with ACC_BENCH_MIN_VIDEOMME_ACCURACY or pass 0 to disable the floor.",
+    )
+
     p.add_argument(
         "--seed-tts-dataset-path",
         type=str,
@@ -427,7 +639,7 @@ def parse_acc_benchmark_args(argv: list[str] | None = None) -> argparse.Namespac
 
 
 def run_acc_benchmark(ns: argparse.Namespace) -> int:
-    """Run Daily-Omni and/or Seed-TTS client benches against a running server; return 0 on success."""
+    """Run Daily-Omni / Video-MME / Seed-TTS client benches against a running server; return 0 on success."""
     failed: list[str] = []
 
     with _preserve_benchmark_dataset_env():
@@ -451,6 +663,21 @@ def run_acc_benchmark(ns: argparse.Namespace) -> int:
                     flush=True,
                 )
 
+        if not ns.skip_videomme:
+            path = run_videomme(ns, vllm)
+            print(f"\n[Video-MME] result JSON: {path}", flush=True)
+            data = load_benchmark_result(path)
+            errs = _validate_videomme(data, min_accuracy=ns.min_videomme_accuracy)
+            if errs:
+                failed.extend([f"[Video-MME] {e}" for e in errs])
+            else:
+                print(
+                    f"[Video-MME] videomme_accuracy={data.get('videomme_accuracy')} "
+                    f"evaluated_ok={data.get('videomme_evaluated_ok')} "
+                    f"per_duration={data.get('videomme_per_duration_accuracy')}",
+                    flush=True,
+                )
+
         if not ns.skip_seed_tts:
             path = run_seed_tts(ns, vllm)
             print(f"\n[Seed-TTS] result JSON: {path}", flush=True)
diff --git a/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py b/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
index bc656723b..15aa4d739 100644
--- a/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
+++ b/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
@@ -73,7 +73,7 @@ def _baseline_path() -> Path:
     return path
 
 
-_OFFLINE_SCRIPT = _REPO_ROOT / "examples" / "offline_inference" / "hunyuan_image3" / "end2end.py"
+_OFFLINE_SCRIPT = _REPO_ROOT / "examples" / "offline_inference" / "text_to_image" / "text_to_image.py"
 
 # DiT-only deploy config with trust_remote_code (based on hunyuan_image3_dit.yaml).
 _DEPLOY_CONFIG: dict[str, Any] = {
@@ -228,20 +228,17 @@ def _run_vllm_omni_hunyuan_image3_offline(*, model: str, deploy_config: str, out
     import subprocess
     import sys
 
-    output_dir = str(output_path.parent)
     subprocess.run(
         [
             sys.executable,
             str(_OFFLINE_SCRIPT),
-            "--modality",
-            "text2img",
             "--deploy-config",
             deploy_config,
-            "--prompts",
+            "--prompt",
             PROMPT,
             "--output",
-            output_dir,
-            "--steps",
+            str(output_path),
+            "--num-inference-steps",
             str(NUM_INFERENCE_STEPS),
             "--guidance-scale",
             str(GUIDANCE_SCALE),
@@ -251,21 +248,21 @@ def _run_vllm_omni_hunyuan_image3_offline(*, model: str, deploy_config: str, out
             str(HEIGHT),
             "--width",
             str(WIDTH),
-            "--bot-task",
-            "none",
-            "--sys-type",
+            "--use-system-prompt",
             "en_unified",
+            "--extra-body",
+            '{"bot_task": "none"}',
+            "--trust-remote-code",
             "--model",
             model,
             "--enforce-eager",
+            "--enable-expert-parallel",
         ],
         check=True,
     )
-    images = sorted(Path(output_dir).glob("output_*.png"))
-    assert images, f"No output image found in {output_dir}"
-    image = Image.open(images[0]).convert("RGB")
+    assert output_path.exists(), f"No output image at {output_path}"
+    image = Image.open(output_path).convert("RGB")
     image.load()
-    image.save(output_path)
     return image
 
 
diff --git a/tests/e2e/accuracy/test_qwen_image.py b/tests/e2e/accuracy/test_qwen_image.py
index fb2f8cbc8..1fca04f99 100644
--- a/tests/e2e/accuracy/test_qwen_image.py
+++ b/tests/e2e/accuracy/test_qwen_image.py
@@ -32,9 +32,9 @@ HEIGHT = 512
 NUM_INFERENCE_STEPS = 20
 TRUE_CFG_SCALE = 4.0
 SEED = 42
-SSIM_THRESHOLD = 0.94
-# With --fa-deterministic, H100 nightlies stably land near SSIM 0.958 / PSNR 27.8
-# vs Diffusers on the FA3 hub path (see #5734 / #5963 / #6971).
+# H100 nightly after RotaryEmbedding CUDA RoPE: SSIM 0.978375 / PSNR 31.83
+# vs Diffusers (Buildkite #15339). SSIM 0.97 so a drop is visible.
+SSIM_THRESHOLD = 0.97
 PSNR_THRESHOLD = 27.0
 
 MODEL_2512_ID = "Qwen/Qwen-Image-2512"
diff --git a/tests/e2e/features/comfyui/test_comfyui_integration.py b/tests/e2e/features/comfyui/test_comfyui_integration.py
index fe42dd9bf..113879951 100644
--- a/tests/e2e/features/comfyui/test_comfyui_integration.py
+++ b/tests/e2e/features/comfyui/test_comfyui_integration.py
@@ -28,6 +28,7 @@ from comfy_api.input import AudioInput, VideoInput
 from comfyui_vllm_omni.nodes import (
     VLLMOmniFastH3Deployment,
     VLLMOmniGenerateImage,
+    VLLMOmniGenerateMusic,
     VLLMOmniGenerateVideo,
     VLLMOmniTTS,
     VLLMOmniUnderstanding,
@@ -62,6 +63,7 @@ class ServerCase(NamedTuple):
     stage_list: list
     stage_configs: list[Any]
     outputs: list[OmniRequestOutput]
+    tokenizer: Any = None
 
 
 class SamplingCase(NamedTuple):
@@ -79,8 +81,10 @@ class SamplingKind(str, Enum):
     UNDERSTANDING_AR_LIST = "understanding_ar_list"
     TTS_NONE = "tts_none"
     TTS_DIFFUSION_SINGLE = "tts_diffusion_single"
+    MUSIC_NONE = "music_none"
     VIDEO_NONE = "video_none"
     VIDEO_DIFFUSION_SINGLE = "video_diffusion_single"
+    VIDEO_FL2VA = "video_fl2va"
     VIDEO_FASTH3 = "video_fasth3"
     VIDEO_REF2VA_IMAGE_AUDIO = "video_ref2va_image_audio"
     VIDEO_REF2VA_MULTI_VIDEO = "video_ref2va_multi_video"
@@ -147,7 +151,7 @@ AR_LIST_SAMPLING_PARAMS = [
 
 VIDEO_MODEL_PARAMS = WanModelSpecificParams({"guidance_scale_2": 5.0, "boundary_ratio": 0.98, "flow_shift": 12.0})
 
-# Matches MiniMax-H3 recipe Ref2VA defaults (task is auto-routed by the client).
+# Matches MiniMax-H3 recipe defaults (task is auto-routed by the client).
 H3_MODEL_PARAMS = MiniMaxH3ModelSpecificParams(
     {
         "type": "minimax_h3",
@@ -380,6 +384,11 @@ def _build_mock_outputs(outputs: Iterable[OmniRequestOutput], sampling_case: Sam
             assert len(received_sampling_params_list) == 3
             for i, expected in enumerate(AR_LIST_SAMPLING_PARAMS):
                 _assert_sampling_param_values(received_sampling_params_list[i], expected)
+        elif sampling_case.kind is SamplingKind.MUSIC_NONE:
+            assert len(received_sampling_params_list) == 2
+            assert prompt["prompt_token_ids"] == [101, 102, 103]
+            assert prompt["additional_information"]["max_audio_frames"] == [1512]
+            assert received_sampling_params_list[0].seed == 7
         elif sampling_case.kind in {SamplingKind.TTS_NONE, SamplingKind.TTS_DIFFUSION_SINGLE}:
             assert len(received_sampling_params_list) == 1
         elif sampling_case.kind is SamplingKind.VIDEO_NONE:
@@ -409,6 +418,34 @@ def _build_mock_outputs(outputs: Iterable[OmniRequestOutput], sampling_case: Sam
                 LORA_PARAMS,
             )
             _assert_model_param_values(received_sampling_params_list[0], VIDEO_MODEL_PARAMS)
+        elif sampling_case.kind is SamplingKind.VIDEO_FL2VA:
+            assert len(received_sampling_params_list) == 1
+            assert isinstance(prompt, dict)
+            multi_modal_data = prompt.get("multi_modal_data")
+            assert isinstance(multi_modal_data, dict)
+            input_images = multi_modal_data.get("image")
+
+            if isinstance(input_images, list):
+                assert len(input_images) == 2
+                assert input_images[0].getpixel((0, 0)) == (0, 0, 0)
+                assert input_images[1].getpixel((0, 0)) == (255, 255, 255)
+                expected_frame_indices = [0, -1]
+            else:
+                assert isinstance(input_images, Image.Image)
+                pixel = input_images.getpixel((0, 0))
+                assert pixel in {(0, 0, 0), (255, 255, 255)}
+                is_first_frame = pixel == (0, 0, 0)
+                expected_frame_indices = [0] if is_first_frame else [-1]
+
+            _assert_model_param_values(
+                received_sampling_params_list[0],
+                {
+                    "flow_shift": 12.0,
+                    "task": "fl2va",
+                    "audio_flow_shift": 3.0,
+                    "frame_indices": expected_frame_indices,
+                },
+            )
         elif sampling_case.kind is SamplingKind.VIDEO_FASTH3:
             assert len(received_sampling_params_list) == 1
             received = received_sampling_params_list[0]
@@ -525,12 +562,17 @@ def mock_async_omni(
     # Need to mock AsyncOmni itself (not only its generate method) because
     # 1. The API layer uses its stage_list and stage_configs attributes
     # 2. Its __init__ method has slow side effects (model & config loading).
+    # These cases use the non-duplex mock engine without loading model configs.
+    mocker.patch("vllm_omni.entrypoints.openai.api_server._should_serve_duplex", return_value=False)
     mock_async_omni_cls = mocker.patch("vllm_omni.entrypoints.openai.api_server.AsyncOmni")
     monkeypatch.setattr(
         "vllm_omni.entrypoints.openai.serving_chat.OmniOpenAIServingChat._preprocess_chat",
         _mock_preprocess_chat,
     )
 
+    if server_case.tokenizer is not None:
+        mocker.patch("transformers.AutoTokenizer.from_pretrained", return_value=server_case.tokenizer)
+
     mock_instance = mocker.AsyncMock(spec=RealAsyncOmni)
     mock_instance.generate = _build_mock_outputs(server_case.outputs, sampling_case, server_case)
 
@@ -558,7 +600,7 @@ def mock_async_omni(
     mock_instance.shutdown = mocker.MagicMock()
     mock_instance.get_vllm_config = mocker.AsyncMock(return_value=None)
     mock_instance.get_supported_tasks = mocker.AsyncMock(return_value=["generate"])
-    mock_instance.get_tokenizer = mocker.AsyncMock(return_value=None)
+    mock_instance.get_tokenizer = mocker.AsyncMock(return_value=server_case.tokenizer)
 
     mock_async_omni_cls.return_value = mock_instance
     yield mock_async_omni_cls
@@ -924,6 +966,164 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
     assert isinstance(result[0], VideoInput)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "server_case",
+    [
+        pytest.param(
+            ServerCase(
+                served_model="MiniMaxAI/MiniMax-H3",
+                stage_list=["diffusion"],
+                stage_configs=[H3_STAGE_CONFIG],
+                outputs=[_build_diffusion_video_output()],
+            ),
+            id="minimax-h3",
+        ),
+    ],
+    indirect=True,
+)
+@pytest.mark.parametrize(
+    "sampling_case",
+    [pytest.param(SamplingCase(kind=SamplingKind.VIDEO_FL2VA, sampling_params=None), id="fl2va")],
+    indirect=True,
+)
+@pytest.mark.parametrize(
+    "frame_selection",
+    [
+        pytest.param("first", id="first-frame"),
+        pytest.param("last", id="last-frame"),
+        pytest.param("both", id="first-and-last-frame"),
+    ],
+)
+async def test_video_generation_node_minimax_h3_fl2va(
+    api_server: str,
+    sampling_case: SamplingCase,
+    frame_selection: str,
+):
+    node = VLLMOmniGenerateVideo()
+    first_frame = torch.zeros((1, VIDEO_HEIGHT, VIDEO_WIDTH, 3), dtype=torch.float32)
+    last_frame = torch.ones((1, VIDEO_HEIGHT, VIDEO_WIDTH, 3), dtype=torch.float32)
+    frame_inputs = {
+        "first": {"first_frame": first_frame},
+        "last": {"last_frame": last_frame},
+        "both": {"first_frame": first_frame, "last_frame": last_frame},
+    }[frame_selection]
+
+    result = await node.generate(
+        url=api_server,
+        model="MiniMaxAI/MiniMax-H3",
+        prompt="A cinematic transition between the supplied keyframes.",
+        negative_prompt="",
+        width=VIDEO_WIDTH,
+        height=VIDEO_HEIGHT,
+        fps=VIDEO_FPS,
+        duration=VIDEO_DURATION,
+        model_params=H3_MODEL_PARAMS,
+        **frame_inputs,
+    )
+
+    assert isinstance(result, tuple)
+    assert len(result) == 1
+    assert isinstance(result[0], VideoInput)
+
+
+def test_video_generation_node_exposes_explicit_keyframe_inputs():
+    node_inputs = VLLMOmniGenerateVideo.INPUT_TYPES()
+    optional_inputs = node_inputs["optional"]
+
+    assert optional_inputs["first_frame"] == ("IMAGE",)
+    assert optional_inputs["last_frame"] == ("IMAGE",)
+    assert node_inputs["required"]["duration"][0] == "FLOAT"
+    assert "num_frames" not in node_inputs["required"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("kwargs", "message"),
+    [
+        ({"frame": object(), "first_frame": object()}, "frame or first_frame/last_frame"),
+        ({"frame": object(), "last_frame": object()}, "frame or first_frame/last_frame"),
+        ({"last_frame": object(), "references": {}}, "first_frame/last_frame or references"),
+    ],
+)
+async def test_video_generation_node_rejects_conflicting_frame_inputs(kwargs: dict, message: str):
+    node = VLLMOmniGenerateVideo()
+    validation_result = node.VALIDATE_INPUTS(
+        url="http://localhost:8000/v1",
+        model="MiniMaxAI/MiniMax-H3",
+        **kwargs,
+    )
+
+    assert isinstance(validation_result, str)
+    assert message in validation_result
+
+    with pytest.raises(ValueError, match=message):
+        await node.generate(
+            url="http://localhost:8000/v1",
+            model="MiniMaxAI/MiniMax-H3",
+            prompt="test",
+            width=VIDEO_WIDTH,
+            height=VIDEO_HEIGHT,
+            fps=VIDEO_FPS,
+            duration=VIDEO_DURATION,
+            **kwargs,
+        )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("keyframe_name", ["first_frame", "last_frame"])
+async def test_video_generation_node_rejects_keyframes_with_fast_h3(keyframe_name: str):
+    node = VLLMOmniGenerateVideo()
+    fast_h3 = {"url": "http://localhost:8000/v1", "model": "MiniMaxAI/MiniMax-H3"}
+    keyframe = {keyframe_name: object()}
+
+    validation_result = node.VALIDATE_INPUTS(
+        url="http://ignored.invalid/v1",
+        model="ignored-model",
+        fast_h3=fast_h3,
+        **keyframe,
+    )
+
+    assert isinstance(validation_result, str)
+    assert "FastH3 Preview supports T2VA only" in validation_result
+
+    with pytest.raises(ValueError, match="FastH3 Preview supports T2VA only"):
+        await node.generate(
+            url="http://ignored.invalid/v1",
+            model="ignored-model",
+            prompt="test",
+            width=VIDEO_WIDTH,
+            height=VIDEO_HEIGHT,
+            fps=VIDEO_FPS,
+            duration=VIDEO_DURATION,
+            fast_h3=fast_h3,
+            **keyframe,
+        )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "keyframes",
+    [
+        {"first_frame": object()},
+        {"last_frame": object()},
+        {"first_frame": object(), "last_frame": object()},
+    ],
+)
+async def test_video_generation_node_rejects_h3_keyframes_for_other_models(keyframes: dict):
+    with pytest.raises(ValueError, match="supported only for MiniMax-H3; use frame"):
+        await VLLMOmniGenerateVideo().generate(
+            url="http://localhost:8000/v1",
+            model="Wan-AI/Wan2.2-I2V-A14B-Diffusers",
+            prompt="test",
+            width=VIDEO_WIDTH,
+            height=VIDEO_HEIGHT,
+            fps=VIDEO_FPS,
+            duration=VIDEO_DURATION,
+            **keyframes,
+        )
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "server_case,deployment_model",
@@ -1081,3 +1281,66 @@ async def test_video_generation_node_minimax_h3_ref2va(
     assert isinstance(result, tuple)
     assert len(result) == 1
     assert isinstance(result[0], VideoInput)
+
+
+def _build_music_tokenizer():
+    # Checkpoint token IDs required by the API adapter's tokenizer validation.
+    special_token_ids = {
+        "<|im_start|>": 151644,
+        "<|im_end|>": 151645,
+        "<|audio_cfg|>": 151654,
+        "<|audio_start|>": 151669,
+        "<|audio_end|>": 151670,
+        "<|caption_start|>": 151671,
+        "<|caption_end|>": 151672,
+        "<|lyrics_start|>": 151673,
+        "<|lyrics_end|>": 151674,
+    }
+
+    def encode(prompt):
+        assert prompt == (
+            "<|im_start|><|caption_start|>Warm acoustic pop at 92 BPM"
+            "<|caption_end|><|lyrics_start|>[start]\n[verse]\nThe morning light"
+            "<|lyrics_end|><|im_end|><|audio_start|>"
+        )
+        return [101, 102, 103]
+
+    return SimpleNamespace(encode=encode, convert_tokens_to_ids=special_token_ids.get)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "server_case",
+    [
+        ServerCase(
+            served_model="MiniMaxAI/MiniMax-Music3",
+            stage_list=["llm", "llm"],
+            stage_configs=[
+                _make_stage_config("llm", model_stage="minimax_music3_ar"),
+                _make_stage_config("llm", model_stage="minimax_music3_acoustic"),
+            ],
+            outputs=[_build_audio_speech_output()],
+            tokenizer=_build_music_tokenizer(),
+        )
+    ],
+    indirect=True,
+)
+@pytest.mark.parametrize(
+    "sampling_case",
+    [SamplingCase(kind=SamplingKind.MUSIC_NONE, sampling_params=None)],
+    indirect=True,
+)
+async def test_music_generation_node_minimax_music3(api_server: str, sampling_case: SamplingCase):
+    result = await VLLMOmniGenerateMusic().generate(
+        url=api_server,
+        model="MiniMaxAI/MiniMax-Music3",
+        lyrics="[Verse]\nThe morning light",
+        instructions="Warm acoustic pop at 92 BPM",
+        max_duration_seconds=60.5,
+        seed=7,
+        response_format="wav",
+    )
+    assert isinstance(result, tuple)
+    assert len(result) == 1
+    assert result[0]["sample_rate"] == 24000
+    assert result[0]["waveform"].shape == (1, 1, 24000)
diff --git a/tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py b/tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py
index 56a960121..4bea6563b 100644
--- a/tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py
+++ b/tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py
@@ -21,6 +21,7 @@ import torch.distributed as dist
 from transformers import AutoTokenizer
 
 from tests.helpers.mark import hardware_test
+from vllm_omni.config.omni_config import VllmOmniDiffusionStageConfig
 from vllm_omni.diffusion.executor.uniproc_executor import UniProcDiffusionExecutor
 from vllm_omni.diffusion.inline_stage_diffusion_client import InlineStageDiffusionClient
 from vllm_omni.entrypoints.async_omni import AsyncOmni
@@ -136,6 +137,15 @@ async def _generate_once(
 
 def _assert_live_uniproc_worker(engine: AsyncOmni) -> None:
     """Default single-GPU path must use the in-process executor, not mp IPC."""
+    stage_configs = engine.engine.stage_configs
+    assert len(stage_configs) == 1
+    stage_config = stage_configs[0]
+    assert isinstance(stage_config, VllmOmniDiffusionStageConfig)
+    assert stage_config.model_config.model == MODEL
+    assert stage_config.model_config.enforce_eager is True
+    assert stage_config.scheduler_config.max_num_seqs == 1
+    assert stage_config.diffusion_config.custom_pipeline_args == {"pipeline_class": CUSTOM_PIPELINE_CLASS}
+    assert stage_config.diffusion_config.worker_extension_cls == WORKER_EXTENSION_CLASS
     clients = engine.engine.stage_clients
     assert len(clients) == 1
     client = clients[0]
diff --git a/tests/e2e/features/helpers/verl_omni_server.py b/tests/e2e/features/helpers/verl_omni_server.py
index a38a3a12e..9d9815a1e 100644
--- a/tests/e2e/features/helpers/verl_omni_server.py
+++ b/tests/e2e/features/helpers/verl_omni_server.py
@@ -10,11 +10,9 @@ Ray workers can unpickle ``vLLMOmniHttpServerLocal`` via
 
 from __future__ import annotations
 
-import argparse
 import json
 import logging
 import os
-from dataclasses import asdict
 from enum import Enum
 from typing import Any
 
@@ -22,14 +20,13 @@ import torchvision.transforms as T
 from omegaconf import DictConfig, OmegaConf
 from pydantic import BaseModel, ConfigDict
 from vllm.entrypoints.openai.api_server import build_app
-from vllm.utils.argparse_utils import FlexibleArgumentParser
 
 import vllm_omni.entrypoints.cli.serve
-from vllm_omni.engine.arg_utils import OmniEngineArgs
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 from vllm_omni.entrypoints.openai.api_server import omni_init_app_state
 from vllm_omni.inputs.data import OmniCustomPrompt, OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
+from vllm_omni.utils.tracking_parser import TrackingArgumentParser, TrackingNamespace
 
 logger = logging.getLogger(__name__)
 
@@ -183,7 +180,6 @@ class vLLMOmniHttpServerLocal:
             "tensor_parallel_size": _cfg_get(self.config, "tensor_model_parallel_size", 1),
             "seed": self.replica_rank + int(_cfg_get(self.config, "seed", 0) or 0),
             "override_generation_config": json.dumps({}),
-            "scheduling_policy": _cfg_get(self.config, "scheduling_policy", "fcfs"),
             "compilation_config": compilation_config,
             **engine_kwargs,
         }
@@ -191,7 +187,7 @@ class vLLMOmniHttpServerLocal:
         model_path = str(_cfg_get(self.model_config, "local_path", None) or _cfg_get(self.model_config, "path"))
         server_args_list = ["serve", model_path] + build_cli_args_from_config(args)
 
-        parser = FlexibleArgumentParser(description="vLLM-Omni CLI")
+        parser = TrackingArgumentParser(description="vLLM-Omni CLI")
         subparsers = parser.add_subparsers(required=False, dest="subparser")
         cmds: dict[str, Any] = {}
         for cmd in vllm_omni.entrypoints.cli.serve.cmd_init():
@@ -204,11 +200,10 @@ class vLLMOmniHttpServerLocal:
 
         await self.run_server(parsed)
 
-    async def run_server(self, args: argparse.Namespace) -> None:
-        engine_args = OmniEngineArgs.from_cli_args(args)
-        engine_args = asdict(engine_args)
-
-        engine_args["enable_dummy_pipeline"] = True
+    async def run_server(self, args: TrackingNamespace) -> None:
+        # Match the production entrypoint: parser defaults are not user overrides.
+        engine_args = args.get_explicit_kwargs_dict()
+        engine_args["model"] = args.model
         engine_args["custom_pipeline_args"] = {"pipeline_class": CUSTOM_PIPELINE_CLASS}
 
         engine_client = AsyncOmni(**engine_args)
diff --git a/tests/e2e/offline_inference/test_anima.py b/tests/e2e/offline_inference/test_anima.py
new file mode 100644
index 000000000..877fcfe2d
--- /dev/null
+++ b/tests/e2e/offline_inference/test_anima.py
@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Offline e2e smoke test for native Anima single-file checkpoints."""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniRunner, OmniRunnerHandler
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+CHECKPOINT_ENV = "ANIMA_CHECKPOINT_PATH"
+COMPONENTS_ENV = "ANIMA_COMPONENTS_PATH"
+CHECKPOINT_REPO = "circlestone-labs/Anima"
+CHECKPOINT_FILENAME = "split_files/diffusion_models/anima-base-v1.0.safetensors"
+COMPONENTS_REPO = "circlestone-labs/Anima-Base-v1.0-Diffusers"
+PROMPT = "A cinematic close-up of a glass teapot on a wooden table."
+
+
+def _resolve_anima_assets() -> tuple[str, str]:
+    checkpoint = os.environ.get(CHECKPOINT_ENV)
+    components = os.environ.get(COMPONENTS_ENV)
+    if checkpoint and components:
+        return checkpoint, components
+
+    from huggingface_hub import hf_hub_download, snapshot_download
+
+    if checkpoint is None:
+        checkpoint = hf_hub_download(
+            repo_id=CHECKPOINT_REPO,
+            filename=CHECKPOINT_FILENAME,
+        )
+    if components is None:
+        components = snapshot_download(repo_id=COMPONENTS_REPO)
+    return checkpoint, components
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+@pytest.mark.parametrize("guidance_scale", [1.0, 4.0])
+def test_anima_text_to_image(guidance_scale):
+    checkpoint, components = _resolve_anima_assets()
+    request_config = {
+        "model": checkpoint,
+        "prompt": PROMPT,
+        "sampling_params": OmniDiffusionSamplingParams(
+            height=256,
+            width=256,
+            num_inference_steps=1,
+            guidance_scale=guidance_scale,
+            seed=42,
+        ),
+    }
+    with OmniRunner(
+        checkpoint,
+        seed=42,
+        model_class_name="AnimaPipeline",
+        custom_pipeline_args={"components_path": components},
+    ) as runner:
+        OmniRunnerHandler(runner).send_diffusion_request(request_config)
diff --git a/tests/e2e/offline_inference/test_dots_tts_expansion.py b/tests/e2e/offline_inference/test_dots_tts_expansion.py
deleted file mode 100644
index 4d13f03fd..000000000
--- a/tests/e2e/offline_inference/test_dots_tts_expansion.py
+++ /dev/null
@@ -1,129 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""E2E tests for dots.tts native AR offline inference."""
-
-from collections.abc import Mapping
-
-import pytest
-import torch
-
-from tests.helpers.mark import hardware_test
-from tests.helpers.runtime import OmniRunner
-from tests.helpers.stage_config import get_deploy_config_path
-
-DOTS_TTS_MODEL = "rednote-hilab/dots.tts-soar"
-DEPLOY_CONFIG = get_deploy_config_path("dots_tts.yaml")
-SAMPLE_RATE = 48000
-
-# dots.tts ships a custom tokenizer carrying the added ``<|audio_gen_start|>``
-# token, so remote code must be explicitly enabled.
-_OMNI_RUNNER_PARAM = (DOTS_TTS_MODEL, DEPLOY_CONFIG, {"trust_remote_code": True})
-
-pytestmark = pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True)
-
-
-def _build_prompt(omni_runner: OmniRunner, text: str) -> dict:
-    """Wrap ``text`` in the prefix scaffold dots.tts prefill expects.
-
-    Unlike most TTS models here, a bare ``{"prompt": ...}`` string does not
-    work: prefill needs ``[文本]<text>[文本对应语音]<|audio_gen_start|>`` as
-    real Qwen2 token ids.
-    """
-    from transformers import AutoTokenizer
-
-    from vllm_omni.model_executor.models.dots_tts.dots_tts_prompt import (
-        build_dots_tts_prompt,
-    )
-
-    tokenizer = AutoTokenizer.from_pretrained(omni_runner.model_name, trust_remote_code=True)
-    return build_dots_tts_prompt(tokenizer=tokenizer, text=text)
-
-
-def _extract_audio(multimodal_output: dict) -> torch.Tensor:
-    """Extract the final complete audio tensor from multimodal output."""
-    assert isinstance(multimodal_output, (dict, Mapping)), f"Expected dict/Mapping, got {type(multimodal_output)}"
-
-    # The talker emits delta chunks; the output processor accumulates them
-    # under "model_outputs" ("audio" kept for backwards compat).
-    audio = multimodal_output.get("model_outputs")
-    if audio is None:
-        audio = multimodal_output.get("audio")
-    assert audio is not None, f"No audio key, got {list(multimodal_output.keys())}"
-
-    if isinstance(audio, list):
-        valid = [torch.as_tensor(x).float().cpu().reshape(-1) for x in audio if x is not None]
-        assert valid, "No valid audio tensors in output list"
-        audio = torch.cat(valid, dim=0) if len(valid) > 1 else valid[0]
-
-    assert isinstance(audio, torch.Tensor), f"Expected Tensor, got {type(audio)}"
-    return audio.float().cpu().reshape(-1)
-
-
-@pytest.mark.slow
-@pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_dots_tts_zero_shot_001(omni_runner: OmniRunner) -> None:
-    """Zero-shot synthesis produces audio of a plausible duration."""
-    prompt = _build_prompt(omni_runner, "Hello, this is a test of dots TTS running on vLLM Omni.")
-
-    outputs = omni_runner.omni.generate([prompt])
-    assert len(outputs) == 1
-
-    audio = _extract_audio(outputs[0].outputs[0].multimodal_output)
-    duration_s = audio.shape[0] / SAMPLE_RATE
-    assert 0.5 < duration_s < 30.0, f"Audio duration out of range: {duration_s:.2f}s"
-    assert torch.isfinite(audio).all(), "Audio contains NaN/Inf"
-    assert audio.abs().max() > 1e-3, "Audio is silent"
-
-
-@pytest.mark.slow
-@pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_dots_tts_prefill_decode_mixed_batch_002(omni_runner: OmniRunner) -> None:
-    """Mixed prefill+decode batches must keep per-request rows aligned.
-
-    ``compute_logits`` fills ``logits[i]`` positionally from
-    ``_results_queue``, so every request in the batch has to push exactly one
-    entry per step, prefills included. When the prefill branch pushed nothing,
-    a shorter request's stop signal could be read into another request's row.
-    Regression guard for that pairing (PR #4765 review).
-    """
-    long_text = (
-        "This is a deliberately long sentence that stays in the decode phase "
-        "for many steps, so the shorter requests behind it keep entering "
-        "prefill alongside it and reproduce the mixed batch pattern."
-    )
-    short_texts = ["Hello one.", "Hello two.", "Hello three.", "Hello four."]
-    prompts = [_build_prompt(omni_runner, long_text)] + [_build_prompt(omni_runner, t) for t in short_texts]
-
-    outputs = omni_runner.omni.generate(prompts)
-    assert len(outputs) == len(prompts)
-
-    for i, out in enumerate(outputs):
-        audio = _extract_audio(out.outputs[0].multimodal_output)
-        duration_s = audio.shape[0] / SAMPLE_RATE
-        assert 0.1 < duration_s < 30.0, f"Request {i} audio duration out of range: {duration_s:.2f}s"
-
-
-@pytest.mark.slow
-@pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_dots_tts_deterministic_flow_matching_noise_003(omni_runner: OmniRunner) -> None:
-    """The same text twice must yield the same audio.
-
-    The DiT flow-matching noise is drawn from a per-request generator seeded
-    from ``blake2b(seed:request_key:noise_step)`` rather than the global CUDA
-    RNG. Drawing from the global RNG made output non-reproducible and let
-    concurrent requests perturb each other's noise streams (PR #4765 review).
-    """
-    text = "Reading aloud every evening helps children build a lasting love of language."
-
-    first = _extract_audio(
-        omni_runner.omni.generate([_build_prompt(omni_runner, text)])[0].outputs[0].multimodal_output
-    )
-    second = _extract_audio(
-        omni_runner.omni.generate([_build_prompt(omni_runner, text)])[0].outputs[0].multimodal_output
-    )
-
-    assert first.shape == second.shape, f"Length differs across runs: {first.shape} vs {second.shape}"
-    assert torch.allclose(first, second, atol=1e-4), "Audio differs across runs; flow-matching noise is not seeded"
diff --git a/tests/e2e/offline_inference/test_dynin_omni_expansion.py b/tests/e2e/offline_inference/test_dynin_omni_expansion.py
deleted file mode 100644
index 922518557..000000000
--- a/tests/e2e/offline_inference/test_dynin_omni_expansion.py
+++ /dev/null
@@ -1,374 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""
-E2E offline smoke tests for Dynin-Omni.
-
-- model: "snu-aidas/Dynin-Omni"
-- stage config: vllm_omni/deploy/dynin_omni_ci.yaml
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-import pytest
-import torch
-from transformers import AutoTokenizer
-
-from tests.helpers.mark import hardware_test
-from tests.helpers.stage_config import get_deploy_config_path
-
-os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-
-_REPO_ROOT = Path(__file__).resolve().parents[3]
-_DEFAULT_DYNIN_CONFIG_PATH: Path | None = None
-_DEFAULT_STAGE_CONFIG_PATH = Path(get_deploy_config_path("dynin_omni_ci.yaml"))
-
-models = ["snu-aidas/Dynin-Omni"]
-stage_configs = [str(_DEFAULT_STAGE_CONFIG_PATH)]
-test_params = [(model, stage_config, {"trust_remote_code": True}) for model in models for stage_config in stage_configs]
-
-DYNIN_CONFIG_PATH = str(_DEFAULT_DYNIN_CONFIG_PATH) if _DEFAULT_DYNIN_CONFIG_PATH is not None else None
-
-pytestmark = [
-    pytest.mark.slow,
-    pytest.mark.omni,
-    pytest.mark.parametrize("omni_runner", test_params, indirect=True),
-]
-
-
-# prompting util
-def _build_mmu_prompt(tokenizer: Any, question: str, dynin_config_path: str | None) -> dict[str, Any]:
-    encoded = tokenizer(question, return_tensors="pt", add_special_tokens=True)
-    token_ids = [int(v) for v in encoded["input_ids"][0].tolist()]
-    attention_mask = [int(v) for v in encoded["attention_mask"][0].tolist()]
-    additional_information: dict[str, Any] = {
-        "task": ["mmu"],
-        "detok_id": [0],
-        "prompt_length": [len(token_ids)],
-        "attention_mask": [attention_mask],
-        "max_new_tokens": [64],
-        "steps": [64],
-        "block_length": [16],
-        "temperature": [0.0],
-    }
-    if dynin_config_path:
-        additional_information["dynin_config_path"] = [str(dynin_config_path)]
-    return {
-        "prompt_token_ids": token_ids,
-        "additional_information": additional_information,
-        "modalities": ["text"],
-    }
-
-
-def _build_mmu_multimodal_prompt(
-    tokenizer: Any,
-    question: str,
-    dynin_config_path: str | None,
-    *,
-    image: Any | None = None,
-    audio: tuple[np.ndarray, int] | None = None,
-) -> dict[str, Any]:
-    if image is None and audio is None:
-        raise ValueError("At least one multimodal input (image or audio) must be provided.")
-
-    prefix_chunks: list[str] = []
-    mm_data: dict[str, Any] = {}
-    if image is not None:
-        prefix_chunks.append("<|soi|><|image|><|eoi|>")
-        mm_data["image"] = image
-    if audio is not None:
-        prefix_chunks.append("<|soa|><|audio|><|eoa|>")
-        mm_data["audio"] = audio
-
-    prefixed_question = " ".join(prefix_chunks + [question]).strip()
-    prompt = _build_mmu_prompt(
-        tokenizer=tokenizer,
-        question=prefixed_question,
-        dynin_config_path=dynin_config_path,
-    )
-    prompt["multi_modal_data"] = mm_data
-    prompt["modalities"] = ["text"]
-    return prompt
-
-
-def _generate_synthetic_image(width: int = 224, height: int = 224) -> np.ndarray:
-    x = np.linspace(0, 255, width, dtype=np.uint8)
-    y = np.linspace(0, 255, height, dtype=np.uint8)[:, None]
-    red = np.tile(x, (height, 1))
-    green = np.tile(y, (1, width))
-    blue = ((red.astype(np.uint16) + green.astype(np.uint16)) // 2).astype(np.uint8)
-    return np.stack([red, green, blue], axis=-1)
-
-
-def _generate_synthetic_audio(duration_s: int = 5, sample_rate: int = 48_000) -> tuple[np.ndarray, int]:
-    t = np.linspace(0, duration_s, int(sample_rate * duration_s), endpoint=False, dtype=np.float32)
-    waveform = 0.1 * np.sin(2.0 * np.pi * 440.0 * t)
-    return waveform.astype(np.float32), sample_rate
-
-
-# prompting util
-def _build_t2s_decode_prompt(dynin_config_path: str | None) -> dict[str, Any]:
-    # Bypass stage-0 generation and directly validate token->audio decode path.
-    generated_audio_token_ids = [int(v) for v in ([10, 11, 12, 13, 14] * 32)]
-    additional_information: dict[str, Any] = {
-        "task": ["t2s"],
-        "detok_id": [1],
-        "generated_token_ids": [generated_audio_token_ids],
-        "audio_codebook_size": [4096],
-    }
-    if dynin_config_path:
-        additional_information["dynin_config_path"] = [str(dynin_config_path)]
-    return {
-        "prompt_token_ids": [0],
-        "additional_information": additional_information,
-        "modalities": ["audio"],
-    }
-
-
-# prompting util
-def _build_t2i_decode_prompt(dynin_config_path: str | None) -> dict[str, Any]:
-    # Bypass stage-0 generation and directly validate token->image decode path.
-    # MAGVIT decode path expects a square token grid; 1024 tokens -> 32x32.
-    generated_image_token_ids = [int(v) for v in ([10, 11, 12, 13, 14, 15, 16, 17] * 128)]
-    additional_information: dict[str, Any] = {
-        "task": ["t2i"],
-        "detok_id": [2],
-        "generated_token_ids": [generated_image_token_ids],
-        "codebook_size": [8192],
-    }
-    if dynin_config_path:
-        additional_information["dynin_config_path"] = [str(dynin_config_path)]
-    return {
-        "prompt_token_ids": [0],
-        "additional_information": additional_information,
-        "modalities": ["image"],
-    }
-
-
-def _configure_dynin_config_env() -> None:
-    if DYNIN_CONFIG_PATH:
-        os.environ["DYNIN_CONFIG_PATH"] = str(DYNIN_CONFIG_PATH)
-    else:
-        os.environ.pop("DYNIN_CONFIG_PATH", None)
-
-
-def _is_finished_request_output(request_output: Any) -> bool:
-    if request_output is None:
-        return False
-    req_list = request_output if isinstance(request_output, list) else [request_output]
-    for req in req_list:
-        if req is not None and bool(getattr(req, "finished", False)):
-            return True
-    return False
-
-
-def _find_stage_output(outputs: list[Any], output_type: str) -> Any | None:
-    matched = [
-        stage_output for stage_output in outputs if getattr(stage_output, "final_output_type", None) == output_type
-    ]
-    if not matched:
-        return None
-
-    # Prefer the latest finished chunk to avoid picking an intermediate stream output.
-    for stage_output in reversed(matched):
-        if _is_finished_request_output(stage_output):
-            return stage_output
-    return matched[-1]
-
-
-def _to_token_list(value: Any) -> list[int]:
-    if value is None:
-        return []
-    if hasattr(value, "detach"):
-        value = value.detach()
-    if hasattr(value, "cpu"):
-        value = value.cpu()
-    if hasattr(value, "flatten"):
-        value = value.flatten().tolist()
-    if isinstance(value, tuple):
-        value = list(value)
-    if not isinstance(value, list):
-        return []
-    out: list[int] = []
-    for token in value:
-        if isinstance(token, bool):
-            continue
-        try:
-            out.append(int(token))
-        except Exception:
-            continue
-    return out
-
-
-def _extract_text(stage_output: Any, tokenizer: Any | None = None) -> str:
-    request_output = stage_output
-    if request_output is None:
-        return ""
-    req_list = request_output if isinstance(request_output, list) else [request_output]
-    for req in req_list:
-        completions = getattr(req, "outputs", None) or []
-        if not completions:
-            continue
-        completion = completions[0]
-        mm_out = (
-            getattr(completion, "multimodal_output", None)
-            or getattr(req, "multimodal_output", None)
-            or getattr(stage_output, "multimodal_output", None)
-            or {}
-        )
-        text = mm_out.get("text")
-        if isinstance(text, list) and text:
-            text = text[-1]
-        if isinstance(text, str) and text.strip():
-            return text.strip()
-        if tokenizer is not None:
-            for key in ("text_tokens", "token_ids"):
-                token_ids = _to_token_list(mm_out.get(key))
-                if not token_ids:
-                    continue
-                decoded = tokenizer.decode(token_ids, skip_special_tokens=True)
-                if isinstance(decoded, str) and decoded.strip():
-                    return decoded.strip()
-        fallback = getattr(completion, "text", None)
-        if isinstance(fallback, str) and fallback.strip():
-            return fallback.strip()
-    return ""
-
-
-def _extract_audio(stage_output: Any) -> Any | None:
-    request_output = stage_output
-    if request_output is None:
-        return None
-    req_list = request_output if isinstance(request_output, list) else [request_output]
-    for req in req_list:
-        completions = getattr(req, "outputs", None) or []
-        if not completions:
-            continue
-        completion = completions[0]
-        mm_out = getattr(completion, "multimodal_output", None) or {}
-        if "audio" in mm_out:
-            return mm_out["audio"]
-    return None
-
-
-def _extract_image(stage_output: Any) -> Any | None:
-    request_output = stage_output
-    if request_output is None:
-        return None
-    req_list = request_output if isinstance(request_output, list) else [request_output]
-    for req in req_list:
-        completions = getattr(req, "outputs", None) or []
-        if not completions:
-            continue
-        completion = completions[0]
-        mm_out = getattr(completion, "multimodal_output", None) or {}
-        if "image" in mm_out:
-            return mm_out["image"]
-    return None
-
-
-def _numel(value: Any) -> int:
-    if value is None:
-        return 0
-    if isinstance(value, torch.Tensor):
-        return int(value.numel())
-    shape = getattr(value, "shape", None)
-    if shape is not None:
-        try:
-            total = 1
-            for dim in shape:
-                total *= int(dim)
-            return int(total)
-        except Exception:
-            pass
-    if isinstance(value, (list, tuple)):
-        return len(value)
-    return 0
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-def test_dynin_t2i_decode_to_image(omni_runner) -> None:
-    _configure_dynin_config_env()
-    prompt = _build_t2i_decode_prompt(dynin_config_path=DYNIN_CONFIG_PATH)
-
-    outputs = omni_runner.generate([prompt])
-
-    image_output = _find_stage_output(outputs, "image")
-    assert image_output is not None
-    image_value = _extract_image(image_output)
-    assert image_value is not None
-    assert _numel(image_value) > 0
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-def test_dynin_mmu_to_text(omni_runner) -> None:
-    _configure_dynin_config_env()
-    tokenizer = AutoTokenizer.from_pretrained(omni_runner.model_name, trust_remote_code=True)
-    prompt = _build_mmu_prompt(
-        tokenizer=tokenizer,
-        question="What is 2 + 2? Answer in one short sentence.",
-        dynin_config_path=DYNIN_CONFIG_PATH,
-    )
-
-    outputs = omni_runner.generate([prompt])
-
-    text_output = _find_stage_output(outputs, "text")
-    assert text_output is not None
-    text_content = _extract_text(text_output, tokenizer=tokenizer)
-    assert text_content
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-def test_dynin_image_to_text(omni_runner) -> None:
-    _configure_dynin_config_env()
-    tokenizer = AutoTokenizer.from_pretrained(omni_runner.model_name, trust_remote_code=True)
-    prompt = _build_mmu_multimodal_prompt(
-        tokenizer=tokenizer,
-        question="Describe the image briefly in one sentence.",
-        dynin_config_path=DYNIN_CONFIG_PATH,
-        image=_generate_synthetic_image(),
-    )
-
-    outputs = omni_runner.generate([prompt])
-
-    text_output = _find_stage_output(outputs, "text")
-    assert text_output is not None
-    text_content = _extract_text(text_output, tokenizer=tokenizer)
-    assert text_content
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-def test_dynin_speech_to_text(omni_runner) -> None:
-    _configure_dynin_config_env()
-    tokenizer = AutoTokenizer.from_pretrained(omni_runner.model_name, trust_remote_code=True)
-    prompt = _build_mmu_multimodal_prompt(
-        tokenizer=tokenizer,
-        question="Transcribe the audio briefly in one sentence.",
-        dynin_config_path=DYNIN_CONFIG_PATH,
-        audio=_generate_synthetic_audio(),
-    )
-
-    outputs = omni_runner.generate([prompt])
-
-    text_output = _find_stage_output(outputs, "text")
-    assert text_output is not None
-    text_content = _extract_text(text_output, tokenizer=tokenizer)
-    assert text_content
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-def test_dynin_t2s_decode_to_audio(omni_runner) -> None:
-    _configure_dynin_config_env()
-    prompt = _build_t2s_decode_prompt(dynin_config_path=DYNIN_CONFIG_PATH)
-
-    outputs = omni_runner.generate([prompt])
-
-    audio_output = _find_stage_output(outputs, "audio")
-    assert audio_output is not None
-    audio_value = _extract_audio(audio_output)
-    assert audio_value is not None
-    assert _numel(audio_value) > 0
diff --git a/tests/e2e/offline_inference/test_hunyuanimage3.py b/tests/e2e/offline_inference/test_hunyuanimage3.py
index 8655bd63f..21bfe9b39 100644
--- a/tests/e2e/offline_inference/test_hunyuanimage3.py
+++ b/tests/e2e/offline_inference/test_hunyuanimage3.py
@@ -1,5 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # ruff: noqa: E501
+import copy
 import importlib.util
+import os
 import sys
 from collections.abc import Generator
 from pathlib import Path
@@ -10,20 +15,37 @@ import torch.nn.functional as F
 from PIL import Image
 from transformers import CLIPModel, CLIPProcessor
 
+from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
-from tests.helpers.stage_config import get_deploy_config_path
+from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
 from vllm_omni import Omni
+from vllm_omni.config.omni_config import (
+    VllmOmniARStageConfig,
+    VllmOmniDiffusionStageConfig,
+)
+from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import build_prompt_tokens, resolve_stop_token_ids
 from vllm_omni.entrypoints.openai.stage_params import clone_sampling_params
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.model_extras import get_ar_input_builder, get_ar_tokenizer_validator, get_model_class_name
 from vllm_omni.platforms import current_omni_platform
 
 PROMPT = "A brown and white dog is running on the grass"
-MODEL_NAME = "tencent/HunyuanImage-3.0"
+MODEL_NAME = os.environ.get("HUNYUAN_IMAGE3_MODEL", "tencent/HunyuanImage-3.0-Instruct")
 LOCAL_CLIP_PATH = "openai/clip-vit-base-patch32"
-DEPLOY_CONFIG_PATH = get_deploy_config_path("hunyuan_image_3_moe.yaml")
+_PRODUCTION_DEPLOY_CONFIG_PATH = get_deploy_config_path("hunyuan_image_3_moe.yaml")
+# Keep the production Mooncake connector, but use its TCP transport for this
+# single-host test.  The shared server's RDMA device is not usable reliably;
+# TCP still exercises the Mooncake AR→DiT data plane without changing deploy
+# semantics in production.
+DEPLOY_CONFIG_PATH = modify_stage_config(
+    _PRODUCTION_DEPLOY_CONFIG_PATH,
+    updates={"connectors.rdma_connector.extra.protocol": "tcp"},
+)
 
-pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion]
+pytestmark = [
+    pytest.mark.advanced_model,
+    pytest.mark.diffusion,
+]
 
 # System prompt type. Options: None, dynamic, en_vanilla, en_recaption, en_think_recaption, en_unified
 # Below are the CLIP embedding tensors from the official HunyuanImage model (seed=1234, prompt: "A brown and white dog is running on the grass").
@@ -285,25 +307,97 @@ def omni() -> Generator[Omni, None, None]:
         yield runner.omni
 
 
+@pytest.mark.skipif(torch.accelerator.device_count() < 4, reason="Need at least 4 CUDA GPUs for this test.")
+@hardware_test(res={"cuda": "H100"}, num_cards=4)
+def test_structured_mixed_pipeline_config_reaches_runtime(omni: Omni) -> None:
+    """Mixed-pipeline deploy settings reach both terminal engine configs."""
+    engine = omni.engine
+
+    # Topology, connector selection, and placement remain Omni-owned.
+    resolved_stages = engine.stage_configs
+    assert len(resolved_stages) == 2
+    ar_stage, diffusion_stage = resolved_stages
+    assert isinstance(ar_stage, VllmOmniARStageConfig)
+    assert ar_stage.stage_id == 0
+    assert ar_stage.model_stage == "AR"
+    assert ar_stage.final_output_type == "text"
+    assert ar_stage.runtime_config.devices == "0,1"
+    assert ar_stage.connector_config.output_connectors == {"to_stage_1": "rdma_connector"}
+    assert isinstance(diffusion_stage, VllmOmniDiffusionStageConfig)
+    assert diffusion_stage.stage_id == 1
+    assert diffusion_stage.model_stage == "dit"
+    assert diffusion_stage.final_output_type == "image"
+    assert diffusion_stage.input_sources == [0]
+    assert diffusion_stage.runtime_config.devices == "2,3"
+    assert diffusion_stage.connector_config.input_connectors == {"from_stage_0": "rdma_connector"}
+
+    # Stage 0 is materialized as the VllmConfig actually passed to its engine.
+    ar_vllm_config, diffusion_vllm_config = engine.stage_vllm_configs
+    assert ar_vllm_config is not None
+    assert diffusion_vllm_config is None
+    assert ar_vllm_config.model_config.enforce_eager is True
+    assert ar_vllm_config.model_config.trust_remote_code is True
+    assert ar_vllm_config.parallel_config.tensor_parallel_size == 2
+    assert ar_vllm_config.scheduler_config.max_num_seqs == 1
+    assert ar_vllm_config.scheduler_config.max_num_batched_tokens == 32768
+    assert ar_vllm_config.cache_config.gpu_memory_utilization == 0.95
+    ar_omni_config = ar_vllm_config.model_config.omni_config
+    assert ar_omni_config.omni_kv_config["need_send_cache"] is True
+
+    expected_ar_sampling = {
+        "temperature": 0.0,
+        "top_p": 1,
+        "top_k": -1,
+        "max_tokens": 8192,
+        "detokenize": True,
+        "skip_special_tokens": False,
+        "include_stop_str_in_output": True,
+    }
+    ar_sampling, diffusion_sampling = engine.default_sampling_params_list
+    assert all(getattr(ar_sampling, name) == value for name, value in expected_ar_sampling.items())
+    assert diffusion_sampling.num_inference_steps == 50
+    assert diffusion_sampling.guidance_scale == 0
+
+    # Stage 1 is a diffusion engine, so its terminal owner is the launched
+    # OmniDiffusionConfig rather than a VllmConfig.
+    od_config = omni.get_diffusion_od_config()
+    assert od_config is not None
+    assert od_config.model == MODEL_NAME
+    assert od_config.enforce_eager is True
+    assert od_config.distributed_executor_backend == "mp"
+    assert od_config.parallel_config.tensor_parallel_size == 2
+    assert od_config.parallel_config.enable_expert_parallel is True
+    assert od_config.max_num_seqs == 1
+    diffusion_kv = od_config.omni_kv_config
+    assert diffusion_kv["need_recv_cache"] is True
+    assert diffusion_kv["enable_kv_async_prefetch"] is True
+    assert diffusion_kv["kv_prefetch_min_free_mem_ratio"] == 0.2
+
+
 def _extract_generated_image(outputs: list[object]) -> Image.Image:
     if not outputs:
         raise AssertionError("No outputs were returned from Omni.generate()")
 
-    first_output = outputs[0]
-    if images := getattr(first_output, "images", None):
-        return images[0]
-
-    request_output = first_output
-    if request_output is not None and (images := getattr(request_output, "images", None)):
-        return images[0]
+    for output in outputs:
+        if images := getattr(output, "images", None):
+            return images[0]
+        multimodal_output = getattr(output, "multimodal_output", None)
+        if isinstance(multimodal_output, dict) and (images := multimodal_output.get("images")):
+            return images[0]
 
     raise AssertionError("No generated image found in Omni output")
 
 
 def extract_embedding(image: Image.Image, clip_model: CLIPModel, clip_processor: CLIPProcessor) -> torch.Tensor:
-    inputs = clip_processor(images=image.convert("RGB"), return_tensors="pt")
+    # The full CLIP forward API is stable across supported Transformers
+    # versions, but it expects text inputs as well as pixels.  An empty text
+    # prompt is sufficient when only the projected image embedding is needed.
+    inputs = clip_processor(text=[""], images=[image.convert("RGB")], return_tensors="pt", padding=True)
     with torch.inference_mode():
-        features = clip_model.get_image_features(**inputs)
+        # Use the public CLIP forward output, matching the shared CLIPScorer
+        # helper.  ``get_image_features`` changed from Tensor to
+        # BaseModelOutputWithPooling in Transformers 5.x.
+        features = clip_model(**inputs).image_embeds
         features = F.normalize(features, p=2, dim=-1)
     return features.squeeze(0)
 
@@ -320,16 +414,36 @@ def compare_semantic(
 
 
 def _generate_image(omni: Omni, use_system_prompt: str | None) -> Image.Image:
-    generator_device = current_omni_platform.device_type or "cuda"
-    sampling_params = OmniDiffusionSamplingParams(
-        seed=1234,
-        generator=torch.Generator(device=generator_device).manual_seed(1234),
-        num_outputs_per_prompt=1,
-    )
-    if use_system_prompt is not None:
-        sampling_params.extra_args = {"use_system_prompt": use_system_prompt}
+    from transformers import AutoTokenizer
 
-    outputs = omni.generate({"prompt": PROMPT}, sampling_params)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+    prompt_tokens = build_prompt_tokens(
+        PROMPT,
+        tokenizer,
+        task="t2i",
+        bot_task="think",
+        sys_type=use_system_prompt or "None",
+    )
+    stop_token_ids = resolve_stop_token_ids(task="t2i", bot_task="think", tokenizer=tokenizer, image_size="1024x1024")
+    params_list = copy.deepcopy(omni.default_sampling_params_list)
+    generator_device = current_omni_platform.device_type or "cuda"
+    for params in params_list:
+        if isinstance(params, OmniDiffusionSamplingParams):
+            params.seed = 1234
+            params.generator = torch.Generator(device=generator_device).manual_seed(1234)
+            params.num_outputs_per_prompt = 1
+        elif hasattr(params, "stop_token_ids"):
+            params.stop_token_ids = stop_token_ids
+
+    prompt = {
+        "prompt": PROMPT,
+        "prompt_token_ids": prompt_tokens.token_ids,
+        "use_system_prompt": prompt_tokens.system_prompt_type,
+        "modalities": ["image"],
+        "height": 1024,
+        "width": 1024,
+    }
+    outputs = omni.generate(prompt, params_list)
     return _extract_generated_image(outputs)
 
 
@@ -342,7 +456,7 @@ def _generate_image(omni: Omni, use_system_prompt: str | None) -> Image.Image:
 MIN_SEMANTIC_SIMILARITY = 0.5
 
 
-@pytest.mark.skipif(torch.accelerator.device_count() < 8, reason="Need at least 8 CUDA GPUs for this test.")
+@pytest.mark.skipif(torch.accelerator.device_count() < 4, reason="Need at least 4 CUDA GPUs for this test.")
 @pytest.mark.parametrize("system_prompt_name,use_system_prompt,expected_embedding", SYSTEM_PROMPT_CASES)
 def test_system_prompt_scores(
     omni: Omni,
@@ -378,7 +492,7 @@ def _load_text_to_image_module():
     return module
 
 
-@pytest.mark.skipif(torch.accelerator.device_count() < 8, reason="Need at least 8 CUDA GPUs for this test.")
+@pytest.mark.skipif(torch.accelerator.device_count() < 4, reason="Need at least 4 CUDA GPUs for this test.")
 def test_shared_script_ar_path_reaches_generation(
     omni: Omni,
     clip_bundle: tuple[CLIPModel, CLIPProcessor],
diff --git a/tests/e2e/offline_inference/test_mammoth_moda2_expansion.py b/tests/e2e/offline_inference/test_mammoth_moda2_expansion.py
index 4f21dd1c4..a5f7aac1d 100644
--- a/tests/e2e/offline_inference/test_mammoth_moda2_expansion.py
+++ b/tests/e2e/offline_inference/test_mammoth_moda2_expansion.py
@@ -4,8 +4,9 @@
 """
 End-to-end test for MammothModa2 text-to-image generation.
 
-Verifies that the AR->DiT pipeline produces an image tensor whose pixel values
-match a golden reference.
+Verifies that the AR->DiT pipeline produces a valid PIL image. When an
+optional golden fixture is present, the test also compares fixed pixel samples;
+the portable golden/stability oracle remains tracked in #7090.
 
 Model Hub repo id: ``bytedance-research/MammothModa2-Preview``.
 Deploy config: ``get_deploy_config_path("mammoth_moda2.yaml")`` -> ``vllm_omni/deploy/mammoth_moda2.yaml``
@@ -20,13 +21,17 @@ import json
 import os
 from pathlib import Path
 
+import numpy as np
 import pytest
 import torch
+from PIL import Image
 from vllm.sampling_params import SamplingParams
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
 from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.transformers_utils.repo_utils import hf_api
 
 # ---------------------------------------------------------------------------
@@ -43,7 +48,7 @@ T2I_DEPLOY_CONFIG = get_deploy_config_path("mammoth_moda2.yaml")
 
 _OMNI_RUNNER_PARAM = (MODEL_PATH, T2I_DEPLOY_CONFIG)
 
-# Golden pixel reference file.  Set UPDATE_GOLDEN=1 to regenerate.
+# Optional golden pixel reference file. Set UPDATE_GOLDEN=1 to regenerate.
 _GOLDEN_T2I_PATH = Path(__file__).parent / "fixtures" / "mammoth_moda2_t2i_golden.json"
 # Fixed sampling coordinates: (channel, row_fraction, col_fraction)
 # Covers corners, centre, and mid-edges across all 3 channels.
@@ -98,17 +103,33 @@ def _sample_pixels(img_tensor: torch.Tensor) -> list[float]:
     return values
 
 
-# ---------------------------------------------------------------------------
-# End-to-end test
-# ---------------------------------------------------------------------------
-pytestmark = [
-    pytest.mark.slow,
-    pytest.mark.diffusion,
-    pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True),
-]
+def _iter_images(outputs: list[object]):
+    """Yield images from shared diffusion ``OmniRequestOutput`` objects."""
+    for out in outputs:
+        ro_list = out if isinstance(out, list) else [out]
+        for ro in ro_list:
+            images = getattr(ro, "images", None)
+            if isinstance(images, list):
+                yield from images
 
 
-@pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/3201")
+def _pil_to_tensor(image: Image.Image) -> torch.Tensor:
+    array = np.asarray(image, dtype=np.float32) / 255.0
+    return torch.from_numpy(array).permute(2, 0, 1)
+
+
+@pytest.mark.cpu
+def test_diffusion_output_exposes_images_at_top_level():
+    image = Image.new("RGB", (16, 16), "black")
+    output = OmniRequestOutput.from_diffusion(request_id="diffusion-test", images=[image])
+
+    assert output.outputs == []
+    assert list(_iter_images([output])) == [image]
+
+
+@pytest.mark.slow
+@pytest.mark.diffusion
+@pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True)
 @hardware_test(res={"cuda": "H100"})
 def test_mammothmoda2_t2i_e2e(omni_runner: OmniRunner):
     """
@@ -116,9 +137,9 @@ def test_mammothmoda2_t2i_e2e(omni_runner: OmniRunner):
 
     Verifies:
       - Omni pipeline initialises with the two-stage YAML config.
-      - DiT stage outputs an image tensor with the correct shape.
-      - A fixed set of pixel values matches a golden reference
-        (regenerate with ``UPDATE_GOLDEN=1``).
+      - DiT stage outputs one RGB PIL image at the requested size.
+      - When the optional fixture exists, fixed pixel samples match its golden
+        reference (regenerate with ``UPDATE_GOLDEN=1``).
     """
     gen_cfg = _load_t2i_gen_config(MODEL_PATH)
     eol_token_id = int(gen_cfg["eol_token_id"])
@@ -139,7 +160,14 @@ def test_mammothmoda2_t2i_e2e(omni_runner: OmniRunner):
         max_tokens=max(1, expected_grid_tokens + 1),
         detokenize=False,
     )
-    dit_sampling = SamplingParams(temperature=0.0, max_tokens=1, detokenize=False)
+    dit_sampling = OmniDiffusionSamplingParams(
+        height=height,
+        width=width,
+        seed=42,
+        guidance_scale=1.0,
+        num_inference_steps=2,
+        extra_args={"cfg_range": [0.0, 1.0]},
+    )
 
     outputs = list(
         omni.generate(
@@ -155,9 +183,6 @@ def test_mammothmoda2_t2i_e2e(omni_runner: OmniRunner):
                         "visual_token_end_id": [visual_end],
                         "image_height": [height],
                         "image_width": [width],
-                        "num_inference_steps": [2],
-                        "text_guidance_scale": [1.0],
-                        "cfg_range": [0.0, 1.0],
                         "visual_ids": [
                             _IMAGE_TOKEN_ID,
                             _VIDEO_TOKEN_ID,
@@ -173,35 +198,21 @@ def test_mammothmoda2_t2i_e2e(omni_runner: OmniRunner):
 
     assert len(outputs) > 0, "Pipeline produced no outputs"
 
-    found_image = False
-    for out in outputs:
-        ro_list = out
-        if not isinstance(ro_list, list):
-            ro_list = [ro_list]
-        for ro in ro_list:
-            completion_outputs = getattr(ro, "outputs", None)
-            if not isinstance(completion_outputs, list):
-                continue
-            for completion in completion_outputs:
-                mm = getattr(completion, "multimodal_output", None)
-                if not (isinstance(mm, dict) and "image" in mm):
-                    continue
-                img_list = mm["image"] if isinstance(mm["image"], list) else [mm["image"]]
-                for img_tensor in img_list:
-                    assert isinstance(img_tensor, torch.Tensor), f"Expected image tensor, got {type(img_tensor)}"
-                    assert img_tensor.ndim in (3, 4), f"Expected 3D or 4D image tensor, got {img_tensor.ndim}D"
+    images = list(_iter_images(outputs))
+    assert len(images) == 1, f"Expected exactly one image, got {len(images)}"
 
-                    sampled = _sample_pixels(img_tensor)
+    image = images[0]
+    assert isinstance(image, Image.Image), f"Expected PIL image, got {type(image)}"
+    assert image.mode == "RGB"
+    assert image.size == (width, height)
 
-                    if os.environ.get("UPDATE_GOLDEN"):
-                        _GOLDEN_T2I_PATH.parent.mkdir(parents=True, exist_ok=True)
-                        _GOLDEN_T2I_PATH.write_text(json.dumps({"pixels": sampled}, indent=2))
-                        print(f"\nGolden file written to {_GOLDEN_T2I_PATH}")
-                    elif _GOLDEN_T2I_PATH.exists():
-                        golden = json.loads(_GOLDEN_T2I_PATH.read_text())["pixels"]
-                        for i, (got, exp) in enumerate(zip(sampled, golden)):
-                            assert abs(got - exp) < 1e-4, f"Pixel {i} mismatch: got {got}, expected {exp}"
+    sampled = _sample_pixels(_pil_to_tensor(image))
 
-                    found_image = True
-
-    assert found_image, "No image tensor found in pipeline output"
+    if os.environ.get("UPDATE_GOLDEN"):
+        _GOLDEN_T2I_PATH.parent.mkdir(parents=True, exist_ok=True)
+        _GOLDEN_T2I_PATH.write_text(json.dumps({"pixels": sampled}, indent=2))
+        print(f"\nGolden file written to {_GOLDEN_T2I_PATH}")
+    elif _GOLDEN_T2I_PATH.exists():
+        golden = json.loads(_GOLDEN_T2I_PATH.read_text())["pixels"]
+        for i, (got, exp) in enumerate(zip(sampled, golden)):
+            assert abs(got - exp) < 1e-4, f"Pixel {i} mismatch: got {got}, expected {exp}"
diff --git a/tests/e2e/offline_inference/test_moss_tts_expansion.py b/tests/e2e/offline_inference/test_moss_tts_expansion.py
index 81a64fcd9..b899252b4 100644
--- a/tests/e2e/offline_inference/test_moss_tts_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_expansion.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """E2E offline inference tests for MOSS-VoiceGenerator (MossTTSDelayModel, 1.7B).
 
 Weekly expansion coverage (``pytest.mark.slow``) for the delay-model path.
@@ -74,7 +74,6 @@ def _get_test_config() -> str:
 
 pytestmark = [
     pytest.mark.slow,
-    pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4700"),
     pytest.mark.tts,
     pytest.mark.parametrize(
         "omni_runner",
@@ -137,7 +136,7 @@ def _collect_audio(omni_runner: OmniRunner, request: dict) -> tuple[torch.Tensor
     return torch.cat(chunks, dim=0), sr_final
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 def test_moss_tts_delay_english(omni_runner: OmniRunner) -> None:
     """VoiceGenerator: English instruction produces non-empty 24 kHz audio."""
     req = _build_request(
@@ -151,7 +150,7 @@ def test_moss_tts_delay_english(omni_runner: OmniRunner) -> None:
     assert not torch.all(audio == 0), "Audio is silence"
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 def test_moss_tts_delay_chinese(omni_runner: OmniRunner) -> None:
     """VoiceGenerator: Chinese input produces non-empty audio."""
     req = _build_request(
@@ -165,7 +164,7 @@ def test_moss_tts_delay_chinese(omni_runner: OmniRunner) -> None:
     assert not torch.all(audio == 0)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 def test_moss_tts_delay_batch(omni_runner: OmniRunner) -> None:
     """VoiceGenerator: batch of two requests each returns non-empty audio."""
     requests = [
diff --git a/tests/e2e/offline_inference/test_moss_tts_realtime.py b/tests/e2e/offline_inference/test_moss_tts_realtime.py
index 81d97cd74..0f0bf59c7 100644
--- a/tests/e2e/offline_inference/test_moss_tts_realtime.py
+++ b/tests/e2e/offline_inference/test_moss_tts_realtime.py
@@ -95,7 +95,6 @@ def _get_test_config() -> str:
 # ---------------------------------------------------------------------------
 
 pytestmark = [
-    pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4700"),
     pytest.mark.slow,
     pytest.mark.tts,
     pytest.mark.parametrize(
@@ -272,7 +271,7 @@ def _collect_audio(omni_runner: OmniRunner, request: dict) -> tuple[torch.Tensor
 # ---------------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 def test_moss_tts_realtime_english(omni_runner: OmniRunner, ref_audio_path: str) -> None:
     """MossTTSRealtime: English voice_clone produces non-empty 24 kHz audio."""
     req = _build_request(ref_audio_path, "This is a real-time TTS streaming test.")
@@ -283,7 +282,7 @@ def test_moss_tts_realtime_english(omni_runner: OmniRunner, ref_audio_path: str)
     assert not torch.all(audio == 0), "Audio is silence"
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 def test_moss_tts_realtime_chinese(omni_runner: OmniRunner, ref_audio_path: str) -> None:
     """MossTTSRealtime: Chinese input produces non-empty audio."""
     req = _build_request(ref_audio_path, "你好，这是语音合成测试。")
diff --git a/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py b/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py
index b84e5a0ff..678fc7e55 100644
--- a/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """E2E offline inference tests for MOSS-TTS-Realtime (MossTTSRealtime, 1.7B).
 
 Exercises the local-transformer generation path on L4. Delay-model coverage is in
@@ -33,7 +33,6 @@ _OMNI_RUNNER_PARAM = (
 pytestmark = [
     pytest.mark.slow,
     pytest.mark.tts,
-    pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4700"),
     pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True),
 ]
 
@@ -118,7 +117,7 @@ def _collect_audio(omni_runner: OmniRunner, request: dict) -> tuple[torch.Tensor
     raise AssertionError("No stage outputs received")
 
 
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 def test_moss_tts_realtime_english(omni_runner: OmniRunner, ref_audio_path) -> None:
     """MossTTSRealtime: English voice_clone produces non-empty 24 kHz audio."""
     req = _build_request("This is a real-time TTS streaming test.", ref_audio_path)
diff --git a/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py b/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py
index 487a6bfa6..b86db369e 100644
--- a/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py
@@ -1,19 +1,21 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """E2E offline inference test for MOSS-TTS-v1.5 (MossTTSDelay-8B).
 
 MOSS-TTS-v1.5 is a continued-training upgrade of MOSS-TTS 1.0 with the SAME
-``MossTTSDelay`` architecture and API. The 8B checkpoint is H100-gated; small-GPU
-MossTTSDelay coverage stays in ``test_moss_tts_expansion.py``.
+``MossTTSDelay`` architecture and API. The 8B checkpoint runs on H100 or MI325;
+small-GPU MossTTSDelay coverage stays in ``test_moss_tts_expansion.py``.
 """
 
 from __future__ import annotations
 
+import gc
 import os
 import urllib.request
 
 import pytest
 import torch
+from transformers import AutoProcessor
 from vllm import SamplingParams
 
 from tests.helpers.mark import hardware_test
@@ -28,14 +30,10 @@ _OMNI_RUNNER_PARAM = (
     {"stage_init_timeout": 600, "trust_remote_code": True},
 )
 
-_SKIP_ISSUE_6417 = pytest.mark.skip(
-    reason="https://github.com/vllm-project/vllm-omni/issues/6417",
-)
-
 pytestmark = [
+    pytest.mark.full_model,
     pytest.mark.slow,
     pytest.mark.tts,
-    _SKIP_ISSUE_6417,
     pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True),
 ]
 
@@ -69,15 +67,19 @@ def ref_audio_path(tmp_path_factory) -> str:
 
 
 def _build_request(text: str, ref_audio_path: str) -> dict:
+    processor = AutoProcessor.from_pretrained(MODEL, trust_remote_code=True)
+    message = processor.build_user_message(
+        text=text,
+        reference=[ref_audio_path],
+        language="English",
+    )
+    unified = processor(conversations=[[message]], mode="generation")["input_ids"][0]
+    del processor
+    gc.collect()
+
     return {
-        "prompt": "<|im_start|>assistant\n",
-        "additional_information": {
-            "task_type": ["voice_clone"],
-            "text": [text],
-            "mode": ["voice_clone"],
-            "prompt_audio_path": [ref_audio_path],
-            "seed": [42],
-        },
+        "prompt_token_ids": unified[:, 0].tolist(),
+        "additional_information": {"codes": {"ref": unified[:, 1:].contiguous().to(torch.int64)}},
     }
 
 
@@ -112,7 +114,7 @@ def _collect_audio(omni_runner: OmniRunner, request: dict) -> tuple[torch.Tensor
     raise AssertionError("No stage outputs received")
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
 def test_moss_tts_v15_voice_clone(omni_runner: OmniRunner, ref_audio_path) -> None:
     """MOSS-TTS-v1.5 (8B): voice_clone produces non-empty 24 kHz audio."""
     req = _build_request("Hello, this is a MOSS-TTS v1.5 voice cloning test.", ref_audio_path)
diff --git a/tests/e2e/offline_inference/test_qwen3_omni.py b/tests/e2e/offline_inference/test_qwen3_omni.py
index 32c345194..4b744df15 100644
--- a/tests/e2e/offline_inference/test_qwen3_omni.py
+++ b/tests/e2e/offline_inference/test_qwen3_omni.py
@@ -13,10 +13,15 @@ import os
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
 import pytest
+from vllm import SamplingParams
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import generate_synthetic_video
 from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
+from vllm_omni.config.omni_config import (
+    VllmOmniARStageConfig,
+    VllmOmniGenerationStageConfig,
+)
 from vllm_omni.platforms import current_omni_platform
 
 models = ["Qwen/Qwen3-Omni-30B-A3B-Instruct"]
@@ -25,6 +30,7 @@ thinker_only_models = ["Qwen/Qwen3-Omni-30B-A3B-Captioner"]
 # Single CI deploy YAML; rocm/xpu deltas are picked automatically via the
 # platforms: section. Only CUDA needs an extra enforce_eager tweak.
 _CI_DEPLOY = get_deploy_config_path("ci/qwen3_omni_moe.yaml")
+_PRODUCTION_DEPLOY = get_deploy_config_path("qwen3_omni_moe.yaml")
 
 
 def get_cuda_graph_config():
@@ -46,6 +52,7 @@ else:
 
 # Create parameter combinations for model and stage config
 test_params = [(model, stage_config) for model in models for stage_config in stage_configs]
+production_test_params = [(model, _PRODUCTION_DEPLOY) for model in models]
 # we can use the same config for a model that only has thinker (i.e., does not
 # enable audio output) because the resolver should figure out that it doesn't
 # need the full pipeline based on the HF config.
@@ -59,6 +66,97 @@ def get_question(prompt_type="video"):
     return prompts.get(prompt_type, prompts["video"])
 
 
+@pytest.mark.advanced_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@pytest.mark.parametrize("omni_runner", production_test_params, indirect=True)
+def test_structured_multistage_config_reaches_runtime(omni_runner, offline_client) -> None:
+    """Deploy settings reach the materialized configs used by live stages."""
+    engine = omni_runner.omni.engine
+
+    # The resolved typed stages remain the Omni-owned source for topology and
+    # placement, which are not fields of the terminal vLLM config.
+    resolved_stages = engine.stage_configs
+    assert len(resolved_stages) == 3
+    thinker, talker, code2wav = resolved_stages
+    assert isinstance(thinker, VllmOmniARStageConfig)
+    assert isinstance(talker, VllmOmniARStageConfig)
+    assert isinstance(code2wav, VllmOmniGenerationStageConfig)
+    assert [stage.stage_id for stage in resolved_stages] == [0, 1, 2]
+    assert [stage.model_stage for stage in resolved_stages] == ["thinker", "talker", "code2wav"]
+    assert code2wav.final_output_type == "audio"
+    assert thinker.runtime_config.devices == "0"
+    assert talker.runtime_config.devices == code2wav.runtime_config.devices == "1"
+    assert talker.connector_config.input_connectors == {"from_stage_0": "connector_of_shared_memory"}
+    assert code2wav.connector_config.input_connectors == {"from_stage_1": "connector_of_shared_memory"}
+
+    # Engine-owned deploy settings must survive the startup projection into
+    # the actual VllmConfig objects retained by the stage pools.
+    assert len(engine.stage_vllm_configs) == 3
+    thinker_vllm, talker_vllm, code2wav_vllm = engine.stage_vllm_configs
+    assert thinker_vllm is not None
+    assert talker_vllm is not None
+    assert code2wav_vllm is not None
+    assert thinker_vllm.scheduler_config.max_num_seqs == 64
+    assert talker_vllm.scheduler_config.max_num_seqs == 64
+    assert code2wav_vllm.scheduler_config.max_num_seqs == 64
+    assert thinker_vllm.scheduler_config.max_num_batched_tokens == 32768
+    assert talker_vllm.scheduler_config.max_num_batched_tokens == 32768
+    assert code2wav_vllm.scheduler_config.max_num_batched_tokens == 65536
+    assert thinker_vllm.cache_config.gpu_memory_utilization == 0.9
+    assert talker_vllm.cache_config.gpu_memory_utilization == 0.6
+    assert code2wav_vllm.cache_config.gpu_memory_utilization == 0.1
+    assert all(config.cache_config.enable_prefix_caching is False for config in engine.stage_vllm_configs)
+    assert all(config.model_config.trust_remote_code is True for config in engine.stage_vllm_configs)
+    assert code2wav_vllm.scheduler_config.enable_chunked_prefill is False
+    assert code2wav_vllm.scheduler_config.async_scheduling is False
+
+    # Sampling defaults are consumed from StageClient metadata, rather than
+    # from either the resolver output or VllmConfig. These literals mirror
+    # vllm_omni/deploy/qwen3_omni_moe.yaml exactly.
+    expected_sampling = (
+        {"temperature": 0.0, "max_tokens": 2048},
+        {"temperature": 0.9, "top_k": 50, "max_tokens": 4096, "repetition_penalty": 1.05},
+        {
+            "temperature": 0.0,
+            "top_p": 1.0,
+            # Deploy YAML literal. The resolver check below compares it verbatim;
+            # the runtime check normalizes it through SamplingParams, which turns
+            # the greedy-sampling sentinel -1 into 0.
+            "top_k": -1,
+            "max_tokens": 65536,
+            "repetition_penalty": 1.1,
+        },
+    )
+    assert len(engine.default_sampling_params_list) == len(expected_sampling)
+    for stage, runtime_params, expected in zip(
+        resolved_stages, engine.default_sampling_params_list, expected_sampling, strict=True
+    ):
+        # The resolver keeps the deploy values verbatim; the pipeline only adds
+        # its own ``detokenize`` / ``stop_token_ids`` constraints on top.
+        assert expected.items() <= (stage.model_config.default_sampling_params or {}).items()
+        # The runtime object is a SamplingParams built from those values, so it
+        # carries vLLM's normalization: greedy sampling (temperature 0) stores
+        # top_k=0, top_p=1.0 and min_p=0.0 even when the YAML spells the
+        # disabled top_k as -1, and backend defaults such as ``detokenize=True``
+        # appear. Compare against the same normalization, not the raw literals.
+        normalized = SamplingParams(**expected)
+        assert all(getattr(runtime_params, name) == getattr(normalized, name) for name in expected)
+
+    if current_omni_platform.is_cuda():
+        assert thinker_vllm.model_config.enforce_eager is False
+        assert talker_vllm.model_config.enforce_eager is False
+
+    # Exercise the materialized stages and their connector path with a real
+    # request; the assertions above are not merely resolver-shape checks.
+    offline_client.send_omni_request(
+        {
+            "prompts": "Answer with one short sentence: what is the capital of China?",
+            "modalities": ["text"],
+        }
+    )
+
+
 @pytest.mark.advanced_model
 @pytest.mark.omni
 @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
diff --git a/tests/e2e/offline_inference/test_qwen3_tts_base.py b/tests/e2e/offline_inference/test_qwen3_tts_base.py
index f800a1163..6515b2e58 100644
--- a/tests/e2e/offline_inference/test_qwen3_tts_base.py
+++ b/tests/e2e/offline_inference/test_qwen3_tts_base.py
@@ -13,6 +13,7 @@ import os
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
 import pytest
+from vllm.platforms import current_platform
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import get_asset_path
@@ -57,7 +58,12 @@ tts_server_params = [
     pytest.param(
         (MODEL, get_cuda_graph_config()),
         id="no_cuda_graph",
-    )
+    ),
+    pytest.param(
+        (MODEL, get_deploy_config_path("qwen3_tts_mrv2.yaml")),
+        id="async_chunk_mrv2",
+        marks=pytest.mark.skipif(not current_platform.is_cuda(), reason="MRV2 validation is CUDA-only"),
+    ),
 ]
 
 
diff --git a/tests/e2e/offline_inference/test_qwen_image_autoround_w4a16_expansion.py b/tests/e2e/offline_inference/test_qwen_image_autoround_w4a16_expansion.py
index 3d370ec8b..3157551ef 100644
--- a/tests/e2e/offline_inference/test_qwen_image_autoround_w4a16_expansion.py
+++ b/tests/e2e/offline_inference/test_qwen_image_autoround_w4a16_expansion.py
@@ -56,7 +56,7 @@ def test_qwen_image_autoround_w4a16_load():
     Verifies that quant_config is propagated to all transformer blocks
     and produces a valid, non-blank image.
     """
-    with OmniRunner(QUANTIZED_MODEL, enforce_eager=True) as runner:
+    with OmniRunner(QUANTIZED_MODEL, enforce_eager=True, enable_cpu_offload=True) as runner:
         outputs = runner.omni.generate(
             "a cup of coffee on a table",
             _sampling_params(),
@@ -85,7 +85,7 @@ def test_qwen_image_autoround_w4a16_generate():
         true_cfg_scale=5.0,
         generator=torch.Generator(device=current_omni_platform.device_type).manual_seed(42),
     )
-    with OmniRunner(QUANTIZED_MODEL, enforce_eager=True) as runner:
+    with OmniRunner(QUANTIZED_MODEL, enforce_eager=True, enable_cpu_offload=True) as runner:
         outputs = runner.omni.generate(
             "a cup of coffee on a wooden table, morning sunlight, photorealistic",
             params,
diff --git a/tests/e2e/offline_inference/test_voxcpm2_tts.py b/tests/e2e/offline_inference/test_voxcpm2_tts.py
index 0b6ff9940..67f36254b 100644
--- a/tests/e2e/offline_inference/test_voxcpm2_tts.py
+++ b/tests/e2e/offline_inference/test_voxcpm2_tts.py
@@ -13,7 +13,7 @@ from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
 from tests.helpers.stage_config import get_deploy_config_path
 
-VOXCPM2_MODEL = "openbmb/VoxCPM2"
+VOXCPM2_MODEL = os.environ.get("VOXCPM2_MODEL", "openbmb/VoxCPM2")
 DEPLOY_CONFIG = get_deploy_config_path("voxcpm2.yaml")
 SAMPLE_RATE = 48000
 
@@ -44,7 +44,7 @@ def _extract_audio(multimodal_output: dict) -> torch.Tensor:
 
 @pytest.mark.slow
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 def test_voxcpm2_zero_shot_001(omni_runner: OmniRunner) -> None:
     """Test zero-shot TTS produces valid audio output."""
     outputs = omni_runner.omni.generate([{"prompt": "Hello, this is a test."}])
@@ -57,7 +57,7 @@ def test_voxcpm2_zero_shot_001(omni_runner: OmniRunner) -> None:
 
 @pytest.mark.slow
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 def test_voxcpm2_voice_clone_002(omni_runner: OmniRunner) -> None:
     """Test voice cloning with a reference audio file.
 
@@ -98,7 +98,7 @@ def test_voxcpm2_voice_clone_002(omni_runner: OmniRunner) -> None:
 
 @pytest.mark.slow
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 def test_voxcpm2_prefill_decode_mixed_batch_003(omni_runner: OmniRunner) -> None:
     """Regression: prefill+decode mixed batch must not crash (PR #2903)."""
     long_prompt = (
diff --git a/tests/e2e/offline_inference/test_wan22_t2v.py b/tests/e2e/offline_inference/test_wan22_t2v.py
index 805fbd1fe..b3c7d6aab 100644
--- a/tests/e2e/offline_inference/test_wan22_t2v.py
+++ b/tests/e2e/offline_inference/test_wan22_t2v.py
@@ -5,6 +5,8 @@ import pytest
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OfflineOmniClient
+from vllm_omni.config.omni_config import VllmOmniDiffusionStageConfig
+from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 MODEL = "Wan-AI/Wan2.2-T2V-A14B-Diffusers"
@@ -12,6 +14,33 @@ PROMPT = "Two anthropomorphic cats in boxing gear on a spotlighted stage."
 NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
 
 
+@pytest.mark.advanced_model
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards={"cuda": 1, "rocm": 1})
+@pytest.mark.parametrize("omni_runner", [(MODEL, None)], indirect=True)
+def test_structured_diffusion_config_reaches_runtime(omni_runner) -> None:
+    """The default WAN resolver launches the typed diffusion config itself."""
+    omni = omni_runner.omni
+    resolved_stages = omni.engine.stage_configs
+    stage_clients = omni.engine.stage_clients
+    assert len(resolved_stages) == 1
+    assert len(stage_clients) == 1
+    stage_config = resolved_stages[0]
+    od_config = stage_clients[0].od_config
+
+    assert isinstance(stage_config, VllmOmniDiffusionStageConfig)
+    assert isinstance(od_config, OmniDiffusionConfig)
+    assert stage_config.stage_id == 0
+    assert stage_config.model_stage == "dit"
+    assert stage_config.final_output_type == "video"
+
+    assert omni.engine.stage_vllm_configs == [None]
+    assert od_config.stage_id == 0
+    assert od_config.model == MODEL
+    assert od_config.model_class_name == "WanPipeline"
+    assert od_config.output_type == "pil"
+
+
 @pytest.mark.advanced_model
 @pytest.mark.diffusion
 @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards={"cuda": 1, "rocm": 1})
diff --git a/tests/e2e/online_serving/personaplex_realtime_duplex.py b/tests/e2e/online_serving/personaplex_realtime_duplex.py
index 20da1598d..78f012548 100644
--- a/tests/e2e/online_serving/personaplex_realtime_duplex.py
+++ b/tests/e2e/online_serving/personaplex_realtime_duplex.py
@@ -10,24 +10,24 @@ import base64
 import hashlib
 import json
 import math
+import time
 import uuid
 import wave
-from collections.abc import Sequence
+from collections.abc import Awaitable, Callable, Sequence
 from pathlib import Path
+from typing import Protocol
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
 import numpy as np
 
 try:
     import websockets
-    from websockets.exceptions import ConnectionClosed
+    from websockets.exceptions import ConnectionClosed, WebSocketException
 except ImportError as exc:  # pragma: no cover - driver dependency.
     raise SystemExit("Install websockets first: pip install websockets") from exc
 
-from vllm_omni.clients.duplex import (
-    EventCollector,
-    write_pcm16_wav,
-)
+from vllm_omni.benchmarks.audio_continuity import compute_continuity_stats
+from vllm_omni.clients.duplex import EventCollector, write_pcm16_wav
 from vllm_omni.clients.duplex import (
     wait_for_condition as wait_for,
 )
@@ -35,6 +35,24 @@ from vllm_omni.clients.duplex import (
 SAMPLE_RATE_HZ = 24_000
 FRAME_SAMPLES = 1_920
 FRAME_PERIOD_S = FRAME_SAMPLES / SAMPLE_RATE_HZ
+AUDIO_DELTA_EVENT_TYPES = frozenset({"response.audio.delta", "response.output_audio.delta"})
+
+
+class _AudioAcceptanceError(AssertionError):
+    """A local acceptance failure with numeric diagnostics safe to report."""
+
+    def __init__(self, check: str, message: str, stats: dict[str, object]) -> None:
+        super().__init__(message)
+        self.check = check
+        self.stats = dict(stats)
+
+
+class _ProbeTransport(Protocol):
+    async def recv(self) -> str | bytes: ...
+
+    async def send(self, message: str) -> None: ...
+
+    async def close(self) -> None: ...
 
 
 class RawRealtimeProbe:
@@ -46,29 +64,33 @@ class RawRealtimeProbe:
     keeps a transport-only client and reads everything from ``.events``.
     """
 
-    def __init__(self, url: str, *, max_size: int = 64 * 1024 * 1024) -> None:
+    def __init__(self, url: str, *, max_size: int = 64 * 1024 * 1024, close_timeout_s: float = 10.0) -> None:
         self.url = url
         self.max_size = max_size
+        self.close_timeout_s = close_timeout_s
         self.events = EventCollector()
-        self._ws = None
+        self._ws: _ProbeTransport | None = None
         self._reader_task: asyncio.Task[None] | None = None
 
     async def __aenter__(self) -> RawRealtimeProbe:
-        self._ws = await websockets.connect(self.url, max_size=self.max_size)
+        self._ws = await websockets.connect(self.url, max_size=self.max_size, close_timeout=self.close_timeout_s)
         self._reader_task = asyncio.create_task(self._read_events())
         return self
 
     async def __aexit__(self, exc_type, exc, traceback) -> None:
-        if self._ws is not None:
-            await self._ws.close()
-        if self._reader_task is not None:
-            self._reader_task.cancel()
-            try:
-                await self._reader_task
-            except asyncio.CancelledError:
-                pass
+        try:
+            if self._ws is not None:
+                await self._ws.close()
+        finally:
+            if self._reader_task is not None:
+                self._reader_task.cancel()
+                try:
+                    await self._reader_task
+                except asyncio.CancelledError:
+                    pass
 
     async def _read_events(self) -> None:
+        assert self._ws is not None
         try:
             while True:
                 raw = await self._ws.recv()
@@ -81,6 +103,7 @@ class RawRealtimeProbe:
             return
 
     async def send(self, event: dict[str, object]) -> None:
+        assert self._ws is not None
         await self._ws.send(json.dumps(event))
 
 
@@ -142,6 +165,38 @@ def _events(client: RawRealtimeProbe, event_type: str) -> list[dict[str, object]
     return [event for event in client.events.events if event.get("type") == event_type]
 
 
+def _audio_events(client: RawRealtimeProbe) -> list[dict[str, object]]:
+    """Return audio deltas from both current and legacy Realtime event names."""
+    return [event for event in client.events.events if event.get("type") in AUDIO_DELTA_EVENT_TYPES]
+
+
+def _validated_audio_event(event: dict[str, object]) -> bytes:
+    """Decode one wire audio delta without depending on client event aliases."""
+    encoded = event.get("delta")
+    if not isinstance(encoded, str):
+        raise ValueError("missing_audio_delta")
+    try:
+        chunk = base64.b64decode(encoded, validate=True)
+    except ValueError:
+        raise ValueError("invalid_audio_base64") from None
+    if chunk:
+        if len(chunk) % 2:
+            raise ValueError("unaligned_pcm16_packet")
+        if event.get("sample_rate_hz") != SAMPLE_RATE_HZ:
+            raise ValueError("invalid_audio_sample_rate")
+        if not isinstance(event.get("response_id"), str) or not event.get("response_id"):
+            raise ValueError("missing_audio_response_id")
+    return chunk
+
+
+def _validated_audio_chunks(client: RawRealtimeProbe) -> list[tuple[dict[str, object], bytes]]:
+    return [(event, _validated_audio_event(event)) for event in _audio_events(client)]
+
+
+def _audio_bytes(client: RawRealtimeProbe) -> bytes:
+    return b"".join(chunk for _, chunk in _validated_audio_chunks(client) if chunk)
+
+
 async def _open_session(
     args: argparse.Namespace,
     *,
@@ -151,22 +206,7 @@ async def _open_session(
 ) -> tuple[RawRealtimeProbe, dict[str, object]]:
     client = RawRealtimeProbe(_realtime_url(args.url, args.model, session_id))
     await client.__aenter__()
-    await client.send(
-        {
-            "type": "session.update",
-            "session": {
-                "session_id": session_id,
-                "model": args.model,
-                "modalities": ["audio", "text"],
-                "input_audio_format": "pcm_f32le",
-                "output_audio_format": "pcm16",
-                "voice": args.voice,
-                "instructions": persona,
-                "turn_detection": None,
-                "extra_body": {"auto_response": True},
-            },
-        }
-    )
+    await client.send(_session_update(args, session_id=session_id, persona=persona))
     event_type = "error" if expect_error else "session.created"
     await wait_for(
         lambda: client.events.count(event_type) > 0,
@@ -176,6 +216,23 @@ async def _open_session(
     return client, _events(client, event_type)[-1]
 
 
+def _session_update(args: argparse.Namespace, *, session_id: str, persona: str) -> dict[str, object]:
+    return {
+        "type": "session.update",
+        "session": {
+            "session_id": session_id,
+            "model": args.model,
+            "modalities": ["audio", "text"],
+            "input_audio_format": "pcm_f32le",
+            "output_audio_format": "pcm16",
+            "voice": args.voice,
+            "instructions": persona,
+            "turn_detection": None,
+            "extra_body": {"auto_response": True},
+        },
+    }
+
+
 async def _close_session(client: RawRealtimeProbe, *, timeout_s: float) -> None:
     await client.send({"type": "session.close"})
     await wait_for(
@@ -200,23 +257,24 @@ async def _stream_frames(
             frame_count = min(frame_count, max_frames)
     for seq in range(frame_count):
         frame = pcm[seq * FRAME_SAMPLES : (seq + 1) * FRAME_SAMPLES]
-        frame = np.pad(frame, (0, FRAME_SAMPLES - frame.size))
-        frame = np.ascontiguousarray(frame, dtype="<f4")
-        await client.send(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": base64.b64encode(frame).decode("ascii"),
-                "format": "pcm_f32le",
-                "sample_rate_hz": SAMPLE_RATE_HZ,
-                "duration_ms": 80,
-                "audio_end_ms": (seq + 1) * 80,
-                "is_speech": bool(np.sqrt(np.mean(np.square(frame))) >= 1e-4),
-            }
-        )
+        await client.send(_frame_event(frame, seq))
         await asyncio.sleep(FRAME_PERIOD_S)
     return frame_count
 
 
+def _frame_event(frame: np.ndarray, seq: int) -> dict[str, object]:
+    frame = np.ascontiguousarray(np.pad(frame, (0, FRAME_SAMPLES - frame.size)), dtype="<f4")
+    return {
+        "type": "input_audio_buffer.append",
+        "audio": base64.b64encode(frame).decode("ascii"),
+        "format": "pcm_f32le",
+        "sample_rate_hz": SAMPLE_RATE_HZ,
+        "duration_ms": 80,
+        "audio_end_ms": (seq + 1) * 80,
+        "is_speech": bool(np.sqrt(np.mean(np.square(frame))) >= 1e-4),
+    }
+
+
 def _audio_frame_stats(
     raw: bytes,
     *,
@@ -242,11 +300,7 @@ def _audio_frame_stats(
 
 
 def _response_ids(client: RawRealtimeProbe) -> set[str]:
-    return {
-        str(event["response_id"])
-        for event in _events(client, "response.output_audio.delta")
-        if isinstance(event.get("response_id"), str)
-    }
+    return {str(event["response_id"]) for event in _audio_events(client) if isinstance(event.get("response_id"), str)}
 
 
 def _session_result(
@@ -256,40 +310,66 @@ def _session_result(
     args: argparse.Namespace,
     minimum_chunks: int,
 ) -> tuple[bytes, set[str], dict[str, object]]:
-    chunks = sum(len(items) for items in client.events.response_audio.values())
-    raw = client.events.audio_bytes()
-    if chunks < minimum_chunks or not raw or len(raw) % 2:
-        raise AssertionError(f"invalid PCM16 output: chunks={chunks}, bytes={len(raw)}")
+    if isinstance(client, RawRealtimeProbe):
+        audio_chunks = _validated_audio_chunks(client)
+        chunks = sum(bool(chunk) for _, chunk in audio_chunks)
+        raw = b"".join(chunk for _, chunk in audio_chunks if chunk)
+    else:
+        # Unit fixtures may provide an already-decoded EventCollector without
+        # retaining the base64 wire field. Real websocket probes always take
+        # the strict wire-validation path above.
+        chunks = sum(len(items) for items in client.events.response_audio.values())
+        raw = client.events.audio_bytes()
+    stats: dict[str, object] = {"audio_chunks": chunks, "audio_samples": len(raw) // 2}
+    if not raw or len(raw) % 2:
+        raise _AudioAcceptanceError("pcm16_output", f"invalid PCM16 output: chunks={chunks}, bytes={len(raw)}", stats)
     pcm = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
     rms = float(np.sqrt(np.mean(np.square(pcm))))
+    stats["audio_rms"] = rms
     # This low floor only catches corrupt, non-finite, or effectively zero PCM.
     # Audible speech is checked per frame below with the higher 1e-3 default.
     if not np.isfinite(pcm).all() or rms <= 1e-5:
-        raise AssertionError(f"output audio is non-finite or silent: samples={pcm.size}, rms={rms}")
-    rates = {
-        int(event["sample_rate_hz"])
-        for event in _events(client, "response.output_audio.delta")
-        if isinstance(event.get("sample_rate_hz"), int)
-    }
+        raise _AudioAcceptanceError(
+            "audio_rms", f"output audio is non-finite or silent: samples={pcm.size}, rms={rms}", stats
+        )
+    rates = {rate for event in _audio_events(client) if isinstance(rate := event.get("sample_rate_hz"), int)}
     if rates != {SAMPLE_RATE_HZ}:
-        raise AssertionError(f"unexpected output sample rates: {sorted(rates)}")
-    stats = _audio_frame_stats(
-        raw,
-        input_frames=input_frames,
-        voiced_frame_rms_threshold=args.voiced_frame_rms_threshold,
-    )
-    if not 0 <= int(stats["frame_deficit"]) <= args.max_frame_deficit:
-        raise AssertionError(f"invalid synchronous frame accounting: input={input_frames}, stats={stats}")
+        raise _AudioAcceptanceError("sample_rate", f"unexpected output sample rates: {sorted(rates)}", stats)
+    if input_frames < 1:
+        raise _AudioAcceptanceError("input_frames", f"audio received without input frames: input={input_frames}", stats)
+    try:
+        frame_stats = _audio_frame_stats(
+            raw,
+            input_frames=input_frames,
+            voiced_frame_rms_threshold=args.voiced_frame_rms_threshold,
+        )
+    except AssertionError as exc:
+        # _audio_frame_stats only formats local sample counts, not wire data.
+        raise _AudioAcceptanceError("whole_codec_frames", str(exc), stats) from exc
+    stats.update(frame_stats)
+    if chunks < minimum_chunks:
+        raise _AudioAcceptanceError(
+            "audio_chunks", f"insufficient audio chunks: chunks={chunks}, minimum={minimum_chunks}", stats
+        )
+    if not 0 <= int(frame_stats["frame_deficit"]) <= args.max_frame_deficit:
+        raise _AudioAcceptanceError(
+            "frame_deficit",
+            f"invalid synchronous frame accounting: input={input_frames}, maximum_deficit={args.max_frame_deficit}, "
+            f"stats={stats}",
+            stats,
+        )
     min_voiced_frames = int(args.min_voiced_frames)
     if min_voiced_frames < 1:
         raise ValueError(f"min_voiced_frames must be positive, got {min_voiced_frames}")
-    if int(stats["voiced_frames"]) < min_voiced_frames:
-        raise AssertionError(
-            f"output contained insufficient audible speech: minimum_voiced_frames={min_voiced_frames}, stats={stats}"
+    if int(frame_stats["voiced_frames"]) < min_voiced_frames:
+        raise _AudioAcceptanceError(
+            "voiced_frames",
+            f"output contained insufficient audible speech: minimum_voiced_frames={min_voiced_frames}, stats={stats}",
+            stats,
         )
     runtime_metadata = [
         metadata["vllm_omni"]
-        for event in _events(client, "response.output_audio.delta")
+        for event in _audio_events(client)
         if isinstance((metadata := event.get("metadata")), dict) and isinstance(metadata.get("vllm_omni"), dict)
     ]
     if not any(
@@ -298,18 +378,19 @@ def _session_result(
         and item.get("runner_kv_backed") is True
         for item in runtime_metadata
     ):
-        raise AssertionError(f"audio events did not prove the scheduler data plane: {runtime_metadata}")
+        raise _AudioAcceptanceError(
+            "scheduler_data_plane", "audio events did not prove the scheduler data plane", stats
+        )
     response_ids = _response_ids(client)
     if len(response_ids) != 1:
-        raise AssertionError(f"continuous stream used multiple responses: {sorted(response_ids)}")
+        raise _AudioAcceptanceError(
+            "response_identity", f"continuous stream requires one response: count={len(response_ids)}", stats
+        )
     return (
         raw,
         response_ids,
         {
             **stats,
-            "audio_chunks": chunks,
-            "audio_samples": len(raw) // 2,
-            "audio_rms": rms,
             "response_ids": sorted(response_ids),
         },
     )
@@ -332,6 +413,8 @@ def _save(output_dir: Path, name: str, client: RawRealtimeProbe, raw: bytes) ->
 
 
 async def run(args: argparse.Namespace) -> dict[str, object]:
+    if getattr(args, "sessions", None) is not None:
+        return await run_load(args)
     input_path = Path(args.input_wav)
     input_identity = _input_identity(
         input_path,
@@ -381,14 +464,12 @@ async def run(args: argparse.Namespace) -> dict[str, object]:
     )
     await asyncio.gather(
         wait_for(
-            lambda: len(primary.events.audio_bytes()) // (2 * FRAME_SAMPLES) >= primary_frames - args.max_frame_deficit,
+            lambda: len(_audio_bytes(primary)) // (2 * FRAME_SAMPLES) >= primary_frames - args.max_frame_deficit,
             timeout_s=args.timeout_s,
             label="primary frame coverage",
         ),
         wait_for(
-            lambda: (
-                len(secondary.events.audio_bytes()) // (2 * FRAME_SAMPLES) >= secondary_frames - args.max_frame_deficit
-            ),
+            lambda: (len(_audio_bytes(secondary)) // (2 * FRAME_SAMPLES) >= secondary_frames - args.max_frame_deficit),
             timeout_s=args.timeout_s,
             label="secondary frame coverage",
         ),
@@ -426,16 +507,14 @@ async def run(args: argparse.Namespace) -> dict[str, object]:
     await asyncio.gather(
         wait_for(
             lambda: (
-                len(secondary.events.audio_bytes()) // (2 * FRAME_SAMPLES)
-                >= secondary_total_frames - args.max_frame_deficit
+                len(_audio_bytes(secondary)) // (2 * FRAME_SAMPLES) >= secondary_total_frames - args.max_frame_deficit
             ),
             timeout_s=args.timeout_s,
             label="survivor frame coverage after slot recycle",
         ),
         wait_for(
             lambda: (
-                len(replacement.events.audio_bytes()) // (2 * FRAME_SAMPLES)
-                >= replacement_frames - args.max_frame_deficit
+                len(_audio_bytes(replacement)) // (2 * FRAME_SAMPLES) >= replacement_frames - args.max_frame_deficit
             ),
             timeout_s=args.timeout_s,
             label="replacement frame coverage",
@@ -493,6 +572,284 @@ async def run(args: argparse.Namespace) -> dict[str, object]:
     return result
 
 
+def _distribution(values: list[float]) -> dict[str, int | float | None]:
+    if not values:
+        return {"count": 0, "median": None, "p99": None, "max": None, "argmax_index": None}
+    return {
+        "count": len(values),
+        "median": float(np.median(values)),
+        "p99": float(np.quantile(values, 0.99)),
+        "max": max(values),
+        "argmax_index": int(np.argmax(values)),
+    }
+
+
+def _load_metrics(client: RawRealtimeProbe, sends: list[tuple[float, float, float]]) -> dict[str, object]:
+    # Use the collector's local clock, never a timestamp supplied by the server.
+    packets: list[dict[str, object]] = []
+    response_ids: set[str] = set()
+    packet_times: list[float] = []
+    packet_bytes: list[int] = []
+    invalid_packets: list[dict[str, object]] = []
+    samples = 0
+    for index, (raw, received) in enumerate(zip(client.events.events, client.events.event_received_at_s, strict=True)):
+        if raw.get("type") not in AUDIO_DELTA_EVENT_TYPES:
+            continue
+        try:
+            chunk = _validated_audio_event(raw)
+        except ValueError as exc:
+            # Only fixed diagnostic codes from the validator are exported,
+            # never audio payloads or details from the remote endpoint.
+            invalid_packets.append({"event_index": index, "received_at_s": received, "code": str(exc)})
+            continue
+        if chunk:
+            samples += len(chunk) // 2
+            packet_times.append(received)
+            packet_bytes.append(len(chunk))
+            response_id = raw.get("response_id")
+            packets.append({"received_at_s": received, "samples": len(chunk) // 2, "response_id": response_id})
+            if isinstance(response_id, str) and response_id:
+                response_ids.add(response_id)
+    intervals = [(b - a) * 1000 for a, b in zip(packet_times, packet_times[1:])]
+    first_send = sends[0][1] if sends else None
+    audio_duration = samples / SAMPLE_RATE_HZ
+    first_audio_ms = (packet_times[0] - first_send) * 1000 if packet_times and first_send is not None else None
+    client_rtf = (packet_times[-1] - first_send) / audio_duration if audio_duration and first_send is not None else None
+    continuity = compute_continuity_stats(packet_times, packet_bytes, SAMPLE_RATE_HZ) if packet_times else None
+    lateness = _distribution([max(0.0, sent - planned) * 1000 for planned, sent, _ in sends])
+    p99_lateness = lateness["p99"]
+    return {
+        "input_frames": len(sends),
+        "output_samples": samples,
+        # Populate frame accounting from _session_result, including on failure.
+        "frame_deficit": None,
+        "response_ids": sorted(response_ids),
+        "client_first_audio_after_stream_start_ms": first_audio_ms,
+        "client_stream_rtf": client_rtf,
+        "client_audio_packet_interval_ms": _distribution(intervals),
+        "client_send_lateness_ms": lateness,
+        "client_pacing_warning": isinstance(p99_lateness, float) and p99_lateness > FRAME_PERIOD_S * 1000,
+        "audio_underrun_s": continuity.max_underrun_s if continuity else None,
+        "audio_underrun_event_count": continuity.underrun_event_count if continuity else None,
+        "audio_continuity_ok": continuity.is_continuous if continuity else None,
+        "input_timeline": [
+            {"frame_index": i, "planned_at_s": planned, "send_started_at_s": sent, "send_completed_at_s": completed}
+            for i, (planned, sent, completed) in enumerate(sends)
+        ],
+        "audio_packet_timeline": packets,
+        "invalid_audio_packets": invalid_packets,
+    }
+
+
+def _check_load_connection(client: RawRealtimeProbe) -> None:
+    if client.events.errors():
+        raise RuntimeError("server emitted a Realtime error (see the session error count)")
+    if client._reader_task is not None and client._reader_task.done():
+        client._reader_task.result()  # Propagate malformed JSON/reader failures.
+        raise RuntimeError("connection closed before session completion")
+
+
+async def _wait_load_event(client: RawRealtimeProbe, event_type: str, timeout_s: float) -> None:
+    def received() -> bool:
+        if client.events.count(event_type):
+            return True
+        _check_load_connection(client)
+        return False
+
+    await wait_for(received, timeout_s=timeout_s, label=event_type)
+
+
+async def _paced_load_frames(
+    client: RawRealtimeProbe,
+    pcm: np.ndarray,
+    *,
+    epoch: float,
+    timeout_s: float,
+    sends: list[tuple[float, float, float]],
+    clock: Callable[[], float] = time.monotonic,
+    sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
+) -> None:
+    next_send = epoch
+    for seq in range(math.ceil(pcm.size / FRAME_SAMPLES)):
+        await sleep(max(0.0, next_send - clock()))
+        _check_load_connection(client)
+        event = _frame_event(pcm[seq * FRAME_SAMPLES : (seq + 1) * FRAME_SAMPLES], seq)
+        started = clock()
+        await asyncio.wait_for(client.send(event), timeout=timeout_s)
+        completed = clock()
+        sends.append((epoch + seq * FRAME_PERIOD_S, started, completed))
+        # Do not burst to catch up after a stalled send; report accumulated lag.
+        next_send = max(epoch + (seq + 1) * FRAME_PERIOD_S, completed + FRAME_PERIOD_S)
+
+
+async def _request_load_close(client: RawRealtimeProbe, timeout_s: float) -> None:
+    await client.send({"type": "session.close"})
+    await _wait_load_event(client, "session.closed", timeout_s)
+
+
+async def _run_load_session(
+    args: argparse.Namespace,
+    pcm: np.ndarray,
+    index: int,
+    ready: asyncio.Future[None],
+    start: asyncio.Future[float],
+) -> dict[str, object]:
+    session_id = f"personaplex-load-{index}-{uuid.uuid4().hex}"
+    client = RawRealtimeProbe(_realtime_url(args.url, args.model, session_id), close_timeout_s=args.cleanup_timeout_s)
+    sends: list[tuple[float, float, float]] = []
+    error: str | None = None
+    cleanup_error: str | None = None
+    metrics: dict[str, object] | None = None
+    session_stats: dict[str, object] = {}
+    acceptance_check: str | None = None
+    phase = "admission"
+    try:
+        async with client:
+            try:
+                await asyncio.wait_for(
+                    client.send(_session_update(args, session_id=session_id, persona=args.persona)), args.timeout_s
+                )
+                await _wait_load_event(client, "session.created", args.timeout_s)
+                capabilities = _capabilities(_events(client, "session.created")[-1])
+                if (
+                    capabilities.get("chunk_period_ms") != 80
+                    or capabilities.get("supports_multi_session_same_replica") is not True
+                ):
+                    raise AssertionError("server did not advertise PersonaPlex multi-session capabilities")
+                ready.set_result(None)
+                phase = "stream"
+                epoch = await asyncio.shield(start)
+                await _paced_load_frames(client, pcm, epoch=epoch, timeout_s=args.timeout_s, sends=sends)
+                phase = "drain"
+                # Fixed, reported observation window. Closing must not extend
+                # it and let a slow session pass by flushing after the cutoff.
+                await asyncio.sleep(args.drain_s)
+                _check_load_connection(client)
+                _, _, session_stats = _session_result(
+                    client, input_frames=len(sends), args=args, minimum_chunks=args.minimum_audio_chunks
+                )
+            finally:
+                metrics = _load_metrics(client, sends)
+                if client.events.count("session.created") and not client.events.count("session.closed"):
+                    try:
+                        # Send and acknowledgement share one short cleanup budget,
+                        # independent of the potentially long inference timeout.
+                        await asyncio.wait_for(
+                            _request_load_close(client, args.cleanup_timeout_s), args.cleanup_timeout_s
+                        )
+                    except (OSError, asyncio.TimeoutError, ValueError, RuntimeError, WebSocketException) as exc:
+                        cleanup_error = f"cleanup: {type(exc).__name__}"
+    except (OSError, asyncio.TimeoutError, ValueError, RuntimeError, AssertionError, WebSocketException) as exc:
+        if isinstance(exc, _AudioAcceptanceError):
+            acceptance_check = exc.check
+            session_stats = exc.stats
+            error = f"{phase}: AssertionError: {exc}"
+        else:
+            # Other assertions/errors may embed handshake credentials or wire
+            # metadata. Only our local numeric acceptance diagnostics are safe.
+            error = f"{phase}: {type(exc).__name__}"
+    finally:
+        # Admission failure must not leave the other sessions at the barrier.
+        if not ready.done():
+            ready.set_result(None)
+    if metrics is None:
+        metrics = _load_metrics(client, sends)
+    if cleanup_error:
+        error = f"{error}; {cleanup_error}" if error else cleanup_error
+    if client.events.errors():
+        error = error or "server emitted a Realtime error"
+    if metrics["invalid_audio_packets"]:
+        error = error or "invalid audio packets"
+    first_audio = metrics["client_first_audio_after_stream_start_ms"]
+    if isinstance(first_audio, float) and first_audio < 0:
+        error = error or "audio arrived before the first input frame"
+    rtf = metrics["client_stream_rtf"]
+    if args.max_client_rtf is not None and isinstance(rtf, float) and rtf > args.max_client_rtf:
+        error = error or f"client_stream_rtf exceeds {args.max_client_rtf}"
+    return {
+        "index": index,
+        "session_id": session_id,
+        "ok": error is None,
+        "error": error,
+        "acceptance_check": acceptance_check,
+        "server_error_count": len(client.events.errors()),
+        "server_error_codes": [
+            str(body.get("code", "unknown")) if isinstance(body := event.get("error"), dict) else "unknown"
+            for event in client.events.errors()
+        ],
+        **metrics,
+        **session_stats,
+    }
+
+
+async def run_load(args: argparse.Namespace) -> dict[str, object]:
+    input_path = Path(args.input_wav)
+    identity = _input_identity(input_path, expected_sha256=args.expected_input_sha256)
+    pcm = _read_wav_as_float32(input_path)
+    if args.tail_s:
+        pcm = np.concatenate([pcm, np.zeros(round(args.tail_s * SAMPLE_RATE_HZ), dtype=np.float32)])
+    pcm = pcm[: args.load_frames * FRAME_SAMPLES]
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    # Refuse to silently overwrite evidence from a previous sweep.
+    result_path = output_dir / "load-result.json"
+    if result_path.exists():
+        raise FileExistsError(result_path)
+    loop = asyncio.get_running_loop()
+    start: asyncio.Future[float] = loop.create_future()
+    ready: list[asyncio.Future[None]] = [loop.create_future() for _ in range(args.sessions)]
+    tasks = [asyncio.create_task(_run_load_session(args, pcm, i, r, start)) for i, r in enumerate(ready)]
+    try:
+        await asyncio.gather(*ready)
+        start.set_result(time.monotonic())
+        rows = await asyncio.gather(*tasks)
+    finally:
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+    seen: set[str] = set()
+    shared: set[str] = set()
+    for row in rows:
+        assert isinstance(row["response_ids"], list)
+        response_ids = set(row["response_ids"])
+        shared.update(seen & response_ids)
+        seen.update(response_ids)
+    for row in rows:
+        assert isinstance(row["response_ids"], list)
+        if shared.intersection(row["response_ids"]):
+            row.update(ok=False, error="concurrent sessions shared a response id")
+    result = {
+        "schema_version": 1,
+        "mode": "paced_multi_session",
+        "model": args.model,
+        "requested_sessions": args.sessions,
+        "passed_sessions": sum(row["ok"] is True for row in rows),
+        "ok": all(row["ok"] is True for row in rows),
+        "input": {**identity, "tail_s": args.tail_s, "load_frames": args.load_frames},
+        "frame_period_s": FRAME_PERIOD_S,
+        "drain_s": args.drain_s,
+        "cleanup_timeout_s": args.cleanup_timeout_s,
+        "client_pacing_warning_threshold_ms": FRAME_PERIOD_S * 1000,
+        "client_pacing_warning_sessions": [row["index"] for row in rows if row["client_pacing_warning"]],
+        "max_client_rtf": args.max_client_rtf,
+        "acceptance": {
+            "max_frame_deficit": args.max_frame_deficit,
+            "min_voiced_frames": args.min_voiced_frames,
+            "minimum_audio_chunks": args.minimum_audio_chunks,
+            "voiced_frame_rms_threshold": args.voiced_frame_rms_threshold,
+        },
+        "shared_response_ids": sorted(shared),
+        "sessions": rows,
+        "reported_server": {"revision": args.server_revision, "hardware": args.server_hardware},
+        "measurement_origin": "client monotonic clock; admission excluded; streaming and drain retained",
+        "interval_definition": "nonempty audio packet arrivals, not server ticks or per-frame inference latency",
+    }
+    with result_path.open("x", encoding="utf-8") as stream:
+        json.dump(result, stream, ensure_ascii=False, indent=2, allow_nan=False)
+    return result
+
+
 def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser()
     parser.add_argument("--url", default="ws://127.0.0.1:8099/v1/realtime?duplex=1")
@@ -510,6 +867,12 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser.add_argument("--tail-s", type=float, default=2.0)
     parser.add_argument("--drain-s", type=float, default=2.0)
     parser.add_argument("--timeout-s", type=float, default=180.0)
+    parser.add_argument(
+        "--cleanup-timeout-s",
+        type=float,
+        default=5.0,
+        help="Load mode: shared session-close/ack budget; also bounds the websocket close handshake.",
+    )
     parser.add_argument(
         "--max-frame-deficit",
         type=int,
@@ -536,11 +899,39 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         default=0,
         help="Frames sent after slot reuse; 0 replays the full input so the replacement must produce audible output.",
     )
-    return parser.parse_args(argv)
+    parser.add_argument(
+        "--sessions", type=int, help="Opt into paced load mode with N sessions; omit for the lifecycle test."
+    )
+    parser.add_argument(
+        "--load-frames", type=int, default=1000, help="Maximum input frames per load session (no repetition)."
+    )
+    parser.add_argument("--max-client-rtf", type=float, help="Optional client stream-window RTF acceptance ceiling.")
+    parser.add_argument("--server-revision", help="User-reported server commit/version; not verified by this client.")
+    parser.add_argument(
+        "--server-hardware", help="User-reported server hardware; not inferred from the client machine."
+    )
+    args = parser.parse_args(argv)
+    if args.sessions is not None:
+        if not 1 <= args.sessions <= 64 or not 1 <= args.load_frames <= 10000:
+            parser.error("load mode requires sessions in [1,64] and load-frames in [1,10000]")
+        for name in ("timeout_s", "cleanup_timeout_s", "drain_s", "tail_s"):
+            value = getattr(args, name)
+            if not math.isfinite(value) or value < 0 or (name in ("timeout_s", "cleanup_timeout_s") and value == 0):
+                parser.error(f"{name} must be finite and non-negative (timeout must be positive)")
+        if args.max_client_rtf is not None and (not math.isfinite(args.max_client_rtf) or args.max_client_rtf <= 0):
+            parser.error("max-client-rtf must be finite and positive")
+        if args.max_frame_deficit < 0 or args.min_voiced_frames < 1 or args.minimum_audio_chunks < 1:
+            parser.error("frame-deficit must be non-negative; voiced frames and audio chunks must be positive")
+        if not math.isfinite(args.voiced_frame_rms_threshold) or args.voiced_frame_rms_threshold < 0:
+            parser.error("voiced-frame-rms-threshold must be finite and non-negative")
+    return args
 
 
 def main() -> None:
-    print(json.dumps(asyncio.run(run(parse_args())), ensure_ascii=False, indent=2))
+    result = asyncio.run(run(parse_args()))
+    print(json.dumps(result, ensure_ascii=False, indent=2, allow_nan=False))
+    if result.get("mode") == "paced_multi_session" and not result["ok"]:
+        raise SystemExit(1)
 
 
 if __name__ == "__main__":
diff --git a/tests/e2e/online_serving/test_anima.py b/tests/e2e/online_serving/test_anima.py
new file mode 100644
index 000000000..d3dc76cce
--- /dev/null
+++ b/tests/e2e/online_serving/test_anima.py
@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Online e2e smoke test for native Anima single-file checkpoints."""
+
+import json
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServer, OpenAIClientHandler, dummy_messages_from_mix_data
+
+CHECKPOINT_ENV = "ANIMA_CHECKPOINT_PATH"
+COMPONENTS_ENV = "ANIMA_COMPONENTS_PATH"
+CHECKPOINT_REPO = "circlestone-labs/Anima"
+CHECKPOINT_FILENAME = "split_files/diffusion_models/anima-base-v1.0.safetensors"
+COMPONENTS_REPO = "circlestone-labs/Anima-Base-v1.0-Diffusers"
+PROMPT = "A cinematic close-up of a glass teapot on a wooden table."
+
+
+def _resolve_anima_assets() -> tuple[str, str]:
+    checkpoint = os.environ.get(CHECKPOINT_ENV)
+    components = os.environ.get(COMPONENTS_ENV)
+    if checkpoint and components:
+        return checkpoint, components
+
+    from huggingface_hub import hf_hub_download, snapshot_download
+
+    if checkpoint is None:
+        checkpoint = hf_hub_download(
+            repo_id=CHECKPOINT_REPO,
+            filename=CHECKPOINT_FILENAME,
+        )
+    if components is None:
+        components = snapshot_download(repo_id=COMPONENTS_REPO)
+    return checkpoint, components
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
+@pytest.mark.parametrize("guidance_scale", [1.0, 4.0])
+def test_anima_text_to_image(guidance_scale):
+    checkpoint, components = _resolve_anima_assets()
+    server_args = [
+        "--model-class-name",
+        "AnimaPipeline",
+        "--custom-pipeline-args",
+        json.dumps({"components_path": components}),
+    ]
+    with OmniServer(checkpoint, server_args) as omni_server:
+        openai_client = OpenAIClientHandler(
+            host=omni_server.host,
+            port=omni_server.port,
+            api_key="EMPTY",
+            run_level="full_model",
+            log_stats=omni_server.log_stats,
+        )
+        _send_text_to_image_request(omni_server, openai_client, guidance_scale)
+
+
+def _send_text_to_image_request(omni_server: OmniServer, openai_client: OpenAIClientHandler, guidance_scale: float):
+    messages = dummy_messages_from_mix_data(content_text=PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "height": 256,
+            "width": 256,
+            "num_inference_steps": 1,
+            "guidance_scale": guidance_scale,
+            "seed": 42,
+        },
+    }
+
+    openai_client.send_diffusion_request(request_config)
diff --git a/tests/e2e/online_serving/test_bagel.py b/tests/e2e/online_serving/test_bagel.py
index 84c2302cc..1a11dc037 100644
--- a/tests/e2e/online_serving/test_bagel.py
+++ b/tests/e2e/online_serving/test_bagel.py
@@ -25,9 +25,11 @@ import os
 from io import BytesIO
 
 import pytest
+from PIL import Image
 from vllm.assets.image import ImageAsset
 
 from tests.helpers.mark import hardware_test
+from tests.helpers.media import generate_synthetic_image
 from tests.helpers.runtime import OmniServerParams
 from tests.helpers.stage_config import get_deploy_config_path
 
@@ -120,3 +122,55 @@ def test_bagel_img2img_online(omni_server, online_client) -> None:
     }
 
     online_client.send_diffusion_request(request_config)
+
+
+EDIT_SOURCE_SIZE = (1280, 720)
+EDIT_REQUESTED_SIZE = "1024x1024"
+
+
+def _edit_source_jpeg() -> tuple[str, bytes, str]:
+    synthetic = generate_synthetic_image(*EDIT_SOURCE_SIZE, seed=7287)
+    return ("source.jpg", base64.b64decode(synthetic["base64"]), "image/jpeg")
+
+
+def _build_edit_request(size: str) -> dict:
+    return {
+        "files": [("image", _edit_source_jpeg())],
+        "data": {
+            "prompt": IMG2IMG_PROMPT,
+            "size": size,
+            "num_inference_steps": 2,
+            "seed": 42,
+            "response_format": "b64_json",
+        },
+    }
+
+
+@pytest.mark.slow
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "H100"})
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_bagel_image_edit_honors_explicit_size_two_stage(omni_server, online_client) -> None:
+    """An explicit ``size`` wins over the AR stage's source-derived KV image shape (#7283)."""
+    (response,) = online_client.send_images_edits_http_request(_build_edit_request(EDIT_REQUESTED_SIZE))
+
+    payload = response.json_body
+    assert isinstance(payload, dict)
+    assert payload["size"] == EDIT_REQUESTED_SIZE
+    image = Image.open(BytesIO(base64.b64decode(payload["data"][0]["b64_json"])))
+    assert image.size == (1024, 1024)
+
+
+@pytest.mark.slow
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "H100"})
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_bagel_image_edit_floors_unaligned_size_two_stage(omni_server, online_client) -> None:
+    """A side that is not a multiple of the latent stride is floored to one (1000x700 -> 992x688)."""
+    (response,) = online_client.send_images_edits_http_request(_build_edit_request("1000x700"))
+
+    payload = response.json_body
+    assert isinstance(payload, dict)
+    assert payload["size"] == "992x688"
+    image = Image.open(BytesIO(base64.b64decode(payload["data"][0]["b64_json"])))
+    assert image.size == (992, 688)
diff --git a/tests/e2e/online_serving/test_dots_tts_expansion.py b/tests/e2e/online_serving/test_dots_tts_expansion.py
deleted file mode 100644
index e5df55a33..000000000
--- a/tests/e2e/online_serving/test_dots_tts_expansion.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""
-E2E Online expansion tests for dots.tts(text-only).
-"""
-
-import os
-
-import pytest
-
-from tests.helpers.mark import hardware_test
-from tests.helpers.runtime import OmniServerParams
-from tests.helpers.stage_config import get_deploy_config_path
-
-pytestmark = [pytest.mark.full_model, pytest.mark.tts]
-
-os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-
-MODEL = "dots-studio/dots.tts-soar"
-DEFAULT_AUDIO_SPEECH_TIMEOUT_S = 300.0
-_MIN_AUDIO_BYTES = 40_000
-MAX_CONCURRENT = 4
-
-
-def get_prompt(prompt_type="text"):
-    prompts = {
-        "text": "The weather is nice today, perfect for a walk in the park.",
-    }
-    return prompts.get(prompt_type, prompts["text"])
-
-
-tts_server_params = [
-    pytest.param(
-        OmniServerParams(
-            model=MODEL,
-            stage_config_path=get_deploy_config_path("dots_tts.yaml"),
-            server_args=["--trust-remote-code", "--disable-log-stats"],
-        ),
-        id="dots_tts",
-    )
-]
-
-
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
-def test_text_only_streaming_001(omni_server, openai_client) -> None:
-    """
-    Test text-only text-to-audio via OpenAI API.
-    Deploy Setting: dots_tts.yaml
-    Input Modal: text
-    Output Modal: audio
-    Input Setting: stream=True
-    Datasets: few requests (max_num_seqs=4)
-    """
-    request_config = {
-        "model": omni_server.model,
-        "input": get_prompt(),
-        "stream": True,
-        "stream_format": "audio",
-        "timeout": DEFAULT_AUDIO_SPEECH_TIMEOUT_S,
-        "response_format": "wav",
-        "voice": "default",
-        "min_audio_bytes": _MIN_AUDIO_BYTES,
-    }
-    openai_client.send_audio_speech_request(request_config, request_num=MAX_CONCURRENT)
-
-
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
-def test_text_only_nonstreaming_pcm_001(omni_server, openai_client) -> None:
-    """
-    Test text-only non-stream PCM output via OpenAI API.
-    Deploy Setting: dots_tts.yaml
-    Input Modal: text
-    Output Modal: audio (pcm)
-    Input Setting: stream=False
-    Datasets: single request
-    """
-    request_config = {
-        "model": omni_server.model,
-        "input": get_prompt(),
-        "response_format": "pcm",
-        "stream": False,
-        "timeout": DEFAULT_AUDIO_SPEECH_TIMEOUT_S,
-        "voice": "default",
-        "min_audio_bytes": _MIN_AUDIO_BYTES,
-        "min_hnr_db": -2.0,
-        # dots.tts-soar emits native 48 kHz PCM, which has no rate header.
-        "expected_sample_rate": 48_000,
-    }
-    openai_client.send_audio_speech_request(request_config)
diff --git a/tests/e2e/online_serving/test_dynin_omni_expansion.py b/tests/e2e/online_serving/test_dynin_omni_expansion.py
deleted file mode 100644
index c4cd40ff8..000000000
--- a/tests/e2e/online_serving/test_dynin_omni_expansion.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""
-Example online tests for Dynin-Omni model.
-"""
-
-import base64
-import os
-from io import BytesIO
-
-import pytest
-from vllm.assets.image import ImageAsset
-
-from tests.helpers.mark import hardware_test
-from tests.helpers.runtime import OmniServerParams
-from tests.helpers.stage_config import get_deploy_config_path
-
-pytestmark = [pytest.mark.slow, pytest.mark.omni]
-
-os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-
-MODEL = "snu-aidas/Dynin-Omni"
-STAGE_CONFIG = get_deploy_config_path("dynin_omni_ci.yaml")
-
-T2I_PROMPT = "A high quality detailed living room interior photo."
-T2S_PROMPT = "Please read this sentence naturally: Hello from online serving."
-I2I_PROMPT = "Transform this outdoor nature boardwalk scene into a painting style with vivid colors."
-
-TEST_PARAMS = [
-    OmniServerParams(
-        model=MODEL,
-        stage_config_path=STAGE_CONFIG,
-        stage_init_timeout=600,
-        server_args=["--trust-remote-code"],
-    )
-]
-_STAGE_COUNT = 3
-_I2I_STAGE_SAMPLING = {"max_tokens": 1, "temperature": 0.0, "top_p": 1.0, "detokenize": False}
-
-
-def _build_t2i_messages(prompt: str) -> list[dict]:
-    return [{"role": "user", "content": [{"type": "text", "text": f"<|t2i|> {prompt}"}]}]
-
-
-def _build_t2s_messages(prompt: str) -> list[dict]:
-    return [{"role": "user", "content": [{"type": "text", "text": f"<|t2s|> {prompt}"}]}]
-
-
-def _build_i2i_messages(prompt: str) -> list[dict]:
-    input_image = ImageAsset("2560px-Gfp-wisconsin-madison-the-nature-boardwalk").pil_image.convert("RGB")
-    buffer = BytesIO()
-    input_image.save(buffer, format="JPEG")
-    image_b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "text", "text": f"<|i2i|> {prompt}"},
-                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}},
-            ],
-        }
-    ]
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-@pytest.mark.parametrize("omni_server", TEST_PARAMS, indirect=True)
-def test_send_i2i_request_001(omni_server, online_client) -> None:
-    request_config = {
-        "model": omni_server.model,
-        "messages": _build_i2i_messages(I2I_PROMPT),
-        "modalities": ["image"],
-        "extra_body": {
-            "sampling_params_list": [dict(_I2I_STAGE_SAMPLING) for _ in range(_STAGE_COUNT)],
-        },
-    }
-    online_client.send_diffusion_request(request_config)
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-@pytest.mark.parametrize("omni_server", TEST_PARAMS, indirect=True)
-def test_send_t2i_request_001(omni_server, online_client) -> None:
-    request_config = {
-        "model": omni_server.model,
-        "messages": _build_t2i_messages(T2I_PROMPT),
-        "modalities": ["image"],
-    }
-    online_client.send_diffusion_request(request_config)
-
-
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"})
-@pytest.mark.parametrize("omni_server", TEST_PARAMS, indirect=True)
-def test_send_t2s_request_001(omni_server, online_client) -> None:
-    request_config = {
-        "model": omni_server.model,
-        "messages": _build_t2s_messages(T2S_PROMPT),
-        "modalities": ["audio"],
-        "audio_ref_text": T2S_PROMPT,
-    }
-    online_client.send_omni_request(request_config)
diff --git a/tests/e2e/online_serving/test_hidream_i1_full_expansion.py b/tests/e2e/online_serving/test_hidream_i1_full_expansion.py
index dea3b3c9a..f9b9ab131 100644
--- a/tests/e2e/online_serving/test_hidream_i1_full_expansion.py
+++ b/tests/e2e/online_serving/test_hidream_i1_full_expansion.py
@@ -49,7 +49,7 @@ def _get_hidream_i1_image_feature_cases(model: str):
     _get_hidream_i1_image_feature_cases(MODEL),
     indirect=True,
 )
-@pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4662")
+@pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/7753")
 def test_hidream_i1_image(
     omni_server: OmniServer,
     online_client: OnlineOmniClient,
diff --git a/tests/e2e/online_serving/test_hunyuan_video_15_expansion.py b/tests/e2e/online_serving/test_hunyuan_video_15_expansion.py
index 1d6df3317..3d54303f7 100644
--- a/tests/e2e/online_serving/test_hunyuan_video_15_expansion.py
+++ b/tests/e2e/online_serving/test_hunyuan_video_15_expansion.py
@@ -4,14 +4,15 @@
 Tests of common diffusion feature combinations in online serving mode
 for HunyuanVideo-1.5-T2V (480p).
 
-Coverage (H100, since model cannot fit L4):
-- CPU offloading (1 GPU) — ``core_model`` + ``advanced_model``
-- CacheDiT + Layerwise CPU offloading (1 GPU) — ``full_model``
-- CacheDiT + TP=2 + VAE patch parallel=2 (2 GPUs) — ``full_model``
+Coverage:
+- Default single-card deployment (H100, B200, or Ascend A2) — ``full_model``
+- CPU offloading (1 H100 or Ascend A2) — ``core_model`` + ``advanced_model``
+- CacheDiT + Layerwise CPU offloading (1 H100, B200, or Ascend A2) — ``full_model``
+- CacheDiT + TP=2 + VAE patch parallel=2 (2 H100s, B200s, or Ascend A2s) — ``full_model``
 
-HunyuanVideo-1.5 is a high-priority model, so only the most basic single-card deployment
-row runs on every PR (L2) and on merge (L3). The heavyweight feature combinations stay
-nightly-only (L4), together with the video similarity suites in
+HunyuanVideo-1.5 is a high-priority model. The CPU-offload row runs in the existing
+CUDA PR (L2) and merge (L3) lanes. The shared default and CacheDiT / parallel rows
+carry ``full_model`` (L4) marks, together with the video similarity suites in
 ``tests/e2e/accuracy/hunyuanvideo15_{t2v,i2v}/``.
 
 From ``tests/``::
@@ -23,8 +24,9 @@ From ``tests/``::
 
 import pytest
 
-from tests.helpers.mark import hardware_marks
+from tests.helpers.mark import hardware_marks, hardware_test
 from tests.helpers.runtime import OmniServer, OmniServerParams, OnlineOmniClient
+from tests.helpers.stage_config import get_deploy_config_path
 
 pytestmark = [pytest.mark.diffusion]
 
@@ -32,17 +34,25 @@ PROMPT = "A cat walking across a sunlit garden, cinematic lighting, slow motion.
 NEGATIVE_PROMPT = "low quality, blurry, distorted"
 
 MODEL = "hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_t2v"
+DEPLOY_CONFIG = get_deploy_config_path("hunyuan_video_15.yaml")
+
+DEFAULT_TEST_PARAMS = [
+    pytest.param(
+        OmniServerParams(model=MODEL, stage_config_path=DEPLOY_CONFIG),
+        id="default",
+    )
+]
 
 
 def _get_diffusion_feature_cases(model: str):
     """Return diffusion feature cases for HunyuanVideo-1.5.
 
-    Designed for 2x H100 environment per issue #1832.
+    Designed for up to two accelerators per issue #1832.
     Only the CPU-offload row is cheap enough for PR (L2) / merge (L3);
     CacheDiT / parallel combinations run nightly (L4).
     """
     return [
-        # (1 GPU) CPU offload
+        # (1 accelerator) CPU offload
         pytest.param(
             OmniServerParams(
                 model=model,
@@ -52,12 +62,12 @@ def _get_diffusion_feature_cases(model: str):
             ),
             id="single_card_cpu_offload",
             marks=[
-                *hardware_marks(res={"cuda": "H100"}),
+                *hardware_marks(res={"cuda": "H100", "npu": "A2"}),
                 pytest.mark.core_model,
                 pytest.mark.advanced_model,
             ],
         ),
-        # (1 GPU) CacheDiT + Layerwise CPU offloading
+        # (1 accelerator) CacheDiT + Layerwise CPU offloading
         pytest.param(
             OmniServerParams(
                 model=model,
@@ -69,11 +79,11 @@ def _get_diffusion_feature_cases(model: str):
             ),
             id="single_card_cachedit_layerwise",
             marks=[
-                *hardware_marks(res={"cuda": ["H100", "B200"]}),
+                *hardware_marks(res={"cuda": ["H100", "B200"], "npu": "A2"}),
                 pytest.mark.full_model,
             ],
         ),
-        # (2 GPUs) CacheDiT + TP=2 + VAE patch parallel=2
+        # (2 accelerators) CacheDiT + TP=2 + VAE patch parallel=2
         pytest.param(
             OmniServerParams(
                 model=model,
@@ -89,23 +99,17 @@ def _get_diffusion_feature_cases(model: str):
             ),
             id="parallel_cachedit_tp2_vae2",
             marks=[
-                *hardware_marks(res={"cuda": ["H100", "B200"]}, num_cards=2),
+                *hardware_marks(res={"cuda": ["H100", "B200"], "npu": "A2"}, num_cards=2),
                 pytest.mark.full_model,
             ],
         ),
     ]
 
 
-@pytest.mark.parametrize(
-    "omni_server",
-    _get_diffusion_feature_cases(MODEL),
-    indirect=True,
-)
-def test_hunyuan_video_15_t2v(
+def _run_hunyuan_video_15_t2v(
     omni_server: OmniServer,
     online_client: OnlineOmniClient,
-):
-    """Diffusion feature coverage for HunyuanVideo-1.5-T2V on H100."""
+) -> None:
     form_data = {
         "prompt": PROMPT,
         "negative_prompt": NEGATIVE_PROMPT,
@@ -123,3 +127,27 @@ def test_hunyuan_video_15_t2v(
     }
 
     online_client.send_video_diffusion_request(request_config)
+
+
+@hardware_test(res={"cuda": ["H100", "B200"], "npu": "A2"}, num_cards=1)
+@pytest.mark.full_model
+@pytest.mark.parametrize("omni_server", DEFAULT_TEST_PARAMS, indirect=True)
+def test_hunyuan_video_15_t2v_default(
+    omni_server: OmniServer,
+    online_client: OnlineOmniClient,
+) -> None:
+    """Generate a short video with the shared default GPU/NPU configuration."""
+    _run_hunyuan_video_15_t2v(omni_server, online_client)
+
+
+@pytest.mark.parametrize(
+    "omni_server",
+    _get_diffusion_feature_cases(MODEL),
+    indirect=True,
+)
+def test_hunyuan_video_15_t2v_features(
+    omni_server: OmniServer,
+    online_client: OnlineOmniClient,
+) -> None:
+    """Exercise shared diffusion features for HunyuanVideo-1.5-T2V."""
+    _run_hunyuan_video_15_t2v(omni_server, online_client)
diff --git a/tests/e2e/online_serving/test_minicpmo_4_5.py b/tests/e2e/online_serving/test_minicpmo_4_5.py
index 5417d2b16..a1d045b72 100644
--- a/tests/e2e/online_serving/test_minicpmo_4_5.py
+++ b/tests/e2e/online_serving/test_minicpmo_4_5.py
@@ -83,6 +83,25 @@ test_params = [
     ),
 ]
 
+turn_test_params = [
+    pytest.param(
+        OmniServerParams(
+            model=_MODEL,
+            stage_config_path=modify_stage_config(_CI_DEPLOY, updates={"session_mode": "turn"}),
+            use_stage_cli=False,
+            server_args=[
+                "--trust-remote-code",
+                "--async-chunk",
+                "--chat-template",
+                str(_NATIVE_CHAT_TEMPLATE),
+                "--chat-template-content-format",
+                "openai",
+            ],
+        ),
+        id="turn_async_chunk",
+    ),
+]
+
 
 def get_system_prompt():
     return {
@@ -138,7 +157,7 @@ def _read_prompt_selection_log(offset: int) -> str:
 @pytest.mark.advanced_model
 @pytest.mark.omni
 @hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
-@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+@pytest.mark.parametrize("omni_server", test_params + turn_test_params, indirect=True)
 def test_text_to_text_001(omni_server, openai_client) -> None:
     """
     Test text-only input generating text output via OpenAI API.
@@ -163,7 +182,7 @@ def test_text_to_text_001(omni_server, openai_client) -> None:
 @pytest.mark.full_model
 @pytest.mark.omni
 @hardware_test(res={"cuda": ["H100", "B200"], "npu": "A3"}, num_cards=1)
-@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+@pytest.mark.parametrize("omni_server", test_params + turn_test_params, indirect=True)
 def test_text_to_audio_001(omni_server, openai_client) -> None:
     """
     Test text-only input generating text + audio output via OpenAI API.
diff --git a/tests/e2e/online_serving/test_moss_tts_expansion.py b/tests/e2e/online_serving/test_moss_tts_expansion.py
index 598326a1e..bd38a7fc7 100644
--- a/tests/e2e/online_serving/test_moss_tts_expansion.py
+++ b/tests/e2e/online_serving/test_moss_tts_expansion.py
@@ -30,20 +30,16 @@ from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniServerParams
 from tests.helpers.stage_config import get_deploy_config_path
 
-_SKIP_ISSUE_6417 = pytest.mark.skip(
-    reason="https://github.com/vllm-project/vllm-omni/issues/6417",
-)
-
 pytestmark = [
+    pytest.mark.advanced_model,
     pytest.mark.slow,
     pytest.mark.tts,
-    _SKIP_ISSUE_6417,
 ]
 
 MODEL = "OpenMOSS-Team/MOSS-TTS-Realtime"
 REF_AUDIO_URL = "https://raw.githubusercontent.com/OpenMOSS/MOSS-TTS/HEAD/assets/audio/reference_zh_1.wav"
-# Voice-clone output is not reliably transcribed by the Whisper check used at
-# full_model run_level; assert non-trivial WAV payload size instead.
+# Reject a response that contains only a header or a very short audio payload.
+# Advanced and full runs also validate the transcript.
 _MIN_AUDIO_BYTES = 10_000
 
 
@@ -77,7 +73,9 @@ def get_prompt(prompt_type: str = "text") -> str:
     """
     prompts = {
         "text": "Hello, this is a real-time voice cloning demo for testing.",
-        "chinese": "你好，这是一段实时语音合成测试。",
+        # Match the offline test prompt. Whisper-small can transcribe "一段"
+        # as "一本", which makes this short sample fail the similarity check.
+        "chinese": "你好，这是语音合成测试。",
     }
     return prompts.get(prompt_type, prompts["text"])
 
@@ -94,7 +92,7 @@ tts_server_params = [
 ]
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_001(omni_server, online_client, ref_audio_data_url) -> None:
     """
@@ -105,9 +103,8 @@ def test_text_to_audio_001(omni_server, online_client, ref_audio_data_url) -> No
     Input Setting: stream=False
     Datasets: single request
 
-    NOTE: ``min_audio_bytes`` skips Whisper transcript similarity — cloned
-    voice output is often empty or mismatched under ASR without indicating a
-    real serving regression.
+    ``min_audio_bytes`` adds a payload-size check. It does not disable the
+    transcript check used by advanced and full runs.
     """
     request_config = {
         "model": omni_server.model,
@@ -121,7 +118,7 @@ def test_text_to_audio_001(omni_server, online_client, ref_audio_data_url) -> No
     online_client.send_audio_speech_request(request_config)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_002_streaming(omni_server, online_client, ref_audio_data_url) -> None:
     """
@@ -150,7 +147,7 @@ def test_text_to_audio_002_streaming(omni_server, online_client, ref_audio_data_
     online_client.send_audio_speech_request(request_config)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_003_chinese(omni_server, online_client, ref_audio_data_url) -> None:
     """
@@ -161,7 +158,8 @@ def test_text_to_audio_003_chinese(omni_server, online_client, ref_audio_data_ur
     Input Setting: stream=False
     Datasets: single request
 
-    NOTE: same ``min_audio_bytes`` rationale as test_text_to_audio_001.
+    ``min_audio_bytes`` adds a payload-size check. It does not disable the
+    transcript check used by advanced and full runs.
     """
     request_config = {
         "model": omni_server.model,
diff --git a/tests/e2e/online_serving/test_nemotron_voicechat_duplex.py b/tests/e2e/online_serving/test_nemotron_voicechat_duplex.py
index 6f97eaee2..dfb3044e8 100644
--- a/tests/e2e/online_serving/test_nemotron_voicechat_duplex.py
+++ b/tests/e2e/online_serving/test_nemotron_voicechat_duplex.py
@@ -29,7 +29,16 @@ _SERVER_ENV: dict[str, str] = {"VLLM_OMNI_INPUT_WAIT_TIMEOUT_S": str(SERVER_INPU
 if TOKENIZER:
     _SERVER_ENV["NEMOTRON_VOICECHAT_LLM_PATH"] = TOKENIZER
 
-pytestmark = [pytest.mark.full_model, pytest.mark.omni]
+pytestmark = [
+    pytest.mark.full_model,
+    pytest.mark.omni,
+    # Since #7413 a duplex-capable model is served by the duplex engine only when
+    # its pipeline declares a duplex_plugin. The Nemotron VoiceChat pipeline does
+    # not, so the server starts the turn engine and the /v1/realtime websocket
+    # falls through to vllm's speech-to-text realtime handler, which rejects the
+    # native duplex client's session.update ("Missing required field: model").
+    pytest.mark.skip(reason="Nemotron VoiceChat is not served by the duplex engine yet (no duplex_plugin)"),
+]
 
 
 @hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
diff --git a/tests/e2e/online_serving/test_personaplex_load_driver.py b/tests/e2e/online_serving/test_personaplex_load_driver.py
new file mode 100644
index 000000000..8e9a6a28d
--- /dev/null
+++ b/tests/e2e/online_serving/test_personaplex_load_driver.py
@@ -0,0 +1,568 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import asyncio
+import base64
+import json
+import wave
+from contextlib import asynccontextmanager
+from typing import TypedDict
+
+import numpy as np
+import pytest
+import websockets
+
+from tests.e2e.online_serving import personaplex_realtime_duplex as driver
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _ServerState(TypedDict):
+    index: int
+    closed: bool
+    frames: int
+    close_requested: bool
+
+
+def _args(tmp_path, *extra):
+    wav_path = tmp_path / "input.wav"
+    with wave.open(str(wav_path), "wb") as stream:
+        stream.setnchannels(1)
+        stream.setsampwidth(2)
+        stream.setframerate(driver.SAMPLE_RATE_HZ)
+        stream.writeframes(np.full(driver.FRAME_SAMPLES * 2, 2000, dtype="<i2").tobytes())
+    return driver.parse_args(
+        [
+            "--model",
+            "fixture-only",
+            "--input-wav",
+            str(wav_path),
+            "--output-dir",
+            str(tmp_path / "out"),
+            "--sessions",
+            "2",
+            "--load-frames",
+            "2",
+            "--tail-s",
+            "0",
+            "--drain-s",
+            "0.04",
+            "--timeout-s",
+            "3",
+            "--cleanup-timeout-s",
+            "1",
+            "--min-voiced-frames",
+            "1",
+            "--minimum-audio-chunks",
+            "1",
+            "--max-frame-deficit",
+            "0",
+            *extra,
+        ]
+    )
+
+
+def _audio(response_id="r", samples=1920, event_type="response.output_audio.delta"):
+    return {
+        "type": event_type,
+        "response_id": response_id,
+        "delta": base64.b64encode(np.full(samples, 2000, dtype="<i2").tobytes()).decode("ascii"),
+        "sample_rate_hz": driver.SAMPLE_RATE_HZ,
+        "metadata": {
+            "vllm_omni": {
+                "runtime_impl": "scheduler_data_plane",
+                "uses_model_runner_scheduler": True,
+                "runner_kv_backed": True,
+            }
+        },
+    }
+
+
+@asynccontextmanager
+async def _server(mode="success"):
+    states: list[_ServerState] = []
+
+    async def handle(ws):
+        index = len(states)
+        state: _ServerState = {"index": index, "closed": False, "frames": 0, "close_requested": False}
+        states.append(state)
+        response_id = "shared" if mode == "shared_response" else f"r-{index}"
+        try:
+            async for raw in ws:
+                message = json.loads(raw)
+                if message["type"] == "session.update":
+                    if mode == "reject_second" and index == 1:
+                        await ws.send(json.dumps({"type": "error", "error": {"code": "resource_exhausted"}}))
+                        continue
+                    if mode == "missing_capabilities":
+                        await ws.send(
+                            json.dumps(
+                                {
+                                    "type": "session.created",
+                                    "session": {"resume_token": "must-not-be-exported"},
+                                }
+                            )
+                        )
+                        continue
+                    await ws.send(
+                        json.dumps(
+                            {
+                                "type": "session.created",
+                                "session": {
+                                    "resume_token": "must-not-be-exported",
+                                    "capabilities": {
+                                        "chunk_period_ms": 80,
+                                        "supports_multi_session_same_replica": True,
+                                    },
+                                },
+                            }
+                        )
+                    )
+                    await ws.send(json.dumps({"type": "response.created", "response": {"id": response_id}}))
+                elif message["type"] == "input_audio_buffer.append":
+                    state["frames"] += 1
+                    if mode == "short_audio" and state["frames"] == 2:
+                        continue
+                    if mode == "disconnect":
+                        await ws.close()
+                        return
+                    if mode == "bad_json":
+                        await ws.send("{")
+                    elif mode not in ("silent", "late_on_close"):
+                        event_type = (
+                            "response.audio.delta" if mode == "legacy_audio_event" else "response.output_audio.delta"
+                        )
+                        packet = _audio(response_id, event_type=event_type)
+                        if mode == "private_metadata":
+                            packet["metadata"] = {"vllm_omni": {"private": "remote-detail-must-not-be-exported"}}
+                        if mode == "odd_packet":
+                            raw_audio = base64.b64decode(packet["delta"])
+                            raw_audio = raw_audio + b"\x00" if state["frames"] == 1 else raw_audio[:-1]
+                            packet["delta"] = base64.b64encode(raw_audio).decode("ascii")
+                        if state["frames"] == 2:
+                            if mode == "missing_packet_rate":
+                                packet.pop("sample_rate_hz")
+                            elif mode == "string_packet_rate":
+                                packet["sample_rate_hz"] = "24000"
+                            elif mode == "invalid_base64":
+                                packet["delta"] = "!" + packet["delta"]
+                            elif mode == "orphan_audio":
+                                orphan = _audio(response_id)
+                                orphan.pop("response_id")
+                                await ws.send(json.dumps(orphan))
+                        await ws.send(json.dumps(packet))
+                elif message["type"] == "session.close":
+                    state["close_requested"] = True
+                    if mode == "late_on_close":
+                        await ws.send(json.dumps(_audio(response_id, samples=driver.FRAME_SAMPLES * state["frames"])))
+                    if mode == "error_on_close":
+                        await ws.send(json.dumps({"type": "error", "error": {"code": "cleanup_failed"}}))
+                    if mode != "no_close_ack":
+                        await ws.send(json.dumps({"type": "session.closed"}))
+        finally:
+            state["closed"] = True
+
+    async with websockets.serve(handle, "127.0.0.1", 0) as server:
+        port = server.sockets[0].getsockname()[1]
+        yield f"ws://127.0.0.1:{port}/v1/realtime", states
+
+
+def test_omitted_sessions_preserves_lifecycle_mode():
+    args = driver.parse_args(["--model", "unused", "--input-wav", "unused.wav"])
+    assert args.sessions is None
+
+
+@pytest.mark.parametrize(
+    "options",
+    [
+        ["--sessions", "0"],
+        ["--sessions", "65"],
+        ["--load-frames", "0"],
+        ["--load-frames", "10001"],
+        ["--drain-s", "nan"],
+        ["--tail-s", "-1"],
+        ["--timeout-s", "0"],
+        ["--timeout-s", "inf"],
+        ["--cleanup-timeout-s", "0"],
+        ["--cleanup-timeout-s", "nan"],
+        ["--max-client-rtf", "-1"],
+        ["--max-frame-deficit", "-1"],
+        ["--minimum-audio-chunks", "0"],
+        ["--min-voiced-frames", "0"],
+        ["--voiced-frame-rms-threshold", "nan"],
+    ],
+)
+def test_load_rejects_invalid_configuration(tmp_path, options):
+    with pytest.raises(SystemExit):
+        _args(tmp_path, *options)
+
+
+def test_metric_clock_and_packet_frame_distinction():
+    client = driver.RawRealtimeProbe("ws://unused")
+    client.events.add({"type": "session.created", "session": {"resume_token": "secret"}}, received_at_s=7)
+    for when in (10.4, 10.8, 11.6):
+        event = _audio(samples=driver.FRAME_SAMPLES * 5)
+        event["_client_received_at_s"] = -999.0
+        client.events.add(event, received_at_s=when)
+    report = driver._load_metrics(client, [(10, 10, 10.01)])
+    intervals = report["client_audio_packet_interval_ms"]
+    assert isinstance(intervals, dict)
+    assert intervals["count"] == 2
+    assert intervals["median"] == pytest.approx(600)
+    assert intervals["p99"] == pytest.approx(796)
+    assert intervals["max"] == pytest.approx(800)
+    assert intervals["argmax_index"] == 1
+    assert report["client_first_audio_after_stream_start_ms"] == pytest.approx(400)
+    assert report["output_samples"] == 15 * driver.FRAME_SAMPLES
+    assert report["audio_underrun_s"] == pytest.approx(0.4)
+    assert report["audio_continuity_ok"] is False
+    underruns = report["audio_underrun_event_count"]
+    assert isinstance(underruns, int) and underruns >= 1
+    assert report["client_pacing_warning"] is False
+    assert "secret" not in json.dumps(report)
+    assert "-999" not in json.dumps(report)
+
+
+def test_empty_output_has_missing_not_zero_latency():
+    report = driver._load_metrics(driver.RawRealtimeProbe("ws://unused"), [])
+    assert report["client_stream_rtf"] is None
+    assert report["audio_continuity_ok"] is None
+    assert report["audio_underrun_s"] is None
+    intervals = report["client_audio_packet_interval_ms"]
+    assert isinstance(intervals, dict)
+    assert intervals["p99"] is None
+
+
+def test_failed_acceptance_retains_frame_counts_without_remote_data():
+    client = driver.RawRealtimeProbe("ws://unused")
+    client.events.add(_audio(), received_at_s=1.0)
+    args = driver.parse_args(
+        ["--model", "unused", "--input-wav", "unused.wav", "--max-frame-deficit", "0", "--min-voiced-frames", "1"]
+    )
+    with pytest.raises(AssertionError) as raised:
+        driver._session_result(client, input_frames=2, args=args, minimum_chunks=1)
+    assert getattr(raised.value, "check", None) == "frame_deficit"
+    stats = getattr(raised.value, "stats", {})
+    assert stats["frame_deficit"] == 1 and type(stats["frame_deficit"]) is int
+    assert stats["output_frames"] == stats["voiced_frames"] == 1
+    assert stats["frame_coverage_ratio"] == 0.5
+
+
+@pytest.mark.parametrize("event_type", sorted(driver.AUDIO_DELTA_EVENT_TYPES))
+def test_session_result_accepts_current_and_legacy_audio_event_names(tmp_path, event_type):
+    client = driver.RawRealtimeProbe("ws://unused")
+    client.events.add(_audio(samples=driver.FRAME_SAMPLES, event_type=event_type), received_at_s=1.0)
+    raw, response_ids, stats = driver._session_result(
+        client,
+        input_frames=1,
+        args=_args(tmp_path, "--sessions", "1"),
+        minimum_chunks=1,
+    )
+    assert len(raw) == driver.FRAME_SAMPLES * 2
+    assert response_ids == {"r"}
+    assert stats["frame_deficit"] == 0
+
+
+def test_legacy_audio_event_name_contributes_load_metrics():
+    client = driver.RawRealtimeProbe("ws://unused")
+    client.events.add(_audio(samples=driver.FRAME_SAMPLES * 5, event_type="response.audio.delta"), received_at_s=10.4)
+    report = driver._load_metrics(client, [(10.0, 10.0, 10.01)])
+    assert report["output_samples"] == driver.FRAME_SAMPLES * 5
+    assert report["response_ids"] == ["r"]
+    assert report["invalid_audio_packets"] == []
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sessions", [1, 2, 4])
+async def test_real_websocket_load_success(tmp_path, sessions):
+    args = _args(tmp_path, "--sessions", str(sessions))
+    async with _server() as (url, states):
+        args.url = url
+        result = await driver.run(args)
+    assert result["ok"] is True
+    assert result["passed_sessions"] == sessions
+    rows = result["sessions"]
+    assert isinstance(rows, list)
+    assert len(rows) == sessions
+    assert all(row["frame_deficit"] == 0 for row in rows)
+    for row in rows:
+        assert type(row["frame_deficit"]) is int
+        assert row["output_frames"] == row["voiced_frames"] == row["audio_chunks"] == 2
+        assert row["silent_frames"] == 0
+        assert row["frame_coverage_ratio"] == 1.0
+        assert row["audio_rms"] == pytest.approx(2000 / 32768)
+        assert row["acceptance_check"] is None
+        assert isinstance(row["audio_continuity_ok"], bool)
+    assert all(s["closed"] and s["close_requested"] for s in states)
+    assert "must-not-be-exported" not in json.dumps(result)
+    saved = json.loads((tmp_path / "out/load-result.json").read_text())
+    assert saved == result
+    origins = [row["input_timeline"][0]["planned_at_s"] for row in rows]
+    assert len(set(origins)) == 1
+
+
+@pytest.mark.asyncio
+async def test_real_websocket_load_accepts_legacy_audio_event_name(tmp_path):
+    args = _args(tmp_path, "--sessions", "2")
+    async with _server("legacy_audio_event") as (url, states):
+        args.url = url
+        result = await driver.run(args)
+    assert result["ok"] is True
+    assert result["passed_sessions"] == 2
+    assert result["shared_response_ids"] == []
+    assert all(s["closed"] and s["close_requested"] for s in states)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "mode",
+    [
+        "reject_second",
+        "silent",
+        "disconnect",
+        "no_close_ack",
+        "shared_response",
+        "late_on_close",
+        "error_on_close",
+        "bad_json",
+        "missing_capabilities",
+    ],
+)
+async def test_real_websocket_failures_remain_in_results(tmp_path, mode):
+    args = _args(tmp_path)
+    async with _server(mode) as (url, states):
+        args.url = url
+        result = await asyncio.wait_for(driver.run(args), timeout=4)
+    assert result["ok"] is False
+    assert "must-not-be-exported" not in json.dumps(result)
+    assert result["requested_sessions"] == 2
+    rows = result["sessions"]
+    assert isinstance(rows, list)
+    assert len(rows) == 2
+    assert all(s["closed"] for s in states)
+    if mode == "reject_second":
+        assert result["passed_sessions"] == 1
+        rejected = next(row for row in rows if not row["ok"])
+        assert rejected["input_frames"] == 0
+        assert rejected["client_stream_rtf"] is None
+        assert rejected["server_error_codes"] == ["resource_exhausted"]
+    if mode == "silent":
+        # A failed measurement must still release its admitted session.
+        assert all(s["close_requested"] for s in states)
+    if mode == "late_on_close":
+        assert all(row["output_samples"] == 0 for row in rows)
+    if mode == "shared_response":
+        assert result["passed_sessions"] == 0
+
+
+@pytest.mark.asyncio
+async def test_existing_report_is_not_overwritten(tmp_path):
+    args = _args(tmp_path)
+    path = tmp_path / "out/load-result.json"
+    path.parent.mkdir()
+    path.write_text("previous measurement")
+    with pytest.raises(FileExistsError):
+        await driver.run(args)
+    assert path.read_text() == "previous measurement"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["success", "no_close_ack"])
+async def test_cancellation_closes_all_connections(tmp_path, mode):
+    args = _args(tmp_path, "--drain-s", "10", "--timeout-s", "30")
+    async with _server(mode) as (url, states):
+        args.url = url
+        task = asyncio.create_task(driver.run(args))
+
+        async def started():
+            while len(states) < 2 or not all(state["frames"] for state in states):
+                await asyncio.sleep(0.01)
+
+        await asyncio.wait_for(started(), timeout=3)
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await asyncio.wait_for(task, timeout=3)
+    assert all(s["closed"] for s in states)
+
+
+@pytest.mark.asyncio
+async def test_client_rtf_ceiling_marks_slow_sessions_failed(tmp_path):
+    args = _args(tmp_path, "--max-client-rtf", "0.001")
+    async with _server() as (url, _):
+        args.url = url
+        result = await driver.run(args)
+    assert result["passed_sessions"] == 0
+    rows = result["sessions"]
+    assert isinstance(rows, list)
+    assert all("client_stream_rtf exceeds" in row["error"] for row in rows)
+
+
+@pytest.mark.asyncio
+async def test_stalled_send_does_not_cause_catchup_burst():
+    class Clock:
+        now = 10.0
+
+        def monotonic(self):
+            return self.now
+
+        async def sleep(self, delay):
+            self.now += delay
+
+    class Client(driver.RawRealtimeProbe):
+        async def send(self, event):
+            if event["audio_end_ms"] == 80:
+                clock.now += 0.25
+
+    clock = Clock()
+    sends: list[tuple[float, float, float]] = []
+    await driver._paced_load_frames(
+        Client("ws://unused"),
+        np.zeros(driver.FRAME_SAMPLES * 3, dtype="<f4"),
+        epoch=10.0,
+        timeout_s=1.0,
+        sends=sends,
+        clock=clock.monotonic,
+        sleep=clock.sleep,
+    )
+    assert len(sends) == 3
+    assert sends[1][1] >= sends[0][2] + driver.FRAME_PERIOD_S
+    assert sends[1][1] - sends[1][0] == pytest.approx(0.25)
+    assert sends[2][1] >= sends[1][2] + driver.FRAME_PERIOD_S
+    metrics = driver._load_metrics(Client("ws://unused"), sends)
+    assert metrics["client_pacing_warning"] is True
+    assert asyncio.sleep != clock.sleep
+
+
+@pytest.mark.asyncio
+async def test_failed_frame_acceptance_preserves_numeric_diagnostics(tmp_path):
+    args = _args(tmp_path, "--sessions", "1")
+    async with _server("short_audio") as (url, states):
+        args.url = url
+        result = await driver.run(args)
+    rows = result["sessions"]
+    assert isinstance(rows, list)
+    row = rows[0]
+    assert row["ok"] is False
+    assert row["acceptance_check"] == "frame_deficit"
+    assert row["frame_deficit"] == 1 and type(row["frame_deficit"]) is int
+    assert row["output_frames"] == row["voiced_frames"] == row["audio_chunks"] == 1
+    assert row["frame_coverage_ratio"] == 0.5
+    assert row["audio_rms"] == pytest.approx(2000 / 32768)
+    assert "input=2" in row["error"] and "maximum_deficit=0" in row["error"]
+    assert all(state["closed"] and state["close_requested"] for state in states)
+    assert json.loads((tmp_path / "out/load-result.json").read_text()) == result
+
+
+@pytest.mark.asyncio
+async def test_acceptance_failure_does_not_export_remote_metadata(tmp_path):
+    args = _args(tmp_path, "--sessions", "1")
+    async with _server("private_metadata") as (url, _):
+        args.url = url
+        result = await driver.run(args)
+    rows = result["sessions"]
+    assert isinstance(rows, list)
+    row = rows[0]
+    assert row["ok"] is False
+    assert row["acceptance_check"] == "scheduler_data_plane"
+    assert "remote-detail" not in json.dumps(result)
+    assert "must-not-be-exported" not in json.dumps(result)
+
+
+@pytest.mark.parametrize("ok", [True, False])
+def test_load_main_exit_status(tmp_path, monkeypatch, ok):
+    args = _args(tmp_path)
+
+    async def completed(_args):
+        return {"mode": "paced_multi_session", "ok": ok}
+
+    monkeypatch.setattr(driver, "parse_args", lambda: args)
+    monkeypatch.setattr(driver, "run", completed)
+    if ok:
+        driver.main()
+    else:
+        with pytest.raises(SystemExit) as exc:
+            driver.main()
+        assert exc.value.code == 1
+
+
+@pytest.mark.asyncio
+async def test_handshake_rejection_is_retained_without_server_details(tmp_path, monkeypatch):
+    from websockets.exceptions import InvalidHandshake
+
+    async def rejected(_self):
+        raise InvalidHandshake("credentials-in-remote-handshake-detail")
+
+    monkeypatch.setattr(driver.RawRealtimeProbe, "__aenter__", rejected)
+    result = await asyncio.wait_for(driver.run(_args(tmp_path)), timeout=3)
+    assert result["ok"] is False
+    rows = result["sessions"]
+    assert isinstance(rows, list) and len(rows) == 2
+    assert all(row["error"] == "admission: InvalidHandshake" for row in rows)
+    assert "credentials-in-remote-handshake-detail" not in json.dumps(result)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sessions", [1, 2])
+@pytest.mark.parametrize(
+    "mode",
+    [
+        "missing_packet_rate",
+        "string_packet_rate",
+        "invalid_base64",
+        "orphan_audio",
+        "odd_packet",
+    ],
+)
+async def test_load_rejects_invalid_individual_audio_packets(tmp_path, sessions, mode):
+    # The concatenated PCM can still meet coverage/voicing thresholds, so the
+    # validator must also check each packet before accepting the whole run.
+    args = _args(tmp_path, "--sessions", str(sessions))
+    async with _server(mode) as (url, states):
+        args.url = url
+        result = await asyncio.wait_for(driver.run(args), timeout=4)
+    assert result["ok"] is False
+    assert result["passed_sessions"] == 0
+    rows = result["sessions"]
+    assert isinstance(rows, list) and len(rows) == sessions
+    assert all(row["error"] is not None for row in rows)
+    expected_code = {
+        "missing_packet_rate": "invalid_audio_sample_rate",
+        "string_packet_rate": "invalid_audio_sample_rate",
+        "invalid_base64": "invalid_audio_base64",
+        "orphan_audio": "missing_audio_response_id",
+        "odd_packet": "unaligned_pcm16_packet",
+    }[mode]
+    assert all({packet["code"] for packet in row["invalid_audio_packets"]} == {expected_code} for row in rows)
+    assert all(
+        sum(packet["samples"] for packet in row["audio_packet_timeline"]) == row["output_samples"] for row in rows
+    )
+    assert all(state["closed"] and state["close_requested"] for state in states)
+    assert json.loads((tmp_path / "out/load-result.json").read_text()) == result
+
+
+def test_load_allows_empty_and_multi_frame_audio_packets():
+    client = driver.RawRealtimeProbe("ws://unused")
+    client.events.add(_audio(samples=0), received_at_s=1.0)
+    client.events.add(_audio(samples=driver.FRAME_SAMPLES * 5), received_at_s=1.4)
+    metrics = driver._load_metrics(client, [(1.0, 1.0, 1.001)])
+    assert metrics["invalid_audio_packets"] == []
+    assert metrics["output_samples"] == driver.FRAME_SAMPLES * 5
+    packets = metrics["audio_packet_timeline"]
+    assert isinstance(packets, list) and len(packets) == 1
+
+
+def test_load_packet_diagnostics_do_not_copy_remote_payload():
+    client = driver.RawRealtimeProbe("ws://unused")
+    event = _audio()
+    event["delta"] = "private-remote-payload!"
+    client.events.add(event, received_at_s=1.4)
+    metrics = driver._load_metrics(client, [])
+    assert metrics["output_samples"] == 0
+    assert metrics["invalid_audio_packets"] == [
+        {
+            "event_index": 0,
+            "received_at_s": 1.4,
+            "code": "invalid_audio_base64",
+        }
+    ]
+    assert "private-remote-payload" not in json.dumps(metrics)
diff --git a/tests/e2e/online_serving/test_pi05_expansion.py b/tests/e2e/online_serving/test_pi05_expansion.py
new file mode 100644
index 000000000..0c6fbfd34
--- /dev/null
+++ b/tests/e2e/online_serving/test_pi05_expansion.py
@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""E2E online serving test for π0.5 OpenPI websocket serving.
+
+Boots ``vllm serve --omni --deploy-config pi05.yaml`` and drives the real OpenPI
+websocket (``/v1/realtime/robot/openpi``) — the same wire path a robot uses
+(handshake metadata → send observation → receive action chunk). Mirrors
+``tests/e2e/online_serving/test_pi0_expansion.py``. Needs one H100 and the full
+π0.5 checkpoint.
+
+The ``pi0_openpi_*`` helpers are protocol-level (handshake, send obs, receive
+chunk) and not π0-specific, so π0.5 reuses them; only the deploy config and the
+expected metadata differ. This file is selected explicitly by the nightly H100
+robot-policy job.
+
+The in-process LeRobot parity oracle lives separately in
+``tests/diffusion/models/pi05/test_pi05_parity.py``.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import (
+    OmniServerParams,
+    get_open_port,
+    pi0_openpi_require_dependencies,
+    pi0_openpi_run_policy_session,
+    pi0_openpi_validate_session_result,
+)
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+os.environ["VLLM_TEST_CLEAN_GPU_MEMORY"] = "0"
+
+MODEL = "lerobot/pi05_base"
+
+
+test_params = [
+    OmniServerParams(
+        model=MODEL,
+        port=8093,
+        server_args=[
+            "--deploy-config",
+            "vllm_omni/deploy/pi05.yaml",
+            "--enforce-eager",
+            "--disable-log-stats",
+        ],
+        env_dict={
+            "ATTENTION_BACKEND": "torch",
+            "DIFFUSION_ATTENTION_BACKEND": "TORCH_SDPA",
+            "VLLM_DISABLE_COMPILE_CACHE": "1",
+            "MASTER_PORT": str(get_open_port()),
+        },
+    )
+]
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "H100"})
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_pi05_openpi_online(omni_server):
+    pi0_openpi_require_dependencies()
+
+    result = pi0_openpi_run_policy_session(
+        host=omni_server.host,
+        port=omni_server.port,
+        prompt="pick up the red block and place it in the bin",
+        session_id="pi05-online-e2e",
+        num_steps=2,
+        num_inference_steps=2,
+    )
+
+    # Asserts every returned chunk is [50, 32] + finite, and the handshake
+    # metadata matches pi05.yaml's policy_server_config.
+    pi0_openpi_validate_session_result(result)
+
+    metadata = result["metadata"]
+    assert tuple(metadata["image_resolution"]) == (224, 224)
+    assert metadata["needs_wrist_camera"] is True
+    assert metadata["needs_session_id"] is False
+    assert metadata["action_space"] == "joint_position"
diff --git a/tests/e2e/online_serving/test_qwen2_5_omni_expansion.py b/tests/e2e/online_serving/test_qwen2_5_omni_expansion.py
index 1e5e59aed..389b0b6ba 100644
--- a/tests/e2e/online_serving/test_qwen2_5_omni_expansion.py
+++ b/tests/e2e/online_serving/test_qwen2_5_omni_expansion.py
@@ -96,6 +96,32 @@ def test_mix_to_text_audio_001(omni_server, online_client) -> None:
     online_client.send_omni_request(request_config)
 
 
+@pytest.mark.slow
+@pytest.mark.omni
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+@pytest.mark.parametrize("stream", [False, True])
+def test_audio_in_video_boundaries(omni_server, online_client, stream: bool) -> None:
+    """Interleaved video/audio input must not treat audio boundaries as image placeholders."""
+    # More than two seconds exercises multiple interleaved video/audio chunks.
+    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(224, 224, 128, embed_audio=True)['base64']}"
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        video_data_url=video_data_url,
+        content_text="Describe what you see and hear in this video in one sentence.",
+    )
+    responses = online_client.send_omni_request(
+        {
+            "model": omni_server.model,
+            "messages": messages,
+            "stream": stream,
+            "modalities": ["text"],
+            "use_audio_in_video": True,
+        }
+    )
+    assert responses[0].text_content
+
+
 @pytest.mark.slow
 @pytest.mark.omni
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
diff --git a/tests/e2e/online_serving/test_qwen3_omni.py b/tests/e2e/online_serving/test_qwen3_omni.py
index f6ede8944..5b4bbc51e 100644
--- a/tests/e2e/online_serving/test_qwen3_omni.py
+++ b/tests/e2e/online_serving/test_qwen3_omni.py
@@ -24,29 +24,40 @@ _MODEL = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
 _CI_DEPLOY = get_deploy_config_path("ci/qwen3_omni_moe.yaml")
 
 
-# For prefix caching checks against we enable it on the thinker and talker via CLI override
-# and enable prompt token details so that we can determine if any tokens were cached.
-# We also explicitly set block size so that we can make sure the cached token counts are a
-# multiple of the block size.
+# Prefix cache is opt-in on the deploy YAML. CI overlay also pins
+# ``async_chunk: False``; the existing server keeps ``--no-async-chunk``.
+# Production Qwen YAML is ``async_chunk: true``, so a sibling server boots
+# with ``--async-chunk`` and the same cache overrides (async output builder).
 BLOCK_SIZE = 16
+_PREFIX_CACHE_SERVER_ARGS = [
+    "--block-size",
+    str(BLOCK_SIZE),
+    "--stage-overrides",
+    '{"0": {"enable_prefix_caching": true}, "1": {"enable_prefix_caching": true}}',
+    "--enable-prompt-tokens-details",
+]
 test_params = [
     pytest.param(
         OmniServerParams(
             model=_MODEL,
             stage_config_path=_CI_DEPLOY,
             use_stage_cli=True,
-            server_args=[
-                "--no-async-chunk",
-                "--block-size",
-                str(BLOCK_SIZE),
-                "--stage-overrides",
-                '{"0": {"enable_prefix_caching": true}, "1": {"enable_prefix_caching": true}}',
-                "--enable-prompt-tokens-details",
-            ],
+            server_args=["--no-async-chunk", *_PREFIX_CACHE_SERVER_ARGS],
         ),
         id="default",
     )
 ]
+prefix_cache_async_chunk_params = [
+    pytest.param(
+        OmniServerParams(
+            model=_MODEL,
+            stage_config_path=_CI_DEPLOY,
+            use_stage_cli=True,
+            server_args=["--async-chunk", *_PREFIX_CACHE_SERVER_ARGS],
+        ),
+        id="prefix_cache_async_chunk",
+    )
+]
 
 
 def get_system_prompt():
@@ -245,6 +256,83 @@ def test_thinker_prefix_caching_audio_output(omni_server, online_client) -> None
     _run_prefix_cache_check(online_client, request_config)
 
 
+def _assert_omni_payload_complete(resp) -> None:
+    """Async-chunk + prefix-cache must still deliver a full downstream payload."""
+    assert resp.success
+    assert resp.text_content
+    has_audio = bool(resp.audio_bytes) or bool(resp.audio_data)
+    assert has_audio
+
+
+@pytest.mark.advanced_model
+@pytest.mark.core_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", prefix_cache_async_chunk_params, indirect=True)
+def test_thinker_prefix_caching_async_chunk_identical(omni_server, online_client) -> None:
+    """Production path: ``async_chunk: true`` plus thinker/talker prefix cache.
+
+    Two identical streaming requests. The second must report a block-aligned
+    cache hit and still produce text + audio (async output builder).
+    """
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        content_text=get_prompt(),
+    )
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+        "stream_options": {"include_usage": True},
+    }
+    first_response, cached_response = _run_prefix_cache_check(online_client, request_config)
+    _assert_omni_payload_complete(first_response)
+    _assert_omni_payload_complete(cached_response)
+
+
+@pytest.mark.advanced_model
+@pytest.mark.core_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", prefix_cache_async_chunk_params, indirect=True)
+def test_thinker_prefix_caching_async_chunk_shared_image_prefix(omni_server, online_client) -> None:
+    """Shared image / system prefix, different user text — not a full-prompt replay.
+
+    The second request must still hit cached tokens (block-aligned, less than
+    its prompt). A merge that only works when ``hit_upto == prompt_len`` would
+    fail this.
+    """
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(224, 224)['base64']}"
+    first_messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        image_data_url=image_data_url,
+        content_text=get_prompt("text_image"),
+    )
+    second_messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        image_data_url=image_data_url,
+        content_text="How many squares are in this image? Answer in 20 words.",
+    )
+    first_cfg = {
+        "model": omni_server.model,
+        "messages": first_messages,
+        "stream": True,
+        "stream_options": {"include_usage": True},
+        "modalities": ["text"],
+    }
+    second_cfg = {**first_cfg, "messages": second_messages}
+    first_response = online_client.send_omni_request(first_cfg, request_num=1)[0]
+    cached_response = online_client.send_omni_request(second_cfg, request_num=1)[0]
+    assert first_response.success and cached_response.success
+    assert first_response.text_content and cached_response.text_content
+    num_cached = cached_response.cached_tokens
+    num_prompt = cached_response.prompt_tokens
+    assert num_cached is not None and num_prompt is not None
+    assert num_cached > 0
+    assert num_cached % BLOCK_SIZE == 0
+    assert num_cached < num_prompt
+
+
 @pytest.mark.advanced_model
 @pytest.mark.core_model
 @pytest.mark.omni
diff --git a/tests/e2e/online_serving/test_qwen3_tts_base.py b/tests/e2e/online_serving/test_qwen3_tts_base.py
index dd25520f9..338655925 100644
--- a/tests/e2e/online_serving/test_qwen3_tts_base.py
+++ b/tests/e2e/online_serving/test_qwen3_tts_base.py
@@ -12,6 +12,7 @@ import os
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
 import pytest
+from vllm.platforms import current_platform
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import get_asset_path
@@ -50,7 +51,16 @@ tts_server_params = [
             server_args=["--trust-remote-code"],
         ),
         id="async_chunk",
-    )
+    ),
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=get_deploy_config_path("qwen3_tts_mrv2.yaml"),
+            server_args=["--trust-remote-code"],
+        ),
+        id="async_chunk_mrv2",
+        marks=pytest.mark.skipif(not current_platform.is_cuda(), reason="MRV2 validation is CUDA-only"),
+    ),
 ]
 
 
diff --git a/tests/e2e/online_serving/test_qwen3_tts_word_timestamps.py b/tests/e2e/online_serving/test_qwen3_tts_word_timestamps.py
new file mode 100644
index 000000000..d8bd6302e
--- /dev/null
+++ b/tests/e2e/online_serving/test_qwen3_tts_word_timestamps.py
@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import base64
+import json
+
+import pytest
+from websockets.sync.client import connect
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
+
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
+
+_DEPLOY = modify_stage_config(
+    get_deploy_config_path("qwen3_tts.yaml"),
+    updates={
+        "stages": {
+            0: {
+                "max_num_seqs": 4,
+                "max_num_batched_tokens": 2048,
+                "max_model_len": 2048,
+                "gpu_memory_utilization": 0.45,
+                "compilation_config.cudagraph_capture_sizes": [1, 2, 4],
+                "default_sampling_params.max_tokens": 256,
+            },
+            1: {
+                "max_num_seqs": 4,
+                "max_num_batched_tokens": 4096,
+                "max_model_len": 8192,
+                "gpu_memory_utilization": 0.15,
+            },
+        }
+    },
+)
+_PARAMS = [
+    OmniServerParams(
+        model="Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice",
+        stage_config_path=_DEPLOY,
+        server_args=[
+            "--trust-remote-code",
+            "--forced-aligner",
+            "Qwen/Qwen3-ForcedAligner-0.6B",
+            "--kv-cache-memory-bytes",
+            str(512 * 1024**2),
+            "--max-num-seqs",
+            "4",
+            "--max-num-batched-tokens",
+            "2048",
+        ],
+    )
+]
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", _PARAMS, indirect=True)
+def test_async_chunk_word_timestamps(omni_server, online_client):
+    online_client.send_audio_speech_request(
+        {
+            "model": omni_server.model,
+            "input": "The weather is nice today, perfect for a walk in the park.",
+            "voice": "vivian",
+            "language": "English",
+            "word_timestamps": True,
+            "response_format": "wav",
+            "min_audio_bytes": 40_000,
+            "timeout": 120,
+        },
+        request_num=2,
+    )
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", _PARAMS, indirect=True)
+def test_async_chunk_speech_without_timestamps(omni_server, online_client):
+    online_client.send_audio_speech_request(
+        {
+            "model": omni_server.model,
+            "input": "The weather is nice today, perfect for a walk in the park.",
+            "voice": "vivian",
+            "language": "English",
+            "stream": True,
+            "stream_format": "audio",
+            "response_format": "wav",
+            "min_audio_bytes": 40_000,
+            "timeout": 120,
+        }
+    )
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", _PARAMS, indirect=True)
+def test_async_chunk_streaming_word_timestamps(omni_server):
+    text = "The weather is nice today, perfect for a walk in the park."
+    chunks = []
+    timestamps = None
+    with connect(f"ws://{omni_server.host}:{omni_server.port}/v1/audio/speech/stream") as ws:
+        ws.send(
+            json.dumps(
+                {
+                    "type": "session.config",
+                    "voice": "vivian",
+                    "language": "English",
+                    "stream_audio": True,
+                    "response_format": "pcm",
+                    "word_timestamps": True,
+                }
+            )
+        )
+        ws.send(json.dumps({"type": "input.text", "text": text}))
+        ws.send(json.dumps({"type": "input.done"}))
+        while True:
+            message = json.loads(ws.recv(timeout=120))
+            assert message["type"] != "error", message
+            if message["type"] == "audio.chunk":
+                if message["audio_b64"]:
+                    chunks.append(base64.b64decode(message["audio_b64"]))
+                if message["timestamps"] is not None:
+                    timestamps = message["timestamps"]
+                    sample_rate = message["sample_rate"]
+            elif message["type"] == "audio.done":
+                assert not message["error"], message
+                assert message["total_bytes"] == sum(map(len, chunks))
+            elif message["type"] == "session.done":
+                break
+
+    assert len(chunks) > 1
+    assert timestamps
+    assert len(timestamps) == len(text.split())
+    duration_ms = sum(map(len, chunks)) / (2 * sample_rate) * 1000
+    final_chunk_ms = len(chunks[-1]) / (2 * sample_rate) * 1000
+    assert timestamps[-1]["end_ms"] > max(duration_ms / 2, final_chunk_ms)
+    previous_end = 0
+    for timestamp in timestamps:
+        assert previous_end <= timestamp["start_ms"] <= timestamp["end_ms"] <= duration_ms + 1
+        previous_end = timestamp["end_ms"]
diff --git a/tests/e2e/online_serving/test_voxcpm2_tts.py b/tests/e2e/online_serving/test_voxcpm2_tts.py
index 0d0364138..1f27d5eb0 100644
--- a/tests/e2e/online_serving/test_voxcpm2_tts.py
+++ b/tests/e2e/online_serving/test_voxcpm2_tts.py
@@ -18,7 +18,7 @@ from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniServerParams
 from tests.helpers.stage_config import get_deploy_config_path
 
-MODEL = "openbmb/VoxCPM2"
+MODEL = os.environ.get("VOXCPM2_MODEL", "openbmb/VoxCPM2")
 DEFAULT_AUDIO_SPEECH_TIMEOUT_S = 300.0
 MAX_CONCURRENT = 4
 
@@ -48,7 +48,7 @@ tts_server_params = [
 
 @pytest.mark.slow
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_001(omni_server, online_client) -> None:
     """
@@ -73,7 +73,7 @@ def test_text_to_audio_001(omni_server, online_client) -> None:
 
 @pytest.mark.slow
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_002(omni_server, online_client) -> None:
     """
diff --git a/tests/e2e/online_serving/test_voxcpm2_tts_expansion.py b/tests/e2e/online_serving/test_voxcpm2_tts_expansion.py
index d630c8627..ad01a9fcb 100644
--- a/tests/e2e/online_serving/test_voxcpm2_tts_expansion.py
+++ b/tests/e2e/online_serving/test_voxcpm2_tts_expansion.py
@@ -20,7 +20,7 @@ pytestmark = [pytest.mark.slow, pytest.mark.tts]
 
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
-MODEL = "openbmb/VoxCPM2"
+MODEL = os.environ.get("VOXCPM2_MODEL", "openbmb/VoxCPM2")
 DEFAULT_AUDIO_SPEECH_TIMEOUT_S = 300.0
 _MIN_AUDIO_BYTES = 40_000
 MAX_CONCURRENT = 4
@@ -47,7 +47,7 @@ tts_server_params = [
 ]
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_voice_clone_streaming_001(omni_server, online_client) -> None:
     """
@@ -72,7 +72,7 @@ def test_voice_clone_streaming_001(omni_server, online_client) -> None:
     online_client.send_audio_speech_request(request_config, request_num=MAX_CONCURRENT)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "npu": "A2"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_response_format_001(omni_server, online_client) -> None:
     """
diff --git a/tests/engine/duplex/test_deadline_pacing.py b/tests/engine/duplex/test_deadline_pacing.py
new file mode 100644
index 000000000..2b1bf09d6
--- /dev/null
+++ b/tests/engine/duplex/test_deadline_pacing.py
@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Deterministic unit tests for deadline-aligned silence continuation.
+
+The engine-resident duplex scheduler in
+``vllm_omni/engine/duplex/session/runner.py`` aligns each silence
+continuation to ``submission_time_N + chunk_period`` and sleeps only the
+remaining budget. These tests cover the pure deadline arithmetic and the
+per-session reset semantics of the shared ``DuplexModelSessionState``
+contract.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from vllm_omni.engine.duplex.session.runner import (
+    compute_silence_continuation_deadline,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.session import (
+    MiniCPMO45ServingSessionState,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    ("chunk_period_s", "now", "last_submit", "current_deadline", "delay_s", "next_silence_deadline"),
+    [
+        # First continuation anchors to the last real submission: unit N was
+        # submitted at t=1.0, audio N produced at 1.4 -> 0.6 s of sleep left.
+        (1.0, 1.4, 1.0, None, 0.6, 3.0),
+        # Only the remaining budget is slept (audio produced at 1.7).
+        (1.0, 1.7, 1.0, None, 0.3, 3.0),
+        # Overdue deadline: no sleep; the chain still advances by the period.
+        (1.0, 2.5, 1.0, None, 0.0, 3.0),
+        # No submission yet (None): the first continuation anchors to now.
+        (1.0, 0.4, None, None, 1.0, 2.4),
+        # Deadlines advance from the current deadline, not from now, so pipeline
+        # processing time does not accumulate as timer drift.
+        (1.0, 4.2, 3.0, 5.0, 0.8, 6.0),
+        # Two consecutive units that overrun their deadline by 0.2 s keep the
+        # 1 s cadence: no sleep, and the chain advances one period each.
+        (1.0, 2.2, 1.0, None, 0.0, 3.0),
+        (1.0, 3.2, 2.0, 3.0, 0.0, 4.0),
+        # A short overshoot (within one period of the current deadline) still
+        # chases the stale deadline: immediate submit, chain advances.
+        (1.0, 2.5, 1.0, 2.0, 0.0, 3.0),
+        # A long stall (more than one period past the current deadline) submits
+        # one continuation immediately and restarts from that submission.
+        (1.0, 5.0, 1.0, 2.0, 0.0, 6.0),
+        # The same recovery applies to the first continuation after a stall.
+        (1.0, 5.0, 1.0, None, 0.0, 6.0),
+        # Zero chunk period (guarded upstream): total, no sleep.
+        (0.0, 10.0, None, None, 0.0, 10.0),
+    ],
+)
+def test_compute_silence_continuation_deadline(
+    chunk_period_s: float,
+    now: float,
+    last_submit: float | None,
+    current_deadline: float | None,
+    delay_s: float,
+    next_silence_deadline: float,
+) -> None:
+    delay, next_dl = compute_silence_continuation_deadline(
+        chunk_period_s=chunk_period_s,
+        now=now,
+        last_submit=last_submit,
+        current_deadline=current_deadline,
+    )
+    assert delay == pytest.approx(delay_s)
+    assert next_dl == pytest.approx(next_silence_deadline)
+
+
+class TestSilenceDeadlineSessionState:
+    def test_clear_continuation_resets_the_deadline_chain(self) -> None:
+        # The native-duplex session state feeds the shared runner, so it must
+        # start with an unset chain and drop it at turn boundaries.
+        state = MiniCPMO45ServingSessionState()
+        assert state.last_native_submit_monotonic is None
+        assert state.silence_deadline_monotonic is None
+        state.last_native_submit_monotonic = 5.0
+        state.silence_deadline_monotonic = 6.0
+        state.clear_continuation()
+        assert state.last_native_submit_monotonic is None
+        assert state.silence_deadline_monotonic is None
diff --git a/tests/engine/duplex/test_deadline_pacing_scheduler.py b/tests/engine/duplex/test_deadline_pacing_scheduler.py
new file mode 100644
index 000000000..451af0bfd
--- /dev/null
+++ b/tests/engine/duplex/test_deadline_pacing_scheduler.py
@@ -0,0 +1,370 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Focused scheduler tests for deadline-aligned silence continuation.
+
+These tests exercise the production ``_schedule_silence_continuation`` path
+(and the append acceptance callback it installs) rather than copying the
+scheduling arithmetic. The monotonic clock is a fake so the deadline math is
+deterministic, and ``asyncio.sleep`` is simulated by advancing that clock.
+Append completion is controlled by gating the stage port's ``submit``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+
+import vllm_omni.engine.duplex.session.model_channel as model_channel_module
+import vllm_omni.engine.duplex.session.runner as runner_module
+from tests.engine.duplex.test_session_runner import (
+    Harness,
+    append_audio,
+    close_harness,
+    open_harness,
+    tts_output,
+)
+from vllm_omni.engine.duplex.contracts import DuplexStageSubmission
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+CHUNK_PERIOD_S = 1.0
+
+
+class FakeClock:
+    """A monotonic clock whose value the test controls directly."""
+
+    def __init__(self, start: float = 0.0) -> None:
+        self.value = start
+
+    def __call__(self) -> float:
+        return self.value
+
+
+async def _active_response_harness() -> Harness:
+    """Open a harness and drive a TTS segment so a response is active."""
+    h = await open_harness()
+    await h.run(append_audio())
+    request_id = h.stage0_request_id()
+    await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+    assert h.session.active_response_id is not None
+    return h
+
+
+def _continuation_kwargs(h: Harness) -> dict[str, object]:
+    """The scheduler arguments the model channel would pass for this session."""
+    return {
+        "request_id": h.session.active_request_id,
+        "owner_id": f"response:{h.session.active_response_id}",
+        "response_id": h.session.active_response_id,
+        "response_owned": True,
+        "expected_epoch": h.session.epoch,
+        "expected_model_turn_id": h.session.turn_id,
+    }
+
+
+def _install_fake_clock(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    clock: FakeClock,
+    real_sleep: Callable[..., Any],
+) -> list[float]:
+    """Point both modules at the fake clock and simulate ``asyncio.sleep``.
+
+    ``real_sleep`` is the unpatched ``asyncio.sleep`` captured before patching;
+    the simulated sleep advances the fake clock by the requested delay and then
+    yields control so the append task can run. The returned ``stall`` list is
+    added once to the next *positive* sleep so a test can model a wake that
+    happens late (after the planned deadline); zero-duration scheduling yields
+    do not consume it.
+    """
+    monkeypatch.setattr(runner_module.time, "monotonic", clock)
+    monkeypatch.setattr(model_channel_module.time, "monotonic", clock)
+    stall: list[float] = [0.0]
+
+    async def fake_sleep(delay: float) -> None:
+        clock.value += delay
+        if delay > 0:
+            clock.value += stall[0]
+            stall[0] = 0.0
+        await real_sleep(0)
+
+    monkeypatch.setattr(asyncio, "sleep", fake_sleep)
+    return stall
+
+
+@pytest.mark.asyncio
+async def test_normal_cadence_keeps_deadlines_aligned(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Processing time reduces the remaining sleep; consecutive deadlines align.
+
+    Each accepted unit becomes the new anchor (its submission time), and the
+    following continuation advances from the stored deadline rather than
+    resetting to now.
+    """
+    clock = FakeClock(start=100.0)
+    real_sleep = asyncio.sleep
+    _install_fake_clock(monkeypatch, clock=clock, real_sleep=real_sleep)
+    h = await _active_response_harness()
+    try:
+        # Real input accepted at t=100.0; the model processes for 0.4 s.
+        h.runner.model_state.last_native_submit_monotonic = 100.0
+        clock.value = 100.4
+
+        # First continuation: due at 101.0, so only 0.6 s of sleep remains.
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        first_task = h.runner.tasks.append_tail
+        assert first_task is not None
+        assert await first_task
+        # The accepted unit re-anchored the chain to its own submission time
+        # (101.0) and stored the following deadline (102.0).
+        assert h.runner.model_state.last_native_submit_monotonic == pytest.approx(101.0)
+        assert h.runner.model_state.silence_deadline_monotonic == pytest.approx(102.0)
+
+        # Model produces the continuation's audio; the next unit is planned
+        # from the stored deadline (no drift): the following deadline is 103.0.
+        clock.value = 101.3
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        second_task = h.runner.tasks.append_tail
+        assert second_task is not None
+        assert await second_task
+        assert h.runner.model_state.silence_deadline_monotonic == pytest.approx(103.0)
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_in_flight_real_append_skips_outdated_silence(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A real append accepted after the silence was planned re-anchors the chain.
+
+    The planned silence queues behind the real append; once the real append
+    completes and re-anchors, ``before_append`` detects the changed anchor
+    (numeric timestamp) and the outdated silence is skipped (no submission,
+    no callback overwrite).
+    """
+    clock = FakeClock(start=200.0)
+    real_sleep = asyncio.sleep
+    _install_fake_clock(monkeypatch, clock=clock, real_sleep=real_sleep)
+    h = await _active_response_harness()
+    state = h.runner.model_state
+    submissions_before = len(h.port.submissions)
+
+    original_submit = h.port.submit
+    entered = asyncio.Event()
+    release = asyncio.Event()
+
+    async def gated_submit(submission: DuplexStageSubmission) -> Any:
+        entered.set()
+        await release.wait()
+        return await original_submit(submission)
+
+    monkeypatch.setattr(h.port, "submit", gated_submit)
+    try:
+        # Existing anchor at t=200.0.
+        state.last_native_submit_monotonic = 200.0
+        state.silence_deadline_monotonic = None
+
+        # The real append starts at t+0.8 and blocks inside the gate.
+        clock.value = 200.8
+        real_append_task = await h.runner._start_append(
+            h.runner.model.silence_unit_payload(),
+            final=False,
+            silence_continuation=False,
+        )
+        await entered.wait()
+        assert not real_append_task.done()
+
+        # At t+1.0 the silence is planned using the existing anchor; its append
+        # task waits behind the real append.
+        clock.value = 201.0
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        silence_task = h.runner.tasks.append_tail
+        assert silence_task is not None
+        assert not silence_task.done()
+
+        # At t+1.1 the real append is released; both appends finish.
+        clock.value = 201.1
+        release.set()
+        assert await real_append_task
+        assert await silence_task
+
+        # Exactly one additional submission happened: the real append. The
+        # outdated silence was skipped, so its callback never overwrote the
+        # new anchor (the real append's submission time t+0.8), and the
+        # deadline the real append cleared stays cleared.
+        assert len(h.port.submissions) == submissions_before + 1
+        assert state.last_native_submit_monotonic == pytest.approx(200.8)
+        assert state.silence_deadline_monotonic is None
+
+        # A fresh continuation uses the new anchor. The clock is left at t+1.1:
+        # the scheduler sleeps the remaining 0.7 s (deadline t+1.8), which
+        # verifies re-anchoring controls the wait. Following deadline t+2.8.
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        fresh_task = h.runner.tasks.append_tail
+        assert fresh_task is not None
+        assert await fresh_task
+        assert state.last_native_submit_monotonic == pytest.approx(201.8)
+        assert state.silence_deadline_monotonic == pytest.approx(202.8)
+    finally:
+        release.set()
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_long_stall_saves_future_deadline_from_actual_submission(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A submission more than one period past the planned deadline restarts.
+
+    The schedule plans the following deadline at ``planned + period``, but the
+    actual submission happens much later. The accepted continuation must save
+    ``submit_time + period`` so the next unit is not immediately due.
+    """
+    clock = FakeClock(start=300.0)
+    real_sleep = asyncio.sleep
+    stall = _install_fake_clock(monkeypatch, clock=clock, real_sleep=real_sleep)
+    h = await _active_response_harness()
+    state = h.runner.model_state
+    try:
+        # Plan a continuation whose deadline is 1.0 s in the future. The wake
+        # is delayed 2 s past the planned submission (anchor + 3.0 during the
+        # scheduler's sleep), so the append accepts 2 s late.
+        anchor = clock.value
+        state.last_native_submit_monotonic = anchor
+        state.silence_deadline_monotonic = None
+        stall[0] = 2.0
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        append_task = h.runner.tasks.append_tail
+        assert append_task is not None
+        assert await append_task
+        # anchor + 3.0 > anchor + 2.0 (planned deadline + period) -> save
+        # submit_time + period = anchor + 4.0.
+        assert state.last_native_submit_monotonic == pytest.approx(anchor + 3.0)
+        assert state.silence_deadline_monotonic == pytest.approx(anchor + 4.0)
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_small_wakeup_delay_preserves_planned_deadline(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Ordinary wakeup jitter (within one period) keeps the planned cadence.
+
+    A submission 0.2 s past the planned deadline must not reset the chain: the
+    stored deadline stays at ``planned + period`` so drift does not accumulate.
+    """
+    clock = FakeClock(start=400.0)
+    real_sleep = asyncio.sleep
+    stall = _install_fake_clock(monkeypatch, clock=clock, real_sleep=real_sleep)
+    h = await _active_response_harness()
+    state = h.runner.model_state
+    try:
+        anchor = clock.value
+        state.last_native_submit_monotonic = anchor
+        state.silence_deadline_monotonic = None
+        stall[0] = 0.2
+
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        append_task = h.runner.tasks.append_tail
+        assert append_task is not None
+        assert await append_task
+
+        # Submitted at anchor + period + 0.2 (within one period): the planned
+        # following deadline is kept.
+        assert state.last_native_submit_monotonic == pytest.approx(anchor + CHUNK_PERIOD_S + 0.2)
+        assert state.silence_deadline_monotonic == pytest.approx(anchor + 2 * CHUNK_PERIOD_S)
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_exact_one_period_late_preserves_planned_deadline(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Exactly one period late is not "more than one period late".
+
+    The strict ``>`` comparison means a submission exactly at the planned
+    following deadline keeps the planned cadence (no extra catch-up unit).
+    """
+    clock = FakeClock(start=500.0)
+    real_sleep = asyncio.sleep
+    stall = _install_fake_clock(monkeypatch, clock=clock, real_sleep=real_sleep)
+    h = await _active_response_harness()
+    state = h.runner.model_state
+    try:
+        anchor = clock.value
+        state.last_native_submit_monotonic = anchor
+        state.silence_deadline_monotonic = None
+        stall[0] = 1.0
+
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        append_task = h.runner.tasks.append_tail
+        assert append_task is not None
+        assert await append_task
+
+        # Submitted exactly at the planned following deadline: kept.
+        assert state.last_native_submit_monotonic == pytest.approx(anchor + 2 * CHUNK_PERIOD_S)
+        assert state.silence_deadline_monotonic == pytest.approx(anchor + 2 * CHUNK_PERIOD_S)
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_failed_append_leaves_timing_unchanged(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A failed append never advances the timing chain."""
+    clock = FakeClock(start=600.0)
+    real_sleep = asyncio.sleep
+    _install_fake_clock(monkeypatch, clock=clock, real_sleep=real_sleep)
+    h = await _active_response_harness()
+    state = h.runner.model_state
+    try:
+        state.last_native_submit_monotonic = 600.0
+        state.silence_deadline_monotonic = 601.0
+        before_anchor = state.last_native_submit_monotonic
+        before_deadline = state.silence_deadline_monotonic
+        h.port.fail_submit = RuntimeError("boom")
+
+        scheduled = await h.runner._schedule_silence_continuation(
+            h.runner.model.silence_unit_payload(),
+            **_continuation_kwargs(h),
+        )
+        assert scheduled is True
+        append_task = h.runner.tasks.append_tail
+        assert append_task is not None
+        # The append fails: its task reports failure, and timing is untouched.
+        assert await append_task is False
+        assert state.last_native_submit_monotonic == before_anchor
+        assert state.silence_deadline_monotonic == before_deadline
+    finally:
+        await close_harness(h)
diff --git a/tests/engine/duplex/test_duplex_events.py b/tests/engine/duplex/test_duplex_events.py
index a4ebfbf5a..6330059a1 100644
--- a/tests/engine/duplex/test_duplex_events.py
+++ b/tests/engine/duplex/test_duplex_events.py
@@ -11,6 +11,7 @@ import inspect
 import pytest
 
 from vllm_omni.engine.duplex import events as events_module
+from vllm_omni.engine.duplex.commands import ClearOutputAudio, TruncateItem
 from vllm_omni.engine.duplex.events import (
     REALTIME_ERROR_TYPES_BY_CODE,
     AudioDelta,
@@ -40,6 +41,9 @@ from vllm_omni.engine.duplex.events import (
 from vllm_omni.engine.duplex.realtime_events import (
     RealtimeProjectionState,
     project_internal_event,
+    resolve_clear_output_audio,
+    resolve_truncate_item,
+    retrieve_item_events,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -373,6 +377,96 @@ def test_projection_of_output_audio_buffer_clear_emits_cleared_before_terminals(
     assert state.item_truncation_cursors["item_resp_1"] == (0, 250)
 
 
+@pytest.mark.parametrize("reason", ["turn_detected", "barge_in", "output_audio_buffer_clear"])
+@pytest.mark.parametrize("committed_ms", [1000, 10000])
+def test_completed_response_cancellation_only_clears_pending_playback(reason, committed_ms):
+    state = RealtimeProjectionState(session_id="duplex-playback")
+    project_internal_event(state, {"type": "response.created", "response_id": "resp_1"})
+    project_internal_event(state, {"type": "response.done", "response_id": "resp_1"})
+
+    cancelled = project_internal_event(
+        state,
+        {
+            "type": "audio.cancelled",
+            "response_id": "resp_1",
+            "reason": reason,
+            "committed_ms": committed_ms,
+            "playback": {"sent_ms": 10000, "committed_ms": committed_ms},
+        },
+    )
+
+    if reason == "output_audio_buffer_clear" or committed_ms < 10000:
+        assert _types(cancelled) == ["output_audio_buffer.cleared"]
+        assert cancelled[0].response_id == "resp_1"
+    else:
+        assert cancelled == []
+
+
+@pytest.mark.parametrize("explicit_response_id", [False, True])
+def test_clear_latest_completed_response_reaches_playback_owner(explicit_response_id):
+    state = RealtimeProjectionState(session_id="duplex-clear")
+    project_internal_event(state, {"type": "response.created", "response_id": "resp_1"})
+    project_internal_event(state, {"type": "response.done", "response_id": "resp_1"})
+
+    control = resolve_clear_output_audio(
+        state, ClearOutputAudio(response_id="resp_1" if explicit_response_id else None, event_id="clear_1")
+    )
+
+    # Generation completion does not prove the client has drained its audio.
+    # A cleared event must follow the engine clearing its playback cursor.
+    assert control.events == []
+    assert control.payloads == [
+        {
+            "type": "output_audio_buffer.clear",
+            "reason": "output_audio_buffer.clear",
+            "response_id": "resp_1",
+            "realtime_event_id": "clear_1",
+        }
+    ]
+
+
+@pytest.mark.parametrize("new_response_finished", [False, True])
+def test_late_clear_of_completed_response_does_not_touch_new_response(new_response_finished):
+    state = RealtimeProjectionState(session_id="duplex-clear")
+    project_internal_event(state, {"type": "response.created", "response_id": "resp_1"})
+    project_internal_event(state, {"type": "response.done", "response_id": "resp_1"})
+    project_internal_event(state, {"type": "response.created", "response_id": "resp_2"})
+    if new_response_finished:
+        project_internal_event(state, {"type": "response.done", "response_id": "resp_2"})
+
+    control = resolve_clear_output_audio(state, ClearOutputAudio(response_id="resp_1"))
+
+    assert control.payloads == []
+    assert _types(control.events) == ["output_audio_buffer.cleared"]
+    assert control.events[0].response_id == "resp_1"
+    assert state.active_response_id == (None if new_response_finished else "resp_2")
+    assert state.last_response_id == "resp_2"
+
+
+def test_one_truncate_command_truncates_retrieved_transcript_once():
+    state = RealtimeProjectionState(session_id="duplex-truncate")
+    state.conversation_items["item_resp_1"] = {
+        "id": "item_resp_1",
+        "type": "message",
+        "role": "assistant",
+        "status": "completed",
+        "content": [{"type": "output_audio", "transcript": "abcdefghij", "audio_duration_ms": 10_000}],
+    }
+
+    control = resolve_truncate_item(state, TruncateItem(item_id="item_resp_1", audio_end_ms=4_000))
+    # The runner executes this signal and projects its acknowledgement.
+    signal = control.payloads[0]
+    payload = signal["payload"]
+    assert isinstance(payload, dict)
+    assert signal["event"] == "conversation.item.truncate"
+    project_internal_event(state, {"type": "conversation.item.truncated", **payload})
+
+    retrieved = retrieve_item_events(state, {"item_id": "item_resp_1"})[0].to_realtime()
+    assert retrieved["item"]["content"][0]["transcript"] == "abcd"
+    # Keep the cursor: later output must not restore the untruncated item.
+    assert state.item_truncation_cursors["item_resp_1"] == (0, 4_000)
+
+
 def test_projection_leaves_error_to_typed_emit_sites():
     # Errors are constructed typed (``error_event``) at the emit site; the projector
     # has no ``error`` branch and falls back to the raw wrapper for such a dict.
diff --git a/tests/engine/duplex/test_engine_session.py b/tests/engine/duplex/test_engine_session.py
index fccaa59e8..5ef4ab6b9 100644
--- a/tests/engine/duplex/test_engine_session.py
+++ b/tests/engine/duplex/test_engine_session.py
@@ -21,6 +21,7 @@ from vllm_omni.engine.duplex.config import (
 from vllm_omni.engine.duplex.contracts import DuplexFence
 from vllm_omni.engine.duplex.events import TurnEvent
 from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession, DuplexFenceMismatchError
+from vllm_omni.engine.duplex.session.playback_ledger import apply_playback_ack
 from vllm_omni.model_executor.models.minicpmo_4_5.duplex.capabilities import (
     minicpmo45_native_capabilities,
 )
@@ -241,6 +242,83 @@ def test_history_commit_with_ack_only_policy_defers_unacknowledged_text():
     assert f"item_{response_id}" in session.pending_history_item_ids
 
 
+@pytest.mark.parametrize("audio_complete", [False, True])
+def test_unaligned_response_keeps_empty_turn_before_later_user_input(audio_complete):
+    session = _session(config=DuplexSessionConfig(playback_commit_policy="ack_only"))
+    first = session.commit_audio_input(transcript="recite a poem")
+    response_id = session.begin_response()
+    session.reserve_history_item(f"item_{response_id}")
+    session.append_assistant_text("An answer the user has only partly heard")
+    session.mark_audio_sent(
+        duration_ms=10_000,
+        text_requires_complete_audio=True,
+        audio_complete=audio_complete,
+    )
+
+    assert session.end_response(commit_text=True) is None
+    session.barge_in()
+    session.clear_playback_cursor()
+    second = session.commit_audio_input(transcript="stop")
+    empty_answer = {"role": "assistant", "content": ""}
+    assert session.history == (first.message, empty_answer, second.message)
+
+    ack = apply_playback_ack(session, {"response_id": response_id, "played_ms": 6_981})
+    assert ack[0].to_realtime()["event"]["history_committed"] is False
+    assert session.history == (first.message, empty_answer, second.message)
+
+    if audio_complete:
+        ack = apply_playback_ack(session, {"response_id": response_id, "played_ms": 10_000})
+        assert ack[0].to_realtime()["event"]["history_committed"] is True
+        assert session.history == (
+            first.message,
+            {"role": "assistant", "content": "An answer the user has only partly heard"},
+            second.message,
+        )
+
+
+@pytest.mark.parametrize(("reserve_slot", "assistant_text"), [(True, ""), (False, "unplayed answer")])
+def test_unaligned_response_only_materializes_an_existing_answer_slot(reserve_slot, assistant_text):
+    session = _session(config=DuplexSessionConfig(playback_commit_policy="ack_only"))
+    first = session.commit_audio_input(transcript="first input")
+    response_id = session.begin_response()
+    if reserve_slot:
+        session.reserve_history_item(f"item_{response_id}")
+    session.append_assistant_text(assistant_text)
+    session.mark_audio_sent(duration_ms=10_000, text_requires_complete_audio=True, audio_complete=True)
+
+    assert session.end_response(commit_text=reserve_slot) is None
+    assert session.history == (first.message,)
+
+
+@pytest.mark.parametrize("operation", ["delete", "truncate"])
+def test_removing_one_empty_assistant_preserves_the_other_turn_boundary(operation):
+    session = _session(config=DuplexSessionConfig(playback_commit_policy="ack_only"))
+    user_inputs = []
+    response_ids = []
+    for transcript in ("first input", "second input"):
+        user_inputs.append(session.commit_audio_input(transcript=transcript).message)
+        response_id = session.begin_response()
+        response_ids.append(response_id)
+        session.reserve_history_item(f"item_{response_id}")
+        session.append_assistant_text("unplayed answer")
+        session.mark_audio_sent(duration_ms=10_000, text_requires_complete_audio=True, audio_complete=True)
+        session.end_response(commit_text=True)
+
+    item_id = f"item_{response_ids[1]}"
+    if operation == "delete":
+        assert session.delete_history_item(item_id) is True
+    else:
+        # A full ACK releases the pending snapshot. Truncation then edits the
+        # stored message into another empty dict before removing that item.
+        ack = apply_playback_ack(session, {"response_id": response_ids[1], "played_ms": 10_000})
+        assert ack[0].to_realtime()["event"]["history_committed"] is True
+        assert session.truncate_history_item(item_id, audio_end_ms=0, hard=True) is True
+    assert session.history == (user_inputs[0], {"role": "assistant", "content": ""}, user_inputs[1])
+    ack = apply_playback_ack(session, {"response_id": response_ids[1], "played_ms": 10_000})
+    assert ack[0].to_realtime()["error"]["code"] == "playback_item_not_found"
+    assert session.history == (user_inputs[0], {"role": "assistant", "content": ""}, user_inputs[1])
+
+
 def test_truncate_history_item_uses_response_alignment_marks():
     session = _session()
     response_id = session.begin_response()
@@ -567,10 +645,10 @@ def test_overlap_policy_defaults_and_invalid_values_to_listen_only():
     assert DuplexSessionConfig.from_event({"session": {"overlap_policy": "bogus"}}).overlap_policy == "listen_only"
 
 
-def test_capabilities_as_dict_reports_model_native_duplex_constants():
+def test_capabilities_as_dict_reports_declared_implementation():
     caps = DuplexCapabilities().as_dict()
 
-    assert caps["implementation_level"] == "model_native_duplex"
+    assert caps["implementation_level"] == "turn_based_duplex"
     assert caps["input_modes"] == ["append_audio_chunk"]
     assert caps["supports_kv_lease"] is False
     assert caps["supports_core_kv_lease"] is False
diff --git a/tests/engine/duplex/test_session_manager.py b/tests/engine/duplex/test_session_manager.py
index 0323f16d8..bccce18f1 100644
--- a/tests/engine/duplex/test_session_manager.py
+++ b/tests/engine/duplex/test_session_manager.py
@@ -120,6 +120,8 @@ class FakeModelSessionState(DuplexModelSessionState):
         self.continuation_units = 0
         self.pending_silence_task = None
         self.pending_silence_owner_id = None
+        self.last_native_submit_monotonic = None
+        self.silence_deadline_monotonic = None
 
     def retain_committed_audio(self, payload, *, operation_id, reserved_bytes=0) -> None:
         self.committed_audio_payload = payload
@@ -136,6 +138,8 @@ class FakeModelSessionState(DuplexModelSessionState):
     def clear_continuation(self) -> None:
         self.continuation_owner_id = None
         self.continuation_units = 0
+        self.last_native_submit_monotonic = None
+        self.silence_deadline_monotonic = None
 
 
 class FakeDataPlane(DuplexDataPlane):
@@ -192,7 +196,7 @@ class FakePlugin(DuplexModelPlugin):
 
     def capabilities(self, *, max_sessions: int) -> DuplexCapabilities:
         del max_sessions
-        return DuplexCapabilities(supports_input_append=True)
+        return DuplexCapabilities(supports_input_append=True, supports_core_resumable_request=True)
 
     def validate_client_extra_body(self, extra_body: object) -> None:
         pass
@@ -404,7 +408,9 @@ async def test_open_answers_with_capabilities_and_emits_session_created() -> Non
         assert result.control_id == "open-sid-open"
         assert result.session_id == "sid-open"
         assert result.lease_generation == 0
-        assert result.capabilities == DuplexCapabilities(supports_input_append=True)
+        assert result.capabilities == DuplexCapabilities(
+            supports_input_append=True, supports_core_resumable_request=True
+        )
         assert result.public_session is not None
         assert result.public_session["id"] == "sid-open"
         assert result.public_session["voice"] == "test"
diff --git a/tests/engine/duplex/test_vad_backend.py b/tests/engine/duplex/test_vad_backend.py
index 8a22259ac..f3163ff4e 100644
--- a/tests/engine/duplex/test_vad_backend.py
+++ b/tests/engine/duplex/test_vad_backend.py
@@ -107,8 +107,8 @@ def test_endpoint_decisions_match_the_serving_side_policy(
 # --------------------------------------------------------------------------- #
 
 
-def test_a_loud_frame_does_not_restart_the_silence_timer() -> None:
-    """Silero v6.2 hysteresis: once silence is running, a loud frame only delays it.
+def test_hysteresis_band_does_not_restart_the_silence_timer() -> None:
+    """Scores between the negative and activation thresholds preserve the timer.
 
     The frame at 0.45 sits above the negative threshold (0.35) but below the
     activation threshold. It must not cancel the pending endpoint, or a speaker
@@ -164,9 +164,14 @@ def _pcm16_b64(samples: np.ndarray) -> str:
 
 def test_pcm16_input_is_accepted_alongside_float32() -> None:
     config = SileroVADConfig(threshold=0.5)
-    tone = np.zeros(FRAME * 2, dtype=np.float32)
+    tone: np.ndarray = np.zeros(FRAME * 2, dtype=np.float32)
     seen: list[int] = []
-    vad = SileroStreamingVAD(config, frame_scorer=lambda frame: seen.append(frame.size) or 0.0)
+
+    def _score_frame(frame: np.ndarray) -> float:
+        seen.append(frame.size)
+        return 0.0
+
+    vad = SileroStreamingVAD(config, frame_scorer=_score_frame)
     vad.process_base64(_pcm16_b64(tone), fmt="pcm16", sample_rate_hz=SAMPLE_RATE_HZ)
     assert seen == [FRAME, FRAME]
 
@@ -272,7 +277,7 @@ def test_the_onnx_backend_holds_the_upstream_silero_v62_contract(monkeypatch, tm
         intra_op_num_threads = 0
 
     class FakeInferenceSession:
-        def __init__(self, path: str, *, providers: list[str], sess_options: object) -> None:
+        def __init__(self, path: str, *, providers: list[str], sess_options: FakeSessionOptions) -> None:
             self.providers = providers
             self.sess_options = sess_options
             self.calls: list[dict[str, np.ndarray]] = []
@@ -313,7 +318,7 @@ def test_the_onnx_backend_holds_the_upstream_silero_v62_contract(monkeypatch, tm
     assert session.calls[0]["sr"].item() == SAMPLE_RATE_HZ
 
     state = backend.new_state()
-    first_frame = np.arange(backend.frame_samples, dtype=np.float32)
+    first_frame: np.ndarray = np.arange(backend.frame_samples, dtype=np.float32)
     probability, state = backend.infer(first_frame, state)
     first_call = session.calls[1]
 
@@ -377,3 +382,17 @@ def test_the_documented_server_vad_fields_are_all_accepted() -> None:
         )
         is None
     )
+
+
+@pytest.mark.parametrize("speech_probability", [0.5, 0.9])
+def test_resumed_speech_cancels_pending_silence(speech_probability):
+    config = SileroVADConfig(threshold=0.5, prefix_padding_ms=0, silence_duration_ms=96, min_speech_duration_ms=32)
+    # 32 ms pause, resumed speech, then a full 96 ms pause: one utterance.
+    scores = [0.9, 0.1, speech_probability, speech_probability, 0.1, 0.1, 0.1]
+    assert _drive(config, scores) == [("start", 0), ("stop", 224)]
+
+
+def test_short_pauses_do_not_split_continuous_speech_into_repeated_turns():
+    config = SileroVADConfig(threshold=0.5, prefix_padding_ms=0, silence_duration_ms=500, min_speech_duration_ms=32)
+    scores = [0.9] + [0.1, 0.9, 0.9, 0.9] * 20
+    assert _drive(config, scores) == [("start", 0)]
diff --git a/tests/engine/test_arg_utils.py b/tests/engine/test_arg_utils.py
index 0e88a00ef..d40a9c226 100644
--- a/tests/engine/test_arg_utils.py
+++ b/tests/engine/test_arg_utils.py
@@ -539,7 +539,44 @@ def test_tensor_parallel_size_none_is_handled():
     engine_args = OmegaConf.create({"stage_id": 0, "engine_args": {"tensor_parallel_size": None}})
     args = build_engine_args_dict(
         engine_args,
-        model="snu-aidas/Dynin-Omni",
+        model="Qwen/Qwen2-VL-2B-Instruct",
     )
     assert isinstance(args, dict)
     assert "tensor_parallel_size" not in args
+
+
+# For https://github.com/vllm-project/vllm-omni/issues/7564
+def test_from_cli_args_preserves_text_encoder_tp_size():
+    """`--text-encoder-tp-size` must survive from_cli_args field filtering.
+
+    Library callers build engine args via ``OmniEngineArgs.from_cli_args``;
+    the dataclass field filter drops any namespace attribute the dataclass
+    does not declare, silently resetting the diffusion text-encoder TP to 1.
+    """
+    engine_args = OmniEngineArgs.from_cli_args(
+        SimpleNamespace(text_encoder_tp_size=2),
+    )
+    assert engine_args.text_encoder_tp_size == 2
+
+
+# For https://github.com/vllm-project/vllm-omni/issues/7564
+def test_text_encoder_tp_size_reaches_default_diffusion_parallel_config():
+    """The preserved CLI value must land in DiffusionParallelConfig.
+
+    Mirrors the library flow: from_cli_args -> kwargs -> the generic
+    diffusion fallback, which resolves the field through
+    ``DiffusionParallelConfig.from_stage_overrides``.
+    """
+    from dataclasses import asdict
+
+    from vllm_omni.config.config_factory import StageConfigFactory
+
+    engine_args = OmniEngineArgs.from_cli_args(
+        SimpleNamespace(text_encoder_tp_size=2),
+    )
+    stage_cfg = StageConfigFactory.create_default_diffusion(
+        {k: v for k, v in asdict(engine_args).items() if v is not None},
+    )[0]
+
+    parallel_config = stage_cfg["engine_args"]["parallel_config"]
+    assert parallel_config["text_encoder_tp_size"] == 2
diff --git a/tests/engine/test_async_omni_engine_abort_ack.py b/tests/engine/test_async_omni_engine_abort_ack.py
index 43a29bf3a..366e640f6 100644
--- a/tests/engine/test_async_omni_engine_abort_ack.py
+++ b/tests/engine/test_async_omni_engine_abort_ack.py
@@ -66,9 +66,10 @@ def test_abort_async_waits_for_ack(mocker: MockerFixture):
         assert msg.rpc_id == "abort-rpc-1"
         assert not task.done()
 
-        rpc_q.put(AbortResultMessage(rpc_id="abort-rpc-1", success=True))
+        partial_output = SimpleNamespace(request_id="req-a", finished=True)
+        rpc_q.put(AbortResultMessage(rpc_id="abort-rpc-1", success=True, abort_outputs=[partial_output]))
         result = await task
-        assert result == []
+        assert result == [partial_output]
 
     try:
         asyncio.run(_run())
diff --git a/tests/engine/test_async_omni_engine_stage_init.py b/tests/engine/test_async_omni_engine_stage_init.py
index f052f7e9d..ec897bd7d 100644
--- a/tests/engine/test_async_omni_engine_stage_init.py
+++ b/tests/engine/test_async_omni_engine_stage_init.py
@@ -8,24 +8,66 @@ import json
 import os
 import time
 import types
+from dataclasses import dataclass, field
 
 import pytest
+from omegaconf import OmegaConf
+from vllm.v1.engine.utils import EngineZmqAddresses
 
+from vllm_omni.config.omni_config import OmniStageRuntimeConfig
 from vllm_omni.diffusion.data import AttentionConfig
 from vllm_omni.engine import omni_engine_base as async_omni_engine_module
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+from vllm_omni.engine.stage_engine_startup import StageReplicaResources
 from vllm_omni.engine.stage_init_utils import (
     LogicalStageInitPlan,
     ReplicaInitPlan,
     build_stage0_input_processor,
     compute_replica_layout,
     split_devices_for_replicas,
+    stage_runtime_env,
 )
 from vllm_omni.engine.stage_runtime import StageRuntime
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+@dataclass
+class _FakeParallelConfig:
+    enable_fault_tolerance: bool = False
+    enable_elastic_ep: bool = False
+    data_parallel_size: int = 1
+    use_ray: bool = False
+
+
+@dataclass
+class _FakeVllmConfig:
+    parallel_config: _FakeParallelConfig = field(default_factory=_FakeParallelConfig)
+
+
+@dataclass
+class _FakeRuntimeConfig:
+    devices: str
+
+
+@dataclass
+class _FakeStageConfig:
+    stage_id: int
+    stage_type: str
+    engine_args: dict[str, object]
+    runtime: _FakeRuntimeConfig
+
+
+def test_stage_runtime_env_accepts_typed_runtime_config(monkeypatch):
+    env_key = "VLLM_OMNI_TEST_TYPED_STAGE_ENV"
+    monkeypatch.delenv(env_key, raising=False)
+
+    with stage_runtime_env(0, OmniStageRuntimeConfig(env={env_key: "typed-value"})):
+        assert os.environ[env_key] == "typed-value"
+
+    assert env_key not in os.environ
+
+
 def test_orchestrator_startup_timeout_warns_how_to_raise_limits(monkeypatch):
     engine = object.__new__(AsyncOmniEngine)
     engine.orchestrator_thread = types.SimpleNamespace(is_alive=lambda: True)
@@ -187,7 +229,7 @@ def test_stage_engine_core_client_module_reload_keeps_forward_refs_deferred():
     )
 
 
-def test_async_omni_engine_initialize_stages_passes_log_stats_to_runtime(monkeypatch):
+def test_async_omni_engine_initialize_stages_passes_log_stats_and_client_config_to_runtime(monkeypatch):
     import vllm_omni.engine.omni_engine_base as engine_mod
 
     engine = object.__new__(AsyncOmniEngine)
@@ -205,6 +247,7 @@ def test_async_omni_engine_initialize_stages_passes_log_stats_to_runtime(monkeyp
     engine._omni_lb_policy = "random"
     engine.request_queue = types.SimpleNamespace()
     engine._log_stats = True
+    engine._client_config = engine_mod.OmniClientConfig(client_count=2, client_index=1, stage_addresses={})
     engine._parallel_stage_init = False
 
     captured: dict[str, object] = {}
@@ -220,6 +263,51 @@ def test_async_omni_engine_initialize_stages_passes_log_stats_to_runtime(monkeyp
 
     assert captured["stage_init_timeout"] == 7
     assert captured["log_stats"] is True
+    assert captured["client_config"] is engine._client_config
+
+
+def test_async_omni_engine_initialize_stages_retains_stage0_prompt_transform(monkeypatch):
+    import vllm_omni.engine.omni_engine_base as engine_mod
+
+    engine = object.__new__(AsyncOmniEngine)
+    engine.stage_configs = [types.SimpleNamespace()]
+    engine.model = "dummy-model"
+    engine.config_path = "dummy-config"
+    engine.single_stage_mode = False
+    engine.async_chunk = False
+    engine.tokenizer = None
+    engine._single_stage_id_filter = None
+    engine._omni_master_address = None
+    engine._omni_master_port = None
+    engine._omni_dp_size_local = 1
+    engine._omni_heartbeat_timeout = 30.0
+    engine._omni_lb_policy = "random"
+    engine.request_queue = types.SimpleNamespace()
+    engine._log_stats = False
+    engine._parallel_stage_init = False
+
+    prompt_transform = object()
+    client = types.SimpleNamespace(
+        prompt_transform_func=prompt_transform,
+        prompt_expand_func=None,
+        default_sampling_params=types.SimpleNamespace(),
+        final_output=True,
+        final_output_type="text",
+        stage_type="llm",
+        model_stage="text_encoder",
+        is_comprehension=True,
+    )
+    pool = types.SimpleNamespace(
+        stage_client=client,
+        stage_vllm_config=None,
+        output_processor=None,
+    )
+    runtime = types.SimpleNamespace(stage_pools=[pool], initialize=lambda: None)
+    monkeypatch.setattr(engine_mod, "create_stage_runtime", lambda **_kwargs: runtime)
+
+    engine._initialize_stages(stage_init_timeout=7)
+
+    assert engine.prompt_transform_func is prompt_transform
 
 
 def test_compute_replica_layout_splits_diffusion_devices_by_world_size():
@@ -776,6 +864,289 @@ def test_stage_runtime_passes_log_stats_to_llm_replica_launch(monkeypatch):
     assert captured["client_log_stats"] is True
 
 
+def test_stage_runtime_attaches_external_llm_client_without_launching_engine(monkeypatch):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    client_addresses = {
+        "input_address": "ipc://stage0-input-1",
+        "output_address": "ipc://stage0-output-1",
+    }
+    client_config = {
+        "client_count": 2,
+        "client_index": 1,
+        "stage_addresses": {0: {0: client_addresses}},
+    }
+    runtime = StageRuntime(
+        stage_configs=[],
+        model="dummy-model",
+        config_path="dummy-config",
+        stage_init_timeout=1,
+        async_chunk=False,
+        client_config=client_config,
+    )
+    parallel_config = _FakeParallelConfig()
+    vllm_config = _FakeVllmConfig(parallel_config=parallel_config)
+    plan = _make_llm_plan(0, stage_id=0, vllm_config=vllm_config).replicas[0]
+    captured: dict[str, object] = {}
+    stage_client = object()
+
+    def _capture_client(**kwargs):
+        captured.update(kwargs)
+        return stage_client
+
+    monkeypatch.setattr(runtime_mod.StageEngineCoreClientBase, "make_async_mp_client", _capture_client)
+    monkeypatch.setattr(
+        runtime_mod,
+        "launch_stage_replica",
+        lambda **_kwargs: pytest.fail("external client must not launch a stage engine"),
+    )
+
+    assert runtime._initialize_local_llm_replica(plan, stage_init_timeout=1) is stage_client
+    assert captured["client_addresses"] == client_addresses
+    assert captured["client_count"] == 2
+    assert captured["client_index"] == 1
+    assert not hasattr(parallel_config, "_api_process_count")
+    assert not hasattr(parallel_config, "_api_process_rank")
+
+
+@pytest.mark.parametrize("stage_ids", [(0,), (0, 1)], ids=["single-stage", "multi-stage"])
+@pytest.mark.parametrize("client_count", [1, 2])
+def test_stage_runtime_launches_shared_engines_with_per_client_addresses(monkeypatch, stage_ids, client_count):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    stage_plans = []
+    for stage_id in stage_ids:
+        parallel_config = _FakeParallelConfig()
+        plan = _make_llm_plan(
+            stage_id,
+            stage_id=stage_id,
+            vllm_config=_FakeVllmConfig(parallel_config=parallel_config),
+        )
+        plan.replicas[0].engine_args_dict = {}
+        stage_plans.append(plan)
+    stage_plans[0].replicas[0].metadata.runtime_cfg = {"env": {"VLLM_OMNI_TEST_STAGE_RUNTIME_ENV": "enabled"}}
+
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: stage_plans)
+    monkeypatch.setattr(runtime, "_resolve_replica_physical_devices", lambda stage_id, _cfg: str(stage_id))
+    monkeypatch.setattr(runtime_mod, "acquire_device_locks", lambda *_args: [])
+
+    events: list[tuple[str, int]] = []
+    captured_launch_kwargs: list[dict[str, object]] = []
+    captured_launch_env: list[str | None] = []
+
+    @contextlib.contextmanager
+    def _fake_launch_stage_replica(**kwargs):
+        stage_id = kwargs["stage_id"]
+        events.append(("enter", stage_id))
+        captured_launch_kwargs.append(kwargs)
+        captured_launch_env.append(os.environ.get("VLLM_OMNI_TEST_STAGE_RUNTIME_ENV"))
+        yield StageReplicaResources(
+            addresses=EngineZmqAddresses(
+                inputs=[f"ipc://stage{stage_id}-input-{idx}" for idx in range(client_count)],
+                outputs=[f"ipc://stage{stage_id}-output-{idx}" for idx in range(client_count)],
+            ),
+        )
+        events.append(("exit", stage_id))
+
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", _fake_launch_stage_replica)
+
+    with runtime.launch_stage_engines(client_count) as launch:
+        expected = (
+            [("enter", stage_id) for stage_id in stage_ids]
+            if client_count > 1
+            else [(event, stage_id) for stage_id in stage_ids for event in ("enter", "exit")]
+        )
+        assert events == expected
+        for client_index, config in enumerate(launch.client_configs):
+            assert config["client_count"] == client_count
+            assert config["client_index"] == client_index
+            for stage_id in stage_ids:
+                assert config["stage_addresses"][stage_id][0] == {
+                    "input_address": f"ipc://stage{stage_id}-input-{client_index}",
+                    "output_address": f"ipc://stage{stage_id}-output-{client_index}",
+                }
+
+    assert events == (
+        [(event, stage_id) for event in ("enter", "exit") for stage_id in stage_ids] if client_count > 1 else expected
+    )
+    assert not hasattr(stage_plans[0].replicas[0].stage_vllm_config.parallel_config, "_api_process_count")
+    assert not hasattr(stage_plans[0].replicas[0].stage_vllm_config.parallel_config, "_api_process_rank")
+    assert all(
+        kwargs["watched_frontend_processes"] is (launch.watched_frontend_processes if client_count > 1 else None)
+        for kwargs in captured_launch_kwargs
+    )
+    assert captured_launch_env == ["enabled" if stage_id == 0 else None for stage_id in stage_ids]
+    assert os.environ.get("VLLM_OMNI_TEST_STAGE_RUNTIME_ENV") is None
+
+
+@pytest.mark.parametrize("client_count", [1, 2])
+def test_stage_runtime_overlapping_devices_acquire_real_locks_once(monkeypatch, tmp_path, client_count):
+    import fcntl
+
+    import vllm_omni.engine.stage_init_utils as init_utils
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    plans = [_make_llm_plan(stage_id, stage_id=stage_id, vllm_config=_FakeVllmConfig()) for stage_id in (0, 1)]
+    for stage_id, plan in enumerate(plans):
+        plan.replicas[0].engine_args_dict = {"tensor_parallel_size": stage_id + 1}
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: plans)
+    monkeypatch.setattr(runtime, "_resolve_replica_physical_devices", lambda sid, _cfg: "0" if sid == 0 else "0,1")
+    monkeypatch.setattr(
+        init_utils, "device_init_lock_path", lambda device_id: str(tmp_path / f"device-{device_id}.lock")
+    )
+    monkeypatch.setattr(
+        init_utils.time, "sleep", lambda _: pytest.fail("Overlapping stages must not wait on their own lock")
+    )
+
+    @contextlib.contextmanager
+    def launch(**kwargs):
+        # Real flock on a separate descriptor proves the runtime holds each lock.
+        for device_id in range(kwargs["stage_id"] + 1):
+            with open(tmp_path / f"device-{device_id}.lock", "a") as probe:
+                with pytest.raises(BlockingIOError):
+                    fcntl.flock(probe, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        yield StageReplicaResources(
+            addresses=EngineZmqAddresses(
+                inputs=[f"ipc://input-{i}" for i in range(client_count)],
+                outputs=[f"ipc://output-{i}" for i in range(client_count)],
+            )
+        )
+
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", launch)
+    with runtime.launch_stage_engines(client_count):
+        pass
+    for device_id in (0, 1):
+        with open(tmp_path / f"device-{device_id}.lock", "a") as probe:
+            fcntl.flock(probe, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            fcntl.flock(probe, fcntl.LOCK_UN)
+
+
+@pytest.mark.parametrize("diffusion_stage_id", [0, 1], ids=["diffusion-only", "enginecore-to-diffusion"])
+def test_stage_runtime_multi_api_rejects_diffusion_before_launch(monkeypatch, diffusion_stage_id):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    stage_plans = [
+        _make_llm_plan(stage_id, stage_id=stage_id, vllm_config=_FakeVllmConfig())
+        for stage_id in range(diffusion_stage_id)
+    ]
+    stage_plans.append(_make_diffusion_plan(diffusion_stage_id, stage_id=diffusion_stage_id))
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: stage_plans)
+    monkeypatch.setattr(
+        runtime_mod,
+        "acquire_device_locks",
+        lambda *_args: pytest.fail("unsupported topology must fail before acquiring devices"),
+    )
+    monkeypatch.setattr(
+        runtime_mod,
+        "launch_stage_replica",
+        lambda **_kwargs: pytest.fail("unsupported topology must not partially launch EngineCore stages"),
+    )
+
+    with pytest.raises(ValueError, match="diffusion stage\\(s\\) are not supported"):
+        with runtime.launch_stage_engines(2):
+            pytest.fail("unsupported topology must not yield a launch handle")
+
+
+def test_stage_runtime_multi_api_maps_stage_devices_from_launcher_visibility(monkeypatch):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    stage_plan = _make_llm_plan(
+        0,
+        stage_id=0,
+        vllm_config=_FakeVllmConfig(),
+    )
+    replica = stage_plan.replicas[0]
+    replica.engine_args_dict = {}
+    replica.metadata.runtime_cfg = {"devices": "0"}
+
+    device_env = runtime_mod.current_omni_platform.device_control_env_var
+    monkeypatch.setenv(device_env, "5")
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: [stage_plan])
+    monkeypatch.setattr(runtime_mod, "acquire_device_locks", lambda *_args: [])
+    captured_devices: list[str | None] = []
+
+    @contextlib.contextmanager
+    def _fake_launch_stage_replica(**kwargs):
+        captured_devices.append(kwargs["stage_visible_devices"])
+        yield StageReplicaResources(
+            addresses=EngineZmqAddresses(
+                inputs=["ipc://input-0", "ipc://input-1"],
+                outputs=["ipc://output-0", "ipc://output-1"],
+            ),
+        )
+
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", _fake_launch_stage_replica)
+
+    with runtime.launch_stage_engines(2):
+        pass
+
+    assert captured_devices == ["5"]
+    assert os.environ[device_env] == "5"
+
+
+def test_stage_runtime_multi_api_rejects_elastic_ep(monkeypatch):
+    runtime = _make_stage_runtime()
+    stage_plan = _make_llm_plan(
+        0,
+        stage_id=0,
+        vllm_config=_FakeVllmConfig(parallel_config=_FakeParallelConfig(enable_elastic_ep=True)),
+    )
+    stage_plan.replicas[0].engine_args_dict = {}
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: [stage_plan])
+
+    with pytest.raises(ValueError, match="enable-elastic-ep"):
+        with runtime.launch_stage_engines(2):
+            pass
+
+
+def test_stage_runtime_multi_api_failure_shuts_down_before_exceptional_context_exit(monkeypatch):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    stage_plan = _make_llm_plan(0, stage_id=0, vllm_config=_FakeVllmConfig())
+    stage_plan.replicas[0].engine_args_dict = {}
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: [stage_plan])
+    monkeypatch.setattr(runtime, "_resolve_replica_physical_devices", lambda *_args: None)
+    monkeypatch.setattr(runtime_mod, "acquire_device_locks", lambda *_args: [])
+
+    events: list[str] = []
+
+    class _Manager:
+        def shutdown(self) -> None:
+            events.append("shutdown")
+
+    @contextlib.contextmanager
+    def _fake_launch_stage_replica(**_kwargs):
+        try:
+            yield StageReplicaResources(
+                manager=_Manager(),
+                addresses=EngineZmqAddresses(
+                    inputs=["tcp://127.0.0.1:0", "tcp://127.0.0.1:1"],
+                    outputs=["tcp://127.0.0.1:2", "tcp://127.0.0.1:3"],
+                ),
+            )
+        except RuntimeError as exc:
+            events.append(f"exceptional-exit:{exc}")
+            raise
+        else:
+            events.append("normal-exit")
+
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", _fake_launch_stage_replica)
+
+    with pytest.raises(RuntimeError, match="deferred TCP addresses"):
+        with runtime.launch_stage_engines(2):
+            pass
+
+    assert events == [
+        "shutdown",
+        "exceptional-exit:Stage 0 returned deferred TCP addresses; multi-API launch requires fixed ports or IPC addresses",
+    ]
+
+
 def test_stage_runtime_passes_log_stats_to_output_processor(monkeypatch):
     import vllm_omni.engine.stage_runtime as runtime_mod
 
@@ -1022,7 +1393,7 @@ def test_initialize_local_llm_replica_passes_stage_init_timeout_to_complete_stag
         num_replicas=1,
         launch_mode="local",
         stage_cfg=types.SimpleNamespace(engine_args={}, runtime=types.SimpleNamespace(devices="0")),
-        metadata=types.SimpleNamespace(stage_id=0, runtime_cfg={"devices": "0"}),
+        metadata=types.SimpleNamespace(stage_id=0, stage_type="llm", runtime_cfg={"devices": "0"}),
         stage_connector_spec={},
         omni_kv_connector=(None, None, None),
         stage_vllm_config=fake_vllm_config,
@@ -1714,6 +2085,51 @@ def test_inject_kv_stage_info_infers_receiver_tp_topology():
     assert stage1.engine_args["omni_kv_config"]["rank_mapping"] == {"from_tp": 4, "to_tp": 2}
 
 
+def test_inject_kv_stage_info_updates_typed_connector_config():
+    from vllm_omni.config.omni_config import (
+        OmniStageConnectorConfig,
+        OmniStageDiffusionParallelConfig,
+        VllmOmniDiffusionStageConfig,
+    )
+    from vllm_omni.config.stage_config import StageExecutionType, StagePipelineConfig
+    from vllm_omni.engine.stage_init_utils import inject_kv_stage_info
+    from vllm_omni.entrypoints.utils import inject_omni_kv_config
+
+    stage0 = VllmOmniDiffusionStageConfig(
+        stage_pipeline_config=StagePipelineConfig(
+            stage_id=0,
+            model_stage="diffusion",
+            execution_type=StageExecutionType.DIFFUSION,
+        ),
+        connector_config=OmniStageConnectorConfig(
+            omni_kv_config={
+                "need_send_cache": True,
+                "omni_from_stage": "0",
+                "omni_to_stage": "1",
+            }
+        ),
+        parallel_config=OmniStageDiffusionParallelConfig(tensor_parallel_size=4),
+    )
+    stage1 = VllmOmniDiffusionStageConfig(
+        stage_pipeline_config=StagePipelineConfig(
+            stage_id=1,
+            model_stage="diffusion",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(0,),
+        ),
+        connector_config=OmniStageConnectorConfig(omni_kv_config={"need_recv_cache": True}),
+        parallel_config=OmniStageDiffusionParallelConfig(tensor_parallel_size=2),
+    )
+
+    inject_omni_kv_config(stage0, {"kv_connector": "P2pNcclConnector"}, "0", "1")
+    inject_kv_stage_info(stage0, 0, [stage0, stage1])
+
+    assert stage0.connector_config.omni_kv_config["stage_id"] == 0
+    assert stage0.connector_config.omni_kv_config["connector_config"] == {"kv_connector": "P2pNcclConnector"}
+    assert stage0.connector_config.omni_kv_config["engine_input_source"] == []
+    assert stage0.connector_config.omni_kv_config["rank_mapping"] == {"from_tp": 4, "to_tp": 2}
+
+
 def test_extract_legacy_stage_metadata_rocm_does_not_inject_diffusion_attention(monkeypatch):
     """ROCm default attention logic only applies to LLM stages, not diffusion."""
     from vllm_omni.engine.stage_init_utils import extract_legacy_stage_metadata
@@ -1829,3 +2245,308 @@ def test_port_from_zmq_address_parsing():
     assert _port_from_zmq_address(None) is None
     assert _port_from_zmq_address("ipc:///tmp/sock") is None
     assert _port_from_zmq_address("tcp://host:not-a-port") is None
+
+
+@pytest.mark.parametrize("parallel", [False, True])
+@pytest.mark.parametrize("failure", ["ready", "attach", None])
+def test_single_api_common_launch_ownership_and_rollback(monkeypatch, parallel, failure):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    runtime._parallel_stage_init = parallel
+    plan = _make_llm_plan(0, stage_id=0, vllm_config=_FakeVllmConfig()).replicas[0]
+    plan.engine_args_dict = {}
+    events = []
+
+    class Manager:
+        def shutdown(self):
+            events.append("shutdown")
+
+    manager = Manager()
+    addresses = EngineZmqAddresses(inputs=["ipc://input"], outputs=["ipc://output"])
+    monkeypatch.setattr(runtime, "_resolve_replica_physical_devices", lambda *_: "0")
+
+    def acquire(*_):
+        events.append("lock")
+        return [42]
+
+    monkeypatch.setattr(runtime_mod, "acquire_device_locks", acquire)
+    monkeypatch.setattr(runtime_mod, "release_device_locks", lambda _: events.append("unlock"))
+
+    @contextlib.contextmanager
+    def launch(**kwargs):
+        assert kwargs["num_api_servers"] == 1
+        assert kwargs["omni_parallel_stage_init"] is parallel
+        events.append("spawn")
+        yield StageReplicaResources(manager=manager, addresses=addresses)
+        assert runtime._replica_launch_lock.locked() is False
+        events.append("ready")
+        if failure == "ready":
+            raise RuntimeError("ready")
+
+    def attach(**kwargs):
+        assert "ready" in events
+        assert kwargs["engine_manager"] is manager
+        events.append("attach")
+        if failure == "attach":
+            raise RuntimeError("attach")
+        return manager
+
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", launch)
+    monkeypatch.setattr(runtime_mod.StageEngineCoreClientBase, "make_async_mp_client", attach)
+    if failure:
+        with pytest.raises(RuntimeError, match=failure):
+            runtime._initialize_local_llm_replica(plan, 1)
+        assert events.count("shutdown") == 1
+    else:
+        assert runtime._initialize_local_llm_replica(plan, 1) is manager
+        assert "shutdown" not in events
+    assert events.count("lock") == events.count("unlock") == (0 if parallel else 1)
+
+
+@pytest.mark.parametrize("client_count", [1, 2])
+def test_common_launch_parallel_admission_before_spawn(monkeypatch, client_count):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = _make_stage_runtime()
+    runtime._parallel_stage_init = True
+    plan = _make_llm_plan(0, stage_id=0, vllm_config=_FakeVllmConfig())
+    plan.replicas[0].engine_args_dict = {}
+    events = []
+    monkeypatch.setattr(runtime, "_prepare_stage_plans", lambda: [plan])
+    monkeypatch.setattr(runtime, "_reject_unguardable_executors", lambda _: events.append("guard"))
+    monkeypatch.setattr(runtime, "_run_stage_admission", lambda _: events.append("admit"))
+    monkeypatch.setattr(runtime, "_resolve_replica_physical_devices", lambda *_: "0")
+
+    def forbidden_lock(*_):
+        pytest.fail("parallel initialization must use child phase locks")
+
+    monkeypatch.setattr(runtime_mod, "acquire_device_locks", forbidden_lock)
+
+    @contextlib.contextmanager
+    def launch(**kwargs):
+        assert events == ["guard", "admit"]
+        assert kwargs["omni_parallel_stage_init"] is True
+        events.append("spawn")
+        yield StageReplicaResources(
+            addresses=EngineZmqAddresses(
+                inputs=[f"ipc://in{i}" for i in range(client_count)],
+                outputs=[f"ipc://out{i}" for i in range(client_count)],
+            )
+        )
+        assert not runtime._replica_launch_lock.locked()
+        events.append("ready")
+
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", launch)
+    with runtime.launch_stage_engines(client_count):
+        pass
+    assert events == ["guard", "admit", "spawn", "ready"]
+
+
+@pytest.mark.parametrize(
+    "stage_modes,expected", [([False, True, True], True), ([False, False], False), ([True, False], True)]
+)
+def test_engine_async_chunk_includes_downstream_stages(monkeypatch, stage_modes, expected):
+    engine = object.__new__(AsyncOmniEngine)
+    stages = [OmegaConf.create({"engine_args": {"async_chunk": mode}}) for mode in stage_modes]
+    monkeypatch.setattr(async_omni_engine_module.StageConfigFactory, "get_pipeline_config", lambda *a, **k: None)
+    monkeypatch.setattr(engine, "_resolve_stage_configs", lambda *a, **k: (None, stages))
+    monkeypatch.setattr(engine, "_set_pipeline_runtime_config", lambda *a: None)
+
+    class ConfigResolvedError(Exception):
+        pass
+
+    def stop_before_queues(*args, **kwargs):
+        raise ConfigResolvedError
+
+    monkeypatch.setattr(async_omni_engine_module.janus, "Queue", stop_before_queues)
+    with pytest.raises(ConfigResolvedError):
+        engine.__init__("test-model")
+    assert engine.async_chunk is expected
+
+
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+def test_dist_stage_runtime_applies_local_dp_to_stage_config(typed):
+    from vllm_omni.config.omni_config import VllmOmniARStageConfig
+    from vllm_omni.config.stage_config import StagePipelineConfig
+    from vllm_omni.engine.stage_runtime import DistStageRuntime
+
+    if typed:
+        stage = VllmOmniARStageConfig(stage_pipeline_config=StagePipelineConfig(stage_id=0, model_stage="ar"))
+        runtime_cfg = stage.runtime_config
+    else:
+        runtime_cfg = types.SimpleNamespace(num_replicas=1)
+        stage = types.SimpleNamespace(stage_id=0, runtime=runtime_cfg)
+    runtime = DistStageRuntime(
+        stage_configs=[stage],
+        model="dummy-model",
+        config_path="dummy-config",
+        stage_init_timeout=1,
+        async_chunk=False,
+        single_stage_id_filter=0,
+        omni_master_address="127.0.0.1",
+        omni_master_port=12345,
+        omni_dp_size_local=2,
+    )
+
+    runtime._validate_single_stage_mode_replica_constraints()
+
+    assert runtime_cfg.num_replicas == 2
+
+
+@pytest.mark.parametrize("num_replicas", [1, 2, 3])
+@pytest.mark.parametrize("kv_owner", [None, "connector_config", "diffusion_config"])
+def test_typed_diffusion_replicas_share_one_config_between_planning_and_launch(mocker, num_replicas, kv_owner):
+    from vllm_omni.config.config_factory import StageConfigFactory
+    from vllm_omni.engine import stage_runtime as runtime_module
+
+    stage = StageConfigFactory.create_typed_default_diffusion(
+        "generic-diffusion", {"model_class_name": "QwenImagePipeline"}
+    ).stage_configs[0]
+    if kv_owner is not None:
+        from vllm.config import KVTransferConfig
+
+        getattr(stage, kv_owner).kv_transfer_config = KVTransferConfig(
+            kv_connector="MooncakeConnector", kv_role="kv_consumer", engine_id="dit"
+        )
+    devices = ",".join(str(i) for i in range(num_replicas))
+    stage.runtime_config.devices = devices
+    stage.runtime_config.num_replicas = num_replicas
+    runtime = StageRuntime(
+        stage_configs=[stage],
+        model="dummy-model",
+        config_path="dummy-config",
+        stage_init_timeout=1,
+        async_chunk=False,
+    )
+    mocker.patch.object(runtime_module, "get_stage_connector_spec", return_value={})
+    mocker.patch.object(runtime_module, "resolve_omni_kv_config_for_stage", return_value=(None, None, None))
+    mocker.patch.object(runtime, "_stage_device_scope", side_effect=lambda *_: contextlib.nullcontext())
+    client = mocker.Mock()
+    launch = mocker.patch.object(runtime_module, "launch_diffusion_stage_replica", return_value=(client, None))
+
+    # Replanning must not inherit the first replica's narrowed device slice.
+    for _ in range(2):
+        counts, device_map = compute_replica_layout([stage])
+        plans = runtime._build_logical_stage_init_plans(
+            omni_transfer_config=None,
+            replicas_per_stage=counts,
+            replica_devices_map=device_map,
+        )
+        replicas = plans[0].replicas
+        assert stage.runtime_config.devices == devices
+        assert len({id(plan.stage_cfg) for plan in replicas}) == num_replicas
+        for i, plan in enumerate(replicas):
+            assert plan.metadata.runtime_cfg is plan.stage_cfg.runtime_config
+            assert plan.stage_cfg.runtime_config.devices == str(i)
+            if num_replicas > 1 or kv_owner is not None:
+                assert plan.stage_cfg is not stage
+            if kv_owner is not None:
+                from vllm_omni.engine.stage_init_utils import build_engine_args_dict_from_omni_stage_config
+
+                assert getattr(stage, kv_owner).kv_transfer_config.engine_id == "dit"
+                engine_args = build_engine_args_dict_from_omni_stage_config(plan.stage_cfg, "dummy-model")
+                assert engine_args["kv_transfer_config"].engine_id == f"dit-s0-r{i}"
+            assert runtime._initialize_local_diffusion_replica(plan, stage_init_timeout=1) is client
+            assert launch.call_args.kwargs["stage_config"] is plan.stage_cfg
+            assert launch.call_args.kwargs["metadata"] is plan.metadata
+            assert launch.call_args.kwargs["use_inline"] is (num_replicas == 1)
+
+    assert launch.call_count == 2 * num_replicas
+
+
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+@pytest.mark.parametrize("num_replicas", [1, 2])
+def test_native_kv_producer_replica_identity_and_bootstrap_are_isolated(mocker, typed, num_replicas):
+    from vllm.config import KVTransferConfig
+
+    from vllm_omni.config.omni_config import VllmOmniARStageConfig
+    from vllm_omni.config.stage_config import StagePipelineConfig
+    from vllm_omni.engine import stage_runtime as runtime_module
+
+    kv_config = KVTransferConfig(
+        kv_connector="MooncakeConnector",
+        kv_role="kv_producer",
+        engine_id="ar",
+        kv_ip="127.0.0.1",
+        kv_connector_extra_config={"bootstrap_port": 9100},
+    )
+    if typed:
+        stage = VllmOmniARStageConfig(stage_pipeline_config=StagePipelineConfig(stage_id=0, model_stage="ar"))
+        stage.connector_config.kv_transfer_config = kv_config
+        runtime_cfg = stage.runtime_config
+    else:
+        runtime_cfg = OmegaConf.create({"devices": "0,1", "env": {"KEEP": "value"}})
+        stage = types.SimpleNamespace(stage_id=0, engine_args={"kv_transfer_config": kv_config}, runtime=runtime_cfg)
+        metadata = _make_llm_metadata(0)
+        mocker.patch.object(
+            runtime_module,
+            "extract_legacy_stage_metadata",
+            side_effect=lambda cfg: types.SimpleNamespace(**{**metadata.__dict__, "runtime_cfg": cfg.runtime}),
+        )
+    runtime_cfg.devices = "0,1"
+    runtime_cfg.env = {"KEEP": "value"}
+    runtime = StageRuntime(
+        stage_configs=[stage],
+        model="dummy-model",
+        config_path="dummy-config",
+        stage_init_timeout=1,
+        async_chunk=False,
+    )
+    mocker.patch.object(runtime_module, "get_stage_connector_spec", return_value={})
+    mocker.patch.object(runtime_module, "resolve_omni_kv_config_for_stage", return_value=(None, None, None))
+    for builder in ("build_engine_args_dict", "build_engine_args_dict_from_omni_stage_config"):
+        mocker.patch.object(runtime_module, builder, return_value={})
+    mocker.patch.object(
+        runtime_module,
+        "build_vllm_config",
+        return_value=(types.SimpleNamespace(kv_transfer_config=kv_config), object),
+    )
+
+    for _ in range(2):
+        plans = runtime._build_logical_stage_init_plans(None, [num_replicas], {})
+        for i, replica in enumerate(plans[0].replicas):
+            config = replica.stage_vllm_config.kv_transfer_config
+            assert config.engine_id == f"ar-s0-r{i}"
+            assert config.kv_connector_extra_config["bootstrap_addr"] == f"http://127.0.0.1:{9100 + i}"
+            assert dict(replica.metadata.runtime_cfg.env) == {
+                "KEEP": "value",
+                "VLLM_MOONCAKE_BOOTSTRAP_PORT": str(9100 + i),
+            }
+            if typed:
+                assert replica.metadata.runtime_cfg is replica.stage_cfg.runtime_config
+        assert kv_config.engine_id == "ar"
+        assert kv_config.kv_connector_extra_config == {"bootstrap_port": 9100}
+        assert dict(runtime_cfg.env) == {"KEEP": "value"}
+
+
+@pytest.mark.parametrize(
+    "roles, sources, async_chunk, valid",
+    [
+        (["kv_producer", "kv_consumer"], [0], False, True),
+        (["kv_producer", "kv_consumer"], [0], True, False),
+        ([None, "kv_consumer"], [0], False, False),
+        (["kv_producer", None], [0], False, False),
+        ([None, "kv_producer", "kv_consumer"], [1], False, False),
+        (["kv_producer", "kv_consumer"], [1], False, False),
+        ([None, None], [0], False, True),
+    ],
+)
+def test_native_kv_topology_rejects_silent_legacy_fallback(roles, sources, async_chunk, valid):
+    plans = []
+    for stage_id, role in enumerate(roles):
+        diffusion = stage_id == len(roles) - 1
+        config = types.SimpleNamespace(kv_role=role) if role else None
+        replica = types.SimpleNamespace(
+            metadata=types.SimpleNamespace(stage_type="diffusion" if diffusion else "llm", engine_input_source=sources),
+            stage_vllm_config=None if diffusion else types.SimpleNamespace(kv_transfer_config=config),
+            stage_cfg=types.SimpleNamespace(engine_args={"kv_transfer_config": config}),
+        )
+        plans.append(types.SimpleNamespace(stage_id=stage_id, replicas=[replica]))
+    runtime = object.__new__(StageRuntime)
+    runtime._async_chunk = async_chunk
+    if valid:
+        runtime._validate_native_kv_topology(plans)
+    else:
+        with pytest.raises(ValueError, match="two-stage"):
+            runtime._validate_native_kv_topology(plans)
diff --git a/tests/engine/test_duplex_orchestrator.py b/tests/engine/test_duplex_orchestrator.py
index 5b8130c36..703af6a35 100644
--- a/tests/engine/test_duplex_orchestrator.py
+++ b/tests/engine/test_duplex_orchestrator.py
@@ -515,3 +515,48 @@ async def test_a_dead_replica_closes_the_sessions_it_was_serving() -> None:
     messages = [output_q.get_nowait() for _ in range(output_q.qsize())]
     types = [getattr(getattr(m, "event", None), "type", type(m).__name__) for m in messages]
     assert types[-1] in {"session.expired", "session.closed"}, f"the client needs a terminal event, got {types}"
+
+
+@pytest.mark.asyncio
+async def test_turn_plugin_processes_multimodal_prompt_before_stage_submission(monkeypatch):
+    from vllm_omni.engine.orchestrator import build_engine_core_request_from_tokens
+    from vllm_omni.model_executor.models.qwen3_omni.duplex.plugin import Qwen3OmniDuplexPlugin
+
+    orchestrator, clients, rpc_q, _ = _build()
+    plugin = Qwen3OmniDuplexPlugin(_encode_audio)
+    plugin.processor = SimpleNamespace(apply_chat_template=lambda messages, **kwargs: "audio prompt")
+    orchestrator.plugin = orchestrator.session_manager.plugin = plugin
+    seen = []
+
+    def process_inputs(**kwargs):
+        seen.append(kwargs)
+        return build_engine_core_request_from_tokens(
+            request_id=kwargs["request_id"],
+            prompt={"prompt_token_ids": [1, 2]},
+            params=kwargs["params"],
+            model_config=orchestrator.stage_pools[0].stage_vllm_config.model_config,
+            resumable=kwargs["resumable"],
+        )
+
+    monkeypatch.setattr(
+        orchestrator, "_get_stage_input_processor", lambda stage_id: SimpleNamespace(process_inputs=process_inputs)
+    )
+    await orchestrator._dispatch_message(
+        OpenDuplexSessionMessage(
+            control_id="open-qwen",
+            session_id=SESSION_ID,
+            session_config=DuplexSessionConfig(model="qwen", modalities=["text", "audio"]),
+        )
+    )
+    assert (await rpc_q.get()).ok
+    try:
+        await _submit(orchestrator, _append_audio())
+        assert not clients[0].add_request_calls
+        await _submit(orchestrator, commands.Commit(final=True, create_response=True))
+        assert len(seen) == 1
+        assert seen[0]["prompt"]["multi_modal_data"]["audio"][0][0].shape == (16000,)
+        submitted = clients[0].add_request_calls[0][0]
+        assert submitted.resumable is False
+        assert not orchestrator.request_states[submitted.request_id].streaming.enabled
+    finally:
+        await _close(orchestrator, rpc_q)
diff --git a/tests/engine/test_orchestrator.py b/tests/engine/test_orchestrator.py
index 3b6ee7e7b..4bbca2515 100644
--- a/tests/engine/test_orchestrator.py
+++ b/tests/engine/test_orchestrator.py
@@ -22,6 +22,7 @@ from vllm.v1.engine.exceptions import EngineDeadError
 from vllm.v1.metrics.stats import IterationStats
 
 from vllm_omni.engine import OmniEngineCoreOutput
+from vllm_omni.engine.errors import NativeKVHandoffError
 from vllm_omni.engine.messages import (
     AbortRequestMessage,
     AbortResultMessage,
@@ -310,7 +311,7 @@ def _engine_core_outputs(tag: str, timestamp: float) -> SimpleNamespace:
     return SimpleNamespace(outputs=[tag], timestamp=timestamp, scheduler_stats=None, finished_requests=None)
 
 
-def _terminal_engine_core_outputs(request_id: str) -> EngineCoreOutputs:
+def _terminal_engine_core_outputs(request_id: str, timestamp: float = 1.0) -> EngineCoreOutputs:
     return EngineCoreOutputs(
         outputs=[
             EngineCoreOutput(
@@ -319,7 +320,7 @@ def _terminal_engine_core_outputs(request_id: str) -> EngineCoreOutputs:
                 finish_reason=FinishReason.STOP,
             )
         ],
-        timestamp=1.0,
+        timestamp=timestamp,
         finished_requests={request_id},
     )
 
@@ -519,6 +520,7 @@ async def _enqueue_add_request(
     original_prompt,
     sampling_params_list,
     final_stage_id: int,
+    final_output_stage_ids: list[int] | None = None,
 ) -> None:
     orchestrator_fixture.request_sync_q.put_nowait(
         StageSubmissionMessage(
@@ -529,6 +531,7 @@ async def _enqueue_add_request(
             output_prompt_text=None,
             sampling_params_list=sampling_params_list,
             final_stage_id=final_stage_id,
+            final_output_stage_ids=final_output_stage_ids,
             preprocess_ms=0.0,
             request_timestamp=time.time(),
             enqueue_ts=time.perf_counter(),
@@ -788,6 +791,10 @@ async def test_run_async_chunk(orchestrator_factory) -> None:
 
         stage1.push_engine_core_outputs(_engine_core_outputs("stage1-final", 3.0))
 
+        await _wait_for(
+            lambda: orchestrator_fixture.orchestrator.request_states["req-async"].pending_final_output is not None
+        )
+        stage0.push_engine_core_outputs(_engine_core_outputs("stage0-final", 3.1))
         output_msg = await _get_output_message(orchestrator_fixture)
 
         assert output_msg.request_id == "req-async"
@@ -1414,6 +1421,105 @@ async def test_handle_streaming_update_unknown_request_is_dropped() -> None:
     assert "req-unknown" not in orchestrator.request_states
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("native_kv", [False, True])
+async def test_add_request_attaches_native_kv_ticket_before_dispatch(mocker, native_kv) -> None:
+    sampling = SamplingParams(extra_args={"keep": "sampling"})
+    prompt = SimpleNamespace(sampling_params=SamplingParams(extra_args={"keep": "prompt"}))
+    source = StagePool(
+        0,
+        FakeStageClient(),
+        stage_vllm_config=SimpleNamespace(
+            kv_transfer_config=SimpleNamespace(kv_role="kv_producer") if native_kv else None
+        ),
+    )
+    target = StagePool(1, FakeStageClient(stage_type="diffusion", final_output=True))
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=asyncio.Queue(),
+        stage_pools=[source, target],
+    )
+
+    async def check_dispatch(request_id, req_state, request, **kwargs):
+        assert req_state.native_kv_transfer_id == ("xfer-req" if native_kv else None)
+        for params, preserved in ((sampling, "sampling"), (request.sampling_params, "prompt")):
+            assert params.extra_args["keep"] == preserved
+            if native_kv:
+                assert params.extra_args["kv_transfer_params"] == {
+                    "transfer_id": "xfer-req",
+                    "do_remote_decode": True,
+                    "do_remote_prefill": False,
+                }
+            else:
+                assert "kv_transfer_params" not in params.extra_args
+        return 0
+
+    dispatch = mocker.patch.object(source, "submit_initial", side_effect=check_dispatch)
+    await orchestrator._handle_add_request(
+        StageSubmissionMessage(
+            type="add_request",
+            request_id="req",
+            prompt=prompt,
+            original_prompt={},
+            output_prompt_text=None,
+            sampling_params_list=[sampling, OmniDiffusionSamplingParams()],
+            final_stage_id=1,
+            preprocess_ms=0,
+            request_timestamp=0,
+            enqueue_ts=0,
+        )
+    )
+    dispatch.assert_awaited_once()
+
+
+def test_native_handoff_uses_bound_replica_and_reports_missing_binding(mocker) -> None:
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.stage_pools = [mocker.Mock()]
+    orchestrator.stage_pools[0].get_bound_client.return_value = None
+    req_state = SimpleNamespace(native_kv_transfer_id="xfer-req")
+    output = SimpleNamespace(kv_transfer_params={"num_transfer_tokens": 4})
+
+    with pytest.raises(NativeKVHandoffError, match="bound AR replica"):
+        orchestrator._diffusion_submit_kwargs("req", 0, SimpleNamespace(engine_input_source=[0]), req_state, output)
+    orchestrator.stage_pools[0].get_bound_client.assert_called_once_with("req")
+    # The pool default points at replica 0; this request actually used replica 1.
+    orchestrator.stage_pools[0].stage_vllm_config = SimpleNamespace(
+        kv_transfer_config=SimpleNamespace(engine_id="ar-0")
+    )
+    config = SimpleNamespace(engine_id="ar-1", kv_connector_extra_config={"bootstrap_addr": "http://host:8999"})
+    orchestrator.stage_pools[0].get_bound_client.return_value = SimpleNamespace(
+        vllm_config=SimpleNamespace(kv_transfer_config=config)
+    )
+    params = orchestrator._diffusion_submit_kwargs(
+        "req", 0, SimpleNamespace(engine_input_source=[0]), req_state, output
+    )
+    assert params["kv_transfer_params"]["remote_engine_id"] == "ar-1"
+    assert params["kv_transfer_params"]["remote_bootstrap_addr"] == "http://host:8999"
+    assert "remote_engine_id" not in output.kv_transfer_params
+
+
+@pytest.mark.asyncio
+async def test_native_handoff_failure_is_request_scoped(mocker):
+    orchestrator = object.__new__(Orchestrator)
+    fail = mocker.patch.object(orchestrator, "_fail_request_client_error", new_callable=mocker.AsyncMock)
+
+    def lost_binding():
+        raise NativeKVHandoffError("bound AR replica is unavailable")
+
+    assert not await orchestrator._dispatch_or_fail_request(
+        lost_binding, req_id="req", stage_id=1, operation="inter-stage forward"
+    )
+    fail.assert_awaited_once_with(
+        "req",
+        1,
+        "bound AR replica is unavailable",
+        status_code=502,
+        error_type="NativeKVHandoffError",
+        release_owners=True,
+    )
+
+
 async def test_handle_streaming_update_passes_prompt_text_to_stage_pool() -> None:
     class RecordingPool:
         def __init__(self) -> None:
diff --git a/tests/engine/test_orchestrator_kv_sender_info.py b/tests/engine/test_orchestrator_kv_sender_info.py
index ca2a26b70..25e662d27 100644
--- a/tests/engine/test_orchestrator_kv_sender_info.py
+++ b/tests/engine/test_orchestrator_kv_sender_info.py
@@ -414,3 +414,67 @@ def test_prewarm_submits_bound_payload_endpoint_for_concurrent_replicas():
 
     assert all(isinstance(request, OmniEngineCoreRequest) for request in submitted.values())
     assert {key: request.payload_sender_info for key, request in submitted.items()} == endpoints
+
+
+@pytest.mark.asyncio
+async def test_async_pipeline_defers_sync_stage_until_audio_finishes(mocker):
+    from vllm import PoolingParams, RequestOutput
+    from vllm.config import VllmConfig
+
+    from vllm_omni.config.model import OmniModelConfig
+    from vllm_omni.engine import OmniEngineCoreRequest
+
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.async_chunk = True
+    orchestrator._pd_pair = None
+    orchestrator._cfg_tracker = CfgCompanionTracker()
+    orchestrator.output_async_queue = asyncio.Queue()
+    orchestrator._duplex_output_decision = lambda *args: None
+    orchestrator._is_duplex_session_request = lambda state: False
+    orchestrator._forward_to_next_stage = mocker.AsyncMock()
+    orchestrator._cleanup_request_ids = mocker.AsyncMock()
+    # A sender stage stands in for Code2Wav, whose audio is also a final output.
+    audio_pool = _build_sender_pool(0, {})
+    audio_pool.stage_client.final_output = True
+    aligner = _DummyDiffusionStage()
+    aligner_pool = StagePool(
+        1,
+        aligner,
+        stage_vllm_config=mocker.Mock(
+            spec=VllmConfig, model_config=mocker.Mock(spec=OmniModelConfig, async_chunk=False)
+        ),
+    )
+    orchestrator.stage_pools = [audio_pool, aligner_pool]
+    state = OrchestratorRequestState(
+        request_id="aligned",
+        prompt={"additional_information": {"text": ["Hello world"]}},
+        sampling_params_list=[SamplingParams(), PoolingParams(task="token_classify")],
+        final_stage_id=1,
+        final_output_stage_ids={0, 1},
+    )
+
+    await orchestrator._prewarm_async_chunk_stages(
+        "aligned", mocker.Mock(spec=OmniEngineCoreRequest, prompt_token_ids=[1, 2]), state
+    )
+    assert aligner.calls == []
+    assert 1 not in state.stage_submit_ts
+
+    output = RequestOutput("aligned", None, [1, 2], None, [], False)
+    await orchestrator._route_output(0, 0, output, state, None)
+    orchestrator._forward_to_next_stage.assert_not_awaited()
+    output.finished = True
+    await orchestrator._route_output(0, 0, output, state, None)
+    orchestrator._forward_to_next_stage.assert_awaited_once_with(
+        "aligned",
+        0,
+        output,
+        state,
+        src_replica_id=0,
+        is_streaming_session=False,
+        is_final_update=False,
+    )
+    orchestrator._cleanup_request_ids.assert_not_awaited()
+    await orchestrator._route_output(1, 0, output, state, None)
+    orchestrator._cleanup_request_ids.assert_awaited_once()
+    messages = [orchestrator.output_async_queue.get_nowait() for _ in range(3)]
+    assert [message.finished for message in messages] == [False, False, True]
diff --git a/tests/engine/test_orchestrator_monitor.py b/tests/engine/test_orchestrator_monitor.py
index 615bb0e89..7ac3f3958 100644
--- a/tests/engine/test_orchestrator_monitor.py
+++ b/tests/engine/test_orchestrator_monitor.py
@@ -65,6 +65,31 @@ def test_note_loop_and_flush_json(tmp_path, monkeypatch):
     assert payload["replicas"]["stage=0,replica=0"]["inflight"] == [10]
 
 
+@pytest.mark.parametrize("drain", [False, True])
+def test_dispatch_backlog_carries_across_windows(tmp_path, monkeypatch, drain):
+    out_path = tmp_path / "orch_monitor.json"
+    monkeypatch.setenv("VLLM_OMNI_ORCH_MONITOR_PATH", str(out_path))
+    now = [0.0]
+    monkeypatch.setattr(time, "monotonic", lambda: now[0])
+    monitor = OrchestratorMonitor(replica_sampler=lambda: {})
+    monitor.set_dispatch_queue_size(3)
+    monitor.set_dispatch_queue_size(1)
+
+    now[0] = monitor_mod._WINDOW_S
+    monitor.note_loop(idle=False)
+    if drain:
+        monitor.set_dispatch_queue_size(0)
+    now[0] += monitor_mod._WINDOW_S
+    monitor.note_loop(idle=False)
+    now[0] += monitor_mod._WINDOW_S
+    monitor.flush()
+
+    windows = json.loads(out_path.read_text())["windows"]
+    remaining = 0 if drain else 1
+    assert windows["dispatch_queue_size"] == [1, remaining, remaining]
+    assert windows["dispatch_queue_high_water"] == [3, 1, remaining]
+
+
 def test_register_replica_backfills_prior_windows(tmp_path, monkeypatch):
     out_path = tmp_path / "orch_monitor.json"
     monkeypatch.setenv("VLLM_OMNI_ORCH_MONITOR_PATH", str(out_path))
diff --git a/tests/engine/test_output_processor.py b/tests/engine/test_output_processor.py
index 8618061d8..9fbecc1c1 100644
--- a/tests/engine/test_output_processor.py
+++ b/tests/engine/test_output_processor.py
@@ -259,6 +259,17 @@ def test_native_text_tpot_only_accepts_positive_finished_metric(
     assert processor.pop_native_text_metrics("r")["vllm_tpot_ms"] == expected_tpot_ms
 
 
+def test_suppressed_native_tokens_use_authoritative_count_even_without_stats(monkeypatch):
+    monkeypatch.setattr(VLLMOutputProcessor, "_update_stats_from_output", lambda *args, **kwargs: None)
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor._native_text_metrics_by_request = {}
+    state = _make_state(RequestOutputKind.FINAL_ONLY)
+    processor._update_stats_from_output(
+        state, SimpleNamespace(new_token_ids=[2150], num_generation_tokens=2048), None, None
+    )
+    assert processor.pop_native_text_metrics("r")["num_generation_tokens"] == 2048
+
+
 def test_delta_drains_output_modality_per_step():
     """DELTA drains the mm_type key (output modality) but preserves hidden-state keys."""
     s = _make_state(RequestOutputKind.DELTA)
@@ -616,6 +627,7 @@ def test_no_detokenizer_process_outputs_returns_nonterminal_audio_chunk(monkeypa
         finish_reason=None,
         stop_reason=None,
         kv_transfer_params=None,
+        ec_transfer_params=None,
         routed_experts=None,
         num_cached_tokens=0,
     )
@@ -631,6 +643,7 @@ def _make_mm_only_output_processor(monkeypatch):
     processor = object.__new__(MultimodalOutputProcessor)
     processor.output_modality = OutputModality.AUDIO
     processor.request_states = {"r": _make_no_detok_state(RequestOutputKind.DELTA)}
+    processor.tracing_enabled = False
     monkeypatch.setattr(
         VLLMOutputProcessor,
         "process_outputs",
@@ -660,6 +673,7 @@ def _audio_engine_output(*, is_segment_finished: bool, is_last_chunk: bool):
         finish_reason=FinishReason.STOP,
         stop_reason=None,
         kv_transfer_params=None,
+        ec_transfer_params=None,
         routed_experts=None,
         num_cached_tokens=0,
         is_segment_finished=is_segment_finished,
@@ -888,3 +902,24 @@ def test_abort_snapshot_leaves_state_until_commit():
     assert "0_parent" not in processor.request_states
     assert "parent" not in processor.parent_requests
     assert "parent" not in processor.external_req_ids
+
+
+def test_cumulative_audio_terminal_output_supplies_full_aligner_waveform():
+    from vllm_omni.model_executor.stage_input_processors.forced_aligner import code2wav2aligner
+
+    state = _make_state(RequestOutputKind.CUMULATIVE)
+    for index, count in enumerate((800, 1200, 400)):
+        state.add_multimodal_tensor(torch.full((1, count), float(index)), mm_type=AUDIO)
+        output = state.make_request_output([index], None, FinishReason.STOP if index == 2 else None, None)
+        assert output is not None
+        if index < 2:
+            assert code2wav2aligner([output], {}) == []
+    prompt = {"additional_information": {"text": ["Hello world"], "language": ["English"]}}
+    aligned = code2wav2aligner([output], prompt)[0]
+    waveform, sr = aligned["multi_modal_data"]["audio"]
+    assert sr == 24000
+    assert waveform.shape == (2400,)
+    assert (waveform[:800] == 0).all()
+    assert (waveform[800:2000] == 1).all()
+    assert (waveform[2000:] == 2).all()
+    assert aligned["additional_information"]["aligner_audio_duration_ms"] == [100.0]
diff --git a/tests/engine/test_output_processor_mrv2_text.py b/tests/engine/test_output_processor_mrv2_text.py
new file mode 100644
index 000000000..b9dbecb1b
--- /dev/null
+++ b/tests/engine/test_output_processor_mrv2_text.py
@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Regression tests for MRv2 Omni AR text detach and generation payload outputs."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+from vllm.sampling_params import RequestOutputKind
+from vllm.v1.engine import FinishReason
+
+from vllm_omni.engine import OmniEngineCoreOutput
+from vllm_omni.engine.output_modality import OutputModality
+from vllm_omni.engine.output_processor import (
+    MultimodalOutputProcessor,
+    OmniRequestState,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Detokenizer:
+    def __init__(self):
+        self.output_token_ids = []
+        self.output_text = ""
+        self.update_calls = []
+
+    def update(self, token_ids, stop):
+        self.update_calls.append((list(token_ids), stop))
+        self.output_token_ids.extend(token_ids)
+        self.output_text += "X" * len(token_ids)
+        return None
+
+    def get_next_output_text(self, finished, delta):
+        return self.output_text
+
+    def num_output_tokens(self):
+        return len(self.output_token_ids)
+
+
+def _make_processor(output_modality, detokenizer=None):
+    state = OmniRequestState(
+        request_id="r",
+        external_req_id="r",
+        parent_req=None,
+        request_index=0,
+        lora_request=None,
+        output_kind=RequestOutputKind.FINAL_ONLY,
+        prompt="prompt" if detokenizer else None,
+        prompt_token_ids=[1] if detokenizer else [],
+        prompt_embeds=None,
+        logprobs_processor=MagicMock(logprobs=None, cumulative_logprob=None, prompt_logprobs=None)
+        if detokenizer
+        else None,
+        detokenizer=detokenizer,
+        max_tokens_param=None,
+        arrival_time=0.0,
+        queue=None,
+        log_stats=False,
+        stream_interval=1,
+    )
+    processor = MultimodalOutputProcessor(tokenizer=None, log_stats=False, output_modality=output_modality)
+    processor.request_states["r"] = state
+    processor.external_req_ids["r"].append("r")
+    return processor, state
+
+
+def _rehydrated_output(*, pooling_output=None, finish_reason=FinishReason.STOP):
+    """Build the post-StagePool shape without violating vLLM's wire schema."""
+    return SimpleNamespace(
+        request_id="r",
+        new_token_ids=[42],
+        pooling_output=pooling_output,
+        finish_reason=finish_reason,
+        stop_reason=None,
+        kv_transfer_params=None,
+        ec_transfer_params=None,
+        routed_experts=None,
+        trace_headers=None,
+        prefill_stats=None,
+        spec_decode_metrics=None,
+        new_sampling_mask=None,
+        num_nans_in_logits=0,
+        multimodal_output=None,
+        is_segment_finished=False,
+        is_non_final_audio_chunk=False,
+        output_type=None,
+        num_generation_tokens=None,
+        finished=True,
+    )
+
+
+def test_text_tokens_are_detokenized_when_mrv2_ar_output_has_pooling_payload():
+    detokenizer = _Detokenizer()
+    processor, state = _make_processor(OutputModality.LATENT, detokenizer)
+
+    # StagePool has already rehydrated the MRv2 carrier.  Use a structural
+    # output here because upstream EngineCoreOutput strictly validates
+    # pooling_output as torch.Tensor | None on construction.
+    output = _rehydrated_output(pooling_output={"hidden": torch.ones(1, 4)})
+
+    processed = processor.process_outputs([output])
+
+    assert detokenizer.update_calls == [([42], True)]
+    completion = processed.request_outputs[0].outputs[0]
+    assert list(completion.token_ids) == [42]
+    assert completion.text == "X"
+    assert not state.mm_accumulated.is_empty
+
+
+@pytest.mark.parametrize("streaming", [False, True])
+def test_generation_stage_mm_delivered_only_with_terminal(streaming):
+    # Non-terminal chunks accumulate; the terminal output carries the audio.
+    # When the first output is already terminal it is delivered directly.
+    processor, _ = _make_processor(OutputModality.AUDIO)
+    audio = torch.ones(1, 320)
+    sr = torch.tensor(24000, dtype=torch.int32)
+    mm_output = OmniEngineCoreOutput(
+        request_id="r",
+        new_token_ids=[],
+        multimodal_output={"model_outputs": audio, "sr": sr},
+        finish_reason=None if streaming else FinishReason.STOP,
+    )
+
+    processed = processor.process_outputs([mm_output])
+    if streaming:
+        assert processed.request_outputs == []
+        processed = processor.process_outputs(
+            [OmniEngineCoreOutput(request_id="r", new_token_ids=[], finish_reason=FinishReason.STOP)]
+        )
+
+    assert len(processed.request_outputs) == 1
+    completion = processed.request_outputs[0].outputs[0]
+    assert completion.text == ""
+    assert torch.equal(completion.multimodal_output["audio"], audio)
+    assert completion.multimodal_output["sr"].item() == 24000
diff --git a/tests/engine/test_parallel_stage_init.py b/tests/engine/test_parallel_stage_init.py
index d88d49825..9f89aabca 100644
--- a/tests/engine/test_parallel_stage_init.py
+++ b/tests/engine/test_parallel_stage_init.py
@@ -306,6 +306,23 @@ def test_check_admission_admits_diffusion_with_explicit_util():
     assert ledgers[0].kv_budget_bytes == int(cap * 0.3)
 
 
+def test_check_admission_reads_typed_diffusion_cache_config():
+    cap = 80 * 1024**3
+    diff = _local_diffusion_replica(0, 0, "0", util=None)
+    diff.stage_cfg.cache_config = types.SimpleNamespace(gpu_memory_utilization=0.35)
+    plan = LogicalStageInitPlan(stage_idx=0, stage_id=0, replicas=[diff])
+
+    ledgers = check_admission(
+        [plan],
+        resolve_physical_devices=lambda _r: [0],
+        device_total_memory=lambda _d: cap,
+        external_reserve_bytes=0,
+        safety_margin_bytes=0,
+    )
+
+    assert ledgers[0].kv_budget_bytes == int(cap * 0.35)
+
+
 def test_check_admission_unresolved_local_raises():
     """A local replica invisible to the ledger must fail admission, not skip it:
     it would otherwise initialize concurrently with unbounded demand."""
diff --git a/tests/engine/test_request_snapshot.py b/tests/engine/test_request_snapshot.py
new file mode 100644
index 000000000..51d61ae3e
--- /dev/null
+++ b/tests/engine/test_request_snapshot.py
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+import copy
+
+import pytest
+
+from vllm_omni.engine.request_snapshot import copy_request_snapshot
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_full_snapshot_preserves_fields_aliases_and_isolation():
+    samples = [0.25, 0.5]
+    source = {"prompt_token_ids": [1, 2], "additional_information": {"samples": samples}, "alias": samples}
+    result = copy_request_snapshot(source)
+    assert result == copy.deepcopy(source)
+    assert result["alias"] is result["additional_information"]["samples"]
+    result["alias"].append(0.75)
+    result["prompt_token_ids"][0] = 9
+    assert samples == [0.25, 0.5]
+    assert source["prompt_token_ids"] == [1, 2]
diff --git a/tests/engine/test_single_stage_mode.py b/tests/engine/test_single_stage_mode.py
index a22ee99e3..0d5e47960 100644
--- a/tests/engine/test_single_stage_mode.py
+++ b/tests/engine/test_single_stage_mode.py
@@ -16,7 +16,13 @@ from pytest_mock import MockerFixture
 from vllm.v1.engine.utils import EngineZmqAddresses
 
 from vllm_omni.config.config_factory import StageConfigFactory
-from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig, PipelineConfig, StagePipelineConfig
+from vllm_omni.config.omni_config import VllmOmniARStageConfig, VllmOmniDiffusionStageConfig
+from vllm_omni.config.stage_config import (
+    DuplexSessionRuntimeConfig,
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
 from vllm_omni.engine.stage_engine_core_client import StageEngineCoreClientBase
 from vllm_omni.engine.stage_engine_startup import (
@@ -57,6 +63,10 @@ def _make_llm_plan(
     vllm_config: Any | None = None,
 ) -> LogicalStageInitPlan:
     stage_cfg = _make_stage_cfg(stage_id)
+    if launch_mode == "remote":
+        stage_cfg = VllmOmniARStageConfig(
+            stage_pipeline_config=StagePipelineConfig(stage_id=stage_id, model_stage="thinker"),
+        )
     metadata = SimpleNamespace(
         stage_id=stage_id,
         stage_type="llm",
@@ -98,6 +108,16 @@ def _make_diffusion_plan(
     launch_mode: str,
 ) -> LogicalStageInitPlan:
     stage_cfg = _make_stage_cfg(stage_id, stage_type="diffusion")
+    if launch_mode == "remote":
+        stage_cfg = VllmOmniDiffusionStageConfig(
+            stage_pipeline_config=StagePipelineConfig(
+                stage_id=stage_id,
+                model_stage="diffusion",
+                execution_type=StageExecutionType.DIFFUSION,
+                final_output=True,
+                final_output_type="image",
+            ),
+        )
     metadata = SimpleNamespace(
         stage_id=stage_id,
         stage_type="diffusion",
@@ -983,6 +1003,7 @@ class TestSingleStageReplicaInitialization:
         assert mock_connect.call_args.kwargs["stage_id"] == 1
         assert mock_connect.call_args.kwargs["replica_id"] == 0
         assert client_kwargs["log_stats"] is True
+        assert client_kwargs["metadata"].model_stage == "thinker"
         assert events == ["enter", "exit", "attach"]
 
     def test_initialize_llm_replica_remote_missing_registered_stage_config_raises(self, mocker: MockerFixture):
@@ -1148,11 +1169,9 @@ class TestSingleStageReplicaInitialization:
 
             return _ctx()
 
-        remote_metadata = _make_diffusion_plan(1, stage_id=1, launch_mode="remote").replicas[0].metadata
         plan = _make_diffusion_plan(1, stage_id=1, launch_mode="remote").replicas[0]
         sentinel_client = SimpleNamespace()
 
-        mocker.patch.object(runtime_mod, "extract_legacy_stage_metadata", return_value=remote_metadata)
         mock_connect = mocker.patch.object(runtime_mod, "connect_remote_diffusion_proc", side_effect=_fake_connect)
         mock_from_addresses = mocker.patch(
             "vllm_omni.diffusion.stage_diffusion_client.StageDiffusionClient.from_addresses",
@@ -1169,6 +1188,7 @@ class TestSingleStageReplicaInitialization:
             replica_id=0,
         )
         mock_from_addresses.assert_called_once()
+        assert mock_from_addresses.call_args.args[0].final_output_type == "image"
 
     def test_initialize_local_diffusion_replica_registers_with_master(self, mocker: MockerFixture):
         import vllm_omni.engine.stage_runtime as runtime_mod
@@ -1401,7 +1421,7 @@ class TestConnectRemoteEngineCoresCoordinator:
             yield mocker.Mock()
 
         mocker.patch("vllm_omni.engine.stage_engine_startup.zmq_socket_ctx", return_value=fake_socket_ctx())
-        mock_wait = mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup")
+        mock_wait = mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup", autospec=True)
         with connect_remote_engine_cores(
             vllm_config=vllm_config,
             omni_master_server=omni_master_server,
@@ -1436,7 +1456,7 @@ class TestConnectRemoteEngineCoresCoordinator:
             yield mocker.Mock()
 
         mocker.patch("vllm_omni.engine.stage_engine_startup.zmq_socket_ctx", return_value=fake_socket_ctx())
-        mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup")
+        mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup", autospec=True)
         with connect_remote_engine_cores(
             vllm_config=vllm_config,
             omni_master_server=omni_master_server,
@@ -1462,7 +1482,7 @@ class TestConnectRemoteEngineCoresCoordinator:
             yield mocker.Mock()
 
         mocker.patch("vllm_omni.engine.stage_engine_startup.zmq_socket_ctx", return_value=fake_socket_ctx())
-        mock_wait = mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup")
+        mock_wait = mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup", autospec=True)
 
         with connect_remote_diffusion_proc(
             omni_master_server=omni_master_server,
@@ -1474,7 +1494,8 @@ class TestConnectRemoteEngineCoresCoordinator:
         omni_master_server.get_zmq_addresses.assert_called_once_with(7, replica_id=2)
         omni_master_server.get_allocation.assert_called_once_with(7, replica_id=2)
         mock_wait.assert_called_once()
-        _, core_engines, parallel_config, *_ = mock_wait.call_args.args
+        _, core_engines, parallel_config, _, _, launch = mock_wait.call_args.args
+        assert launch.addresses is omni_master_server.get_zmq_addresses.return_value
         assert core_engines[0].local is False
         assert parallel_config.data_parallel_size_local == 0
 
@@ -1515,7 +1536,7 @@ class TestLaunchOmniCoreEngines:
             "vllm_omni.engine.stage_engine_startup.CoreEngineProcManager",
             return_value=local_engine_manager,
         )
-        mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup")
+        mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup", autospec=True)
         with _launch_omni_core_engines(
             vllm_config=vllm_config,
             executor_class=mocker.Mock(),
@@ -1592,7 +1613,7 @@ class TestLaunchOmniCoreEngines:
             "vllm_omni.engine.stage_engine_startup.CoreEngineProcManager",
             return_value=mocker.Mock(),
         )
-        mock_wait = mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup")
+        mock_wait = mocker.patch("vllm_omni.engine.stage_engine_startup.wait_for_engine_startup", autospec=True)
         with _launch_omni_core_engines(
             vllm_config=vllm_config,
             executor_class=mocker.Mock(),
diff --git a/tests/engine/test_stage_device_layout.py b/tests/engine/test_stage_device_layout.py
index 0473dc341..6dd30373d 100644
--- a/tests/engine/test_stage_device_layout.py
+++ b/tests/engine/test_stage_device_layout.py
@@ -18,6 +18,7 @@ import types
 from unittest import mock
 
 import pytest
+from pytest_mock import MockerFixture
 
 from vllm_omni.engine import stage_init_utils
 from vllm_omni.engine.stage_init_utils import (
@@ -156,6 +157,43 @@ def test_replica_guard_and_splitter_share_local_world_size(devices, expected):
     assert replica_devices_map == {0: expected}
 
 
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+@pytest.mark.parametrize("local_dp", [None, 0, 1, 2])
+@pytest.mark.parametrize("pool_devices", [False, True], ids=["template", "pool"])
+def test_replica_layout_preserves_local_dp_semantics(typed, local_dp, pool_devices):
+    from vllm_omni.config.omni_config import VllmOmniConfig
+    from vllm_omni.config.stage_config import PipelineConfig, StagePipelineConfig
+    from vllm_omni.engine.stage_engine_startup import get_headless_replica_devices
+
+    engine_args = {
+        "tensor_parallel_size": 2,
+        "data_parallel_size": 4,
+        "data_parallel_size_local": local_dp,
+        "pipeline_parallel_size": 2,
+    }
+    width = 2 * max(1, local_dp if local_dp is not None else 4) * 2
+    devices = ",".join(str(i) for i in range(width * (2 if pool_devices else 1)))
+    if typed:
+        pipeline = PipelineConfig(
+            model_type="test",
+            model_arch="TestModel",
+            stages=(StagePipelineConfig(stage_id=0, model_stage="ar", final_output=True),),
+        )
+        stage = VllmOmniConfig.from_pipeline_config(
+            pipeline,
+            cli_overrides={
+                f"stage_0_{key}": value for key, value in {**engine_args, "devices": devices, "num_replicas": 2}.items()
+            },
+        ).stage_configs[0]
+    else:
+        stage = _stage(0, devices=devices, num_replicas=2, engine_args=engine_args)
+    expected = [",".join(str(i) for i in range(r * width, (r + 1) * width)) for r in range(2)]
+
+    assert get_stage_devices_per_replica(stage) == width
+    assert compute_replica_layout([stage]) == ([2], {0: expected})
+    assert get_headless_replica_devices(stage, stage_id=0, omni_dp_size_local=2) == expected
+
+
 def test_non_tp_layout_error_uses_generic_guidance():
     """A PP mismatch must not be reported as a top-level TP broadcast."""
     stage = _stage(0, devices="0")
@@ -203,7 +241,7 @@ def test_build_vllm_config_fails_before_engine_config_on_mismatch():
     get_class.assert_not_called()
 
 
-def test_build_vllm_config_proceeds_on_consistent_layout():
+def test_build_vllm_config_proceeds_on_consistent_layout(mocker: MockerFixture) -> None:
     """The guard must not false-positive: a consistent single-GPU stage flows past
     it and reaches ``create_engine_config`` / ``Executor.get_class`` as usual."""
     stage = _stage(1, devices="1")
@@ -212,18 +250,30 @@ def test_build_vllm_config_proceeds_on_consistent_layout():
         model_config=types.SimpleNamespace(hf_config=types.SimpleNamespace()),
     )
     sentinel_executor = object()
-    with (
-        mock.patch.object(
-            stage_init_utils.OmniEngineArgs, "create_engine_config", return_value=fake_config
-        ) as create_engine_config,
-        mock.patch.object(stage_init_utils.Executor, "get_class", return_value=sentinel_executor),
-        mock.patch.object(stage_init_utils.OmniINCConfig, "maybe_upgrade", side_effect=lambda quant: quant),
-    ):
-        vllm_config, executor_class = build_vllm_config(
-            stage,
-            model="dummy-model",
-            engine_args_dict={"tensor_parallel_size": 1},
-        )
+    captured_api_process_config: dict[str, int] = {}
+
+    def capture_create_engine_config(engine_args, *args, **kwargs):
+        captured_api_process_config["count"] = engine_args._api_process_count
+        captured_api_process_config["rank"] = engine_args._api_process_rank
+        return fake_config
+
+    create_engine_config = mocker.patch.object(
+        stage_init_utils.OmniEngineArgs,
+        "create_engine_config",
+        autospec=True,
+        side_effect=capture_create_engine_config,
+    )
+    mocker.patch.object(stage_init_utils.Executor, "get_class", return_value=sentinel_executor)
+    mocker.patch.object(stage_init_utils.OmniINCConfig, "maybe_upgrade", side_effect=lambda quant: quant)
+
+    vllm_config, executor_class = build_vllm_config(
+        stage,
+        model="dummy-model",
+        engine_args_dict={"tensor_parallel_size": 1},
+        api_process_count=3,
+        api_process_rank=2,
+    )
     create_engine_config.assert_called_once()
     assert vllm_config is fake_config
     assert executor_class is sentinel_executor
+    assert captured_api_process_config == {"count": 3, "rank": 2}
diff --git a/tests/engine/test_stage_engine_args.py b/tests/engine/test_stage_engine_args.py
index 7ac5b6b69..c27292be4 100644
--- a/tests/engine/test_stage_engine_args.py
+++ b/tests/engine/test_stage_engine_args.py
@@ -8,6 +8,7 @@ import sys
 import types
 from dataclasses import fields, replace
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
 from pydantic.fields import FieldInfo
@@ -29,6 +30,7 @@ from vllm_omni.config.omni_config import (
     OmniStageSchedulerConfig,
     VllmOmniARStageConfig,
     VllmOmniConfig,
+    extract_diffusion_stage_config_kwargs,
 )
 from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, resolve_pipeline_config
 from vllm_omni.config.stage_config import (
@@ -60,9 +62,14 @@ _DEPLOY_DIR = Path(__file__).parents[2] / "vllm_omni" / "deploy"
 def _effective_backend_values(config_cls: type, engine_args: dict) -> dict[str, object]:
     backend_fields = fields(config_cls)
     backend_field_names = {backend_field.name for backend_field in backend_fields}
-    backend_config = config_cls(
-        **{name: copy.deepcopy(value) for name, value in engine_args.items() if name in backend_field_names}
-    )
+    # This is a schema/normalization comparison, not a Hub download test.
+    with (
+        patch("vllm.engine.arg_utils.get_model_path", side_effect=lambda model, *_: model),
+        patch("vllm_omni.diffusion.data.get_model_path", side_effect=lambda model, *_: model),
+    ):
+        backend_config = config_cls(
+            **{name: copy.deepcopy(value) for name, value in engine_args.items() if name in backend_field_names}
+        )
     effective_values: dict[str, object] = {}
     for backend_field in backend_fields:
         value = getattr(backend_config, backend_field.name)
@@ -77,6 +84,9 @@ _DIFFUSION_BACKEND_FIELDS = frozenset(field.name for field in fields(OmniDiffusi
 _TOPOLOGY_ONLY_ENGINE_ARGS = frozenset({"inline_diffusion"})
 _OMNI_ONLY_LLM_STAGE_ENGINE_FIELDS = frozenset(
     {
+        "final_output",
+        "use_v2_model_runner",
+        "supports_native_mrv2_data_plane",
         "active_stream_window",
         "codec_frame_rate_hz",
         "custom_voice_dir",
@@ -95,6 +105,7 @@ _OMNI_ONLY_LLM_STAGE_ENGINE_FIELDS = frozenset(
         "num_weight_load_threads",
         "omni_kv_config",
         "parallel_config",
+        "pooling_output_decoder",
         "silence_ban_frames",
         "subtalker_sampling_params",
         "task_type",
@@ -366,6 +377,21 @@ def test_typed_llm_projection_does_not_emit_inherited_upstream_defaults():
     assert inherited_defaults.isdisjoint(engine_args)
 
 
+def test_typed_llm_projection_omits_diffusion_only_and_process_only_defaults():
+    stage_config = VllmOmniARStageConfig(
+        stage_pipeline_config=StagePipelineConfig(stage_id=0, model_stage="test"),
+    )
+
+    engine_args = stage_init_utils._project_omni_stage_engine_args(stage_config)
+
+    assert {
+        "enable_multithread_weight_load",
+        "num_weight_load_threads",
+        "disable_autocast",
+        "log_level",
+    }.isdisjoint(engine_args)
+
+
 def test_mammoth_fp8_kv_deploy_projects_only_ar_stage(monkeypatch):
     monkeypatch.setattr(stage_init_utils, "resolve_worker_cls", lambda _engine_args: None)
 
@@ -551,7 +577,9 @@ def test_engine_args_consume_stage_diffusion_attention_shorthand(tmp_path):
         assert engine_args.get("diffusion_attention_backend") is None
         assert isinstance(engine_args["diffusion_attention_config"], AttentionConfig)
         assert engine_args["diffusion_attention_config"].default.backend == "TORCH_SDPA"
-        od_config = OmniDiffusionConfig.from_kwargs(**engine_args)
+        od_config = OmniDiffusionConfig.from_kwargs(
+            **extract_diffusion_stage_config_kwargs(engine_args, stage_id=2, include_engine_adapter_metadata=True)
+        )
         assert od_config.diffusion_attention_config.default.backend == "TORCH_SDPA"
 
 
@@ -584,7 +612,9 @@ def test_engine_args_apply_cli_attention_shorthand_over_yaml_config(tmp_path, ya
         attention_config = engine_args["diffusion_attention_config"]
         assert attention_config.default.backend == "TORCH_SDPA"
         assert attention_config.per_role["cross"].backend == "SAGE_ATTN"
-        od_config = OmniDiffusionConfig.from_kwargs(**engine_args)
+        od_config = OmniDiffusionConfig.from_kwargs(
+            **extract_diffusion_stage_config_kwargs(engine_args, stage_id=2, include_engine_adapter_metadata=True)
+        )
         assert od_config.diffusion_attention_config.default.backend == "TORCH_SDPA"
 
 
diff --git a/tests/engine/test_terminal_stage_metrics_order.py b/tests/engine/test_terminal_stage_metrics_order.py
new file mode 100644
index 000000000..a64fe8cc3
--- /dev/null
+++ b/tests/engine/test_terminal_stage_metrics_order.py
@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Terminal audio must not retire a request before upstream terminal metrics."""
+
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from vllm_omni.engine.orchestrator import Orchestrator, OrchestratorRequestState
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def build():
+    o = Orchestrator.__new__(Orchestrator)
+    o.stage_pools = [
+        SimpleNamespace(
+            final_output=False, build_stage_metrics=lambda *a, **k: SimpleNamespace(stage_id=0, num_tokens_out=42)
+        ),
+        SimpleNamespace(
+            final_output=True, build_stage_metrics=lambda *a, **k: SimpleNamespace(stage_id=1, num_tokens_out=0)
+        ),
+    ]
+    state = OrchestratorRequestState(
+        request_id="r",
+        final_stage_id=1,
+        final_output_stage_ids={1},
+        stage_submit_ts={0: 0, 1: 0},
+        sampling_params_list=[None, None],
+    )
+    o.request_states = {"r": state}
+    o.output_async_queue = asyncio.Queue()
+    o.async_chunk = True
+    o._pd_pair = None
+    o._cfg_tracker = MagicMock()
+    o._cfg_tracker.is_companion.return_value = False
+    o._cfg_tracker.cleanup_parent.return_value = []
+    o._is_duplex_session_request = lambda s: False
+    o._duplex_output_decision = lambda *a: None
+    o._stage_receives_async_chunks = lambda s: True
+    cleaned = []
+
+    async def cleanup(ids):
+        cleaned.extend(ids)
+        for r in ids:
+            o.request_states.pop(r, None)
+
+    o._cleanup_request_ids = cleanup
+    return o, state, cleaned
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("order", [(0, 1), (1, 0)])
+async def test_terminal_metrics_precede_final_audio_for_either_arrival_order(order):
+    o, state, cleaned = build()
+    for stage in order:
+        await o._handle_processed_outputs(stage, 0, [SimpleNamespace(request_id="r", finished=True, error=None)])
+        if stage == 1 and not state.finished_stage_ids.issuperset({0, 1}):
+            assert o.output_async_queue.empty()
+            assert "r" in o.request_states
+            assert cleaned == []
+    metrics = o.output_async_queue.get_nowait()
+    final = o.output_async_queue.get_nowait()
+    assert type(metrics).__name__ == "StageMetricsMessage"
+    assert metrics.stage_id == 0 and metrics.metrics.num_tokens_out == 42
+    assert type(final).__name__ == "OutputMessage" and final.finished
+    assert o.output_async_queue.empty()
+    assert cleaned == ["r"]
+    assert state.pending_final_output is None
+
+
+@pytest.mark.asyncio
+async def test_cancelled_pending_output_is_not_published_by_late_upstream():
+    o, state, cleaned = build()
+    await o._handle_processed_outputs(1, 0, [SimpleNamespace(request_id="r", finished=True, error=None)])
+    assert state.pending_final_output is not None
+    await o._cleanup_request_ids(["r"])
+    await o._handle_processed_outputs(0, 0, [SimpleNamespace(request_id="r", finished=True, error=None)])
+    assert o.output_async_queue.empty()
+    assert cleaned == ["r"]
diff --git a/tests/entrypoints/openai_api/test_api_server_guards.py b/tests/entrypoints/openai_api/test_api_server_guards.py
index 37e2dc430..43d88d692 100644
--- a/tests/entrypoints/openai_api/test_api_server_guards.py
+++ b/tests/entrypoints/openai_api/test_api_server_guards.py
@@ -42,8 +42,12 @@ from __future__ import annotations
 
 import asyncio
 import json
+import signal
+from argparse import Namespace
 from contextlib import asynccontextmanager
+from dataclasses import dataclass
 from types import SimpleNamespace
+from typing import Any
 
 import pytest
 from fastapi import FastAPI, HTTPException
@@ -59,11 +63,78 @@ from vllm_omni.entrypoints.serve.utils import errors as serve_errors
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
+
+@dataclass
+class _FakeParallelConfig:
+    _api_process_rank: int
+
+
+@dataclass
+class _FakeVllmConfig:
+    parallel_config: _FakeParallelConfig
+
+
+def test_omni_api_worker_sets_parent_death_signal_before_validation(mocker):
+    args = _minimal_args(_omni_stage_client_configs=[{"stage_addresses": {}}])
+    death_signal = mocker.patch.object(api_server, "set_death_signal")
+
+    with pytest.raises(RuntimeError, match="client configuration"):
+        api_server.run_omni_api_server_worker_proc(
+            "127.0.0.1:8000",
+            mocker.Mock(),
+            args,
+            {"client_count": 2, "client_index": -1},
+        )
+
+    death_signal.assert_called_once_with(signal.SIGTERM)
+
+
+@pytest.mark.asyncio
+async def test_omni_run_server_worker_forwards_client_config(monkeypatch):
+    captured: dict[str, object] = {}
+
+    @asynccontextmanager
+    async def fake_build_async_omni(*_args, **kwargs):
+        captured.update(kwargs)
+        yield _FakeEngineClient(vllm_config=_FakeVllmConfig(_FakeParallelConfig(_api_process_rank=1)))
+
+    monkeypatch.setattr(api_server, "build_async_omni", fake_build_async_omni)
+    monkeypatch.setattr(api_server, "build_openai_app", lambda *_args: FastAPI())
+    monkeypatch.setattr(api_server, "omni_init_app_state", lambda *_args: asyncio.sleep(0))
+    monkeypatch.setattr(api_server, "shutdown_unsupported_routes", lambda *_args: None)
+
+    async def fake_storage_start() -> None:
+        return None
+
+    monkeypatch.setattr(api_server.STORAGE_MANAGER, "start", fake_storage_start)
+
+    async def fake_serve_http(app, **_kwargs):
+        assert app.state.api_server_count == 2
+        task = asyncio.create_task(asyncio.sleep(0))
+        await asyncio.sleep(0)
+        return task
+
+    monkeypatch.setattr(api_server, "serve_http", fake_serve_http)
+
+    args = _minimal_args(model="dummy")
+    config = {"client_count": 2, "client_index": 1, "stage_addresses": {}}
+
+    await api_server.omni_run_server_worker("127.0.0.1:8000", _FakeSocket(), args, config)
+    assert captured["client_config"] is config
+
+
 # FastAPI/Starlette auto-adds HEAD on every GET route. Including HEAD here
 # would invent ("HEAD", path) entries for every GET and fail the current census.
 # TODO: extend this set and the expected census if @router.head / @router.options appear.
 _HTTP_METHODS = {"GET", "POST", "DELETE", "PUT", "PATCH"}
 
+
+def test_profiler_endpoints_detect_typed_stage_config():
+    stage = SimpleNamespace(profiler_config=SimpleNamespace(profiler="torch"))
+
+    assert api_server._should_enable_profiler_endpoints([stage])
+
+
 # Exact Omni router census on main. Update intentionally when routes change.
 _EXPECTED_ROUTER_ROUTES = {
     ("POST", "/v1/chat/completions"),
@@ -494,7 +565,7 @@ async def test_timestamp_middleware_stamps_http_and_passes_websocket(monkeypatch
     Fails if HTTP requests lose ``request_timestamp``, or WebSocket scopes
     start getting stamped / mutated incorrectly.
     """
-    captured: dict[str, object] = {}
+    captured: dict[str, Any] = {}
 
     def fake_build_openai_app(args, supported_tasks):
         return FastAPI()
@@ -522,8 +593,8 @@ async def test_timestamp_middleware_stamps_http_and_passes_websocket(monkeypatch
     await api_server.omni_run_server_worker("127.0.0.1:8000", _FakeSocket(), _minimal_args())
     middleware = captured["served_app"]
 
-    http_scope = {"type": "http", "state": {}}
-    ws_scope = {"type": "websocket"}
+    http_scope: dict[str, Any] = {"type": "http", "state": {}}
+    ws_scope: dict[str, Any] = {"type": "websocket"}
 
     async def _receive():
         return {"type": "http.disconnect"}
@@ -619,6 +690,48 @@ async def test_realtime_route_defaults_to_configured_duplex_handler(
     assert calls == [expected_handler]
 
 
+@pytest.mark.parametrize("path", ["/v1/duplex", "/v1/realtime", "/v1/realtime?duplex=1"])
+def test_multi_api_duplex_reconnect_rejected_on_each_worker(path: str) -> None:
+    class SessionHandler:
+        async def handle_realtime_session(self, _websocket) -> None:
+            pytest.fail("Multi-API requests must not access process-local sessions")
+
+    class PendingWarmup:
+        def is_set(self) -> bool:
+            raise AssertionError("Multi-API rejection must not wait for duplex warmup")
+
+    # Separate apps represent workers with independent frontend registries.
+    # Opening on A then reconnecting to B must reject at the same boundary.
+    for worker_index in (0, 1):
+        app = FastAPI()
+        app.state.api_server_count = 2
+        app.state.api_server_index = worker_index
+        app.state.openai_serving_duplex = SessionHandler()
+        app.state.duplex_warmup_done = PendingWarmup()
+        app.include_router(api_server.router)
+        with TestClient(app) as client, client.websocket_connect(path) as websocket:
+            assert websocket.receive_json()["code"] == "multi_api_duplex_unsupported"
+            with pytest.raises(WebSocketDisconnect) as exc:
+                websocket.receive_text()
+            assert exc.value.code == 1008
+
+
+@pytest.mark.parametrize("path", ["/v1/duplex", "/v1/realtime?duplex=1"])
+def test_single_api_duplex_session_still_reaches_handler(path: str) -> None:
+    class SessionHandler:
+        async def handle_realtime_session(self, websocket) -> None:
+            await websocket.accept()
+            await websocket.send_json({"type": "session.created"})
+            await websocket.close()
+
+    app = FastAPI()
+    app.state.api_server_count = 1
+    app.state.openai_serving_duplex = SessionHandler()
+    app.include_router(api_server.router)
+    with TestClient(app) as client, client.websocket_connect(path) as websocket:
+        assert websocket.receive_json() == {"type": "session.created"}
+
+
 def test_health_without_engine_returns_stable_unhealthy_response() -> None:
     """Lock ``/health`` with no engine initialized.
 
@@ -708,6 +821,38 @@ def test_speech_without_handler_preserves_not_found_http_error() -> None:
     assert exc_info.value.detail == "The model does not support Speech API"
 
 
+@pytest.mark.asyncio
+async def test_multi_api_rejects_runtime_voice_upload() -> None:
+    app = FastAPI()
+    app.state.api_server_count = 2
+    raw_request = _request_for(app, method="POST", path="/v1/audio/voices")
+
+    with pytest.raises(HTTPException) as exc_info:
+        await api_server.upload_voice(
+            raw_request,
+            audio_sample=None,
+            speaker_embedding=None,
+            consent="consent-id",
+            name="probe",
+        )
+
+    assert exc_info.value.status_code == 409
+    assert "process-local frontend state" in exc_info.value.detail
+
+
+@pytest.mark.asyncio
+async def test_multi_api_rejects_sleep_route() -> None:
+    app = FastAPI()
+    app.state.api_server_count = 2
+    raw_request = _request_for(app, method="POST", path="/v1/omni/sleep")
+
+    with pytest.raises(HTTPException) as exc_info:
+        await api_server.omni_sleep(api_server.OmniSleepRequest(stage_ids=[0]), raw_request)
+
+    assert exc_info.value.status_code == 409
+    assert "process-local frontend state" in exc_info.value.detail
+
+
 def test_engine_error_json_response_includes_request_and_stage_fields(monkeypatch) -> None:
     """Lock shared ``EngineGenerateError`` JSON fields used by Omni handlers.
 
@@ -776,11 +921,10 @@ async def test_pure_diffusion_app_state_key_snapshot(monkeypatch) -> None:
     engine = _FakeEngineClient(stage_configs=[stage])
 
     def _for_diffusion_factory(label: str):
-        @classmethod
         def _factory(cls, *args, **kwargs):
             return _marker(label)
 
-        return _factory
+        return classmethod(_factory)
 
     monkeypatch.setattr(api_server.OmniOpenAIServingChat, "for_diffusion", _for_diffusion_factory("chat"))
     monkeypatch.setattr(api_server.OmniOpenAIServingChatBatch, "for_diffusion", _for_diffusion_factory("chat_batch"))
@@ -821,13 +965,11 @@ async def test_pure_diffusion_speech_forwards_media_access_args(monkeypatch) ->
     speech_kwargs = {}
 
     def _for_diffusion_factory(label: str):
-        @classmethod
         def _factory(cls, *args, **kwargs):
             return _marker(label)
 
-        return _factory
+        return classmethod(_factory)
 
-    @classmethod
     def _speech_factory(cls, *args, **kwargs):
         speech_kwargs.update(kwargs)
         return _marker("speech")
@@ -841,7 +983,7 @@ async def test_pure_diffusion_speech_forwards_media_access_args(monkeypatch) ->
     )
     monkeypatch.setattr(api_server.OmniOpenAIServingVideo, "for_diffusion", _for_diffusion_factory("video"))
     monkeypatch.setattr(api_server.OmniStreamingVideoOutputHandler, "__init__", lambda self, *a, **k: None)
-    monkeypatch.setattr(api_server.OmniOpenAIServingSpeech, "for_diffusion", _speech_factory)
+    monkeypatch.setattr(api_server.OmniOpenAIServingSpeech, "for_diffusion", classmethod(_speech_factory))
     monkeypatch.setattr(
         api_server.ServingRealtimeRobotOpenPI,
         "create_policy_server",
@@ -930,3 +1072,57 @@ async def test_multistage_app_state_key_snapshot(monkeypatch) -> None:
         must_be_wired=_MULTISTAGE_MUST_BE_WIRED,
         must_be_none=_MULTISTAGE_MUST_BE_NONE,
     )
+
+
+@pytest.mark.parametrize("count", [None, 0, -1, "2", True])
+def test_process_local_guard_rejects_unknown_topology(count):
+    app = FastAPI()
+    if count is not None:
+        app.state.api_server_count = count
+    # CLI args cannot substitute for missing/invalid actual runtime state.
+    app.state.args = Namespace(api_server_count=1)
+    with pytest.raises(HTTPException) as exc:
+        api_server._reject_process_local_state_with_multiple_api_workers(_request_for(app), "Sleep")
+    assert exc.value.status_code == 503
+
+
+@pytest.mark.parametrize(
+    "requested,config,expected",
+    [(None, None, 1), (1, None, 1), (2, {"client_count": 2}, 2), (None, {"client_count": 2}, 2)],
+)
+def test_api_topology_resolved_from_launch(requested, config, expected):
+    assert api_server._resolve_api_server_count(Namespace(api_server_count=requested), config) == expected
+
+
+@pytest.mark.parametrize("requested,config", [(2, None), (2, {}), (2, {"client_count": 1}), (2, {"client_count": "2"})])
+def test_api_topology_rejects_inconsistent_launch(requested, config):
+    with pytest.raises(ValueError):
+        api_server._resolve_api_server_count(Namespace(api_server_count=requested), config)
+
+
+@pytest.mark.parametrize("count,status", [(2, 409), (None, 503)])
+@pytest.mark.parametrize(
+    "method,path",
+    [
+        ("POST", "/v1/videos"),
+        ("GET", "/v1/videos"),
+        ("GET", "/v1/videos/job"),
+        ("GET", "/v1/videos/job/content"),
+        ("DELETE", "/v1/videos/job"),
+    ],
+)
+def test_video_lifecycle_guard_precedes_processing(monkeypatch, count, status, method, path):
+    from fastapi.testclient import TestClient
+
+    app = FastAPI()
+    if count is not None:
+        app.state.api_server_count = count
+    app.include_router(api_server.router)
+
+    async def forbidden_form():
+        pytest.fail("video form processing must not run before topology rejection")
+
+    app.dependency_overrides[api_server._parse_video_form] = forbidden_form
+    with TestClient(app) as client:
+        response = client.request(method, path)
+    assert response.status_code == status
diff --git a/tests/entrypoints/openai_api/test_audex_serving_guards.py b/tests/entrypoints/openai_api/test_audex_serving_guards.py
index 87524825e..141dd8cac 100644
--- a/tests/entrypoints/openai_api/test_audex_serving_guards.py
+++ b/tests/entrypoints/openai_api/test_audex_serving_guards.py
@@ -15,6 +15,7 @@ from types import SimpleNamespace
 import pytest
 import torch
 
+from vllm_omni.config.stage_config import StagePipelineConfig
 from vllm_omni.entrypoints.openai.serving_speech import (
     _AUDEX_NO_AUDIO_GUARD_MODEL_TYPES,
     OmniOpenAIServingSpeech,
@@ -251,9 +252,28 @@ class TestAudexStageDetection:
         stage = serving._find_tts_stage()
         assert stage is not None and stage.engine_args.model_stage == "audex_thinker"
 
+    def test_typed_pipeline_detected_without_legacy_engine_args(self):
+        serving = OmniOpenAIServingSpeech.__new__(OmniOpenAIServingSpeech)
+        stages = [
+            SimpleNamespace(
+                stage_pipeline_config=StagePipelineConfig(stage_id=index, model_stage=model_stage),
+                model_config=SimpleNamespace(model_arch=None),
+                worker_type="generation",
+            )
+            for index, model_stage in enumerate(("audex_thinker", "audex_code2wav"))
+        ]
+        serving.engine_client = SimpleNamespace(stage_configs=stages)
+
+        stage = serving._find_tts_stage()
+        serving._tts_stage = stage
+
+        assert stage is stages[0]
+        assert serving._detect_tts_model_type() == "audex"
+
 
 def test_guided_injection_sets_guided_temperature():
     """Guided requests decode at the measured CFG temperature (0.05)."""
+
     serving = TestAudexCfgInjection()._serving_with_fake_tokenizer()
     cond = TestAudexCfgInjection()._cond_prompt()
     params = SimpleNamespace(extra_args={"cfg_scale": 1.5}, temperature=0.1)
@@ -265,6 +285,31 @@ def test_guided_injection_sets_guided_temperature():
     assert out.temperature == 0.1
 
 
+def test_typed_full_pipeline_uses_full_checkpoint_tokenizer(mocker):
+    from vllm_omni.entrypoints.openai.tts_adapters.base import SpeechServingContext
+
+    serving = OmniOpenAIServingSpeech.__new__(OmniOpenAIServingSpeech)
+    serving._tts_stage = SimpleNamespace(
+        stage_pipeline_config=StagePipelineConfig(stage_id=0, model_stage="audex_omni"),
+        model_config=SimpleNamespace(model_arch=None),
+        worker_type="ar",
+    )
+    serving.engine_client = SimpleNamespace(
+        model_config=SimpleNamespace(model="/models/audex"),
+    )
+    ensure_snapshot = mocker.patch(
+        "vllm_omni.model_executor.models.audex.checkpoint.ensure_audex_snapshot",
+        return_value="/snapshots/audex",
+    )
+    from_pretrained = mocker.patch("transformers.AutoTokenizer.from_pretrained", return_value=object())
+
+    adapter = AudexAdapter(SpeechServingContext(server=serving, engine_client=serving.engine_client))
+    adapter._get_tokenizer()
+
+    ensure_snapshot.assert_called_once_with("/models/audex", profile="full")
+    from_pretrained.assert_called_once_with("/snapshots/audex/checkpoint_folder_full")
+
+
 # ---------------------------------------------------------------- TTA serving surface
 
 from vllm_omni.entrypoints.openai.tts_adapters import resolve_adapter  # noqa: E402
diff --git a/tests/entrypoints/openai_api/test_duplex_api_server.py b/tests/entrypoints/openai_api/test_duplex_api_server.py
index b528cbc2a..0d9eebe5b 100644
--- a/tests/entrypoints/openai_api/test_duplex_api_server.py
+++ b/tests/entrypoints/openai_api/test_duplex_api_server.py
@@ -1,28 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Guards for the duplex-only API server (unified full-duplex framework).
-
-A model whose pipeline declares ``duplex_plugin`` is served through
-``DuplexOmni`` and nothing else: sessions run over ``/v1/realtime?duplex=1``
-(alias ``/v1/duplex``) and every turn-based route reports "not available".
-These tests lock that shape, which ``test_api_server_guards.py`` covers for the
-diffusion and multi-stage servers:
-
-* the pipeline probe that decides duplex vs turn-based at startup,
-* the ``app.state`` snapshot of a duplex server (what is wired, what stays
-  ``None``),
-* both duplex websocket routes reaching the session handler, and
-  ``/v1/realtime`` without the flag still reporting the turn-based Realtime API
-  as unavailable,
-* the startup-warmup gate that holds real clients while the warmup session runs.
-
-CPU-only: no engine is started; ``DuplexOmni`` is subclassed with just the
-accessors the app-state wiring reads.
-"""
+"""CPU tests for serving-mode selection, duplex API wiring and warmup."""
 
 from __future__ import annotations
 
 import asyncio
+from argparse import Namespace
+from dataclasses import replace
 from types import SimpleNamespace
 
 import pytest
@@ -31,12 +15,14 @@ from fastapi.testclient import TestClient
 from starlette.datastructures import State
 from starlette.websockets import WebSocketDisconnect
 
+from vllm_omni.config import stage_config
 from vllm_omni.config.config_factory import StageConfigFactory
-from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig, PipelineConfig, StagePipelineConfig
 from vllm_omni.engine.duplex.config import DuplexCapabilities
 from vllm_omni.entrypoints.duplex.serving import OmniDuplexSessionHandler
 from vllm_omni.entrypoints.duplex_omni import DuplexOmni
 from vllm_omni.entrypoints.openai import api_server
+from vllm_omni.utils.tracking_parser import TrackingNamespace
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -202,9 +188,10 @@ def _minimal_args(**overrides) -> SimpleNamespace:
         (None, False),
     ],
 )
-def test_duplex_model_probe_follows_the_pipeline_plugin(monkeypatch, pipeline_config, expected: bool) -> None:
-    """``duplex_plugin`` alone decides whether ``serve`` builds ``DuplexOmni``."""
+def test_duplex_serving_requires_a_pipeline_plugin(monkeypatch, tmp_path, pipeline_config, expected: bool) -> None:
     seen: dict[str, object] = {}
+    deploy_path = tmp_path / "deploy.yaml"
+    deploy_path.write_text("session_mode: duplex\n")
 
     def fake_get_pipeline_config(*, model, trust_remote_code, deploy_config_path=None, **_kwargs):
         seen.update(model=model, trust_remote_code=trust_remote_code, deploy_config_path=deploy_config_path)
@@ -212,12 +199,12 @@ def test_duplex_model_probe_follows_the_pipeline_plugin(monkeypatch, pipeline_co
 
     monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", fake_get_pipeline_config)
 
-    kwargs = {"trust_remote_code": True, "deploy_config": "deploy.yaml"}
-    assert api_server._is_duplex_model("demo-duplex-model", kwargs) is expected
+    kwargs = {"trust_remote_code": True, "deploy_config": str(deploy_path)}
+    assert api_server._should_serve_duplex("demo-duplex-model", kwargs) is expected
     assert seen == {
         "model": "demo-duplex-model",
         "trust_remote_code": True,
-        "deploy_config_path": "deploy.yaml",
+        "deploy_config_path": str(deploy_path),
     }
 
 
@@ -230,7 +217,98 @@ def test_duplex_model_probe_propagates_resolution_errors(monkeypatch) -> None:
     monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", fake_get_pipeline_config)
 
     with pytest.raises(ValueError, match="trust_remote_code"):
-        api_server._is_duplex_model("demo-duplex-model", {})
+        api_server._should_serve_duplex("demo-duplex-model", {})
+
+
+@pytest.fixture
+def duplex_pipeline():
+    return PipelineConfig(
+        model_type="demo",
+        stages=(StagePipelineConfig(stage_id=0, model_stage="demo", final_output=True),),
+        duplex_plugin="pkg.mod.Plugin",
+    )
+
+
+@pytest.mark.parametrize("session_mode", ["turn", "duplex"])
+@pytest.mark.parametrize("config_source", ["explicit", "default", "basename", "inherited"])
+@pytest.mark.asyncio
+async def test_serving_mode_selects_engine_and_preserves_stage_config(
+    monkeypatch, tmp_path, duplex_pipeline, session_mode, config_source
+):
+    base_path = tmp_path / "base.yaml"
+    base_path.write_text("session_mode: duplex\nstages:\n  - stage_id: 0\n    max_num_seqs: 4\n")
+    deploy_path = tmp_path / "deploy.yaml"
+    deploy_path.write_text(f"base_config: base.yaml\nsession_mode: {session_mode}\n")
+    if config_source == "inherited":
+        deploy_path = tmp_path / "overlay.yaml"
+        deploy_path.write_text("base_config: deploy.yaml\n")
+    pipeline = replace(duplex_pipeline, default_deploy_config_name=deploy_path.name)
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", lambda **_: pipeline)
+    monkeypatch.setattr(stage_config, "_DEPLOY_DIR", tmp_path)
+    kwargs = {}
+    if config_source != "default":
+        kwargs["deploy_config"] = deploy_path.name if config_source == "basename" else str(deploy_path)
+
+    created = []
+
+    class TurnEngine:
+        def __init__(self, model, **engine_kwargs):
+            self.model = model
+            self.kwargs = engine_kwargs
+            self.closed = False
+            created.append(self)
+
+        def shutdown(self):
+            self.closed = True
+
+    class DuplexEngine(TurnEngine):
+        pass
+
+    monkeypatch.setattr(api_server, "AsyncOmni", TurnEngine)
+    monkeypatch.setattr(api_server, "DuplexOmni", DuplexEngine)
+    args = TrackingNamespace(
+        Namespace(model="demo-model", disable_log_stats=True, **kwargs), frozenset({"model", *kwargs})
+    )
+    async with api_server.build_async_omni_from_stage_config(args) as engine:
+        assert type(engine) is (DuplexEngine if session_mode == "duplex" else TurnEngine)
+        assert engine.model == "demo-model"
+        assert engine.kwargs == {**kwargs, "log_stats": False}
+        assert not engine.closed
+    assert len(created) == 1
+    assert engine.closed
+    deploy = stage_config.load_deploy_config(deploy_path)
+    assert deploy.session_mode == session_mode
+    assert deploy.stages[0].max_num_seqs == 4
+
+
+@pytest.mark.parametrize("contents", ["{}\n", "session_mode: null\n", "session_mode: typo\n"])
+def test_duplex_serving_rejects_missing_or_invalid_mode(monkeypatch, tmp_path, duplex_pipeline, contents):
+    deploy_path = tmp_path / "deploy.yaml"
+    deploy_path.write_text(contents)
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", lambda **_: duplex_pipeline)
+    with pytest.raises(ValueError, match="session_mode: turn or duplex"):
+        api_server._should_serve_duplex("demo-model", {"deploy_config": str(deploy_path)})
+
+
+def test_duplex_serving_requires_a_deploy_config(monkeypatch, duplex_pipeline):
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", lambda **_: duplex_pipeline)
+    with pytest.raises(ValueError, match="requires a deploy config"):
+        api_server._should_serve_duplex("demo-model", {})
+
+
+def test_duplex_serving_propagates_deploy_load_errors(monkeypatch, tmp_path, duplex_pipeline):
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", lambda **_: duplex_pipeline)
+    with pytest.raises(FileNotFoundError):
+        api_server._should_serve_duplex("demo-model", {"deploy_config": str(tmp_path / "missing.yaml")})
+
+
+@pytest.mark.parametrize("deploy_name,expected", [("minicpmo_4_5.yaml", True), ("minicpmo_4_5_turn.yaml", False)])
+def test_minicpmo_serving_profiles(monkeypatch, deploy_name, expected):
+    from vllm_omni.model_executor.models.minicpmo_4_5.pipeline import MINICPMO_4_5_PIPELINE
+
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", lambda **_: MINICPMO_4_5_PIPELINE)
+    assert api_server._should_serve_duplex("openbmb/MiniCPM-o-4_5", {"deploy_config": deploy_name}) is expected
+    assert api_server._should_serve_duplex("openbmb/MiniCPM-o-4_5", {}) is True
 
 
 # --------------------------------------------------------------------------- #
@@ -412,3 +490,31 @@ async def test_a_model_that_does_not_declare_chat_completions_does_not_get_the_r
 
     assert state.openai_serving_chat is None
     assert isinstance(state.openai_serving_duplex, OmniDuplexSessionHandler)
+
+
+def test_qwen_plugin_preserves_custom_turn_deployment_default(monkeypatch, tmp_path):
+    from vllm_omni.model_executor.models.qwen3_omni.pipeline import QWEN3_OMNI_PIPELINE
+
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", lambda **kwargs: QWEN3_OMNI_PIPELINE)
+    deploy = tmp_path / "qwen.yaml"
+    deploy.write_text("stages: []\n")
+    assert not api_server._should_serve_duplex("qwen", {"deploy_config": str(deploy)})
+    deploy.write_text("session_mode: duplex\nstages: []\n")
+    assert api_server._should_serve_duplex("qwen", {"deploy_config": str(deploy)})
+
+
+@pytest.mark.parametrize("flag", ["1", "true", "on"])
+def test_turn_deployment_rejects_explicit_duplex_without_falling_back_to_stt(flag: str) -> None:
+    app = _duplex_app(None)
+    # Even an available STT service must not silently accept a duplex request.
+    app.state.openai_serving_realtime = object()
+    with TestClient(app) as client:
+        with client.websocket_connect(f"/v1/realtime?duplex={flag}") as websocket:
+            assert websocket.receive_json() == {
+                "type": "error",
+                "code": "unsupported",
+                "error": "VAD realtime is not enabled",
+            }
+            with pytest.raises(WebSocketDisconnect) as exc:
+                websocket.receive_text()
+            assert exc.value.code == 1008
diff --git a/tests/entrypoints/openai_api/test_image_server.py b/tests/entrypoints/openai_api/test_image_server.py
index 60850248e..1c124a19b 100644
--- a/tests/entrypoints/openai_api/test_image_server.py
+++ b/tests/entrypoints/openai_api/test_image_server.py
@@ -1719,7 +1719,7 @@ def test_image_edit_parameter_pass(async_omni_test_client):
         img = Image.open(io.BytesIO(img_bytes))
         assert img.format.lower() == "jpeg"
         assert data["output_format"] == "jpeg"
-        assert data["size"] == "16x24"
+        assert data["size"] == "64x64"
 
 
 def test_image_edit_layers_and_resolution(async_omni_test_client):
@@ -1896,6 +1896,7 @@ def test_image_edit_parameter_default_single_stage(test_client):
 
     assert captured_sampling_params.width == 24
     assert captured_sampling_params.height == 16
+    assert (captured_sampling_params.height_not_provided, captured_sampling_params.width_not_provided) == (True, True)
     assert captured_sampling_params.num_outputs_per_prompt == 1
     assert captured_sampling_params.num_inference_steps == 4
     assert captured_sampling_params.guidance_scale == 7.5
@@ -1913,6 +1914,40 @@ def test_image_edit_parameter_default_single_stage(test_client):
     assert response.status_code == 400
 
 
+def test_image_edit_explicit_size_marks_canvas_provided_single_stage(test_client):
+    response = test_client.post(
+        "/v1/images/edits",
+        files=[("image", make_test_image_bytes((24, 16)))],
+        data={"prompt": "hello world.", "size": "16x24"},
+    )
+
+    assert response.status_code == 200
+    sampling = test_client.app.state.engine_client.captured_sampling_params_list[0]
+    assert (sampling.height, sampling.width) == (24, 16)
+    assert (sampling.height_not_provided, sampling.width_not_provided) == (False, False)
+
+
+def test_image_edit_response_size_reports_generated_image_single_stage(test_client):
+    response = test_client.post(
+        "/v1/images/edits",
+        files=[("image", make_test_image_bytes((24, 16)))],
+        data={"prompt": "hello world.", "size": "16x24"},
+    )
+
+    assert response.status_code == 200
+    assert response.json()["size"] == "64x64"
+
+
+def test_generate_images_response_size_reports_generated_image(test_client):
+    response = test_client.post(
+        "/v1/images/generations",
+        json={"prompt": "a cat", "n": 1, "size": "1024x1024"},
+    )
+
+    assert response.status_code == 200
+    assert response.json()["size"] == "64x64"
+
+
 def test_image_edit_compression_jpeg(test_client):
     img_bytes_1 = make_test_image_bytes((16, 16))
     # uploadfile with image key
diff --git a/tests/entrypoints/openai_api/test_moss_tts_realtime_serving.py b/tests/entrypoints/openai_api/test_moss_tts_realtime_serving.py
new file mode 100644
index 000000000..d69597634
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_moss_tts_realtime_serving.py
@@ -0,0 +1,302 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import asyncio
+import threading
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+import torch
+
+from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+from vllm_omni.entrypoints.openai.tts_adapters import moss_tts as adapter_module
+from vllm_omni.entrypoints.openai.tts_adapters.base import SpeechServingContext
+from vllm_omni.entrypoints.openai.tts_adapters.moss_tts import MossTTSAdapter
+from vllm_omni.model_executor.models.moss_tts import reference_encoder
+from vllm_omni.utils.speaker_cache import SpeakerEmbeddingCache
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    ("hf_config", "expected_codec_path"),
+    [
+        (SimpleNamespace(), "OpenMOSS-Team/MOSS-Audio-Tokenizer"),
+        (
+            SimpleNamespace(codec_model_name_or_path="/models/custom-moss-codec"),
+            "/models/custom-moss-codec",
+        ),
+    ],
+    ids=["default-codec", "configured-codec"],
+)
+def test_realtime_components_use_the_realtime_model_and_codec(
+    monkeypatch: pytest.MonkeyPatch,
+    hf_config: SimpleNamespace,
+    expected_codec_path: str,
+) -> None:
+    engine_client = SimpleNamespace(
+        model_config=SimpleNamespace(
+            model="OpenMOSS-Team/MOSS-TTS-Realtime",
+            hf_config=hf_config,
+        )
+    )
+
+    server = MossTTSAdapter(SpeechServingContext(server=object(), engine_client=engine_client))
+
+    tokenizer = object()
+    codec = type("Codec", (), {"to": lambda self, device: self, "eval": lambda self: self})()
+    processor_calls = []
+
+    class Processor:
+        def __init__(self, *, tokenizer):
+            processor_calls.append(tokenizer)
+
+    class_calls = []
+    tokenizer_calls = []
+    codec_calls = []
+
+    def fake_get_class(class_reference, model_id):
+        class_calls.append((class_reference, model_id))
+        return Processor
+
+    def fake_load_tokenizer(model_id, *, trust_remote_code):
+        tokenizer_calls.append((model_id, trust_remote_code))
+        return tokenizer
+
+    def fake_load_codec(model_id, *, trust_remote_code):
+        codec_calls.append((model_id, trust_remote_code))
+        return codec
+
+    monkeypatch.setattr(adapter_module, "get_class_from_dynamic_module", fake_get_class)
+    monkeypatch.setattr(adapter_module.AutoTokenizer, "from_pretrained", fake_load_tokenizer)
+    monkeypatch.setattr(adapter_module.AutoModel, "from_pretrained", fake_load_codec)
+
+    components = server._get_moss_realtime_components()
+
+    assert components[0] is tokenizer
+    assert components[2] is codec
+    assert server._get_moss_realtime_components() is components
+    assert class_calls == [
+        (
+            "processing_mossttsrealtime.MossTTSRealtimeProcessor",
+            "OpenMOSS-Team/MOSS-TTS-Realtime",
+        )
+    ]
+    assert tokenizer_calls == [("OpenMOSS-Team/MOSS-TTS-Realtime", True)]
+    assert codec_calls == [(expected_codec_path, True)]
+    assert processor_calls == [tokenizer]
+
+
+def test_realtime_serving_builds_the_talker_prompt(monkeypatch: pytest.MonkeyPatch) -> None:
+    server = MossTTSAdapter(SpeechServingContext(server=SimpleNamespace(uploaded_speakers={})))
+    server._moss_variant = "realtime"
+    tokenizer = object()
+    processor = object()
+    codec = object()
+    request_thread = threading.get_ident()
+
+    def load_components():
+        assert threading.get_ident() != request_thread
+        return tokenizer, processor, codec
+
+    server._get_moss_realtime_components = load_components
+
+    reference_codes = torch.arange(64, dtype=torch.int64).reshape(4, 16)
+    encode = AsyncMock(return_value=([reference_codes], {0: "reference-cache-key"}))
+    monkeypatch.setattr(server, "_encode_moss_references", encode)
+
+    build_call = None
+
+    def fake_build(actual_tokenizer, actual_processor, text, actual_codes):
+        nonlocal build_call
+        build_call = (actual_tokenizer, actual_processor, text, actual_codes)
+        return {
+            "prompt_token_ids": [10, 11],
+            "codes": {"ref": actual_codes},
+            "ids": {"all": [12]},
+        }
+
+    monkeypatch.setattr(adapter_module, "build_realtime_prompt", fake_build)
+
+    params = asyncio.run(
+        server._build_moss_tts_params(
+            OpenAICreateSpeechRequest(
+                input="speak this text",
+                ref_audio="data:audio/wav;base64,AAAA",
+                max_new_tokens=50,
+            )
+        )
+    )
+
+    encode.assert_awaited_once()
+    assert encode.call_args.kwargs == {"has_inline_ref_audio": False, "two_speaker": False}
+    assert encode.call_args.args[0].ref_audio == "data:audio/wav;base64,AAAA"
+    assert build_call == (tokenizer, processor, "speak this text", reference_codes)
+    assert params == {
+        "prompt_token_ids": [10, 11],
+        "codes": {"ref": reference_codes},
+        "ids": {"all": [12]},
+        "max_new_frames": [50],
+        "ref_audio_cache_key": "reference-cache-key",
+    }
+    assert "prompt_audio_array" not in params
+
+
+def test_cancelled_component_waiter_does_not_duplicate_codec_load(monkeypatch):
+    adapter = MossTTSAdapter(
+        SpeechServingContext(
+            server=object(),
+            engine_client=SimpleNamespace(
+                model_config=SimpleNamespace(model="OpenMOSS-Team/MOSS-TTS-Realtime", hf_config=SimpleNamespace())
+            ),
+        )
+    )
+    started = threading.Event()
+    release = threading.Event()
+    second_started = threading.Event()
+    loads = []
+    codec = type("Codec", (), {"to": lambda self, device: self, "eval": lambda self: self})()
+
+    def load_codec(*args, **kwargs):
+        loads.append(args)
+        started.set()
+        assert release.wait(5), "codec loader was not released"
+        return codec
+
+    monkeypatch.setattr(adapter_module, "get_class_from_dynamic_module", lambda *args: lambda **kwargs: object())
+    monkeypatch.setattr(adapter_module.AutoTokenizer, "from_pretrained", lambda *args, **kwargs: object())
+    monkeypatch.setattr(adapter_module.AutoModel, "from_pretrained", load_codec)
+
+    def second_load():
+        second_started.set()
+        return adapter._get_moss_realtime_components()
+
+    async def run():
+        first = asyncio.create_task(asyncio.to_thread(adapter._get_moss_realtime_components))
+        try:
+            assert await asyncio.to_thread(started.wait, 5)
+            first.cancel()
+            with pytest.raises(asyncio.CancelledError):
+                await first
+            second = asyncio.create_task(asyncio.to_thread(second_load))
+            try:
+                assert await asyncio.to_thread(second_started.wait, 5)
+            finally:
+                release.set()
+            components = await asyncio.wait_for(second, 5)
+            assert components[2] is codec
+            assert adapter._get_moss_realtime_components() is components
+            assert len(loads) == 1
+        finally:
+            release.set()
+
+    asyncio.run(run())
+
+
+@pytest.mark.parametrize("voice_name", [None, "speaker"])
+def test_realtime_reference_cache_reuses_codes(voice_name):
+    cache = SpeakerEmbeddingCache()
+    resolve = AsyncMock(return_value=([0.0], 24000, "audio-key"))
+    request_thread = threading.get_ident()
+    encode_calls = []
+    expected = torch.arange(64).reshape(4, 16)
+
+    def batch_encode(wavs, *, num_quantizers):
+        assert threading.get_ident() != request_thread
+        assert num_quantizers == 16
+        encode_calls.append(wavs)
+        return SimpleNamespace(audio_codes=expected.T.unsqueeze(1), audio_codes_lengths=torch.tensor([4]))
+
+    encoder = reference_encoder.build_reference_encoder(
+        SimpleNamespace(batch_encode=batch_encode), variant="realtime", speaker_cache=cache
+    )
+
+    async def run():
+        kwargs = dict(
+            resolve_ref_audio=resolve,
+            get_artifact_key=lambda key: "content-key",
+            voice_name=voice_name,
+            voice_created_at=1,
+        )
+        try:
+            first, first_key = await encoder.encode("reference", **kwargs)
+            second, second_key = await encoder.encode("reference", **kwargs)
+            assert torch.equal(first, expected)
+            assert torch.equal(second, expected)
+            assert first.dtype == torch.int64
+            assert first_key == "audio-key"
+            assert second_key == (None if voice_name else "audio-key")
+            second.zero_()
+            third, _ = await encoder.encode("another-reference", **kwargs)
+            assert torch.equal(third, expected)
+            assert len(encode_calls) == 1
+            assert resolve.await_count == (1 if voice_name else 3)
+            key = cache.make_cache_key(
+                voice_name or "ref:content-key", "moss_tts_realtime_nq16", 1 if voice_name else 0
+            )
+            assert cache.get(key)["codes"].dtype == torch.int32
+            if voice_name:
+                kwargs["voice_created_at"] = 2
+                await encoder.encode("reference", **kwargs)
+                assert len(encode_calls) == 2
+                assert resolve.await_count == 2
+        finally:
+            await encoder.aclose()
+
+    asyncio.run(run())
+
+
+def test_realtime_reference_batch_trims_each_item():
+    cache = SpeakerEmbeddingCache()
+    codes = torch.arange(16 * 2 * 5).reshape(16, 2, 5)
+    calls = []
+
+    def batch_encode(wavs, *, num_quantizers):
+        calls.append(wavs)
+        assert num_quantizers == 16
+        assert [wav.shape for wav in wavs] == [torch.Size([8]), torch.Size([12])]
+        return SimpleNamespace(audio_codes=codes, audio_codes_lengths=torch.tensor([3, 5]))
+
+    encoder = reference_encoder.build_reference_encoder(
+        SimpleNamespace(batch_encode=batch_encode), variant="realtime", speaker_cache=cache
+    )
+
+    async def resolve(ref):
+        return [0.0] * (8 if ref == "short" else 12), 24000, ref
+
+    async def run():
+        try:
+            short, long = await asyncio.gather(
+                encoder.encode("short", resolve_ref_audio=resolve, get_artifact_key=lambda key: key),
+                encoder.encode("long", resolve_ref_audio=resolve, get_artifact_key=lambda key: key),
+            )
+            torch.testing.assert_close(short[0], codes[:, 0, :3].T)
+            torch.testing.assert_close(long[0], codes[:, 1, :5].T)
+            assert len(calls) == 1
+        finally:
+            await encoder.aclose()
+
+    asyncio.run(run())
+
+
+def test_failed_realtime_reference_encoding_does_not_populate_cache():
+    cache = SpeakerEmbeddingCache()
+    resolve = AsyncMock(return_value=([0.0], 24000, "audio-key"))
+
+    def fail(*args, **kwargs):
+        raise ValueError("invalid reference")
+
+    encoder = reference_encoder.build_reference_encoder(
+        SimpleNamespace(batch_encode=fail), variant="realtime", speaker_cache=cache
+    )
+
+    async def run():
+        try:
+            with pytest.raises(ValueError, match="invalid reference"):
+                await encoder.encode("reference", resolve_ref_audio=resolve, get_artifact_key=lambda key: None)
+            assert cache.memory_bytes() == 0
+        finally:
+            await encoder.aclose()
+
+    asyncio.run(run())
diff --git a/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py b/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py
index 615248fcf..ba5925d8f 100644
--- a/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py
+++ b/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py
@@ -20,6 +20,7 @@ def _make_app(engine_client):
     from vllm_omni.entrypoints.openai.api_server import router
 
     app = FastAPI()
+    app.state.api_server_count = 1
     app.include_router(router)
     app.state.engine_client = engine_client
     app.state.sleeping_stages = set()
@@ -253,6 +254,7 @@ def pure_diffusion_app(pure_diffusion_engine, mocker):
     )
 
     app = FastAPI()
+    app.state.api_server_count = 1
     app.include_router(router)
 
     mocker.patch(
diff --git a/tests/entrypoints/openai_api/test_openpi_serving.py b/tests/entrypoints/openai_api/test_openpi_serving.py
index 46ff0f822..fa0148599 100644
--- a/tests/entrypoints/openai_api/test_openpi_serving.py
+++ b/tests/entrypoints/openai_api/test_openpi_serving.py
@@ -138,6 +138,36 @@ def test_policy_server_config_reads_stage_config_model_config():
     assert serving.policy_server_config.to_dict() == policy_config
 
 
+@pytest.mark.parametrize("inline", [False, True], ids=["out_of_process", "inline"])
+def test_policy_server_config_reads_typed_runtime(inline):
+    from tests.helpers.stage_config import get_deploy_config_path
+    from vllm_omni.config.omni_config import VllmOmniConfig
+    from vllm_omni.diffusion.models.pi0_pipeline_config import PI0_PIPELINE
+    from vllm_omni.entrypoints.async_omni import AsyncOmni
+
+    typed_stage = VllmOmniConfig.from_pipeline_config(
+        PI0_PIPELINE, deploy_config_path=get_deploy_config_path("pi0.yaml")
+    ).stage_configs[0]
+    policy_config = typed_stage.diffusion_config.model_config["policy_server_config"]
+    stage_client = SimpleNamespace(stage_type="diffusion")
+    if inline:
+        # Worker-enriched inline metadata remains authoritative over the
+        # startup stage config; only the process client needs the fallback.
+        policy_config = {**policy_config, "worker_metadata": "loaded"}
+        stage_client.od_config = SimpleNamespace(model_config={"policy_server_config": policy_config})
+    engine_client = AsyncOmni.__new__(AsyncOmni)
+    engine_client.engine = SimpleNamespace(
+        stage_clients=[stage_client],
+        stage_configs=[typed_stage],
+        stage_vllm_configs=[None],
+        get_diffusion_od_config=lambda: SimpleNamespace(model_class_name="Pi0Pipeline"),
+    )
+
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=engine_client)
+
+    assert serving.policy_server_config.to_dict() == policy_config
+
+
 def test_policy_server_config_reads_omegaconf_stage_config():
     engine_client = SimpleNamespace(
         get_diffusion_od_config=lambda: None,
@@ -240,12 +270,14 @@ def test_build_request_uses_unique_engine_request_id_per_inference():
 
 def test_build_request_clones_stage_defaults_before_protocol_fields():
     default_params = OmniDiffusionSamplingParams(
+        num_inference_steps=12,
+        output_type="latent",
         extra_args={
             "format_prompt_as_json": True,
             "session_id": "configured-session-must-not-win",
             "reset": False,
             "nested": {"values": []},
-        }
+        },
     )
     od_config = SimpleNamespace(model_config={"policy_server_config": {}})
     engine_client = SimpleNamespace(
@@ -267,10 +299,18 @@ def test_build_request_clones_stage_defaults_before_protocol_fields():
         session_id="wire-session",
         reset=False,
     )
+    request_c = serving._build_request(
+        {"prompt": "pick up the object", "sampling_params": {"num_inference_steps": 4}},
+        session_id="wire-session",
+        reset=False,
+    )
 
     assert request_a.sampling_params.extra_args["format_prompt_as_json"] is True
     assert request_a.sampling_params.extra_args["session_id"] == "wire-session"
     assert request_a.sampling_params.extra_args["reset"] is True
+    assert request_a.sampling_params.num_inference_steps == 12
+    assert request_a.sampling_params.output_type == "latent"
+    assert request_c.sampling_params.num_inference_steps == 4
     request_a.sampling_params.extra_args["nested"]["values"].append("request-a")
     assert request_b.sampling_params.extra_args["nested"] == {"values": []}
     assert default_params.extra_args["nested"] == {"values": []}
@@ -288,6 +328,46 @@ def test_build_request_forwards_seed_to_sampling_params():
     assert isinstance(unseeded.sampling_params.seed, int)
 
 
+# Per-request inference parameters live in their own namespace so robot feature
+# names stay open-ended. Unknown keys inside it are ignored rather than rejected.
+def test_build_request_forwards_num_inference_steps():
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=_engine_with_policy_config())
+
+    request = serving._build_request(
+        {"prompt": "pick up the object", "sampling_params": {"num_inference_steps": 4}},
+        session_id="session-a",
+        reset=True,
+    )
+
+    assert request.sampling_params.num_inference_steps == 4
+    # The namespace is an engine concern; the pipeline must not see it as a feature.
+    assert "sampling_params" not in request.sampling_params.extra_args["robot_obs"]
+
+
+def test_build_request_omits_num_inference_steps_when_not_sent():
+    """Absent must stay absent: the pipeline reads None as "use the configured
+    default", so materialising a null here would be a different request."""
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=_engine_with_policy_config())
+
+    request = serving._build_request({"prompt": "x"}, session_id="s", reset=True)
+
+    assert request.sampling_params.num_inference_steps is None
+
+
+def test_build_request_does_not_forward_arbitrary_observation_keys():
+    """A robot observation may carry any feature name; none of them become
+    engine parameters."""
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=_engine_with_policy_config())
+
+    request = serving._build_request(
+        {"prompt": "x", "state": np.zeros(32), "guidance_scale": 7.5}, session_id="s", reset=True
+    )
+
+    extra_args = request.sampling_params.extra_args
+    assert set(extra_args) == {"reset", "session_id", "robot_obs"}
+    assert extra_args["robot_obs"]["guidance_scale"] == 7.5
+
+
 def test_infer_keeps_session_state_but_uses_unique_engine_request_ids():
     engine = RecordingEngine()
     serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=engine)
diff --git a/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py b/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py
index d0476b56c..7aaa975b5 100644
--- a/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py
+++ b/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py
@@ -18,20 +18,26 @@ import io
 import json
 import os
 import wave
+from contextlib import asynccontextmanager, suppress
+from pathlib import Path
+from typing import Any, NamedTuple
 
+import numpy as np
 import pytest
 import websockets
+import yaml
 
-from tests.e2e.online_serving.helpers.minicpmo_4_5_duplex import validated_input_wav
+from tests.e2e.online_serving.helpers.minicpmo_4_5_duplex import validated_input_wav, validated_soft_interrupt_wav
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import (
     convert_audio_bytes_to_text,
     cosine_similarity_text,
     generate_synthetic_audio,
 )
-from tests.helpers.runtime import OmniServerParams
+from tests.helpers.runtime import OmniServer, OmniServerParams, get_model_prefix
 from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
 from vllm_omni.config.stage_config import load_deploy_config
+from vllm_omni.engine.duplex.contracts import duplex_resource_request_belongs_to_session
 from vllm_omni.engine.duplex.vad import (
     SILERO_VAD_FILENAME,
     SILERO_VAD_REPO_ID,
@@ -361,6 +367,15 @@ def _assert_realtime_accuracy(
 
 
 class TestQwen3OmniRealtimeWebSocket:
+    @pytest.fixture(scope="class")
+    def omni_server(self, request, run_level):
+        # Release the legacy turn deployment before the duplex class below
+        # starts another model server on the same pair of GPUs.
+        from tests.helpers.fixtures.runtime import omni_fixture_lock
+        from tests.helpers.runtime import iter_omni_server
+
+        yield from iter_omni_server(request, run_level, omni_fixture_lock)
+
     @pytest.mark.advanced_model
     @pytest.mark.omni
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
@@ -518,3 +533,394 @@ class TestQwen3OmniRealtimeWebSocket:
 
         _assert_realtime_smoke(result)
         _assert_realtime_accuracy(result)
+
+
+# These regressions use the engine-owned Qwen duplex plugin. The older class
+# above intentionally exercises the separate turn/STT deployment.
+_DUPLEX_REPEATS = int(os.environ.get("VLLM_OMNI_TEST_QWEN_DUPLEX_REPEATS", "20"))
+_DUPLEX_LONG_INSTRUCTIONS = "Answer the user's question in English using at least eight complete sentences."
+_DUPLEX_SHORT_INSTRUCTIONS = "Answer the user's question in one short English sentence."
+
+
+class _DuplexTestRuntime(NamedTuple):
+    server: OmniServer
+    processor: Any
+    artifacts: Path
+
+
+@pytest.fixture(scope="class")
+def qwen_duplex_server(tmp_path_factory, cached_silero_vad_artifact, run_level):
+    """Load real weights once for all interruption repetitions and history checks."""
+    from transformers import AutoProcessor
+
+    assert run_level in {"advanced_model", "full_model"}, "Duplex playback acceptance requires real weights"
+    artifacts = tmp_path_factory.mktemp("qwen_duplex_playback")
+    deploy = artifacts / "deploy.yaml"
+    # An absolute base keeps the production YAML's relative inheritance intact
+    # when the test's Silero override lives in a temporary directory.
+    deploy.write_text(
+        yaml.safe_dump(
+            {
+                "base_config": get_deploy_config_path("qwen3_omni_duplex.yaml"),
+                "duplex_session": {"server_vad_model_path": cached_silero_vad_artifact},
+            }
+        )
+    )
+    assert load_deploy_config(deploy).session_mode == "duplex"
+    model = get_model_prefix() + MODEL
+    processor = AutoProcessor.from_pretrained(model, trust_remote_code=True)
+    with OmniServer(
+        model,
+        ["--deploy-config", str(deploy), "--init-timeout", "900", "--stage-init-timeout", "600"],
+        env_dict={"VLLM_OMNI_QWEN_VISUAL_DEBUG_DIR": str(artifacts)},
+    ) as server:
+        yield _DuplexTestRuntime(server=server, processor=processor, artifacts=artifacts)
+
+
+def _duplex_fixture_pcm(path: Path, *, duration_s: float | None = None) -> bytes:
+    """Replay checked-in speech at the web client's negotiated 24 kHz PCM16 rate."""
+    pcm = np.frombuffer(_pcm16_mono_16k_from_wav_bytes(path.read_bytes()), dtype="<i2")
+    if duration_s is not None:
+        pcm = pcm[: int(duration_s * 16000)]
+    positions = np.arange(len(pcm) * 3 // 2) * (2.0 / 3.0)
+    return np.interp(positions, np.arange(len(pcm)), pcm).astype("<i2").tobytes()
+
+
+def _duplex_response_id(event: dict) -> str | None:
+    return event.get("response_id") or event.get("response", {}).get("id")
+
+
+def _duplex_response_events(events: list[dict], response_id: str, event_type: str) -> list[dict]:
+    return [event for event in events if event["type"] == event_type and _duplex_response_id(event) == response_id]
+
+
+async def _duplex_receive_until(ws, events: list[dict], predicate, *, timeout_s: float = 180) -> None:
+    # One deadline covers the whole operation, including an endless stream that
+    # would otherwise reset a per-recv timeout forever.
+    async def receive() -> None:
+        while not predicate():
+            raw = await ws.recv()
+            assert isinstance(raw, str), "Expected JSON Realtime events"
+            event = json.loads(raw)
+            events.append(event)
+            assert event.get("type") != "error", event
+
+    await asyncio.wait_for(receive(), timeout=timeout_s)
+
+
+async def _duplex_send_pcm(ws, pcm: bytes, *, paced: bool = False, trailing_silence: bool = True) -> None:
+    if trailing_silence:
+        pcm += bytes(24000 * 2)  # One second exceeds the configured 500 ms endpoint.
+    chunk_bytes = 24000 * 2 // 5
+    for offset in range(0, len(pcm), chunk_bytes):
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "input_audio_buffer.append",
+                    "audio": base64.b64encode(pcm[offset : offset + chunk_bytes]).decode(),
+                }
+            )
+        )
+        if paced:
+            await asyncio.sleep(0.2)
+
+
+async def _duplex_add_image(ws) -> None:
+    from PIL import Image
+
+    image = io.BytesIO()
+    Image.new("RGB", (448, 336), (32, 96, 160)).save(image, format="JPEG")
+    await ws.send(
+        json.dumps(
+            {
+                "type": "conversation.item.create",
+                "item": {
+                    "id": "camera_1",
+                    "type": "message",
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "input_image",
+                            "image_url": "data:image/jpeg;base64," + base64.b64encode(image.getvalue()).decode(),
+                        }
+                    ],
+                },
+            }
+        )
+    )
+
+
+@asynccontextmanager
+async def _duplex_recorded_session(runtime, log_path: Path, *, instructions: str, vad: bool = True):
+    events: list[dict] = []
+    server = runtime.server
+    async with websockets.connect(
+        f"ws://{server.host}:{server.port}/v1/realtime?duplex=1", max_size=64 * 1024 * 1024
+    ) as ws:
+        failed = True
+        try:
+            await ws.send(
+                json.dumps(
+                    {
+                        "type": "session.update",
+                        "session": {
+                            "model": server.model,
+                            "instructions": instructions,
+                            "temperature": 0,
+                            "max_output_tokens": 384 if vad else 64,
+                            "audio": {
+                                "input": {
+                                    "format": {"type": "audio/pcm", "rate": 24000},
+                                    "turn_detection": {
+                                        "type": "server_vad",
+                                        "threshold": 0.5,
+                                        "prefix_padding_ms": 300,
+                                        "silence_duration_ms": 500,
+                                        "create_response": True,
+                                        "interrupt_response": True,
+                                    }
+                                    if vad
+                                    else None,
+                                },
+                                "output": {"format": {"type": "audio/pcm", "rate": 24000}},
+                            },
+                        },
+                    }
+                )
+            )
+            await _duplex_receive_until(ws, events, lambda: any(e["type"] == "session.updated" for e in events))
+            session = next(e["session"] for e in events if e["type"] == "session.updated")
+            if vad:
+                accepted = session["audio"]["input"]["turn_detection"]
+                assert accepted["interrupt_response"] is True
+                assert accepted["create_response"] is True
+            await _duplex_add_image(ws)
+            yield ws, events, session["id"]
+            failed = False
+        finally:
+            # Closing the transport alone leaves a resumable session occupying
+            # the deployment's single session slot. Always release the session.
+            try:
+                await ws.send(json.dumps({"type": "session.close"}))
+                await _duplex_receive_until(
+                    ws, events, lambda: any(e["type"] == "session.closed" for e in events), timeout_s=15
+                )
+            except Exception:
+                if not failed:
+                    raise
+            finally:
+                log_path.write_text(json.dumps(events, ensure_ascii=False, indent=2))
+
+
+def _duplex_assert_prompt(
+    runtime,
+    session_id: str,
+    *,
+    audio_count: int,
+    instructions: str,
+    request_count: int,
+    assistant_texts: list[str] | None = None,
+):
+    captures = []
+    for path in runtime.artifacts.glob("*/input.json"):
+        capture = json.loads(path.read_text())
+        if duplex_resource_request_belongs_to_session(capture["request_id"], session_id):
+            captures.append((path.stat().st_mtime_ns, capture))
+    assert len(captures) == request_count, captures
+    capture = max(captures, key=lambda item: item[0])[1]
+    assert capture["audio_count"] == audio_count
+    # The camera belongs to the first user turn and leaves with its audio.
+    image_retained = request_count <= 4
+    assert len(capture["images"]) == int(image_retained)
+    messages: list[dict[str, Any]] = [{"role": "system", "content": instructions}]
+    if assistant_texts is None:
+        assistant_texts = [""] * (audio_count - 1)
+    assert len(assistant_texts) == audio_count - 1
+    for index in range(audio_count):
+        if index:
+            messages.append({"role": "assistant", "content": assistant_texts[index - 1]})
+        parts = [{"type": "image"}] if index == 0 and image_retained else []
+        parts.append({"type": "audio"})
+        messages.append({"role": "user", "content": parts})
+    expected = runtime.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    assert capture["prompt"] == expected
+    # Use the checkpoint tokenizer too: a repr(messages) processor stub cannot
+    # establish that an empty assistant survives as a real turn separator.
+    tokenizer = runtime.processor.tokenizer
+    actual_ids = tokenizer.encode(capture["prompt"], add_special_tokens=False)
+    separator_ids = tokenizer.encode("<|im_start|>assistant\n<|im_end|>\n", add_special_tokens=False)
+    assert sum(
+        actual_ids[index : index + len(separator_ids)] == separator_ids for index in range(len(actual_ids))
+    ) == assistant_texts.count("")
+
+
+def _duplex_assert_completed_audio(events: list[dict], response_id: str) -> None:
+    terminal = _duplex_response_events(events, response_id, "response.done")
+    assert len(terminal) == 1, terminal
+    assert terminal[0]["response"]["status"] == "completed", terminal
+    audio = _duplex_response_events(events, response_id, "response.output_audio.delta")
+    assert sum(len(base64.b64decode(event["delta"])) for event in audio) > 4800
+    assert any(
+        event.get("delta")
+        for event in events
+        if _duplex_response_id(event) == response_id
+        and event["type"] in {"response.output_text.delta", "response.output_audio_transcript.delta"}
+    ), "The follow-up must produce text as well as audio"
+
+
+async def _run_duplex_playback_interruption(runtime, log_path: Path, *, generation_finished: bool) -> None:
+    async with _duplex_recorded_session(runtime, log_path, instructions=_DUPLEX_LONG_INSTRUCTIONS) as (
+        ws,
+        events,
+        session_id,
+    ):
+        await _duplex_send_pcm(ws, _duplex_fixture_pcm(validated_input_wav()))
+        await _duplex_receive_until(ws, events, lambda: any(e["type"] == "response.created" for e in events))
+        old_id = next(_duplex_response_id(e) for e in events if e["type"] == "response.created")
+        assert old_id
+        await _duplex_receive_until(
+            ws,
+            events,
+            lambda: (
+                sum(
+                    len(base64.b64decode(e["delta"]))
+                    for e in _duplex_response_events(events, old_id, "response.output_audio.delta")
+                )
+                > 4800
+            ),
+        )
+        if generation_finished:
+            await _duplex_receive_until(ws, events, lambda: _duplex_response_events(events, old_id, "response.done"))
+        await ws.send(
+            json.dumps({"type": "playback.ack", "response_id": old_id, "played_ms": 100, "committed_ms": 100})
+        )
+        await _duplex_receive_until(ws, events, lambda: any(e["type"] == "playback.acknowledged" for e in events))
+        ack = next(e["event"] for e in events if e["type"] == "playback.acknowledged")
+        assert ack["item_id"] == f"item_{old_id}"
+        assert ack["committed_ms"] == 100
+        assert ack["playback"]["sent_ms"] > 100
+        cursor = len(events)
+        sender = asyncio.create_task(
+            _duplex_send_pcm(ws, _duplex_fixture_pcm(validated_soft_interrupt_wav(), duration_s=4.7), paced=True)
+        )
+        try:
+            await _duplex_receive_until(
+                ws, events, lambda: any(e["type"] == "input_audio_buffer.speech_started" for e in events[cursor:])
+            )
+            speech_index = next(
+                i for i in range(cursor, len(events)) if events[i]["type"] == "input_audio_buffer.speech_started"
+            )
+            if not generation_finished:
+                assert not _duplex_response_events(events[:speech_index], old_id, "response.done"), (
+                    "Generation completed before speech interruption; the in-progress scenario was not exercised"
+                )
+            await _duplex_receive_until(
+                ws,
+                events,
+                lambda: any(e["type"] == "response.done" and _duplex_response_id(e) != old_id for e in events[cursor:]),
+            )
+            await sender
+        finally:
+            sender.cancel()
+            with suppress(asyncio.CancelledError):
+                await sender
+        new_id = next(
+            _duplex_response_id(e)
+            for e in events[cursor:]
+            if e["type"] == "response.created" and _duplex_response_id(e) != old_id
+        )
+    # Include everything observed through session.closed when checking duplicates.
+    terminals = _duplex_response_events(events, old_id, "response.done")
+    assert len(terminals) == 1, terminals
+    assert terminals[0]["response"]["status"] == ("completed" if generation_finished else "cancelled")
+    if generation_finished:
+        cleared = _duplex_response_events(events, old_id, "output_audio_buffer.cleared")
+        assert len(cleared) == 1, cleared
+        boundary = events.index(cleared[0])
+    else:
+        boundary = events.index(terminals[0])
+    assert not _duplex_response_events(events[boundary + 1 :], old_id, "response.output_audio.delta")
+    assert new_id and new_id != old_id
+    _duplex_assert_completed_audio(events, new_id)
+    _duplex_assert_prompt(runtime, session_id, audio_count=2, instructions=_DUPLEX_LONG_INSTRUCTIONS, request_count=2)
+
+
+async def _run_duplex_history_pruning(runtime, log_path: Path) -> None:
+    async with _duplex_recorded_session(runtime, log_path, instructions=_DUPLEX_SHORT_INSTRUCTIONS, vad=False) as (
+        ws,
+        events,
+        session_id,
+    ):
+        response_ids = []
+        heard_texts: list[str] = []
+        pcm = _duplex_fixture_pcm(validated_input_wav())
+        for turn in range(6):
+            cursor = len(events)
+            await _duplex_send_pcm(ws, pcm, trailing_silence=False)
+            await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
+            await ws.send(json.dumps({"type": "response.create"}))
+            await _duplex_receive_until(ws, events, lambda: any(e["type"] == "response.done" for e in events[cursor:]))
+            response_id = next(_duplex_response_id(e) for e in events[cursor:] if e["type"] == "response.done")
+            assert response_id and response_id not in response_ids
+            response_ids.append(response_id)
+            _duplex_assert_completed_audio(events, response_id)
+            _duplex_assert_prompt(
+                runtime,
+                session_id,
+                audio_count=min(turn + 1, 4),
+                instructions=_DUPLEX_SHORT_INSTRUCTIONS,
+                request_count=turn + 1,
+                assistant_texts=heard_texts[-3:],
+            )
+            # Complete playback so pruning is checked against real assistant
+            # answers paired with retained user audio. Repeated empty assistant
+            # turns can make Qwen emit EOS; interruption tests cover those slots.
+            done = _duplex_response_events(events, response_id, "response.done")[0]["response"]
+            played_ms = done["metadata"]["playback"]["sent_ms"]
+            heard_texts.append(
+                "".join(
+                    e["delta"]
+                    for e in _duplex_response_events(events, response_id, "response.output_audio_transcript.delta")
+                ).strip()
+            )
+            assert heard_texts[-1]
+            cursor = len(events)
+            await ws.send(
+                json.dumps(
+                    {
+                        "type": "playback.ack",
+                        "response_id": response_id,
+                        "played_ms": played_ms,
+                        "committed_ms": played_ms,
+                    }
+                )
+            )
+            await _duplex_receive_until(
+                ws, events, lambda: any(e["type"] == "playback.acknowledged" for e in events[cursor:])
+            )
+            ack = next(e["event"] for e in events[cursor:] if e["type"] == "playback.acknowledged")
+            assert ack["item_id"] == f"item_{response_id}"
+            assert ack["committed_ms"] == ack["playback"]["sent_ms"] == played_ms
+            assert ack["history_committed"] is True
+    for response_id in response_ids:
+        _duplex_assert_completed_audio(events, response_id)
+
+
+@pytest.mark.advanced_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+class TestQwen3OmniDuplexPlayback:
+    @pytest.mark.parametrize("generation_finished", [False, True], ids=["generating", "queued-playback"])
+    @pytest.mark.parametrize("repetition", range(_DUPLEX_REPEATS))
+    def test_speech_interrupts_playback(
+        self, qwen_duplex_server, tmp_path: Path, generation_finished: bool, repetition: int
+    ):
+        """Reuse one live deployment; every repetition opens an independent call."""
+        asyncio.run(
+            _run_duplex_playback_interruption(
+                qwen_duplex_server, tmp_path / f"events-{repetition}.json", generation_finished=generation_finished
+            )
+        )
+
+    def test_mixed_image_audio_history_pruning(self, qwen_duplex_server, tmp_path: Path):
+        asyncio.run(_run_duplex_history_pruning(qwen_duplex_server, tmp_path / "events.json"))
diff --git a/tests/entrypoints/openai_api/test_ref_audio_cache.py b/tests/entrypoints/openai_api/test_ref_audio_cache.py
new file mode 100644
index 000000000..8026864b0
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_ref_audio_cache.py
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import asyncio
+import hashlib
+from collections import OrderedDict
+
+import numpy as np
+import pytest
+
+from vllm_omni.entrypoints.openai.serving_speech import (
+    _REF_AUDIO_RESOLVE_CACHE_MAX_BYTES,
+    _REF_AUDIO_RESOLVE_CACHE_MAX_ENTRIES,
+    OmniOpenAIServingSpeech,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def cache():
+    server = object.__new__(OmniOpenAIServingSpeech)
+    server._diffusion_mode = False
+    server.model_config = None
+    server._ref_audio_resolve_cache = OrderedDict()
+    server._ref_audio_resolve_cache_bytes = 0
+    server._ref_audio_resolve_cache_max_entries = _REF_AUDIO_RESOLVE_CACHE_MAX_ENTRIES
+    server._ref_audio_resolve_cache_max_bytes = _REF_AUDIO_RESOLVE_CACHE_MAX_BYTES
+    server._ref_audio_model_artifact_ready = set()
+    server._request_ref_audio_artifact_keys = {}
+    return server
+
+
+def _put(cache, key, samples, artifact=None):
+    cache._put_resolved_ref_audio(key, samples, 24000, artifact or key)
+
+
+def test_compact_storage_and_default_capacity(cache):
+    assert cache._ref_audio_resolve_cache_max_entries == 1024
+    assert cache._ref_audio_resolve_cache_max_bytes == 512 * 1024 * 1024
+    _put(cache, "a", [0.0, 0.25, -0.5, 1.0])
+    value = cache._ref_audio_resolve_cache["a"]
+    assert value[0].dtype == np.float32
+    assert value[2] == cache._ref_audio_resolve_cache_bytes == 16
+
+
+def test_cached_float32_roundtrip_and_mutation_isolation(cache):
+    source = "data:audio/wav;base64,already-cached"
+    key = hashlib.sha1(source.encode()).hexdigest()
+    values = np.random.default_rng(42).standard_normal(48000).astype(np.float32).tolist()
+    expected = values.copy()
+    _put(cache, key, values)
+    values[0] = 99.0
+    first, sample_rate, _ = asyncio.run(cache._resolve_ref_audio(source))
+    assert first == expected
+    first[0] = 100.0
+    second, _, _ = asyncio.run(cache._resolve_ref_audio(source))
+    assert sample_rate == 24000
+    assert second == expected
+
+
+def test_entry_eviction_invalidates_artifact_readiness(cache):
+    cache._ref_audio_resolve_cache_max_entries = 2
+    _put(cache, "a", [0.0])
+    cache._ref_audio_model_artifact_ready.add(("a", False))
+    _put(cache, "b", [0.0])
+    _put(cache, "c", [0.0])
+    assert list(cache._ref_audio_resolve_cache) == ["b", "c"]
+    assert ("a", False) not in cache._ref_audio_model_artifact_ready
+
+
+def test_byte_budget_evicts_and_rejects_oversized_entries(cache):
+    cache._ref_audio_resolve_cache_max_bytes = 16
+    _put(cache, "a", [0.0] * 3)
+    _put(cache, "b", [0.0] * 3)
+    assert list(cache._ref_audio_resolve_cache) == ["b"]
+    assert cache._ref_audio_resolve_cache_bytes == 12
+    _put(cache, "too-large", [0.0] * 5)
+    assert "too-large" not in cache._ref_audio_resolve_cache
+
+
+def test_replacement_accounts_bytes_and_preserves_referenced_artifact(cache):
+    _put(cache, "a", [0.0] * 3, "same")
+    _put(cache, "alias", [0.0] * 2, "same")
+    cache._ref_audio_model_artifact_ready.add(("same", False))
+    _put(cache, "a", [1.0] * 4, "new")
+    assert cache._ref_audio_resolve_cache_bytes == 24
+    assert ("same", False) in cache._ref_audio_model_artifact_ready
+
+
+def test_pool_accepts_666_references(cache):
+    for index in range(666):
+        _put(cache, str(index), [0.0] * 8)
+    assert len(cache._ref_audio_resolve_cache) == 666
+    assert cache._ref_audio_resolve_cache_bytes == 666 * 8 * 4
diff --git a/tests/entrypoints/openai_api/test_reference_waveform_cache.py b/tests/entrypoints/openai_api/test_reference_waveform_cache.py
new file mode 100644
index 000000000..9d87d560b
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_reference_waveform_cache.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import numpy as np
+import pytest
+
+from vllm_omni.entrypoints.openai.serving_speech import OmniOpenAIServingSpeech
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def server(monkeypatch, tmp_path):
+    monkeypatch.setenv("SPEAKER_SAMPLES_DIR", str(tmp_path))
+    return OmniOpenAIServingSpeech.__new__(OmniOpenAIServingSpeech)
+
+
+@pytest.mark.parametrize("stereo", [False, True])
+def test_finalized_waveform_owns_contiguous_numeric_storage(server, stereo):
+    import gc
+
+    source = np.linspace(-1, 1, 96000, dtype=np.float64).reshape(48000, 2)
+    decoded = source if stereo else source[:, 0]
+    expected = np.asarray(decoded, dtype=np.float32)
+    if stereo:
+        expected = expected.mean(axis=-1)
+    waveform, sr, artifact, duration = server._finalize_fetched_ref_audio(decoded, 24000)
+    assert waveform.dtype == np.float32
+    assert waveform.flags.c_contiguous and waveform.flags.owndata
+    assert not np.shares_memory(waveform, decoded)
+    assert not gc.is_tracked(waveform)
+    np.testing.assert_array_equal(waveform, expected)
+    assert artifact == server._make_ref_audio_artifact_cache_key(expected, sr)
+    assert duration == 2.0
+
+
+@pytest.mark.asyncio
+async def test_array_resolver_reuses_buffer_and_legacy_lists_are_temporary(server, mocker):
+    server._init_speaker_storage()
+    server._diffusion_mode = True
+    server._allowed_local_media_path = ""
+    server._ref_audio_cache_key = mocker.AsyncMock(return_value="locator")
+    server._media_connector = mocker.Mock()
+    server._media_connector.fetch_audio_async = mocker.AsyncMock(
+        return_value=(np.linspace(-1, 1, 24000, dtype=np.float32), 24000)
+    )
+    first, sr, key = await server._resolve_ref_audio_array("reference")
+    second, _, _ = await server._resolve_ref_audio_array("reference")
+    legacy, _, _ = await server._resolve_ref_audio("reference")
+    assert first is second
+    assert isinstance(legacy, list)
+    np.testing.assert_array_equal(first, legacy)
+    legacy[0] = 100
+    assert first[0] == -1
+    assert server._ref_audio_resolve_cache[key][0] is first
+    assert server._ref_audio_resolve_cache_bytes == first.nbytes == 96000
+    server._media_connector.fetch_audio_async.assert_awaited_once()
+
+
+@pytest.mark.parametrize("variant", [None, "local", "delay", "realtime"])
+@pytest.mark.asyncio
+async def test_moss_array_resolution_keeps_nano_list_transport(mocker, variant):
+    from vllm_omni.entrypoints.openai.tts_adapters.base import SpeechServingContext
+    from vllm_omni.entrypoints.openai.tts_adapters.moss_tts import _MossTTSAdapterBase
+
+    server = mocker.Mock()
+    server._resolve_ref_audio = mocker.AsyncMock(return_value=([0.0], 24000, "key"))
+    waveform = np.zeros(1, dtype=np.float32)
+    server._resolve_ref_audio_array = mocker.AsyncMock(return_value=(waveform, 24000, "key"))
+    adapter = _MossTTSAdapterBase.__new__(_MossTTSAdapterBase)
+    adapter.ctx = SpeechServingContext(server=server)
+    adapter._moss_variant = variant
+    result, _, _ = await adapter._resolve_ref_audio("reference")
+    if variant is None:
+        assert isinstance(result, list)
+        server._resolve_ref_audio_array.assert_not_awaited()
+    else:
+        assert result is waveform
+        server._resolve_ref_audio.assert_not_awaited()
+
+
+def test_waveform_cache_eviction_releases_owned_buffer(server):
+    import weakref
+
+    server._init_speaker_storage()
+    server._ref_audio_resolve_cache_max_entries = 1
+    waveform = np.zeros(24000, dtype=np.float32)
+    ref = weakref.ref(waveform)
+    server._put_resolved_ref_audio("first", waveform, 24000, "artifact-first")
+    del waveform
+    assert ref() is not None
+    server._put_resolved_ref_audio("second", np.zeros(24000, dtype=np.float32), 24000, "artifact-second")
+    assert ref() is None
+    assert server._ref_audio_resolve_cache_bytes == 96000
+
+
+@pytest.mark.parametrize("entries, budget", [(1, 1000), (10, 8)])
+def test_numeric_waveform_cache_limits(server, entries, budget):
+    server._init_speaker_storage()
+    server._ref_audio_resolve_cache_max_entries = entries
+    server._ref_audio_resolve_cache_max_bytes = budget
+    server._put_resolved_ref_audio("a", np.zeros(2, dtype=np.float32), 24000, "artifact-a")
+    server._put_resolved_ref_audio("b", np.ones(2, dtype=np.float32), 24000, "artifact-b")
+    assert list(server._ref_audio_resolve_cache) == ["b"]
+    assert server._ref_audio_resolve_cache_bytes == 8
diff --git a/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_reference_audio.py b/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_reference_audio.py
index 59d070a39..417f457d3 100644
--- a/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_reference_audio.py
+++ b/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_reference_audio.py
@@ -27,7 +27,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 @dataclass
 class _EngineClientStub:
-    stage_configs: list[dict[str, object]]
+    stage_configs: list[object]
 
 
 @dataclass
@@ -149,6 +149,37 @@ async def test_chat_reference_audio_reaches_code2wav_transport(
     assert code2wav_payload.meta.ref_audio_sr == 16000
 
 
+@pytest.mark.asyncio
+async def test_typed_stage_enables_reference_audio(
+    serving_chat: OmniOpenAIServingChat,
+    mocker: MockerFixture,
+) -> None:
+    reference_audio_url = "data:audio/wav;base64,AAAA"
+    reference_waveform = np.array([0.25, -0.5], dtype=np.float32)
+    serving_chat.engine_client = _EngineClientStub(
+        [
+            SimpleNamespace(
+                model_config=SimpleNamespace(model_arch="MiniCPMO45OmniForConditionalGeneration"),
+                model_stage="llm",
+            )
+        ]
+    )
+    serving_chat.model_config = _ModelConfigStub()
+    engine_prompt: TokensPrompt = {"type": "tokens", "prompt_token_ids": [1]}
+    media_connector = mocker.patch(
+        "vllm_omni.entrypoints.openai.serving_chat.MediaConnector",
+    ).return_value
+    media_connector.fetch_audio_async = mocker.AsyncMock(return_value=(reference_waveform, 16000))
+
+    await serving_chat._attach_minicpmo45_reference_audio(
+        engine_prompt,
+        _chat_request(reference_audio_url),
+    )
+
+    media_connector.fetch_audio_async.assert_awaited_once_with(reference_audio_url)
+    assert MINICPMO45_REFERENCE_AUDIO_KEY in cast(dict[str, object], engine_prompt)
+
+
 @pytest.mark.parametrize("request_shape", ["extra_body", "model_extra"])
 @pytest.mark.asyncio
 async def test_reference_audio_accepts_request_extra_mappings(
diff --git a/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py b/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py
index 1a3a4f22e..5ce129d15 100644
--- a/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py
+++ b/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for MiniCPM-o 4.5 audio-streaming output-kind coercion.
 
 Chat ``stream=true`` coerces every AR stage to DELTA. For MiniCPM-o 4.5 that
@@ -33,6 +34,13 @@ def _stage(model_arch: str, model_stage: str) -> SimpleNamespace:
     return SimpleNamespace(engine_args=SimpleNamespace(model_arch=model_arch, model_stage=model_stage))
 
 
+def _typed_stage(model_arch: str, model_stage: str) -> SimpleNamespace:
+    return SimpleNamespace(
+        model_config=SimpleNamespace(model_arch=model_arch),
+        model_stage=model_stage,
+    )
+
+
 def _minicpmo45_stages():
     return [_stage(MINICPMO45_ARCH, "llm"), _stage(MINICPMO45_ARCH, "tts")]
 
@@ -50,6 +58,20 @@ def test_thinker_forced_final_only_talker_stays_delta(serving_chat):
     assert out[1].output_kind is RequestOutputKind.DELTA
 
 
+def test_typed_stages_force_thinker_final_only(serving_chat):
+    serving_chat.engine_client = SimpleNamespace(
+        stage_configs=[
+            _typed_stage(MINICPMO45_ARCH, "llm"),
+            _typed_stage(MINICPMO45_ARCH, "tts"),
+        ]
+    )
+
+    out = serving_chat._fix_minicpmo45_audio_stream_output_kinds(_delta_params(), ["text", "audio"])
+
+    assert out[0].output_kind is RequestOutputKind.FINAL_ONLY
+    assert out[1].output_kind is RequestOutputKind.DELTA
+
+
 @pytest.mark.parametrize("modalities", [None, [], ["text"]])
 def test_non_audio_request_is_untouched(serving_chat, modalities):
     serving_chat.engine_client = SimpleNamespace(stage_configs=_minicpmo45_stages())
diff --git a/tests/entrypoints/openai_api/test_serving_chat_multistage_generation.py b/tests/entrypoints/openai_api/test_serving_chat_multistage_generation.py
index 639ddf6c6..b51debe2a 100644
--- a/tests/entrypoints/openai_api/test_serving_chat_multistage_generation.py
+++ b/tests/entrypoints/openai_api/test_serving_chat_multistage_generation.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for multistage generation input construction."""
 
 from __future__ import annotations
@@ -94,6 +95,34 @@ def test_build_multistage_generation_inputs_applies_stage_specific_overrides(ser
     assert engine.default_sampling_params_list[2].lora_request is None
 
 
+@pytest.mark.parametrize("extra_body", [{}, {"bot_task": "think"}])
+def test_build_multistage_generation_inputs_leaves_mm_uuids_to_content_hash(serving_chat, extra_body):
+    """Fixed image UUIDs collide across requests with the same processor kwargs.
+
+    Leave UUID generation to vLLM so cache keys depend on image content.
+    """
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+    engine = SimpleNamespace(
+        stage_configs=[
+            SimpleNamespace(stage_type="llm", is_comprehension=True),
+            SimpleNamespace(stage_type="diffusion", is_comprehension=False),
+        ],
+        default_sampling_params_list=[SamplingParams(temperature=0.0), OmniDiffusionSamplingParams()],
+    )
+    for images in ([Image.new("RGB", (32, 32), color="red")], [Image.new("RGB", (32, 32), c) for c in ("red", "blue")]):
+        engine_prompt, _ = OmniOpenAIServingChat._build_multistage_generation_inputs(
+            serving_chat,
+            engine=engine,
+            prompt="edit me",
+            extra_body=dict(extra_body),
+            reference_images=images,
+            gen_params=OmniDiffusionSamplingParams(seed=0),
+        )
+        assert engine_prompt["multi_modal_data"]
+        assert "multi_modal_uuids" not in engine_prompt
+
+
 def test_prepare_multistage_multimodal_inputs_defers_downstream_modalities(serving_chat):
     from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
 
diff --git a/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py b/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py
index f81e61cf1..8b2586bd5 100644
--- a/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py
+++ b/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """
 Unit tests for OmniOpenAIServingChat sampling params handling.
 
@@ -8,6 +9,7 @@ are correctly applied to the comprehension stage while preserving YAML defaults.
 
 import asyncio
 from types import SimpleNamespace
+from typing import Any, cast
 
 import pytest
 from pytest_mock import MockerFixture
@@ -326,6 +328,64 @@ def test_mixed_consumer_keeps_root_common_args_with_nested_extras(mock_engine_cl
     assert captured["prompt"]["negative_prompt"] == "avoid blur"
 
 
+def test_text_only_request_reaches_engine_with_comprehension_task_mode(mock_engine_client, mocker: MockerFixture):
+    """Exercise the production chat path, not only the tagging helper."""
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    mock_engine_client.stage_configs = [
+        SimpleNamespace(stage_type="llm", is_comprehension=True),
+        SimpleNamespace(stage_type="diffusion", is_comprehension=False),
+    ]
+    mock_engine_client.default_sampling_params_list = [
+        SamplingParams(),
+        OmniDiffusionSamplingParams(),
+    ]
+    mock_engine_client.output_modalities = ["text", "image"]
+    mock_engine_client.errored = False
+    mock_engine_client.renderer = SimpleNamespace(get_tokenizer=lambda: object())
+    captured: dict[str, object] = {}
+
+    async def results():
+        if False:
+            yield None
+
+    def generate(**kwargs):
+        captured.update(kwargs)
+        return results()
+
+    mock_engine_client.generate = generate
+    serving_chat = build_serving_chat(
+        engine_client=mock_engine_client,
+        models=SimpleNamespace(model_name=lambda _: "test"),
+        online_renderer=SimpleNamespace(validate_chat_template=lambda **_: None),
+        trust_request_chat_template=True,
+    )
+    serving_chat._diffusion_mode = False
+    serving_chat._diffusion_extra_body_params = frozenset()
+    mocker.patch.multiple(
+        serving_chat,
+        _check_model=mocker.AsyncMock(return_value=None),
+        _maybe_get_adapters=mocker.Mock(return_value=None),
+        _effective_chat_template_kwargs=mocker.Mock(return_value={}),
+        _preprocess_chat=mocker.AsyncMock(return_value=([], [{"prompt": "raw"}])),
+        _base_request_id=mocker.Mock(return_value="test"),
+        _log_inputs=mocker.Mock(),
+        chat_completion_full_generator=mocker.AsyncMock(return_value="done"),
+    )
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[{"role": "user", "content": "describe this image"}],
+        modalities=["text"],
+    )
+
+    assert asyncio.run(serving_chat._create_chat_completion(request)) == "done"
+
+    sampling_params_list = cast(list[Any], captured["sampling_params_list"])
+    assert sampling_params_list[0].extra_args == {"ar_task_mode": "comprehension"}
+    assert sampling_params_list[1].extra_args == {}
+    assert captured["output_modalities"] == ["text"]
+
+
 @pytest.fixture
 def mock_request(mocker: MockerFixture):
     """Create a mock request with all OpenAI sampling params set to None."""
@@ -865,3 +925,54 @@ class TestResolveHeightWidth:
         h, w = OmniOpenAIServingChat._resolve_height_width_from_extra_body({"size": "invalid"})
         assert h is None
         assert w is None
+
+
+# Tests for _apply_text_chat_ar_task_mode (#6088)
+
+
+def _tag_request(modalities):
+    return SimpleNamespace(modalities=modalities)
+
+
+def _apply_tag(params, modalities):
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+    OmniOpenAIServingChat._apply_text_chat_ar_task_mode(params, _tag_request(modalities))
+    return params
+
+
+@pytest.mark.parametrize("modalities", [[], ["text"]])
+def test_text_only_chat_tags_ar_stage_as_comprehension(modalities):
+    ar = SamplingParams()
+    params = _apply_tag([ar], modalities)
+    assert params[0].extra_args == {"ar_task_mode": "comprehension"}
+
+
+@pytest.mark.parametrize("modalities", [["image"], ["text", "audio"], ["video"]])
+def test_non_text_output_request_is_untouched(modalities):
+    ar = SamplingParams()
+    _apply_tag([ar], modalities)
+    assert ar.extra_args is None
+
+
+def test_diffusion_stage_params_are_untouched():
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    ar = SamplingParams()
+    dit = OmniDiffusionSamplingParams()
+    dit_extra_before = getattr(dit, "extra_args", None)
+    _apply_tag([ar, dit], ["text"])
+    assert ar.extra_args == {"ar_task_mode": "comprehension"}
+    assert getattr(dit, "extra_args", None) == dit_extra_before
+
+
+def test_explicit_caller_ar_task_mode_is_preserved():
+    ar = SamplingParams(extra_args={"ar_task_mode": "generation"})
+    _apply_tag([ar], ["text"])
+    assert ar.extra_args["ar_task_mode"] == "generation"
+
+
+def test_existing_extra_args_are_merged_not_replaced():
+    ar = SamplingParams(extra_args={"custom": 1})
+    _apply_tag([ar], None)
+    assert ar.extra_args == {"custom": 1, "ar_task_mode": "comprehension"}
diff --git a/tests/entrypoints/openai_api/test_serving_speech.py b/tests/entrypoints/openai_api/test_serving_speech.py
index f910c68af..146488aa2 100644
--- a/tests/entrypoints/openai_api/test_serving_speech.py
+++ b/tests/entrypoints/openai_api/test_serving_speech.py
@@ -27,6 +27,7 @@ from pydantic import ValidationError
 from pytest_mock import MockerFixture
 from vllm.entrypoints.serve.engine.protocol import ErrorInfo, ErrorResponse
 
+from vllm_omni.config.stage_config import StagePipelineConfig
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched.request_scheduler import RequestScheduler
 from vllm_omni.diffusion.sched.step_scheduler import StepScheduler
@@ -1039,6 +1040,38 @@ class TestTTSMethods:
             asyncio.run(server._prepare_speech_generation(request))
         server.shutdown()
 
+    def test_prepare_speech_rejects_typed_non_tts_omni_model(self, mocker: MockerFixture):
+        """Typed Qwen3-Omni stages must hit the same talker guard as legacy stages."""
+        mock_engine_client = mocker.MagicMock()
+        mock_engine_client.errored = False
+        mock_engine_client.tts_max_instructions_length = None
+        mock_engine_client.stage_configs = [
+            SimpleNamespace(
+                stage_pipeline_config=StagePipelineConfig(stage_id=index, model_stage=model_stage),
+                model_config=SimpleNamespace(model_arch=None),
+                worker_type=worker_type,
+            )
+            for index, (model_stage, worker_type) in enumerate(
+                (
+                    ("thinker", "ar"),
+                    ("talker", "ar"),
+                    ("code2wav", "generation"),
+                )
+            )
+        ]
+
+        mock_models = mocker.MagicMock()
+        mock_models.is_base_model.return_value = True
+        server = OmniOpenAIServingSpeech(
+            engine_client=mock_engine_client,
+            models=mock_models,
+            request_logger=mocker.MagicMock(),
+        )
+        request = OpenAICreateSpeechRequest(input="Hello world")
+        with pytest.raises(ValueError, match="only supported for dedicated TTS models"):
+            asyncio.run(server._prepare_speech_generation(request))
+        server.shutdown()
+
     def test_estimate_prompt_len_fallback(self, speech_server):
         """Test prompt length estimation falls back to 2048 when model is unavailable."""
         tts_params = {"text": ["Hello"], "task_type": ["CustomVoice"]}
@@ -1559,7 +1592,8 @@ class TestTTSMethods:
 
         assert first[1] == 24000
         assert second[1] == 24000
-        assert first[0] is second[0]
+        assert first[0] == second[0]
+        assert first[0] is not second[0]
         assert first[0][0] == pytest.approx(float(wav[0]), abs=1e-4)
         cache_key = first[2]
         assert speech_server._get_resolved_ref_audio_artifact_key(
@@ -1826,6 +1860,53 @@ class TestTTSMethods:
         assert prompt_a["additional_information"]["ref_audio_cache_key"] == "key_aaa"
         assert prompt_b["additional_information"]["ref_audio_cache_key"] == "key_bbb"
 
+    @pytest.mark.asyncio
+    async def test_higgs_v2_cache_salt_changes_for_same_shaped_reference_audio(self, speech_server, mocker):
+        """Higgs v2 must salt identical placeholder prompts by resolved audio content."""
+        build_voice_clone_prompt = mocker.patch(
+            "vllm_omni.model_executor.models.higgs_audio_v2.higgs_audio_v2_tokenizer.build_voice_clone_prompt"
+        )
+        build_voice_clone_prompt.side_effect = lambda _processor, _input, wav, _sr, _ref_text: {
+            "prompt_token_ids": [1, 151700, 151700, 2],
+            "audio_input_ids": torch.tensor([[100 if wav[0] < 0.5 else 900, 2], [3, 4]], dtype=torch.long),
+            "audio_input_ids_mask": torch.ones(2, dtype=torch.bool),
+        }
+
+        speech_server._tts_model_type = "higgs_audio_v2"
+        speech_server._adapter = speech_server._get_tts_adapter()
+        speech_server._adapter._resolve_higgs_audio_v2_processor = mocker.AsyncMock(return_value=object())
+
+        req_a = OpenAICreateSpeechRequest(
+            input="hello",
+            ref_audio="file:///data/spk.wav",
+            ref_text="transcript",
+        )
+        req_b = OpenAICreateSpeechRequest(
+            input="hello",
+            ref_audio="file:///data/spk.wav",
+            ref_text="transcript",
+        )
+        speech_server._adapter._resolve_ref_audio = mocker.AsyncMock(
+            side_effect=[([0.1] * 48000, 24000, "key_aaa"), ([0.9] * 48000, 24000, "key_bbb")]
+        )
+
+        prompt_a = await speech_server._adapter._build_higgs_audio_v2_params(req_a)
+        prompt_b = await speech_server._adapter._build_higgs_audio_v2_params(req_b)
+
+        assert prompt_a["prompt_token_ids"] == [1, 151700, 151700, 2]
+        assert prompt_a["prompt_token_ids"] == prompt_b["prompt_token_ids"]
+        assert (
+            prompt_a["additional_information"]["audio_input_ids"].shape
+            == prompt_b["additional_information"]["audio_input_ids"].shape
+        )
+        assert not torch.equal(
+            prompt_a["additional_information"]["audio_input_ids"],
+            prompt_b["additional_information"]["audio_input_ids"],
+        )
+        assert prompt_a["cache_salt"] != prompt_b["cache_salt"]
+        assert prompt_a["additional_information"]["ref_audio_cache_key"] == "key_aaa"
+        assert prompt_b["additional_information"]["ref_audio_cache_key"] == "key_bbb"
+
     # ── MossReferenceEncoder: speaker cache invalidation ──
 
     @pytest.mark.asyncio
@@ -3793,6 +3874,7 @@ def test_api_server_create_speech_wraps_error_response_status(mocker: MockerFixt
 def _make_api_server_request(handler, *, method: str = "POST", path: str = "/v1/audio/voices") -> Request:
     app = FastAPI()
     app.state.openai_serving_speech = handler
+    app.state.api_server_count = 1
     scope = {
         "type": "http",
         "app": app,
@@ -4954,89 +5036,6 @@ class TestMingFlashOmniTTSServing:
         assert prompt["additional_information"]["voice_name"] == "test"
 
 
-@pytest.fixture
-def dots_tts_server(mocker: MockerFixture):
-    mocker.patch(
-        "vllm_omni.entrypoints.openai.tts_adapters.base.load_supported_speakers",
-        return_value=set(),
-    )
-    mocker.patch(
-        "vllm_omni.entrypoints.openai.tts_adapters.base.load_codec_frame_rate",
-        return_value=None,
-    )
-
-    mock_engine_client = mocker.MagicMock()
-    mock_engine_client.errored = False
-    mock_engine_client.model_config = mocker.MagicMock(
-        model="dots-studio/dots.tts-soar",
-    )
-    mock_engine_client.default_sampling_params_list = [
-        SimpleNamespace(max_tokens=2048, min_tokens=None, extra_args=None)
-    ]
-    mock_engine_client.tts_batch_max_items = 32
-    mock_engine_client.generate = mocker.MagicMock(return_value="generator")
-    mock_engine_client.stage_configs = [
-        SimpleNamespace(
-            engine_args=SimpleNamespace(model_stage="latent_generator", model_arch="DotsTTSForConditionalGeneration"),
-            tts_args={},
-        )
-    ]
-
-    mock_models = mocker.MagicMock()
-    mock_models.is_base_model.return_value = True
-
-    return OmniOpenAIServingSpeech(
-        engine_client=mock_engine_client,
-        models=mock_models,
-        request_logger=mocker.MagicMock(),
-    )
-
-
-class TestDotsTTSServing:
-    def test_dots_tts_prompt_validation(self, dots_tts_server):
-        request = OpenAICreateSpeechRequest(input="Hello", ref_text="Reference transcript")
-        error = dots_tts_server._validate_tts_request(request)
-        assert error is not None
-        assert "ref_text" in error
-
-        request = OpenAICreateSpeechRequest(input="Hello", ref_audio="data:audio/wav;base64,abc")
-        error = dots_tts_server._validate_tts_request(request)
-        assert error is not None
-        assert "ref_audio" in error
-
-        request = OpenAICreateSpeechRequest(input="Hello", voice="test")
-        error = dots_tts_server._validate_tts_request(request)
-        assert error is not None
-        assert "voice" in error
-
-        request = OpenAICreateSpeechRequest(input="Hello", speaker_embedding=[1, 2, 3])
-        error = dots_tts_server._validate_tts_request(request)
-        assert error is not None
-        assert "speaker_embedding" in error
-
-        request = OpenAICreateSpeechRequest(input="Hello", x_vector_only_mode=True)
-        error = dots_tts_server._validate_tts_request(request)
-        assert error is not None
-        assert "x_vector_only_mode" in error
-
-    def test_dots_tts_adapter_awaits_async_prompt_builder(self, dots_tts_server, mocker: MockerFixture):
-        build_prompt_async = mocker.patch.object(
-            dots_tts_server._adapter,
-            "_build_prompt_async",
-            new=mocker.AsyncMock(return_value={"prompt_token_ids": [1, 2, 3]}),
-        )
-        request = OpenAICreateSpeechRequest(input="Hello")
-        asyncio.run(dots_tts_server._prepare_speech_generation(request))
-        build_prompt_async.assert_awaited_once_with("Hello")
-
-    def test_dots_tts_adapter_apply_sampling_overrides(self, dots_tts_server, mocker: MockerFixture):
-        mocker.patch.object(dots_tts_server._adapter, "build", return_value=PreparedRequest(prompt="Hello"))
-        request = OpenAICreateSpeechRequest(input="Hello", max_new_tokens=10)
-        asyncio.run(dots_tts_server._prepare_speech_generation(request))
-        sampling_params_list = dots_tts_server.engine_client.generate.call_args.kwargs["sampling_params_list"]
-        assert sampling_params_list[0].max_tokens == 10
-
-
 class TestTTSAsyncOffloading:
     """Tests for event-loop-safe offloading of blocking TTS operations."""
 
@@ -5212,6 +5211,52 @@ class TestTTSAsyncOffloading:
             for call in log_info.call_args_list
         )
 
+    @pytest.mark.parametrize("word_timestamps", [False, True])
+    def test_streaming_timestamps_retain_complete_audio(self, qwen3_tts_server, mocker, word_timestamps):
+        from vllm import SamplingParams
+        from vllm.sampling_params import RequestOutputKind
+
+        defaults = [SamplingParams(), SamplingParams()]
+        qwen3_tts_server.engine_client.default_sampling_params_list = defaults
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter._build_tts_params = mocker.MagicMock(
+            return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
+        )
+        qwen3_tts_server._adapter._estimate_prompt_len_async = mocker.AsyncMock(return_value=512)
+        request = OpenAICreateSpeechRequest(
+            input="hello", stream=True, response_format="pcm", word_timestamps=word_timestamps
+        )
+        asyncio.run(qwen3_tts_server._prepare_speech_generation(request))
+
+        params = qwen3_tts_server.engine_client.generate.call_args.kwargs["sampling_params_list"]
+        expected = RequestOutputKind.CUMULATIVE if word_timestamps else RequestOutputKind.DELTA
+        assert all(sp.output_kind == expected for sp in params)
+        assert all(sp.output_kind == RequestOutputKind.CUMULATIVE for sp in defaults)
+        assert all(sp is not original for sp, original in zip(params, defaults))
+
+    @pytest.mark.asyncio
+    async def test_cumulative_timestamp_audio_emits_each_sample_once(self, qwen3_tts_server):
+        audio = torch.linspace(-0.5, 0.5, 2400)
+
+        async def cumulative_generator():
+            for end in (800, 1600, 2400, 2400):
+                yield OmniRequestOutput(
+                    request_id="req-cumulative",
+                    final_output_type="audio",
+                    _multimodal_output={"audio": audio[:end], "sr": 24000},
+                )
+
+        chunks = [
+            chunk
+            async for chunk in qwen3_tts_server._generate_pcm_chunks(
+                cumulative_generator(), "req-cumulative", cumulative_audio=True
+            )
+        ]
+        assert len(chunks) == 3
+        assert len(b"".join(chunks)) == 2400 * 2
+        decoded = np.frombuffer(b"".join(chunks), dtype=np.int16)
+        assert np.all(np.diff(decoded.astype(np.int32)) >= 0)
+
     def test_prepare_speech_generation_treats_sse_as_streaming(self, qwen3_tts_server, mocker: MockerFixture):
         """stream_format=sse should request delta-style multimodal outputs."""
         qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
@@ -5386,7 +5431,7 @@ class TestTTSAsyncOffloading:
         ref_audio = "data:audio/wav;base64,same"
         qwen3_tts_server._put_resolved_ref_audio(
             hashlib.sha1(ref_audio.encode("utf-8")).hexdigest(),
-            wav_list,
+            np.asarray(wav_list, dtype=np.float32),
             24000,
             artifact_key,
         )
@@ -5422,9 +5467,9 @@ class TestTTSAsyncOffloading:
         qwen3_tts_server._ref_audio_resolve_cache_max_entries = 1
         qwen3_tts_server._ref_audio_resolve_cache_max_bytes = 1_000_000
 
-        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", np.zeros(8, dtype=np.float32), 24000, "artifact-a")
         qwen3_tts_server._ref_audio_model_artifact_ready.add(("artifact-a", False))
-        qwen3_tts_server._put_resolved_ref_audio("ref-b", [0.0] * 8, 24000, "artifact-b")
+        qwen3_tts_server._put_resolved_ref_audio("ref-b", np.zeros(8, dtype=np.float32), 24000, "artifact-b")
 
         assert ("artifact-a", False) not in qwen3_tts_server._ref_audio_model_artifact_ready
         assert "artifact-b" in {entry[3] for entry in qwen3_tts_server._ref_audio_resolve_cache.values()}
@@ -5671,7 +5716,7 @@ class TestTTSAsyncOffloading:
     def test_qwen3_xvector_ready_artifact_does_not_enable_icl_artifact_only(self, qwen3_tts_server):
         # An x-vector-only artifact (speaker embedding, no ref_code) must not enable
         # the artifact-only path for a later ICL request with the same ref_audio (#5049).
-        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", np.zeros(8, dtype=np.float32), 24000, "artifact-a")
         qwen3_tts_server._track_ref_audio_artifact_warmup("req-xvec", "artifact-a", x_vector_only=True)
         qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-xvec")
 
@@ -5679,7 +5724,7 @@ class TestTTSAsyncOffloading:
         assert qwen3_tts_server._adapter._qwen3_tts_can_use_ref_audio_artifact_only(icl_params, "artifact-a") is False
 
     def test_qwen3_xvector_ready_artifact_still_reusable_by_xvector_request(self, qwen3_tts_server):
-        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", np.zeros(8, dtype=np.float32), 24000, "artifact-a")
         qwen3_tts_server._track_ref_audio_artifact_warmup("req-xvec", "artifact-a", x_vector_only=True)
         qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-xvec")
 
@@ -5687,7 +5732,7 @@ class TestTTSAsyncOffloading:
         assert qwen3_tts_server._adapter._qwen3_tts_can_use_ref_audio_artifact_only(xvec_params, "artifact-a") is True
 
     def test_qwen3_icl_ready_artifact_enables_icl_artifact_only(self, qwen3_tts_server):
-        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", np.zeros(8, dtype=np.float32), 24000, "artifact-a")
         qwen3_tts_server._track_ref_audio_artifact_warmup("req-icl", "artifact-a", x_vector_only=False)
         qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-icl")
 
diff --git a/tests/entrypoints/openai_api/test_serving_speech_stream.py b/tests/entrypoints/openai_api/test_serving_speech_stream.py
index 39c9e66d9..1d34b6e0b 100644
--- a/tests/entrypoints/openai_api/test_serving_speech_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_speech_stream.py
@@ -56,6 +56,7 @@ def _build_test_app(
             include_sample_rate=False,
             tts_params=None,
             collect=None,
+            cumulative_audio=False,
         ):
             for chunk in (b"\x01\x02", b"\x03\x04\x05"):
                 yield (chunk, 24000) if include_sample_rate else chunk
@@ -386,9 +387,11 @@ class TestStreamingSpeechWebSocket:
             include_sample_rate=False,
             tts_params=None,
             collect=None,
+            cumulative_audio=False,
         ):
             assert request_start_s is not None
             assert request_arrival_ts is not None
+            assert cumulative_audio is True
             for chunk in (first_chunk, second_chunk):
                 yield (chunk, 1000) if include_sample_rate else chunk
             if collect is not None:
@@ -480,6 +483,7 @@ class TestStreamingSpeechWebSocket:
             include_sample_rate=False,
             tts_params=None,
             collect=None,
+            cumulative_audio=False,
         ):
             chunk = b"\x01" * 1000
             yield (chunk, 1000) if include_sample_rate else chunk
diff --git a/tests/entrypoints/openai_api/test_serving_video_output_stream.py b/tests/entrypoints/openai_api/test_serving_video_output_stream.py
index 291eada75..d8eccb6e4 100644
--- a/tests/entrypoints/openai_api/test_serving_video_output_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_video_output_stream.py
@@ -959,6 +959,76 @@ class TestStreamingVideoOutputPromptUpdate:
             },
         )
 
+    def test_composite_prompt_and_camera_interaction_forwarded(self, mocker: MockerFixture):
+        """Prompt + camera multi_modal_data is admitted and forwarded to the engine."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+
+        camera_payload = {
+            "mode": "target",
+            "data": {"translation": [0.0, 0.0, 1.0]},
+        }
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial scene"})
+                start = ws.receive_json()
+                assert start["type"] == "video.start"
+                request_id = start["request_id"]
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json(
+                    {
+                        "type": "session.interaction",
+                        "interaction": {
+                            "event_id": "combo-1",
+                            "event": {
+                                "prompt": "new scene",
+                                "multi_modal_data": {"camera": camera_payload},
+                            },
+                            "transition_chunks": 2,
+                        },
+                    }
+                )
+                queued = ws.receive_json()
+                assert queued["type"] == "session.interaction.queued"
+                assert queued["event_id"] == "combo-1"
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                assert ws.receive_json()["type"] == "session.done"
+
+        engine_client.submit_interaction_async.assert_awaited_once_with(
+            request_id,
+            interaction={
+                "event_id": "combo-1",
+                "event": {
+                    "prompt": "new scene",
+                    "multi_modal_data": {"camera": camera_payload},
+                },
+                "transition_chunks": 2,
+            },
+        )
+
 
 class TestStreamingVideoOutputExtraParams:
     """extra_params handling when building streaming generation inputs."""
diff --git a/tests/entrypoints/openai_api/test_tts_adapter.py b/tests/entrypoints/openai_api/test_tts_adapter.py
index e0a165a55..22aab89ac 100644
--- a/tests/entrypoints/openai_api/test_tts_adapter.py
+++ b/tests/entrypoints/openai_api/test_tts_adapter.py
@@ -22,6 +22,7 @@ from vllm_omni.entrypoints.openai.tts_adapters import (
     detect_tts_model_type,
     resolve_adapter,
 )
+from vllm_omni.entrypoints.openai.tts_adapters.base import resolve_stage_model_path
 from vllm_omni.entrypoints.openai.tts_adapters.covo_audio import CovoAudioAdapter
 from vllm_omni.entrypoints.openai.tts_adapters.higgs_audio_v2 import HiggsAudioV2Adapter
 from vllm_omni.entrypoints.openai.tts_adapters.indextts2 import (
@@ -70,7 +71,6 @@ EXPECTED_MODEL_TYPES = {
     "indextts2",
     "indextts2_5",
     "gepard",
-    "dots_tts",
 }
 
 
@@ -99,6 +99,31 @@ def test_resolve_unknown_returns_none():
     assert resolve_adapter(None) is None
 
 
+def test_stage_model_path_prefers_typed_override():
+    engine_client = SimpleNamespace(
+        stage_configs=[
+            SimpleNamespace(engine_args=SimpleNamespace(model="legacy-stage-model")),
+            SimpleNamespace(
+                model_config=SimpleNamespace(model="typed-stage-model"),
+            ),
+        ],
+        model="served-model",
+    )
+
+    assert resolve_stage_model_path(engine_client) == "typed-stage-model"
+
+
+def test_stage_model_path_falls_back_to_legacy_then_served_model():
+    legacy_client = SimpleNamespace(
+        stage_configs=[SimpleNamespace(engine_args=SimpleNamespace(model="legacy-stage-model"))],
+        model="served-model",
+    )
+    served_client = SimpleNamespace(stage_configs=[SimpleNamespace()], model="served-model")
+
+    assert resolve_stage_model_path(legacy_client) == "legacy-stage-model"
+    assert resolve_stage_model_path(served_client) == "served-model"
+
+
 def test_voxcpm2_resolves():
     """VoxCPM2 (the served ``latent_generator`` model) resolves cleanly.
 
@@ -229,6 +254,115 @@ def test_moss_reference_transcript_mode(variant, ref_text, mode, mocker):
     assert request.input == "Target."
 
 
+def _moss_adapter_with_stage_configs(stage_configs, mocker):
+    engine_client = SimpleNamespace(
+        model_config=SimpleNamespace(model="OpenMOSS-Team/MOSS-TTS-Local-Transformer-v1.5"),
+        stage_configs=stage_configs,
+    )
+    return MossTTSAdapter(SpeechServingContext(server=mocker.Mock(), engine_client=engine_client))
+
+
+def _moss_cuda_available(mocker, device_count=8):
+    mocker.patch("torch.cuda.is_available", return_value=True)
+    mocker.patch("torch.accelerator.device_count", return_value=device_count)
+
+
+@pytest.mark.parametrize(
+    "stage_configs,expected",
+    [
+        # Follows the code2wav stage's first device.
+        (
+            [
+                SimpleNamespace(model_stage="moss_tts_local", runtime_config=SimpleNamespace(devices="0")),
+                SimpleNamespace(model_stage="moss_tts_local_codec", runtime_config=SimpleNamespace(devices="3")),
+            ],
+            "cuda:3",
+        ),
+        # No codec-named stage: anchors on the last stage of the pipeline.
+        (
+            [
+                SimpleNamespace(model_stage="talker", runtime_config=SimpleNamespace(devices="1")),
+                SimpleNamespace(model_stage="decoder", runtime_config=SimpleNamespace(devices="2")),
+            ],
+            "cuda:2",
+        ),
+        # Multi-device codec stage pins replica 0 on the first device.
+        (
+            [
+                SimpleNamespace(model_stage="moss_tts_local_codec", runtime_config=SimpleNamespace(devices="5,6")),
+            ],
+            "cuda:5",
+        ),
+        # No explicit pinning anywhere: stage worker defaults to cuda:0.
+        (
+            [SimpleNamespace(model_stage="moss_tts_local_codec", runtime_config=SimpleNamespace(devices=None))],
+            "cuda:0",
+        ),
+    ],
+)
+def test_moss_ref_encoder_device_follows_codec_stage(stage_configs, expected, mocker):
+    import torch
+
+    _moss_cuda_available(mocker)
+    adapter = _moss_adapter_with_stage_configs(stage_configs, mocker)
+    assert adapter._resolve_ref_encoder_device() == torch.device(expected)
+
+
+def test_moss_ref_encoder_device_accepts_dict_runtime(mocker):
+    import torch
+
+    _moss_cuda_available(mocker)
+    adapter = _moss_adapter_with_stage_configs(
+        [SimpleNamespace(model_stage="moss_tts_local_codec", runtime={"devices": "2"})],
+        mocker,
+    )
+    assert adapter._resolve_ref_encoder_device() == torch.device("cuda:2")
+
+
+def test_moss_ref_encoder_device_cpu_when_cuda_unavailable(mocker):
+    import torch
+
+    mocker.patch("torch.cuda.is_available", return_value=False)
+    adapter = _moss_adapter_with_stage_configs(
+        [SimpleNamespace(model_stage="moss_tts_local_codec", runtime_config=SimpleNamespace(devices="3"))],
+        mocker,
+    )
+    assert adapter._resolve_ref_encoder_device() == torch.device("cpu")
+
+
+def test_moss_ref_encoder_device_cpu_when_index_out_of_range(mocker):
+    import torch
+
+    _moss_cuda_available(mocker, device_count=2)
+    adapter = _moss_adapter_with_stage_configs(
+        [SimpleNamespace(model_stage="moss_tts_local_codec", runtime_config=SimpleNamespace(devices="5"))],
+        mocker,
+    )
+    assert adapter._resolve_ref_encoder_device() == torch.device("cpu")
+
+
+def test_moss_get_processor_places_audio_tokenizer_on_codec_stage_device(mocker):
+    import torch
+
+    _moss_cuda_available(mocker)
+    adapter = _moss_adapter_with_stage_configs(
+        [SimpleNamespace(model_stage="moss_tts_local_codec", runtime_config=SimpleNamespace(devices="3"))],
+        mocker,
+    )
+    audio_tokenizer = mocker.Mock()
+    audio_tokenizer.to.return_value = audio_tokenizer
+    processor = SimpleNamespace(audio_tokenizer=audio_tokenizer)
+    from_pretrained = mocker.patch("transformers.AutoProcessor.from_pretrained", return_value=processor)
+
+    assert adapter._get_moss_processor() is processor
+    audio_tokenizer.to.assert_called_once_with(torch.device("cuda", 3))
+    audio_tokenizer.eval.assert_called_once_with()
+    # Lazy cache: no re-load / re-placement on the second call.
+    assert adapter._get_moss_processor() is processor
+    from_pretrained.assert_called_once()
+    audio_tokenizer.to.assert_called_once()
+
+
 def test_qwen3_tts_metadata():
     assert Qwen3TTSAdapter.backend == "ar"
     assert issubclass(Qwen3TTSAdapter, ARTTSAdapter)
diff --git a/tests/entrypoints/openai_api/test_tts_detection.py b/tests/entrypoints/openai_api/test_tts_detection.py
index 90e7e0fee..8ecb137a2 100644
--- a/tests/entrypoints/openai_api/test_tts_detection.py
+++ b/tests/entrypoints/openai_api/test_tts_detection.py
@@ -263,7 +263,6 @@ def test_arch_matching_is_a_fallback_not_an_override():
 
 def test_shared_latent_generator_resolves_by_architecture_priority():
     assert detect_tts_model_type("latent_generator", "VoxCPM2TalkerForConditionalGeneration") == "voxcpm2"
-    assert detect_tts_model_type("latent_generator", "DotsTTSForConditionalGeneration") == "dots_tts"
 
 
 def test_stage_keys_cover_legacy_stage_set():
diff --git a/tests/entrypoints/openai_api/test_video_server.py b/tests/entrypoints/openai_api/test_video_server.py
index 2de5c4056..f0e7b7d53 100644
--- a/tests/entrypoints/openai_api/test_video_server.py
+++ b/tests/entrypoints/openai_api/test_video_server.py
@@ -11,6 +11,7 @@ import json
 import os
 import threading
 import time
+from concurrent.futures import CancelledError as FutureCancelledError
 from contextlib import asynccontextmanager
 from pathlib import Path
 from types import SimpleNamespace
@@ -84,6 +85,7 @@ class FakeAsyncOmni:
         self.model_class_name = "WanPipeline"
         self.captured_prompt = None
         self.captured_reference_video_bytes = None
+        self.captured_latent_edit_source_bytes = {}
         self.captured_control_reference_bytes = {}
         self.captured_sampling_params_list = None
 
@@ -104,6 +106,10 @@ class FakeAsyncOmni:
             and all(isinstance(item, str) for item in reference_videos)
         ):
             self.captured_reference_video_bytes = [Path(item).read_bytes() for item in reference_videos]
+        for field_name in ("source_video", "source_audio"):
+            source_path = prompt.get("multi_modal_data", {}).get(field_name)
+            if isinstance(source_path, str):
+                self.captured_latent_edit_source_bytes[field_name] = Path(source_path).read_bytes()
         num_outputs = sampling_params_list[0].num_outputs_per_prompt
         if sampling_params_list[0].emit_request_lifecycle:
             yield MockVideoResult(
@@ -224,6 +230,10 @@ def test_resolve_diffusion_od_config_prefers_getter_over_attribute():
 
 
 class BlockingVideoHandler:
+    supports_mixed_reference_inputs = False
+    supports_latent_mask_editing = False
+    supported_control_upload_types = frozenset()
+
     def __init__(self):
         self.model_name = "Wan-AI/Wan2.2-T2V-A14B-Diffusers"
         self.stage_configs = None
@@ -243,8 +253,9 @@ class BlockingVideoHandler:
         reference_video=None,
         reference_audio=None,
         on_started=None,
+        latent_edit_input=None,
     ):
-        del request, reference_id, reference_image, reference_video, reference_audio
+        del request, reference_id, reference_image, reference_video, reference_audio, latent_edit_input
         if on_started is not None:
             await on_started()
         self.started.set()
@@ -282,8 +293,9 @@ class CompletingDuringAbortHandler(BlockingVideoHandler):
         reference_video=None,
         reference_audio=None,
         on_started=None,
+        latent_edit_input=None,
     ):
-        del request, reference_image, reference_video, reference_audio
+        del request, reference_image, reference_video, reference_audio, latent_edit_input
         if on_started is not None:
             await on_started()
         self.started.set()
@@ -318,8 +330,9 @@ class SchedulerQueuedVideoHandler(BlockingVideoHandler):
         reference_video=None,
         reference_audio=None,
         on_started=None,
+        latent_edit_input=None,
     ):
-        del request, reference_id, reference_image, reference_video, reference_audio
+        del request, reference_id, reference_image, reference_video, reference_audio, latent_edit_input
         self.started.set()
         try:
             while not self.admit.is_set():
@@ -463,6 +476,7 @@ async def test_server_worker_keeps_engine_alive_until_http_shutdown(monkeypatch)
 @pytest.fixture
 def test_client():
     app = FastAPI()
+    app.state.api_server_count = 1
     app.include_router(router)
     app.state.openai_serving_video = OmniOpenAIServingVideo.for_diffusion(
         diffusion_engine=FakeAsyncOmni(),
@@ -495,6 +509,11 @@ def _make_test_video_bytes(size=(32, 24), num_frames=3) -> bytes:
     return mux_video_audio_bytes(frames, fps=8, video_codec_options={"preset": "ultrafast", "threads": "0"})
 
 
+def _mask_file(value) -> tuple[str, bytes, str]:
+    payload = value if isinstance(value, str) else json.dumps(value)
+    return "mask.json", payload.encode(), "application/json"
+
+
 def test_mux_video_audio_marks_aac_priming_timestamp():
     frames = np.zeros((2, 16, 16, 3), dtype=np.uint8)
     audio = np.zeros((2, 2048), dtype=np.float32)
@@ -1134,6 +1153,251 @@ def test_mixed_reference_capability_uses_model_metadata_when_config_defaults_fal
     assert handler.supports_mixed_reference_inputs
 
 
+def test_typed_stage_drives_video_capability_checks():
+    from vllm_omni.config.config_factory import StageConfigFactory
+    from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
+
+    minimax_stage = StageConfigFactory.create_typed_default_diffusion(
+        "minimax-h3",
+        {"model_class_name": "MiniMaxH3Pipeline"},
+    ).stage_configs[0]
+    minimax_handler = OmniOpenAIServingVideo.for_diffusion(
+        SimpleNamespace(od_config=SimpleNamespace(model_class_name=None)),
+        model_name="minimax-h3",
+        stage_configs=[minimax_stage],
+    )
+    assert minimax_handler.supports_mixed_reference_inputs
+    assert minimax_handler.supports_latent_mask_editing
+    assert get_diffusion_model_metadata("MiniMaxH3ModularPipeline").supports_latent_mask_editing
+
+    cosmos_stage = StageConfigFactory.create_typed_default_diffusion(
+        "cosmos3",
+        {"model_class_name": "Cosmos3OmniDiffusersPipeline"},
+    ).stage_configs[0]
+    cosmos_handler = OmniOpenAIServingVideo.for_diffusion(
+        SimpleNamespace(od_config=SimpleNamespace(model_class_name=None)),
+        model_name="cosmos3",
+        stage_configs=[cosmos_stage],
+    )
+    assert cosmos_handler.supported_control_upload_types == frozenset({"edge", "blur", "depth", "seg", "wsm"})
+    assert not cosmos_handler.supports_latent_mask_editing
+
+
+@pytest.mark.parametrize("endpoint", ["/v1/videos", "/v1/videos/sync"])
+def test_h3_latent_edit_uploads_reach_generation_and_are_cleaned(endpoint, test_client, mocker: MockerFixture):
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.serving_video._encode_video_bytes",
+        return_value=b"fake-video",
+    )
+    engine = test_client.app.state.openai_serving_video._engine_client
+    engine.model_class_name = "MiniMaxH3Pipeline"
+    video_mask = [[[0.0, 1.0], [0.5, 1.0]]]
+    audio_mask = [0.0, 0.25, 1.0]
+
+    response = test_client.post(
+        endpoint,
+        data={"prompt": "Replace only the masked regions."},
+        files=[
+            ("source_video", ("source.mov", b"source-video", "video/quicktime")),
+            ("source_audio", ("source.mp3", b"source-audio", "audio/mpeg")),
+            ("video_noise_mask", _mask_file(video_mask)),
+            ("audio_noise_mask", _mask_file(audio_mask)),
+        ],
+    )
+
+    assert response.status_code == 200
+    if not endpoint.endswith("/sync"):
+        _wait_for_status(test_client, response.json()["id"], VideoGenerationStatus.COMPLETED.value)
+
+    multi_modal_data = engine.captured_prompt["multi_modal_data"]
+    assert engine.captured_latent_edit_source_bytes == {
+        "source_video": b"source-video",
+        "source_audio": b"source-audio",
+    }
+    assert multi_modal_data["video_noise_mask"] == video_mask
+    assert multi_modal_data["audio_noise_mask"] == audio_mask
+    _wait_until(
+        lambda: (
+            not Path(multi_modal_data["source_video"]).exists() and not Path(multi_modal_data["source_audio"]).exists()
+        )
+    )
+    assert not Path(multi_modal_data["source_video"]).exists()
+    assert not Path(multi_modal_data["source_audio"]).exists()
+
+
+def test_latent_edit_fields_are_rejected_for_models_without_capability(test_client):
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "edit"},
+        files=[
+            ("source_video", ("source.mp4", b"video", "video/mp4")),
+            ("video_noise_mask", _mask_file("1")),
+        ],
+    )
+
+    assert response.status_code == 400
+    assert "not supported" in response.json()["detail"].lower()
+
+
+@pytest.mark.parametrize(
+    ("files", "message"),
+    [
+        (
+            [("source_video", ("source.mp4", b"video", "video/mp4"))],
+            "at least one",
+        ),
+        (
+            [
+                ("source_audio", ("source.wav", b"audio", "audio/wav")),
+                ("video_noise_mask", _mask_file("0")),
+            ],
+            "source_audio requires an audio_noise_mask",
+        ),
+    ],
+)
+def test_h3_latent_edit_cross_field_validation(test_client, files, message):
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+
+    response = test_client.post("/v1/videos/sync", data={"prompt": "edit"}, files=files)
+
+    assert response.status_code == 400
+    assert message in response.json()["detail"]
+
+
+@pytest.mark.parametrize(
+    ("field_name", "filename", "content_type", "message"),
+    [
+        ("source_video", "source.webm", "video/webm", "MP4 or MOV"),
+        ("source_audio", "source.flac", "audio/flac", "WAV or MP3"),
+    ],
+)
+def test_h3_latent_edit_rejects_unsupported_source_formats(
+    test_client,
+    field_name,
+    filename,
+    content_type,
+    message,
+):
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    mask_name = "video_noise_mask" if field_name == "source_video" else "audio_noise_mask"
+
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "edit"},
+        files=[
+            (field_name, (filename, b"source", content_type)),
+            (mask_name, _mask_file("0")),
+        ],
+    )
+
+    assert response.status_code == 400
+    assert message in response.json()["detail"]
+
+
+@pytest.mark.parametrize(
+    ("mask", "message"),
+    [
+        ("[not-json", "Invalid JSON"),
+        ("[" * 2000 + "0" + "]" * 2000, "nested too deeply"),
+        ("[" * 65 + "0" + "]" * 65, "nested too deeply"),
+    ],
+)
+def test_h3_latent_edit_rejects_malformed_mask_json(test_client, mask, message):
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "edit"},
+        files=[
+            ("source_video", ("source.mp4", b"video", "video/mp4")),
+            ("video_noise_mask", _mask_file(mask)),
+        ],
+    )
+
+    assert response.status_code == 400
+    assert message in response.json()["detail"]
+
+
+def test_h3_latent_edit_rejects_mask_text_form_fields(test_client):
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "edit", "video_noise_mask": "0"},
+    )
+
+    assert response.status_code == 422
+
+
+def test_h3_latent_edit_masks_without_sources_are_forwarded_to_stage0(test_client, mocker: MockerFixture):
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.serving_video._encode_video_bytes",
+        return_value=b"fake-video",
+    )
+    engine = test_client.app.state.openai_serving_video._engine_client
+    engine.model_class_name = "MiniMaxH3Pipeline"
+
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "ordinary generation"},
+        files=[
+            ("video_noise_mask", _mask_file("1")),
+            ("audio_noise_mask", _mask_file("[1, 1]")),
+        ],
+    )
+
+    assert response.status_code == 200
+    assert engine.captured_prompt["multi_modal_data"]["video_noise_mask"] == 1
+    assert engine.captured_prompt["multi_modal_data"]["audio_noise_mask"] == [1, 1]
+
+
+def test_h3_latent_edit_rejects_oversized_mask_json(test_client, monkeypatch):
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    monkeypatch.setattr(video_generation_helpers, "LATENT_EDIT_MASK_FILE_MAX_BYTES", 4)
+
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "edit"},
+        files=[
+            ("source_video", ("source.mp4", b"video", "video/mp4")),
+            ("video_noise_mask", _mask_file("[0.0]")),
+        ],
+    )
+
+    assert response.status_code == 400
+    assert "JSON exceeds" in response.json()["detail"]
+
+
+def test_cancelled_latent_edit_persistence_cleans_prior_source(test_client, monkeypatch):
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    persist = video_generation_helpers._persist_latent_edit_source
+    persisted_paths: list[str] = []
+
+    async def persist_then_cancel(upload, *, field_name):
+        if field_name == "source_audio":
+            raise asyncio.CancelledError
+        path = await persist(upload, field_name=field_name)
+        persisted_paths.append(path)
+        return path
+
+    monkeypatch.setattr(video_generation_helpers, "_persist_latent_edit_source", persist_then_cancel)
+
+    with pytest.raises(FutureCancelledError):
+        test_client.post(
+            "/v1/videos/sync",
+            data={"prompt": "edit"},
+            files=[
+                ("source_video", ("source.mp4", b"source-video", "video/mp4")),
+                ("source_audio", ("source.wav", b"source-audio", "audio/wav")),
+                ("video_noise_mask", _mask_file("0")),
+                ("audio_noise_mask", _mask_file("0")),
+            ],
+        )
+
+    assert len(persisted_paths) == 1
+    assert not Path(persisted_paths[0]).exists()
+
+
 @pytest.mark.parametrize("model_class_name", ["Cosmos3OmniDiffusersPipeline", "Cosmos3OmniPipeline"])
 def test_control_upload_capability_is_declared_only_by_cosmos3(test_client, model_class_name):
     handler = test_client.app.state.openai_serving_video
@@ -1191,6 +1455,35 @@ def test_cosmos3_reference_video_limit_uses_v2v_condition_frames():
     assert spec.keep == "first"
 
 
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+@pytest.mark.parametrize(
+    ("num_frames", "extra_params", "expected"),
+    [
+        (189, {"condition_frame_indexes_vision": [0, 2], "condition_video_keep": "last"}, (9, "last")),
+        (189, {"condition_frame_indexes_vision": [0, 2]}, (9, "first")),
+        (5, {"condition_frame_indexes_vision": [0, 20]}, (5, "first")),
+        (None, {"action_mode": "inverse_dynamics", "action_chunk_size": 16}, (17, "first")),
+    ],
+)
+def test_cosmos3_reference_video_decode_policy_with_runtime_configs(typed, num_frames, extra_params, expected):
+    from vllm_omni.config.config_factory import StageConfigFactory
+
+    if typed:
+        stages = list(
+            StageConfigFactory.create_typed_default_diffusion(
+                "cosmos3",
+                {"model_class_name": "Cosmos3OmniDiffusersPipeline"},
+            ).stage_configs
+        )
+    else:
+        stages = _cosmos3_stage_configs()
+    request = VideoGenerationRequest(prompt="Continue this motion.", num_frames=num_frames, extra_params=extra_params)
+
+    spec = _reference_video_decode_spec(request, stages)
+
+    assert (spec.max_frames, spec.keep) == expected
+
+
 def test_cosmos3_reference_video_limit_preserves_action_frames():
     request = VideoGenerationRequest(
         prompt="Predict the action.",
@@ -1749,6 +2042,7 @@ def test_action_extraction_accepts_multimodal_actions_payload():
 
 def test_missing_handler_returns_503():
     app = FastAPI()
+    app.state.api_server_count = 1
     app.include_router(router)
     app.state.openai_serving_video = None
     client = TestClient(app)
@@ -1973,6 +2267,33 @@ def test_failed_generation_awaits_storage_cleanup(test_client, isolated_video_ba
     delete_spy.assert_called_once_with(video_id)
 
 
+def test_failed_async_latent_edit_cleans_source_upload(test_client, mocker: MockerFixture):
+    handler = test_client.app.state.openai_serving_video
+    handler._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    captured_path: list[str] = []
+
+    async def fail_generation(*_args, latent_edit_input=None, **_kwargs):
+        assert latent_edit_input is not None
+        captured_path.append(latent_edit_input.source_video)
+        assert Path(latent_edit_input.source_video).read_bytes() == b"source-video"
+        raise RuntimeError("edit failed")
+
+    mocker.patch.object(handler, "generate_video_bytes", side_effect=fail_generation)
+    response = test_client.post(
+        "/v1/videos",
+        data={"prompt": "will fail"},
+        files=[
+            ("source_video", ("source.mp4", b"source-video", "video/mp4")),
+            ("video_noise_mask", _mask_file("0")),
+        ],
+    )
+    assert response.status_code == 200
+
+    _wait_for_status(test_client, response.json()["id"], VideoGenerationStatus.FAILED.value)
+    assert len(captured_path) == 1
+    _wait_until(lambda: not Path(captured_path[0]).exists())
+
+
 def test_async_guardrail_error_returns_400_on_retrieve(test_client, mocker: MockerFixture):
     mocker.patch.object(
         OmniOpenAIServingVideo,
@@ -2735,6 +3056,7 @@ def test_cosmos3_control_upload_rejects_invalid_size(control_bytes, message, tes
 
 def test_sync_missing_handler_returns_503():
     app = FastAPI()
+    app.state.api_server_count = 1
     app.include_router(router)
     app.state.openai_serving_video = None
     client = TestClient(app)
diff --git a/tests/entrypoints/test_async_omni_diffusion_config.py b/tests/entrypoints/test_async_omni_diffusion_config.py
index 3b378930a..1d106932d 100644
--- a/tests/entrypoints/test_async_omni_diffusion_config.py
+++ b/tests/entrypoints/test_async_omni_diffusion_config.py
@@ -2,13 +2,15 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from types import SimpleNamespace
+from typing import Any
 
 import pytest
 import torch
 from pydantic import ValidationError
 
 from vllm_omni.config.config_factory import StageConfigFactory
-from vllm_omni.config.resolver import OmniConfigResolution
+from vllm_omni.config.omni_config import VllmOmniDiffusionStageConfig, extract_diffusion_stage_config_kwargs
+from vllm_omni.config.resolver import OmniConfigResolution, resolve_omni_config
 from vllm_omni.diffusion.data import AttentionConfig, OmniDiffusionConfig
 from vllm_omni.engine import stage_init_utils
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
@@ -19,7 +21,8 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
 def _terminal_config(stage_cfg: dict) -> OmniDiffusionConfig:
-    return OmniDiffusionConfig.from_kwargs(**stage_cfg["engine_args"])
+    kwargs = extract_diffusion_stage_config_kwargs(stage_cfg["engine_args"], stage_id=stage_cfg["stage_id"])
+    return OmniDiffusionConfig.from_kwargs(**kwargs)
 
 
 def test_default_stage_config_includes_cache_backend():
@@ -30,6 +33,9 @@ def test_default_stage_config_includes_cache_backend():
             "cache_config": '{"Fn_compute_blocks": 2}',
             "vae_use_slicing": True,
             "ulysses_degree": 2,
+            "seed": 7,
+            "kv_cache_dtype": "fp8",
+            "diffusion_kv_cache_dtype": "fp8_e4m3",
         }
     )[0]
 
@@ -40,6 +46,9 @@ def test_default_stage_config_includes_cache_backend():
     assert engine_args["vae_use_slicing"] is True
     assert engine_args["parallel_config"]["ulysses_degree"] == 2
     assert engine_args["model_stage"] == "diffusion"
+    assert "seed" not in engine_args
+    assert "kv_cache_dtype" not in engine_args
+    assert engine_args["diffusion_kv_cache_dtype"] == "fp8_e4m3"
 
 
 def test_default_stage_config_preserves_ulysses_a2a_permute() -> None:
@@ -117,7 +126,7 @@ def test_stage_override_preserves_model_extras_for_default_diffusion_stage(mocke
         trust_remote_code=False,
     )
 
-    assert stage_configs[0]["engine_args"]["extras"]["ltx2_use_conv_vae"] is True
+    assert stage_configs[0].diffusion_config.extras["ltx2_use_conv_vae"] is True
 
 
 def test_default_stage_rejects_unknown_nested_parallel_config_key():
@@ -128,6 +137,67 @@ def test_default_stage_rejects_unknown_nested_parallel_config_key():
         )
 
 
+def test_default_stage_routes_ar_profiler_away_before_diffusion_build(mocker):
+    stage_dict = StageConfigFactory.create_default_diffusion({"enable_ar_profiler": True})[0]
+    assert "enable_ar_profiler" not in stage_dict["engine_args"]
+
+
+@pytest.mark.parametrize(
+    ("field_name", "value"),
+    [
+        ("enable_sleep_mod", None),
+        ("enable_lora", True),
+        ("kv_cache_dtype", "fp8"),
+        ("seed", 7),
+    ],
+)
+def test_legacy_diffusion_stage_rejects_unowned_field(field_name, value):
+    from vllm_omni.config.config_factory import StageConfigFactory
+    from vllm_omni.config.yaml_util import create_config
+    from vllm_omni.engine.stage_init_utils import build_diffusion_config
+
+    stage_dict = StageConfigFactory.create_default_diffusion({"model": "unused"})[0]
+    stage_dict["engine_args"][field_name] = value
+    stage_cfg = create_config(stage_dict)
+    metadata = SimpleNamespace(stage_id=0, cfg_kv_collect_func=None)
+
+    with pytest.raises(ValueError, match=rf"stage 0.*{field_name}"):
+        build_diffusion_config("unused", stage_cfg, metadata)
+
+
+@pytest.mark.parametrize(
+    ("field_name", "value"),
+    [
+        ("enable_sleep_mod", None),
+        ("enable_lora", True),
+    ],
+)
+def test_default_diffusion_factory_rejects_unowned_field(field_name, value):
+    with pytest.raises(ValueError, match=rf"stage 0.*{field_name}"):
+        StageConfigFactory.create_default_diffusion({field_name: value})
+
+
+def test_legacy_default_stage_build_accepts_engine_adapter_metadata(monkeypatch):
+    from vllm_omni.config.config_factory import StageConfigFactory
+    from vllm_omni.config.yaml_util import create_config
+    from vllm_omni.engine import stage_init_utils
+
+    stage_dict = StageConfigFactory.create_default_diffusion(
+        {
+            "model": "unused",
+            "api_key": "frontend-owned",
+        }
+    )[0]
+    assert "api_key" not in stage_dict["engine_args"]
+    stage_cfg = create_config(stage_dict)
+    metadata = SimpleNamespace(stage_id=0, cfg_kv_collect_func=None, default_sampling_params=None)
+    monkeypatch.setattr(stage_init_utils.current_omni_platform, "get_device_count", lambda: 1)
+
+    config = stage_init_utils.build_diffusion_config("unused", stage_cfg, metadata)
+
+    assert config.model == "unused"
+
+
 def test_default_cache_config_used_when_missing():
     """Ensure default cache_config is synthesized when only backend is given."""
     stage_cfg = StageConfigFactory.create_default_diffusion(
@@ -239,6 +309,33 @@ def test_default_stage_config_includes_default_sampling_params():
     }
 
 
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+@pytest.mark.parametrize("sampling_defaults", [{"0": {"guidance_scale": 7.5}}, '{"0":{"guidance_scale":7.5}}'])
+def test_generic_diffusion_sampling_defaults_remain_overridable(typed, sampling_defaults):
+    from vllm_omni.config.yaml_util import create_config
+    from vllm_omni.entrypoints.omni_base import OmniBase
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    kwargs = {"model_class_name": "QwenImagePipeline", "default_sampling_params": sampling_defaults}
+    if typed:
+        stage = StageConfigFactory.create_typed_default_diffusion("generic-diffusion", kwargs).stage_configs[0]
+        metadata = stage_init_utils.extract_stage_metadata_from_omni_stage_config(stage)
+    else:
+        stage = create_config(StageConfigFactory.create_default_diffusion(kwargs))[0]
+        metadata = stage_init_utils.extract_legacy_stage_metadata(stage)
+    base = OmniBase.__new__(OmniBase)
+    base.engine = SimpleNamespace(num_stages=1, stage_configs=[stage])
+    base.default_sampling_params_list = [metadata.default_sampling_params]
+    base.sampling_constraints_list = base._get_sampling_constraints_list([stage])
+
+    assert base.resolve_sampling_params_list(None)[0].guidance_scale == 7.5
+    requested = OmniDiffusionSamplingParams(guidance_scale=2.0)
+    assert base.resolve_sampling_params_list(requested)[0].guidance_scale == 2.0
+    assert requested.guidance_scale == 2.0
+    assert base.default_sampling_params_list[0].guidance_scale == 7.5
+    assert base.sampling_constraints_list == [{}]
+
+
 def test_default_stage_config_includes_diffusion_attention_backend():
     """Ensure diffusion attention shorthand lands in engine_args.diffusion_attention_config."""
     stage_cfg = StageConfigFactory.create_default_diffusion(
@@ -642,10 +739,11 @@ def test_serve_cli_rejects_invalid_request_batch_max_wait_ms(bad_wait: str):
         )
 
 
-def test_serve_cli_accepts_additional_config():
+@pytest.mark.parametrize("subcommand_dest", ["command", "subparser"])
+def test_serve_cli_accepts_additional_config(subcommand_dest):
     """Ensure diffusion serve CLI exposes additional_config and forwards it to stage config."""
     parser = TrackingArgumentParser()
-    subparsers = parser.add_subparsers(dest="command")
+    subparsers = parser.add_subparsers(dest=subcommand_dest)
     OmniServeCommand().subparser_init(subparsers)
 
     args = parser.parse_args(
@@ -658,7 +756,7 @@ def test_serve_cli_accepts_additional_config():
         ]
     )
 
-    stage_cfg = StageConfigFactory.create_default_diffusion(vars(args))[0]
+    stage_cfg = StageConfigFactory.create_default_diffusion(args.get_explicit_kwargs_dict())[0]
 
     engine_args = stage_cfg["engine_args"]
 
@@ -726,3 +824,124 @@ def test_default_stage_config_includes_quantization_config():
     stage_cfg = StageConfigFactory.create_default_diffusion({"quantization_config": quantization_config})[0]
 
     assert stage_cfg["engine_args"]["quantization_config"] == quantization_config
+
+
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+def test_default_diffusion_factory_preserves_engine_quantization(typed, monkeypatch):
+    monkeypatch.setattr(OmniDiffusionConfig, "_resolve_master_port", lambda _self: 29500)
+    monkeypatch.setattr(OmniDiffusionConfig, "enrich_config", lambda _self: None)
+    kwargs = {"quantization": "fp8"}
+
+    if typed:
+        stage = StageConfigFactory.create_typed_default_diffusion("generic-diffusion", kwargs).stage_configs[0]
+        config = stage.diffusion_config
+        config.enrich_config()
+    else:
+        config = _terminal_config(StageConfigFactory.create_default_diffusion(kwargs)[0])
+
+    assert config.quantization_config is not None
+    assert config.quantization_config.get_name() == "fp8"
+    assert config.quantization_config_is_auto_detected is False
+
+
+@pytest.mark.parametrize("model_class_name", ["HeliosPipeline", "HunyuanVideo15Pipeline"])
+def test_generic_diffusion_uses_canonical_video_output_type(model_class_name):
+    config = StageConfigFactory.create_typed_default_diffusion(
+        "generic-video",
+        {"model_class_name": model_class_name},
+    )
+
+    assert config.stage_configs[0].final_output_type == "video"
+
+
+def test_generic_diffusion_resolves_structured_stage_without_legacy_conversion(mocker):
+    """Generic diffusion reaches runtime as the structured stage itself."""
+    mocker.patch("vllm_omni.config.resolver.StageConfigFactory.create_from_model", return_value=None)
+    mocker.patch(
+        "vllm_omni.config.resolver._resolve_generic_diffusion_model_class",
+        return_value=(True, "FakeDiffusionPipeline"),
+    )
+
+    resolved = resolve_omni_config(
+        "generic-diffusion",
+        trust_remote_code=False,
+        deploy_config_path=None,
+        cli_overrides={
+            "num_gpus": 4,
+            "tensor_parallel_size": 2,
+            "default_sampling_params": '{"0": {"guidance_scale": 7.5}}',
+        },
+        stage_overrides=None,
+        strategy_config_path=None,
+    )
+
+    assert resolved.pipeline_config is not None
+    assert resolved.pipeline_config.model_type == "generic_diffusion"
+    assert len(resolved.stage_configs) == 1
+    stage = resolved.stage_configs[0]
+    assert isinstance(stage, VllmOmniDiffusionStageConfig)
+    assert stage.model_config.model == "generic-diffusion"
+    assert stage.model_config.default_sampling_params == {"guidance_scale": 7.5}
+    assert stage.parallel_config.tensor_parallel_size == 2
+    assert stage.parallel_config.data_parallel_size == 2
+    assert stage.parallel_config.world_size == 4
+    assert stage.runtime_config.devices == "0,1,2,3"
+
+
+def test_generic_diffusion_structured_stage_reaches_standard_startup(mocker):
+    """Standard runtime resolves and starts the typed stage through the real launcher."""
+    from vllm_omni.engine import stage_engine_startup as startup_module
+    from vllm_omni.engine import stage_runtime as runtime_module
+    from vllm_omni.engine.stage_runtime import StageRuntime
+
+    mocker.patch("vllm_omni.config.resolver.StageConfigFactory.create_from_model", return_value=None)
+    mocker.patch(
+        "vllm_omni.config.resolver._resolve_generic_diffusion_model_class",
+        return_value=(True, "FakeDiffusionPipeline"),
+    )
+    resolved = resolve_omni_config(
+        "generic-diffusion",
+        trust_remote_code=False,
+        deploy_config_path=None,
+        cli_overrides={"num_gpus": 1},
+        stage_overrides=None,
+        strategy_config_path=None,
+    )
+    stage = resolved.stage_configs[0]
+    launched: dict[str, Any] = {}
+    client = SimpleNamespace(input_address=None, shutdown=mocker.Mock())
+
+    mocker.patch.object(runtime_module, "prepare_engine_environment")
+    mocker.patch.object(runtime_module, "load_omni_transfer_config_for_model", return_value=None)
+    mocker.patch.object(runtime_module, "get_stage_connector_spec", return_value={})
+    mocker.patch.object(runtime_module, "resolve_omni_kv_config_for_stage", return_value=(None, None, None))
+
+    def _initialize_typed_stage(stage_id, model, stage_config, metadata, **kwargs):
+        launched.update(
+            stage_id=stage_id,
+            model=model,
+            stage_config=stage_config,
+            metadata=metadata,
+            **kwargs,
+        )
+        return client
+
+    mocker.patch.object(startup_module, "initialize_diffusion_stage", side_effect=_initialize_typed_stage)
+
+    runtime = StageRuntime(
+        stage_configs=list(resolved.stage_configs),
+        model="generic-diffusion",
+        config_path="",
+        stage_init_timeout=10,
+        async_chunk=False,
+    )
+    runtime.initialize()
+
+    assert launched["stage_config"] is stage
+    assert isinstance(launched["stage_config"], VllmOmniDiffusionStageConfig)
+    assert launched["metadata"].stage_type == "diffusion"
+    assert launched["metadata"].model_stage == "diffusion"
+    assert launched["use_inline"] is True
+    assert launched["model"] == "generic-diffusion"
+    assert launched["stage_id"] == 0
+    assert runtime.stage_pools[0].clients == [client]
diff --git a/tests/entrypoints/test_omni_entrypoints.py b/tests/entrypoints/test_omni_entrypoints.py
index 32d7d9988..969bbaf91 100644
--- a/tests/entrypoints/test_omni_entrypoints.py
+++ b/tests/entrypoints/test_omni_entrypoints.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import gc
 import queue
 from collections.abc import Callable
@@ -16,6 +17,8 @@ from vllm.entrypoints.openai.models.serving import OpenAIServingModels
 from vllm.sampling_params import RequestOutputKind, SamplingParams
 from vllm.v1.engine.exceptions import EngineDeadError, EngineGenerateError
 
+from vllm_omni.config.omni_config import VllmOmniConfig
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
 from vllm_omni.config.stage_config import StageConfig
 from vllm_omni.engine.async_omni_engine import StageRuntimeInfo
 from vllm_omni.engine.messages import ErrorMessage, OutputMessage
@@ -201,6 +204,49 @@ def _make_base():
     return obj
 
 
+@pytest.mark.parametrize("typed", [False, True], ids=["legacy", "typed"])
+def test_resolve_sampling_params_list_preserves_stage_constraints(typed):
+    from vllm_omni.config.omni_config import VllmOmniARStageConfig
+    from vllm_omni.config.stage_config import StagePipelineConfig
+
+    base = _make_base()
+    base.engine.num_stages = 1
+    base.default_sampling_params_list = [SamplingParams(max_tokens=1000, detokenize=False, stop_token_ids=[42])]
+    if typed:
+        stage = VllmOmniARStageConfig(
+            stage_pipeline_config=StagePipelineConfig(
+                stage_id=0,
+                model_stage="dummy-model",
+                sampling_constraints={"detokenize": False, "stop_token_ids": [42]},
+            )
+        )
+    else:
+        stage = StageConfig(
+            stage_id=0,
+            model_stage="dummy-model",
+            sampling_constraints={"detokenize": False, "stop_token_ids": [42]},
+        ).to_omegaconf()
+    base.engine.stage_configs = [stage]
+    base.sampling_constraints_list = base._get_sampling_constraints_list(base.engine.stage_configs)
+    assert base.sampling_constraints_list == [{"detokenize": False, "stop_token_ids": [42]}]
+
+    resolved_defaults = base.resolve_sampling_params_list(None)
+    assert resolved_defaults[0].stop_token_ids == [42]
+
+    caller_params = SamplingParams(seed=1234, max_tokens=7, detokenize=True, stop_token_ids=[7])
+    resolved = base.resolve_sampling_params_list(caller_params)
+
+    assert resolved[0] is not caller_params
+    assert resolved[0].seed == 1234
+    assert resolved[0].max_tokens == 7
+    assert resolved[0].detokenize is False
+    assert resolved[0].stop_token_ids == [7, 42]
+    assert 7 in resolved[0]._all_stop_token_ids
+    assert 42 in resolved[0]._all_stop_token_ids
+    assert caller_params.detokenize is True
+    assert caller_params.stop_token_ids == [7]
+
+
 def test_resolve_sampling_params_list_merges_required_stop_tokens():
     base = _make_base()
     base.engine.num_stages = 1
@@ -218,22 +264,13 @@ def test_resolve_sampling_params_list_merges_required_stop_tokens():
     base.sampling_constraints_list = base._get_sampling_constraints_list(base.engine.stage_configs)
     assert base.sampling_constraints_list == [{"detokenize": False, "stop_token_ids": required_stop_ids}]
 
-    resolved_defaults = base.resolve_sampling_params_list(None)
 
-    assert resolved_defaults[0].stop_token_ids == [99, 151704, 151645]
+def test_sampling_constraints_are_forwarded_by_typed_stage_configs():
+    config = VllmOmniConfig.from_pipeline_config(OMNI_PIPELINES["qwen3_tts"])
 
-    caller_params = SamplingParams(seed=1234, max_tokens=7, detokenize=True, stop_token_ids=[100, 151704])
+    constraints = OmniBase._get_sampling_constraints_list(config.stage_configs)
 
-    resolved = base.resolve_sampling_params_list(caller_params)
-
-    assert resolved[0] is not caller_params
-    assert resolved[0].seed == 1234
-    assert resolved[0].max_tokens == 7
-    assert resolved[0].detokenize is False
-    assert resolved[0].stop_token_ids == [100, 151704, 151645]
-    assert {100, 151704, 151645}.issubset(resolved[0]._all_stop_token_ids)
-    assert caller_params.detokenize is True
-    assert caller_params.stop_token_ids == [100, 151704]
+    assert constraints == [dict(stage.stage_pipeline_config.sampling_constraints) for stage in config.stage_configs]
 
 
 @pytest.mark.parametrize("use_defaults", [False, True])
@@ -634,6 +671,43 @@ async def test_async_omni_llm_diffusion_yields_text_stream_then_image(monkeypatc
     assert "req-1" not in app.request_states
 
 
+@pytest.mark.asyncio
+async def test_async_omni_abort_yields_terminal_from_requested_final_stage(monkeypatch: pytest.MonkeyPatch):
+    stage_metadata = [
+        _stage_meta(stage_type="llm", final_output=False, final_output_type=None),
+        _stage_meta(stage_type="llm", final_output=True, final_output_type="audio"),
+    ]
+    engine = FakeAsyncOmniEngine(stage_metadata=stage_metadata)
+    _patch_engine(monkeypatch, engine)
+    app = AsyncOmni("dummy-model")
+
+    async def collect_outputs() -> list[OmniRequestOutput]:
+        return [
+            output
+            async for output in app.generate(
+                prompt="hello",
+                request_id="req-1",
+                output_modalities=["audio"],
+            )
+        ]
+
+    try:
+        generate_task = asyncio.create_task(collect_outputs())
+        while not engine.submitted:
+            await asyncio.sleep(0)
+        await app.abort("req-1")
+        outputs = await asyncio.wait_for(generate_task, timeout=1)
+    finally:
+        app.shutdown()
+
+    assert len(outputs) == 1
+    assert outputs[0].stage_id == 1
+    assert outputs[0].final_output_type == "audio"
+    assert outputs[0].finished is True
+    assert outputs[0].outputs[0].finish_reason == "abort"
+    assert "req-1" not in app.request_states
+
+
 @pytest.mark.asyncio
 async def test_async_omni_abort_forwards_to_engine(monkeypatch: pytest.MonkeyPatch):
     engine = FakeAsyncOmniEngine(stage_metadata=THREE_STAGE_META)
diff --git a/tests/entrypoints/test_omni_sleep_mode.py b/tests/entrypoints/test_omni_sleep_mode.py
index 9567cbc96..c4900e9ca 100644
--- a/tests/entrypoints/test_omni_sleep_mode.py
+++ b/tests/entrypoints/test_omni_sleep_mode.py
@@ -18,6 +18,7 @@ import torch
 from vllm import SamplingParams
 
 from tests.helpers.mark import hardware_test
+from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.platforms import current_omni_platform
@@ -98,16 +99,6 @@ MODEL = "ByteDance-Seed/BAGEL-7B-MoT"
 MODEL_DIFF = "riverclouds/qwen_image_random"
 
 
-def get_dynamic_devices(stage_idx: int, num_stages: int, tp_size: int) -> str:
-    total_gpus = torch.accelerator.device_count()
-    gpus_per_stage = tp_size
-    start_idx = stage_idx * gpus_per_stage
-    if start_idx + gpus_per_stage > total_gpus:
-        start_idx = start_idx % total_gpus
-    device_ids = [str(start_idx + i) for i in range(gpus_per_stage)]
-    return ",".join(device_ids)
-
-
 async def _ensure_awake(engine: AsyncOmni, stage_ids: list[int]) -> None:
     """Best-effort full wake + resume so the next shared-engine test starts active."""
     try:
@@ -120,33 +111,28 @@ async def _ensure_awake(engine: AsyncOmni, stage_ids: list[int]) -> None:
         logger.warning("ensure_resume failed (stage_ids=%s): %s", stage_ids, e)
 
 
-def _build_llm_stages() -> tuple[list[dict], list[dict]]:
-    common_args = {
-        "worker_type": "ar",
-        "enable_sleep_mode": True,
-        "dtype": "bfloat16",
-        "trust_remote_code": True,
-        "max_model_len": 2048,
-        "max_num_batched_tokens": 8192,
-        "enforce_eager": True,
-    }
-    stages = [
-        {
-            "stage_id": 0,
-            "stage_type": "llm",
-            "runtime": {"process": True, "devices": "0", "max_batch_size": 1},
-            "engine_args": {**common_args, "model_stage": "thinker", "gpu_memory_utilization": 0.1},
+def _sleep_deploy_config(*, diffusion_only: bool = False, tp_size: int = 1) -> str:
+    """Use registered BAGEL topology and override only deployment settings."""
+    filename = "bagel_single_stage.yaml" if diffusion_only else "bagel.yaml"
+    stage_ids = (0,) if diffusion_only else (0, 1)
+    return modify_stage_config(
+        get_deploy_config_path(filename),
+        updates={
+            "stages": {
+                stage_id: {
+                    "devices": ",".join(str(stage_id * tp_size + rank) for rank in range(tp_size)),
+                    "tensor_parallel_size": tp_size,
+                    "enable_sleep_mode": True,
+                    "enforce_eager": True,
+                    "dtype": "bfloat16",
+                    # Stages use disjoint GPUs. On an 80 GiB H100, 40% cannot
+                    # fit TP=1 Thinker weights, activation peaks and KV cache.
+                    "gpu_memory_utilization": 0.8 if not diffusion_only and stage_id == 0 else 0.4,
+                }
+                for stage_id in stage_ids
+            }
         },
-        {
-            "stage_id": 1,
-            "stage_type": "llm",
-            "engine_input_source": [0],
-            "runtime": {"process": True, "devices": "1", "max_batch_size": 1, "connector_type": "queue"},
-            "engine_args": {**common_args, "model_stage": "talker", "gpu_memory_utilization": 0.1},
-        },
-    ]
-    connectors = [{"src_stage_id": 0, "dst_stage_id": 1, "connector_type": "queue"}]
-    return stages, connectors
+    )
 
 
 @pytest.fixture(scope="module", autouse=True)
@@ -163,11 +149,10 @@ def _module_device_cleanup():
 
 @pytest_asyncio.fixture(scope="class", loop_scope="class")
 async def llm_engine():
-    """Shared 2-stage BAGEL LLM engine for sleep/wake protocol tests."""
+    """Shared BAGEL Thinker + DiT engine for LLM sleep/wake protocol tests."""
     if current_omni_platform.is_rocm():
         clean_device_envs()
-    stages, connectors = _build_llm_stages()
-    engine = AsyncOmni(model=MODEL, stages=stages, connectors=connectors, init_timeout=600, enable_sleep_mode=True)
+    engine = AsyncOmni(model=MODEL, deploy_config=_sleep_deploy_config(), init_timeout=600, enable_sleep_mode=True)
     yield engine
     engine.shutdown()
     await asyncio.sleep(1.5)
@@ -178,27 +163,12 @@ async def diffusion_engine():
     """Shared BAGEL diffusion TP=2 engine for sleep/wake + generate checks."""
     if current_omni_platform.is_rocm():
         clean_device_envs()
-    stages = [
-        {
-            "stage_id": 0,
-            "stage_type": "diffusion",
-            "runtime": {"process": True, "devices": "0,1", "max_batch_size": 1},
-            "engine_args": {
-                "model_stage": "base",
-                "gpu_memory_utilization": 0.1,
-                "model_class_name": "BagelPipeline",
-                "enable_sleep_mode": True,
-                "enforce_eager": True,
-                "max_num_batched_tokens": 8192,
-                "parallel_config": {
-                    "tensor_parallel_size": 2,
-                },
-            },
-            "final_output": True,
-            "final_output_type": "image",
-        }
-    ]
-    engine = AsyncOmni(model=MODEL, stages=stages, init_timeout=600, enable_sleep_mode=True)
+    engine = AsyncOmni(
+        model=MODEL,
+        deploy_config=_sleep_deploy_config(diffusion_only=True, tp_size=2),
+        init_timeout=600,
+        enable_sleep_mode=True,
+    )
     yield engine
     engine.shutdown()
     await asyncio.sleep(1.5)
@@ -208,7 +178,7 @@ class TestOmniLlmSleepMode:
     """LLM sleep/wake protocol tests sharing one class-scoped engine."""
 
     @pytest.mark.asyncio(loop_scope="class")
-    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=1)
+    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
     async def test_llm_sleep_ack(self, llm_engine: AsyncOmni):
         """LLM Thinker (GPU0) Signal and Physical Recycling Audit"""
         device_id = 0
@@ -333,11 +303,10 @@ class TestOmniDiffusionSleepMode:
             # --- integrity: baseline generate at original resolution/steps ---
             prompt = "A huge swimming pool, with many people swimming."
             sp = OmniDiffusionSamplingParams(num_inference_steps=4, height=512, width=512, seed=42)
-            llm_sp = SamplingParams()
 
             logger.info("Running Baseline Generation...")
             base_output = None
-            async for output in diffusion_engine.generate(prompt, request_id="base", sampling_params_list=[llm_sp, sp]):
+            async for output in diffusion_engine.generate(prompt, request_id="base", sampling_params=sp):
                 base_output = output
             assert base_output is not None and len(base_output.images) > 0
             logger.info("Baseline Generation successful.")
@@ -384,7 +353,7 @@ class TestOmniDiffusionSleepMode:
             # --- integrity + lifecycle: post-wake generate ---
             logger.info("Running Post-Wakeup Generation...")
             post_output = None
-            async for output in diffusion_engine.generate(prompt, request_id="post", sampling_params_list=[llm_sp, sp]):
+            async for output in diffusion_engine.generate(prompt, request_id="post", sampling_params=sp):
                 post_output = output
             assert post_output is not None
             assert len(base_output.images) == len(post_output.images)
@@ -458,41 +427,22 @@ class TestOmniCoordinatedSleepMode:
 @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
 @pytest.mark.asyncio
 async def test_multistage_llm_diffusion_sleep_wake(tp_size: int):
-    """Explicit 2-stage (llm + diffusion) + connectors; sleep/wake both stages."""
+    """Registered BAGEL Thinker + DiT topology; sleep/wake both stages."""
     if current_omni_platform.is_rocm():
         clean_device_envs()
     num_gpus = torch.accelerator.device_count()
     if num_gpus < tp_size * 2:
         pytest.skip("Not enough GPUs")
 
-    stages = []
-    for i in range(2):
-        devs = get_dynamic_devices(i, 2, tp_size)
-        stages.append(
-            {
-                "stage_id": i,
-                "stage_type": "llm" if i == 0 else "diffusion",
-                "runtime": {"process": True, "devices": devs},
-                "engine_args": {
-                    "model": MODEL,
-                    "model_stage": "thinker" if i == 0 else "base",
-                    "tensor_parallel_size": tp_size,
-                    "gpu_memory_utilization": 0.4,
-                    "dtype": "bfloat16",
-                    "enable_sleep_mode": True,
-                    "trust_remote_code": True,
-                },
-            }
-        )
-
-    connectors = [{"src_stage_id": 0, "dst_stage_id": 1, "connector_type": "queue"}]
-
     engine = AsyncOmni(
-        model=MODEL, stages=stages, connectors=connectors, enable_sleep_mode=True, stage_init_timeout=1200
+        model=MODEL,
+        deploy_config=_sleep_deploy_config(tp_size=tp_size),
+        enable_sleep_mode=True,
+        stage_init_timeout=1200,
     )
     try:
         sp = OmniDiffusionSamplingParams(num_inference_steps=2)
-        async for _ in engine.generate("warmup", sampling_params_list=[SamplingParams(), sp]):
+        async for _ in engine.generate("warmup", sampling_params_list=[engine.default_sampling_params_list[0], sp]):
             pass
 
         acks = await engine.sleep(stage_ids=[0, 1], level=1)
@@ -500,7 +450,7 @@ async def test_multistage_llm_diffusion_sleep_wake(tp_size: int):
 
         await engine.wake_up(stage_ids=[0, 1])
         await engine.resume_generation(stage_ids=[0, 1])
-        async for _ in engine.generate("verify", sampling_params_list=[SamplingParams(), sp]):
+        async for _ in engine.generate("verify", sampling_params_list=[engine.default_sampling_params_list[0], sp]):
             pass
     finally:
         engine.shutdown()
diff --git a/tests/entrypoints/test_resolve_dreamzero_config.py b/tests/entrypoints/test_resolve_dreamzero_config.py
index 450e1be39..3cfa0f0e5 100644
--- a/tests/entrypoints/test_resolve_dreamzero_config.py
+++ b/tests/entrypoints/test_resolve_dreamzero_config.py
@@ -32,15 +32,18 @@ def test_dreamzero_resolves_through_registry_with_model_defaults(monkeypatch):
         stage_overrides=None,
         strategy_config_path=None,
     )
-    engine_args = resolved.stage_configs[0].engine_args
+    stage = resolved.stage_configs[0]
 
     assert resolved.config_path is not None
     assert resolved.config_path.endswith("vllm_omni/deploy/dreamzero.yaml")
-    assert engine_args.model_class_name == "DreamZeroPipeline"
-    assert engine_args.model_config.policy_server_config.action_space == "joint_position"
+    assert stage.diffusion_config.model_class_name == "DreamZeroPipeline"
+    assert stage.diffusion_config.model_config["policy_server_config"]["action_space"] == "joint_position"
 
 
 def test_dreamzero_enrich_config_preserves_explicit_model_class_name(monkeypatch):
+    def _get_hf_config(path, _model):
+        return None if path == "model_index.json" else {"model_type": "vla", "architectures": ["VLA"]}
+
     monkeypatch.setattr(
         "vllm.transformers_utils.config.get_hf_file_to_dict",
         lambda path, _model, **_kwargs: (
diff --git a/tests/entrypoints/test_serve.py b/tests/entrypoints/test_serve.py
index 1f3b58170..0f51a4320 100644
--- a/tests/entrypoints/test_serve.py
+++ b/tests/entrypoints/test_serve.py
@@ -6,12 +6,19 @@
 from __future__ import annotations
 
 import argparse
+from dataclasses import dataclass
+from multiprocessing.reduction import ForkingPickler
 from types import SimpleNamespace
+from typing import Any
 
 import pytest
 from pytest_mock import MockerFixture
+from vllm.v1.engine.utils import EngineZmqAddresses
 
+from vllm_omni.config.omni_config import VllmOmniDiffusionStageConfig
 from vllm_omni.config.resolver import OmniConfigResolution
+from vllm_omni.engine.stage_engine_startup import StageReplicaResources
+from vllm_omni.engine.stage_runtime import StageEngineLaunch
 from vllm_omni.entrypoints.cli.serve import (
     OmniServeCommand,
     _parse_stage_overrides,
@@ -23,6 +30,31 @@ from vllm_omni.utils.tracking_parser import TrackingArgumentParser, TrackingName
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+@dataclass(frozen=True)
+class _FakeProcess:
+    sentinel: str
+    exitcode: int | None
+    name: str
+    pid: int
+
+
+@dataclass
+class _FakeProcessOwner:
+    processes: list[_FakeProcess]
+
+
+@dataclass
+class _FakeStageEngineArgs:
+    async_chunk: bool
+    enable_sleep_mode: bool
+
+
+@dataclass
+class _FakeStageConfig:
+    stage_id: int
+    engine_args: _FakeStageEngineArgs
+
+
 def _resolved(*stages: SimpleNamespace) -> OmniConfigResolution:
     return OmniConfigResolution(config_path="/fake/stages.yaml", stage_configs=tuple(stages))
 
@@ -42,6 +74,8 @@ def test_serve_parser_accepts_no_async_chunk_and_marks_it_explicit() -> None:
     explicit = args.get_explicit_kwargs_dict()
     assert args.get_explicit_kwargs_dict()
     assert not explicit["async_chunk"]
+    assert (args.api_server_count or 1) == 1
+    assert "api_server_count" not in explicit
 
 
 def _parse_serve_args(argv: list[str]) -> TrackingNamespace:
@@ -118,6 +152,37 @@ def test_omni_serve_accepts_explicit_model(argv: list[str], mocker: MockerFixtur
     cmd.validate(args)
 
 
+@pytest.mark.parametrize(
+    "model_class,exists,native",
+    [
+        ("AnimaPipeline", True, True),
+        ("AnimaModularPipeline", True, True),
+        ("AnimaPipeline", False, False),
+        ("FluxPipeline", True, False),
+        (None, True, False),
+    ],
+)
+def test_serve_native_checkpoint_validation(model_class, exists, native, tmp_path, mocker):
+    checkpoint = tmp_path / "anima.safetensors"
+    if exists:
+        checkpoint.touch()
+    argv = ["serve", str(checkpoint), "--omni"]
+    if model_class is not None:
+        argv.extend(["--model-class-name", model_class])
+    args = _parse_serve_args(argv)
+    detect_model = mocker.patch("vllm_omni.diffusion.utils.hf_utils.is_diffusion_model", return_value=False)
+    validate_llm = mocker.patch("vllm_omni.entrypoints.cli.serve.validate_parsed_serve_args")
+
+    OmniServeCommand().validate(args)
+
+    if native:
+        detect_model.assert_not_called()
+        validate_llm.assert_not_called()
+    else:
+        detect_model.assert_called_once_with(str(checkpoint))
+        validate_llm.assert_called_once_with(args)
+
+
 def test_serve_parser_accepts_strategy_config() -> None:
     """``--strategy-config`` must parse onto the ``strategy_config`` dest and be
     forwarded as an explicit kwarg so the engine can overlay the strategy."""
@@ -167,6 +232,253 @@ def test_serve_parser_rejects_invalid_video_output_transport(value: str) -> None
         parser.parse_args(["serve", "fake-model", "--omni", "--video-output-transport", value])
 
 
+def test_tracking_namespace_is_picklable_for_spawned_api_workers() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+    args = parser.parse_args(["serve", "fake-model", "--omni", "--api-server-count", "2"])
+    args._omni_stage_client_configs = [{"stage_addresses": {0: {0: {"input_address": "ipc://input"}}}}]
+
+    restored = ForkingPickler.loads(ForkingPickler.dumps(args))
+
+    assert restored.api_server_count == 2
+    assert restored.get_explicit_kwargs_dict()["api_server_count"] == 2
+    assert restored._omni_stage_client_configs == args._omni_stage_client_configs
+
+
+@pytest.mark.parametrize("native_checkpoint", [False, True])
+def test_serve_validate_rejects_multiple_api_servers_for_diffusion(
+    mocker: MockerFixture, tmp_path, native_checkpoint: bool
+) -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    cmd = OmniServeCommand()
+    cmd.subparser_init(subparsers)
+    argv = ["serve", "fake-diffusion-model", "--omni", "--api-server-count", "2"]
+    if native_checkpoint:
+        checkpoint = tmp_path / "anima.safetensors"
+        checkpoint.touch()
+        argv[1] = str(checkpoint)
+        argv.extend(["--model-class-name", "AnimaPipeline"])
+    args = parser.parse_args(argv)
+
+    mocker.patch("vllm_omni.diffusion.utils.hf_utils.is_diffusion_model", return_value=not native_checkpoint)
+    validate = mocker.patch("vllm_omni.entrypoints.cli.serve.validate_parsed_serve_args")
+
+    with pytest.raises(ValueError, match="not supported for diffusion"):
+        cmd.validate(args)
+
+    validate.assert_not_called()
+
+
+def test_serve_validate_rejects_sleep_mode_with_multiple_api_servers(mocker: MockerFixture) -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    cmd = OmniServeCommand()
+    cmd.subparser_init(subparsers)
+    args = parser.parse_args(["serve", "fake-model", "--omni", "--api-server-count", "2", "--enable-sleep-mode"])
+
+    mocker.patch("vllm_omni.diffusion.utils.hf_utils.is_diffusion_model", return_value=False)
+    mocker.patch("vllm_omni.entrypoints.cli.serve.validate_parsed_serve_args")
+
+    with pytest.raises(ValueError, match="enable-sleep-mode"):
+        cmd.validate(args)
+
+
+@pytest.mark.parametrize("typed", [False, True])
+@pytest.mark.parametrize("downstream_async_chunk", [False, True])
+def test_build_multi_api_stage_runtime_matches_current_constructor(
+    mocker: MockerFixture, typed: bool, downstream_async_chunk: bool
+) -> None:
+    from vllm_omni.entrypoints.cli import serve as serve_module
+
+    args = TrackingNamespace(
+        argparse.Namespace(
+            model="dummy-model",
+            model_tag=None,
+            stage_init_timeout=1,
+            tokenizer=None,
+            disable_log_stats=False,
+        ),
+        frozenset({"model"}),
+    )
+    if typed:
+        from vllm_omni.config.omni_config import VllmOmniARStageConfig
+        from vllm_omni.config.stage_config import StagePipelineConfig
+
+        stages = [
+            VllmOmniARStageConfig(stage_pipeline_config=StagePipelineConfig(stage_id=i, model_stage="ar"))
+            for i in range(2)
+        ]
+        stages[1].connector_config.async_chunk = downstream_async_chunk
+    else:
+        stages = [
+            _FakeStageConfig(
+                stage_id=i,
+                engine_args=_FakeStageEngineArgs(
+                    async_chunk=bool(i and downstream_async_chunk), enable_sleep_mode=False
+                ),
+            )
+            for i in range(2)
+        ]
+    mocker.patch("vllm_omni.entrypoints.omni_base.omni_snapshot_download", return_value="dummy-model")
+    mocker.patch(
+        "vllm_omni.config.config_factory.with_trust_remote_code_override",
+        side_effect=lambda kwargs, _trust: kwargs,
+    )
+    mocker.patch("vllm_omni.entrypoints.utils.parse_stage_overrides", return_value={})
+    mocker.patch(
+        "vllm_omni.config.resolver.resolve_omni_config",
+        return_value=OmniConfigResolution(config_path="dummy-config", stage_configs=tuple(stages)),
+    )
+
+    runtime = serve_module._build_multi_api_stage_runtime(args, 2)
+
+    assert runtime._client_count == 1
+    assert runtime._client_index == 0
+    assert runtime._async_chunk is downstream_async_chunk
+
+
+@pytest.mark.parametrize("typed", [False, True])
+def test_build_multi_api_stage_runtime_rejects_sleep_enabled_in_stage_config(
+    mocker: MockerFixture, typed: bool
+) -> None:
+    from vllm_omni.entrypoints.cli import serve as serve_module
+
+    args = TrackingNamespace(
+        argparse.Namespace(
+            model="dummy-model",
+            model_tag=None,
+            stage_init_timeout=1,
+            tokenizer=None,
+            disable_log_stats=False,
+        ),
+        frozenset({"model"}),
+    )
+    stage_config = _FakeStageConfig(
+        stage_id=3,
+        engine_args=_FakeStageEngineArgs(async_chunk=False, enable_sleep_mode=True),
+    )
+    if typed:
+        from vllm_omni.config.omni_config import VllmOmniARStageConfig
+        from vllm_omni.config.stage_config import StagePipelineConfig
+
+        typed_stage = VllmOmniARStageConfig(stage_pipeline_config=StagePipelineConfig(stage_id=3, model_stage="ar"))
+        typed_stage.model_config.enable_sleep_mode = True
+        stage_config = typed_stage
+    mocker.patch("vllm_omni.entrypoints.omni_base.omni_snapshot_download", return_value="dummy-model")
+    mocker.patch(
+        "vllm_omni.config.config_factory.with_trust_remote_code_override",
+        side_effect=lambda kwargs, _trust: kwargs,
+    )
+    mocker.patch("vllm_omni.entrypoints.utils.parse_stage_overrides", return_value={})
+    mocker.patch(
+        "vllm_omni.config.resolver.resolve_omni_config",
+        return_value=OmniConfigResolution(config_path="dummy-config", stage_configs=(stage_config,)),
+    )
+
+    with pytest.raises(ValueError, match=r"sleep mode.*stage\(s\) \[3\]"):
+        serve_module._build_multi_api_stage_runtime(args, 2)
+
+
+def test_run_multi_api_server_omni_starts_workers_after_shared_engine_launch(mocker: MockerFixture) -> None:
+    from vllm_omni.entrypoints.cli import serve as serve_module
+
+    args = TrackingNamespace(
+        argparse.Namespace(api_server_count=2, shutdown_timeout=1),
+        frozenset({"api_server_count", "shutdown_timeout"}),
+    )
+    socket = mocker.Mock()
+    primary_addresses = EngineZmqAddresses(
+        inputs=["ipc://input-0", "ipc://input-1"],
+        outputs=["ipc://output-0", "ipc://output-1"],
+    )
+    engine_launch = StageEngineLaunch(
+        client_configs=[{"client_count": 2, "client_index": index, "stage_addresses": {}} for index in range(2)],
+        resources=[StageReplicaResources(addresses=primary_addresses)],
+    )
+    runtime = mocker.MagicMock()
+    runtime.launch_stage_engines.return_value.__enter__.return_value = engine_launch
+    runtime.launch_stage_engines.return_value.__exit__.return_value = False
+
+    manager = mocker.Mock()
+    manager.processes = [mocker.Mock()]
+    manager.gather_actual_addresses.return_value = (primary_addresses.inputs, primary_addresses.outputs)
+
+    mocker.patch.object(serve_module, "_build_multi_api_stage_runtime", return_value=runtime)
+    mocker.patch.object(serve_module, "_wait_for_multi_api_server_completion")
+    mocker.patch("signal.signal")
+    mocker.patch("vllm.entrypoints.openai.api_server.setup_server", return_value=("127.0.0.1:8000", socket))
+    mocker.patch("vllm.v1.metrics.prometheus.setup_multiprocess_prometheus")
+    start_manager = mocker.patch.object(serve_module, "_start_api_server_process_manager", return_value=manager)
+
+    serve_module.run_multi_api_server_omni(args)
+
+    assert args._omni_stage_client_configs is engine_launch.client_configs
+    start_manager.assert_called_once()
+    manager_kwargs = start_manager.call_args.kwargs
+    assert manager_kwargs["cleanup_timeout"] == 1
+    assert manager_kwargs["num_servers"] == 2
+    assert manager_kwargs["input_addresses"] == ["ipc://input-0", "ipc://input-1"]
+    assert manager_kwargs["target_server_fn"] is serve_module.run_omni_api_server_worker_proc
+    assert engine_launch.watched_frontend_processes == manager.processes
+    runtime.shutdown.assert_called_once_with()
+    socket.close.assert_called_once_with()
+
+
+def test_start_api_server_process_manager_cleans_up_partial_start(mocker: MockerFixture) -> None:
+    from vllm_omni.entrypoints.cli import serve as serve_module
+
+    first_process = mocker.Mock(name="first_process")
+    second_process = mocker.Mock(name="second_process")
+    first_process.pid = 1234
+    second_process.pid = None
+    second_process.start.side_effect = RuntimeError("spawn failed")
+    parent_pipes = [mocker.Mock(name="parent_pipe_0"), mocker.Mock(name="parent_pipe_1")]
+    child_pipes = [mocker.Mock(name="child_pipe_0"), mocker.Mock(name="child_pipe_1")]
+    spawn_context = mocker.Mock()
+    spawn_context.Process.side_effect = [first_process, second_process]
+    spawn_context.Pipe.side_effect = list(zip(parent_pipes, child_pipes))
+    mocker.patch("vllm.v1.utils.multiprocessing.get_context", return_value=spawn_context)
+    shutdown = mocker.patch("vllm.v1.utils.shutdown")
+
+    with pytest.raises(RuntimeError, match="spawn failed"):
+        serve_module._start_api_server_process_manager(
+            cleanup_timeout=1.5,
+            listen_address="127.0.0.1:8000",
+            sock=mocker.Mock(),
+            args=argparse.Namespace(),
+            num_servers=2,
+            input_addresses=["ipc://input-0", "ipc://input-1"],
+            output_addresses=["ipc://output-0", "ipc://output-1"],
+            target_server_fn=mocker.Mock(),
+        )
+
+    first_process.start.assert_called_once_with()
+    second_process.start.assert_called_once_with()
+    for pipe in parent_pipes:
+        pipe.close.assert_called_once_with()
+    shutdown.assert_called_once_with([first_process], timeout=1.5)
+
+
+def test_wait_for_multi_api_server_completion_rejects_engine_failure(
+    mocker: MockerFixture,
+) -> None:
+    from vllm_omni.entrypoints.cli import serve as serve_module
+
+    api_process = _FakeProcess(sentinel="api-0", exitcode=None, name="api-0", pid=10)
+    engine_process = _FakeProcess(sentinel="engine-0", exitcode=4, name="engine-0", pid=20)
+    manager = _FakeProcessOwner(processes=[api_process])
+    engine_launch = StageEngineLaunch(
+        client_configs=[],
+        resources=[StageReplicaResources(manager=_FakeProcessOwner(processes=[engine_process]))],
+    )
+    mocker.patch("multiprocessing.connection.wait", return_value=["engine-0"])
+
+    with pytest.raises(RuntimeError, match=r"Shared stage engine process engine-0 .* exited with code 4"):
+        serve_module._wait_for_multi_api_server_completion(manager, engine_launch)
+
+
 def test_serve_parser_rejects_stage_configs_path() -> None:
     parser = TrackingArgumentParser()
     subparsers = parser.add_subparsers(dest="subcommand")
@@ -334,6 +646,26 @@ def test_parse_stage_overrides_invalid_json_raises() -> None:
     assert f"Got: {bad!r}" in message
 
 
+@pytest.mark.parametrize(
+    "payload",
+    ['{"abc": {}}', '{"-1": {}}', '{"1.5": {}}', '{"\uff10": {}}'],
+)
+def test_parse_stage_overrides_rejects_invalid_stage_ids(payload: str) -> None:
+    with pytest.raises(argparse.ArgumentTypeError, match="non-negative integer stage ids"):
+        _parse_stage_overrides(payload)
+
+
+def test_parse_stage_overrides_preserves_arbitrary_override_fields() -> None:
+    parsed = _parse_stage_overrides(
+        '{"0": {"extras": {"ltx2_use_conv_vae": true}, "kv_cache_dtype": "fp8", "typo_field_xyz": 1}}'
+    )
+    assert parsed["0"] == {
+        "extras": {"ltx2_use_conv_vae": True},
+        "kv_cache_dtype": "fp8",
+        "typo_field_xyz": 1,
+    }
+
+
 def test_parse_stage_overrides_rejects_non_dict_top_level() -> None:
     """Top-level must be a JSON object (dict). A list, scalar, or non-dict
     mapping is rejected with a ValueError naming ``--stage-overrides`` and
@@ -706,6 +1038,77 @@ def test_run_headless_diffusion_registers_and_spawns_proc(mocker: MockerFixture)
     assert manager_kwargs["omni_replica_id"] == 0
 
 
+def test_run_headless_generic_diffusion_launches_structured_stage(mocker: MockerFixture) -> None:
+    """Headless resolution starts the typed stage through the real group launcher."""
+    from vllm_omni.engine import stage_engine_startup as startup_module
+
+    mocker.patch("vllm_omni.config.resolver.StageConfigFactory.create_from_model", return_value=None)
+    mocker.patch(
+        "vllm_omni.config.resolver._resolve_generic_diffusion_model_class",
+        return_value=(True, "FakeDiffusionPipeline"),
+    )
+    mocker.patch("vllm_omni.engine.stage_init_utils.prepare_engine_environment")
+    mocker.patch.object(startup_module.stage_init_utils, "load_omni_transfer_config_for_model", return_value=None)
+    mocker.patch.object(
+        startup_module.initialization,
+        "resolve_omni_kv_config_for_stage",
+        return_value=(None, None, None),
+    )
+    captured: dict[str, Any] = {}
+    od_config = SimpleNamespace()
+
+    def _build_diffusion_config(model, stage_config, metadata):
+        captured.update(model=model, stage_config=stage_config, metadata=metadata)
+        return od_config
+
+    def _launch_replica_group(**kwargs):
+        captured.update(group_kwargs=kwargs)
+        captured["manager"] = kwargs["launch_one"](0)
+
+    def _launch_replica(**kwargs):
+        captured.update(replica_kwargs=kwargs)
+        return SimpleNamespace(exitcode=None)
+
+    mocker.patch.object(startup_module.stage_init_utils, "build_diffusion_config", side_effect=_build_diffusion_config)
+    mocker.patch.object(startup_module, "launch_headless_replica_group", side_effect=_launch_replica_group)
+    mocker.patch.object(startup_module, "launch_headless_diffusion_replica", side_effect=_launch_replica)
+
+    explicit_keys = frozenset(
+        {
+            "model",
+            "stage_id",
+            "omni_master_address",
+            "omni_master_port",
+            "worker_backend",
+            "model_class_name",
+            "num_gpus",
+        }
+    )
+    args = _make_headless_args(
+        explicit_keys=explicit_keys,
+        model="generic-diffusion",
+        model_class_name="FakeDiffusionPipeline",
+        num_gpus=1,
+    )
+
+    run_headless(args)
+
+    stage = captured["stage_config"]
+    assert isinstance(stage, VllmOmniDiffusionStageConfig)
+    assert captured["metadata"].stage_type == "diffusion"
+    assert captured["metadata"].model_stage == "diffusion"
+    assert captured["model"] == "generic-diffusion"
+    assert captured["group_kwargs"]["stage_id"] == 0
+    assert captured["group_kwargs"]["omni_dp_size_local"] == 1
+    assert captured["group_kwargs"]["per_replica_devices"] == ["0"]
+    assert captured["replica_kwargs"]["stage_config"] is stage
+    assert captured["replica_kwargs"]["stage_id"] == 0
+    assert captured["replica_kwargs"]["omni_master_address"] == "127.0.0.1"
+    assert captured["replica_kwargs"]["omni_master_port"] == 26000
+    assert captured["replica_kwargs"]["od_config"] is od_config
+    assert stage.runtime_config.devices == "0"
+
+
 def test_run_headless_diffusion_raises_on_nonzero_proc_exit(mocker: MockerFixture) -> None:
     """A diffusion replica that exits with a non-zero code must surface as a
     RuntimeError from ``run_headless`` (the head needs the signal to roll
@@ -754,3 +1157,22 @@ def test_run_headless_diffusion_raises_on_nonzero_proc_exit(mocker: MockerFixtur
 
     with pytest.raises(RuntimeError, match=r"exited with code 137"):
         run_headless(_make_headless_args(stage_id=1))
+
+
+@pytest.mark.parametrize("name", ["unfiltered_ns", "explicit_keys", "missing", "__dict__"])
+def test_tracking_namespace_uninitialized_access_raises_attribute_error(name):
+    namespace = object.__new__(TrackingNamespace)
+    with pytest.raises(AttributeError):
+        getattr(namespace, name)
+
+
+@pytest.mark.parametrize("deep", [False, True])
+def test_tracking_namespace_copy_preserves_tracking(deep):
+    import copy
+
+    namespace = TrackingNamespace(
+        argparse.Namespace(model="example", api_server_count=2), frozenset({"api_server_count"})
+    )
+    restored = copy.deepcopy(namespace) if deep else copy.copy(namespace)
+    assert restored.get_explicit_kwargs_dict() == {"api_server_count": 2}
+    assert restored.model == "example"
diff --git a/tests/entrypoints/test_utils.py b/tests/entrypoints/test_utils.py
index 680bb110c..338df4833 100644
--- a/tests/entrypoints/test_utils.py
+++ b/tests/entrypoints/test_utils.py
@@ -13,6 +13,14 @@ import torch
 from pytest_mock import MockerFixture
 from vllm.sampling_params import RequestOutputKind, SamplingParams
 
+from vllm_omni.config.composable_parallel import (
+    Broadcast,
+    FanInByStage,
+    MeshAxisSpec,
+    RouteByStage,
+    StrategySpec,
+    TakeRank,
+)
 from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
 from vllm_omni.config.resolver import (
     OmniConfigResolution,
@@ -21,7 +29,6 @@ from vllm_omni.config.resolver import (
     resolve_omni_config,
 )
 from vllm_omni.config.stage_config import PipelineConfig
-from vllm_omni.config.yaml_util import create_config
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.engine.arg_utils import OmniEngineArgs
 from vllm_omni.entrypoints.utils import (
@@ -296,6 +303,70 @@ class TestFilterDataclassKwargs:
 
 
 class TestResolveOmniConfig:
+    @pytest.mark.parametrize("model_class_name", ["AnimaPipeline", "AnimaModularPipeline"])
+    def test_native_anima_checkpoint_uses_default_diffusion_stage_without_model_config(
+        self, tmp_path, mocker: MockerFixture, model_class_name: str
+    ):
+        checkpoint = tmp_path / "anima.safetensors"
+        checkpoint.write_text("dummy")
+        custom_args = {"components_path": "/tmp/anima-components"}
+        mocker.patch(
+            "vllm_omni.config.resolver.StageConfigFactory.create_from_model",
+            side_effect=AssertionError("native Anima checkpoints should not require model config discovery"),
+        )
+
+        resolved = resolve_omni_config(
+            str(checkpoint),
+            trust_remote_code=False,
+            deploy_config_path=None,
+            cli_overrides={"model_class_name": model_class_name, "custom_pipeline_args": custom_args},
+            stage_overrides=None,
+            strategy_config_path=None,
+        )
+
+        assert resolved.config_path is None
+        assert len(resolved.stage_configs) == 1
+        stage_config = resolved.stage_configs[0]
+        assert stage_config.model_stage == "diffusion"
+        assert stage_config.diffusion_config.model_class_name == "AnimaPipeline"
+        assert stage_config.diffusion_config.custom_pipeline_args == custom_args
+
+    @pytest.mark.parametrize(
+        ("model_class_name", "checkpoint_exists", "deploy_config_path"),
+        [
+            ("AnimaPipeline", True, "deploy.yaml"),
+            ("AnimaPipeline", False, None),
+            ("FluxPipeline", True, None),
+        ],
+    )
+    def test_native_single_file_fallback_preserves_config_discovery(
+        self, tmp_path, mocker: MockerFixture, model_class_name, checkpoint_exists, deploy_config_path
+    ):
+        checkpoint = tmp_path / "model.safetensors"
+        if checkpoint_exists:
+            checkpoint.write_text("dummy")
+        create_from_model = mocker.patch(
+            "vllm_omni.config.resolver.StageConfigFactory.create_from_model", return_value=None
+        )
+
+        resolved = resolve_omni_config(
+            str(checkpoint),
+            trust_remote_code=False,
+            deploy_config_path=deploy_config_path,
+            cli_overrides={"model_class_name": model_class_name},
+            stage_overrides=None,
+            strategy_config_path=None,
+        )
+
+        create_from_model.assert_called_once_with(
+            str(checkpoint),
+            trust_remote_code=False,
+            cli_overrides={"model_class_name": model_class_name, "trust_remote_code": False},
+            deploy_config_path=deploy_config_path,
+            strategy_specs=None,
+        )
+        assert resolved.config_path == deploy_config_path
+
     def test_bare_deploy_name_returns_packaged_resolved_path(self, tmp_path, mocker: MockerFixture):
         deploy_name = "qwen3_omni_moe.yaml"
         deploy_path = tmp_path / deploy_name
@@ -356,16 +427,12 @@ class TestResolveOmniConfig:
         )
         assert resolved.config_path is None
         assert len(resolved.stage_configs) == 1
-        engine_args = resolved.stage_configs[0]["engine_args"]
-        assert "dtype" in engine_args
-        assert engine_args["engine_backend"] == engine_backend
-        assert engine_args["revision"] == "pinned-revision"
+        assert resolved.stage_configs[0].diffusion_config.dtype is torch.float32
+        assert resolved.stage_configs[0].diffusion_config.engine_backend == engine_backend
+        assert resolved.stage_configs[0].diffusion_config.revision == "pinned-revision"
 
     def test_generic_diffusion_uses_registered_model_metadata(self, mocker: MockerFixture):
-        mocker.patch(
-            "vllm_omni.config.resolver.StageConfigFactory.create_from_model",
-            return_value=None,
-        )
+        mocker.patch("vllm_omni.config.resolver.StageConfigFactory.create_from_model", return_value=None)
         resolve_model_class = mocker.patch(
             "vllm_omni.config.resolver.resolve_model_class_name",
             return_value="WanImageToVideoPipeline",
@@ -374,59 +441,98 @@ class TestResolveOmniConfig:
             "vllm_omni.config.resolver.DiffusionModelRegistry.get_supported_archs",
             return_value={"WanImageToVideoPipeline"},
         )
+        load_model_class = mocker.patch("vllm_omni.config.resolver.DiffusionModelRegistry._try_load_model_cls")
 
         resolved = resolve_omni_config(
             "/models/Wan2.2-I2V",
             trust_remote_code=False,
             deploy_config_path=None,
-            cli_overrides={
-                "diffusion_load_format": "diffusers",
-                "revision": "pinned-revision",
-            },
+            cli_overrides={"diffusion_load_format": "diffusers", "revision": "pinned-revision"},
             stage_overrides=None,
             strategy_config_path=None,
         )
 
+        resolve_model_class.assert_called_once_with("/models/Wan2.2-I2V", "diffusers", "pinned-revision")
+        load_model_class.assert_not_called()
         stage = resolved.stage_configs[0]
-        resolve_model_class.assert_called_once_with(
-            "/models/Wan2.2-I2V",
-            "diffusers",
-            "pinned-revision",
-        )
-        assert stage.engine_args.model_class_name == "WanImageToVideoPipeline"
+        assert stage.diffusion_config.model_class_name == "WanImageToVideoPipeline"
+        assert stage.diffusion_config.revision == "pinned-revision"
         assert stage.final_output_type == "video"
 
+    def test_generic_diffusion_stage_overrides_reach_typed_backend(self, mocker: MockerFixture):
+        from vllm_omni.engine.stage_init_utils import build_engine_args_dict_from_omni_stage_config
+
+        mocker.patch("vllm_omni.config.resolver.StageConfigFactory.create_from_model", return_value=None)
+        mocker.patch(
+            "vllm_omni.config.resolver._resolve_generic_diffusion_model_class",
+            return_value=(True, "LTX2Pipeline"),
+        )
+        resolved = resolve_omni_config(
+            "/models/LTX-2.5-Diffusers",
+            trust_remote_code=False,
+            deploy_config_path=None,
+            cli_overrides={
+                "extras": {"ltx2_use_conv_vae": False, "keep": "global"},
+                "tensor_parallel_size": 1,
+                "diffusion_streaming_output": True,
+            },
+            stage_overrides={
+                "0": {
+                    "extras": {"ltx2_use_conv_vae": True},
+                    "tensor_parallel_size": 2,
+                    "devices": "2,3",
+                    "engine_backend": "custom.backend",
+                },
+            },
+            strategy_config_path=None,
+        )
+        stage = resolved.stage_by_id(0)
+        engine_args = build_engine_args_dict_from_omni_stage_config(stage, model="/models/LTX-2.5-Diffusers")
+
+        assert stage.runtime_config.devices == "2,3"
+        assert stage.parallel_config.world_size == 2
+        assert engine_args["engine_backend"] == "custom.backend"
+        assert engine_args["extras"]["ltx2_use_conv_vae"] is True
+        assert engine_args["extras"]["keep"] == "global"
+        assert engine_args["streaming_output"] is True
+
     def test_registered_pipeline_uses_structured_metadata_and_preserves_override_trust(self, mocker: MockerFixture):
         endpoint_restriction = SimpleNamespace(name="chat")
+        typed_stage = SimpleNamespace(stage_id=1)
         structured_config = SimpleNamespace(
-            orchestrator_config=SimpleNamespace(deploy_config_path="/resolved/deploy.yaml"),
+            orchestrator_config=SimpleNamespace(
+                deploy_config_path="/resolved/deploy.yaml",
+                omni_lb_policy="round_robin",
+            ),
             pipeline_config=SimpleNamespace(endpoint_restrictions=(endpoint_restriction,)),
+            stage_configs=(typed_stage,),
+            strategy_omni_lb_policy="round-robin",
         )
-        runtime_stage = create_config(
-            {
-                "stage_id": 1,
-                "runtime": {"devices": "1,2,3", "num_replicas": 3},
-                "engine_args": {"model": "dummy-model"},
-            }
-        )
-        legacy_stage = SimpleNamespace(to_omegaconf=lambda: runtime_stage)
         create_structured = mocker.patch(
             "vllm_omni.config.resolver.StageConfigFactory.create_from_model",
             return_value=structured_config,
         )
         create_legacy = mocker.patch(
-            "vllm_omni.config.resolver.StageConfigFactory._resolve_legacy_from_registry",
-            return_value=SimpleNamespace(
-                stage_configs=[legacy_stage],
-                pipeline_config=structured_config.pipeline_config,
-                omni_lb_policy="round_robin",
-            ),
+            "vllm_omni.config.resolver.StageConfigFactory.create_legacy_stage_configs_from_model",
         )
-        strategy_specs = {"stage_1": {"dp": 3}}
+        strategy_specs = {
+            "stage_1": [
+                StrategySpec(
+                    "stage_replica",
+                    MeshAxisSpec("stage_replica", 2),
+                    RouteByStage("round_robin"),
+                    FanInByStage(),
+                )
+            ]
+        }
         load_strategy = mocker.patch(
             "vllm_omni.config.resolver._load_strategy_specs",
             return_value=strategy_specs,
         )
+        apply_strategy = mocker.patch(
+            "vllm_omni.config.composable_parallel.apply_strategy_specs",
+            return_value=SimpleNamespace(omni_lb_policy="round_robin"),
+        )
 
         resolved = resolve_omni_config(
             "dummy-model",
@@ -447,31 +553,63 @@ class TestResolveOmniConfig:
             trust_remote_code=None,
             cli_overrides=expected_overrides,
             deploy_config_path="deploy.yaml",
-        )
-        create_legacy.assert_called_once_with(
-            structured_config.pipeline_config,
-            expected_overrides,
-            "/resolved/deploy.yaml",
             strategy_specs=strategy_specs,
         )
+        create_legacy.assert_not_called()
         load_strategy.assert_called_once_with("strategy.yaml")
+        apply_strategy.assert_not_called()
         assert resolved.config_path == "/resolved/deploy.yaml"
         assert resolved.pipeline_config is structured_config.pipeline_config
-        assert resolved.omni_lb_policy == "round_robin"
+        assert resolved.omni_lb_policy == "round-robin"
         assert resolved.endpoint_restrictions == (endpoint_restriction,)
-        assert resolved.stage_configs == (runtime_stage,)
+        assert resolved.stage_configs == (typed_stage,)
 
-    def test_registered_resolution_exposes_forced_aligner_topology(self, mocker: MockerFixture):
-        pipeline = OMNI_PIPELINES["qwen3_tts"]
-        assert isinstance(pipeline, PipelineConfig)
+    def test_tp_only_strategy_does_not_report_default_lb_policy_as_derived(self, mocker: MockerFixture):
         structured_config = SimpleNamespace(
-            orchestrator_config=SimpleNamespace(deploy_config_path=None),
-            pipeline_config=pipeline,
+            orchestrator_config=SimpleNamespace(
+                deploy_config_path="/resolved/deploy.yaml",
+                omni_lb_policy="round-robin",
+            ),
+            pipeline_config=SimpleNamespace(endpoint_restrictions=()),
+            stage_configs=(SimpleNamespace(stage_id=0),),
+            strategy_omni_lb_policy=None,
         )
         mocker.patch(
             "vllm_omni.config.resolver.StageConfigFactory.create_from_model",
             return_value=structured_config,
         )
+        mocker.patch(
+            "vllm_omni.config.resolver._load_strategy_specs",
+            return_value={
+                "thinker": [
+                    StrategySpec(
+                        "tp",
+                        MeshAxisSpec("tp", 2),
+                        Broadcast(),
+                        TakeRank(),
+                    )
+                ]
+            },
+        )
+
+        resolved = resolve_omni_config(
+            "dummy-model",
+            trust_remote_code=True,
+            deploy_config_path="deploy.yaml",
+            cli_overrides={"omni_lb_policy": "round-robin"},
+            stage_overrides=None,
+            strategy_config_path="strategy.yaml",
+        )
+
+        assert resolved.omni_lb_policy is None
+
+    def test_registered_resolution_exposes_forced_aligner_topology(self, mocker: MockerFixture):
+        pipeline = OMNI_PIPELINES["qwen3_tts"]
+        assert isinstance(pipeline, PipelineConfig)
+        mocker.patch(
+            "vllm_omni.config.config_factory.StageConfigFactory.get_pipeline_config",
+            return_value=pipeline,
+        )
 
         resolved = resolve_omni_config(
             "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice",
@@ -483,9 +621,9 @@ class TestResolveOmniConfig:
         )
 
         assert resolved.pipeline_config is not None
-        pipeline_stage_ids = [stage.stage_id for stage in resolved.pipeline_config.stages]
-        runtime_stage_ids = [stage.stage_id for stage in resolved.stage_configs]
-        assert pipeline_stage_ids == runtime_stage_ids
+        assert [stage.stage_id for stage in resolved.pipeline_config.stages] == [
+            stage.stage_id for stage in resolved.stage_configs
+        ]
         assert resolved.pipeline_config.stages[-1].model_stage == "forced_aligner"
         assert len(resolved.pipeline_config.stages) == len(pipeline.stages) + 1
 
@@ -529,3 +667,21 @@ class TestCumulativeStreamingCoercion:
         assert all([isinstance(r, SamplingParams) for r in result])
         assert result[0].output_kind == RequestOutputKind.DELTA
         assert result[1].output_kind == RequestOutputKind.DELTA
+
+
+@pytest.mark.parametrize("api_server_count", [1, 2])
+def test_prepare_stage_config_inputs_filters_frontend_options(api_server_count):
+    from vllm_omni.entrypoints.utils import prepare_stage_config_inputs
+
+    kwargs = {
+        "api_server_count": api_server_count,
+        "disable_log_stats": True,
+        "model_tag": "example",
+        "max_num_seqs": 8,
+        "stage_overrides": '{"0": {"max_num_seqs": 4}}',
+    }
+    inputs = prepare_stage_config_inputs("example", kwargs, trust_remote_code=None)
+
+    assert inputs.kwargs == {"max_num_seqs": 8}
+    assert inputs.stage_overrides == {"0": {"max_num_seqs": 4}}
+    assert kwargs["api_server_count"] == api_server_count
diff --git a/tests/examples/offline_inference/test_text_to_video_prompts.py b/tests/examples/offline_inference/test_text_to_video_prompts.py
index c588b7a38..e0c381bf3 100644
--- a/tests/examples/offline_inference/test_text_to_video_prompts.py
+++ b/tests/examples/offline_inference/test_text_to_video_prompts.py
@@ -1,10 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from __future__ import annotations
 
 import functools
 import importlib.util
+import sys
+from types import SimpleNamespace
 
 import pytest
 import torch
@@ -24,6 +26,51 @@ def _load_text_to_video():
     return module
 
 
+@pytest.mark.parametrize(
+    ("arguments", "expected"),
+    [
+        (["--quantization", "mxfp4"], {"quantization": "mxfp4"}),
+        (
+            ["--quantization-config", '{"method":"mxfp4","w4a8_fallback_steps":[0,2]}'],
+            {"quantization_config": {"method": "mxfp4", "w4a8_fallback_steps": [0, 2]}},
+        ),
+    ],
+)
+def test_quantization_cli_reaches_omni(arguments, expected, monkeypatch):
+    mod = _load_text_to_video()
+    captured = {}
+
+    class StopBeforeModelLoadError(Exception):
+        pass
+
+    def capture_omni(**kwargs):
+        captured.update(kwargs)
+        raise StopBeforeModelLoadError
+
+    monkeypatch.setattr(sys, "argv", ["text_to_video.py", "--model", "Wan-AI/Wan2.2-T2V-A14B-Diffusers", *arguments])
+    monkeypatch.setattr(mod, "current_omni_platform", SimpleNamespace(device_type="cpu"))
+    monkeypatch.setattr(mod, "Omni", capture_omni)
+
+    with pytest.raises(StopBeforeModelLoadError):
+        mod.main()
+
+    assert {key: captured[key] for key in ("quantization", "quantization_config") if key in captured} == expected
+
+
+def test_quantization_cli_options_are_mutually_exclusive(monkeypatch):
+    mod = _load_text_to_video()
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        ["text_to_video.py", "--quantization", "mxfp4", "--quantization-config", '{"method":"mxfp4"}'],
+    )
+
+    with pytest.raises(SystemExit) as exc:
+        mod.parse_args()
+
+    assert exc.value.code == 2
+
+
 @pytest.mark.parametrize(
     ("negative_prompt", "expected_negative_prompt"),
     [(None, None), ("", ""), ("blurry", "blurry")],
diff --git a/tests/examples/test_minicpmo_realtime_web_server.py b/tests/examples/test_minicpmo_realtime_web_server.py
index 6c35760a7..44f04eb1b 100644
--- a/tests/examples/test_minicpmo_realtime_web_server.py
+++ b/tests/examples/test_minicpmo_realtime_web_server.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import hashlib
 import importlib.util
 import sys
@@ -70,7 +73,12 @@ def test_build_app_injects_public_realtime_url():
 def test_build_app_versions_client_bundle_and_disables_index_cache():
     client = TestClient(build_app())
     expected_version_hash = hashlib.sha256()
-    for asset_name in ("app.js", "pcm_worklet.js", "playback_worklet.js"):
+    for asset_name in (
+        "app.js",
+        "pcm_worklet.js",
+        "playback_worklet.js",
+        *[str(p.relative_to(STATIC_DIR)) for p in sorted((STATIC_DIR / "profiles").glob("*.js"))],
+    ):
         expected_version_hash.update((STATIC_DIR / asset_name).read_bytes())
     expected_version = expected_version_hash.hexdigest()[:12]
 
@@ -97,3 +105,41 @@ def test_build_app_exposes_realtime_websocket_and_static_assets():
     assert client.get("/static/app.js").status_code == 200
     assert client.get("/static/pcm_worklet.js").status_code == 200
     assert client.get("/static/playback_worklet.js").status_code == 200
+
+
+def test_qwen_config_does_not_inject_reference_voice():
+    client = TestClient(build_app(profile="qwen3-turn", adapter="vad", model="Qwen/Qwen3-Omni-30B-A3B-Instruct"))
+    page = client.get("/").text
+    assert '"profile": "qwen3-turn"' in page
+    assert '"adapter": "vad"' in page
+    assert '"refAudio": null' in page
+    for name in ("common", "minicpm_native", "qwen3_turn"):
+        assert client.get(f"/static/profiles/{name}.js").status_code == 200
+    with pytest.raises(ValueError, match="ref-audio"):
+        build_app(profile="qwen3-turn", ref_audio="unused.wav")
+
+
+def test_config_cannot_close_its_script_element():
+    page = TestClient(build_app(model="</script><script>alert(1)</script>")).get("/").text
+    assert "</script><script>alert(1)" not in page
+    assert "\\u003c/script>" in page
+
+
+def test_proxy_reports_unreachable_backend(monkeypatch):
+    from examples.online_serving.realtime_web import server as shared_server
+
+    class RefusedConnection:
+        async def __aenter__(self):
+            raise ConnectionRefusedError(111, "Connection refused")
+
+        async def __aexit__(self, *args):
+            pass
+
+    monkeypatch.setattr(shared_server.websockets, "connect", lambda *args, **kwargs: RefusedConnection())
+    client = TestClient(build_app(ws_backend="ws://127.0.0.1:8091"))
+    with client.websocket_connect("/v1/realtime?duplex=0") as ws:
+        event = ws.receive_json()
+        assert event["type"] == "error"
+        assert event["code"] == "backend_unavailable"
+        assert "ws://127.0.0.1:8091" in event["error"]
+        assert "--port" in event["error"]
diff --git a/tests/examples/test_minicpmo_realtime_web_static.py b/tests/examples/test_minicpmo_realtime_web_static.py
index 2027d5aa3..e96be408d 100644
--- a/tests/examples/test_minicpmo_realtime_web_static.py
+++ b/tests/examples/test_minicpmo_realtime_web_static.py
@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-import re
 import shutil
 import subprocess
 import textwrap
@@ -9,7 +8,7 @@ from pathlib import Path
 
 import pytest
 
-ROOT = Path(__file__).resolve().parents[2] / "examples" / "online_serving" / "minicpmo" / "realtime_web"
+ROOT = Path(__file__).resolve().parents[2] / "examples" / "online_serving" / "realtime_web"
 APP_ROOT = ROOT / "app"
 STATIC_ROOT = APP_ROOT / "static"
 
@@ -30,73 +29,37 @@ def test_page_exposes_focused_call_conversation_and_log_surfaces():
     assert "Server VAD" not in html
 
 
-def test_client_uses_proxy_relative_realtime_url_and_model_policy_session():
+def test_shared_shell_delegates_wire_contract_to_profiles():
     source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+    assert "profile.url(config, window.location.href)" in source
+    assert "profile.initialMessages(config, instructions)" in source
+    assert "profile.append(" in source
+    assert "profile.mapEvent(event)" in source
+    assert "native_duplex" not in source
+    assert "server_vad" not in source
 
-    assert "new URL(config.realtimePath, window.location.href)" in source
-    assert "url.protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'" in source
-    assert "url.searchParams.set('autostart', '0')" in source
+
+def test_native_profile_preserves_session_and_capture_policy():
+    source = (STATIC_ROOT / "profiles/minicpm_native.js").read_text(encoding="utf-8")
     assert "native_duplex" not in source
     assert "auto_response: true" in source
-    assert "input_audio_buffer.append" in source
-    assert "input_audio_buffer.commit" not in source
-    assert "playback.ack" in source
-    assert "event.event || event" in source
-    assert "response.output_audio.delta" in source
-    assert "response.output_audio_transcript.delta" in source
-    assert "conversation.item.input_audio_transcription" in source
-    assert "force_barge_in" not in source
-    assert "server_vad" not in source
-    assert "type: 'response.create'" not in source
-    assert 'type: "response.create"' not in source
-
-
-def test_web_server_requires_ref_audio_for_audio_output_session():
-    source = (ROOT / "server.py").read_text(encoding="utf-8")
-
-    ref_audio_arg = re.search(
-        r"parser\.add_argument\(\s*\"--ref-audio\",(?P<body>.*?)\n\s*\)",
-        source,
-        re.DOTALL,
-    )
-    assert ref_audio_arg is not None
-    assert "required=True" in ref_audio_arg.group("body")
-    assert "Optional reference voice" not in ref_audio_arg.group("body")
-
-
-def test_client_sends_ref_audio_in_realtime_session_contract():
-    source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
-
     assert "if (config.refAudio) session.ref_audio = config.refAudio;" in source
-    assert "extraBody.ref_audio" not in source
+    assert "halfDuplex: false" in source
+    assert "commitMessages: () => []" in source
+    assert "video_frames" in source
+    assert "playback.ack" in source
 
 
 def test_client_has_transactional_cleanup_and_visible_event_logging():
     source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
-
-    assert "async function stopSession" in source
-    assert "type: 'session.close'" in source
+    assert "async function cleanupSession" in source
     assert "waitForSessionClosed" in source
-    assert "SESSION_CLOSE_TIMEOUT_MS" in source
-    assert "case 'session.closed':" in source
     assert "track.stop()" in source
     assert "clearInterval(sendTimer)" in source
     assert "appendEventLog(event)" in source
     assert "stopSession({ terminal: false })" in source
 
 
-def test_client_keeps_microphone_upload_active_during_assistant_playback():
-    source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
-    upload_gate = re.search(r"function microphoneUploadEnabled\(\) \{(?P<body>.*?)\n  \}", source, re.DOTALL)
-    begin_assistant = re.search(r"function beginAssistant\(responseId\) \{(?P<body>.*?)\n  \}", source, re.DOTALL)
-
-    assert upload_gate is not None
-    assert "return running && !muted;" in upload_gate.group("body")
-    assert "assistantActive" not in upload_gate.group("body")
-    assert begin_assistant is not None
-    assert "pendingCapture = []" not in begin_assistant.group("body")
-
-
 def test_audio_worklets_define_capture_and_playback_processors():
     capture = (STATIC_ROOT / "pcm_worklet.js").read_text(encoding="utf-8")
     playback = (STATIC_ROOT / "playback_worklet.js").read_text(encoding="utf-8")
@@ -138,6 +101,7 @@ def test_playback_worklet_waits_before_playing_and_rebuffers_after_underrun():
     node = shutil.which("node")
     if node is None:
         pytest.skip("node is required for the AudioWorklet regression test")
+    assert node is not None
 
     script = textwrap.dedent(
         """
@@ -216,6 +180,7 @@ def test_playback_worklet_fades_terminal_drain_to_zero():
     node = shutil.which("node")
     if node is None:
         pytest.skip("node is required for the AudioWorklet regression test")
+    assert node is not None
 
     script = textwrap.dedent(
         """
diff --git a/tests/examples/test_realtime_web_profiles.cjs b/tests/examples/test_realtime_web_profiles.cjs
new file mode 100644
index 000000000..1cf32e600
--- /dev/null
+++ b/tests/examples/test_realtime_web_profiles.cjs
@@ -0,0 +1,600 @@
+const assert = require('node:assert/strict');
+const { test } = require('node:test');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const root = path.resolve(__dirname, '../../examples/online_serving/realtime_web/app/static');
+const context = vm.createContext({ URL });
+for (const name of ['common', 'minicpm_native', 'qwen3_turn']) {
+  vm.runInContext(fs.readFileSync(path.join(root, `profiles/${name}.js`), 'utf8'), context);
+}
+const profiles = context.OmniRealtimeProfiles;
+const plain = (value) => JSON.parse(JSON.stringify(value));
+const config = { model: 'Qwen/Qwen3-Omni-30B-A3B-Instruct', realtimePath: 'v1/realtime' };
+
+test('MiniCPM keeps native flags, reference voice, camera, acknowledgements and no commits', () => {
+  const native = profiles['minicpm-native']();
+  const url = new URL(native.url({ ...config, model: 'MiniCPM' }, 'https://localhost/ui/'));
+  assert.equal(url.protocol, 'wss:');
+  assert.equal(url.searchParams.get('duplex'), '1');
+  assert.equal(url.searchParams.has('native_duplex'), false);
+  const [update] = native.initialMessages({ refAudio: 'data:audio/wav;base64,AA==' }, 'Prompt');
+  assert.equal(update.session.ref_audio, 'data:audio/wav;base64,AA==');
+  assert.equal(update.session.extra_body.native_duplex, undefined);
+  assert.equal(update.session.instructions, 'Prompt');
+  assert.deepEqual(plain(native.commitMessages()), []);
+  assert.equal(native.append('PCM', 'JPEG').video_frames[0], 'JPEG');
+  assert.equal(native.ack('r1', 200).type, 'playback.ack');
+  assert.equal(native.halfDuplex, false);
+});
+
+test('STT uses the shipped commit sequence and audio payload, including each new turn', () => {
+  const stt = profiles['qwen3-turn'](config);
+  for (let turn = 0; turn < 2; turn++) {
+    assert.deepEqual(plain(stt.initialMessages(config, 'ignored')), [
+      { type: 'session.update', model: config.model },
+      { type: 'input_audio_buffer.commit', final: false },
+    ]);
+    assert.deepEqual(plain(stt.commitMessages()), [{ type: 'input_audio_buffer.commit', final: true }]);
+  }
+  assert.equal(stt.reconnectEachTurn, true);
+  assert.equal(stt.mapEvent({ type: 'response.output_audio.delta', audio: 'PCM' }).event.delta, 'PCM');
+  assert.equal(stt.mapEvent({ type: 'response.output_audio.done' }).kind, 'done');
+  assert.equal(stt.mapEvent({ type: 'transcription.delta', delta: 'hello' }).role, 'assistant');
+});
+
+test('Qwen enables camera and playback ACK only for the duplex VAD profile', () => {
+  for (const adapter of ['stt', 'vad']) {
+    const p = profiles['qwen3-turn']({ ...config, adapter });
+    const url = new URL(p.url({ ...config, realtimePath: 'wss://backend/v1/realtime?native_duplex=1&minicpmo45_native_duplex=1' }, 'http://localhost/'));
+    assert.equal(url.protocol, 'wss:');
+    assert.equal(url.searchParams.get('duplex'), adapter === 'vad' ? '1' : '0');
+    assert.equal(url.searchParams.has('native_duplex'), false);
+    assert.equal(url.searchParams.has('minicpmo45_native_duplex'), false);
+    assert.equal(p.append('PCM', 'JPEG').video_frames, undefined);
+    assert.equal(plain(p.imageMessages('JPEG')).length, adapter === 'vad' ? 1 : 0);
+    assert.equal(p.ack('r', 100)?.type || null, adapter === 'vad' ? 'playback.ack' : null);
+    assert.equal(p.camera, adapter === 'vad');
+    assert.equal(p.mapEvent({ type: 'response.listen' }).kind, 'ignore');
+  }
+});
+
+test('VAD uses nested format and interruptible endpoint detection', () => {
+  const vad = profiles['qwen3-turn']({ ...config, adapter: 'vad' });
+  const [update] = vad.initialMessages(config, 'help');
+  assert.deepEqual(plain(update.session.audio.input), {
+    format: { type: 'audio/pcm', rate: 24000 },
+    turn_detection: { type: 'server_vad', threshold: 0.5, prefix_padding_ms: 300,
+      silence_duration_ms: 500, create_response: true, interrupt_response: true },
+  });
+  assert.equal(update.session.extra_body, undefined);
+  assert.deepEqual(plain(vad.commitMessages()), []);
+  assert.equal(vad.mapEvent({ type: 'response.audio.done' }).kind, 'drain');
+  assert.equal(vad.mapEvent({ type: 'response.done' }).kind, 'done');
+  assert.equal(vad.mapEvent({ type: 'response.output_text.delta', delta: 'hello' }).text, 'hello');
+  assert.equal(vad.mapEvent({ type: 'error', error: { code: 'input_backpressure' } }).kind, 'backpressure');
+  assert.equal(vad.mapEvent({ type: 'input_audio_buffer.cleared' }).kind, 'backpressure');
+  assert.match(vad.mapEvent({ type: 'error', code: 'unsupported', error: 'Unavailable' }).message, /session_mode: duplex/);
+  assert.match(vad.mapEvent({ type: 'error', code: 'server_vad_initialization_failed' }).message, /Silero/);
+});
+
+function shell(profileName, adapter = 'stt', options = {}) {
+  const elements = new Map();
+  class Element {
+    constructor() { this.style = {}; this.listeners = {}; this.children = []; this.value = ''; this.textContent = ''; this.classList = { add() {}, remove() {}, toggle() {} }; }
+    addEventListener(name, callback) { this.listeners[name] = callback; }
+    append(...children) { this.children.push(...children); }
+    appendChild(child) { this.children.push(child); }
+    replaceChildren() { this.children = []; }
+    remove() {}
+  }
+  const document = {
+    getElementById(id) { if (!elements.has(id)) elements.set(id, new Element()); return elements.get(id); },
+    createElement() { return new Element(); },
+  };
+  const timers = new Map();
+  let timerId = 0;
+  const sockets = [];
+  const nodes = [];
+  class Socket {
+    static OPEN = 1;
+    constructor() {
+      this.readyState = 1; this.sent = []; sockets.push(this);
+      queueMicrotask(() => {
+        this.onopen?.();
+        if (!options.silent) this.onmessage?.({ data: JSON.stringify(options.error || { type: adapter === 'stt' && profileName === 'qwen3-turn' ? 'session.created' : 'session.updated' }) });
+      });
+    }
+    send(value) { this.sent.push(JSON.parse(value)); }
+    close() { this.readyState = 3; this.onclose?.({ code: 1000 }); }
+  }
+  class AudioContext {
+    constructor(options) { this.sampleRate = options.sampleRate; this.audioWorklet = { addModule: async () => {} }; this.destination = {}; }
+    createMediaStreamSource() { return { connect() {} }; }
+    createGain() { return { gain: {}, connect() {} }; }
+    decodeAudioData(bytes) { return options.decodeAudioData(bytes); }
+    async resume() {}
+    async close() {}
+  }
+  class AudioWorkletNode {
+    constructor(_context, name) {
+      this.name = name; this.sent = []; nodes.push(this);
+      this.port = { postMessage: (message) => { this.sent.push(message); this.player?.handleMessage(message); } };
+      if (options.realPlayback && name === 'fullduplex-pcm-playback') {
+        let Playback;
+        const node = this;
+        const worker = vm.createContext({
+          sampleRate: 24000,
+          AudioWorkletProcessor: class {
+            constructor() { this.port = { postMessage: message => queueMicrotask(() => node.port.onmessage?.({ data: message })) }; }
+          },
+          registerProcessor: (_name, cls) => { Playback = cls; },
+        });
+        vm.runInContext(fs.readFileSync(path.join(root, 'playback_worklet.js'), 'utf8'), worker);
+        this.player = new Playback();
+      }
+    }
+    connect(target) { return target; }
+  }
+  const ctx = vm.createContext({
+    URL, document, AudioContext, AudioWorkletNode, WebSocket: Socket,
+    navigator: { mediaDevices: { getUserMedia: async () => ({ getTracks: () => [{ stop() {} }] }) } },
+    location: { href: 'https://localhost/' },
+    OMNI_REALTIME_CONFIG: { ...config, profile: profileName, adapter },
+    addEventListener() {},
+    setTimeout(fn, ms) { const id = ++timerId; timers.set(id, { fn, ms }); return id; },
+    clearTimeout(id) { timers.delete(id); },
+    setInterval() { return ++timerId; }, clearInterval() {},
+    btoa: (value) => Buffer.from(value, 'binary').toString('base64'),
+    atob: (value) => Buffer.from(value, 'base64').toString('binary'),
+  });
+  ctx.window = ctx;
+  for (const name of ['common', 'minicpm_native', 'qwen3_turn']) {
+    vm.runInContext(fs.readFileSync(path.join(root, `profiles/${name}.js`), 'utf8'), ctx);
+  }
+  // Expose closure controls only in the test VM; production has no test API.
+  const source = fs.readFileSync(path.join(root, 'app.js'), 'utf8').replace(/\}\)\(\);\s*$/, `
+    globalThis.testUI = { startSession, stopSession, handleEvent, playbackDrained,
+      microphoneUploadEnabled, flushCapture, awaitQueue: () => audioChain,
+      capture() { pendingCapture.push(new Int16Array([100, 200])); },
+      state() { return { running, connectionReady, assistantActive }; }
+    };
+  })();`);
+  vm.runInContext(source, ctx);
+  return { ui: ctx.testUI, elements, sockets, nodes,
+    timeout() { for (const timer of timers.values()) if (timer.ms === 15000) timer.fn(); },
+    async echo() {
+      for (const [id, timer] of timers) if (timer.ms === 300) { timers.delete(id); await timer.fn(); }
+    },
+    async turnWatchdog() {
+      for (const [id, timer] of timers) if (timer.ms === 120000) { timers.delete(id); await timer.fn(); }
+    },
+  };
+}
+
+test('shared shell STT sends final commit and starts a fresh second turn only after playback', async () => {
+  const app = shell('qwen3-turn');
+  await app.ui.startSession();
+  assert.equal(app.ui.microphoneUploadEnabled(), true);
+  app.ui.capture(); app.ui.flushCapture();
+  app.elements.get('sendTurnButton').listeners.click();
+  assert.equal(app.sockets[0].sent.at(-1).final, true);
+  assert.equal(app.ui.microphoneUploadEnabled(), false);
+  await app.ui.handleEvent({ type: 'response.output_audio.delta', audio: 'AAAAAA==' });
+  await app.ui.handleEvent({ type: 'response.output_audio.done' });
+  await app.echo();
+  assert.equal(app.sockets.length, 1, 'wait for actual speaker drain');
+  app.ui.playbackDrained({ responseId: 'turn-1', playedMs: 1 });
+  await app.echo();
+  assert.equal(app.sockets.length, 2);
+  assert.equal(app.sockets[1].sent[1].final, false);
+  assert.equal(app.ui.microphoneUploadEnabled(), true);
+  assert.equal(app.elements.get('cameraButton').hidden, true);
+  assert.equal(app.sockets.flatMap(s => s.sent).some(e => e.type === 'playback.ack'), false);
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('VAD keeps uploading while generating and waits for response.done after audio drain', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'error', code: 'input_backpressure' });
+  assert.equal(app.ui.microphoneUploadEnabled(), true);
+  await app.ui.handleEvent({ type: 'response.created', response: { id: 'r1' } });
+  await app.ui.handleEvent({ type: 'response.audio.delta', delta: 'AAAAAA==', response_id: 'r1' });
+  await app.ui.handleEvent({ type: 'response.audio.done', response_id: 'r1' });
+  app.ui.playbackDrained({ responseId: 'r1', playedMs: 1 });
+  await app.echo();
+  assert.equal(app.ui.microphoneUploadEnabled(), true, 'continuous capture remains enabled');
+  assert.equal(app.ui.state().assistantActive, true, 'audio drain must wait for response.done');
+  assert.equal(app.sockets[0].sent.at(-1).type, 'playback.ack');
+  await app.ui.handleEvent({ type: 'response.done', response: { id: 'r1' } });
+  await app.echo();
+  assert.equal(app.ui.microphoneUploadEnabled(), true);
+  assert.equal(app.sockets.length, 1, 'VAD keeps its session');
+  assert.equal(app.sockets[0].sent.some(e => e.type === 'input_audio_buffer.commit'), false);
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('a rejected operation is reported without hanging up the call', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'error', code: 'invalid_image', error: 'input_image requires a JPEG or PNG base64 data URL' });
+  assert.equal(app.ui.state().running, true, 'one refused image must not end the session');
+  assert.equal(app.ui.state().connectionReady, true);
+  assert.match(app.elements.get('runtimeDetail').textContent, /JPEG or PNG/);
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('a session-level error still tears the call down', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'error', code: 'unknown_session', error: 'Unknown or closed duplex session' });
+  assert.equal(app.ui.state().running, false);
+  assert.equal(app.elements.get('connectionState').textContent, 'Error');
+});
+
+test('an interrupted response disarms the turn watchdog it left armed', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'response.created', response: { id: 'r1' } });
+  await app.ui.handleEvent({ type: 'error', code: 'input_backpressure' });
+  await app.ui.handleEvent({ type: 'response.done', response: { id: 'r1', status: 'cancelled' } });
+  await app.turnWatchdog();
+  assert.equal(app.ui.state().running, true, 'barge-in must not time the session out two minutes later');
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('MiniCPM retains microphone upload while speaking and acknowledges speaker drain', async () => {
+  const app = shell('minicpm-native');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'response.speak', response_id: 'native-r1' });
+  assert.equal(app.ui.microphoneUploadEnabled(), true);
+  await app.ui.handleEvent({ type: 'response.output_audio.delta', delta: 'AAAAAA==', response_id: 'native-r1' });
+  app.ui.playbackDrained({ responseId: 'native-r1', playedMs: 100 });
+  assert.equal(app.sockets[0].sent.at(-1).type, 'playback.ack');
+  assert.equal(app.sockets[0].sent.some(e => e.type === 'input_audio_buffer.commit'), false);
+  await app.ui.stopSession({ terminal: false });
+  await app.echo();
+  assert.equal(app.ui.state().running, false);
+});
+
+test('VAD handshake errors remain visible after resource cleanup', async () => {
+  const app = shell('qwen3-turn', 'vad', { error: { type: 'error', code: 'unsupported', error: 'Realtime API is not available' } });
+  await app.ui.startSession();
+  assert.equal(app.ui.state().running, false);
+  assert.equal(app.elements.get('connectionState').textContent, 'Error');
+  assert.match(app.elements.get('runtimeDetail').textContent, /session_mode: duplex/);
+  assert.equal(app.sockets[0].readyState, 3);
+});
+
+test('missing session acknowledgement fails instead of leaving Start disabled forever', async () => {
+  const app = shell('qwen3-turn', 'vad', { silent: true });
+  const starting = app.ui.startSession();
+  for (let i = 0; i < 20; i++) await Promise.resolve();
+  app.timeout();
+  await starting;
+  assert.equal(app.ui.state().running, false);
+  assert.equal(app.elements.get('callButton').disabled, false);
+  assert.match(app.elements.get('runtimeDetail').textContent, /handshake timed out/);
+});
+
+test('Qwen does not duplicate text and audio-transcript channels', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'response.audio_transcript.delta', delta: '' });
+  await app.ui.handleEvent({ type: 'response.output_text.delta', delta: 'Hello' });
+  await app.ui.handleEvent({ type: 'response.audio_transcript.delta', delta: 'Hello' });
+  await app.ui.handleEvent({ type: 'response.output_text.done', text: 'Hello' });
+  await app.ui.handleEvent({ type: 'response.done' });
+  const turns = app.elements.get('conversation').children;
+  assert.equal(turns.length, 1);
+  assert.equal(turns[0].children[1].textContent, 'Hello');
+  await app.ui.stopSession({ terminal: false });
+});
+
+const flushTasks = async () => { for (let i = 0; i < 40; i++) await Promise.resolve(); };
+
+test('closing socket accepts only session.closed and completes without the fallback timer', async () => {
+  const app = shell('minicpm-native');
+  await app.ui.startSession();
+  const old = app.sockets[0];
+  let stopped = false;
+  const stopping = app.ui.stopSession().then(() => { stopped = true; });
+  assert.equal(old.sent.at(-1).type, 'session.close');
+  old.onmessage({ data: JSON.stringify({ type: 'session.updated' }) });
+  await flushTasks();
+  assert.equal(stopped, false);
+  old.onmessage({ data: JSON.stringify({ type: 'session.closed' }) });
+  await flushTasks();
+  assert.equal(stopped, true, 'must finish without firing the timeout');
+  await stopping;
+  await app.ui.startSession();
+  old.onmessage({ data: JSON.stringify({ type: 'session.closed' }) });
+  old.onmessage({ data: '{broken' });
+  await flushTasks();
+  assert.equal(app.ui.state().running, true, 'stale socket cannot affect a new session');
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('malformed JSON before readiness rejects the handshake and cleans up', async () => {
+  const app = shell('qwen3-turn', 'vad', { silent: true });
+  const starting = app.ui.startSession();
+  await flushTasks();
+  app.sockets[0].onmessage({ data: '{broken' });
+  await starting;
+  assert.equal(app.ui.state().running, false);
+  assert.equal(app.sockets[0].readyState, 3);
+  assert.equal(app.elements.get('connectionState').textContent, 'Error');
+  assert.match(app.elements.get('runtimeDetail').textContent, /Invalid server event/);
+});
+
+test('malformed JSON after readiness fails the session and releases resources', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  app.sockets[0].onmessage({ data: '{broken' });
+  await flushTasks();
+  assert.equal(app.ui.state().running, false);
+  assert.equal(app.ui.microphoneUploadEnabled(), false);
+  assert.equal(app.sockets[0].readyState, 3);
+  assert.equal(app.elements.get('connectionState').textContent, 'Error');
+  assert.match(app.elements.get('runtimeDetail').textContent, /Invalid server event/);
+});
+
+
+test('Qwen VAD interruption clears playback while continuing microphone upload', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  await app.ui.handleEvent({ type: 'response.created', response: { id: 'r1' } });
+  await app.ui.handleEvent({ type: 'response.audio.delta', delta: 'AAAAAA==', response_id: 'r1' });
+  await app.ui.handleEvent({ type: 'output_audio_buffer.cleared', response_id: 'r1' });
+  assert.equal(app.ui.state().assistantActive, false);
+  assert.equal(app.ui.microphoneUploadEnabled(), true);
+  assert.ok(app.nodes.some(node => node.sent.some(message => message.type === 'clear')));
+  await app.ui.stopSession({ terminal: false });
+});
+
+
+test('Qwen runtime errors do not suggest changing a working deployment', () => {
+  const p = profiles['qwen3-turn']({ adapter: 'vad' });
+  const message = 'playback.ack arrived after a later user input was committed.';
+  assert.equal(p.mapEvent({ type: 'error', code: 'playback_ack_too_late', error: message }).message, message);
+});
+
+test('interrupted playback reports its cursor before clear resets it', () => {
+  let Playback;
+  const messages = [];
+  const ctx = vm.createContext({
+    sampleRate: 24000,
+    AudioWorkletProcessor: class { constructor() { this.port = { postMessage: m => messages.push(m) }; } },
+    registerProcessor: (_name, cls) => { Playback = cls; },
+  });
+  vm.runInContext(fs.readFileSync(path.join(root, 'playback_worklet.js'), 'utf8'), ctx);
+  const player = new Playback();
+  player.handleMessage({ type: 'audio', responseId: 'old', pcm: new Int16Array(24000), initialBufferMs: 0 });
+  player.process([], [[new Float32Array(2400)]]);
+  player.handleMessage({ type: 'clear' });
+  const report = messages.find(m => m.type === 'playback-stopped');
+  assert.equal(report.responseId, 'old');
+  assert.equal(report.playedMs, 100);
+  assert.equal(player.playedFrames, 0);
+  assert.equal(player.bufferedFrames(), 0);
+  player.handleMessage({ type: 'clear' });
+  assert.equal(messages.filter(m => m.type === 'playback-stopped').length, 1);
+});
+
+test('late interruption cursor acknowledges old response without finishing the new response', async () => {
+  const app = shell('qwen3-turn', 'vad');
+  await app.ui.startSession();
+  const player = app.nodes.find(n => n.name === 'fullduplex-pcm-playback');
+  await app.ui.handleEvent({ type: 'response.created', response: { id: 'old' } });
+  await app.ui.handleEvent({ type: 'output_audio_buffer.cleared', response_id: 'old' });
+  await app.ui.handleEvent({ type: 'response.created', response: { id: 'new' } });
+  player.port.onmessage({ data: { type: 'playback-stopped', responseId: 'old', playedMs: 100 } });
+  const ack = app.sockets[0].sent.find(m => m.type === 'playback.ack');
+  assert.equal(ack.response_id, 'old');
+  assert.equal(ack.played_ms, 100);
+  assert.equal(app.ui.state().assistantActive, true);
+});
+
+
+test('Qwen camera frames ride the OpenAI image interface, not the audio append', () => {
+  const p = profiles['qwen3-turn']({ ...config, adapter: 'vad' });
+  assert.deepEqual(plain(p.append('PCM', 'JPEG')), { type: 'input_audio_buffer.append', audio: 'PCM' });
+
+  const [created] = plain(p.imageMessages('JPEG'));
+  assert.equal(created.type, 'conversation.item.create');
+  assert.equal(created.item.role, 'user');
+  assert.deepEqual(created.item.content, [
+    { type: 'input_image', image_url: 'data:image/jpeg;base64,JPEG' },
+  ]);
+});
+
+test('the camera retires its oldest image instead of exhausting the session budget', () => {
+  const p = profiles['qwen3-turn']({ ...config, adapter: 'vad' });
+  const ids = [];
+  for (let i = 0; i < 8; i++) {
+    const messages = plain(p.imageMessages('JPEG'));
+    assert.equal(messages.length, 1, 'nothing to retire while under the budget');
+    ids.push(messages[0].item.id);
+  }
+  // The engine counts what it already stores, so the delete has to lead.
+  const ninth = plain(p.imageMessages('JPEG'));
+  assert.deepEqual(ninth[0], { type: 'conversation.item.delete', item_id: ids[0] });
+  assert.equal(ninth[1].type, 'conversation.item.create');
+  assert.equal(new Set(ids).size, 8, 'item ids must be distinct to be deletable');
+
+  // A new call reopens the budget; stale ids from the old one must not linger.
+  assert.equal(plain(p.initialMessages(config, 'x')).length > 0, true);
+  assert.equal(plain(p.imageMessages('JPEG')).length, 1);
+});
+
+// Exercise the real WebSocket dispatch queue together with the actual playback
+// processor: sending a clear message alone does not prove the speaker is silent.
+function receive(app, event) {
+  app.sockets[0].onmessage({ data: JSON.stringify(event) });
+}
+
+function audioChunk(responseId, extra = {}) {
+  const pcm = new Int16Array(24000).fill(12000);
+  return { type: 'response.output_audio.delta', response_id: responseId,
+    delta: Buffer.from(pcm.buffer).toString('base64'), format: 'pcm16', sample_rate_hz: 24000, ...extra };
+}
+
+function renderPlayback(player) {
+  const output = new Float32Array(128);
+  player.process([], [[output]]);
+  return output;
+}
+
+async function playingQwen(options = {}) {
+  const app = shell('qwen3-turn', 'vad', { realPlayback: true, ...options });
+  await app.ui.startSession();
+  receive(app, { type: 'response.created', response: { id: 'old' } });
+  receive(app, audioChunk('old'));
+  await app.ui.awaitQueue();
+  app.player = app.nodes.find(node => node.name === 'fullduplex-pcm-playback').player;
+  // Advance through the initial 400 ms playback buffer.
+  for (let index = 0; index < 75; index++) renderPlayback(app.player);
+  assert.ok(renderPlayback(app.player).some(sample => sample !== 0));
+  return app;
+}
+
+function assertSilent(player) {
+  assert.equal(player.bufferedFrames(), 0, 'interrupted audio must leave the playback queue');
+  assert.ok(renderPlayback(player).every(sample => sample === 0), 'speaker must output silence');
+}
+
+for (const terminal of [false, true]) {
+  test(`Qwen speech interrupts actual playback after generation completed=${terminal}`, async () => {
+    const app = await playingQwen();
+    if (terminal) {
+      receive(app, { type: 'response.output_audio.done', response_id: 'old' });
+      receive(app, { type: 'response.done', response: { id: 'old', status: 'completed' } });
+      await app.ui.awaitQueue();
+    }
+    receive(app, { type: 'input_audio_buffer.speech_started', item_id: 'next', audio_start_ms: 1000 });
+    await app.ui.awaitQueue();
+    assertSilent(app.player);
+    assert.equal(app.ui.microphoneUploadEnabled(), true);
+    const ack = app.sockets[0].sent.find(event => event.type === 'playback.ack');
+    assert.equal(ack.response_id, 'old');
+    assert.equal(ack.played_ms, 5, 'ack only the 128 frames actually played, not all queued audio');
+    await app.ui.stopSession({ terminal: false });
+  });
+}
+
+test('Qwen cancellation preempts pending decode and does not delay the next response', async () => {
+  let releaseDecode;
+  const app = await playingQwen({ decodeAudioData: () => new Promise(resolve => { releaseDecode = resolve; }) });
+  receive(app, audioChunk('old', { format: 'wav' }));
+  await flushTasks();
+  assert.equal(typeof releaseDecode, 'function');
+  receive(app, { type: 'response.done', response: { id: 'old', status: 'cancelled' } });
+  await flushTasks();
+  assertSilent(app.player);
+  receive(app, { type: 'response.created', response: { id: 'new' } });
+  receive(app, audioChunk('new'));
+  await flushTasks();
+  assert.equal(app.player.activeResponseId, 'new');
+  assert.equal(app.player.bufferedFrames(), 24000);
+  releaseDecode({ sampleRate: 24000, getChannelData: () => new Float32Array(24000).fill(0.4) });
+  await flushTasks();
+  assert.equal(app.player.bufferedFrames(), 24000, 'old decoded audio must not enter the new response');
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('Qwen interruption rejects queued and late audio for the cancelled response', async () => {
+  const app = await playingQwen();
+  receive(app, audioChunk('old'));
+  receive(app, { type: 'response.done', response: { id: 'old', status: 'cancelled' } });
+  receive(app, audioChunk('old'));
+  await app.ui.awaitQueue();
+  assertSilent(app.player);
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('late cancellation of an old Qwen response does not clear a newer response', async () => {
+  const app = await playingQwen();
+  receive(app, { type: 'response.done', response: { id: 'old', status: 'cancelled' } });
+  await app.ui.awaitQueue();
+  receive(app, { type: 'response.created', response: { id: 'new' } });
+  receive(app, audioChunk('new'));
+  await app.ui.awaitQueue();
+  receive(app, { type: 'output_audio_buffer.cleared', response_id: 'old' });
+  receive(app, { type: 'response.done', response: { id: 'old', status: 'cancelled' } });
+  await app.ui.awaitQueue();
+  assert.equal(app.player.activeResponseId, 'new');
+  assert.equal(app.player.bufferedFrames(), 24000);
+  assert.equal(app.ui.state().assistantActive, true);
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('Qwen speech interruption follows accepted turn detection; MiniCPM mapping stays unchanged', () => {
+  const qwen = profiles['qwen3-turn']({ adapter: 'vad' });
+  const speech = { type: 'input_audio_buffer.speech_started', item_id: 'next' };
+  assert.equal(qwen.mapEvent(speech).kind, 'interrupt');
+  qwen.mapEvent({ type: 'session.updated', session: { audio: { input: { turn_detection: {
+    type: 'server_vad', interrupt_response: false,
+  } } } } });
+  assert.equal(qwen.mapEvent(speech).kind, 'ignore');
+  qwen.mapEvent({ type: 'session.updated', session: { audio: { input: { turn_detection: null } } } });
+  assert.equal(qwen.mapEvent(speech).kind, 'ignore');
+  qwen.mapEvent({ type: 'session.updated', session: { audio: { input: { turn_detection: {
+    type: 'server_vad', interrupt_response: true,
+  } } } } });
+  assert.equal(qwen.mapEvent(speech).kind, 'interrupt');
+  assert.equal(profiles['qwen3-turn']({ adapter: 'stt' }).mapEvent(speech).kind, 'ignore');
+  assert.equal(profiles['minicpm-native']().mapEvent(speech).kind, 'ignore');
+});
+
+test('late old-response controls cannot invalidate a newer pending decode', async () => {
+  let releaseDecode;
+  const app = await playingQwen({ decodeAudioData: () => new Promise(resolve => { releaseDecode = resolve; }) });
+  receive(app, { type: 'input_audio_buffer.speech_started', item_id: 'next', audio_start_ms: 1000 });
+  await app.ui.awaitQueue();
+  receive(app, { type: 'response.created', response: { id: 'new' } });
+  receive(app, audioChunk('new', { format: 'wav' }));
+  await flushTasks();
+  assert.equal(typeof releaseDecode, 'function');
+  receive(app, { type: 'output_audio_buffer.cleared', response_id: 'old' });
+  receive(app, { type: 'response.done', response: { id: 'old', status: 'cancelled' } });
+  releaseDecode({ sampleRate: 24000, getChannelData: () => new Float32Array(24000).fill(0.4) });
+  await app.ui.awaitQueue();
+  assert.equal(app.player.activeResponseId, 'new');
+  assert.equal(app.player.bufferedFrames(), 24000);
+  assert.equal(app.ui.state().assistantActive, true);
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('normal completion still waits for decoding before draining playback', async () => {
+  let releaseDecode;
+  const app = await playingQwen({ decodeAudioData: () => new Promise(resolve => { releaseDecode = resolve; }) });
+  receive(app, audioChunk('old', { format: 'wav' }));
+  await flushTasks();
+  receive(app, { type: 'response.output_audio.done', response_id: 'old' });
+  receive(app, { type: 'response.done', response: { id: 'old', status: 'completed' } });
+  await flushTasks();
+  assert.equal(app.player.drain, null);
+  releaseDecode({ sampleRate: 24000, getChannelData: () => new Float32Array(24000).fill(0.4) });
+  await app.ui.awaitQueue();
+  assert.equal(app.player.bufferedFrames(), 47872);
+  assert.equal(app.player.drain.responseId, 'old');
+  await app.ui.stopSession({ terminal: false });
+});
+
+test('interrupting an old decode preserves a newer response already waiting in the event queue', async () => {
+  let releaseDecode;
+  const app = await playingQwen({ decodeAudioData: () => new Promise(resolve => { releaseDecode = resolve; }) });
+  receive(app, audioChunk('old', { format: 'wav' }));
+  await flushTasks();
+  receive(app, { type: 'response.created', response: { id: 'new' } });
+  receive(app, audioChunk('new'));
+  receive(app, { type: 'output_audio_buffer.cleared', response_id: 'old' });
+  await flushTasks();
+  assert.equal(app.player.activeResponseId, 'new');
+  assert.equal(app.player.bufferedFrames(), 24000);
+  releaseDecode({ sampleRate: 24000, getChannelData: () => new Float32Array(24000).fill(0.4) });
+  await flushTasks();
+  assert.equal(app.player.bufferedFrames(), 24000);
+  await app.ui.stopSession({ terminal: false });
+});
diff --git a/tests/examples/test_realtime_web_profiles.py b/tests/examples/test_realtime_web_profiles.py
new file mode 100644
index 000000000..6b21d86a0
--- /dev/null
+++ b/tests/examples/test_realtime_web_profiles.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_realtime_profiles_and_shell_lifecycle():
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("node is required for browser protocol tests")
+    assert node is not None
+    subprocess.run(
+        [node, "--test", str(Path(__file__).with_suffix(".cjs"))],
+        check=True,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
diff --git a/tests/helpers/assertions.py b/tests/helpers/assertions.py
index 7dc7a6ab3..5df9dfa7e 100644
--- a/tests/helpers/assertions.py
+++ b/tests/helpers/assertions.py
@@ -955,6 +955,17 @@ def assert_audio_speech_response(response: Any, request_config: dict[str, Any],
     """
     assert response.success, "The request failed."
 
+    if request_config.get("word_timestamps"):
+        timestamps = response.word_timestamps
+        assert isinstance(timestamps, list) and timestamps, "Expected nonempty X-Word-Timestamps"
+        previous_start = 0
+        for timestamp in timestamps:
+            assert isinstance(timestamp["word"], str) and timestamp["word"]
+            start, end = timestamp["start_ms"], timestamp["end_ms"]
+            assert isinstance(start, int) and isinstance(end, int)
+            assert previous_start <= start <= end
+            previous_start = start
+
     # Optional floor on decoded audio size (models with very short clips may use a lower value).
     min_audio = request_config.get("min_audio_bytes")
     if min_audio is not None:
diff --git a/tests/helpers/client.py b/tests/helpers/client.py
index ed5158b92..e1042321a 100644
--- a/tests/helpers/client.py
+++ b/tests/helpers/client.py
@@ -102,6 +102,7 @@ class OmniResponse:
     audio_content: str | None = None
     audio_format: str | None = None
     audio_bytes: bytes | None = None
+    word_timestamps: list[dict[str, str | int]] | None = None
     #: End-to-end wall time in **seconds** (``perf_counter`` delta), from just before the
     #: OpenAI client call through response parsing and local post-process (e.g. audio decode).
     e2e_latency: float | None = None
@@ -1419,6 +1420,9 @@ class OnlineOmniClient:
             result.success = True
             result.audio_format = getattr(response, "response", None)
             if result.audio_format is not None:
+                timestamps = result.audio_format.headers.get("X-Word-Timestamps")
+                if timestamps is not None:
+                    result.word_timestamps = json.loads(timestamps)
                 result.audio_format = result.audio_format.headers.get("content-type", "")
 
         except Exception as e:
@@ -1472,6 +1476,7 @@ class OnlineOmniClient:
             "extra_params",
             "stream_format",
             "x_vector_only_mode",
+            "word_timestamps",
         ):
             if key in request_config:
                 extra_body[key] = request_config[key]
diff --git a/tests/helpers/runtime.py b/tests/helpers/runtime.py
index 0632db55d..5c9c8076f 100644
--- a/tests/helpers/runtime.py
+++ b/tests/helpers/runtime.py
@@ -38,6 +38,8 @@ from vllm_omni.outputs import OmniRequestOutput
 
 logger = init_logger(__name__)
 
+SERVER_STARTUP_TIMEOUT_S = 1200
+
 PromptAudioInput = list[tuple[Any, int]] | tuple[Any, int] | None
 PromptImageInput = list[Any] | Any | None
 PromptVideoInput = list[Any] | Any | None
@@ -246,9 +248,10 @@ class OmniServer:
             cwd=_omni_subprocess_cwd(),
         )
 
-        max_wait = 1200
-        start_time = time.time()
-        while time.time() - start_time < max_wait:
+        max_wait = SERVER_STARTUP_TIMEOUT_S
+        # System clock corrections must not shorten or extend startup waits.
+        start_time = time.monotonic()
+        while time.monotonic() - start_time < max_wait:
             ret = self.proc.poll()
             if ret is not None:
                 raise RuntimeError(f"Server processes exited with code {ret} before becoming ready.")
@@ -550,9 +553,10 @@ class OmniServerStageCli(OmniServer):
             for replica_id in range(self.stage_replica_counts.get(stage_id, 1)):
                 self._launch_stage(stage_id, headless=True, replica_id=replica_id)
 
-        max_wait = 1200
-        start_time = time.time()
-        while time.time() - start_time < max_wait:
+        max_wait = SERVER_STARTUP_TIMEOUT_S
+        # System clock corrections must not shorten or extend startup waits.
+        start_time = time.monotonic()
+        while time.monotonic() - start_time < max_wait:
             self._ensure_stage_processes_alive()
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                 sock.settimeout(1)
@@ -1166,6 +1170,7 @@ def pi0_openpi_run_policy_session(
     prompt: str = PI0_OPENPI_DEFAULT_PROMPT,
     session_id: str | None = None,
     num_steps: int = 2,
+    num_inference_steps: int | None = None,
 ) -> dict[str, Any]:
     """Connect, read handshake metadata, send ``num_steps`` observations."""
     import uuid
@@ -1184,6 +1189,8 @@ def pi0_openpi_run_policy_session(
         actions = []
         for _ in range(num_steps):
             payload = pi0_make_dummy_obs(prompt=prompt, session_id=session_id)
+            if num_inference_steps is not None:
+                payload["sampling_params"] = {"num_inference_steps": num_inference_steps}
             payload["endpoint"] = "infer"
             conn.send(packer.pack(payload))
             actions.append(_pi0_decode_action_response(conn.recv()))
diff --git a/tests/helpers/tests/test_assertions.py b/tests/helpers/tests/test_assertions.py
index e9b1a771c..55956a6f2 100644
--- a/tests/helpers/tests/test_assertions.py
+++ b/tests/helpers/tests/test_assertions.py
@@ -173,3 +173,26 @@ def test_bounded_tail_allows_ratio_bound_for_long_answers():
     # Twenty expected words allow up to max(2, ceil(0.2 * 20)) = 4 tail words.
     assert assertions._transcript_has_bounded_tail(four_word_tail, expected)
     assert not assertions._transcript_has_bounded_tail(five_word_tail, expected)
+
+
+def test_speech_timestamp_header_is_required_and_decoded():
+    import time
+
+    import httpx
+    from openai._legacy_response import HttpxBinaryResponseContent
+
+    from tests.helpers.client import OnlineOmniClient
+
+    client = object.__new__(OnlineOmniClient)
+    request = {"word_timestamps": True}
+    for headers in ({}, {"X-Word-Timestamps": '[{"word":"Hello","start_ms":0,"end_ms":300}]'}):
+        response = client._process_non_stream_audio_speech_response(
+            HttpxBinaryResponseContent(httpx.Response(200, content=b"audio", headers=headers)),
+            wall_start=time.perf_counter(),
+        )
+        if headers:
+            assert_audio_speech_response(response, request)
+            assert response.word_timestamps == [{"word": "Hello", "start_ms": 0, "end_ms": 300}]
+        else:
+            with pytest.raises(AssertionError, match="X-Word-Timestamps"):
+                assert_audio_speech_response(response, request)
diff --git a/tests/helpers/tests/test_check_test_marks.py b/tests/helpers/tests/test_check_test_marks.py
new file mode 100644
index 000000000..8b29b6f33
--- /dev/null
+++ b/tests/helpers/tests/test_check_test_marks.py
@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+
+from tools.pre_commit import check_test_marks
+
+pytestmark = [pytest.mark.cpu, pytest.mark.core_model]
+
+
+@pytest.mark.parametrize("kind", ["offline", "online"])
+def test_common_diffusion_marks_are_checked_in_helper(kind, monkeypatch):
+    path = f"tests/model_tests/diffusion/test_common_{kind}.py"
+    assert check_test_marks.get_files_missing_markers([path]) == {}
+
+    read_file = check_test_marks.read_test_file
+    monkeypatch.setattr(
+        check_test_marks,
+        "read_test_file",
+        lambda filename: "" if filename.endswith("case_filtering.py") else read_file(filename),
+    )
+    assert check_test_marks.get_files_missing_markers([path]) == {path: ["Level", "Hardware"]}
+
+
+def test_unrelated_tests_cannot_inherit_diffusion_marks(monkeypatch):
+    path = "tests/test_missing_marks.py"
+    monkeypatch.setattr(check_test_marks, "read_test_file", lambda filename: "get_parametrized_options(settings)")
+    assert check_test_marks.get_files_missing_markers([path]) == {path: ["Level", "Hardware"]}
diff --git a/tests/helpers/tests/test_runtime_startup_timeout.py b/tests/helpers/tests/test_runtime_startup_timeout.py
new file mode 100644
index 000000000..0eb6a91bf
--- /dev/null
+++ b/tests/helpers/tests/test_runtime_startup_timeout.py
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Startup deadlines must be independent of system clock corrections."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from tests.helpers import runtime
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture(params=["server", "stage_cli"])
+def startup_server(request, tmp_path, monkeypatch):
+    monkeypatch.setattr(runtime, "cleanup_test_environment", lambda: None)
+    proc = MagicMock(spec=runtime.subprocess.Popen)
+    proc.poll.return_value = None
+    monkeypatch.setattr(runtime.subprocess, "Popen", lambda *args, **kwargs: proc)
+    if request.param == "server":
+        # Exercise the wait-loop clock without reserving or inspecting real ports.
+        monkeypatch.setattr(runtime.OmniServer, "_reserve_port", lambda self: None)
+        monkeypatch.setattr(runtime.OmniServer, "_owns_listening_port", lambda self: True)
+        return runtime.OmniServer("fake-model", [])
+
+    config = tmp_path / "stages.yaml"
+    config.write_text("stages:\n  - stage_id: 0\n  - stage_id: 1\n")
+    server = runtime.OmniServerStageCli("fake-model", str(config), [])
+
+    def launch(stage_id, *, headless, replica_id=0):
+        server.stage_procs[(stage_id, replica_id)] = proc
+
+    monkeypatch.setattr(server, "_launch_stage", launch)
+    return server
+
+
+@pytest.mark.parametrize("wall_clock_jump", [3600, -3600])
+@pytest.mark.parametrize("becomes_ready", [True, False], ids=["ready", "timeout"])
+def test_startup_deadline_ignores_wall_clock_changes(startup_server, monkeypatch, wall_clock_jump, becomes_ready):
+    elapsed = 0.0
+    wall_offset = 0.0
+    first_probe_at = None
+    probes = 0
+
+    def sleep(seconds):
+        nonlocal elapsed
+        elapsed += seconds
+
+    # Replace only this module's clock, leaving pytest's own timing untouched.
+    monkeypatch.setattr(
+        runtime,
+        "time",
+        SimpleNamespace(
+            time=lambda: 1_700_000_000 + elapsed + wall_offset,
+            monotonic=lambda: elapsed,
+            perf_counter=lambda: elapsed,
+            sleep=sleep,
+        ),
+    )
+
+    def connect(address):
+        nonlocal probes, wall_offset, first_probe_at
+        assert address == (startup_server.host, startup_server.port)
+        if first_probe_at is None:
+            first_probe_at = elapsed
+        # Even a backwards clock correction must not extend the deadline.
+        assert elapsed - first_probe_at < runtime.SERVER_STARTUP_TIMEOUT_S, "startup exceeded its elapsed-time budget"
+        probes += 1
+        if probes == 1:
+            wall_offset += wall_clock_jump
+            return 111
+        return 0 if becomes_ready else 111
+
+    sock = MagicMock()
+    sock.__enter__.return_value = sock
+    sock.connect_ex.side_effect = connect
+    monkeypatch.setattr(runtime.socket, "socket", lambda *args, **kwargs: sock)
+
+    if becomes_ready:
+        startup_server._start_server()
+        assert probes == 2
+        assert first_probe_at is not None
+        assert elapsed - first_probe_at == 2
+    else:
+        with pytest.raises(RuntimeError, match=f"failed to start within {runtime.SERVER_STARTUP_TIMEOUT_S} seconds"):
+            startup_server._start_server()
+        assert first_probe_at is not None
+        assert elapsed - first_probe_at == runtime.SERVER_STARTUP_TIMEOUT_S
diff --git a/tests/metrics/test_stat_logger.py b/tests/metrics/test_stat_logger.py
index 3591579d8..97a18911d 100644
--- a/tests/metrics/test_stat_logger.py
+++ b/tests/metrics/test_stat_logger.py
@@ -1,8 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from __future__ import annotations
 
-import pytest
-from prometheus_client import CollectorRegistry, generate_latest
+import asyncio
+from unittest.mock import AsyncMock, Mock
 
+import pytest
+from prometheus_client import REGISTRY, CollectorRegistry, generate_latest
+from vllm.config import ModelConfig, ObservabilityConfig, SpeculativeConfig, VllmConfig
+from vllm.v1.engine import EngineCoreOutputs
+from vllm.v1.metrics.prometheus import unregister_vllm_metrics
+from vllm.v1.metrics.stats import IterationStats, SchedulerStats
+from vllm.v1.spec_decode.metrics import SpecDecodingStats
+
+from vllm_omni.engine.orchestrator import Orchestrator
+from vllm_omni.engine.stage_pool import StagePool
 from vllm_omni.metrics.stat_logger import (
     _ENGINE_INDEX_MAP,
     OmniPrometheusStatLogger,
@@ -454,3 +467,80 @@ class TestDoubleRewriteGuard:
         c.labels("m", "1", "stop").inc(3)
         out = generate_latest(fresh_registry).decode()
         assert 'dr_legacy_with_extra_total{model_name="m",reason="stop",replica="0",stage="1"} 3.0' in out
+
+
+@pytest.fixture
+def stats_config():
+    config = Mock(
+        spec=VllmConfig,
+        model_config=Mock(spec=ModelConfig, served_model_name="test-model", max_model_len=2048, is_diffusion=False),
+        observability_config=ObservabilityConfig(kv_cache_metrics=True),
+        speculative_config=Mock(spec=SpeculativeConfig, num_speculative_tokens=3),
+        kv_transfer_config=None,
+        lora_config=None,
+    )
+    yield config
+    unregister_vllm_metrics()
+
+
+@pytest.mark.parametrize("initial_map", [{}, {0: ("0", "0"), 1: ("1", "0")}])
+def test_register_replica_preserves_existing_metrics(stats_config, initial_map):
+    stat_logger = OmniPrometheusStatLogger(stats_config, dict(initial_map))
+    iteration = IterationStats()
+    iteration.num_generation_tokens = 7
+    if initial_map:
+        stat_logger.record(None, iteration, engine_idx=0)
+        stat_logger.record_sleep_state(sleep=1, level=1)
+    new_idx = len(initial_map)
+    stat_logger.register_replica(new_idx, "0", "4")
+    scheduler = SchedulerStats(num_running_reqs=2, num_waiting_reqs=3)
+    scheduler.spec_decoding_stats = SpecDecodingStats(
+        num_spec_tokens=3,
+        num_drafts=1,
+        num_draft_tokens=3,
+        num_accepted_tokens=2,
+        num_accepted_tokens_per_pos=[1, 1, 0],
+    )
+    stat_logger.record(scheduler, iteration, engine_idx=new_idx)
+    stat_logger.register_replica(new_idx, "0", "4")  # Rejoin keeps the same counters.
+    stat_logger.record(None, iteration, engine_idx=new_idx)
+    labels = {"model_name": "test-model", "stage": "0", "replica": "4"}
+    assert REGISTRY.get_sample_value("vllm:generation_tokens_total", labels) == 14
+    assert REGISTRY.get_sample_value("vllm:num_requests_running", labels) == 2
+    assert REGISTRY.get_sample_value("vllm:engine_sleep_state", labels | {"sleep_state": "awake"}) == 1
+    assert REGISTRY.get_sample_value("vllm:iteration_tokens_total_count", labels) == 2
+    assert (
+        REGISTRY.get_sample_value("vllm:spec_decode_num_accepted_tokens_per_pos_total", labels | {"position": "1"}) == 1
+    )
+    if initial_map:
+        assert (
+            REGISTRY.get_sample_value("vllm:engine_sleep_state", labels | {"replica": "0", "sleep_state": "awake"}) == 0
+        )
+        assert REGISTRY.get_sample_value("vllm:generation_tokens_total", labels | {"replica": "0"}) == 7
+    with pytest.raises(ValueError, match="already belongs"):
+        stat_logger.register_replica(new_idx, "2", "0")
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("initial_replicas", [0, 1])
+async def test_orchestrator_records_stats_from_late_replica(stats_config, initial_replicas):
+    pool = Mock(spec=StagePool, num_replicas=initial_replicas, stage_vllm_config=stats_config)
+    pool.available_replica_ids.return_value = list(range(initial_replicas))
+    pool.process_llm_raw_outputs = AsyncMock(return_value=[])
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=asyncio.Queue(),
+        stage_pools=[pool],
+        log_stats=True,
+    )
+    raw = EngineCoreOutputs(outputs=[], scheduler_stats=SchedulerStats(num_running_reqs=5))
+    await orchestrator._process_llm_stage_outputs(0, 3, raw, set())
+    assert (
+        REGISTRY.get_sample_value(
+            "vllm:num_requests_running", {"model_name": "test-model", "stage": "0", "replica": "3"}
+        )
+        == 5
+    )
+    await orchestrator._process_llm_stage_outputs(0, 3, raw, set())
+    assert len(orchestrator._stage_replica_to_engine_idx) == initial_replicas + 1
diff --git a/tests/model_executor/models/breeze_tts_2/test_instruction.py b/tests/model_executor/models/breeze_tts_2/test_instruction.py
index 3817ccb30..c7f2fef66 100644
--- a/tests/model_executor/models/breeze_tts_2/test_instruction.py
+++ b/tests/model_executor/models/breeze_tts_2/test_instruction.py
@@ -4,6 +4,7 @@
 from types import SimpleNamespace
 
 import pytest
+from vllm import SamplingParams
 
 from vllm_omni.entrypoints.openai.tts_adapters.breeze_tts_2 import BreezeTTS2Adapter
 from vllm_omni.model_executor.models.breeze_tts_2.prompt_builder import (
@@ -133,3 +134,24 @@ def test_non_greedy_sampling_overrides_are_rejected():
     assert "greedy" in adapter.validate(_request({"top_p": 0.9}))
     assert "greedy" in adapter.validate(_request({"top_k": 50}))
     assert "temperature must be a number" in adapter.validate(_request({"temperature": "warm"}))
+
+
+@pytest.mark.parametrize("value", [0, -1, float("nan"), float("inf"), "invalid"])
+def test_invalid_repetition_penalties_are_rejected(value):
+    assert "repetition_penalty" in _adapter().validate(_request({"repetition_penalty": value}))
+
+
+@pytest.mark.parametrize("value", [0.9, 1.0, 1.1, "1.2"])
+@pytest.mark.parametrize("max_new_tokens", [None, 32])
+def test_repetition_penalty_override_reaches_standard_sampling_metadata(value, max_new_tokens):
+    adapter = _adapter()
+    request = _request({"repetition_penalty": value}, max_new_tokens=max_new_tokens)
+    original = [SamplingParams(max_tokens=128, repetition_penalty=1.1)]
+
+    assert adapter.validate(request) is None
+    updated = adapter.apply_sampling_overrides(original, request)
+
+    assert updated[0].repetition_penalty == float(value)
+    assert updated[0].max_tokens == (128 if max_new_tokens is None else max_new_tokens)
+    assert original[0].repetition_penalty == 1.1
+    assert original[0].max_tokens == 128
diff --git a/tests/model_executor/models/breeze_tts_2/test_repetition_penalty.py b/tests/model_executor/models/breeze_tts_2/test_repetition_penalty.py
new file mode 100644
index 000000000..0edaabc6f
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_repetition_penalty.py
@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from typing import Any
+
+import pytest
+import torch
+from vllm.v1.sample.logits_processor import LogitsProcessors
+from vllm.v1.sample.metadata import SamplingMetadata
+
+from tests.model_executor.models.breeze_tts_2.test_talker_state_machine import _depth_codes, _talker
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _model(first_score=11.0, second_score=10.5):
+    model = _talker()
+    model._async_chunk = True
+    logits = torch.full((1, 9), -100.0)
+    logits[0, 2:4] = torch.tensor([first_score, second_score])
+    model._main_head_logits = lambda hidden: logits.expand(hidden.shape[0], -1).clone()
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    return model
+
+
+def _step(model, infos, penalties, *, no_penalties=False):
+    return model.make_omni_output(
+        torch.zeros(len(infos), 16),
+        model_intermediate_buffer=infos,
+        request_token_spans=[(i, i + 1) for i in range(len(infos))],
+        sampling_metadata=SamplingMetadata(
+            temperature=None,
+            all_greedy=True,
+            all_random=False,
+            top_p=None,
+            top_k=None,
+            generators={},
+            max_num_logprobs=None,
+            no_penalties=no_penalties,
+            frequency_penalties=torch.zeros(len(infos)),
+            presence_penalties=torch.zeros(len(infos)),
+            repetition_penalties=torch.tensor(penalties),
+            # Text/reference conditioning must never be counted as generated
+            # codec history, even if the scheduler ids overlap the codec ids.
+            prompt_token_ids=torch.tensor([[2, 2]] * len(infos)),
+            output_token_ids=[list(info.get("breeze_generated_code0_ids", [])) for info in infos],
+            allowed_token_ids_mask=None,
+            bad_words_token_ids={},
+            logitsprocs=LogitsProcessors(),
+        ),
+    )
+
+
+@pytest.mark.parametrize("scores", [(11.0, 10.5), (-1.0, -1.05)])
+def test_penalty_applies_once_per_generated_token_and_respects_logit_sign(scores):
+    model = _model(*scores)
+    info = {"prompt_ids": torch.tensor([2]), "input_values": torch.tensor([[2, 3, 4, 5]])}
+    chosen = []
+
+    for _ in range(4):
+        output = _step(model, [info], [1.1])
+        chosen.append(output.multimodal_outputs["codes"]["audio"][0][0, 0].item())
+
+    assert chosen == [2, 3, 2, 2]
+
+
+def test_request_history_and_penalty_are_independent():
+    model = _model()
+    first: dict[str, Any] = {}
+    second: dict[str, Any] = {}
+    _step(model, [first], [1.1])
+    output = _step(model, [first, second], [1.1, 1.1])
+    assert [codes[0, 0].item() for codes in output.multimodal_outputs["codes"]["audio"]] == [3, 2]
+
+    # Reverse the batch order; a request's history follows its state, while
+    # each penalty follows the current sampling-metadata row.
+    output = _step(model, [second, first], [1.1, 1.0])
+    assert [codes[0, 0].item() for codes in output.multimodal_outputs["codes"]["audio"]] == [3, 2]
+
+
+def test_disabled_penalties_do_not_read_uninitialized_sampling_buffer():
+    model = _model()
+    info: dict[str, Any] = {}
+    for _ in range(2):
+        output = _step(model, [info], [float("nan")], no_penalties=True)
+        assert output.multimodal_outputs["codes"]["audio"][0][0, 0].item() == 2
+
+
+def test_scheduler_logits_preserve_selected_frame_under_further_sampling_transforms():
+    model = _model()
+    info: dict[str, Any] = {}
+    _step(model, [info], [1.1])
+    output = _step(model, [info], [1.1])
+    selected = output.multimodal_outputs["codes"]["audio"][0][0, 0].item()
+    logits = model.compute_logits(torch.zeros(1, 16))
+
+    assert selected == 3
+    assert logits.argmax(dim=-1).item() == selected
+    assert torch.isfinite(logits).sum().item() == 1
+    assert logits[0, selected].item() == 0.0
+    # The scheduler may apply repetition again and rescale temperature. A
+    # finite zero for the selected token preserves a valid point mass.
+    for temperature in (0.1, 0.9, 2.0):
+        probabilities = torch.softmax(logits / 1.1 / temperature, dim=-1)
+        assert torch.isfinite(probabilities).all()
+        assert probabilities[0, selected].item() == 1.0
+
+
+def test_repetition_penalty_can_select_eos_without_emitting_a_frame():
+    model = _model()
+    info: dict[str, Any] = {}
+    _step(model, [info], [1.1])
+    logits = torch.full((1, 9), -100.0)
+    logits[0, 2] = 11.0
+    logits[0, 8] = 10.5
+    model._main_head_logits = lambda hidden: logits.expand(hidden.shape[0], -1).clone()
+
+    output = _step(model, [info], [1.1])
+
+    assert output.multimodal_outputs["codes"]["audio"][0].numel() == 0
+    assert info["breeze_generated_frames"] == 1
+    assert model.compute_logits(torch.zeros(1, 16)).argmax(dim=-1).item() == 8
diff --git a/tests/model_executor/models/breeze_tts_2/test_sampling_eos.py b/tests/model_executor/models/breeze_tts_2/test_sampling_eos.py
new file mode 100644
index 000000000..8cd389d17
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_sampling_eos.py
@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from pathlib import Path
+
+import pytest
+import torch
+import yaml
+from vllm import SamplingParams
+from vllm.v1.core.sched.utils import check_stop
+from vllm.v1.request import Request, RequestStatus
+from vllm.v1.sample.logits_processor import BatchUpdate, MinTokensLogitsProcessor
+
+from vllm_omni.config.stage_config import merge_sampling_constraints
+from vllm_omni.model_executor.models.breeze_tts_2.pipeline import BREEZE_TTS_2_PIPELINE
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def talker_sampling_params():
+    deploy_path = Path(__file__).parents[4] / "vllm_omni" / "deploy" / "breeze_tts_2.yaml"
+    deploy = yaml.safe_load(deploy_path.read_text(encoding="utf-8"))
+    params = SamplingParams(
+        **merge_sampling_constraints(
+            deploy["stages"][0]["default_sampling_params"],
+            BREEZE_TTS_2_PIPELINE.stages[0].sampling_constraints,
+        )
+    )
+    # Mirror the input processor: Breeze's text tokenizer uses EOS 1,
+    # which is also an ordinary token in the generated codec vocabulary.
+    params.update_from_generation_config({"eos_token_id": [1]}, eos_token_id=1)
+    return params
+
+
+@pytest.mark.parametrize("codec_token, should_stop", [(0, False), (1, False), (2047, False), (2051, True)])
+def test_scheduler_stops_only_on_codec_eos(talker_sampling_params, codec_token, should_stop):
+    request = Request(
+        request_id="breeze-eos-test",
+        prompt_token_ids=[7, 8, 9],
+        sampling_params=talker_sampling_params,
+        pooling_params=None,
+    )
+    request.append_output_token_ids([42, codec_token])
+    request.status = RequestStatus.RUNNING
+
+    assert check_stop(request, max_model_len=4096) is should_stop
+    if should_stop:
+        assert request.status == RequestStatus.FINISHED_STOPPED
+        assert request.stop_reason == 2051
+    else:
+        assert request.status == RequestStatus.RUNNING
+
+
+@pytest.mark.parametrize("codec_token", [1, 2051])
+def test_first_step_keeps_codec_token_and_eos_logits(talker_sampling_params, codec_token, monkeypatch):
+    # vLLM's tensor helper uses a global flag rather than is_pin_memory,
+    # and pinned allocations require a CUDA device even for this CPU test.
+    monkeypatch.setattr("vllm.utils.torch_utils.PIN_MEMORY", False)
+    # ignore_eos still leaves text EOS in all_stop_token_ids. Exercise the
+    # actual processor so the first codec frame and immediate EOS stay valid.
+    processor = MinTokensLogitsProcessor(None, device=torch.device("cpu"), is_pin_memory=False)
+    processor.update_state(
+        BatchUpdate(batch_size=1, removed=[], added=[(0, talker_sampling_params, None, [])], moved=[])
+    )
+    logits = torch.full((1, 2052), -float("inf"))
+    logits[0, codec_token] = 0.0
+
+    processed = processor.apply(logits.clone())
+
+    assert torch.equal(processed, logits)
+    assert processed.argmax(dim=-1).item() == codec_token
+
+
+def test_pipeline_disallows_minimum_tokens_that_mask_selected_codec_ids():
+    params = merge_sampling_constraints({"min_tokens": 10}, BREEZE_TTS_2_PIPELINE.stages[0].sampling_constraints)
+    assert params["min_tokens"] == 0
diff --git a/tests/model_executor/models/breeze_tts_2/test_streaming.py b/tests/model_executor/models/breeze_tts_2/test_streaming.py
index 045444ec3..a630b90bc 100644
--- a/tests/model_executor/models/breeze_tts_2/test_streaming.py
+++ b/tests/model_executor/models/breeze_tts_2/test_streaming.py
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+import copy
 from collections import defaultdict
 from types import SimpleNamespace
 
@@ -20,7 +21,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 class _TransferManager:
     def __init__(self, chunk_frames: int = 4):
         self.connector = SimpleNamespace(config={"breeze_codec_chunk_frames": chunk_frames})
-        self.code_prompt_token_ids = defaultdict(list)
+        self.code_prompt_token_ids: defaultdict[str, list[torch.Tensor]] = defaultdict(list)
 
 
 class _Request:
@@ -120,7 +121,8 @@ def test_stateful_codec_rejects_partial_frame_chunk():
     assert decoder.calls == []
 
 
-def test_stateful_codec_terminal_marker_pops_state_without_decoding():
+@pytest.mark.parametrize("token_counts", [(4, 0), (0, 4), (0, 4, 0, 8, 0)])
+def test_stateful_codec_terminal_marker_pops_state_without_decoding(token_counts):
     decoder = _Decoder()
     codec = object.__new__(BreezeTTS2MimiCodec)
     codec._async_chunk = True
@@ -128,24 +130,114 @@ def test_stateful_codec_terminal_marker_pops_state_without_decoding():
     codec._codebook_size = 8
     codec._sample_rate = 24_000
     codec._audio_tokenizer = SimpleNamespace(model=SimpleNamespace(decoder=decoder))
-    codec._decoder_state_cache = {"scheduler-live": {}, "scheduler-done": {}}
+    request_ids = [f"scheduler-{index}" for index in range(len(token_counts))]
+    codec._decoder_state_cache = {request_id: {} for request_id in request_ids}
 
     output = codec.forward(
-        torch.tensor([0, 1, 2, 3], dtype=torch.long),
+        torch.arange(sum(token_counts), dtype=torch.long) % codec._codebook_size,
         runtime_additional_information=[
             # Plain ``finished`` covers the fallback for direct in-process
             # callers that do not go through the connector receiver.
-            {"meta": {"request_id": "live", "finished": False}},
-            {"meta": {"request_id": "done", "finished": True}},
+            {"meta": {"finished": count == 0}}
+            for count in token_counts
         ],
-        seq_token_counts=[4, 0],
-        request_ids=["scheduler-live", "scheduler-done"],
+        seq_token_counts=token_counts,
+        request_ids=request_ids,
     )
 
-    # The empty terminal marker decodes nothing and releases its state; the
-    # live request still decodes its own chunk.
+    # Empty terminal markers release their state without consuming an output
+    # slot belonging to another request, regardless of their batch position.
     assert len(decoder.calls) == 1
-    assert decoder.calls[0][0][0] == 1
-    assert [item.numel() for item in output.multimodal_outputs["model_outputs"]] == [1920, 0]
-    assert list(codec._decoder_state_cache) == ["scheduler-live"]
-    assert codec._decoder_state_cache["scheduler-live"]["prefix_frames"] == 0
+    assert decoder.calls[0][0][0] == sum(count > 0 for count in token_counts)
+    assert [item.numel() for item in output.multimodal_outputs["model_outputs"]] == [
+        count // codec._num_codebooks * 1920 for count in token_counts
+    ]
+    live_request_ids = [request_id for request_id, count in zip(request_ids, token_counts) if count]
+    assert list(codec._decoder_state_cache) == live_request_ids
+    assert all(codec._decoder_state_cache[request_id]["prefix_frames"] == 0 for request_id in live_request_ids)
+
+
+@pytest.mark.parametrize("configured_chunk_frames", [None, 4])
+def test_stateful_codec_advances_decoder_cache_after_sliding_window(monkeypatch, tmp_path, configured_chunk_frames):
+    from vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_tokenizer import Qwen3TTSTokenizer
+    from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz.configuration_qwen3_tts_tokenizer_v2 import (
+        Qwen3TTSTokenizerV2DecoderConfig,
+    )
+    from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz.modeling_qwen3_tts_tokenizer_v2 import (
+        Qwen3TTSTokenizerV2Decoder,
+    )
+
+    torch.manual_seed(0)
+    config = Qwen3TTSTokenizerV2DecoderConfig(
+        codebook_size=32,
+        hidden_size=16,
+        latent_dim=16,
+        codebook_dim=16,
+        num_attention_heads=2,
+        num_key_value_heads=2,
+        intermediate_size=32,
+        num_hidden_layers=1,
+        num_quantizers=2,
+        decoder_dim=32,
+        upsample_rates=(2,),
+        upsampling_ratios=(2,),
+        sliding_window=72,
+    )
+    decoder = Qwen3TTSTokenizerV2Decoder(config).eval()
+    # Codebooks initialize to zeros before checkpoint loading; populate them
+    # so different codec IDs produce distinguishable cached frame histories.
+    with torch.no_grad():
+        for name, parameter in decoder.quantizer.named_parameters():
+            if name.endswith("embedding_sum"):
+                parameter.normal_()
+    tokenizer = SimpleNamespace(model=SimpleNamespace(decoder=decoder, get_output_sample_rate=lambda: 24_000))
+    monkeypatch.setattr(Qwen3TTSTokenizer, "from_pretrained", lambda *args, **kwargs: tokenizer)
+    connector_extra = {} if configured_chunk_frames is None else {"breeze_codec_chunk_frames": configured_chunk_frames}
+    chunk_frames = configured_chunk_frames or 8
+    codec = object.__new__(BreezeTTS2MimiCodec)
+    codec.vllm_config = SimpleNamespace(
+        model_config=SimpleNamespace(stage_connector_config={"extra": connector_extra}),
+        device_config=SimpleNamespace(device="cpu"),
+    )
+    codec._tokenizer_path = tmp_path / "audio_tokenizer"
+    codec._audio_tokenizer = None
+    codec._async_chunk = True
+    codec._num_codebooks = config.num_quantizers
+    codec._codebook_size = config.codebook_size
+    codec._decoder_state_cache = {}
+    codec.load_weights(iter(()))
+
+    # At least two chunks after the decoder's rolling window expose a stale
+    # cache even when the first padded chunk still produces plausible audio.
+    total_frames = config.sliding_window + 2 * chunk_frames
+    tail_frames = 3
+    codes = torch.randint(0, config.codebook_size, (1, config.num_quantizers, total_frames + tail_frames))
+    for end in range(chunk_frames, total_frames + 1, chunk_frames):
+        flat = codes[0, :, end - chunk_frames : end].reshape(-1)
+        codec.forward(
+            flat,
+            runtime_additional_information=[{"meta": {"stream_finished": False}}],
+            seq_token_counts=[flat.numel()],
+            request_ids=["scheduler-live"],
+        )
+        state = codec._decoder_state_cache["scheduler-live"]
+        assert state["suffix_frames"] == min(end - chunk_frames, config.sliding_window) + chunk_frames
+        with torch.inference_mode():
+            expected_quantized = decoder.quantizer.decode(codes[..., max(0, end - config.sliding_window) : end])
+        torch.testing.assert_close(state["suffix_quantized"], expected_quantized)
+
+    # A short terminal chunk must emit only its real frames, then release
+    # state. Its waveform should agree with the unpadded single-request path.
+    with torch.inference_mode():
+        expected_tail = decoder.chunked_decode(codes[..., -tail_frames:], caches=copy.deepcopy(state))
+    flat_tail = codes[0, :, -tail_frames:].reshape(-1)
+    output = codec.forward(
+        flat_tail,
+        runtime_additional_information=[{"meta": {"stream_finished": True}}],
+        seq_token_counts=[flat_tail.numel()],
+        request_ids=["scheduler-live"],
+    )
+    waveform = output.multimodal_outputs["model_outputs"][0]
+    assert waveform.numel() == tail_frames * decoder.total_upsample
+    torch.testing.assert_close(waveform, expected_tail.reshape(-1), atol=1e-5, rtol=1e-4)
+    assert codec._decoder_state_cache == {}
diff --git a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
index 7dfbe6e74..46255110c 100644
--- a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
+++ b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
@@ -10,11 +10,11 @@ import pytest
 import torch
 import torch.nn as nn
 
-from tests.helpers.mark import hardware_test
 from vllm_omni.diffusion.config import set_current_diffusion_config
 from vllm_omni.diffusion.data import AttentionConfig
 from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.hifigan import (
     CausalHiFTGenerator,
+    HiFTGenerator,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -76,6 +76,39 @@ def test_causal_hift_stft_moves_window_to_input_device(causal_hift):
     assert causal_hift.stft_window.device == waveform.device
 
 
+class _MinimalF0Predictor(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.proj = nn.Conv1d(80, 1, 1)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.proj(x).squeeze(1).abs()
+
+
+@pytest.mark.parametrize("sampling_rate", [22050, 24000])
+def test_noncausal_hift_inference_runs_with_real_sinegen(sampling_rate):
+    """Base (non-causal) HiFTGenerator with a real SineGen/SineGen2 (not a
+    test double) must still run: SourceModuleHnNSF/SineGen/SineGen2/_f02sine
+    all branch on `self.causal` to return the pre-streaming (shorter) tuple
+    contract for non-causal callers, and any one of them regressing back to
+    always returning the streaming-length tuple breaks this immediately.
+    """
+    hift = HiFTGenerator(
+        base_channels=32,
+        sampling_rate=sampling_rate,
+        upsample_rates=[8, 5, 3],
+        upsample_kernel_sizes=[16, 11, 7],
+        source_resblock_kernel_sizes=[7, 7, 11],
+        source_resblock_dilation_sizes=[[1, 3, 5]] * 3,
+        f0_predictor=_MinimalF0Predictor(),
+    ).eval()
+
+    speech, _ = hift.inference(torch.randn(1, 80, 20))
+
+    assert speech.shape[0] == 1
+    assert torch.isfinite(speech).all()
+
+
 def test_causal_hift_routes_npu_transforms_to_cpu_fallback(causal_hift, monkeypatch):
     class NpuTensor:
         device = SimpleNamespace(type="npu")
@@ -83,16 +116,17 @@ def test_causal_hift_routes_npu_transforms_to_cpu_fallback(causal_hift, monkeypa
     tensor = NpuTensor()
     stft_calls = []
     istft_calls = []
-    monkeypatch.setattr(
-        causal_hift,
-        "_stft_on_cpu",
-        lambda value: stft_calls.append(value) or ("real", "imag"),
-    )
-    monkeypatch.setattr(
-        causal_hift,
-        "_istft_on_cpu",
-        lambda magnitude, phase: istft_calls.append((magnitude, phase)) or "waveform",
-    )
+
+    def fake_stft(value):
+        stft_calls.append(value)
+        return ("real", "imag")
+
+    def fake_istft(magnitude, phase):
+        istft_calls.append((magnitude, phase))
+        return "waveform"
+
+    monkeypatch.setattr(causal_hift, "_stft_on_cpu", fake_stft)
+    monkeypatch.setattr(causal_hift, "_istft_on_cpu", fake_istft)
 
     assert causal_hift._stft(tensor) == ("real", "imag")
     assert causal_hift._istft(tensor, tensor) == "waveform"
@@ -627,7 +661,11 @@ def test_code2wav_forward_finalizes_hift_tail():
 
         def inference(self, speech_feat, finalize=True):
             self.finalize_calls.append(bool(finalize))
-            return torch.zeros((speech_feat.shape[0], 1, speech_feat.shape[-1]), dtype=speech_feat.dtype), None
+            return (
+                torch.zeros((speech_feat.shape[0], 1, speech_feat.shape[-1]), dtype=speech_feat.dtype),
+                None,
+                None,
+            )
 
     model = object.__new__(CosyVoice3Code2Wav)
     nn.Module.__init__(model)
@@ -693,114 +731,3 @@ def test_code2wav_streaming_batch_pads_codec_tokens_and_preserves_lengths():
     assert torch.equal(call["token_lens"], torch.tensor([3, 5], dtype=torch.int32))
     assert results[0][0].shape[-1] == 4
     assert results[1][0].shape[-1] == 8
-
-
-@pytest.mark.core_model
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_code2wav_streaming_batch_matches_ragged_flow_numerics(monkeypatch):
-    """A padded flow batch must match individual flow calls on valid mels."""
-    from omegaconf import DictConfig
-
-    from vllm_omni.diffusion.models.cosyvoice3_audio.cosyvoice3_dit import DiT
-    from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.cfm import (
-        CausalConditionalCFM,
-        CausalMaskedDiffWithDiT,
-    )
-    from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.layers import PreLookaheadLayer
-    from vllm_omni.model_executor.models.cosyvoice3.cosyvoice3_code2wav import CosyVoice3Code2Wav
-
-    torch.manual_seed(0)
-    estimator = DiT(
-        dim=32,
-        depth=1,
-        heads=4,
-        dim_head=8,
-        dropout=0.0,
-        ff_mult=2,
-        mel_dim=80,
-        mu_dim=80,
-        spk_dim=80,
-        out_channels=80,
-    )
-    decoder = CausalConditionalCFM(
-        in_channels=80,
-        cfm_params=DictConfig(
-            {
-                "sigma_min": 1e-6,
-                "solver": "euler",
-                "t_scheduler": "cosine",
-                "training_cfg_rate": 0.2,
-                "inference_cfg_rate": 0.7,
-            }
-        ),
-        n_spks=1,
-        spk_emb_dim=80,
-        estimator=estimator,
-    )
-    flow_model = (
-        CausalMaskedDiffWithDiT(
-            input_size=80,
-            output_size=80,
-            spk_embed_dim=192,
-            vocab_size=64,
-            input_frame_rate=25,
-            only_mask_loss=True,
-            token_mel_ratio=2,
-            pre_lookahead_len=1,
-            pre_lookahead_layer=PreLookaheadLayer(in_channels=80, channels=80, pre_lookahead_len=1),
-            decoder=decoder,
-        )
-        .to(device="cuda", dtype=torch.bfloat16)
-        .eval()
-    )
-
-    model = object.__new__(CosyVoice3Code2Wav)
-    nn.Module.__init__(model)
-    model.flow_model = flow_model
-
-    def return_mel(self, feat, *, cache_state=None, finalize=False):
-        return feat, None
-
-    model._stream_hift_from_feat = types.MethodType(return_mel, model)
-
-    original_randn = torch.randn
-
-    def length_consistent_randn(*size, **kwargs):
-        shape = tuple(size[0]) if len(size) == 1 and isinstance(size[0], (tuple, list)) else tuple(size)
-        if len(shape) == 3 and shape[1] == 80:
-            device = kwargs.get("device")
-            dtype = kwargs.get("dtype", torch.float32)
-            channels = torch.arange(shape[1], device=device, dtype=torch.float32).view(1, -1, 1)
-            positions = torch.arange(shape[2], device=device, dtype=torch.float32).view(1, 1, -1)
-            noise = torch.sin(channels * 0.17 + positions * 0.31)
-            return noise.expand(shape[0], -1, -1).to(dtype=dtype).clone()
-        return original_randn(*size, **kwargs)
-
-    monkeypatch.setattr(torch, "randn", length_consistent_randn)
-    common = {
-        "prompt_token": torch.tensor([[7, 8]], dtype=torch.int32),
-        "prompt_feat": torch.linspace(-0.5, 0.5, 4 * 80).reshape(1, 4, 80),
-        "embedding": torch.linspace(-1.0, 1.0, 192).reshape(1, 192),
-        "finalize": False,
-    }
-    items = [
-        {**common, "token": torch.tensor([[1, 2, 3]], dtype=torch.int32)},
-        {**common, "token": torch.tensor([[1, 2, 3, 4, 5]], dtype=torch.int32)},
-    ]
-
-    batched = model.forward_streaming_batch(items, n_timesteps=2)
-    individual = [
-        model.forward_streaming(
-            token=item["token"],
-            prompt_token=item["prompt_token"],
-            prompt_feat=item["prompt_feat"],
-            embedding=item["embedding"],
-            n_timesteps=2,
-        )
-        for item in items
-    ]
-
-    for (batched_mel, _), (individual_mel, _) in zip(batched, individual):
-        assert batched_mel.shape == individual_mel.shape
-        rel_mean = (batched_mel - individual_mel).abs().mean() / individual_mel.abs().mean().clamp_min(1e-6)
-        assert rel_mean.item() < 0.05
diff --git a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components_cuda.py b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components_cuda.py
new file mode 100644
index 000000000..aff89f852
--- /dev/null
+++ b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components_cuda.py
@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CUDA-only CosyVoice3 component tests."""
+
+import types
+
+import pytest
+import torch
+import torch.nn as nn
+
+from tests.helpers.mark import hardware_test
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="requires CUDA"),
+]
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_code2wav_streaming_batch_matches_ragged_flow_numerics(monkeypatch):
+    """A padded flow batch must match individual flow calls on valid mels."""
+    from omegaconf import DictConfig
+
+    from vllm_omni.diffusion.models.cosyvoice3_audio.cosyvoice3_dit import DiT
+    from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.cfm import (
+        CausalConditionalCFM,
+        CausalMaskedDiffWithDiT,
+    )
+    from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.layers import PreLookaheadLayer
+    from vllm_omni.model_executor.models.cosyvoice3.cosyvoice3_code2wav import CosyVoice3Code2Wav
+
+    torch.manual_seed(0)
+    estimator = DiT(
+        dim=32,
+        depth=1,
+        heads=4,
+        dim_head=8,
+        dropout=0.0,
+        ff_mult=2,
+        mel_dim=80,
+        mu_dim=80,
+        spk_dim=80,
+        out_channels=80,
+    )
+    decoder = CausalConditionalCFM(
+        in_channels=80,
+        cfm_params=DictConfig(
+            {
+                "sigma_min": 1e-6,
+                "solver": "euler",
+                "t_scheduler": "cosine",
+                "training_cfg_rate": 0.2,
+                "inference_cfg_rate": 0.7,
+            }
+        ),
+        n_spks=1,
+        spk_emb_dim=80,
+        estimator=estimator,
+    )
+    flow_model = (
+        CausalMaskedDiffWithDiT(
+            input_size=80,
+            output_size=80,
+            spk_embed_dim=192,
+            vocab_size=64,
+            input_frame_rate=25,
+            only_mask_loss=True,
+            token_mel_ratio=2,
+            pre_lookahead_len=1,
+            pre_lookahead_layer=PreLookaheadLayer(in_channels=80, channels=80, pre_lookahead_len=1),
+            decoder=decoder,
+        )
+        .to(device="cuda", dtype=torch.bfloat16)
+        .eval()
+    )
+
+    model = object.__new__(CosyVoice3Code2Wav)
+    nn.Module.__init__(model)
+    model.flow_model = flow_model
+
+    def return_mel(self, feat, *, cache_state=None, finalize=False):
+        return feat, None
+
+    model._stream_hift_from_feat = types.MethodType(return_mel, model)
+
+    original_randn = torch.randn
+
+    def length_consistent_randn(*size, **kwargs):
+        shape = tuple(size[0]) if len(size) == 1 and isinstance(size[0], (tuple, list)) else tuple(size)
+        if len(shape) == 3 and shape[1] == 80:
+            device = kwargs.get("device")
+            dtype = kwargs.get("dtype", torch.float32)
+            channels = torch.arange(shape[1], device=device, dtype=torch.float32).view(1, -1, 1)
+            positions = torch.arange(shape[2], device=device, dtype=torch.float32).view(1, 1, -1)
+            noise = torch.sin(channels * 0.17 + positions * 0.31)
+            return noise.expand(shape[0], -1, -1).to(dtype=dtype).clone()
+        return original_randn(*size, **kwargs)
+
+    monkeypatch.setattr(torch, "randn", length_consistent_randn)
+    common = {
+        "prompt_token": torch.tensor([[7, 8]], dtype=torch.int32),
+        "prompt_feat": torch.linspace(-0.5, 0.5, 4 * 80).reshape(1, 4, 80),
+        "embedding": torch.linspace(-1.0, 1.0, 192).reshape(1, 192),
+        "finalize": False,
+    }
+    items = [
+        {**common, "token": torch.tensor([[1, 2, 3]], dtype=torch.int32)},
+        {**common, "token": torch.tensor([[1, 2, 3, 4, 5]], dtype=torch.int32)},
+    ]
+
+    batched = model.forward_streaming_batch(items, n_timesteps=2)
+    individual = [
+        model.forward_streaming(
+            token=item["token"],
+            prompt_token=item["prompt_token"],
+            prompt_feat=item["prompt_feat"],
+            embedding=item["embedding"],
+            n_timesteps=2,
+        )
+        for item in items
+    ]
+
+    for (batched_mel, _), (individual_mel, _) in zip(batched, individual):
+        assert batched_mel.shape == individual_mel.shape
+        rel_mean = (batched_mel - individual_mel).abs().mean() / individual_mel.abs().mean().clamp_min(1e-6)
+        assert rel_mean.item() < 0.05
diff --git a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_incremental_hift.py b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_incremental_hift.py
new file mode 100644
index 000000000..91b322864
--- /dev/null
+++ b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_incremental_hift.py
@@ -0,0 +1,420 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Correctness + boundedness tests for the incremental (windowed) HiFT path.
+
+The streaming vocoder runs HiFT over a bounded mel window instead of the full
+cumulative history, carrying harmonic phase and noise-buffer offset across
+chunks.
+
+* **Correctness** — windowed output must match the full cumulative re-run.
+  With full history the match is bit-exact (proves the phase/noise carry is
+  right). With a bounded window, float64 still agrees to ~1e-16 (the window
+  is algebraically exact); float32 differs by ~2e-7 absolute (reassociation
+  rounding, not truncation), so tests assert a tight atol/rtol rather than
+  PCM16 byte-identity, since a sub-LSB perturbation can flip a boundary sample.
+* **Boundedness** — the per-chunk window must not grow with mel history.
+
+Tests are parametrized across REAL_CONFIG (24000 Hz -> SineGen2, what
+CosyVoice3 ships) and LEGACY_CONFIG (22050 Hz -> SineGen) so a class-selection
+regression in either path is caught.
+"""
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.hifigan import (
+    CausalConvRNNF0Predictor,
+    CausalHiFTGenerator,
+    SineGen,
+    SineGen2,
+    _wrapped_slice,
+)
+from vllm_omni.model_executor.models.cosyvoice3.cosyvoice3_code2wav import CosyVoice3Code2Wav
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+CHUNK_LEN = 24
+TOTAL_MEL = 96
+SPM = 480  # samples per mel frame for the small test HiFT (8*5*3*4), matching the real model
+
+LONG_TOTAL_MEL = 400  # long enough that the 64-frame window actually truncates
+PCM16_LSB = 1.0 / 32767.0  # smallest representable PCM16 difference
+
+# Worst observed deviation is 1.97e-7 (~2x float32 eps); atol=1e-6 keeps 5x headroom.
+ATOL = 1e-6
+RTOL = 1e-5
+
+# What CosyVoice3 ships (-> SineGen2). nb_harmonics=8 is required, not a free
+# choice: SineGen2's causal buffers are hardcoded to dim 9 (= harmonic_num+1).
+REAL_CONFIG = {"sampling_rate": 24000, "nb_harmonics": 8}
+LEGACY_CONFIG = {"sampling_rate": 22050, "nb_harmonics": 4}  # -> SineGen, still shipped code
+
+CONFIGS = [
+    pytest.param(REAL_CONFIG, id="sinegen2_real_config"),
+    pytest.param(LEGACY_CONFIG, id="sinegen1_legacy_config"),
+]
+
+
+def _make_hift(config: dict = REAL_CONFIG) -> CausalHiFTGenerator:
+    """Small CausalHiFTGenerator; defaults to the config CosyVoice3 ships."""
+    torch.manual_seed(0)
+    f0_predictor = CausalConvRNNF0Predictor(num_class=1, in_channels=80, cond_channels=16)
+    return CausalHiFTGenerator(
+        in_channels=80,
+        base_channels=32,
+        nb_harmonics=config["nb_harmonics"],
+        sampling_rate=config["sampling_rate"],
+        upsample_rates=[8, 5, 3],
+        upsample_kernel_sizes=[16, 11, 7],
+        source_resblock_kernel_sizes=[7, 7, 11],
+        source_resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+        resblock_kernel_sizes=[3, 7, 11],
+        resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+        f0_predictor=f0_predictor,
+    ).eval()
+
+
+def test_real_config_resolves_to_sinegen2():
+    """Guard against silently testing the wrong SineGen class again."""
+    hift = _make_hift(REAL_CONFIG)
+    assert isinstance(hift.m_source.l_sin_gen, SineGen2)
+
+    hift_legacy = _make_hift(LEGACY_CONFIG)
+    assert isinstance(hift_legacy.m_source.l_sin_gen, SineGen)
+
+
+def _make_model(hift: CausalHiFTGenerator, window_len: int) -> CosyVoice3Code2Wav:
+    """Build a CosyVoice3Code2Wav shell wired to the given HiFT."""
+    model = object.__new__(CosyVoice3Code2Wav)
+    nn.Module.__init__(model)
+    model.hift = hift
+    model._hift_window_len = window_len
+    return model
+
+
+def _chunks(total_mel: int = TOTAL_MEL, chunk_len: int = CHUNK_LEN) -> list[torch.Tensor]:
+    torch.manual_seed(1)
+    mel = torch.randn(1, 80, total_mel)
+    return [mel[:, :, i : i + chunk_len] for i in range(0, total_mel, chunk_len)]
+
+
+def _variable_chunks(total_mel: int, first_len: int, step_len: int) -> list[torch.Tensor]:
+    """First chunk sized like a real prompt prefill, then small fixed-size steps."""
+    torch.manual_seed(1)
+    mel = torch.randn(1, 80, total_mel)
+    chunks = [mel[:, :, :first_len]]
+    pos = first_len
+    while pos < total_mel:
+        chunks.append(mel[:, :, pos : pos + step_len])
+        pos += step_len
+    return chunks
+
+
+def _full_reference(model: CosyVoice3Code2Wav, chunks: list[torch.Tensor]) -> torch.Tensor:
+    """Re-run HiFT over the full cumulative mel each chunk (pre-windowing behavior).
+
+    Uses non-finalize inference per chunk, matching the old streaming vocoder; a
+    single finalize pass would emit the look-right tail streaming holds back.
+    """
+    torch.manual_seed(0)
+    emitted = []
+    cache: dict[str, torch.Tensor] | None = None
+    for chunk in chunks:
+        cached = None if cache is None else cache.get("mel")
+        if cached is not None and cached.numel() > 0:
+            tts_mel = torch.cat([cached, chunk], dim=-1)
+        else:
+            tts_mel = chunk
+        speech, _, _ = model.hift.inference(speech_feat=tts_mel, finalize=False)
+        speech = speech.reshape(speech.shape[0], -1)
+        offset = 0 if cache is None else cache.get("speech_offset")
+        emitted.append(speech[:, offset:])
+        cache = {"mel": tts_mel.detach().cpu(), "speech_offset": int(speech.shape[-1])}
+    return torch.cat(emitted, dim=-1)
+
+
+def _pcm16(x: torch.Tensor) -> torch.Tensor:
+    """Quantize float audio to PCM16, the format the server streams to clients."""
+    return (x.clamp(-1, 1) * 32767).round().to(torch.int16)
+
+
+def _incremental(model: CosyVoice3Code2Wav, chunks: list[torch.Tensor]) -> torch.Tensor:
+    """Run the new windowed path via _stream_hift_from_feat."""
+    torch.manual_seed(0)
+    emitted = []
+    cache: dict[str, torch.Tensor] | None = None
+    for chunk in chunks:
+        speech, cache = model._stream_hift_from_feat(chunk, cache_state=cache, finalize=False)
+        emitted.append(speech.reshape(speech.shape[0], -1))
+    return torch.cat(emitted, dim=-1)
+
+
+def _rel_divergence(a: torch.Tensor, b: torch.Tensor) -> float:
+    return ((a - b).abs().mean() / a.abs().mean().clamp_min(1e-6)).item()
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+def test_incremental_hift_matches_full_reference_exactly_with_full_history(config):
+    """With a window covering the full history, the windowed path must match the
+    full cumulative re-run exactly. This proves the phase/noise carry is right."""
+    hift = _make_hift(config)
+    model = _make_model(hift, window_len=TOTAL_MEL)  # window >= history
+    chunks = _chunks()
+
+    full = _full_reference(model, chunks)
+    incr = _incremental(model, chunks)
+
+    assert full.shape == incr.shape, f"{full.shape} vs {incr.shape}"
+    assert _rel_divergence(full, incr) < 1e-6
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+def test_incremental_hift_bounded_window_is_close(config):
+    """With a bounded window, the windowed path stays close to the full re-run;
+    only the truncated deep history diverges, and it is small."""
+    hift = _make_hift(config)
+    model = _make_model(hift, window_len=48)
+    chunks = _chunks()
+
+    full = _full_reference(model, chunks)
+    incr = _incremental(model, chunks)
+
+    assert full.shape == incr.shape
+    torch.testing.assert_close(incr, full, atol=ATOL, rtol=RTOL)
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+def test_incremental_hift_matches_streaming_reference_within_tolerance(config):
+    """Windowed output matches the full-cumulative reference within float32 rounding.
+
+    The load-bearing correctness test: 400 mel frames far exceeds the 64-frame
+    window, so truncation genuinely exercises the phase/noise carry. Float64
+    agrees to ~1e-16, confirming the residual here is rounding, not truncation.
+    """
+    hift = _make_hift(config)
+    model = _make_model(hift, window_len=64)  # the real _hift_window_len
+    chunks = _chunks(total_mel=LONG_TOTAL_MEL)
+
+    trim = int(hift.f0_predictor.condnet[0].causal_padding)
+    assert LONG_TOTAL_MEL > 64 + trim + CHUNK_LEN  # window must actually truncate
+
+    full = _full_reference(model, chunks)
+    incr = _incremental(model, chunks)
+
+    assert full.shape == incr.shape, f"{full.shape} vs {incr.shape}"
+    torch.testing.assert_close(incr, full, atol=ATOL, rtol=RTOL)
+
+    max_dev = (full - incr).abs().max().item()  # stays far below one PCM16 step
+    assert max_dev < PCM16_LSB / 10, f"max deviation {max_dev:.3e} vs PCM16 LSB {PCM16_LSB:.3e}"
+
+
+def test_incremental_hift_window_is_bounded():
+    """Per-chunk window must not grow with cumulative mel history."""
+    hift = _make_hift()
+    model = _make_model(hift, window_len=32)
+    chunks = _chunks(total_mel=200, chunk_len=24)
+
+    trim = int(hift.f0_predictor.condnet[0].causal_padding)
+    f0_margin = int(hift.f0_predictor.left_context_frames)
+
+    cache = None
+    window_sizes = []
+    for chunk in chunks:
+        _, cache = model._stream_hift_from_feat(chunk, cache_state=cache, finalize=False)
+        window_sizes.append(int(cache["mel"].shape[-1]))
+
+    assert max(window_sizes) <= 32 + trim + f0_margin + 24  # bounded regardless of utterance length
+    steady = max(window_sizes)
+    assert window_sizes.count(steady) >= 2  # steady-state value repeats once history exceeds window
+
+
+def test_incremental_hift_finalize_releases_tail():
+    """Finalize must emit the released look-right tail without crashing."""
+    hift = _make_hift()
+    model = _make_model(hift, window_len=32)
+    chunks = _chunks(total_mel=72, chunk_len=24)
+
+    cache = None
+    emitted = []
+    for i, chunk in enumerate(chunks):
+        finalize = i == len(chunks) - 1
+        speech, cache = model._stream_hift_from_feat(chunk, cache_state=cache, finalize=finalize)
+        emitted.append(speech.reshape(speech.shape[0], -1))
+        if finalize:
+            assert cache is None
+
+    full = torch.cat(emitted, dim=-1)
+    assert full.shape[-1] > 0
+    assert torch.isfinite(full).all()
+
+
+def test_incremental_hift_emits_full_audio_length():
+    """Streamed output covers the full mel history at samples-per-mel resolution.
+
+    Guards against emission arithmetic dropping an upsample stage, which
+    silently truncates audio (e.g. 1/3 of expected length with [8,5,3]).
+    """
+    hift = _make_hift()
+    model = _make_model(hift, window_len=32)
+    chunks = _chunks(total_mel=72, chunk_len=24)
+
+    cache = None
+    emitted = []
+    for i, chunk in enumerate(chunks):
+        finalize = i == len(chunks) - 1
+        speech, cache = model._stream_hift_from_feat(chunk, cache_state=cache, finalize=finalize)
+        emitted.append(speech.reshape(speech.shape[0], -1))
+        if finalize:
+            assert cache is None
+
+    full = torch.cat(emitted, dim=-1)
+    # total_mel * SPM, +slack for finalize's look-right tail, -slack for a dropped upsample stage
+    total_mel = sum(c.shape[-1] for c in chunks)
+    assert full.shape[-1] > total_mel * SPM * 0.8, f"{full.shape[-1]} vs {total_mel * SPM}"
+    assert full.shape[-1] < total_mel * SPM * 1.5, f"{full.shape[-1]} vs {total_mel * SPM}"
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+def test_finalize_matches_single_pass_length_exactly(config):
+    """Streamed total (chunked, last=finalize) must exactly match a single
+    non-streaming finalize=True call over the whole mel -- not just approximately.
+
+    The finalize release must include `trim` (the F0 predictor's own held-back
+    frames), or the last 3 mel frames (1,440 samples / 60ms at 24kHz) of every
+    stream's audio go missing.
+    """
+    hift = _make_hift(config)
+    chunks = _chunks(total_mel=200, chunk_len=24)
+
+    torch.manual_seed(0)
+    full_mel = torch.cat(chunks, dim=-1)
+    ground_truth, _, _ = hift.inference(speech_feat=full_mel, finalize=True)
+    ground_truth = ground_truth.reshape(ground_truth.shape[0], -1)
+
+    hift2 = _make_hift(config)
+    model = _make_model(hift2, window_len=64)
+    torch.manual_seed(0)
+    cache = None
+    emitted = []
+    for i, chunk in enumerate(chunks):
+        finalize = i == len(chunks) - 1
+        speech, cache = model._stream_hift_from_feat(chunk, cache_state=cache, finalize=finalize)
+        emitted.append(speech.reshape(speech.shape[0], -1))
+    streamed = torch.cat(emitted, dim=-1)
+
+    assert streamed.shape[-1] == ground_truth.shape[-1], (
+        f"{streamed.shape[-1]} vs {ground_truth.shape[-1]} (diff={ground_truth.shape[-1] - streamed.shape[-1]} samples)"
+    )
+    torch.testing.assert_close(streamed, ground_truth, atol=ATOL, rtol=RTOL)
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+def test_incremental_hift_matches_reference_for_voiced_f0(config):
+    """Forces F0 above nsf_voiced_threshold (untrained weights never trigger voiced,
+    so no other test here does) and checks windowed output against the full-
+    cumulative reference, which exercises condnet's left-causal convs and
+    SineGen/SineGen2's phase integration under genuinely voiced harmonics.
+
+    Tolerance is looser than ATOL/RTOL: summing this sustained constant-F0 phase
+    in per-window chunks vs. one recompute reassociates float32 adds differently;
+    real speech's varying/unvoiced F0 keeps this far smaller in practice.
+    """
+    hift = _make_hift(config)
+    with torch.no_grad():
+        hift.f0_predictor.classifier.bias.fill_(150.0)  # clearly voiced (threshold is 10)
+    chunks = _chunks(total_mel=200, chunk_len=24)
+
+    full = _full_reference(_make_model(hift, window_len=400), chunks)
+    incr = _incremental(_make_model(hift, window_len=64), chunks)
+
+    assert full.shape == incr.shape
+    torch.testing.assert_close(incr, full, atol=2e-4, rtol=2e-4)
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+@pytest.mark.parametrize("first_len,step_len", [(10, 6), (10, 3), (20, 3), (10, 1)])
+@pytest.mark.skipif(
+    current_omni_platform.is_rocm(),
+    reason="exhaustive CPU reference matrix exceeds the AMD CI time budget",
+)
+def test_incremental_hift_matches_reference_for_voiced_f0_small_chunks(config, first_len, step_len):
+    """Same as test_incremental_hift_matches_reference_for_voiced_f0, but with small,
+    sub-receptive-field chunk sizes (down to 1 mel frame) instead of the uniform
+    24-frame chunks used elsewhere. cache_state must carry the F0 predictor's own
+    left receptive field across calls regardless of how small a single chunk is,
+    or the next call's margin comes up short and substitutes zero-padding for real
+    history -- corrupting SineGen's phase integration the same way as an absent
+    margin entirely.
+    """
+    hift = _make_hift(config)
+    with torch.no_grad():
+        hift.f0_predictor.classifier.bias.fill_(150.0)  # clearly voiced (threshold is 10)
+    chunks = _variable_chunks(total_mel=200, first_len=first_len, step_len=step_len)
+
+    full = _full_reference(_make_model(hift, window_len=400), chunks)
+    incr = _incremental(_make_model(hift, window_len=64), chunks)
+
+    assert full.shape == incr.shape
+    torch.testing.assert_close(incr, full, atol=2e-4, rtol=2e-4)
+
+
+def test_wrapped_slice_wraps_position_deterministically():
+    """SineGen/SineGen2/SourceModuleHnNSF's noise buffers are a fixed 300s at
+    24kHz; a stream running past that must keep repeating the realization
+    (position-deterministic) rather than the slice coming back short and
+    failing to broadcast against the rest of that call's tensors.
+    """
+    buf = torch.arange(10).reshape(1, 10, 1)
+
+    assert _wrapped_slice(buf, 2, 3).flatten().tolist() == [2, 3, 4]
+    assert _wrapped_slice(buf, 8, 4).flatten().tolist() == [8, 9, 0, 1]
+    assert _wrapped_slice(buf, 12, 3).flatten().tolist() == [2, 3, 4]  # offset past the end
+    assert _wrapped_slice(buf, 5, 13).flatten().tolist() == [5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7]
+
+
+def test_incremental_hift_empty_middle_chunk_emits_nothing():
+    """An empty middle chunk (reachable from forward_streaming_batch when a
+    row's post-trim feat comes out empty near the lookahead boundary) must
+    emit zero samples and leave cache_state's phase_acc unchanged, not
+    re-emit the re-decoded overlap window as if it were new audio.
+    """
+    hift = _make_hift(REAL_CONFIG)
+    model = _make_model(hift, window_len=64)
+    chunks = _chunks(total_mel=96, chunk_len=24)
+    empty = chunks[0][:, :, :0]
+
+    cache = None
+    for chunk in chunks[:2]:
+        _, cache = model._stream_hift_from_feat(chunk, cache_state=cache, finalize=False)
+    assert cache is not None
+    phase_acc_before = cache["phase_acc"]
+
+    speech, cache = model._stream_hift_from_feat(empty, cache_state=cache, finalize=False)
+
+    assert speech.shape[-1] == 0
+    if phase_acc_before is None:
+        assert cache["phase_acc"] is None
+    else:
+        torch.testing.assert_close(cache["phase_acc"], phase_acc_before)
+
+
+@pytest.mark.parametrize("config", CONFIGS)
+@pytest.mark.parametrize("mel_frames", [1, 2, 3, 4])
+def test_incremental_hift_short_finalize_chunk_does_not_crash(config, mel_frames):
+    """A one-token (or otherwise sub-trim) utterance that finalizes on its very
+    first chunk must not crash. On finalize the F0 predictor consumes the whole
+    window (it does not hold back `trim` frames), so the phase-carry index must
+    not be inflated by `trim` -- it would point past the end of a short window.
+    """
+    hift = _make_hift(config)
+    model = _make_model(hift, window_len=32)
+    chunk = torch.randn(1, 80, mel_frames)
+
+    speech, cache = model._stream_hift_from_feat(chunk, cache_state=None, finalize=True)
+
+    assert cache is None
+    assert speech.shape[0] == 1
+    assert speech.shape[-1] > 0
+    assert torch.isfinite(speech).all()
diff --git a/tests/model_executor/models/dots_tts/__init__.py b/tests/model_executor/models/dots_tts/__init__.py
deleted file mode 100644
index 208f01a7c..000000000
--- a/tests/model_executor/models/dots_tts/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
diff --git a/tests/model_executor/models/dots_tts/test_talker.py b/tests/model_executor/models/dots_tts/test_talker.py
deleted file mode 100644
index ed3c6bcaa..000000000
--- a/tests/model_executor/models/dots_tts/test_talker.py
+++ /dev/null
@@ -1,137 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Regression tests for the dots.tts talker's stop-signal pairing and
-per-request state lifecycle.
-
-Pure-CPU tests on a bare talker (``__new__`` + the handful of attributes
-the methods under test read) — no weights, no GPU, no engine.  Mirrors
-tests/model_executor/models/voxcpm2/test_talker_state_eviction.py.
-"""
-
-from __future__ import annotations
-
-import functools
-from types import SimpleNamespace
-
-import pytest
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-torch = pytest.importorskip("torch")
-
-_VOCAB_SIZE = 151672
-
-
-@functools.lru_cache(maxsize=1)
-def _dots_tts_talker_mod():
-    """Defer talker import (pulls vLLM model_executor) until first use."""
-    from vllm_omni.model_executor.models.dots_tts.dots_tts_talker import (
-        DotsTTSForConditionalGeneration,
-        _RequestState,
-    )
-
-    return DotsTTSForConditionalGeneration, _RequestState
-
-
-def _make_bare_talker():
-    DotsTTSForConditionalGeneration, _ = _dots_tts_talker_mod()
-    talker = DotsTTSForConditionalGeneration.__new__(DotsTTSForConditionalGeneration)
-    talker.config = SimpleNamespace(vocab_size=_VOCAB_SIZE)
-    talker._active_states = {}
-    talker._pending_requests = []
-    talker._results_queue = []
-    talker._audio_queue = []
-    talker._deferred_cleanup_ids = set()
-    talker._beta_trace = False
-    return talker
-
-
-def _add_state(talker, req_id: str, *, is_stopping: bool = False):
-    _, _RequestState = _dots_tts_talker_mod()
-    state = _RequestState(request_id=req_id)
-    state.prefill_completed = True
-    state.is_stopping = is_stopping
-    talker._active_states[req_id] = state
-    return state
-
-
-def _hidden(bsz: int) -> torch.Tensor:
-    return torch.zeros(bsz, 1536, dtype=torch.float32)
-
-
-class TestComputeLogitsPairing:
-    """compute_logits pairs _results_queue entries with batch rows
-    positionally, so every request must push exactly one entry per step —
-    including prefills, which push a (req_id, None) placeholder."""
-
-    def test_mixed_batch_prefill_placeholder_keeps_rows_aligned(self) -> None:
-        talker = _make_bare_talker()
-        _add_state(talker, "prefill-req")
-        decode_state = _add_state(talker, "decode-req", is_stopping=True)
-        decode_state.precomputed_stop_logits = torch.tensor([[0.1, 0.9]])
-
-        # Row 0 is the prefill (None placeholder), row 1 the stopping decode.
-        talker._results_queue = [
-            ("prefill-req", None),
-            ("decode-req", torch.tensor([[0.1, 0.9]])),
-        ]
-        logits = talker.compute_logits(_hidden(2))
-
-        assert logits.shape == (2, _VOCAB_SIZE)
-        # Prefill row: forced continue.
-        assert logits[0, 0].item() == 1.0
-        assert logits[0, 1].item() == float("-inf")
-        # Stopping decode row: stop slot wins.
-        assert logits[1, 1].item() == 1.0
-        assert logits[1, 0].item() == 0.0
-        # Everything else stays masked.
-        assert logits[0, 2].item() == float("-inf")
-        assert logits[1, 2].item() == float("-inf")
-        # Queue drained.
-        assert talker._results_queue == []
-
-    def test_below_threshold_stop_logits_force_continue(self) -> None:
-        """Raw (continue, stop) softmax must not reach the sampler: a
-        prob_stop in (0.5, 0.8] would flip greedy argmax even though
-        is_stopping stayed False (the 0.8-threshold contract)."""
-        talker = _make_bare_talker()
-        _add_state(talker, "req", is_stopping=False)
-        talker._results_queue = [("req", torch.tensor([[0.3, 0.7]]))]
-
-        logits = talker.compute_logits(_hidden(1))
-
-        assert logits[0, 0].item() == 1.0
-        assert logits[0, 1].item() == float("-inf")
-
-    def test_empty_queue_defaults_to_all_continue(self) -> None:
-        talker = _make_bare_talker()
-        logits = talker.compute_logits(_hidden(3))
-
-        assert torch.all(logits[:, 0] == 1.0)
-        assert torch.all(logits[:, 1] == float("-inf"))
-
-
-class TestStateEviction:
-    """on_requests_finished fires BEFORE forward(), so eviction must be
-    deferred to _flush_deferred_cleanup at the end of the step — the
-    finishing request's audio still drains through the current forward."""
-
-    def test_finished_request_survives_until_flush(self) -> None:
-        talker = _make_bare_talker()
-        _add_state(talker, "req-a")
-        _add_state(talker, "req-b")
-
-        talker.on_requests_finished(["req-a"])
-        assert "req-a" in talker._active_states  # not evicted yet
-
-        talker._flush_deferred_cleanup()
-        assert "req-a" not in talker._active_states
-        assert "req-b" in talker._active_states
-        assert talker._deferred_cleanup_ids == set()
-
-    def test_unknown_request_id_is_ignored(self) -> None:
-        talker = _make_bare_talker()
-        talker.on_requests_finished(["never-seen"])
-        talker._flush_deferred_cleanup()
-        assert talker._active_states == {}
diff --git a/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py b/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py
deleted file mode 100644
index d2138541f..000000000
--- a/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-import pytest
-from transformers import PreTrainedModel
-
-from vllm_omni.model_executor.models.dynin_omni.dynin_omni_token2audio import (
-    _ensure_transformers_tied_weights_compat,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def test_transformers_tied_weights_compat(monkeypatch):
-    """Compat shim must not permanently mutate ``PreTrainedModel``.
-
-    ``monkeypatch.delattr(..., raising=False)`` is a no-op undo when the attr
-    was absent. ``_ensure_transformers_tied_weights_compat`` then assigns a
-    read-only ``property`` on the class that later PreTrainedModel subclasses
-    (e.g. qwen3 TTS mask-cache) can trip over with
-    ``AttributeError: property ... has no setter``.
-    """
-    monkeypatch.delattr(PreTrainedModel, "all_tied_weights_keys", raising=False)
-
-    _ensure_transformers_tied_weights_compat()
-    installed = PreTrainedModel.__dict__.get("all_tied_weights_keys")
-    assert installed is not None
-
-    # Re-own the installed descriptor through monkeypatch so teardown always
-    # removes/restores it, even when the attr did not exist before this test.
-    delattr(PreTrainedModel, "all_tied_weights_keys")
-    monkeypatch.setattr(PreTrainedModel, "all_tied_weights_keys", installed, raising=False)
-
-    model = PreTrainedModel.__new__(PreTrainedModel)
-    model._tied_weights_keys = ["decoder.weight"]
-    model._dynamic_tied_weights_keys = {"lm_head.weight": "decoder.weight"}
-
-    assert model.all_tied_weights_keys == {
-        "decoder.weight": None,
-        "lm_head.weight": "decoder.weight",
-    }
diff --git a/tests/model_executor/models/minicpmo_4_5/duplex/test_scheduler_token_budget.py b/tests/model_executor/models/minicpmo_4_5/duplex/test_scheduler_token_budget.py
new file mode 100644
index 000000000..03072cb33
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/duplex/test_scheduler_token_budget.py
@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""What a duplex append reserves in the scheduler, and why that number.
+
+The reservation is not advisory: ``build_duplex_data_plane_prompt`` turns it
+into ``[scheduler_token_id] * budget``, and a unit whose embeddings outnumber
+its slots has its tail dropped with a warning rather than failing
+(``MiniCPMO45OmniModel.get_input_embeddings``). Over-reserving only wastes
+slots, so every uncertainty here has to resolve upwards.
+
+The camera side depends on HD slicing, which depends on the frame size
+*relative to the checkpoint's normalization tile*. The tile is configuration,
+not a constant, so the cases below drive the arithmetic at more than one tile
+size and check it against ``MiniCPMVImageProcessor.get_sliced_grid`` -- the
+same grid search the checkpoint's own processor runs.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+from dataclasses import dataclass
+
+import pytest
+from PIL import Image
+
+from vllm_omni.engine.duplex.config import DuplexSessionConfig
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.plugin import (
+    PRIVATE_RUNTIME_CONFIG_KEYS,
+    _apply_default_scheduler_policy,
+    _duplex_vision_tile_pixels,
+    _duplex_vision_tokens,
+    _model_vision_tile_pixels,
+    duplex_scheduler_token_budget,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import MiniCPMVImageProcessor
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+TOKENS_PER_BLOCK = 66
+#: ``_official_max_slice_nums`` gives the first frame of a stacked pair 2 and
+#: every other frame 1.
+BASE_FRAME_MAX_SLICES = 2
+#: What the released MiniCPM-o 4.5 checkpoint configures.
+TILE_448 = 448 * 448
+
+SIZES = [(224, 224), (320, 180), (448, 448), (448, 449), (640, 480), (960, 540), (1280, 720), (540, 960)]
+
+
+def _frame(size: tuple[int, int], fmt: str = "JPEG") -> str:
+    buffer = io.BytesIO()
+    Image.new("RGB", size).save(buffer, format=fmt)
+    return base64.b64encode(buffer.getvalue()).decode()
+
+
+def _blocks_the_model_makes(size: tuple[int, int], max_slice_nums: int, scale_resolution: int) -> int:
+    """Source tile plus the HD patches, straight from the model's grid search."""
+    processor = MiniCPMVImageProcessor(scale_resolution=scale_resolution)
+    grid = processor.get_sliced_grid(image_size=size, max_slice_nums=max_slice_nums)
+    return 1 + grid[0] * grid[1] if grid else 1
+
+
+@pytest.mark.parametrize("scale_resolution", [336, 448, 560])
+@pytest.mark.parametrize("size", SIZES, ids=[f"{w}x{h}" for w, h in SIZES])
+@pytest.mark.parametrize("fmt", ["JPEG", "PNG"])
+def test_a_stacked_pair_reserves_what_the_model_slices_it_into(
+    size: tuple[int, int], fmt: str, scale_resolution: int
+) -> None:
+    """The tile comes from the checkpoint, so the arithmetic has to follow it."""
+    frame = _frame(size, fmt)
+    expected_blocks = _blocks_the_model_makes(size, BASE_FRAME_MAX_SLICES, scale_resolution) + _blocks_the_model_makes(
+        size, 1, scale_resolution
+    )
+
+    reserved = _duplex_vision_tokens({"video_frames": [frame, frame]}, tile_pixels=scale_resolution**2)
+
+    assert reserved == expected_blocks * TOKENS_PER_BLOCK
+
+
+def test_a_small_frame_no_longer_reserves_three_hd_blocks() -> None:
+    """A 448x448 frame is one tile, so a stacked pair is two blocks, not four.
+
+    The size-independent count reserved 264 tokens for this pair. 132 of them
+    were for patches the model never produces.
+    """
+    frame = _frame((448, 448))
+
+    assert _duplex_vision_tokens({"video_frames": [frame, frame]}, tile_pixels=TILE_448) == 2 * TOKENS_PER_BLOCK
+
+
+def test_one_tile_is_the_whole_slicing_decision() -> None:
+    """``ceil(w * h / tile)`` capped at 2: a single pixel over the tile slices."""
+
+    def pair(size: tuple[int, int]) -> int:
+        frame = _frame(size)
+        return _duplex_vision_tokens({"video_frames": [frame, frame]}, tile_pixels=TILE_448)
+
+    assert pair((448, 448)) == 2 * TOKENS_PER_BLOCK
+    assert pair((448, 449)) == 4 * TOKENS_PER_BLOCK
+
+
+def test_only_the_first_frame_of_a_pair_is_hd_sliced() -> None:
+    """``_official_max_slice_nums`` is ``[2, 1]``: the composite is never sliced.
+
+    Sizing the wrong half of the pair would pass every same-size case, so the
+    two orders have to disagree.
+    """
+    small, large = _frame((448, 448)), _frame((1280, 720))
+
+    assert _duplex_vision_tokens({"video_frames": [small, large]}, tile_pixels=TILE_448) == 2 * TOKENS_PER_BLOCK
+    assert _duplex_vision_tokens({"video_frames": [large, small]}, tile_pixels=TILE_448) == 4 * TOKENS_PER_BLOCK
+
+
+def test_a_lone_frame_is_never_hd_sliced() -> None:
+    """``_official_max_slice_nums(1)`` is ``[1]``: one frame is one tile at any size."""
+    assert _duplex_vision_tokens({"video_frames": [_frame((1280, 720))]}, tile_pixels=TILE_448) == TOKENS_PER_BLOCK
+
+
+def test_extra_frames_past_the_pair_each_cost_one_block() -> None:
+    """The wire caps a frame list at two; the in-process API does not."""
+    small, large = _frame((448, 448)), _frame((1280, 720))
+
+    assert _duplex_vision_tokens({"video_frames": [small] * 3}, tile_pixels=TILE_448) == 3 * TOKENS_PER_BLOCK
+    assert _duplex_vision_tokens({"video_frames": [large] * 3}, tile_pixels=TILE_448) == 5 * TOKENS_PER_BLOCK
+
+
+def test_an_unknown_tile_size_keeps_the_sliced_reservation() -> None:
+    """No tile, no shrinking. A checkpoint whose config cannot be read keeps the old number."""
+    frame = _frame((224, 224))
+
+    assert _duplex_vision_tokens({"video_frames": [frame, frame]}) == 4 * TOKENS_PER_BLOCK
+    assert _duplex_vision_tokens({"video_frames": [frame, frame]}, tile_pixels=None) == 4 * TOKENS_PER_BLOCK
+
+
+@pytest.mark.parametrize(
+    "first_frame",
+    [
+        pytest.param("data:image/jpeg;base64," + _frame((224, 224)), id="data url"),
+        pytest.param("!!! not base64 !!!", id="corrupt base64"),
+        pytest.param(base64.b64encode(b"\x00" * 64).decode(), id="base64 of something else"),
+        pytest.param(base64.b64encode(base64.b64decode(_frame((224, 224)))[:8]).decode(), id="truncated jpeg"),
+    ],
+)
+def test_a_frame_whose_header_will_not_parse_keeps_the_sliced_reservation(first_frame: str) -> None:
+    """The Realtime wire screens most of these; the in-process API does not.
+
+    ``validate_realtime_video_frames`` rejects bad base64 and anything whose
+    magic bytes are not JPEG or PNG, so on a websocket session only a truncated
+    but well-headed frame gets this far. ``DuplexOmni.append_audio`` submits
+    without that screen, so the reservation still has to hold on its own.
+    """
+    good = _frame((224, 224))
+
+    assert _duplex_vision_tokens({"video_frames": [first_frame, good]}, tile_pixels=TILE_448) == 4 * TOKENS_PER_BLOCK
+
+
+def test_no_camera_track_reserves_nothing() -> None:
+    for payload in ({}, {"video_frames": []}, {"video_frames": "not a list"}, {"video_frames": [None, ""]}, None):
+        assert _duplex_vision_tokens(payload, tile_pixels=TILE_448) == 0
+
+
+def test_the_audio_budget_is_untouched_by_the_camera_track() -> None:
+    """One second of pcm_f32le is 12 slots; the frames are added on top."""
+    one_second = base64.b64encode(b"\x00" * 4 * 16000).decode()
+    audio_only = {"audio": one_second, "format": "pcm_f32le"}
+    with_frames = {**audio_only, "video_frames": [_frame((448, 448)), _frame((448, 448))]}
+
+    assert duplex_scheduler_token_budget(audio_only, tile_pixels=TILE_448) == 12
+    assert duplex_scheduler_token_budget(with_frames, tile_pixels=TILE_448) == 12 + 2 * TOKENS_PER_BLOCK
+
+
+# ---- where the tile comes from ----
+
+
+@dataclass(frozen=True)
+class _SliceConfig:
+    scale_resolution: int
+
+
+@dataclass(frozen=True)
+class _HFConfig:
+    slice_config: object = None
+    image_size: object = None
+
+
+@dataclass(frozen=True)
+class _ModelConfig:
+    hf_config: object = None
+
+
+@pytest.mark.parametrize(
+    ("hf_config", "expected"),
+    [
+        (_HFConfig(slice_config={"max_slice_nums": 1, "scale_resolution": 448}, image_size=448), TILE_448),
+        (_HFConfig(slice_config=_SliceConfig(scale_resolution=336), image_size=448), 336 * 336),
+        (_HFConfig(image_size=560), 560 * 560),
+        (_HFConfig(), None),
+        (_HFConfig(slice_config={"scale_resolution": 0}, image_size=0), None),
+    ],
+    ids=["released-checkpoint", "attribute", "image-size-fallback", "nothing-to-read", "nonsense"],
+)
+def test_the_tile_is_read_from_the_checkpoint(hf_config: object, expected: int | None) -> None:
+    """First row is the released MiniCPM-o 4.5 ``config.json``, where ``slice_config`` is a dict."""
+    assert _model_vision_tile_pixels(_ModelConfig(hf_config=hf_config)) == expected
+
+
+def test_no_model_config_means_no_tile() -> None:
+    assert _model_vision_tile_pixels(None) is None
+    assert _model_vision_tile_pixels(_ModelConfig()) is None
+
+
+def test_the_tile_reaches_the_budget_through_the_runtime_config() -> None:
+    """``_apply_default_scheduler_policy`` writes it; ``build_duplex_data_plane_prompt`` reads it back."""
+    runtime_config: dict[str, object] = {}
+
+    _apply_default_scheduler_policy(
+        runtime_config,
+        config=DuplexSessionConfig(),
+        tokenizer=None,
+        model_config=_ModelConfig(hf_config=_HFConfig(slice_config={"scale_resolution": 448})),
+    )
+
+    assert runtime_config["duplex_vision_tile_pixels"] == TILE_448
+    assert _duplex_vision_tile_pixels(runtime_config) == TILE_448
+
+
+def test_a_checkpoint_that_cannot_be_read_leaves_the_key_out() -> None:
+    """No key, no tile, and no tile is the sliced reservation."""
+    runtime_config: dict[str, object] = {}
+
+    _apply_default_scheduler_policy(runtime_config, config=DuplexSessionConfig(), tokenizer=None)
+
+    assert "duplex_vision_tile_pixels" not in runtime_config
+    assert _duplex_vision_tile_pixels(runtime_config) is None
+
+
+def test_a_junk_tile_in_the_runtime_config_is_ignored() -> None:
+    for value in (0, -1, "448", 448.0, None):
+        assert _duplex_vision_tile_pixels({"duplex_vision_tile_pixels": value}) is None
+
+
+def test_the_tile_is_server_owned() -> None:
+    """A client that could set the tile could shrink the reservation under the worker."""
+    assert "duplex_vision_tile_pixels" in PRIVATE_RUNTIME_CONFIG_KEYS
diff --git a/tests/model_executor/models/minicpmo_4_5/test_cuda_graph_wrapper.py b/tests/model_executor/models/minicpmo_4_5/test_cuda_graph_wrapper.py
index 959156b8f..555e72e46 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_cuda_graph_wrapper.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_cuda_graph_wrapper.py
@@ -177,6 +177,8 @@ class _MiniDiT(nn.Module):
         cnn_cache_buffer: torch.Tensor | None = None,
         att_cache_buffer: torch.Tensor | None = None,
     ) -> torch.Tensor:
+        assert cnn_cache_buffer is not None
+        assert att_cache_buffer is not None
         x = x.transpose(1, 2)
         x = self.in_proj(x)
         for b_idx in range(len(self.blocks)):
diff --git a/tests/model_executor/models/minicpmo_4_5/test_pipeline.py b/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
index 6c22b818b..92e96b25a 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
@@ -178,7 +178,7 @@ class TestDeployTopology:
                 0.18,
             ]
             assert sum(memory_utilizations) <= 0.9 + 1e-6
-            # Daily-Omni minicpm-interleave: up to 64 image/audio items (+ optional video).
+            # Keep the default Daily-Omni budget; Video-MME overrides stage 0 explicitly.
             assert stages[0].yaml_engine_args["limit_mm_per_prompt"] == {
                 "image": 64,
                 "audio": 64,
diff --git a/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py b/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py
index 0c5b97ae2..4335bb88e 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py
@@ -20,12 +20,14 @@ from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
 from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_tts import (
     _CODEC_PENALTY_WINDOW,
     _DUPLEX_CODEC_TOKENS_PER_CHUNK,
+    _DUPLEX_TURN_END_CODEC_TOKENS,
     _OFFLINE_CODEC_MAX_NEW_TOKENS,
     _REPETITION_PENALTY_CHUNK_SIZE,
     MiniCPMO45OmniTTSForConditionalGeneration,
     _apply_batched_repetition_penalty,
     _native_duplex_chunk_budget,
     _restore_weight_norm_weight,
+    _turn_end_boundary_eos_masked,
     blank_scheduler_prompt_for_penalties,
 )
 from vllm_omni.utils.mm_outputs import to_payload_element
@@ -453,7 +455,9 @@ def test_sample_leaves_unforced_rows_to_the_sampler(mocker) -> None:
 def test_native_duplex_chunk_budget_masks_eos_until_generate_chunk_is_full() -> None:
     assert _native_duplex_chunk_budget({}) == (_DUPLEX_CODEC_TOKENS_PER_CHUNK, _DUPLEX_CODEC_TOKENS_PER_CHUNK)
     assert _native_duplex_chunk_budget({"turn_start": True}) == (_DUPLEX_CODEC_TOKENS_PER_CHUNK, 0)
-    assert _native_duplex_chunk_budget({"turn_end": True}) == (_DUPLEX_CODEC_TOKENS_PER_CHUNK, 0)
+    # The turn-end chunk drains the owed text: no floor, multi-unit ceiling.
+    assert _native_duplex_chunk_budget({"turn_end": True}) == (_DUPLEX_TURN_END_CODEC_TOKENS, 0)
+    assert _DUPLEX_TURN_END_CODEC_TOKENS > _DUPLEX_CODEC_TOKENS_PER_CHUNK
 
     talker = _make_talker()
     talker._request_audio_states["req-chunk"] = {
@@ -1097,3 +1101,43 @@ def test_request_cleanup_evicts_decode_state() -> None:
 
     assert "req-done" not in talker._request_audio_states
     assert "req-done" not in talker._request_condition_states
+
+
+def test_turn_end_drain_masks_only_the_cadence_eos() -> None:
+    # Early EOS (text spoken before the first boundary) is allowed.
+    assert not _turn_end_boundary_eos_masked(0)
+    assert not _turn_end_boundary_eos_masked(18)
+    assert not _turn_end_boundary_eos_masked(24)
+    # The cadence EOS right after each 25-frame boundary is masked for a short window.
+    assert _turn_end_boundary_eos_masked(25)
+    assert _turn_end_boundary_eos_masked(29)
+    assert not _turn_end_boundary_eos_masked(30)
+    assert not _turn_end_boundary_eos_masked(49)
+    assert _turn_end_boundary_eos_masked(50)
+    assert not _turn_end_boundary_eos_masked(60)
+
+    talker = _make_talker()
+    talker._request_audio_states["req-drain"] = {
+        "finished": False,
+        "step": 25,
+        "max_tokens": _DUPLEX_TURN_END_CODEC_TOKENS,
+        "min_tokens": 0,
+        "turn_end_drain": True,
+    }
+    output = talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[{"request_id": "req-drain", "codes": {"audio": torch.empty(0)}}],
+        request_token_spans=[(0, 1)],
+    )
+    logits = talker.compute_logits(output.text_hidden_states)
+    assert logits[0, 7].item() == float("-inf")
+    assert output.multimodal_outputs["meta"]["finished"][0].item() is False
+
+    talker._request_audio_states["req-drain"]["step"] = 30
+    output = talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[{"request_id": "req-drain", "codes": {"audio": torch.empty(0)}}],
+        request_token_spans=[(0, 1)],
+    )
+    logits = talker.compute_logits(output.text_hidden_states)
+    assert torch.isfinite(logits[0, 7])
diff --git a/tests/model_executor/models/moss_tts/test_audio_tokenizer_v1_streaming.py b/tests/model_executor/models/moss_tts/test_audio_tokenizer_v1_streaming.py
new file mode 100644
index 000000000..c03526307
--- /dev/null
+++ b/tests/model_executor/models/moss_tts/test_audio_tokenizer_v1_streaming.py
@@ -0,0 +1,199 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.moss_tts.audio_tokenizer import (
+    MossAudioTokenizerConfig,
+    MossAudioTokenizerModel,
+    _Attention,
+    _StreamingExecutionContext,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_codec() -> MossAudioTokenizerModel:
+    torch.manual_seed(0)
+    config = MossAudioTokenizerConfig(
+        sampling_rate=100,
+        downsample_rate=1,
+        causal_transformer_context_duration=0.08,
+        encoder_kwargs=[{"module_type": "PatchedPretransform", "patch_size": 1}],
+        decoder_kwargs=[
+            {
+                "module_type": "Transformer",
+                "input_dimension": 4,
+                "output_dimension": 1,
+                "d_model": 4,
+                "num_heads": 2,
+                "num_layers": 2,
+                "dim_feedforward": 8,
+                "causal": True,
+                "norm": "layer_norm",
+                "positional_embedding": "rope",
+                "max_period": 10_000,
+                "gating": "none",
+                "layer_scale": 0.01,
+                "conv_layout": True,
+            }
+        ],
+        quantizer_kwargs={
+            "input_dim": 4,
+            "rvq_dim": 4,
+            "output_dim": 4,
+            "num_quantizers": 2,
+            "codebook_size": 8,
+            "codebook_dim": 2,
+            "quantizer_type": "rlfq",
+        },
+    )
+    return MossAudioTokenizerModel(config).eval()
+
+
+def _codes(values: list[list[int]]) -> torch.Tensor:
+    return torch.tensor(values, dtype=torch.long)
+
+
+def _reference_audio(codec: MossAudioTokenizerModel, codes: torch.Tensor) -> torch.Tensor:
+    output = codec.batch_decode([codes], num_quantizers=int(codes.shape[0]))
+    assert output.audio is not None
+    return output.audio[0]
+
+
+def _stream(
+    codec: MossAudioTokenizerModel,
+    codes: torch.Tensor,
+    *,
+    slot: int,
+) -> torch.Tensor:
+    output = codec.decode_streaming_batch(
+        codes.unsqueeze(1),
+        torch.tensor([codes.shape[1]], dtype=torch.long),
+        torch.tensor([slot], dtype=torch.long),
+        torch.tensor([True]),
+    )
+    assert output.audio is not None
+    return output.audio[0]
+
+
+def test_streaming_chunks_match_full_decode() -> None:
+    codec = _make_codec()
+    codes = _codes([[1, 2, 3, 4], [4, 3, 2, 1]])
+    expected = _reference_audio(codec, codes)
+
+    codec.initialize_decoder_state_pool(state_capacity=2)
+    first = _stream(codec, codes[:, :2], slot=1)
+    second = _stream(codec, codes[:, 2:], slot=1)
+
+    torch.testing.assert_close(torch.cat([first, second], dim=-1), expected, atol=1e-5, rtol=1e-5)
+
+
+def test_streaming_attention_ring_wrap_matches_full_attention() -> None:
+    torch.manual_seed(0)
+    attention = _Attention(
+        embed_dim=8,
+        num_heads=2,
+        causal=True,
+        max_period=10_000,
+        context=8,
+    ).eval()
+    hidden_states = torch.randn(1, 12, 8)
+    expected = attention(hidden_states)
+
+    attention.initialize_streaming_state(torch.zeros(1, dtype=torch.long))
+    execution_context = _StreamingExecutionContext(
+        state_slot_ids=torch.tensor([0]),
+        valid_rows=torch.tensor([True]),
+    )
+    chunks = [
+        attention(hidden_states[:, start : start + 3], execution_context)
+        for start in range(0, hidden_states.shape[1], 3)
+    ]
+
+    torch.testing.assert_close(torch.cat(chunks, dim=1), expected, atol=1e-6, rtol=1e-6)
+
+
+def test_streaming_slots_keep_independent_state() -> None:
+    codec = _make_codec()
+    first_codes = _codes([[1, 2, 3, 4], [4, 3, 2, 1]])
+    second_codes = _codes([[5, 6, 7, 1], [1, 7, 6, 5]])
+    first_expected = _reference_audio(codec, first_codes)
+    second_expected = _reference_audio(codec, second_codes)
+
+    codec.initialize_decoder_state_pool(state_capacity=3)
+    chunks: list[tuple[torch.Tensor, torch.Tensor]] = []
+    for start in (0, 2):
+        batch = torch.stack([first_codes[:, start : start + 2], second_codes[:, start : start + 2]], dim=1)
+        output = codec.decode_streaming_batch(
+            batch,
+            torch.tensor([2, 2], dtype=torch.long),
+            torch.tensor([2, 0], dtype=torch.long),
+            torch.tensor([True, True]),
+        )
+        assert output.audio is not None
+        chunks.append((output.audio[0], output.audio[1]))
+
+    torch.testing.assert_close(
+        torch.cat([chunk[0] for chunk in chunks], dim=-1),
+        first_expected,
+        atol=1e-5,
+        rtol=1e-5,
+    )
+    torch.testing.assert_close(
+        torch.cat([chunk[1] for chunk in chunks], dim=-1),
+        second_expected,
+        atol=1e-5,
+        rtol=1e-5,
+    )
+
+
+def test_reset_slot_removes_previous_request_state() -> None:
+    codec = _make_codec()
+    old_codes = _codes([[1, 2], [4, 3]])
+    new_codes = _codes([[7, 6], [2, 5]])
+    expected = _reference_audio(codec, new_codes)
+
+    codec.initialize_decoder_state_pool(state_capacity=1)
+    _stream(codec, old_codes, slot=0)
+    codec.reset_decoder_state_slots(torch.tensor([0], dtype=torch.long))
+
+    torch.testing.assert_close(_stream(codec, new_codes, slot=0), expected, atol=1e-5, rtol=1e-5)
+
+
+def test_invalid_padding_row_does_not_advance_state() -> None:
+    codec = _make_codec()
+    codes = _codes([[1, 2], [4, 3]])
+    expected = _reference_audio(codec, codes)
+
+    codec.initialize_decoder_state_pool(state_capacity=1, scratch_capacity=1)
+    padding_output = codec.decode_streaming_batch(
+        codes.unsqueeze(1),
+        torch.tensor([0], dtype=torch.long),
+        torch.tensor([1], dtype=torch.long),
+        torch.tensor([False]),
+    )
+    assert padding_output.audio_lengths is not None
+    assert int(padding_output.audio_lengths[0]) == 0
+
+    torch.testing.assert_close(_stream(codec, codes, slot=1), expected, atol=1e-5, rtol=1e-5)
+
+
+def test_streaming_requires_initialized_state_pool() -> None:
+    codec = _make_codec()
+    codes = _codes([[1], [2]])
+
+    with pytest.raises(RuntimeError, match="state pool is not initialized"):
+        _stream(codec, codes, slot=0)
+
+
+def test_closed_state_pool_can_be_reinitialized() -> None:
+    codec = _make_codec()
+    codes = _codes([[1], [2]])
+
+    codec.initialize_decoder_state_pool(state_capacity=1)
+    codec.close_decoder_state_pool()
+    codec.initialize_decoder_state_pool(state_capacity=1)
+
+    assert _stream(codec, codes, slot=0).numel() > 0
diff --git a/tests/model_executor/models/moss_tts/test_audio_tokenizer_v2.py b/tests/model_executor/models/moss_tts/test_audio_tokenizer_v2.py
new file mode 100644
index 000000000..f5d799dd7
--- /dev/null
+++ b/tests/model_executor/models/moss_tts/test_audio_tokenizer_v2.py
@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Regression tests for MOSS audio tokenizer v2 projection modules."""
+
+from __future__ import annotations
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.model_executor.models.moss_tts.audio_tokenizer_v2 import (
+    MossAudioTokenizerProjectedTransformer,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_projected_transformer_keeps_learned_projections_when_dimensions_match() -> None:
+    module = MossAudioTokenizerProjectedTransformer(
+        input_dimension=8,
+        output_dimension=8,
+        d_model=8,
+        module_type="transformer",
+        num_heads=1,
+        num_layers=0,
+        positional_embedding="rope",
+    )
+
+    assert isinstance(module.input_proj, nn.Linear)
+    assert isinstance(module.output_proj, nn.Linear)
+    assert module.input_proj.weight.shape == (8, 8)
+    assert module.output_proj.weight.shape == (8, 8)
+
+    x = torch.randn(2, 8, 5)
+    lengths = torch.tensor([5, 3], dtype=torch.long)
+    output, output_lengths = module(x, lengths)
+
+    assert output.shape == x.shape
+    torch.testing.assert_close(output_lengths, lengths)
+
+
+def test_projected_transformer_keeps_linear_projections_when_dimensions_differ() -> None:
+    module = MossAudioTokenizerProjectedTransformer(
+        input_dimension=8,
+        output_dimension=6,
+        d_model=10,
+        module_type="transformer",
+        num_heads=1,
+        num_layers=0,
+        positional_embedding="rope",
+    )
+
+    assert isinstance(module.input_proj, nn.Linear)
+    assert isinstance(module.output_proj, nn.Linear)
diff --git a/tests/model_executor/models/moss_tts/test_realtime_chunked_prefill.py b/tests/model_executor/models/moss_tts/test_realtime_chunked_prefill.py
new file mode 100644
index 000000000..916213318
--- /dev/null
+++ b/tests/model_executor/models/moss_tts/test_realtime_chunked_prefill.py
@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_realtime_talker_preserves_state_across_chunked_prefill() -> None:
+    from vllm_omni.model_executor.models.moss_tts.modeling_moss_tts_talker import (
+        MossTTSRealtimeTalkerForGeneration,
+    )
+
+    talker = MossTTSRealtimeTalkerForGeneration.__new__(MossTTSRealtimeTalkerForGeneration)
+    talker.n_vq = 2
+    talker.audio_pad_token = 1024
+    talker.text_vocab_size = 16
+    talker.text_pad_id = 2
+    talker._batch_state = None
+    talker._batch_state_spans = None
+
+    embedded_audio: list[torch.Tensor | None] = []
+
+    def build_input_embeds(input_ids, audio_codes):
+        embedded_audio.append(audio_codes.clone() if audio_codes is not None else None)
+        return torch.zeros((input_ids.shape[0], 1))
+
+    generated: list[None] = []
+
+    def generate_frame(*args, **kwargs):
+        generated.append(None)
+        return torch.ones((1, talker.n_vq), dtype=torch.long)
+
+    talker._build_input_embeds = build_input_embeds
+    talker.local_transformer = SimpleNamespace(generate_frame=generate_frame)
+    talker.local_lm_heads = []
+
+    ref_codes = torch.arange(10, dtype=torch.long).reshape(5, 2)
+    info: dict[str, Any] = {
+        "codes": {"ref": ref_codes},
+        "ids": {"all": [7, 8]},
+        "max_new_frames": [3],
+    }
+    chunks = [(0, 2, False), (2, 2, False), (4, 1, True)]
+
+    state: dict[str, Any] | None = None
+    for computed, length, eligible in chunks:
+        _, _, update = talker.preprocess(
+            torch.ones(length, dtype=torch.long),
+            None,
+            _omni_is_prefill=True,
+            _omni_num_computed_tokens=computed,
+            _omni_prompt_len=5,
+            **info,
+        )
+        info.update(update)
+        if state is None:
+            state = info["audio_state"]
+        else:
+            assert info["audio_state"] is state
+
+        output = talker.make_omni_output(
+            torch.ones((length, 1)),
+            model_intermediate_buffer=[info],
+            request_token_spans=[(0, length)],
+            request_sample_eligible=[eligible],
+        )
+        if not eligible:
+            assert output.multimodal_outputs == {}
+        logits = talker.compute_logits(torch.ones((1, 1)))
+        assert logits.argmax().item() == (7 if eligible else talker.text_pad_id)
+
+    assert state is not None
+    assert info["ref_offset"] == 5
+    assert state["step"] == 1
+    assert state["text_cursor"] == 1
+    assert state["remaining_text"] == [7, 8]
+    assert len(generated) == 1
+    assert output.multimodal_outputs["codes"]["audio"][0].shape == (1, 2)
+    for actual, expected in zip(embedded_audio, ref_codes.split((2, 2, 1)), strict=True):
+        assert actual is not None
+        torch.testing.assert_close(actual, expected)
diff --git a/tests/model_executor/models/moss_tts/test_realtime_generation_limit.py b/tests/model_executor/models/moss_tts/test_realtime_generation_limit.py
new file mode 100644
index 000000000..1bbfaeeef
--- /dev/null
+++ b/tests/model_executor/models/moss_tts/test_realtime_generation_limit.py
@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_realtime_talker_stops_at_max_new_frames() -> None:
+    from vllm_omni.model_executor.models.moss_tts.modeling_moss_tts_talker import (
+        MossTTSRealtimeTalkerForGeneration,
+    )
+
+    talker = MossTTSRealtimeTalkerForGeneration.__new__(MossTTSRealtimeTalkerForGeneration)
+    talker.n_vq = 4
+    talker.audio_pad_token = 1024
+    talker.text_vocab_size = 8
+    talker.text_pad_id = 2
+    talker.audio_eos_id = 3
+    talker._batch_state = None
+    talker._build_input_embeds = lambda input_ids, audio_codes: torch.zeros((input_ids.shape[0], 1))
+
+    generated: list[None] = []
+
+    def generate_frame(*args, **kwargs):
+        generated.append(None)
+        return torch.ones((1, talker.n_vq), dtype=torch.long)
+
+    talker.local_transformer = SimpleNamespace(generate_frame=generate_frame)
+    talker.local_lm_heads = []
+
+    _, _, info = talker.preprocess(
+        torch.tensor([1, 2]),
+        None,
+        max_new_frames=[2],
+    )
+    assert info["audio_state"]["max_new_frames"] == 2
+
+    for _ in range(3):
+        output = talker.make_omni_output(
+            torch.ones((1, 1)),
+            runtime_additional_information=[info],
+            request_token_spans=[(0, 1)],
+        )
+
+    assert len(generated) == 2
+    assert info["audio_state"]["step"] == 2
+    assert info["audio_state"]["is_stopping"] is True
+    assert output.multimodal_outputs == {}
+    assert talker.compute_logits(torch.ones((1, 1))).argmax().item() == talker.audio_eos_id
diff --git a/tests/model_executor/models/moss_tts/test_realtime_prompt.py b/tests/model_executor/models/moss_tts/test_realtime_prompt.py
new file mode 100644
index 000000000..cb36f6dd8
--- /dev/null
+++ b/tests/model_executor/models/moss_tts/test_realtime_prompt.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.moss_tts.realtime_prompt import build_realtime_prompt
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Tokenizer:
+    def encode(self, text: str, add_special_tokens: bool = False) -> list[int]:
+        del add_special_tokens
+        if text == "<|im_start|>assistant\n":
+            return [20, 21]
+        return list(range(100, 100 + len(text.split())))
+
+
+class _Processor:
+    audio_channel_pad = 1024
+    audio_bos_token = 1025
+
+    def __init__(self) -> None:
+        self.reference_codes = None
+
+    def make_ensemble(self, prompt_audio_tokens):
+        self.reference_codes = prompt_audio_tokens
+        return np.full((3, 17), self.audio_channel_pad, dtype=np.int64)
+
+
+def test_build_realtime_prompt_aligns_reference_and_prefill_text() -> None:
+    processor = _Processor()
+    reference_codes = torch.arange(80, dtype=torch.int64).reshape(5, 16)
+
+    params = build_realtime_prompt(
+        _Tokenizer(),
+        processor,
+        "one two three",
+        reference_codes,
+    )
+
+    assert np.array_equal(processor.reference_codes, reference_codes.numpy())
+    assert params["prompt_token_ids"] == [1024, 1024, 1024, 20, 21, 100, 101, 102]
+    audio_grid = params["codes"]["ref"]
+    assert audio_grid.shape == (len(params["prompt_token_ids"]), 16)
+    assert audio_grid[-1, 0].item() == processor.audio_bos_token
+    assert "ids" not in params
+
+
+def test_build_realtime_prompt_streams_text_after_first_twelve_tokens() -> None:
+    params = build_realtime_prompt(
+        _Tokenizer(),
+        _Processor(),
+        " ".join(f"word{i}" for i in range(15)),
+        torch.zeros((2, 16), dtype=torch.int64),
+    )
+
+    assert params["prompt_token_ids"][-12:] == list(range(100, 112))
+    assert params["ids"] == {"all": [112, 113, 114]}
+
+
+def test_build_realtime_prompt_rejects_wrong_processor_layout(monkeypatch: pytest.MonkeyPatch) -> None:
+    processor = _Processor()
+    monkeypatch.setattr(
+        processor,
+        "make_ensemble",
+        lambda prompt_audio_tokens: np.zeros((3, 16), dtype=np.int64),
+    )
+
+    with pytest.raises(ValueError, match=r"expected \(sequence_length, 17\)"):
+        build_realtime_prompt(
+            _Tokenizer(),
+            processor,
+            "one",
+            torch.zeros((2, 16), dtype=torch.int64),
+        )
diff --git a/tests/model_executor/models/moss_tts/test_reference_encoder.py b/tests/model_executor/models/moss_tts/test_reference_encoder.py
index bb03d556b..8cab6009e 100644
--- a/tests/model_executor/models/moss_tts/test_reference_encoder.py
+++ b/tests/model_executor/models/moss_tts/test_reference_encoder.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for MossReferenceEncoder: content-addressed caching,
 single-flight, and micro-batched encoding."""
 
@@ -534,3 +534,50 @@ async def test_encode_request_references_keys_second_speaker_by_slot(make_encode
     assert proc.total_items == 2
     # Concurrent, so both clips shared one batch window.
     assert proc.attempt_sizes == [2]
+
+
+@pytest.mark.parametrize("sr", [24000, 48000])
+def test_numeric_waveform_prep_matches_list_and_does_not_mutate_cache(sr):
+    import numpy as np
+
+    from vllm_omni.model_executor.models.moss_tts.reference_encoder import _prep_wav_sync
+
+    waveform = np.linspace(-1, 1, sr, dtype=np.float32)
+    expected = waveform.copy()
+    tensor = _prep_wav_sync(waveform, sr, 24000)
+    assert torch.equal(tensor, _prep_wav_sync(waveform.tolist(), sr, 24000))
+    tensor.zero_()
+    np.testing.assert_array_equal(waveform, expected)
+
+
+@pytest.mark.asyncio
+async def test_idle_batcher_releases_all_completed_waveforms():
+    import weakref
+
+    import numpy as np
+
+    batcher = _RefEncodeBatcher(
+        lambda payload: [torch.zeros((1, 4), dtype=torch.long) for _ in payload],
+        window_ms=0,
+        max_batch=8,
+    )
+    refs = []
+
+    async def submit_one():
+        waveform = np.zeros(24000, dtype=np.float32)
+        refs.append(weakref.ref(waveform))
+        await batcher.submit(waveform, 24000)
+
+    try:
+        await asyncio.gather(submit_one(), submit_one())
+
+        # Future completion can race the executor releasing its work item.
+        # Wait without forcing GC or overwriting first/jobs with a new batch.
+        async def wait_for_release():
+            while any(ref() is not None for ref in refs):
+                await asyncio.sleep(0.001)
+
+        await asyncio.wait_for(wait_for_release(), timeout=2.0)
+        assert batcher._drainer is not None and not batcher._drainer.done()
+    finally:
+        await batcher.aclose()
diff --git a/tests/model_executor/models/personaplex/test_ring_per_row_offsets.py b/tests/model_executor/models/personaplex/test_ring_per_row_offsets.py
new file mode 100644
index 000000000..fce42f40c
--- /dev/null
+++ b/tests/model_executor/models/personaplex/test_ring_per_row_offsets.py
@@ -0,0 +1,369 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+import torch.nn as nn
+from pytest_mock import MockerFixture
+
+from vllm_omni.model_executor.models.personaplex.personaplex_mimi import (
+    PersonaPlexMimiCodec,
+    _MimiStreamingTransformer,
+    _StreamConv1d,
+    _StreamConvTr1d,
+)
+from vllm_omni.model_executor.models.personaplex.personaplex_temporal import (
+    PersonaPlexTemporalStreaming,
+    _RingKV,
+)
+
+pytestmark = pytest.mark.core_model
+
+SEED = 1234
+CUDA_DEVICE = torch.device("cuda")
+
+
+def _mask(*rows: bool, device: torch.device | str = "cpu") -> torch.Tensor:
+    return torch.tensor(rows, dtype=torch.bool, device=device)
+
+
+def _inputs(shape: tuple[int, ...], seed: int, device: torch.device) -> torch.Tensor:
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    return torch.randn(*shape, generator=generator).to(device)
+
+
+def _make_mimi_transformer(
+    batch_size: int,
+    device: torch.device,
+    context: int = 6,
+) -> _MimiStreamingTransformer:
+    torch.manual_seed(SEED)
+    transformer = _MimiStreamingTransformer(
+        num_layers=2,
+        dim=32,
+        num_heads=4,
+        context=context,
+    ).to(device)
+    for parameter in transformer.parameters():
+        if parameter.dtype.is_floating_point:
+            nn.init.normal_(parameter, std=0.1)
+    transformer.streaming_init(batch_size)
+    return transformer
+
+
+def _make_temporal(
+    batch_size: int,
+    device: torch.device,
+    context: int = 6,
+) -> PersonaPlexTemporalStreaming:
+    torch.manual_seed(SEED)
+    temporal = PersonaPlexTemporalStreaming(
+        dim=16,
+        num_layers=2,
+        num_heads=4,
+        hidden=32,
+        context=context,
+        text_card=11,
+    ).to(device)
+    for parameter in temporal.parameters():
+        if parameter.dtype.is_floating_point:
+            nn.init.normal_(parameter, std=0.1)
+    temporal.streaming_init(batch_size)
+    return temporal
+
+
+def _assert_valid_ring_row_matches(
+    batched: _RingKV,
+    reference: _RingKV,
+    batched_positions: torch.Tensor,
+    reference_positions: torch.Tensor,
+    row: int,
+) -> None:
+    assert torch.equal(batched_positions[row], reference_positions)
+    assert torch.equal(batched.end_offset[row], reference.end_offset[0])
+
+    # The active mask covers the physical write as well as offset advancement,
+    # so the complete per-row ring state remains singleton-identical.
+    assert torch.equal(batched.cache[:, row], reference.cache[:, 0])
+
+
+def _stream_carry(stream: _StreamConv1d | _StreamConvTr1d) -> torch.Tensor:
+    if isinstance(stream, _StreamConv1d):
+        assert stream.prev is not None
+        return stream.prev
+    assert stream.partial is not None
+    return stream.partial
+
+
+def _make_passthrough_stage(mocker: MockerFixture):
+    stage = mocker.Mock(spec=["reset", "reset_slot"])
+    stage.side_effect = lambda x, active: x
+    return stage
+
+
+def _make_passthrough_transformer(mocker: MockerFixture):
+    transformer = mocker.Mock(spec=["streaming_init", "reset_streaming", "reset_slot", "step"])
+    transformer.step.side_effect = lambda x, active: x
+    return transformer
+
+
+def _active_args(call_args_list) -> torch.Tensor:
+    return torch.stack([call.args[1] for call in call_args_list])
+
+
+def _make_codec_stub(mocker: MockerFixture) -> PersonaPlexMimiCodec:
+    codec = PersonaPlexMimiCodec.__new__(PersonaPlexMimiCodec)
+    nn.Module.__init__(codec)
+
+    quantizer = mocker.Mock(spec=["encode", "decode"])
+    quantizer.encode.side_effect = lambda x: torch.zeros(8, x.shape[0], x.shape[-1], dtype=torch.long)
+    quantizer.decode.side_effect = lambda codes: torch.zeros(codes.shape[0], 1, codes.shape[-1])
+
+    codec.device = torch.device("cpu")
+    codec.dtype = torch.float32
+    codec.model = SimpleNamespace(quantizer=quantizer)
+    codec._enc_stages = []
+    codec._dec_stages = []
+    codec._downsample = _make_passthrough_stage(mocker)
+    codec._upsample = _make_passthrough_stage(mocker)
+    codec.encoder_transformer = _make_passthrough_transformer(mocker)
+    codec.decoder_transformer = _make_passthrough_transformer(mocker)
+    codec.streaming_init(batch_size=2)
+    return codec
+
+
+@pytest.mark.cpu
+def test_codec_entrypoints_forward_active_mask(mocker: MockerFixture) -> None:
+    codec = _make_codec_stub(mocker)
+    active = _mask(True, False)
+    all_active = torch.ones_like(active)
+
+    codec.encode_frame(torch.zeros(2, 1920), active)
+    codec.decode_frame(torch.zeros(2, 8), active)
+    codec.decode_frames(torch.zeros(2, 8, 3), active)
+    codec.decode_frames(torch.zeros(2, 8, 3), active=None)
+
+    assert torch.equal(_active_args(codec._downsample.call_args_list), active[None])
+    assert torch.equal(_active_args(codec._upsample.call_args_list), torch.stack((active, active, all_active)))
+    assert torch.equal(_active_args(codec.encoder_transformer.step.call_args_list), active[None])
+    assert torch.equal(
+        _active_args(codec.decoder_transformer.step.call_args_list),
+        torch.stack((active, active, all_active)),
+    )
+
+
+@pytest.mark.cpu
+def test_ring_mixed_offsets_match_singleton_streams() -> None:
+    batch_size, heads, head_dim, capacity, tokens = 3, 2, 3, 6, 2
+    batched = _RingKV(batch_size, heads, head_dim, capacity, torch.device("cpu"), torch.float32)
+    singletons = [_RingKV(1, heads, head_dim, capacity, torch.device("cpu"), torch.float32) for _ in range(batch_size)]
+    reference_positions: list[torch.Tensor | None] = [None] * batch_size
+    active_schedule = [
+        _mask(True, True, True),
+        _mask(True, False, False),
+        _mask(False, False, True),
+        _mask(True, True, False),
+        _mask(False, True, True),
+        _mask(True, False, True),
+        _mask(True, True, True),
+    ] * 2
+
+    torch.manual_seed(SEED)
+    for active in active_schedule:
+        keys = torch.randn(batch_size, heads, tokens, head_dim)
+        values = torch.randn_like(keys)
+        _, _, positions = batched.complete(keys, values, active)
+
+        for row, is_active in enumerate(active.tolist()):
+            if is_active:
+                _, _, singleton_positions = singletons[row].complete(
+                    keys[row : row + 1],
+                    values[row : row + 1],
+                    _mask(True),
+                )
+                reference_positions[row] = singleton_positions[0].clone()
+
+            assert reference_positions[row] is not None
+            _assert_valid_ring_row_matches(
+                batched,
+                singletons[row],
+                positions,
+                reference_positions[row],
+                row,
+            )
+
+    assert any(int(offset) > capacity for offset in batched.end_offset)
+    assert not torch.equal(batched.end_offset[0], batched.end_offset[1])
+
+
+@pytest.mark.cpu
+def test_ring_slot_recycle_masks_old_history() -> None:
+    ring = _RingKV(2, 1, 1, 8, torch.device("cpu"), torch.float32)
+    for _ in range(4):
+        ring.complete(torch.randn(2, 1, 2, 1), torch.randn(2, 1, 2, 1), _mask(True, True))
+
+    old_end = ring.end_offset.clone()
+    ring.reset_slot(1)
+    _, _, positions = ring.complete(
+        torch.randn(2, 1, 2, 1),
+        torch.randn(2, 1, 2, 1),
+        _mask(False, True),
+    )
+    visible = positions[1] >= 0
+    assert torch.all(positions[1][visible] >= old_end[1])
+
+    ring.reset_slot(0)
+    ring.bump_slot_start(0)
+    _, _, positions = ring.complete(
+        torch.randn(2, 1, 2, 1),
+        torch.randn(2, 1, 2, 1),
+        _mask(True, False),
+    )
+    visible = positions[0] >= 0
+    assert torch.all(positions[0][visible] >= old_end[0] + 1)
+
+
+@pytest.mark.cpu
+def test_temporal_streaming_rejects_invalid_active_shape() -> None:
+    temporal = _make_temporal(2, torch.device("cpu"))
+
+    with pytest.raises(ValueError, match=r"active must have shape \(2,\)"):
+        temporal.step(torch.zeros(2, 1, 16), torch.ones(1))
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_mimi_transformer_mixed_offsets_match_singletons() -> None:
+    batch_size, tokens, dim = 3, 2, 32
+    batched = _make_mimi_transformer(batch_size, CUDA_DEVICE)
+    singletons = [_make_mimi_transformer(1, CUDA_DEVICE) for _ in range(batch_size)]
+    active_schedule = [
+        _mask(True, True, True, device=CUDA_DEVICE),
+        _mask(True, False, False, device=CUDA_DEVICE),
+        _mask(False, False, True, device=CUDA_DEVICE),
+        _mask(True, True, False, device=CUDA_DEVICE),
+        _mask(False, True, True, device=CUDA_DEVICE),
+        _mask(True, False, True, device=CUDA_DEVICE),
+        _mask(True, True, True, device=CUDA_DEVICE),
+    ] * 2
+
+    for step, active in enumerate(active_schedule):
+        inputs = _inputs((batch_size, tokens, dim), SEED + step, CUDA_DEVICE)
+        offsets_before = batched._offset.clone()
+        cache_before = [kv.cache.clone() for kv in batched._kv]
+        output = batched.step(inputs, active)
+
+        for row, is_active in enumerate(active.tolist()):
+            if is_active:
+                expected = singletons[row].step(
+                    inputs[row : row + 1],
+                    _mask(True, device=CUDA_DEVICE),
+                )
+                torch.testing.assert_close(output[row : row + 1], expected, rtol=0.0, atol=0.0)
+                assert torch.equal(batched._offset[row], singletons[row]._offset[0])
+                for batched_kv, singleton_kv in zip(batched._kv, singletons[row]._kv):
+                    assert torch.equal(batched_kv.end_offset[row], singleton_kv.end_offset[0])
+                    torch.testing.assert_close(batched_kv.cache[:, row], singleton_kv.cache[:, 0], rtol=0.0, atol=0.0)
+            else:
+                assert torch.equal(batched._offset[row], offsets_before[row])
+                for kv, previous_cache in zip(batched._kv, cache_before):
+                    assert torch.equal(kv.end_offset[row], offsets_before[row])
+                    assert torch.equal(kv.cache[:, row], previous_cache[:, row])
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_temporal_streaming_mixed_offsets_match_isolated_rows() -> None:
+    # Keep the reference shape at B=2 so exact comparisons use the same CUDA
+    # kernel shape while the target row runs independently.
+    batched = _make_temporal(2, CUDA_DEVICE)
+    references = [_make_temporal(2, CUDA_DEVICE) for _ in range(2)]
+    active_schedule = [
+        _mask(True, True, device=CUDA_DEVICE),
+        _mask(True, False, device=CUDA_DEVICE),
+        _mask(False, False, device=CUDA_DEVICE),
+        _mask(False, True, device=CUDA_DEVICE),
+        _mask(True, True, device=CUDA_DEVICE),
+        _mask(True, False, device=CUDA_DEVICE),
+        _mask(False, True, device=CUDA_DEVICE),
+        _mask(True, True, device=CUDA_DEVICE),
+    ] * 2
+
+    for step, active in enumerate(active_schedule):
+        inputs = _inputs((2, 1, 16), SEED + 100 + step, CUDA_DEVICE)
+        offsets_before = batched._offset.clone()
+        cache_before = [kv.cache.clone() for kv in batched._kv]
+        output, logits = batched.step(inputs, active)
+
+        for row, (reference, is_active) in enumerate(zip(references, active.tolist())):
+            if is_active:
+                reference_inputs = torch.zeros_like(inputs)
+                reference_inputs[row] = inputs[row]
+                reference_active = torch.zeros_like(active)
+                reference_active[row] = True
+                expected_output, expected_logits = reference.step(reference_inputs, reference_active)
+                torch.testing.assert_close(output[row : row + 1], expected_output[row : row + 1], rtol=0.0, atol=0.0)
+                torch.testing.assert_close(logits[row : row + 1], expected_logits[row : row + 1], rtol=0.0, atol=0.0)
+                assert torch.equal(batched._offset[row], reference._offset[row])
+                for batched_kv, reference_kv in zip(batched._kv, reference._kv):
+                    assert torch.equal(batched_kv.end_offset[row], reference_kv.end_offset[row])
+                    torch.testing.assert_close(batched_kv.cache[:, row], reference_kv.cache[:, row], rtol=0.0, atol=0.0)
+            else:
+                assert torch.equal(batched._offset[row], offsets_before[row])
+                for kv, previous_cache in zip(batched._kv, cache_before):
+                    assert torch.equal(kv.end_offset[row], offsets_before[row])
+                    assert torch.equal(kv.cache[:, row], previous_cache[:, row])
+
+
+@pytest.mark.parametrize("kind", ["conv", "convtr"])
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_mimi_conv_carries_preserve_inactive_rows(kind: str) -> None:
+    if kind == "conv":
+        conv = nn.Conv1d(1, 2, kernel_size=3, stride=2, device=CUDA_DEVICE)
+        batched = _StreamConv1d(conv, pad_mode="replicate")
+        row0 = _StreamConv1d(conv, pad_mode="replicate")
+        row1 = _StreamConv1d(conv, pad_mode="replicate")
+        samples = 4
+    else:
+        conv = nn.ConvTranspose1d(1, 2, kernel_size=4, stride=2, device=CUDA_DEVICE)
+        batched = _StreamConvTr1d(conv)
+        row0 = _StreamConvTr1d(conv)
+        row1 = _StreamConvTr1d(conv)
+        samples = 2
+
+    for stream, batch_size in ((batched, 2), (row0, 1), (row1, 1)):
+        stream.reset(batch_size, CUDA_DEVICE, torch.float32)
+
+    singletons = [row0, row1]
+    active_schedule = [
+        _mask(False, False, device=CUDA_DEVICE),
+        _mask(True, False, device=CUDA_DEVICE),
+        _mask(True, True, device=CUDA_DEVICE),
+        _mask(False, True, device=CUDA_DEVICE),
+        _mask(True, True, device=CUDA_DEVICE),
+    ]
+
+    for step, active in enumerate(active_schedule):
+        inputs = _inputs((2, 1, samples), SEED + 200 + step, CUDA_DEVICE)
+        carry_before = _stream_carry(batched).clone()
+        fresh_before = batched._fresh.clone()
+        output = PersonaPlexMimiCodec._run_stages(inputs, [(kind, batched)], active)
+
+        for row, is_active in enumerate(active.tolist()):
+            if is_active:
+                expected = PersonaPlexMimiCodec._run_stages(
+                    inputs[row : row + 1],
+                    [(kind, singletons[row])],
+                    _mask(True, device=CUDA_DEVICE),
+                )
+                torch.testing.assert_close(output[row : row + 1], expected, rtol=0.0, atol=0.0)
+                torch.testing.assert_close(
+                    _stream_carry(batched)[row], _stream_carry(singletons[row])[0], rtol=0.0, atol=0.0
+                )
+                assert torch.equal(batched._fresh[row], singletons[row]._fresh[0])
+            else:
+                assert torch.equal(_stream_carry(batched)[row], carry_before[row])
+                assert torch.equal(batched._fresh[row], fresh_before[row])
diff --git a/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py b/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py
index 54efc99e4..9ebad492b 100644
--- a/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py
+++ b/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py
@@ -582,7 +582,7 @@ def test_get_video_use_audio_in_video_falls_back_to_prompt_updates_for_cache_hit
 
 
 def test_derive_audio_from_video_placeholders_only_pairs_true_videos():
-    fake_self = _fake_processor()
+    fake_self = _fake_qwen2_prompt_processor()
     video_placeholders = [
         PlaceholderFeaturesInfo(
             modality="video",
diff --git a/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py b/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py
index 7b624ba11..0d7cd8175 100644
--- a/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py
+++ b/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py
@@ -331,6 +331,56 @@ class TestEmbedInputIds:
             "Interleaved: audio positions should get audio embeddings"
         )
 
+    def test_interleaved_audio_boundaries_keep_text_embeddings(self, mocker: MockerFixture):
+        from vllm.multimodal.processing.processor import PlaceholderFeaturesInfo
+
+        from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
+            Qwen2_5OmniThinkerMultiModalProcessor,
+        )
+
+        processor = mocker.Mock()
+        processor.info.get_hf_processor.return_value = mocker.Mock(audio_token="audio", video_token="video")
+        processor.info.get_tokenizer.return_value.get_vocab.return_value = {
+            "audio": AUDIO_TOKEN_ID,
+            "video": VIDEO_TOKEN_ID,
+        }
+        # Real audio_bos/audio_eos IDs from the failing use_audio_in_video input.
+        tokens = [151647, VIDEO_TOKEN_ID, AUDIO_TOKEN_ID, VIDEO_TOKEN_ID, AUDIO_TOKEN_ID, 151648]
+        placeholder = PlaceholderFeaturesInfo(
+            modality="video",
+            item_idx=0,
+            start_idx=2,
+            tokens=tokens,
+            is_embed=torch.ones(len(tokens), dtype=torch.bool),
+        )
+        placeholders = Qwen2_5OmniThinkerMultiModalProcessor._derive_audio_from_video_placeholders(
+            processor,
+            {"video": [placeholder]},
+            {"audio": [[object()]]},
+            [True],
+        )
+
+        input_ids = torch.tensor([TEXT_TOKEN_ID] * 2 + tokens + [TEXT_TOKEN_ID])
+        is_multimodal = torch.zeros_like(input_ids, dtype=torch.bool)
+        for modality in ("audio", "video"):
+            derived = placeholders[modality][0].to_range()
+            is_multimodal[derived.offset : derived.offset + derived.length] |= derived.is_embed
+
+        model, hidden = make_mock_model(mocker, thinker_cls=_omni_qwen2_5_thinker_cls())
+        text_embeddings = model.get_language_model().embed_input_ids(input_ids)
+        result = model.embed_input_ids(
+            input_ids,
+            build_mm_embeds(audio_n=2, image_n=0, video_n=2, hidden=hidden),
+            is_multimodal=is_multimodal,
+        )
+
+        is_audio = input_ids == AUDIO_TOKEN_ID
+        is_video = input_ids == VIDEO_TOKEN_ID
+        assert torch.equal(is_multimodal, is_audio | is_video)
+        torch.testing.assert_close(result[is_audio], torch.full((2, hidden), 10.0))
+        torch.testing.assert_close(result[is_video], torch.full((2, hidden), 30.0))
+        torch.testing.assert_close(result[~(is_audio | is_video)], text_embeddings[~(is_audio | is_video)])
+
 
 # ---------------------------------------------------------------------------
 # Tests for merge_interleaved_embeddings helper
diff --git a/tests/model_executor/models/qwen3_omni/test_duplex_plugin.py b/tests/model_executor/models/qwen3_omni/test_duplex_plugin.py
new file mode 100644
index 000000000..908ae6cf6
--- /dev/null
+++ b/tests/model_executor/models/qwen3_omni/test_duplex_plugin.py
@@ -0,0 +1,948 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+import ast
+import asyncio
+import base64
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import pytest
+
+from tests.engine.duplex.test_session_runner import (
+    SESSION_ID,
+    Harness,
+    RecordingStagePort,
+    _speech_then_stop,
+    append_audio,
+    tts_output,
+)
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex.commands import (
+    AckPlayback,
+    CancelResponse,
+    ClearOutputAudio,
+    Commit,
+    CreateResponse,
+    UpdateSession,
+)
+from vllm_omni.engine.duplex.config import DuplexSessionConfig
+from vllm_omni.engine.duplex.messages import OpenDuplexSessionMessage
+from vllm_omni.engine.duplex.plugin import DuplexRuntimeConfigError
+from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+from vllm_omni.model_executor.models.qwen3_omni.duplex.input import QwenPcmBuffer
+from vllm_omni.model_executor.models.qwen3_omni.duplex.plugin import MAX_PROMPT_IMAGES, Qwen3OmniDuplexPlugin
+from vllm_omni.outputs import OmniRequestOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_buffer_commit_and_rollback_preserve_all_samples():
+    buffer = QwenPcmBuffer()
+    raw = np.ones(101, dtype="<f4").tobytes()
+    payload = {"audio": base64.b64encode(raw).decode(), "format": "pcm_f32le", "sample_rate_hz": 16000}
+    assert buffer.prepare_append(payload, operation_id="a", chunk_period_ms=1000, allow_emit=True) is None
+    reservation = buffer.prepare_commit(operation_id="c", chunk_period_ms=1000)
+    assert base64.b64decode(reservation.payload["audio"]) == raw
+    reservation.rollback()
+    assert buffer.pending_byte_count == len(raw)
+    final = buffer.prepare_commit(operation_id="d", chunk_period_ms=1000)
+    final.commit()
+    assert not buffer.has_pending() and not buffer.has_reserved()
+
+
+def test_buffer_refuses_video_frames_and_points_at_the_openai_interface():
+    buffer = QwenPcmBuffer()
+    payload = {
+        "audio": base64.b64encode(np.ones(16, dtype="<f4").tobytes()).decode(),
+        "format": "pcm_f32le",
+        "sample_rate_hz": 16000,
+        "video_frames": ["a-frame"],
+    }
+    with pytest.raises(ValueError, match="input_image"):
+        buffer.prepare_append(payload, operation_id="first", chunk_period_ms=200, allow_emit=True)
+    # The refusal must not swallow the audio it was sent with.
+    assert not buffer.has_pending()
+
+    del payload["video_frames"]
+    buffer.prepare_append(payload, operation_id="second", chunk_period_ms=200, allow_emit=True)
+    committed = buffer.prepare_commit(operation_id="second-commit", chunk_period_ms=200)
+    assert "video_frames" not in committed.payload
+    committed.commit()
+
+
+async def open_qwen():
+    plugin = Qwen3OmniDuplexPlugin(lambda audio, *args: "AAAA")
+    plugin.processor = SimpleNamespace(apply_chat_template=lambda messages, **kw: repr(messages))
+    port = RecordingStagePort(stage_count=3)
+    output: asyncio.Queue[Any] = asyncio.Queue()
+    results: asyncio.Queue[Any] = asyncio.Queue()
+    manager = DuplexSessionManager(
+        plugin=plugin,
+        stage_port=port,
+        output_sink=output,
+        result_sink=results,
+        runtime_config=DuplexSessionRuntimeConfig(),
+        model_config=None,
+    )
+    config = DuplexSessionConfig(model="qwen", modalities=["text", "audio"], overlap_policy="barge_in_on_speech")
+    await manager.handle(OpenDuplexSessionMessage(control_id="open", session_id=SESSION_ID, session_config=config))
+    result = await results.get()
+    assert result.ok, result
+    harness = Harness(manager, port, output, results, manager.runners[SESSION_ID])
+    await harness.settle()
+    return harness
+
+
+@pytest.mark.asyncio
+async def test_two_committed_turns_stream_text_and_audio_and_release_requests():
+    h = await open_qwen()
+    try:
+        ids = []
+        for i in range(2):
+            await h.run(append_audio())
+            assert len(h.port.submissions) == i
+            await h.run(Commit(final=True, create_response=True))
+            assert len(h.port.submissions) == i + 1, [e.to_realtime() for e in h.events]
+            request_id = h.port.submissions[-1].context.request_id
+            ids.append(request_id)
+            assert h.session.active_request_id == request_id
+            assert len(h.port.submissions[-1].prompt["multi_modal_data"]["audio"]) == i + 1
+            text = OmniRequestOutput.from_stage_output(
+                tts_output(request_id, samples=0, text="hello", finished=True),
+                request_id=request_id,
+                stage_id=None,
+            )
+            assert not h.deliver(text, stage_id=0), "Thinker output must still forward to Talker"
+            await h.settle()
+            assert text.finished, "projection must not mutate the output forwarded to Talker"
+            assert h.session.active_response_id is not None, "Thinker finished must not end the response"
+            response_id = h.session.active_response_id
+            await h.deliver_and_settle(tts_output(request_id, finished=True), stage_id=2)
+            await h.run(AckPlayback(response_id=response_id, played_ms=1000))
+            assert h.session.active_response_id is None
+            assert h.port.cleanups[-1][0] == [request_id]
+        assert len(set(ids)) == 2
+        assert h.session.capabilities.as_dict()["implementation_level"] == "turn_based_duplex"
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("played_ms", [0, 500, 1000])
+async def test_clear_completed_qwen_playback_allows_next_manual_turn(played_ms):
+    h = await open_qwen()
+    try:
+        await h.run(UpdateSession(patch={"turn_detection": None}))
+        assert h.session.config.overlap_policy == "listen_only"
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=False))
+        await h.run(CreateResponse())
+        old = h.port.submissions[-1].context
+        response_id = h.session.active_response_id
+        await h.deliver_and_settle(
+            tts_output(old.request_id, samples=0, text="first answer", finished=True), stage_id=0
+        )
+        await h.deliver_and_settle(tts_output(old.request_id, finished=True), stage_id=2)
+        if played_ms:
+            await h.run(AckPlayback(response_id=response_id, played_ms=played_ms, committed_ms=played_ms))
+        assert h.session.active_response_id is None
+        assert h.session.playback.sent_ms == 1000
+
+        events = await h.run(ClearOutputAudio(response_id=response_id))
+        cleared = [event for event in events if event.type == "output_audio_buffer.cleared"]
+        assert len(cleared) == 1
+        assert cleared[0].response_id == response_id
+        assert h.session.playback.sent_ms == h.session.playback.committed_ms == 0
+        # Repeated clear after the queue is empty still identifies the old turn.
+        repeated = await h.run(ClearOutputAudio(response_id=response_id))
+        assert [event.response_id for event in repeated if event.type == "output_audio_buffer.cleared"] == [response_id]
+
+        await h.run(append_audio(value=-0.25))
+        await h.run(Commit(final=True, create_response=False))
+        await h.run(CreateResponse())
+        assert len(h.port.submissions) == 2, [event.to_realtime() for event in h.events]
+        latest = h.port.submissions[-1]
+        assert latest.context.request_id != old.request_id
+        assert latest.prompt["prompt"] == repr(
+            [
+                {"role": "user", "content": [{"type": "audio"}]},
+                {"role": "assistant", "content": "first answer" if played_ms == 1000 else ""},
+                {"role": "user", "content": [{"type": "audio"}]},
+            ]
+        )
+        newest_audio, sample_rate = latest.prompt["multi_modal_data"]["audio"][-1]
+        assert sample_rate == 16000
+        np.testing.assert_array_equal(newest_audio, np.full(16000, -0.25, dtype=np.float32))
+
+        new_response_id = h.session.active_response_id
+        new_epoch = h.session.epoch
+        await h.deliver_and_settle(tts_output(latest.context.request_id, finished=False), stage_id=2)
+        new_playback = h.session.playback.as_dict()
+        late_clear = await h.run(ClearOutputAudio(response_id=response_id))
+        assert [event.response_id for event in late_clear if event.type == "output_audio_buffer.cleared"] == [
+            response_id
+        ]
+        assert h.session.active_response_id == new_response_id
+        assert h.session.active_request_id == latest.context.request_id
+        assert h.session.epoch == new_epoch
+        assert h.session.playback.as_dict() == new_playback
+        terminals = [event for event in h.events if event.type == "response.done" and event.response_id == response_id]
+        assert len(terminals) == 1 and terminals[0].status == "completed"
+        assert not any(event.to_realtime().get("type") == "error" for event in h.events)
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_cancel_drops_old_output_and_accepts_next_turn():
+    h = await open_qwen()
+    try:
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        old = h.port.submissions[-1].context
+        await h.run(CancelResponse())
+        await h.deliver_and_settle(tts_output(old.request_id, finished=True), stage_id=2, epoch=old.fence.epoch)
+        assert h.session.active_response_id is None
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        assert len(h.port.submissions) == 2
+        assert h.port.submissions[-1].context.request_id != old.request_id
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_vad_commits_and_speech_interrupts_active_qwen_response():
+    h = await open_qwen()
+    try:
+        h.runner.control._detector = _speech_then_stop()
+        await h.run(append_audio())
+        await h.run(append_audio(is_speech=False, value=0.0))
+        assert len(h.port.submissions) == 1
+        old = h.port.submissions[-1].context
+        h.runner.control._detector = _speech_then_stop()
+        await h.run(append_audio())
+        assert h.session.epoch > old.fence.epoch
+        await h.run(append_audio(is_speech=False, value=0.0))
+        assert len(h.port.submissions) == 2
+        assert h.port.submissions[-1].context.request_id != old.request_id
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("generation_finished", [False, True])
+async def test_vad_interrupts_queued_qwen_audio_and_keeps_the_new_utterance(generation_finished):
+    h = await open_qwen()
+    try:
+        h.runner.control._detector = _speech_then_stop()
+        await h.run(append_audio(value=0.125))
+        await h.run(append_audio(is_speech=False, value=0.0))
+        old = h.port.submissions[-1].context
+        response_id = h.session.active_response_id
+        await h.deliver_and_settle(
+            tts_output(old.request_id, samples=0, text="first answer", finished=True), stage_id=0
+        )
+        await h.deliver_and_settle(tts_output(old.request_id, samples=240000, finished=generation_finished), stage_id=2)
+        await h.run(AckPlayback(response_id=response_id, played_ms=1000, committed_ms=1000))
+        assert h.session.playback.sent_ms == 10000
+        assert h.session.playback.committed_ms == 1000
+        if generation_finished:
+            assert h.session.active_response_id is None
+            assert h.session.active_request_id is None
+
+        h.runner.control._detector = _speech_then_stop()
+        events = await h.run(append_audio(value=-0.25))
+        if generation_finished:
+            cleared = [event for event in events if event.type == "output_audio_buffer.cleared"]
+            assert len(cleared) == 1, [event.to_realtime() for event in events]
+            assert cleared[0].response_id == response_id
+        else:
+            assert any(event.type == "response.done" and event.status == "cancelled" for event in events)
+        assert h.session.epoch > old.fence.epoch
+        # Generation already completed is still completed: stopping playback
+        # must not emit a second, cancelled terminal for the same response.
+        terminals = [event for event in h.events if event.type == "response.done" and event.response_id == response_id]
+        assert len(terminals) == 1
+        assert terminals[0].status == ("completed" if generation_finished else "cancelled")
+
+        await h.run(append_audio(is_speech=False, value=0.0))
+        assert len(h.port.submissions) == 2
+        latest = h.port.submissions[-1]
+        assert latest.context.request_id != old.request_id
+        assert latest.prompt["prompt"] == repr(
+            [
+                {"role": "user", "content": [{"type": "audio"}]},
+                {"role": "assistant", "content": ""},
+                {"role": "user", "content": [{"type": "audio"}]},
+            ]
+        )
+        newest_audio, sample_rate = latest.prompt["multi_modal_data"]["audio"][-1]
+        assert sample_rate == 16000
+        np.testing.assert_array_equal(newest_audio, np.full(16000, -0.25, dtype=np.float32))
+    finally:
+        await h.manager.shutdown()
+
+
+def test_audio_projector_handles_delta_tensor_lists_and_sample_rate():
+    import torch
+
+    encoded: list[tuple[Any, object]] = []
+
+    def _encode(audio: object, rate: int, *_args: object) -> str:
+        encoded.append((audio, rate))
+        return "encoded"
+
+    plugin = Qwen3OmniDuplexPlugin(_encode)
+    output = SimpleNamespace(
+        request_id="r",
+        stage_id=2,
+        finished=True,
+        outputs=[],
+        multimodal_output={"audio": [torch.ones(8), torch.ones(16)], "sr": [torch.tensor(24000)]},
+    )
+    events = list(plugin.data_plane.project({"data_plane_outputs": [output]}, context={"modalities": ["audio"]}))
+    assert len(encoded) == 1 and encoded[0][0].shape == (24,)
+    assert events[0]["audio_duration_ms"] == 1
+    assert events[0]["end_of_turn"] is True
+
+
+def test_format_history_merges_user_parts_but_preserves_empty_assistant_boundary():
+    text = {"type": "text", "text": "first question"}
+    image = {"type": "image"}
+    audio = {"type": "audio"}
+    source = [
+        {"role": "system", "content": "instructions"},
+        {"role": "user", "content": [image]},
+        {"role": "user", "content": "first question"},
+        {"role": "user", "content": [audio]},
+        {"role": "assistant", "content": ""},
+        {"role": "user", "content": "next question"},
+        {"role": "user", "content": [image, audio]},
+    ]
+    before = repr(source)
+    assert Qwen3OmniDuplexPlugin.format_history(source) == [
+        source[0],
+        {"role": "user", "content": [image, text, audio]},
+        {"role": "assistant", "content": ""},
+        {"role": "user", "content": [image, audio, {"type": "text", "text": "next question"}]},
+    ]
+    assert repr(source) == before
+
+
+def test_audio_byte_budget_evicts_whole_multimodal_turn():
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    state = plugin.create_session_state()
+    first = {"role": "user", "content": [{"type": "audio_url"}]}
+    image = {"role": "user", "content": [{"type": "image_url"}]}
+    source = [first, image]
+    plugin.prepare_prompt_config({"conversation": source}, state=state, payload={"audio": "A" * (5 * 1024 * 1024)})
+    source.extend(
+        [
+            {"role": "assistant", "content": "old answer"},
+            {"role": "user", "content": [{"type": "audio_url"}]},
+        ]
+    )
+    current = {"audio": "B" * (4 * 1024 * 1024)}
+    config = plugin.prepare_prompt_config({"conversation": source}, state=state, payload=current)
+    assert config["qwen_messages"] == [{"role": "user", "audio_payload": current}]
+    assert len(state.audio_history) == 1
+    assert source[1] is image
+
+
+def test_audio_history_is_bounded_and_does_not_cross_sessions():
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    state, other = plugin.create_session_state(), plugin.create_session_state()
+    history = []
+    for i in range(6):
+        history.append({"role": "user", "content": [{"type": "audio_url"}]})
+        config = plugin.prepare_prompt_config({"conversation": history}, state=state, payload={"audio": str(i)})
+        history.append({"role": "assistant", "content": f"reply-{i}"})
+    assert len(state.audio_history) == 4
+    assert [m["audio_payload"]["audio"] for m in config["qwen_messages"] if "audio_payload" in m] == [
+        "2",
+        "3",
+        "4",
+        "5",
+    ]
+    assert other.audio_history == []
+
+
+@pytest.mark.parametrize("assistant_text", ["", "previous answer"])
+def test_dropped_audio_removes_its_image_and_assistant(assistant_text):
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    state = plugin.create_session_state()
+    image = {"role": "user", "content": [{"type": "image_url"}]}
+    history = [image]
+    for i in range(6):
+        history.append({"role": "user", "content": [{"type": "audio_url"}]})
+        config = plugin.prepare_prompt_config({"conversation": history}, state=state, payload={"audio": str(i)})
+        history.append({"role": "assistant", "content": assistant_text})
+    assert config["qwen_messages"] == [
+        {"role": "user", "audio_payload": {"audio": "2"}},
+        {"role": "assistant", "content": assistant_text},
+        {"role": "user", "audio_payload": {"audio": "3"}},
+        {"role": "assistant", "content": assistant_text},
+        {"role": "user", "audio_payload": {"audio": "4"}},
+        {"role": "assistant", "content": assistant_text},
+        {"role": "user", "audio_payload": {"audio": "5"}},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_late_playback_ack_keeps_answer_before_new_user_input():
+    h = await open_qwen()
+    try:
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        request_id = h.port.submissions[-1].context.request_id
+        response_id = h.session.active_response_id
+        await h.deliver_and_settle(tts_output(request_id, samples=0, text="first answer", finished=True), stage_id=0)
+        await h.deliver_and_settle(tts_output(request_id, finished=True), stage_id=2)
+        # The unplayed answer reserves its turn without exposing unheard text.
+        assert [m["role"] for m in h.session.history] == ["user", "assistant"]
+        assert h.session.history[1]["content"] == ""
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        assert h.port.submissions[-1].prompt["prompt"] == repr(
+            [
+                {"role": "user", "content": [{"type": "audio"}]},
+                {"role": "assistant", "content": ""},
+                {"role": "user", "content": [{"type": "audio"}]},
+            ]
+        )
+        current_response = h.session.active_response_id
+        events = await h.run(AckPlayback(response_id=response_id, played_ms=1000))
+        assert not any(e.to_realtime().get("type") == "error" for e in events)
+        assert [m["role"] for m in h.session.history] == ["user", "assistant", "user"]
+        assert h.session.history[1]["content"] == "first answer"
+        assert h.session.active_response_id == current_response
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("streaming_vad", [False, True])
+async def test_finished_qwen_response_does_not_repeat_during_silence(streaming_vad):
+    h = await open_qwen()
+    try:
+        if streaming_vad:
+            from vllm_omni.engine.duplex.turn_detection import ServerTurnDetector, TurnDetectionConfig
+
+            detector = ServerTurnDetector(TurnDetectionConfig())
+            # Exercise framing, endpointing and reset across the entire response.
+            # A deterministic scorer avoids requiring an ONNX artifact in CPU tests.
+            detector.vad._frame_scorer = lambda frame: float(np.max(np.abs(frame)) > 0.01)
+            h.runner.control._detector = detector
+        else:
+            h.runner.control._detector = _speech_then_stop()
+        await h.run(append_audio())
+        await h.run(append_audio(is_speech=False, value=0.0))
+        if not streaming_vad:
+            h.runner.control._detector = None
+        assert len(h.port.submissions) == 1
+        request_id = h.port.submissions[0].context.request_id
+        response_id = h.session.active_response_id
+        await h.deliver_and_settle(tts_output(request_id, samples=0, text="story", finished=True), stage_id=0)
+        for _ in range(3):
+            await h.run(append_audio(is_speech=False, value=0.0))
+        await h.deliver_and_settle(tts_output(request_id, finished=True), stage_id=2)
+        for _ in range(3):
+            await h.run(append_audio(is_speech=False, value=0.0))
+        await h.run(AckPlayback(response_id=response_id, played_ms=1000))
+        await h.settle()
+        assert len(h.port.submissions) == 1
+        assert not h.runner.model_state.audio_buffer.has_pending()
+        assert h.runner.model_state.committed_audio_payload is None
+    finally:
+        await h.manager.shutdown()
+
+
+def test_current_audio_is_not_replaced_by_history_ending_with_assistant():
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    plugin.processor = SimpleNamespace(apply_chat_template=lambda messages, **kwargs: repr(messages))
+    state = plugin.create_session_state()
+    first = {"audio": base64.b64encode(np.full(160, 0.1, dtype="<f4").tobytes()).decode()}
+    current = {"audio": base64.b64encode(np.full(320, 0.2, dtype="<f4").tobytes()).decode()}
+    history = [{"role": "user", "content": [{"type": "audio_url"}]}]
+    plugin.prepare_prompt_config({"conversation": history}, state=state, payload=first)
+    history.append({"role": "assistant", "content": "Previous answer"})
+    config = plugin.prepare_prompt_config({"conversation": history}, state=state, payload=current)
+    plan = plugin.plan_append(
+        request_id="new",
+        fence=None,
+        session_config=config,
+        runtime_config={},
+        seq=1,
+        turn_seq=1,
+        payload=current,
+        final=True,
+        sampling_params=None,
+    )
+    audios = plan.prompt["multi_modal_data"]["audio"]
+    assert len(audios) == 2
+    np.testing.assert_allclose(audios[-1][0], np.full(320, 0.2, dtype="<f4"))
+    assert config["qwen_messages"][-1]["audio_payload"] is current
+
+
+@pytest.mark.parametrize("current_in_history", [False, True])
+def test_empty_assistant_keeps_turn_boundary_in_audio_prompt(current_in_history):
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    plugin.processor = SimpleNamespace(apply_chat_template=lambda messages, **kwargs: repr(messages))
+    state = plugin.create_session_state()
+    first = {"audio": base64.b64encode(np.full(160, 0.1, dtype="<f4").tobytes()).decode()}
+    current = {"audio": base64.b64encode(np.full(320, 0.2, dtype="<f4").tobytes()).decode()}
+    history = [{"role": "user", "content": [{"type": "audio_url"}]}]
+    plugin.prepare_prompt_config({"conversation": history}, state=state, payload=first)
+    # Playback was interrupted before any unaligned Thinker text was committed.
+    # The assistant turn still separates the old request from the new utterance.
+    history.append({"role": "assistant", "content": ""})
+    if current_in_history:
+        history.append({"role": "user", "content": [{"type": "audio_url"}]})
+    config = plugin.prepare_prompt_config({"conversation": history}, state=state, payload=current)
+    plan = plugin.plan_append(
+        request_id="after-interruption",
+        fence=None,
+        session_config=config,
+        runtime_config={},
+        seq=1,
+        turn_seq=1,
+        payload=current,
+        final=True,
+        sampling_params=None,
+    )
+    assert plan.prompt["prompt"] == repr(
+        [
+            {"role": "user", "content": [{"type": "audio"}]},
+            {"role": "assistant", "content": ""},
+            {"role": "user", "content": [{"type": "audio"}]},
+        ]
+    )
+    audios = plan.prompt["multi_modal_data"]["audio"]
+    assert len(audios) == 2
+    np.testing.assert_allclose(audios[0][0], np.full(160, 0.1, dtype="<f4"))
+    np.testing.assert_allclose(audios[1][0], np.full(320, 0.2, dtype="<f4"))
+
+
+@pytest.mark.asyncio
+async def test_partial_playback_does_not_commit_unaligned_thinker_text():
+    h = await open_qwen()
+    try:
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        request_id = h.port.submissions[-1].context.request_id
+        response_id = h.session.active_response_id
+        await h.deliver_and_settle(tts_output(request_id, samples=0, text="entire answer", finished=True), stage_id=0)
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, finished=False), stage_id=2)
+        await h.run(AckPlayback(response_id=response_id, played_ms=1000))
+        assert not any(m["role"] == "assistant" for m in h.session.history)
+        await h.deliver_and_settle(tts_output(request_id, samples=216000, finished=True), stage_id=2)
+        await h.run(AckPlayback(response_id=response_id, played_ms=1000))
+        assert [m for m in h.session.history if m["role"] == "assistant"] == [{"role": "assistant", "content": ""}]
+        await h.run(AckPlayback(response_id=response_id, played_ms=10000))
+        assert h.session.history[-1]["content"] == "entire answer"
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_prompt_preparation_runs_off_loop_and_cancellation_prevents_submission():
+    import threading
+
+    h = await open_qwen()
+    entered, release = threading.Event(), threading.Event()
+    thread_ids = []
+    original = h.manager.plugin.plan_append
+
+    def slow_plan(**kwargs):
+        thread_ids.append(threading.get_ident())
+        entered.set()
+        assert release.wait(5)
+        return original(**kwargs)
+
+    h.manager.plugin.plan_append = slow_plan
+    try:
+        await h.run(append_audio())
+        commit = asyncio.create_task(h.run(Commit(final=True, create_response=True)))
+        for _ in range(100):
+            if entered.is_set():
+                break
+            await asyncio.sleep(0.01)
+        assert entered.is_set()
+        assert thread_ids != [threading.get_ident()]
+        await h.run(CancelResponse())
+        release.set()
+        await commit
+        await h.settle()
+        assert not h.port.submissions
+    finally:
+        release.set()
+        await h.manager.shutdown()
+
+
+def camera_frame():
+    import io
+
+    from PIL import Image
+
+    buf = io.BytesIO()
+    Image.new("RGB", (16, 16), "red").save(buf, format="JPEG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def pcm16_base64(samples=16000):
+    """Loud PCM16, so the projection reads it as speech rather than silence."""
+    pcm = (np.sin(np.arange(samples) * 0.05) * 20000).astype("<i2")
+    return base64.b64encode(pcm.tobytes()).decode()
+
+
+def image_item(item_id="camera"):
+    return {
+        "id": item_id,
+        "type": "message",
+        "role": "user",
+        "content": [
+            {"type": "input_image", "image_url": "data:image/jpeg;base64," + camera_frame()},
+            {"type": "input_text", "text": "What color is this?"},
+        ],
+    }
+
+
+@pytest.mark.asyncio
+async def test_image_item_is_context_until_response_create_and_delete_removes_it():
+    from vllm_omni.engine.duplex.commands import CreateResponse, DeleteItem
+
+    h = await open_qwen()
+    try:
+        from vllm_omni.engine.duplex.realtime_commands import translate_realtime_command
+
+        await h.run(translate_realtime_command({"type": "conversation.item.create", "item": image_item()}))
+        assert not h.port.submissions
+        await h.run(CreateResponse())
+        assert len(h.port.submissions) == 1
+        prompt = h.port.submissions[-1].prompt
+        assert len(prompt["multi_modal_data"]["image"]) == 1
+        assert "audio" not in prompt["multi_modal_data"]
+        assert "What color is this?" in prompt["prompt"]
+        await h.run(CancelResponse())
+        await h.run(DeleteItem(item_id="camera"))
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=False))
+        assert len(h.port.submissions) == 1
+        await h.run(CreateResponse())
+        assert "image" not in h.port.submissions[-1].prompt["multi_modal_data"]
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_image_context_reaches_audio_turn_and_survives_commit():
+    from vllm_omni.engine.duplex.commands import CreateItem
+
+    h = await open_qwen()
+    try:
+        await h.run(CreateItem(item=image_item()))
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        mm = h.port.submissions[-1].prompt["multi_modal_data"]
+        assert len(mm["image"]) == 1 and len(mm["audio"]) == 1
+        assert any(
+            isinstance(m["content"], list) and any(p.get("type") == "image_url" for p in m["content"])
+            for m in h.session.history
+        )
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_multiple_commits_before_response_keep_one_combined_audio_in_history():
+    from vllm_omni.engine.duplex.commands import CreateItem
+
+    h = await open_qwen()
+    try:
+        await h.run(append_audio(value=0.1))
+        await h.run(Commit(final=True, create_response=False))
+        await h.run(CreateItem(item=image_item()))
+        await h.run(append_audio(value=0.2))
+        await h.run(Commit(final=True, create_response=False))
+        await h.run(CreateResponse())
+        assert len(h.port.submissions) == 1, [e.to_realtime() for e in h.events]
+        first = h.port.submissions[-1]
+        audio = first.prompt["multi_modal_data"]["audio"]
+        assert len(audio) == 1
+        np.testing.assert_allclose(audio[0][0], np.repeat(np.array([0.1, 0.2], dtype=np.float32), 16000))
+        response_id = h.session.active_response_id
+        await h.deliver_and_settle(
+            tts_output(first.context.request_id, samples=0, text="combined answer", finished=True), stage_id=0
+        )
+        await h.deliver_and_settle(tts_output(first.context.request_id, finished=True), stage_id=2)
+        await h.run(AckPlayback(response_id=response_id, played_ms=1000, committed_ms=1000))
+        await h.run(append_audio(value=0.3))
+        await h.run(Commit(final=True, create_response=True))
+        next_audio = h.port.submissions[-1].prompt["multi_modal_data"]["audio"]
+        assert len(next_audio) == 2
+        np.testing.assert_array_equal(next_audio[0][0], audio[0][0])
+        np.testing.assert_allclose(next_audio[1][0], 0.3)
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("image_after_commit", [False, True])
+async def test_multimodal_turn_is_merged_retained_and_evicted_with_its_answer(image_after_commit):
+    from vllm_omni.engine.duplex.commands import CreateItem
+
+    h = await open_qwen()
+    try:
+        for turn in range(6):
+            if turn == 0 and not image_after_commit:
+                await h.run(CreateItem(item=image_item()))
+            await h.run(append_audio(value=(turn + 1) / 10))
+            await h.run(Commit(final=True, create_response=False))
+            assert len(h.port.submissions) == turn
+            if turn == 0 and image_after_commit:
+                await h.run(CreateItem(item=image_item()))
+            await h.run(CreateResponse())
+            submission = h.port.submissions[-1]
+            prompt = submission.prompt
+            messages = ast.literal_eval(prompt["prompt"])
+            first_retained = max(0, turn - 3)
+            assert [m["role"] for m in messages] == ["user", "assistant"] * (turn - first_retained) + ["user"]
+            assert [m["content"] for m in messages if m["role"] == "assistant"] == [
+                f"answer-{i}" for i in range(first_retained, turn)
+            ]
+            audios = prompt["multi_modal_data"]["audio"]
+            assert len(audios) == turn - first_retained + 1
+            for index, (audio, rate) in enumerate(audios, start=first_retained):
+                assert rate == 16000
+                np.testing.assert_allclose(audio, (index + 1) / 10)
+            assert len(prompt["multi_modal_data"].get("image", [])) == int(first_retained == 0)
+            if first_retained == 0:
+                parts = messages[0]["content"]
+                assert sum(p["type"] == "image" for p in parts) == 1
+                assert sum(p["type"] == "audio" for p in parts) == 1
+                assert {"type": "text", "text": "What color is this?"} in parts
+
+            response_id = h.session.active_response_id
+            request_id = submission.context.request_id
+            await h.deliver_and_settle(
+                tts_output(request_id, samples=0, text=f"answer-{turn}", finished=True), stage_id=0
+            )
+            await h.deliver_and_settle(tts_output(request_id, finished=True), stage_id=2)
+            await h.run(AckPlayback(response_id=response_id, played_ms=1000, committed_ms=1000))
+            assert h.session.history[-1]["content"] == f"answer-{turn}"
+        # Prompt eviction leaves source items individually addressable by the client.
+        assert "camera" in h.session.history_item_ids
+        assert not any(e.to_realtime().get("type") == "error" for e in h.events)
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_image_only_item_reaches_the_prompt_the_way_the_camera_sends_it():
+    """The camera sends each frame as its own item, with no text part.
+
+    A user item used to be forwarded to the session only when it carried text
+    or audio, so an image-only item was acknowledged to the client and then
+    dropped. Nothing reported it and every prompt that followed was blind.
+    """
+    from vllm_omni.engine.duplex.realtime_commands import translate_realtime_command
+
+    h = await open_qwen()
+    try:
+        item = {
+            "id": "camera_1",
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_image", "image_url": "data:image/jpeg;base64," + camera_frame()}],
+        }
+        await h.run(translate_realtime_command({"type": "conversation.item.create", "item": item}))
+        assert [
+            part
+            for message in h.session.history
+            if isinstance(message.get("content"), list)
+            for part in message["content"]
+            if part.get("type") == "image_url"
+        ], "an image-only item never reached the session history"
+
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        mm = h.port.submissions[-1].prompt["multi_modal_data"]
+        assert len(mm["image"]) == 1 and len(mm["audio"]) == 1
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_one_item_carrying_both_speech_and_a_picture_keeps_both():
+    """Audio and images leave the same item by different routes.
+
+    The audio becomes buffered appends that a commit seals under this item's
+    id; registering the spoken message there would overwrite an image stored
+    under the same id, so the picture has to become its own item.
+    """
+    from vllm_omni.engine.duplex.commands import CreateResponse
+    from vllm_omni.engine.duplex.realtime_commands import translate_realtime_command
+
+    h = await open_qwen()
+    try:
+        item = {
+            "id": "mixed_1",
+            "type": "message",
+            "role": "user",
+            "content": [
+                {"type": "input_image", "image_url": "data:image/jpeg;base64," + camera_frame()},
+                {"type": "input_audio", "audio": pcm16_base64(), "format": "pcm16", "sample_rate_hz": 16000},
+            ],
+        }
+        await h.run(translate_realtime_command({"type": "conversation.item.create", "item": item}))
+        await h.run(CreateResponse())
+        mm = h.port.submissions[-1].prompt["multi_modal_data"]
+        assert len(mm["image"]) == 1, "the picture was dropped on its way out of a mixed item"
+        assert len(mm["audio"]) == 1
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_image_limit_rejects_atomically_and_delete_reclaims_capacity():
+    from vllm_omni.engine.duplex.commands import CreateItem, DeleteItem
+
+    h = await open_qwen()
+    try:
+        for i in range(8):
+            await h.run(CreateItem(item=image_item(f"camera_{i}")))
+        events = await h.run(CreateItem(item=image_item("overflow")))
+        assert any(e.to_realtime()["type"] == "error" for e in events)
+        assert len(h.session.history) == 8
+        await h.run(DeleteItem(item_id="camera_0"))
+        await h.run(CreateItem(item=image_item("replacement")))
+        assert len(h.session.history) == 8
+        assert not h.port.submissions
+    finally:
+        await h.manager.shutdown()
+
+
+def test_prompt_holds_stored_images_to_the_stage_limit():
+    """The prompt is the last guard before ``limit_mm_per_prompt``.
+
+    A dropped image has to take its ``{"type": "image"}`` placeholder with
+    it, because the processor pairs placeholders with ``mm["image"]``
+    positionally.
+    """
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    plugin.processor = SimpleNamespace(apply_chat_template=lambda messages, **kwargs: repr(messages))
+    url = "data:image/jpeg;base64," + camera_frame()
+    history: list[dict[str, Any]] = [
+        {
+            "role": "user",
+            "content": [{"type": "image_url", "image_url": {"url": url}}, {"type": "text", "text": f"i{i}"}],
+        }
+        for i in range(MAX_PROMPT_IMAGES + 2)
+    ]
+    audio = base64.b64encode(np.full(160, 0.1, dtype="<f4").tobytes()).decode()
+    history.append({"role": "user", "audio_payload": {"audio": audio}})
+
+    plan = plugin.plan_append(
+        request_id="r",
+        fence=None,
+        session_config={"qwen_messages": history},
+        runtime_config={},
+        seq=1,
+        turn_seq=1,
+        payload={"audio": audio},
+        final=True,
+        sampling_params=None,
+    )
+
+    prompt = plan.prompt
+    assert len(prompt["multi_modal_data"]["image"]) == MAX_PROMPT_IMAGES
+    assert prompt["prompt"].count("{'type': 'image'}") == MAX_PROMPT_IMAGES
+    # Only the image part is retired; the message keeps what it said.
+    assert "'i0'" in prompt["prompt"]
+
+
+def test_text_only_turn_without_prepared_messages_is_refused_not_crashed():
+    plugin = Qwen3OmniDuplexPlugin(lambda *args: None)
+    plugin.processor = SimpleNamespace(apply_chat_template=lambda messages, **kwargs: repr(messages))
+    with pytest.raises(DuplexRuntimeConfigError):
+        plugin.plan_append(
+            request_id="r",
+            fence=None,
+            # An empty prepared list is not a missing one: it must not fall
+            # back to a payload that has no audio to read.
+            session_config={"qwen_messages": []},
+            runtime_config={},
+            seq=1,
+            turn_seq=1,
+            payload={"is_speech": True},
+            final=True,
+            sampling_params=None,
+        )
+
+
+@pytest.mark.asyncio
+async def test_commit_all_on_done_keeps_unaligned_text_the_client_never_acks():
+    h = await open_qwen()
+    try:
+        # The runner starts every session ack-gated; this client opts out.
+        await h.run(UpdateSession(patch={"playback_commit_policy": "commit_all_on_done"}))
+        assert h.session.config.playback_commit_policy == "commit_all_on_done"
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        request_id = h.port.submissions[-1].context.request_id
+        await h.deliver_and_settle(tts_output(request_id, samples=0, text="entire answer", finished=True), stage_id=0)
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, finished=True), stage_id=2)
+        # Qwen text is unaligned to its audio, but waiting for an ACK this
+        # client will never send would drop the turn from history entirely.
+        assert h.session.active_response_id is None
+        assert h.session.history[-1]["content"] == "entire answer"
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_the_bound_request_id_is_the_one_the_stage_received():
+    h = await open_qwen()
+    try:
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        submitted = h.port.submissions[-1].context.request_id
+        # Qwen has no resumable core request, so every turn gets its own stage
+        # id. The runner names that id before the append runs and the model
+        # channel names it again when it submits; they have to agree.
+        assert submitted.endswith(".r.stage0-turn0"), submitted
+        assert h.session.active_request_id == submitted
+    finally:
+        await h.manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_visual_capture_records_submitted_pixels_and_request(tmp_path, monkeypatch):
+    import json
+
+    from PIL import Image
+
+    from vllm_omni.engine.duplex.commands import CreateItem
+
+    monkeypatch.setenv("VLLM_OMNI_QWEN_VISUAL_DEBUG_DIR", str(tmp_path))
+    h = await open_qwen()
+    try:
+        await h.run(CreateItem(item=image_item()))
+        await h.run(append_audio())
+        await h.run(Commit(final=True, create_response=True))
+        submission = h.port.submissions[-1]
+        captures = list(tmp_path.glob("*/input.json"))
+        assert len(captures) == 1
+        metadata = json.loads(captures[0].read_text())
+        assert metadata["request_id"] == submission.context.request_id
+        assert metadata["audio_count"] == 1
+        assert metadata["prompt"] == submission.prompt["prompt"]
+        assert len(metadata["images"]) == 1
+        with Image.open(captures[0].parent / metadata["images"][0]) as saved:
+            actual = submission.prompt["multi_modal_data"]["image"][0]
+            assert saved.size == actual.size
+            assert saved.tobytes() == actual.tobytes()
+    finally:
+        await h.manager.shutdown()
diff --git a/tests/model_executor/models/qwen3_omni/test_qwen3_omni_embed.py b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_embed.py
new file mode 100644
index 000000000..ec6e653c5
--- /dev/null
+++ b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_embed.py
@@ -0,0 +1,219 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Run Qwen3-Omni embedding regressions on a Linux/CUDA environment.
+
+The oracle assigns features to token positions independently of the model's
+merge helpers. LM call counts additionally catch issue #7451: ordinary
+multimodal inputs must not repeat the text embedding lookup. Small synthetic
+weights suffice; no checkpoint is downloaded or loaded.
+"""
+
+import sys
+
+import pytest
+import torch
+from pytest_mock import MockerFixture
+
+from benchmarks.qwen3_omni.embedding_harness import (
+    ModelShape,
+    assert_case_output,
+    build_case,
+    expected_outputs,
+    make_thinker,
+)
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.cuda,
+    pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="requires NVIDIA CUDA"),
+]
+
+_SHAPE = ModelShape(
+    vocab_size=64,
+    hidden_size=8,
+    deepstack_levels=3,
+    image_token_id=60,
+    video_token_id=61,
+    audio_token_id=62,
+)
+
+_SCENARIOS = (
+    "text",
+    "empty",
+    "audio",
+    "image",
+    "video",
+    "mixed",
+    "interleaved",
+    "vision_no_deepstack",
+)
+
+
+@pytest.fixture(scope="module", autouse=True)
+def require_cuda_environment():
+    if sys.platform != "linux" or torch.version.cuda is None or not torch.cuda.is_available():
+        pytest.fail(
+            "This validation suite requires a Linux/CUDA environment; "
+            "CPU execution and an all-skipped result are not valid substitutes.",
+            pytrace=False,
+        )
+    if not torch.cuda.is_bf16_supported(including_emulation=False):
+        pytest.fail("This validation suite requires native BF16 support on the current CUDA device.", pytrace=False)
+
+
+@torch.inference_mode()
+def _embed(model, case):
+    return model.embed_input_ids(
+        case.input_ids,
+        multimodal_embeddings=case.fresh_embeddings(),
+        is_multimodal=case.is_multimodal,
+    )
+
+
+@pytest.mark.parametrize(
+    ("scenario", "dtype"),
+    [pytest.param(scenario, torch.bfloat16, id=f"{scenario}-bf16") for scenario in _SCENARIOS]
+    + [pytest.param(scenario, torch.float32, id=f"{scenario}-fp32") for scenario in ("image", "mixed", "interleaved")],
+)
+def test_embedding_positions_and_single_lm_lookup(mocker: MockerFixture, scenario: str, dtype: torch.dtype):
+    model = make_thinker(_SHAPE, device="cuda", dtype=dtype, deepstack=scenario != "vision_no_deepstack")
+    case = build_case(
+        scenario,
+        16,
+        0 if scenario in {"text", "empty"} else 8,
+        _SHAPE,
+        device="cuda",
+        dtype=dtype,
+        mask_device="cpu",
+    )
+    lm_embed = mocker.spy(model.language_model, "embed_input_ids")
+
+    result = _embed(model, case)
+
+    # Unlike upstream-only mocks, make_thinker returns an instance of Omni's
+    # actual thinker class, so its zero-argument super() follows the real MRO.
+    lm_embed.assert_called_once()
+    assert_case_output(model, case, result)
+
+
+@pytest.mark.parametrize("scenario", ["image", "mixed", "interleaved"])
+def test_repeated_calls_keep_original_deepstack_features(mocker: MockerFixture, scenario: str):
+    model = make_thinker(_SHAPE, device="cuda", dtype=torch.bfloat16)
+    case = build_case(scenario, 16, 8, _SHAPE, device="cuda", dtype=torch.bfloat16, mask_device="cpu")
+    original_embeddings = case.fresh_embeddings()
+    assert original_embeddings
+    original_shapes = [tensor.shape for tensor in original_embeddings]
+    original_modalities = [getattr(tensor, "modality", None) for tensor in original_embeddings]
+    lm_embed = mocker.spy(model.language_model, "embed_input_ids")
+    previous_list = None
+
+    for _ in range(3):
+        embeddings = case.fresh_embeddings()
+        assert embeddings is not original_embeddings
+        assert embeddings is not previous_list
+        assert [tensor.shape for tensor in embeddings] == original_shapes
+        assert [getattr(tensor, "modality", None) for tensor in embeddings] == original_modalities
+        lm_embed.reset_mock()
+
+        with torch.inference_mode():
+            result = model.embed_input_ids(
+                case.input_ids,
+                multimodal_embeddings=embeddings,
+                is_multimodal=case.is_multimodal,
+            )
+
+        lm_embed.assert_called_once()
+        assert_case_output(model, case, result)
+        # torch.split replaces entries in the supplied list with main-scale
+        # views. The next call must receive the original multiscale tensors.
+        assert [tensor.shape for tensor in original_embeddings] == original_shapes
+        model._clear_deepstack_input_embeds(case.input_ids.numel())
+        previous_list = embeddings
+
+
+@pytest.mark.parametrize("scenario", ["audio", "image", "mixed", "interleaved"])
+def test_oov_multimodal_ids_are_masked_before_lm_lookup(mocker: MockerFixture, scenario: str):
+    model = make_thinker(_SHAPE, device="cuda", dtype=torch.bfloat16, oov=True)
+    case = build_case(scenario, 16, 8, _SHAPE, device="cuda", dtype=torch.bfloat16, mask_device="cpu", oov=True)
+    original_ids = case.input_ids.clone()
+    mask = case.is_multimodal.to(device=case.input_ids.device)
+    assert torch.all(case.input_ids[mask] >= _SHAPE.vocab_size)
+    lm_embed = mocker.spy(model.language_model, "embed_input_ids")
+
+    result = _embed(model, case)
+
+    lm_embed.assert_called_once()
+    received_ids = lm_embed.call_args.args[0]
+    torch.testing.assert_close(received_ids, original_ids.masked_fill(mask, 0), rtol=0, atol=0)
+    torch.testing.assert_close(case.input_ids, original_ids, rtol=0, atol=0)
+    assert_case_output(model, case, result)
+
+
+@pytest.mark.parametrize("next_scenario", ["text", "empty"])
+def test_padded_deepstack_read_and_clear_do_not_leak_into_decode(mocker: MockerFixture, next_scenario: str):
+    model = make_thinker(_SHAPE, device="cuda", dtype=torch.bfloat16, buffer_capacity=32)
+    image_case = build_case("image", 16, 8, _SHAPE, device="cuda", dtype=torch.bfloat16, mask_device="cpu")
+    image_result = _embed(model, image_case)
+    assert_case_output(model, image_case, image_result)
+    _, expected_deepstack = expected_outputs(model, image_case)
+    assert expected_deepstack is not None
+
+    num_valid = image_case.input_ids.numel()
+    num_padded = 24
+    # Padding may contain old buffer contents. _get must zero the tail while
+    # retaining all valid visual features, as the real forward requires.
+    for buffer in model.deepstack_input_embeds:
+        buffer[num_valid:num_padded].fill_(77)
+    padded = model._get_deepstack_input_embeds(num_padded)
+    assert padded is not None
+    for level in range(_SHAPE.deepstack_levels):
+        actual = padded[f"deepstack_input_embeds_{level}"]
+        torch.testing.assert_close(actual[:num_valid], expected_deepstack[level])
+        assert torch.count_nonzero(actual[num_valid:]).item() == 0
+
+    model._clear_deepstack_input_embeds(num_padded)
+    assert model.deepstack_input_embeds_num_tokens == 0
+    for buffer in model.deepstack_input_embeds:
+        assert torch.count_nonzero(buffer[:num_padded]).item() == 0
+
+    decode_case = build_case(next_scenario, 1, 0, _SHAPE, device="cuda", dtype=torch.bfloat16, mask_device="cpu")
+    lm_embed = mocker.spy(model.language_model, "embed_input_ids")
+    decode_result = _embed(model, decode_case)
+    lm_embed.assert_called_once()
+    assert_case_output(model, decode_case, decode_result)
+    decode_deepstack = model._get_deepstack_input_embeds(2)
+    assert decode_deepstack is not None
+    for level in range(_SHAPE.deepstack_levels):
+        assert torch.count_nonzero(decode_deepstack[f"deepstack_input_embeds_{level}"]).item() == 0
+
+
+@torch.inference_mode()
+def test_deepstack_set_resizes_for_larger_scheduled_windows(mocker: MockerFixture):
+    model = make_thinker(_SHAPE, device="cuda", dtype=torch.bfloat16, buffer_capacity=4)
+    lm_embed = mocker.spy(model.language_model, "embed_input_ids")
+
+    for num_tokens in (16, 24):
+        case = build_case("mixed", num_tokens, 8, _SHAPE, device="cuda", dtype=torch.bfloat16, mask_device="cpu")
+        lm_embed.reset_mock()
+        result = _embed(model, case)
+
+        lm_embed.assert_called_once()
+        assert_case_output(model, case, result)
+        assert model.deepstack_input_embeds_num_tokens == num_tokens
+        assert all(buffer.size(0) >= num_tokens for buffer in model.deepstack_input_embeds)
+        model._clear_deepstack_input_embeds(num_tokens)
+
+
+@pytest.mark.parametrize("mask_device", ["cpu", "cuda"])
+@pytest.mark.parametrize("scenario", ["image", "interleaved"])
+def test_cuda_embeddings_accept_cpu_or_cuda_mask(mocker: MockerFixture, scenario: str, mask_device: str):
+    model = make_thinker(_SHAPE, device="cuda", dtype=torch.bfloat16)
+    case = build_case(scenario, 16, 8, _SHAPE, device="cuda", dtype=torch.bfloat16, mask_device=mask_device)
+    lm_embed = mocker.spy(model.language_model, "embed_input_ids")
+
+    result = _embed(model, case)
+
+    lm_embed.assert_called_once()
+    assert result.device.type == "cuda"
+    assert_case_output(model, case, result)
diff --git a/tests/model_executor/models/qwen3_omni/test_qwen3_omni_forward_contract.py b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_forward_contract.py
index 0055d1704..f4635a81f 100644
--- a/tests/model_executor/models/qwen3_omni/test_qwen3_omni_forward_contract.py
+++ b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_forward_contract.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for the Qwen3-Omni thinker forward return contract.
 
 Background
@@ -41,6 +41,7 @@ from vllm_omni.model_executor.models.qwen3_omni.qwen3_omni import (
     Qwen3OmniMoeForConditionalGeneration,
 )
 from vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker import (
+    Qwen3MoeLLMModel,
     Qwen3OmniMoeThinkerForConditionalGeneration,
 )
 
@@ -54,6 +55,52 @@ def _hidden_states() -> torch.Tensor:
     return torch.zeros(_TOKENS, _HIDDEN)
 
 
+def test_single_rank_intermediate_capture_includes_deferred_residual(mocker):
+    """Capture the Talker state on the default single-PP-rank path."""
+    import vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker as module
+
+    pp_group = mocker.Mock(is_first_rank=True, is_last_rank=True)
+    mocker.patch.object(module, "get_pp_group", return_value=pp_group)
+
+    class SplitStateLayer(nn.Module):
+        def forward(self, positions, hidden_states, residual):
+            next_residual = hidden_states if residual is None else hidden_states + residual
+            return hidden_states * 2, next_residual
+
+    class Combine(nn.Module):
+        def forward(self, hidden_states, residual):
+            return hidden_states + residual, None
+
+    model = object.__new__(Qwen3MoeLLMModel)
+    nn.Module.__init__(model)
+    model.layers = nn.ModuleList([SplitStateLayer(), SplitStateLayer()])
+    model.start_layer = 0
+    model.end_layer = 2
+    model.norm = Combine()
+    inputs = torch.ones(_TOKENS, _HIDDEN)
+
+    output_without_capture, _ = Qwen3MoeLLMModel.forward(
+        model,
+        input_ids=None,
+        positions=torch.arange(_TOKENS),
+        inputs_embeds=inputs,
+    )
+    output_with_capture, captured = Qwen3MoeLLMModel.forward(
+        model,
+        input_ids=None,
+        positions=torch.arange(_TOKENS),
+        inputs_embeds=inputs,
+        capture_layer_indices=[0, 1],
+        return_hidden_states=True,
+    )
+
+    layers = captured["hidden_states"]["layers"]
+    torch.testing.assert_close(layers[0], inputs)
+    torch.testing.assert_close(layers[1], torch.full_like(inputs, 3))
+    torch.testing.assert_close(output_with_capture, output_without_capture)
+    torch.testing.assert_close(output_with_capture, torch.full_like(inputs, 7))
+
+
 class _InnerModelStub:
     """Stands in for ``Qwen3MoeLLMModel``: always returns the internal 2-tuple."""
 
@@ -169,7 +216,7 @@ def test_make_omni_output_accepts_bare_tensor():
 
 def test_make_omni_output_accepts_capture_tuple():
     model = _make_combined(is_staged_run=True)
-    captured = {"hidden_states": {"layers": {}}}
+    captured: dict[str, dict[str, dict[int, torch.Tensor]]] = {"hidden_states": {"layers": {}}}
     out = model.make_omni_output((_hidden_states(), captured))
     assert isinstance(out, OmniOutput)
     assert out.multimodal_outputs == captured
diff --git a/tests/model_executor/models/qwen3_tts/test_code_predictor_dtype.py b/tests/model_executor/models/qwen3_tts/test_code_predictor_dtype.py
index 1998a4dd4..587993fca 100644
--- a/tests/model_executor/models/qwen3_tts/test_code_predictor_dtype.py
+++ b/tests/model_executor/models/qwen3_tts/test_code_predictor_dtype.py
@@ -682,6 +682,7 @@ class TestCodePredictorGraphReplay:
             return_proj_buf=False,
         )
         predictor._prefix_graphs_enabled = False
+        predictor._prefix_reprefill_enabled = False
         predictor._bucket_pos_ids = {1: torch.arange(4).unsqueeze(0)}
         graph = mocker.Mock()
         graph_output = torch.zeros(1, 4, 4)
@@ -1362,3 +1363,38 @@ class TestCodePredictorFusedProjections:
 
         with pytest.raises(RuntimeError, match="missing fused parameters"):
             model.load_weights(weights)
+
+
+class TestMTPExecutionBuckets:
+    """Outer MRv2 MTP graph buckets must align with the predictor bucket set."""
+
+    def test_configure_mtp_execution_buckets(self, mocker: MockerFixture, loaded_target_classes) -> None:
+        _ = loaded_target_classes
+        common_mod = sys.modules["vllm_omni.model_executor.models.common.qwen3_code_predictor"]
+        mocker.patch.object(common_mod.current_omni_platform, "is_npu", return_value=False)
+
+        cp_config, _ = _make_tiny_config(loaded_target_classes)
+        vllm_config = _make_vllm_config(mocker, max_num_seqs=4)
+        wrapper = common_mod.CodePredictorWrapper(
+            vllm_config=vllm_config,
+            cp_config=cp_config,
+            wrapper_config=common_mod.CodePredictorWrapperConfig(use_cuda_graphs=False),
+            talker_hidden_size=cp_config.hidden_size,
+        )
+
+        # Default keeps the legacy power-of-two derivation.
+        assert wrapper._execution_batch_buckets is None
+        assert wrapper._batch_bucket_sizes() == [1, 2, 4]
+
+        wrapper.configure_mtp_execution_buckets([3, 1, 3, 0, 9])
+        assert wrapper._batch_bucket_sizes() == [1, 3, 4]  # deduplicate/filter declaration and retain max
+
+        with pytest.raises(RuntimeError, match="before the first warmup"):
+            wrapper2 = common_mod.CodePredictorWrapper(
+                vllm_config=vllm_config,
+                cp_config=cp_config,
+                wrapper_config=common_mod.CodePredictorWrapperConfig(use_cuda_graphs=False),
+                talker_hidden_size=cp_config.hidden_size,
+            )
+            wrapper2._bucket_sizes = [1, 2, 4]  # stand-in for warmed-up state
+            wrapper2.configure_mtp_execution_buckets([3])
diff --git a/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py b/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py
index f3e8d0166..23eec9c8f 100644
--- a/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py
+++ b/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """
 Tests for CUDA Graph decoder wrapper numerical equivalence.
 
@@ -142,6 +142,28 @@ def test_padded_output_shape_and_length(decoder, wrapper, seq_len):
     assert graph_out.shape[-1] == expected_len
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_padded_batch_size_uses_larger_capture_bucket(decoder):
+    """Non-exact batch sizes should replay the next captured batch bucket."""
+    w = CUDAGraphDecoderWrapper(
+        decoder=decoder,
+        capture_sizes=[25],
+        capture_batch_sizes=[1, 4],
+        num_quantizers=NUM_QUANTIZERS,
+        enabled=True,
+    )
+    w.warmup(DEVICE)
+    codes = _random_codes(25, batch_size=3)
+
+    with torch.no_grad():
+        eager_out = decoder(codes)
+        graph_out = w.decode(codes)
+
+    assert (4, 25) in w.graphs
+    assert graph_out.shape == eager_out.shape
+    torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
+
+
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [10, 30, 47, 73, 99])
 def test_padded_interior_positions_close(decoder, wrapper, seq_len):
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_output_async_cuda.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_output_async_cuda.py
new file mode 100644
index 000000000..cd45288aa
--- /dev/null
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_output_async_cuda.py
@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Output metadata must not wait for the preceding model forward on CUDA."""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from tests.helpers.mark import hardware_test
+from vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_talker import (
+    Qwen3TTSTalkerForConditionalGeneration,
+)
+from vllm_omni.worker.gpu_ar_model_runner import _snapshot_tensor_payload_to_cpu_async
+
+pytestmark = [pytest.mark.core_model]
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("validity_device", ["cpu", "cuda"])
+@torch.inference_mode()
+def test_output_validity_preserves_values_without_waiting_for_forward(validity_device):
+    talker = Qwen3TTSTalkerForConditionalGeneration.__new__(Qwen3TTSTalkerForConditionalGeneration)
+    talker.vllm_config = SimpleNamespace(model_config=SimpleNamespace(async_chunk=True))
+    hidden = torch.zeros((3, 8), device="cuda")
+    infos = [
+        {
+            "codes": {"audio": torch.zeros((frames, 16), device="cuda", dtype=torch.long)},
+            "meta": {"codec_frame_valid": torch.tensor(valid, device=validity_device)},
+        }
+        for frames, valid in [(2, True), (1, False)]
+    ]
+    # Warm allocation paths before checking the stream-ordering contract.
+    talker.make_omni_output(hidden, model_intermediate_buffer=infos)
+    copy_stream = torch.cuda.Stream()
+    torch.accelerator.synchronize()
+
+    preceding_forward = torch.cuda.Event()
+    torch.cuda._sleep(500_000_000)
+    preceding_forward.record()
+    output = talker.make_omni_output(hidden, model_intermediate_buffer=infos)
+    waited_for_forward = preceding_forward.query()
+    validity = output.multimodal_outputs["meta"]["codec_frame_valid"]
+    snapshot = _snapshot_tensor_payload_to_cpu_async(
+        output.multimodal_outputs, copy_stream=copy_stream, pin_memory=True
+    )
+    snapshot.wait()
+
+    assert not waited_for_forward, "output construction synchronized the preceding forward"
+    assert validity.device.type == "cuda"
+    assert validity.dtype == torch.int8
+    cpu_validity = snapshot.payload["meta"]["codec_frame_valid"]
+    assert cpu_validity.device.type == "cpu"
+    assert cpu_validity.tolist() == [1, 1, 0]
+    assert all(info["meta"]["codec_frame_valid"].device.type == validity_device for info in infos)
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_stateless_capture.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_stateless_capture.py
new file mode 100644
index 000000000..8e4d5e094
--- /dev/null
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_stateless_capture.py
@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Exercise actual stateless decoder capture, not a mocked capture indicator."""
+
+import pytest
+import torch
+
+from tests.helpers.mark import hardware_marks
+from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz.configuration_qwen3_tts_tokenizer_v2 import (
+    Qwen3TTSTokenizerV2DecoderConfig,
+)
+from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz.modeling_qwen3_tts_tokenizer_v2 import (
+    Qwen3TTSTokenizerV2DecoderTransformerModel,
+)
+
+pytestmark = [pytest.mark.core_model, *hardware_marks(res={"cuda": "L4"}, num_cards=1)]
+
+
+@pytest.mark.parametrize("batch_size", [1, 2])
+@pytest.mark.parametrize("input_mode", ["implicit", "positions"])
+@torch.inference_mode()
+def test_stateless_decoder_capture_replays_new_inputs(batch_size, input_mode):
+    sequence_length = 8
+    torch.manual_seed(42)
+    config = Qwen3TTSTokenizerV2DecoderConfig(
+        hidden_size=32,
+        latent_dim=16,
+        max_position_embeddings=512,
+        num_attention_heads=4,
+        num_key_value_heads=4,
+        intermediate_size=64,
+        num_hidden_layers=1,
+        num_quantizers=2,
+        sliding_window=16,
+        decoder_dim=32,
+        upsample_rates=(2,),
+        upsampling_ratios=(2,),
+    )
+    config._attn_implementation = "sdpa"
+    model = Qwen3TTSTokenizerV2DecoderTransformerModel._from_config(config).cuda().eval()
+    inputs = torch.randn(batch_size, sequence_length, config.latent_dim, device="cuda")
+    positions = {}
+    if input_mode == "positions":
+        cache_position = torch.arange(sequence_length, device="cuda")
+        positions = {"cache_position": cache_position, "position_ids": cache_position.unsqueeze(0)}
+    stream = torch.cuda.Stream()
+    stream.wait_stream(torch.cuda.current_stream())
+    with torch.cuda.stream(stream):
+        for _ in range(3):
+            model(inputs_embeds=inputs, use_cache=False, **positions)
+    torch.cuda.current_stream().wait_stream(stream)
+    torch.accelerator.synchronize()
+
+    # No wrapper or eager fallback: an illegal capture must fail this test.
+    graph = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(graph):
+        captured_output = model(inputs_embeds=inputs, use_cache=False, **positions).last_hidden_state
+
+    outputs = []
+    for _ in range(3):
+        new_inputs = torch.randn_like(inputs)
+        expected = model(inputs_embeds=new_inputs, use_cache=False, **positions).last_hidden_state
+        if input_mode == "implicit":
+            # Compare the cached mask against the independent live-mask path,
+            # not only against eager execution using the same cached mask.
+            reference = model(
+                inputs_embeds=new_inputs,
+                use_cache=False,
+                position_ids=torch.arange(sequence_length, device="cuda").unsqueeze(0),
+            ).last_hidden_state
+            torch.testing.assert_close(expected, reference, atol=1e-5, rtol=1e-4)
+        inputs.copy_(new_inputs)
+        graph.replay()
+        torch.accelerator.synchronize()
+        torch.testing.assert_close(captured_output, expected, atol=1e-5, rtol=1e-4)
+        outputs.append(captured_output.clone())
+    assert not torch.equal(outputs[0], outputs[1]), "replay must consume the new input"
+
+
+@pytest.mark.parametrize("batch_size", [1, 2])
+@torch.inference_mode()
+def test_stateless_codec_wrapper_captures_and_replays_waveform(batch_size):
+    from tests.model_executor.models.qwen3_tts.test_qwen3_tts_incremental_decode import _make_small_decoder
+    from vllm_omni.model_executor.models.qwen3_tts.segmented_graph_wrapper import CUDAGraphDecoderWrapper
+
+    torch.manual_seed(42)
+    decoder = _make_small_decoder().cuda().eval()
+    wrapper = CUDAGraphDecoderWrapper(decoder, num_quantizers=2, async_chunk=False)
+    # Exercise the production capture method, including quantization and
+    # waveform convolutions, without accepting warmup's eager fallback.
+    wrapper._capture_stateless(batch_size, 8, torch.device("cuda"), torch.long)
+    state = wrapper.stateless_states[(batch_size, 8)]
+    for _ in range(3):
+        codes = torch.randint(0, 32, (batch_size, 2, 8), device="cuda")
+        expected = decoder._forward_exact(codes)
+        state["input"]["codes"].copy_(codes)
+        state["graph"].replay()
+        torch.accelerator.synchronize()
+        torch.testing.assert_close(state["output"], expected, atol=1e-5, rtol=1e-4)
+        assert torch.isfinite(state["output"]).all()
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py
index d176a1ff0..39e3fdce5 100644
--- a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py
@@ -1,5 +1,9 @@
-from collections import OrderedDict
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from collections import OrderedDict, UserDict
 from types import SimpleNamespace
+from typing import Any
 
 import numpy as np
 import pytest
@@ -36,6 +40,7 @@ def _make_minimal_talker(
     """
     model = Qwen3TTSTalkerForConditionalGeneration.__new__(Qwen3TTSTalkerForConditionalGeneration)
     model.talker_config = SimpleNamespace(codec_pad_id=7, num_code_groups=16)
+    model._codebook_vocab_size = 2048
     model._embedding_dtype = torch.bfloat16
     if tts_pad_embed is None:
         tts_pad_embed = torch.zeros((1, 4), dtype=torch.bfloat16)
@@ -51,6 +56,22 @@ def _make_minimal_talker(
     return model
 
 
+def test_postprocess_batch_gathers_each_request_tail():
+    from vllm_omni.model_executor.models.output_templates import OwnedBatchTensor
+
+    model = _make_minimal_talker()
+    hidden = torch.tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]])
+
+    key, values = model.postprocess_batch_mrv2(
+        hidden_states=hidden,
+        last_token_indices=torch.tensor([1, 3]),
+    )
+
+    assert key == ("hidden_states", "last")
+    assert isinstance(values, OwnedBatchTensor)  # freshly allocated rows transfer ownership
+    assert torch.equal(values.tensor, torch.tensor([[3.0, 4.0], [7.0, 8.0]]))
+
+
 def _make_minimal_builder(
     *,
     config: SimpleNamespace | None = None,
@@ -95,6 +116,7 @@ def _make_minimal_builder(
     )
     builder._speaker_cache = None
     builder._text_tokenizer = None
+    builder._projected_token_cache = {}
     builder._embedding_dtype = torch.bfloat16
     builder._ref_audio_artifact_cache_max_entries = 256
     builder._ref_audio_artifact_cache = OrderedDict()
@@ -259,6 +281,30 @@ def test_decode_compacts_long_trailing_text_after_large_offset():
     assert torch.equal(update["hidden_states"]["trailing_text"], trailing_text[65:])
 
 
+def test_decode_marks_codec_frame_validity_from_processed_input_token():
+    model = _make_minimal_talker()
+    model.embed_input_ids = lambda input_ids: input_ids.to(torch.float32).reshape(1, 1, 1).expand(1, 1, 4)
+    common = {
+        "input_embeds": None,
+        "text": ["hello"],
+        "task_type": ["CustomVoice"],
+        "hidden_states": {
+            "trailing_text": torch.ones((2, 4)),
+            "last": torch.ones(4),
+        },
+        "meta": {"talker_text_offset": 0},
+        "_omni_is_prefill": False,
+        "_omni_num_computed_tokens": 2,
+        "_omni_prompt_len": 2,
+    }
+
+    _, _, valid_update = model.preprocess(input_ids=torch.tensor([123]), **common)
+    _, _, eos_update = model.preprocess(input_ids=torch.tensor([4198]), **common)
+
+    assert valid_update["meta"]["codec_frame_valid"].item() is True
+    assert eos_update["meta"]["codec_frame_valid"].item() is False
+
+
 def test_decode_replay_span_embeds_all_tokens_without_mutating_decode_state():
     model = _make_minimal_talker()
 
@@ -286,14 +332,17 @@ def test_decode_replay_span_embeds_all_tokens_without_mutating_decode_state():
         out_embeds.cpu(),
         torch.tensor([[101.0] * 4, [202.0] * 4, [303.0] * 4], dtype=torch.bfloat16),
     )
-    assert update == {"meta": {"codec_streaming": True}}
+    assert update["meta"]["codec_streaming"] is True
+    assert update["meta"]["codec_frame_valid"].item() is False
 
 
-def test_decode_batch_preprocess_matches_decode_state_updates():
+@pytest.mark.parametrize("mrv2", [False, True])
+def test_decode_batch_preprocess_matches_decode_state_updates(mrv2):
     tts_pad = torch.full((1, 4), -1.0, dtype=torch.bfloat16)
     model = _make_minimal_talker(tts_pad_embed=tts_pad)
 
     def fake_embed_input_ids(input_ids):
+        assert not mrv2, "MRV2 must reuse the prepared token embeddings"
         return input_ids.to(torch.float32).reshape(-1, 1, 1).expand(-1, 1, 4)
 
     model.embed_input_ids = fake_embed_input_ids
@@ -302,7 +351,10 @@ def test_decode_batch_preprocess_matches_decode_state_updates():
     last_a = torch.full((4,), 2.0, dtype=torch.float32)
     last_b = torch.full((4,), 3.0, dtype=torch.float32)
 
-    out_ids, out_embeds, past_hidden, text_step, updates = model.preprocess_decode_batch(
+    preprocess = model.preprocess_decode_batch_mrv2 if mrv2 else model.preprocess_decode_batch
+    prepared = torch.tensor([[101.0] * 4, [202.0] * 4], dtype=torch.bfloat16)
+    out_ids, out_embeds, past_hidden, text_step, updates = preprocess(
+        **({"input_embeds": prepared} if mrv2 else {}),
         input_ids=torch.tensor([101, 202], dtype=torch.long),
         req_infos=[
             {
@@ -321,15 +373,19 @@ def test_decode_batch_preprocess_matches_decode_state_updates():
     )
 
     assert out_ids.tolist() == [101, 202]
+    if mrv2:
+        assert out_embeds.data_ptr() == prepared.data_ptr()
     assert torch.equal(out_embeds.cpu(), torch.tensor([[101.0] * 4, [202.0] * 4], dtype=torch.bfloat16))
     assert torch.equal(past_hidden.cpu(), torch.stack([last_a, last_b]).to(torch.bfloat16))
     assert torch.equal(text_step[0].cpu(), trailing_a[1].to(torch.bfloat16))
     assert torch.equal(text_step[1].cpu(), tts_pad.reshape(-1).to(torch.bfloat16))
     assert updates[0]["meta"]["talker_text_offset"] == 2
     assert updates[0]["meta"]["codec_streaming"] is True
+    assert updates[0]["meta"]["codec_frame_valid"].item() is True
     assert "hidden_states" not in updates[0]
     assert updates[1]["meta"]["talker_text_offset"] == 0
     assert updates[1]["meta"]["codec_streaming"] is False
+    assert updates[1]["meta"]["codec_frame_valid"].item() is True
     assert updates[1]["hidden_states"]["trailing_text"].numel() == 0
 
 
@@ -449,11 +505,11 @@ def test_base_voice_clone_batch_preprocess_encodes_ref_code_by_sample_rate():
 
         def __call__(self, texts, *, padding=False):
             self.calls.append((texts, padding))
-            return {"input_ids": [[idx + 1, idx + 2, idx + 3] for idx, _ in enumerate(texts)]}
+            return UserDict({"input_ids": [[1, 2, 3], [2, 3, 4, 5]]})
 
     text_tok = FakeTextTokenizer()
     builder._text_tokenizer = text_tok
-    buf = {
+    buf: dict[str, dict[str, Any]] = {
         "r1": {
             "task_type": ["Base"],
             "text": ["one"],
@@ -488,9 +544,17 @@ def test_base_voice_clone_batch_preprocess_encodes_ref_code_by_sample_rate():
     assert buf["r2"][NORMALIZED_REF_AUDIO_KEY][0] is wav2
     assert len(text_tok.calls) == 2
     assert torch.equal(buf["r1"][PRECOMPUTED_TEXT_IDS_KEY], torch.tensor([1, 2, 3]))
-    assert torch.equal(buf["r2"][PRECOMPUTED_TEXT_IDS_KEY], torch.tensor([2, 3, 4]))
+    assert torch.equal(buf["r2"][PRECOMPUTED_TEXT_IDS_KEY], torch.tensor([2, 3, 4, 5]))
     assert torch.equal(buf["r1"][PRECOMPUTED_REF_IDS_KEY], torch.tensor([1, 2, 3]))
-    assert torch.equal(buf["r2"][PRECOMPUTED_REF_IDS_KEY], torch.tensor([2, 3, 4]))
+    assert torch.equal(buf["r2"][PRECOMPUTED_REF_IDS_KEY], torch.tensor([2, 3, 4, 5]))
+    assert (
+        buf["r1"][PRECOMPUTED_TEXT_IDS_KEY].untyped_storage().data_ptr()
+        == buf["r2"][PRECOMPUTED_TEXT_IDS_KEY].untyped_storage().data_ptr()
+    )
+    assert (
+        buf["r1"][PRECOMPUTED_REF_IDS_KEY].untyped_storage().data_ptr()
+        == buf["r2"][PRECOMPUTED_REF_IDS_KEY].untyped_storage().data_ptr()
+    )
 
 
 def test_base_voice_clone_batch_preprocess_reuses_singleton_normalized_audio_without_speech_tokenizer():
@@ -506,7 +570,7 @@ def test_base_voice_clone_batch_preprocess_reuses_singleton_normalized_audio_wit
             return {"input_ids": [[7, 8, 9] for _ in texts]}
 
     builder._text_tokenizer = FakeTextTokenizer()
-    buf = {
+    buf: dict[str, dict[str, Any]] = {
         "r1": {
             "task_type": ["Base"],
             "text": ["one"],
@@ -539,7 +603,7 @@ def test_base_voice_clone_batch_preprocess_skips_after_initial_prefill_state_exi
     builder._encode_ref_audio_batch_fn = lambda *a, **kw: (_ for _ in ()).throw(
         AssertionError("speech tokenizer not expected")
     )
-    buf = {
+    buf: dict[str, dict[str, Any]] = {
         "r1": {
             "task_type": ["Base"],
             "text": ["one"],
@@ -574,7 +638,7 @@ def test_base_voice_clone_batch_preprocess_uses_serving_artifact_cache_key_witho
             return {"input_ids": [[7, 8, 9] for _ in texts]}
 
     builder._text_tokenizer = FakeTextTokenizer()
-    buf = {
+    buf: dict[str, dict[str, Any]] = {
         "r1": {
             "task_type": ["Base"],
             "text": ["one"],
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_ref_codes.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_ref_codes.py
index 3c145e4ca..b830aa835 100644
--- a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_ref_codes.py
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_ref_codes.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for cross-request ``codes.ref`` leakage (#4370).
 
 ``make_omni_output`` used to collapse every request's reference codec
@@ -11,11 +11,14 @@ vocoder chunks then decoded with another request's reference voice as
 context (audible onset timbre deformation at any concurrency > 1).
 """
 
+from types import SimpleNamespace
+
 import pytest
 import torch
 
 from vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_talker import (
     Qwen3TTSTalkerForConditionalGeneration,
+    _qwen3_tts_gpu_resident_buffer_keys,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -23,6 +26,18 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 _NUM_CODE_GROUPS = 16
 
 
+def test_large_tts_prefill_artifacts_stay_gpu_resident_only_on_mrv2() -> None:
+    v1_keys = _qwen3_tts_gpu_resident_buffer_keys(False)
+    v2_keys = _qwen3_tts_gpu_resident_buffer_keys(True)
+
+    assert ("embed", "prefill") not in v1_keys
+    assert ("codes", "ref") not in v1_keys
+    assert ("meta", "codec_frame_valid") not in v1_keys
+    assert ("embed", "prefill") in v2_keys
+    assert ("codes", "ref") in v2_keys
+    assert ("meta", "codec_frame_valid") in v2_keys
+
+
 def _make_talker() -> Qwen3TTSTalkerForConditionalGeneration:
     # make_omni_output reads no instance state, so skip __init__ (no real
     # config / checkpoint needed), same as the preprocess tests.
@@ -89,3 +104,42 @@ def test_make_omni_output_keeps_hidden_states_for_replay_spans_without_audio_cod
 
     assert torch.equal(out.text_hidden_states, hidden)
     assert out.multimodal_outputs["codes"]["audio"].shape == (1, _NUM_CODE_GROUPS)
+
+
+def test_make_omni_output_preserves_per_request_codec_frame_validity() -> None:
+    talker = _make_talker()
+    talker.vllm_config = SimpleNamespace(model_config=SimpleNamespace(async_chunk=True))
+    valid = _info(1, None)
+    invalid = _info(1, None)
+    valid["meta"]["codec_frame_valid"] = True
+    invalid["meta"]["codec_frame_valid"] = False
+
+    out = talker.make_omni_output(
+        torch.zeros((2, 8)),
+        model_intermediate_buffer=[valid, invalid],
+    )
+
+    assert out.multimodal_outputs["meta"]["codec_frame_valid"].tolist() == [1, 0]
+
+
+def test_make_omni_output_publishes_ref_once_for_kv_resumed_first_decode() -> None:
+    talker = _make_talker()
+    talker.vllm_config = SimpleNamespace(
+        model_config=SimpleNamespace(async_chunk=True),
+    )
+    ref_code = torch.ones((5, _NUM_CODE_GROUPS), dtype=torch.long)
+    info = _info(1, ref_code)
+    info["_omni_num_computed_tokens"] = 9
+    info["_omni_prompt_len"] = 5
+
+    first = talker.make_omni_output(
+        torch.zeros((1, 8)),
+        model_intermediate_buffer=[info],
+    )
+    second = talker.make_omni_output(
+        torch.zeros((1, 8)),
+        model_intermediate_buffer=[info],
+    )
+
+    assert first.multimodal_outputs["codes"]["ref"][0] is ref_code
+    assert "ref" not in second.multimodal_outputs["codes"]
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_silence_ban.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_silence_ban.py
index 3552c5356..3b58eb7d2 100644
--- a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_silence_ban.py
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_silence_ban.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for the Qwen3-TTS leading-silence ban (#4966, #5048).
 
 ``compute_logits`` suppresses the checkpoint-derived silence codec vocabulary
@@ -59,6 +59,7 @@ def _make_talker(*, ban_frames: int, logits: torch.Tensor, modes=None):
     object.__setattr__(talker, "_silence_mask", silence_mask)
     object.__setattr__(talker, "_codec_disallowed_mask", torch.zeros((_VOCAB,), dtype=torch.bool))
     object.__setattr__(talker, "_batch_req_ids", req_ids)
+    object.__setattr__(talker, "_mrv2_silence_ban_mask", None)
     object.__setattr__(
         talker,
         "_req_x_vector_only",
@@ -78,7 +79,26 @@ def _banned(row: torch.Tensor) -> set[int]:
     return {int(i) for i in torch.nonzero(torch.isinf(row) & (row < 0)).flatten()}
 
 
-# -------------------- the step gate --------------------
+def test_mrv2_silence_ban_tracks_batch_order_scope_and_decode_window() -> None:
+    talker = _make_talker(ban_frames=3, logits=torch.zeros((3, _VOCAB)), modes=[True, False, True])
+    with talker.mrv2_sampling_context(
+        req_ids=["req2", "req1", "req0"],
+        num_output_tokens=torch.tensor([3, 0, 1]),
+    ):
+        logits = talker.compute_logits(torch.zeros((3, 4)))
+
+    assert _banned(logits[0]) == set()
+    assert _banned(logits[1]) == set()
+    assert _banned(logits[2]) == set(_SILENCE_IDS)
+
+    # Prompt logprobs are computed after sampling and must remain unmasked.
+    assert not torch.isneginf(talker.compute_logits(torch.zeros((3, 4)))).any()
+
+    with talker.mrv2_sampling_context(
+        req_ids=["req2", "req1", "req0"],
+        num_output_tokens=torch.tensor([4, 1, 3]),
+    ):
+        assert not torch.isneginf(talker.compute_logits(torch.zeros((3, 4)))).any()
 
 
 def test_ban_disabled_leaves_logits_unchanged() -> None:
diff --git a/tests/model_executor/models/test_minimax_h3_encoder_payload.py b/tests/model_executor/models/test_minimax_h3_encoder_payload.py
index 4c9a7137b..110a0259a 100644
--- a/tests/model_executor/models/test_minimax_h3_encoder_payload.py
+++ b/tests/model_executor/models/test_minimax_h3_encoder_payload.py
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+import subprocess
 from contextlib import contextmanager
 from types import SimpleNamespace
 
@@ -9,15 +10,82 @@ import torch
 
 from vllm_omni.data_entry_keys import flatten_payload
 from vllm_omni.model_executor.models.minimax_h3.conditioning import (
+    MINIMAX_H3_ENCODER_LAYOUT_KEY,
+    STAGE_SCHEMA_VERSION,
     MiniMaxH3EncoderConditioning,
     MiniMaxH3EncoderMediaConditioning,
     MiniMaxH3EncoderMediaInput,
 )
+from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
+    _canonical_audio_edit_mask,
+    _canonical_video_edit_mask,
+)
 from vllm_omni.model_executor.stage_input_processors.minimax_h3 import encoder2diffusion
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+def test_edit_mask_boundary_canonicalizes_supported_request_shapes() -> None:
+    video_token = torch.arange(168, dtype=torch.float32).reshape(7, 4, 6) / 168
+    video_full = video_token.repeat_interleave(2, dim=1).repeat_interleave(2, dim=2)
+    video_kwargs = {"latent_t": 7, "latent_h": 8, "latent_w": 12}
+    for value in (video_token.flatten()[None, None], video_token[None], video_full[None]):
+        torch.testing.assert_close(_canonical_video_edit_mask(value, **video_kwargs), video_full)
+    torch.testing.assert_close(
+        _canonical_video_edit_mask(torch.tensor([[[0.25]]]), **video_kwargs),
+        torch.full((7, 8, 12), 0.25),
+    )
+
+    audio_temporal = torch.arange(37, dtype=torch.float32) / 37
+    audio_full = audio_temporal.repeat(2, 1)
+    for value in (audio_temporal[None, None], audio_full.flatten()[None], audio_full[None]):
+        torch.testing.assert_close(_canonical_audio_edit_mask(value, audio_t=37), audio_full)
+    torch.testing.assert_close(
+        _canonical_audio_edit_mask(torch.tensor([[[0.25]]]), audio_t=37),
+        torch.full((2, 37), 0.25),
+    )
+
+
+@pytest.mark.parametrize(
+    ("canonicalize", "value", "kwargs", "message"),
+    [
+        (_canonical_video_edit_mask, [True], {"latent_t": 7, "latent_h": 8, "latent_w": 12}, "booleans"),
+        (_canonical_audio_edit_mask, float("nan"), {"audio_t": 37}, "finite"),
+        (_canonical_audio_edit_mask, 10**400, {"audio_t": 37}, "finite"),
+        (_canonical_audio_edit_mask, 1.01, {"audio_t": 37}, r"\[0, 1\]"),
+        (_canonical_video_edit_mask, [0.0, 0.5], {"latent_t": 7, "latent_h": 8, "latent_w": 12}, "shape"),
+    ],
+)
+def test_edit_mask_boundary_rejects_invalid_values(canonicalize, value, kwargs, message) -> None:
+    from vllm_omni.errors import OmniClientError
+
+    with pytest.raises(OmniClientError, match=message):
+        canonicalize(value, **kwargs)
+
+
+def test_encoder_elides_all_generate_masks_but_requires_sources(monkeypatch) -> None:
+    from vllm_omni.errors import OmniClientError
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+
+    monkeypatch.setattr(processing, "resolve_minimax_h3_shape", lambda *_args: (64, 96, 22, 7, 37))
+    sampling = SimpleNamespace(extra_args={"task": "t2va"})
+    prepared = processing.prepare_encoder_inputs(
+        {
+            "prompt": "generate",
+            "multi_modal_data": {"video_noise_mask": 1.0, "audio_noise_mask": 1.0},
+        },
+        sampling,
+    )
+    assert prepared.media.video_edit is None
+    assert prepared.media.audio_edit is None
+
+    with pytest.raises(OmniClientError, match="video_noise_mask requires source_video"):
+        processing.prepare_encoder_inputs(
+            {"prompt": "edit", "multi_modal_data": {"video_noise_mask": 0.5}},
+            sampling,
+        )
+
+
 def test_pipeline_owns_three_encoders_then_dit_and_decoders() -> None:
     from vllm_omni.model_executor.models.minimax_h3.pipeline import MINIMAX_H3_PIPELINE
 
@@ -275,6 +343,43 @@ def test_prepare_encoder_inputs_keeps_reference_audio_budgets_separate(monkeypat
     assert prepared.condition_labels == [("audio", 1), ("video", 1), ("audio", 2)]
 
 
+@pytest.mark.parametrize(
+    ("source_key", "mask_key", "mask_shape", "decoder"),
+    [
+        ("source_video", "video_noise_mask", (7, 4, 6), "prepare_edit_video"),
+        ("source_audio", "audio_noise_mask", (37,), "load_audio_file"),
+        ("source_video", "audio_noise_mask", (37,), "load_video_audio"),
+    ],
+)
+def test_prepare_encoder_inputs_maps_corrupt_edit_media_to_client_error(
+    monkeypatch,
+    source_key,
+    mask_key,
+    mask_shape,
+    decoder,
+) -> None:
+    from vllm_omni.errors import OmniClientError
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+
+    def fail_decode(*_args, **_kwargs):
+        raise subprocess.CalledProcessError(1, ["ffmpeg"])
+
+    monkeypatch.setattr(processing, "resolve_minimax_h3_shape", lambda *_args: (64, 96, 22, 7, 37))
+    monkeypatch.setattr(processing, decoder, fail_decode)
+
+    with pytest.raises(OmniClientError, match=f"could not decode {source_key}"):
+        processing.prepare_encoder_inputs(
+            {
+                "prompt": "edit",
+                "multi_modal_data": {
+                    source_key: "corrupt.media",
+                    mask_key: torch.zeros(mask_shape),
+                },
+            },
+            SimpleNamespace(extra_args={"task": "t2va"}),
+        )
+
+
 @pytest.mark.parametrize(
     ("embedded_lengths", "standalone_lengths", "valid"),
     [((400,), (400,), True), ((320, 320), (400,), False), ((400,), (320, 320), False)],
@@ -339,7 +444,7 @@ def test_encode_media_keeps_audio_budgets_and_component_residency_separate(
     assert scopes == [video_vae, audio_vae]
 
 
-def test_encoder_output_reuses_encoder_handoff_and_round_trips() -> None:
+def test_encoder_output_reuses_encoder_handoff_and_round_trips(monkeypatch) -> None:
     expected = MiniMaxH3EncoderConditioning(
         hidden_states=torch.randn(3, 5120, dtype=torch.bfloat16),
         token_tags=torch.tensor([1, 0, 1], dtype=torch.int64),
@@ -349,8 +454,15 @@ def test_encoder_output_reuses_encoder_handoff_and_round_trips() -> None:
         num_frames=17,
         latent_t=5,
         audio_t=10,
+        video_edit_clean_rows=torch.zeros(5 * 8 * 14, 96),
+        video_edit_mask=torch.zeros(5, 16, 28),
     )
 
+    def fail_value_scan(*_args, **_kwargs):
+        raise AssertionError("wire must trust encoder-boundary value validation")
+
+    monkeypatch.setattr(torch, "isfinite", fail_value_scan)
+
     source = SimpleNamespace(
         finished=True,
         request_id="request-1",
@@ -366,8 +478,19 @@ def test_encoder_output_reuses_encoder_handoff_and_round_trips() -> None:
     assert result is not None
     payload = result["additional_information"]["encoder_output"]
     actual = MiniMaxH3EncoderConditioning.from_omni_payload(payload)
+    monkeypatch.undo()
     torch.testing.assert_close(actual.hidden_states, expected.hidden_states)
     torch.testing.assert_close(actual.token_tags, expected.token_tags)
+    torch.testing.assert_close(actual.video_edit_mask, expected.video_edit_mask)
+
+    layout = payload["kv_metadata"][MINIMAX_H3_ENCODER_LAYOUT_KEY]
+    assert int(layout[1]) == STAGE_SCHEMA_VERSION
+    legacy_layout = layout.clone()
+    legacy_layout[1] = STAGE_SCHEMA_VERSION - 1
+    payload["kv_metadata"][MINIMAX_H3_ENCODER_LAYOUT_KEY] = legacy_layout
+
+    with pytest.raises(ValueError, match=rf"unsupported MiniMax H3 encoder wire schema 1:{STAGE_SCHEMA_VERSION - 1}"):
+        MiniMaxH3EncoderConditioning.from_omni_payload(payload)
 
 
 def test_encoder_releases_workspace_after_cpu_payload(monkeypatch) -> None:
@@ -404,3 +527,65 @@ def test_encoder_releases_workspace_after_cpu_payload(monkeypatch) -> None:
     assert empty_cache_calls == 1
     assert output.multimodal_outputs is not None
     assert output.multimodal_outputs["embed"]["embedding"][0].device.type == "cpu"
+
+
+def test_driving_audio_is_not_a_short_reference_and_survives_stage_transport():
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+
+    sampling = OmniDiffusionSamplingParams(
+        width=64,
+        height=64,
+        fps=24,
+        extra_args={
+            "aspect_ratio": "1:1",
+            "duration": 20,
+            "long_video": True,
+            "audio_mode": "lock_source",
+        },
+    )
+    prepared = processing.prepare_encoder_inputs(
+        {"prompt": "A singer", "multi_modal_data": {"audio": (torch.zeros(75 * 800), 800)}}, sampling
+    )
+    media = MiniMaxH3EncoderMediaInput.from_mm_tensors(prepared.media.to_mm_tensors(), prepared.media.to_metadata())
+    assert media.task == "t2va"
+    assert media.audio_mode == "lock_source"
+    assert prepared.condition_labels == []
+
+    class FakeAudioVAE:
+        def encode_waveform(self, waveform: torch.Tensor, sample_rate: int) -> tuple[torch.Tensor, int]:
+            return torch.ones(6000, 32), 3000
+
+    audio_vae = FakeAudioVAE()
+    conditioning = processing.encode_media(media, video_vae=None, audio_vae=audio_vae, emit_conditioning=True)
+    assert conditioning.audio_condition_lengths == (3000,)
+    assert conditioning.ref_blocks == ()
+
+
+def test_driving_audio_does_not_override_fl2va_task_inference():
+    from PIL import Image
+
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+
+    sampling = OmniDiffusionSamplingParams(
+        width=64,
+        height=64,
+        fps=24,
+        num_frames=124,
+        extra_args={"audio_mode": "lock_source"},
+    )
+    prepared = processing.prepare_encoder_inputs(
+        {
+            "prompt": "A singer",
+            "multi_modal_data": {
+                "image": Image.new("RGB", (256, 256)),
+                "audio": (torch.zeros(5 * 800), 800),
+            },
+        },
+        sampling,
+    )
+
+    assert prepared.media.task == "fl2va"
+    assert prepared.media.audio_mode == "lock_source"
+    assert prepared.condition_labels == [("image", 1)]
diff --git a/tests/model_executor/models/voxcpm2/test_request_seed_cfm_noise.py b/tests/model_executor/models/voxcpm2/test_request_seed_cfm_noise.py
new file mode 100644
index 000000000..df49667f8
--- /dev/null
+++ b/tests/model_executor/models/voxcpm2/test_request_seed_cfm_noise.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Request-level seeds must control the VoxCPM2 CFM noise stream (#7658).
+
+``/v1/audio/speech`` folds ``request.seed`` into ``SamplingParams.seed``, which
+reaches vLLM's sampler but never the CFM (flow-matching) noise draws: every
+noise site used the global RNG, so identical text + seed returned different
+audio. A seeded request now carries a dedicated ``torch.Generator`` in its
+``_RequestState``; these tests pin the noise semantics without instantiating
+the full model.
+"""
+
+from __future__ import annotations
+
+import functools
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+torch = pytest.importorskip("torch")
+
+
+@functools.lru_cache(maxsize=1)
+def _talker_cls():
+    """Defer talker import (pulls vLLM model_executor) until first use."""
+    from vllm_omni.model_executor.models.voxcpm2.voxcpm2_talker import (
+        VoxCPM2TalkerForConditionalGeneration,
+    )
+
+    return VoxCPM2TalkerForConditionalGeneration
+
+
+def _make_talker(deterministic_cfm_noise: bool = False):
+    cls = _talker_cls()
+    talker = cls.__new__(cls)
+    talker._deterministic_cfm_noise = deterministic_cfm_noise
+    return talker
+
+
+def _make_state(request_id: str = "req-1", seed: int | None = 42):
+    from vllm_omni.model_executor.models.voxcpm2.voxcpm2_talker import _RequestState
+
+    state = _RequestState(request_id=request_id)
+    if seed is not None:
+        state.cfm_generator = torch.Generator(device="cpu")
+        state.cfm_generator.manual_seed(seed)
+    return state
+
+
+def test_seeded_noise_is_deterministic_across_requests():
+    talker = _make_talker()
+
+    a1 = torch.empty(1, 128, 5)
+    a2 = torch.empty(1, 128, 5)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(seed=7), a1)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(seed=7), a2)
+
+    assert torch.equal(a1, a2)
+
+
+def test_seed_value_changes_the_noise_stream():
+    talker = _make_talker()
+
+    a = torch.empty(1, 128, 5)
+    b = torch.empty(1, 128, 5)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(seed=7), a)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(seed=8), b)
+
+    assert not torch.equal(a, b)
+
+
+def test_seeded_noise_advances_with_each_draw():
+    talker = _make_talker()
+    state = _make_state(seed=7)
+
+    first = torch.empty(1, 128, 5)
+    second = torch.empty(1, 128, 5)
+    talker._fill_deterministic_cfm_noise_for_state(state, first)
+    talker._fill_deterministic_cfm_noise_for_state(state, second)
+
+    assert not torch.equal(first, second)
+
+
+def test_seeded_noise_is_batch_position_independent():
+    """A seeded row draws the same bytes whether it sits alone or mid-batch."""
+    talker = _make_talker()
+
+    solo = torch.empty(1, 128, 5)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(seed=7), solo)
+
+    batch = torch.empty(3, 128, 5)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(seed=7), batch[1:2])
+
+    assert torch.equal(solo, batch[1:2])
+
+
+def test_has_deterministic_noise_prefers_request_seed_over_flag():
+    unflagged = _make_talker(deterministic_cfm_noise=False)
+    assert unflagged._has_deterministic_cfm_noise(_make_state(seed=1))
+    assert not unflagged._has_deterministic_cfm_noise(_make_state(seed=None))
+
+    flagged = _make_talker(deterministic_cfm_noise=True)
+    assert flagged._has_deterministic_cfm_noise(_make_state(seed=None))
+
+
+def test_request_seed_wins_over_replay_hash():
+    """The per-request generator keys noise off the seed, not the request id."""
+    talker = _make_talker(deterministic_cfm_noise=True)
+
+    r1 = torch.empty(1, 128, 5)
+    r2 = torch.empty(1, 128, 5)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(request_id="111", seed=7), r1)
+    talker._fill_deterministic_cfm_noise_for_state(_make_state(request_id="222", seed=7), r2)
+
+    assert torch.equal(r1, r2)
diff --git a/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py b/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py
index 0007f021a..0c2d9ee67 100644
--- a/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py
+++ b/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py
@@ -74,7 +74,9 @@ def test_ar_runner_without_model_hook_stays_on_normal_path():
     assert "exceptException" not in compact_request_source
 
     set_context_source = source[source.index("def _set_runner_assisted_full_attention_metadata_context") :]
-    set_context_source = set_context_source[: set_context_source.index("def _deferred_prefix_cache_mm_keys")]
+    set_context_source = set_context_source[
+        : set_context_source.index("def _prepare_prefix_cache_pooler_payload_sources")
+    ]
     assert "except Exception" not in set_context_source
 
 
diff --git a/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py b/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py
index e0b52d1aa..0ad8b5df9 100644
--- a/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py
+++ b/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for VoxCPM2 talker per-request state lifecycle."""
 
 from __future__ import annotations
@@ -72,6 +72,99 @@ def _seed_cached_decode(talker, req_id: str):
 
 
 class TestStateEvictionContract:
+    def test_eager_optimizations_do_not_require_torch_inductor(self, monkeypatch) -> None:
+        from vllm_omni.model_executor.models.voxcpm2 import voxcpm2_talker as tk
+
+        class FakeEstimator:
+            pass
+
+        class FakeFeatDecoder:
+            def __init__(self, estimator) -> None:
+                self.estimator = estimator
+                self.mean_mode = False
+
+        class FakeTTS:
+            def __init__(self, estimator) -> None:
+                self.feat_decoder = FakeFeatDecoder(estimator)
+
+        talker = _make_bare_talker()
+        estimator = FakeEstimator()
+        talker._tts = FakeTTS(estimator)
+        _, _, RuntimeConfig = _voxcpm2_talker_mod()
+        talker._runtime_config = RuntimeConfig()
+        talker._enable_torch_compile = False
+
+        applied: list[str] = []
+
+        def install_qkv(*_args, **_kwargs) -> int:
+            applied.append("qkv")
+            return 12
+
+        def install_mlp(*_args, **_kwargs) -> int:
+            applied.append("mlp")
+            return 12
+
+        def install_zero_dt(*_args, **_kwargs) -> bool:
+            applied.append("zero_dt")
+            return True
+
+        monkeypatch.setattr(
+            tk,
+            "_install_locdit_fused_qkv",
+            install_qkv,
+        )
+        monkeypatch.setattr(
+            tk,
+            "_install_locdit_fused_mlp",
+            install_mlp,
+        )
+        monkeypatch.setattr(
+            tk,
+            "_install_locdit_zero_dt_cache",
+            install_zero_dt,
+        )
+
+        talker._setup_execution_optimizations()
+
+        assert applied == ["qkv", "mlp", "zero_dt"]
+        assert talker._eager_optimizations_applied is True
+        assert not hasattr(estimator, "_compiled")
+
+    def test_profiler_drops_invalid_accelerator_graph_events(self, monkeypatch) -> None:
+        from vllm_omni.model_executor.models.voxcpm2 import voxcpm2_talker as tk
+
+        timer = tk._PerfTimer(enabled=False)
+        timer._enabled = True
+
+        class InvalidEvent:
+            def elapsed_time(self, _end) -> float:
+                raise RuntimeError("event recorder null")
+
+        timer._pairs.append(("captured", InvalidEvent(), object()))
+        monkeypatch.setattr(torch.accelerator, "synchronize", lambda: None)
+
+        assert timer.breakdown() == ""
+        assert timer._pairs == []
+
+    def test_profiler_disables_device_without_timing_events(self, monkeypatch) -> None:
+        from vllm_omni.model_executor.models.voxcpm2 import voxcpm2_talker as tk
+
+        class DeviceWithoutEvents:
+            pass
+
+        monkeypatch.setattr(
+            torch,
+            "get_device_module",
+            lambda _device: DeviceWithoutEvents(),
+        )
+
+        timer = tk._PerfTimer(enabled=True)
+        timer.start("cpu")
+
+        assert timer._enabled is False
+        assert timer._device_module is None
+        assert timer._starts == {}
+
     def test_runtime_config_normalizes_mutually_exclusive_paths(self) -> None:
         _, _, RuntimeConfig = _voxcpm2_talker_mod()
 
@@ -295,6 +388,7 @@ class TestChunkedPrefillContract:
         talker._get_multichar_zh_split = lambda: {}
         talker._perf = _NoopPerf()
         talker._enable_torch_compile = False
+        talker._setup_execution_optimizations = lambda: None
         talker._setup_cfm_buffers = lambda: None
         talker._run_cfm_for_state = lambda *_args: torch.ones(1, 1, 4)
 
diff --git a/tests/model_executor/stage_input_processors/test_mammoth_moda2.py b/tests/model_executor/stage_input_processors/test_mammoth_moda2.py
index 992908c36..c404b6d58 100644
--- a/tests/model_executor/stage_input_processors/test_mammoth_moda2.py
+++ b/tests/model_executor/stage_input_processors/test_mammoth_moda2.py
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""CPU regression tests for MammothModa2's completed-AR to DiT bridge."""
+"""CPU regressions for MammothModa2's completed-AR to diffusion bridge."""
 
-from types import SimpleNamespace
+from dataclasses import dataclass
 
 import pytest
 import torch
@@ -16,90 +16,129 @@ from vllm_omni.engine.serialization import (
 )
 from vllm_omni.engine.stage_engine_core_client import StageEngineCoreClient
 from vllm_omni.model_executor.models.mammoth_moda2.pipeline import MAMMOTH_MODA2_PIPELINE
-from vllm_omni.model_executor.stage_input_processors.mammoth_moda2 import ar2dit
+from vllm_omni.model_executor.stage_input_processors.mammoth_moda2 import ar2diffusion
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
-_PROMPT_TOKEN_IDS = [7, 8, 9]
-_GENERATED_TOKEN_IDS = [101, 102, 103]
+@dataclass
+class _CompletionOutputStub:
+    cumulative_token_ids: list[int]
+    multimodal_output: dict[str, torch.Tensor]
 
 
-def _hidden_states(rows: int = 5, dtype: torch.dtype = torch.bfloat16) -> torch.Tensor:
-    return torch.arange(rows * 4, dtype=dtype).reshape(rows, 4)
+@dataclass
+class _AROutputStub:
+    request_id: str
+    prompt_token_ids: list[int]
+    outputs: list[_CompletionOutputStub]
 
 
-def _ar_output(hidden_states: torch.Tensor | None = None) -> SimpleNamespace:
-    multimodal_output = {} if hidden_states is None else {"latent": hidden_states}
-    return SimpleNamespace(
-        request_id="mammoth-request",
-        prompt_token_ids=list(_PROMPT_TOKEN_IDS),
-        outputs=[
-            SimpleNamespace(
-                cumulative_token_ids=list(_GENERATED_TOKEN_IDS),
-                multimodal_output=multimodal_output,
-            )
-        ],
+@dataclass
+class _TextConfigStub:
+    gen_vocab_start_index: int
+
+
+@dataclass
+class _MammothConfigStub:
+    llm_config: _TextConfigStub
+    image_token_id: int
+    video_token_id: int
+    vision_start_token_id: int
+    vision_end_token_id: int
+
+
+def _source_output(*, include_latent: bool = True) -> _AROutputStub:
+    multimodal_output = {"latent": torch.arange(32, dtype=torch.float32).reshape(4, 8)} if include_latent else {}
+    completion = _CompletionOutputStub(
+        cumulative_token_ids=[100, 101, 102],
+        multimodal_output=multimodal_output,
+    )
+    return _AROutputStub(
+        request_id="req-7",
+        prompt_token_ids=[10, 11],
+        outputs=[completion],
     )
 
 
-def _prompt(
-    *,
-    target_h: int | None = None,
-    target_w: int | None = None,
-) -> dict[str, object]:
-    mm_processor_kwargs: dict[str, int] = {}
-    if target_h is not None:
-        mm_processor_kwargs["target_h"] = target_h
-    if target_w is not None:
-        mm_processor_kwargs["target_w"] = target_w
-    return {
-        "additional_information": {
-            "image_height": [384],
-            "image_width": [640],
-            "text_guidance_scale": [4.5],
-            "cfg_range": [0.1, 0.9],
-            "num_inference_steps": [20],
+def test_ar2diffusion_builds_one_prompt_with_raw_ar_conditions() -> None:
+    result = ar2diffusion(
+        [_source_output()],
+        {"prompt": "a cat", "mm_processor_kwargs": {"target_h": 512, "target_w": 768}},
+    )
+    assert not isinstance(result, list)
+    assert result["prompt"] == ""
+    assert result["height"] == 512
+    assert result["width"] == 768
+    info = result["additional_information"]
+    assert info["full_token_ids"] == [10, 11, 100, 101]
+    assert info["answer_start_index"] == 2
+    torch.testing.assert_close(
+        info["full_hidden_states"],
+        torch.arange(32, dtype=torch.float32).reshape(4, 8),
+    )
+    assert info["full_hidden_states"].is_contiguous()
+
+
+def test_ar2diffusion_uses_prompt_dimension_fallbacks() -> None:
+    result = ar2diffusion(
+        [_source_output()],
+        {"additional_information": {"image_height": [256], "image_width": [384]}},
+    )
+    assert (result["height"], result["width"]) == (256, 384)
+
+
+def test_ar2diffusion_preserves_request_level_sampling_fallbacks() -> None:
+    result = ar2diffusion(
+        [_source_output()],
+        {
+            "additional_information": {
+                "text_guidance_scale": [1.5],
+                "num_inference_steps": [3],
+                "cfg_range": [0.25, 0.75],
+            }
         },
-        "mm_processor_kwargs": mm_processor_kwargs,
-    }
+    )
+
+    info = result["additional_information"]
+    assert info["text_guidance_scale"] == [1.5]
+    assert info["num_inference_steps"] == [3]
+    assert info["cfg_range"] == [0.25, 0.75]
 
 
-def _assert_complete_dit_input(dit_inputs: list[dict[str, object]], hidden_states: torch.Tensor) -> None:
-    assert len(dit_inputs) == 1
-    dit_input = dit_inputs[0]
-    assert dit_input["prompt_token_ids"] == [0]
-
-    additional_information = dit_input["additional_information"]
-    assert isinstance(additional_information, dict)
-    full_hidden_states = additional_information["full_hidden_states"]
-    assert isinstance(full_hidden_states, torch.Tensor)
-    assert full_hidden_states.dtype == torch.bfloat16
-    assert full_hidden_states.is_contiguous()
-    assert torch.equal(full_hidden_states, hidden_states)
-    assert additional_information["full_token_ids"] == [7, 8, 9, 101, 102]
-    assert additional_information["answer_start_index"] == [3]
-    assert additional_information["image_height"] == [384]
-    assert additional_information["image_width"] == [640]
-    assert additional_information["text_guidance_scale"] == [4.5]
-    assert additional_information["cfg_range"] == [0.1, 0.9]
-    assert additional_information["num_inference_steps"] == [20]
+def test_ar2diffusion_unwraps_the_orchestrator_prompt_list() -> None:
+    result = ar2diffusion(
+        [_source_output()],
+        [{"mm_processor_kwargs": {"target_h": 640, "target_w": 960}}],
+    )
+    assert (result["height"], result["width"]) == (640, 960)
 
 
-def test_ar2dit_builds_one_complete_dit_input() -> None:
-    hidden_states = _hidden_states()
+def test_ar2diffusion_rejects_multiple_source_requests() -> None:
+    with pytest.raises(ValueError, match="exactly one AR output"):
+        ar2diffusion([_source_output(), _source_output()], {})
 
-    dit_inputs = ar2dit([_ar_output(hidden_states)], _prompt())
 
-    _assert_complete_dit_input(dit_inputs, hidden_states)
+def test_ar2diffusion_reports_missing_latent_with_request_id() -> None:
+    with pytest.raises(ValueError, match="req-7"):
+        ar2diffusion([_source_output(include_latent=False)], {})
+
+
+def test_ar2diffusion_rejects_hidden_state_length_mismatch() -> None:
+    source = _source_output()
+    source.outputs[0].multimodal_output["latent"] = torch.zeros(3, 8)
+    with pytest.raises(ValueError, match="Hidden states length mismatch"):
+        ar2diffusion([source], {})
 
 
 @pytest.mark.parametrize("dtype", (torch.float16, torch.bfloat16))
-def test_ar2dit_preserves_low_precision_through_engine_core_payload(dtype: torch.dtype) -> None:
-    hidden_states = _hidden_states(dtype=dtype)
-    dit_input = ar2dit([_ar_output(hidden_states)], _prompt())[0]
+def test_ar2diffusion_preserves_low_precision_through_engine_core_payload(dtype: torch.dtype) -> None:
+    source = _source_output()
+    hidden_states = torch.arange(32, dtype=dtype).reshape(4, 8)
+    source.outputs[0].multimodal_output["latent"] = hidden_states
+    diffusion_input = ar2diffusion([source], {})
 
-    wire_payload = serialize_additional_information(dit_input["additional_information"])
+    wire_payload = serialize_additional_information(diffusion_input["additional_information"])
     assert wire_payload is not None
     restored = deserialize_additional_information(wire_payload)
     restored_hidden_states = restored["full_hidden_states"]
@@ -112,21 +151,19 @@ def test_ar2dit_preserves_low_precision_through_engine_core_payload(dtype: torch
 
 @pytest.mark.parametrize("dtype", (torch.float16, torch.bfloat16))
 def test_dit_condition_split_preserves_compact_transfer_dtype(dtype: torch.dtype) -> None:
-    # Construct only the config read by _split_ar_conditions.  This keeps the
-    # test CPU-only and avoids loading the DiT/VAE weights.
     pipeline = object.__new__(MammothModa2DiTPipeline)
     object.__setattr__(
         pipeline,
         "config",
-        SimpleNamespace(
-            llm_config=SimpleNamespace(gen_vocab_start_index=100),
+        _MammothConfigStub(
+            llm_config=_TextConfigStub(gen_vocab_start_index=100),
             image_token_id=20,
             video_token_id=21,
             vision_start_token_id=22,
             vision_end_token_id=23,
         ),
     )
-    hidden_states = _hidden_states(dtype=dtype)
+    hidden_states = torch.arange(20, dtype=dtype).reshape(5, 4)
 
     text_cond, image_cond = pipeline._split_ar_conditions(
         full_hidden_states=hidden_states,
@@ -142,44 +179,29 @@ def test_dit_condition_split_preserves_compact_transfer_dtype(dtype: torch.dtype
     assert torch.equal(image_cond, hidden_states[[3, 4]])
 
 
-def test_ar2dit_prefers_processor_image_dimensions() -> None:
-    hidden_states = _hidden_states()
-
-    dit_inputs = ar2dit([_ar_output(hidden_states)], _prompt(target_h=512, target_w=768))
-
-    additional_information = dit_inputs[0]["additional_information"]
-    assert additional_information["image_height"] == [512]
-    assert additional_information["image_width"] == [768]
-
-
-def test_ar2dit_rejects_missing_latent_output() -> None:
-    with pytest.raises(ValueError, match="missing latent multimodal output"):
-        ar2dit([_ar_output()], _prompt())
-
-
-def test_ar2dit_rejects_hidden_token_row_mismatch() -> None:
-    with pytest.raises(AssertionError, match="Hidden states length mismatch"):
-        ar2dit([_ar_output(_hidden_states(rows=4))], _prompt())
-
-
 def test_mammoth_pipeline_uses_standard_completed_ar_forwarding() -> None:
     stage0, stage1 = MAMMOTH_MODA2_PIPELINE.stages
 
     assert stage0.custom_process_next_stage_input_func is None
-    assert stage1.custom_process_input_func.endswith(".ar2dit")
+    assert stage1.custom_process_input_func.endswith(".ar2diffusion")
     assert stage1.sync_process_input_func is None
     assert stage1.requires_full_payload_input is False
 
 
 def test_stage_client_forwards_completed_ar_output_to_mammoth_adapter() -> None:
-    hidden_states = _hidden_states()
+    source = _source_output()
     client = object.__new__(StageEngineCoreClient)
-    client.custom_process_input_func = ar2dit
+    client.custom_process_input_func = ar2diffusion
     client.requires_multimodal_data = False
 
-    dit_inputs = client.process_engine_inputs(
-        [_ar_output(hidden_states)],
-        _prompt(),
+    diffusion_input = client.process_engine_inputs(
+        [source],
+        {"mm_processor_kwargs": {"target_h": 512, "target_w": 768}},
     )
 
-    _assert_complete_dit_input(dit_inputs, hidden_states)
+    assert diffusion_input["height"] == 512
+    assert diffusion_input["width"] == 768
+    info = diffusion_input["additional_information"]
+    assert info["full_token_ids"] == [10, 11, 100, 101]
+    assert info["answer_start_index"] == 2
+    assert torch.equal(info["full_hidden_states"], source.outputs[0].multimodal_output["latent"])
diff --git a/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py b/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py
index c1a6041c7..208cc72c6 100644
--- a/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py
+++ b/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for Qwen3-Omni streaming thinker→talker / talker→codec helpers (PR #2581)."""
 
 from __future__ import annotations
@@ -356,7 +356,7 @@ def test_accumulator_concat_default_when_no_replace_keys() -> None:
     class _StubMixin(OmniConnectorModelRunnerMixin):
         def __init__(self):
             self._pending_full_payload_send = {}
-            self._full_payload_replace_keys_cached = frozenset()
+            self._full_payload_replace_keys_cached: frozenset[str] = frozenset()
 
     stub = _StubMixin()
     stub.accumulate_full_payload_output(
@@ -415,51 +415,6 @@ def test_covo_audio_llm2code2wav_full_payload_smoke() -> None:
     assert payload["meta"]["finished"].item() is True
 
 
-def test_dynin_omni_token_only_smoke() -> None:
-    """Smoke: dynin_omni token-only builders return placeholders."""
-    from vllm_omni.model_executor.stage_input_processors.dynin_omni import (
-        token2text_to_token2image_token_only,
-    )
-
-    class _Out:
-        def __init__(self, tids, mm=None):
-            self.token_ids = tids
-            self.multimodal_output = mm
-
-    class _Wrapper:
-        def __init__(self, tids, mm=None):
-            self.outputs = [_Out(tids, mm)]
-            self.request_id = "r0"
-
-    class _Stage:
-        def __init__(self, outs):
-            self.engine_outputs = outs
-
-    src = [_Wrapper([10, 11, 12])]
-    out = token2text_to_token2image_token_only([_Stage(src)], [0])
-    assert len(out) == 1
-    assert len(out[0]["prompt_token_ids"]) == 3
-    assert out[0]["additional_information"] is None
-
-
-def test_dynin_omni_full_payload_smoke() -> None:
-    """Smoke: dynin_omni producer-side payload builder returns nested OmniPayload + carries metadata."""
-    from types import SimpleNamespace
-
-    from vllm_omni.model_executor.stage_input_processors.dynin_omni import (
-        token2text_to_token2image_full_payload,
-    )
-
-    pooling = {"token_ids": [1, 2, 3]}
-    req = SimpleNamespace(output_token_ids=[], additional_information={"speaker": ["alice"]})
-    payload = token2text_to_token2image_full_payload(None, pooling, req)
-    assert payload is not None
-    assert payload["codes"]["audio"] == [1, 2, 3]
-    assert payload["meta"]["finished"].item() is True
-    # additional_information is normalized + carried forward (speaker stays list-wrapped).
-    assert payload.get("speaker") == ["alice"]
-
-
 def test_qwen2_5_omni_talker2code2wav_token_only_smoke() -> None:
     """Smoke: qwen2_5_omni talker→code2wav token_only marker + boundary strip."""
     from vllm_omni.model_executor.stage_input_processors.qwen2_5_omni import (
diff --git a/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py b/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py
index 4b542bf77..f929e41c9 100644
--- a/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py
+++ b/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py
@@ -7,6 +7,9 @@ from types import SimpleNamespace
 import pytest
 import torch
 
+from vllm_omni.model_executor.stage_input_processors import (
+    qwen3_tts as qwen3_tts_processors,
+)
 from vllm_omni.model_executor.stage_input_processors.chunk_size_utils import (
     AdaptiveChunkController,
     compute_adaptive_emit,
@@ -32,7 +35,52 @@ _FRAME = [1, 2, 3, 4]
 _Q = len(_FRAME)
 
 
-def _req(rid, *, finished, initial_codec_chunk_frames=None, non_streaming_mode=None, full_utterance_decode=None):
+@pytest.mark.parametrize("frames", [1, 26])
+def test_terminal_without_new_frames_does_not_replay_last_chunk(frames):
+    tm = _tm(initial_chunk_frames=1)
+    emitted = 0
+    for count in range(1, frames + 1):
+        payload = _call(tm, "r", n_frames=count)
+        if payload is not None:
+            emitted += payload.codes.audio.numel() // _Q
+            tm.put_req_chunk["r"] += 1
+    terminal = _call(tm, "r", n_frames=frames, finished=True)
+    assert terminal is not None and terminal.meta.finished.item()
+    assert terminal.codes.audio.numel() == 0
+    assert emitted == frames
+
+
+def test_repeated_nonterminal_callback_does_not_republish_boundary():
+    tm = _tm(initial_chunk_frames=1)
+    first = _call(tm, "r", n_frames=1)
+    assert first is not None
+    tm.put_req_chunk["r"] += 1
+    assert _call(tm, "r", n_frames=1) is None
+    next_chunk = _call(tm, "r", n_frames=26)
+    assert next_chunk.codes.audio.numel() // _Q == 25
+
+
+def test_terminal_flush_contains_only_frames_not_previously_emitted():
+    tm = _tm(initial_chunk_frames=1)
+    _call(tm, "r", n_frames=1)
+    tm.put_req_chunk["r"] += 1
+    _call(tm, "r", n_frames=26)
+    tm.put_req_chunk["r"] += 1
+    final = _call(tm, "r", n_frames=30, finished=True)
+    assert final.codes.audio.numel() // _Q == 4
+    tm.put_req_chunk["r"] += 1
+    assert _call(tm, "r", n_frames=30, finished=True).codes.audio.numel() == 0
+
+
+def _req(
+    rid,
+    *,
+    finished,
+    initial_codec_chunk_frames=None,
+    non_streaming_mode=None,
+    full_utterance_decode=None,
+    output_token_ids=None,
+):
     entries = {}
     if initial_codec_chunk_frames is not None:
         entries["initial_codec_chunk_frames"] = SimpleNamespace(list_data=[initial_codec_chunk_frames])
@@ -40,11 +88,11 @@ def _req(rid, *, finished, initial_codec_chunk_frames=None, non_streaming_mode=N
         entries["non_streaming_mode"] = SimpleNamespace(list_data=[non_streaming_mode])
     if full_utterance_decode is not None:
         entries["full_utterance_decode"] = SimpleNamespace(list_data=[full_utterance_decode])
-    ai = SimpleNamespace(entries=entries) if entries else None
     return SimpleNamespace(
         external_req_id=rid,
         is_finished=lambda: finished,
-        additional_information=ai,
+        additional_information=SimpleNamespace(entries=entries) if entries else None,
+        output_token_ids=output_token_ids or [],
     )
 
 
@@ -206,6 +254,112 @@ def test_voicedesign_prompt_mode_with_streaming_keeps_windowed_emit():
     assert len(p.codes.audio) == _Q * 25
 
 
+def test_async_chunk_skips_stop_token_zero_frame_without_gpu_value_check():
+    tm = _tm()
+    rid = "r-stop"
+    tm.code_prompt_token_ids[rid] = [_FRAME[:]]
+
+    payload = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output={"codes": {"audio": torch.zeros((1, _Q), dtype=torch.long)}},
+        request=_req(rid, finished=True, initial_codec_chunk_frames=2, output_token_ids=[2150]),
+        is_finished=True,
+    )
+
+    assert payload is not None
+    assert payload.codes.audio.tolist() == _FRAME
+    assert len(tm.code_prompt_token_ids[rid]) == 1
+
+
+def test_async_chunk_uses_authoritative_frame_validity_without_token_history():
+    tm = _tm()
+    rid = "r-native-validity"
+
+    payload = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output={
+            "codes": {"audio": torch.tensor([[1, 2, 3, 4]])},
+            "meta": {"codec_frame_valid": False},
+        },
+        request=_req(rid, finished=False, initial_codec_chunk_frames=1, output_token_ids=[]),
+        is_finished=False,
+    )
+
+    assert payload is None
+    assert tm.code_prompt_token_ids[rid] == []
+
+
+def test_async_chunk_keeps_final_real_frame_when_eos_was_just_sampled():
+    tm = _tm()
+    rid = "r-final-real-frame"
+
+    payload = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output={
+            "codes": {"audio": torch.tensor([[1, 2, 3, 4]])},
+            "meta": {"codec_frame_valid": True},
+        },
+        request=_req(rid, finished=True, initial_codec_chunk_frames=1, output_token_ids=[4198]),
+        is_finished=True,
+    )
+
+    assert payload is not None
+    assert payload.codes.audio.tolist() == [1, 2, 3, 4]
+
+
+def test_async_chunk_batch_matches_scalar_payloads_and_state():
+    batch_builder = getattr(qwen3_tts_processors, "talker2code2wav_async_chunk_batch", None)
+    assert callable(batch_builder), "Qwen3-TTS must provide the native MRv2 batch payload builder"
+
+    scalar_tm = _tm(chunk_frames=4, left_context=3, initial_chunk_frames=1)
+    batch_tm = _tm(chunk_frames=4, left_context=3, initial_chunk_frames=1)
+    requests = [
+        _req("r-batch-0", finished=False, output_token_ids=[7]),
+        _req("r-batch-1", finished=False, output_token_ids=[8]),
+    ]
+    ref_code = torch.tensor([[9, 9, 9, 9], [8, 8, 8, 8]], dtype=torch.long)
+    # Request 2 has a multi-token span: the last validity flag wins the chunk.
+    outputs = [
+        {"codes": {"audio": torch.tensor([[1, 2, 3, 4]]), "ref": ref_code}},
+        {
+            "codes": {"audio": torch.tensor([[9, 9, 9, 9], [5, 6, 7, 8]])},
+            "meta": {"codec_frame_valid": torch.tensor([False, True])},
+        },
+    ]
+
+    scalar_payloads = [
+        talker2code2wav_async_chunk(
+            transfer_manager=scalar_tm,
+            multimodal_output=output,
+            request=request,
+            is_finished=False,
+        )
+        for request, output in zip(requests, outputs)
+    ]
+    batch_payloads = batch_builder(
+        transfer_manager=batch_tm,
+        pooling_outputs=outputs,
+        requests=requests,
+        is_finished=[False, False],
+    )
+
+    assert len(batch_payloads) == len(scalar_payloads)
+    for scalar, batched in zip(scalar_payloads, batch_payloads):
+        assert scalar is not None and batched is not None
+        torch.testing.assert_close(batched.codes.audio, scalar.codes.audio)
+        assert batched.meta.left_context_size == scalar.meta.left_context_size
+        assert batched.meta.finished.item() == scalar.meta.finished.item()
+        assert batched.speaker == scalar.speaker
+        assert batched.language == scalar.language
+    for request in requests:
+        rid = request.external_req_id
+        torch.testing.assert_close(
+            torch.stack(batch_tm.code_prompt_token_ids[rid]),
+            torch.stack(scalar_tm.code_prompt_token_ids[rid]),
+        )
+    torch.testing.assert_close(batch_tm.request_payload["r-batch-0"], scalar_tm.request_payload["r-batch-0"])
+
+
 _CASES = [
     # ── IC boundary rule ──────────────────────────────────────────────
     # initial_codec_chunk_frames only controls the first emitted chunk.
@@ -703,35 +857,27 @@ class TestRampHelpers:
     def test_parse_ramp_mixed_list_returns_none(self):
         assert parse_chunk_ramp({"codec_chunk_ramp": [4, "x"]}) is None
 
-    def test_parse_ramp_warns_on_tail_mismatch(self, caplog):
-        import logging
+    def test_parse_ramp_warns_on_tail_mismatch(self, monkeypatch):
+        warnings = []
+        monkeypatch.setattr(
+            "vllm_omni.model_executor.stage_input_processors.chunk_size_utils.logger.warning",
+            lambda message, *args: warnings.append(message % args),
+        )
 
-        target_logger = logging.getLogger("vllm_omni.model_executor.stage_input_processors.chunk_size_utils")
-        target_logger.addHandler(caplog.handler)
-        prev_level = target_logger.level
-        target_logger.setLevel(logging.WARNING)
-        try:
-            result = parse_chunk_ramp({"codec_chunk_ramp": [4, 4, 8]}, steady=25)
-        finally:
-            target_logger.removeHandler(caplog.handler)
-            target_logger.setLevel(prev_level)
+        result = parse_chunk_ramp({"codec_chunk_ramp": [4, 4, 8]}, steady=25)
         assert result == [4, 4, 8]
-        assert "reintroduces" in caplog.text
+        assert any("reintroduces" in message for message in warnings)
 
-    def test_parse_ramp_no_warn_on_tail_match(self, caplog):
-        import logging
+    def test_parse_ramp_no_warn_on_tail_match(self, monkeypatch):
+        warnings = []
+        monkeypatch.setattr(
+            "vllm_omni.model_executor.stage_input_processors.chunk_size_utils.logger.warning",
+            lambda message, *args: warnings.append(message % args),
+        )
 
-        target_logger = logging.getLogger("vllm_omni.model_executor.stage_input_processors.chunk_size_utils")
-        target_logger.addHandler(caplog.handler)
-        prev_level = target_logger.level
-        target_logger.setLevel(logging.WARNING)
-        try:
-            result = parse_chunk_ramp({"codec_chunk_ramp": [4, 4, 8, 16, 25]}, steady=25)
-        finally:
-            target_logger.removeHandler(caplog.handler)
-            target_logger.setLevel(prev_level)
+        result = parse_chunk_ramp({"codec_chunk_ramp": [4, 4, 8, 16, 25]}, steady=25)
         assert result == [4, 4, 8, 16, 25]
-        assert "reintroduces" not in caplog.text
+        assert warnings == []
 
     @pytest.mark.parametrize(
         "index,ramp,steady,expected",
@@ -1028,6 +1174,7 @@ class TestChunkRampEmission:
         tm.put_req_chunk[rid] = 2
 
         tm.code_prompt_token_ids[rid] = []
+        tm._qwen3_tts_emitted_frames.pop(rid, None)
         tm.ramp_chunk_count.pop(rid, None)
 
         p_seg2_0 = self._emit(tm, rid, 4)
@@ -1051,6 +1198,7 @@ class TestChunkRampEmission:
         tm.put_req_chunk[rid] = 1
 
         tm.code_prompt_token_ids[rid] = []
+        tm._qwen3_tts_emitted_frames.pop(rid, None)
         tm.ramp_chunk_count.pop(rid, None)
 
         p_seg2_0 = self._emit(tm, rid, 4)
@@ -1429,6 +1577,7 @@ class TestAdaptiveEmission:
         tm.put_req_chunk[rid] = 1
 
         tm.code_prompt_token_ids[rid] = []
+        tm._qwen3_tts_emitted_frames.pop(rid, None)
         tm.ramp_chunk_count.pop(rid, None)
         tm._adaptive_states.pop(rid, None)
 
diff --git a/tests/model_extras/test_shared_script_ar_integration.py b/tests/model_extras/test_shared_script_ar_integration.py
index f781ca5fb..4c24134e6 100644
--- a/tests/model_extras/test_shared_script_ar_integration.py
+++ b/tests/model_extras/test_shared_script_ar_integration.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Integration coverage for the shared task examples' ``_apply_ar_stage_inputs``.
 
 The unit tests in ``test_model_extras.py`` cover ``get_ar_input_builder`` and
@@ -25,6 +25,7 @@ import importlib.util
 import sys
 from dataclasses import dataclass
 from pathlib import Path
+from types import SimpleNamespace
 from typing import Any
 
 import pytest
@@ -36,6 +37,96 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 _REPO_ROOT = Path(__file__).resolve().parents[2]
 
 
+@pytest.mark.parametrize("with_ar_stage", [False, True])
+def test_text_to_image_only_builds_ar_inputs_for_ar_deployments(monkeypatch, tmp_path, with_ar_stage):
+    from PIL import Image
+    from vllm import SamplingParams
+
+    from vllm_omni.config.omni_config import normalize_and_validate_diffusion_engine_ingress_kwargs
+
+    module = _load_module("_shared_text_to_image_deploy", "examples/offline_inference/text_to_image/text_to_image.py")
+    tokenizer_calls = _patch_tokenizer_loader(monkeypatch, module)
+    monkeypatch.setattr(module, "get_ar_tokenizer_validator", lambda _: None)
+    monkeypatch.setattr(
+        module, "current_omni_platform", SimpleNamespace(device_type="cpu", pre_register_and_update=lambda parser: None)
+    )
+    monkeypatch.setattr(module, "is_nextstep_model", lambda _: False)
+    monkeypatch.setattr(module, "get_model_class_name", lambda _: "HunyuanImage3ForCausalMM")
+    defaults = [OmniDiffusionSamplingParams()]
+    if with_ar_stage:
+        defaults.insert(0, SamplingParams())
+    captured: dict[str, Any] = {}
+
+    def generate(prompt, *, sampling_params_list):
+        captured.update(prompt=prompt, params=sampling_params_list)
+        return [SimpleNamespace(images=[Image.new("RGB", (8, 8))])]
+
+    def create_omni(**kwargs):
+        # Exercise the real ingress validator so stale example-only options
+        # cannot silently pass this test while breaking model initialization.
+        normalize_and_validate_diffusion_engine_ingress_kwargs(kwargs, stage_id=0)
+        return SimpleNamespace(default_sampling_params_list=defaults, generate=generate)
+
+    monkeypatch.setattr(module, "Omni", create_omni)
+    output = tmp_path / "output.png"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        [
+            "text_to_image.py",
+            "--model",
+            "test-hunyuan",
+            "--prompt",
+            "A dog",
+            "--output",
+            str(output),
+            "--extra-body",
+            '{"bot_task": null}' if with_ar_stage else '{"bot_task": "none"}',
+            "--trust-remote-code",
+        ],
+    )
+    module.main()
+
+    assert output.is_file()
+    assert bool(tokenizer_calls) == with_ar_stage
+    assert ("prompt_token_ids" in captured["prompt"]) == with_ar_stage
+    if with_ar_stage:
+        assert captured["params"][0].stop_token_ids
+    else:
+        assert captured["prompt"] == {"prompt": "A dog", "modalities": ["image"]}
+        assert captured["params"][0].extra_args["bot_task"] == "none"
+
+
+def test_hunyuan_accuracy_offline_cli_contract(monkeypatch, tmp_path):
+    import subprocess
+
+    from PIL import Image
+
+    accuracy = _load_module("_hunyuan_accuracy", "tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py")
+    module = _load_module("_hunyuan_accuracy_cli", "examples/offline_inference/text_to_image/text_to_image.py")
+    output = tmp_path / "offline.png"
+
+    def run(argv, *, check):
+        assert check
+        assert Path(argv[1]).is_file()
+        monkeypatch.setattr(sys, "argv", argv[1:])
+        args = module.parse_args()
+        assert args.enable_expert_parallel
+        assert args.extra_body == {"bot_task": "none"}
+        assert args.use_system_prompt == "en_unified"
+        assert args.trust_remote_code
+        assert args.seed == accuracy.SEED
+        assert args.num_inference_steps == accuracy.NUM_INFERENCE_STEPS
+        assert args.output == str(output)
+        Image.new("RGB", (8, 8)).save(args.output)
+
+    monkeypatch.setattr(subprocess, "run", run)
+    image = accuracy._run_vllm_omni_hunyuan_image3_offline(
+        model="test-hunyuan", deploy_config="deploy.yaml", output_path=output
+    )
+    assert image.size == (8, 8)
+
+
 def _load_module(name: str, relpath: str):
     path = _REPO_ROOT / relpath
     spec = importlib.util.spec_from_file_location(name, path)
@@ -75,9 +166,7 @@ def _patch_tokenizer_loader(monkeypatch: pytest.MonkeyPatch, module: Any) -> lis
             calls.append({"model": model, "trust_remote_code": trust_remote_code})
             return _FakeHunyuanTokenizer()
 
-    fake_transformers = type(sys)("transformers")
-    fake_transformers.AutoTokenizer = _FakeAutoTokenizer
-    monkeypatch.setitem(sys.modules, "transformers", fake_transformers)
+    monkeypatch.setattr("transformers.AutoTokenizer.from_pretrained", _FakeAutoTokenizer.from_pretrained)
     return calls
 
 
@@ -90,9 +179,7 @@ def _patch_failing_tokenizer_loader(monkeypatch: pytest.MonkeyPatch) -> None:
         def from_pretrained(model: str, trust_remote_code: bool = False) -> Any:
             raise OSError("simulated tokenizer load failure")
 
-    fake_transformers = type(sys)("transformers")
-    fake_transformers.AutoTokenizer = _FailingAutoTokenizer
-    monkeypatch.setitem(sys.modules, "transformers", fake_transformers)
+    monkeypatch.setattr("transformers.AutoTokenizer.from_pretrained", _FailingAutoTokenizer.from_pretrained)
 
 
 @pytest.mark.parametrize(
diff --git a/tests/model_tests/conftest.py b/tests/model_tests/conftest.py
index 7760fa25d..28cfa8891 100644
--- a/tests/model_tests/conftest.py
+++ b/tests/model_tests/conftest.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import json
 from shutil import rmtree
 
@@ -12,7 +15,7 @@ def tiny_model_paths(request, run_level, tmp_path_factory):
     """Build or download the tiny models for the selected tests.
 
     At core_model level, builds tiny models via the builder function.
-    At advanced_model / full_model level, uses the real HF model path.
+    At advanced_model / full_model level, uses the real HF model path or asset resolver.
 
     NOTE: this is session scoped to avoid churn in tiny model creation,
     but will ensure all the tiny models you need are created for the selected tests
@@ -45,7 +48,11 @@ def tiny_model_paths(request, run_level, tmp_path_factory):
                             built_paths.append(path)
                         else:
                             print(f"Run level is {run_level}; {model_name} will use the full model")
-                            path = settings.model
+                            if callable(settings.model):
+                                path = settings.model()
+                                built_paths.append(path)
+                            else:
+                                path = settings.model
                         model_paths[model_name] = path
                 data_file.write_text(json.dumps(model_paths))
 
diff --git a/tests/model_tests/diffusion/anima_builder.py b/tests/model_tests/diffusion/anima_builder.py
new file mode 100644
index 000000000..ca0f9e29a
--- /dev/null
+++ b/tests/model_tests/diffusion/anima_builder.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Local random-weight Anima assets and real-checkpoint assets for common tests."""
+
+import json
+import tempfile
+from pathlib import Path
+
+import torch
+from diffusers import AutoencoderKLQwenImage, FlowMatchEulerDiscreteScheduler
+from huggingface_hub import hf_hub_download, snapshot_download
+from safetensors.torch import save_file
+from tokenizers import Tokenizer
+from tokenizers.models import Unigram, WordLevel
+from tokenizers.pre_tokenizers import Whitespace
+from tokenizers.processors import TemplateProcessing
+from transformers import PreTrainedTokenizerFast, Qwen3Config, Qwen3Model, T5TokenizerFast
+
+from vllm_omni.diffusion.models.anima.anima_text_conditioner import (
+    ANIMA_TEXT_CONDITIONER_CONFIG,
+    AnimaTextConditioner,
+)
+from vllm_omni.diffusion.models.anima.anima_transformer import ANIMA_TRANSFORMER_CONFIG, AnimaTransformer3DModel
+
+CHECKPOINT_FILENAME = "anima.safetensors"
+
+
+def tiny_anima_builder() -> str:
+    """Build all components locally, without downloading any model weights or tokenizers."""
+    model_dir = Path(tempfile.mkdtemp(prefix="tiny-anima-"))
+    transformer_config = {
+        **ANIMA_TRANSFORMER_CONFIG,
+        "num_attention_heads": 2,
+        "attention_head_dim": 32,
+        "num_layers": 1,
+        "mlp_ratio": 1.0,
+        "text_embed_dim": 32,
+        "adaln_lora_dim": 8,
+        "max_size": (1, 64, 64),
+    }
+    conditioner_config = {
+        **ANIMA_TEXT_CONDITIONER_CONFIG,
+        "source_dim": 32,
+        "target_dim": 32,
+        "model_dim": 32,
+        "num_layers": 1,
+        "num_attention_heads": 2,
+        "mlp_ratio": 1.0,
+        "target_vocab_size": 8,
+        "min_sequence_length": 8,
+    }
+    transformer = AnimaTransformer3DModel(**transformer_config).to(torch.bfloat16)
+    conditioner = AnimaTextConditioner(**conditioner_config).to(torch.bfloat16)
+    save_file(
+        {
+            **{f"transformer.{name}": tensor for name, tensor in transformer.state_dict().items()},
+            **{f"text_conditioner.{name}": tensor for name, tensor in conditioner.state_dict().items()},
+        },
+        str(model_dir / CHECKPOINT_FILENAME),
+    )
+    (model_dir / "anima.json").write_text(
+        json.dumps({"transformer": transformer_config, "text_conditioner": conditioner_config})
+    )
+    Qwen3Model(
+        Qwen3Config(
+            vocab_size=8,
+            hidden_size=32,
+            intermediate_size=64,
+            num_hidden_layers=1,
+            num_attention_heads=2,
+            num_key_value_heads=2,
+            head_dim=16,
+        )
+    ).to(torch.bfloat16).save_pretrained(model_dir / "text_encoder")
+    AutoencoderKLQwenImage(
+        base_dim=4,
+        z_dim=16,
+        dim_mult=[1, 1, 1, 1],
+        num_res_blocks=1,
+        latents_mean=[0.0] * 16,
+        latents_std=[1.0] * 16,
+    ).to(torch.bfloat16).save_pretrained(model_dir / "vae")
+    tokenizer = Tokenizer(WordLevel({"<pad>": 0, "</s>": 1, "<unk>": 2, "Dummy": 3, "prompt": 4}, unk_token="<unk>"))
+    tokenizer.pre_tokenizer = Whitespace()
+    tokenizer.post_processor = TemplateProcessing(single="$A </s>", special_tokens=[("</s>", 1)])
+    PreTrainedTokenizerFast(
+        tokenizer_object=tokenizer, pad_token="<pad>", eos_token="</s>", unk_token="<unk>"
+    ).save_pretrained(model_dir / "tokenizer")
+    t5_tokenizer = Tokenizer(
+        Unigram(
+            [("<pad>", 0.0), ("</s>", 0.0), ("<unk>", 0.0), ("▁", -1.0), ("Dummy", -1.0), ("prompt", -1.0)], unk_id=2
+        )
+    )
+    T5TokenizerFast(tokenizer_object=t5_tokenizer, extra_ids=0).save_pretrained(model_dir / "t5_tokenizer")
+    FlowMatchEulerDiscreteScheduler(shift=3.0).save_pretrained(model_dir / "scheduler")
+    return str(model_dir)
+
+
+def real_anima_model() -> str:
+    """Keep cached real assets intact; return a disposable directory of links."""
+    components = Path(
+        snapshot_download(
+            "circlestone-labs/Anima-Base-v1.0-Diffusers",
+            allow_patterns=["text_encoder/*", "vae/*", "tokenizer/*", "t5_tokenizer/*", "scheduler/*"],
+        )
+    )
+    checkpoint = hf_hub_download(
+        "circlestone-labs/Anima", filename="split_files/diffusion_models/anima-base-v1.0.safetensors"
+    )
+    model_dir = Path(tempfile.mkdtemp(prefix="real-anima-"))
+    (model_dir / CHECKPOINT_FILENAME).symlink_to(checkpoint)
+    for name in ("text_encoder", "vae", "tokenizer", "t5_tokenizer", "scheduler"):
+        if (components / name).is_dir():
+            (model_dir / name).symlink_to(components / name, target_is_directory=True)
+    return str(model_dir)
diff --git a/tests/model_tests/diffusion/config_types.py b/tests/model_tests/diffusion/config_types.py
index 634036ed4..8b66af191 100644
--- a/tests/model_tests/diffusion/config_types.py
+++ b/tests/model_tests/diffusion/config_types.py
@@ -1,10 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Common definitions for controlling what tests run where.
 """
 
 from collections.abc import Callable
 from enum import Enum
-from typing import NamedTuple, TypeAlias
+from typing import Any, NamedTuple, TypeAlias
 
 from pytest import MarkDecorator
 
@@ -45,7 +48,9 @@ class DiffusionModelTestOpts(NamedTuple):
     # HF model name for real-weight tests (advanced_model / full_model level).
     # For now, whether we use the real weights vs tiny weights in the common tests
     # depends on the run level.
-    model: str
+    # A callable may assemble native assets in a temporary directory; the fixture
+    # removes that directory after the tests, so it must not return a cache root.
+    model: str | Callable[[], str]
 
     # Creates a tiny model for the given architecture. We should always use tiny
     # model weights for tests that do not require us to check the model quality.
@@ -81,9 +86,12 @@ class DiffusionModelTestOpts(NamedTuple):
     # set False for pipelines that mandate an image and fail closed without one (SANA-Video I2V).
     check_i2v_t2v_divergence: bool = True
 
+    # Native single-file models: builders/resolvers return the containing directory.
+    checkpoint_filename: str | None = None
+
 
 ### Mappings & utils for building offline Omni() instances given a list of enabled accelerations
-ACC_OMNI_KWARGS = {
+ACC_OMNI_KWARGS: dict[DiffusionAccs, dict[str, Any]] = {
     DiffusionAccs.VAE_PATCH_PARALLEL: {"vae_use_tiling": True},
     DiffusionAccs.CPU_OFFLOAD: {"enable_cpu_offload": True},
     DiffusionAccs.LAYERWISE_OFFLOAD: {"enable_layerwise_offload": True},
diff --git a/tests/model_tests/diffusion/model_settings.py b/tests/model_tests/diffusion/model_settings.py
index 083dba0ed..8c5955c8d 100644
--- a/tests/model_tests/diffusion/model_settings.py
+++ b/tests/model_tests/diffusion/model_settings.py
@@ -1,4 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from tests.model_tests.diffusion import diff_model_builders
+from tests.model_tests.diffusion.anima_builder import CHECKPOINT_FILENAME, real_anima_model, tiny_anima_builder
 from tests.model_tests.diffusion.config_types import (
     DiffusionAccs,
     DiffusionModelTestOpts,
@@ -29,6 +33,12 @@ from tests.model_tests.diffusion.config_types import (
 # $ pytest test_common_offline.py -k test_pipeline_on_supported_tasks[Flux2KleinPipeline
 #   ^ Runs all test groups for Flux2KleinPipeline only
 DIFFUSION_TEST_SETTINGS = {
+    "AnimaPipeline": DiffusionModelTestOpts(
+        model=real_anima_model,
+        builder=tiny_anima_builder,
+        supported_tasks=[DiffusionTasks.TEXT_TO_IMAGE],
+        checkpoint_filename=CHECKPOINT_FILENAME,
+    ),
     "Flux2KleinPipeline": DiffusionModelTestOpts(
         model="black-forest-labs/FLUX.2-klein-4B",
         builder=diff_model_builders.tiny_flux2_klein_builder,
diff --git a/tests/model_tests/diffusion/test_alignment.py b/tests/model_tests/diffusion/test_alignment.py
index f0a1285bc..f7f1855cc 100644
--- a/tests/model_tests/diffusion/test_alignment.py
+++ b/tests/model_tests/diffusion/test_alignment.py
@@ -28,6 +28,9 @@ EXCLUDED_MODELS = [
     "GlmImagePipeline",
     "ZImagePipeline",
     "OvisImagePipeline",
+    # Requires upstream AR hidden states and token boundaries; covered by
+    # dedicated MammothModa2 bridge/pipeline tests and real-checkpoint E2E.
+    "MammothModa2DiTPipeline",
     "WanPipeline",
     "WanDMDPipeline",
     "WanVACEPipeline",
@@ -82,6 +85,7 @@ EXCLUDED_MODELS = [
     "StableDiffusionXLPipeline",
     "Gr00tN1d7Pipeline",
     "Pi0Pipeline",
+    "Pi05Pipeline",
     "SanaWmPipeline",
     # Audio pipeline conditioned by a separate Qwen2.5-Omni encoder stage;
     # covered by tests/diffusion/models/auk (CPU pipeline tests, parity) and
diff --git a/tests/model_tests/diffusion/test_common_offline.py b/tests/model_tests/diffusion/test_common_offline.py
index 9cecc31fd..b610ed013 100644
--- a/tests/model_tests/diffusion/test_common_offline.py
+++ b/tests/model_tests/diffusion/test_common_offline.py
@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+from pathlib import Path
+
 import pytest
 
 from tests.model_tests.diffusion.case_filtering import get_parametrized_options
@@ -47,10 +49,17 @@ def test_pipeline_on_supported_tasks(
     # since starting the server can take 10+ seconds, even for tiny models.
     #
     # NOTE: Be sure to install pytest-subtests if you're running on pytest < 9
+    settings = DIFFUSION_TEST_SETTINGS[model_name]
+    model_path = tiny_model_paths[model_name]
+    model_kwargs = {}
+    if settings.checkpoint_filename is not None:
+        model_path = str(Path(model_path) / settings.checkpoint_filename)
+        model_kwargs["model_class_name"] = model_name
     omni = build_omni_from_diff_accelerations(
         accelerations=accelerations,
-        model=tiny_model_paths[model_name],
+        model=model_path,
         enforce_eager=True,
+        **model_kwargs,
     )
     try:
         for task_type in supported_tasks:
diff --git a/tests/model_tests/diffusion/test_common_online.py b/tests/model_tests/diffusion/test_common_online.py
index ed7f0e2fa..ef4449501 100644
--- a/tests/model_tests/diffusion/test_common_online.py
+++ b/tests/model_tests/diffusion/test_common_online.py
@@ -7,6 +7,8 @@ online serving stack (CLI arg parsing, subprocess, API routing, response
 encoding) using tiny models.
 """
 
+from pathlib import Path
+
 import pytest
 from xdist import is_xdist_worker
 
@@ -68,6 +70,10 @@ def test_online_on_supported_tasks(
     model_path = tiny_model_paths[model_name]
     server_args = build_server_args_from_diff_accelerations(accelerations)
     server_args.append("--enforce-eager")
+    settings = DIFFUSION_TEST_SETTINGS[model_name]
+    if settings.checkpoint_filename is not None:
+        model_path = str(Path(model_path) / settings.checkpoint_filename)
+        server_args.extend(["--model-class-name", model_name])
 
     with OmniServer(model_path, server_args) as server:
         # TODO: We may want to revisit run_level validation here,
diff --git a/tests/model_tests/diffusion/test_native_model_settings.py b/tests/model_tests/diffusion/test_native_model_settings.py
new file mode 100644
index 000000000..10db75d05
--- /dev/null
+++ b/tests/model_tests/diffusion/test_native_model_settings.py
@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from contextlib import nullcontext
+from pathlib import Path
+from shutil import rmtree
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from tests.model_tests.diffusion import anima_builder, test_common_offline, test_common_online
+from tests.model_tests.diffusion.config_types import DiffusionTasks
+
+pytestmark = [pytest.mark.cpu, pytest.mark.core_model, pytest.mark.diffusion]
+
+
+@pytest.mark.parametrize("model_name", ["AnimaPipeline", "FluxPipeline"])
+def test_common_runners_resolve_native_checkpoint(model_name, tmp_path, monkeypatch):
+    """Both entry points receive the file and class; directory models keep their existing arguments."""
+    paths = {model_name: str(tmp_path)}
+    subtests = SimpleNamespace(test=lambda **kwargs: nullcontext())
+    build_omni = MagicMock()
+    monkeypatch.setattr(test_common_offline, "build_omni_from_diff_accelerations", build_omni)
+    monkeypatch.setattr(test_common_offline, "run_and_validate_text_to_image_request", MagicMock())
+    test_common_offline.test_pipeline_on_supported_tasks(
+        model_name, None, [DiffusionTasks.TEXT_TO_IMAGE], False, False, False, paths, subtests
+    )
+    server = MagicMock()
+    monkeypatch.setattr(test_common_online, "OmniServer", server)
+    monkeypatch.setattr(test_common_online, "OnlineOmniClient", MagicMock())
+    monkeypatch.setattr(test_common_online, "run_and_validate_online_text_to_image_request", MagicMock())
+    test_common_online.test_online_on_supported_tasks(
+        model_name, None, [DiffusionTasks.TEXT_TO_IMAGE], False, False, paths, "core_model", subtests
+    )
+    if model_name == "AnimaPipeline":
+        checkpoint = str(tmp_path / anima_builder.CHECKPOINT_FILENAME)
+        build_omni.assert_called_once_with(
+            accelerations=None, model=checkpoint, enforce_eager=True, model_class_name=model_name
+        )
+        server.assert_called_once_with(checkpoint, ["--enforce-eager", "--model-class-name", model_name])
+    else:
+        build_omni.assert_called_once_with(accelerations=None, model=str(tmp_path), enforce_eager=True)
+        server.assert_called_once_with(str(tmp_path), ["--enforce-eager"])
+
+
+def test_real_anima_assets_leave_cache_intact(tmp_path, monkeypatch):
+    """The fixture may delete the assembled directory without deleting cached model assets."""
+    components = tmp_path / "components"
+    for name in ("text_encoder", "vae", "tokenizer", "t5_tokenizer"):
+        (components / name).mkdir(parents=True)
+        (components / name / "asset").write_text(name)
+    checkpoint = tmp_path / "real.safetensors"
+    checkpoint.write_bytes(b"checkpoint")
+    monkeypatch.setattr(anima_builder, "snapshot_download", lambda *args, **kwargs: str(components))
+    monkeypatch.setattr(anima_builder, "hf_hub_download", lambda *args, **kwargs: str(checkpoint))
+    directory = Path(anima_builder.real_anima_model())
+    try:
+        assert (directory / anima_builder.CHECKPOINT_FILENAME).read_bytes() == b"checkpoint"
+        assert (directory / "vae" / "asset").read_text() == "vae"
+        # Missing scheduler is supported by Anima's default scheduler fallback.
+        assert not (directory / "scheduler").exists()
+    finally:
+        rmtree(directory)
+    assert checkpoint.read_bytes() == b"checkpoint"
+    assert (components / "vae" / "asset").read_text() == "vae"
diff --git a/tests/model_tests/diffusion/utils.py b/tests/model_tests/diffusion/utils.py
index 35577b68f..137eae123 100644
--- a/tests/model_tests/diffusion/utils.py
+++ b/tests/model_tests/diffusion/utils.py
@@ -1,8 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Utilities for resolving real models to their tiny model equivalents.
 """
 
 import logging
+from pathlib import Path
 
 from tests.model_tests.diffusion.model_settings import DIFFUSION_TEST_SETTINGS
 from vllm_omni.diffusion.data import resolve_model_class_name
@@ -30,4 +34,7 @@ def resolve_tiny_model_path(model: str) -> str:
         )
         return model
 
-    return test_opts.builder()
+    model_path = test_opts.builder()
+    if test_opts.checkpoint_filename is not None:
+        return str(Path(model_path) / test_opts.checkpoint_filename)
+    return model_path
diff --git a/tests/platforms/npu/quant/test_kv_quant_npu.py b/tests/platforms/npu/quant/test_kv_quant_npu.py
index 0c828a6a3..611721809 100644
--- a/tests/platforms/npu/quant/test_kv_quant_npu.py
+++ b/tests/platforms/npu/quant/test_kv_quant_npu.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Unit tests for NPU FP8 KV quantization helpers.
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Tests for seeded rotations and the quantized NPU attention backend.
 
 These tests load ``kv_quant_npu`` from its source file via ``importlib`` so
 the test module itself does not ``import vllm_omni`` (which would pull
@@ -10,10 +10,8 @@ the test module itself does not ``import vllm_omni`` (which would pull
 from __future__ import annotations
 
 import importlib.util
-import math
 from pathlib import Path
-from types import ModuleType, SimpleNamespace
-from typing import Any
+from types import ModuleType
 
 import pytest
 import torch
@@ -61,147 +59,39 @@ def _npu_smoke_available() -> bool:
 npu_smoke = pytest.mark.skipif(not _npu_smoke_available(), reason="NPU device or torch_npu not available.")
 
 
-def test_is_quantized_kv_cache() -> None:
-    assert kv_quant_npu.is_quantized_kv_cache("fp8")
-    assert not kv_quant_npu.is_quantized_kv_cache(None)
-    assert not kv_quant_npu.is_quantized_kv_cache("int8")
-
-
-class TestKVQuantNPUUnit:
-    @pytest.fixture(autouse=True)
-    def clear_rot_cache(self):
-        kv_quant_npu._ROT_MATRIXS.clear()
-
-    def test_get_rot_matrix_caches_by_device_dtype_and_head_dim(self) -> None:
-        calls = {"count": 0}
-
-        class FakeQuaRotMode:
-            HADAMARD = "hadamard"
-
-        def fake_create_rot(mode, head_dim, seed):
-            calls["count"] += 1
-            assert mode == FakeQuaRotMode.HADAMARD
-            assert seed == 425500
-            return torch.eye(head_dim, dtype=torch.float32)
-
-        device = torch.device("cpu")
-        rot_1 = kv_quant_npu._get_rot_matrix(device, torch.float16, 8, FakeQuaRotMode, fake_create_rot)
-        rot_2 = kv_quant_npu._get_rot_matrix(device, torch.float16, 8, FakeQuaRotMode, fake_create_rot)
-        rot_3 = kv_quant_npu._get_rot_matrix(device, torch.bfloat16, 8, FakeQuaRotMode, fake_create_rot)
-        rot_4 = kv_quant_npu._get_rot_matrix(device, torch.float16, 16, FakeQuaRotMode, fake_create_rot)
-
-        assert calls["count"] == 3
-        assert rot_1 is rot_2
-        assert rot_3.dtype == torch.bfloat16
-        assert rot_4.shape == (16, 16)
-
-    @pytest.fixture
-    def fake_quant_ops(self, monkeypatch: pytest.MonkeyPatch) -> dict[str, Any]:
-        captured: dict[str, Any] = {
-            "fa_calls": [],
-            "npu_kwargs": None,
-            "out_shape": None,
-        }
-
-        class FakeTorchNPU:
-            float8_e4m3fn = "fp8_marker"
-
-            @staticmethod
-            def npu_fused_infer_attention_score_v2(q, k, v, **kwargs):
-                del q, k, v
-                captured["npu_kwargs"] = kwargs
-                out_shape = captured["out_shape"]
-                return (torch.ones(out_shape, dtype=torch.float32),)
-
-        def fake_fa_block_quant_preprocess(x, block_size, dst_type, layout):
-            captured["fa_calls"].append(
-                {
-                    "block_size": block_size,
-                    "layout": layout,
-                    "dst_type": dst_type,
-                    "shape": tuple(x.shape),
-                }
-            )
-            scale = torch.full((1,), float(block_size), dtype=torch.float32)
-            return x, scale
-
-        fake_qua_rot_mode = SimpleNamespace(HADAMARD="hadamard")
-
-        def fake_create_rot(mode, head_dim, seed):
-            assert mode == "hadamard"
-            assert seed == 425500
-            return torch.eye(head_dim, dtype=torch.float32)
-
-        monkeypatch.setattr(
-            kv_quant_npu,
-            "_load_quant_ops",
-            lambda: (FakeTorchNPU, fake_fa_block_quant_preprocess, fake_qua_rot_mode, fake_create_rot),
-        )
-
-        return captured
-
-    @staticmethod
-    def _make_qkv(shape: tuple[int, int, int, int]) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        query = torch.randn(*shape, dtype=torch.float32)
-        key = torch.randn(*shape, dtype=torch.float32)
-        value = torch.randn(*shape, dtype=torch.float32)
-        return query, key, value
-
-    @pytest.mark.parametrize(
-        "layout,input_shape,out_shape,softmax_scale,expected_scale",
-        [
-            ("BNSD", (2, 3, 4, 8), (2, 3, 6, 8), None, 1.0 / math.sqrt(8)),
-            ("BSND", (2, 4, 3, 8), (2, 6, 3, 8), 0.125, 0.125),
-        ],
-    )
-    def test_fp8_rotate_quant_fa_layouts_scale_and_crop(
-        self,
-        fake_quant_ops: dict[str, Any],
-        layout: str,
-        input_shape: tuple[int, int, int, int],
-        out_shape: tuple[int, int, int, int],
-        softmax_scale: float | None,
-        expected_scale: float,
-    ) -> None:
-        query, key, value = self._make_qkv(input_shape)
-        fake_quant_ops["out_shape"] = out_shape
-
-        out = kv_quant_npu.fp8_rotate_quant_fa(query, key, value, layout=layout, softmax_scale=softmax_scale)
-
-        assert out.shape == query.shape
-        assert out.dtype == query.dtype
-        assert fake_quant_ops["npu_kwargs"]["input_layout"] == layout
-        # BNSD: shape[1]==heads, BSND: shape[2]==heads.
-        expected_heads = input_shape[1] if layout == "BNSD" else input_shape[2]
-        assert fake_quant_ops["npu_kwargs"]["num_query_heads"] == expected_heads
-        assert fake_quant_ops["npu_kwargs"]["softmax_scale"] == pytest.approx(expected_scale)
-        assert [call["block_size"] for call in fake_quant_ops["fa_calls"]] == [128, 256, 256]
-
-    def test_fp8_rotate_quant_fa_invalid_layout_raises(self, fake_quant_ops) -> None:
-        query = torch.randn(1, 2, 3, 4, dtype=torch.float32)
-        key = torch.randn(1, 2, 3, 4, dtype=torch.float32)
-        value = torch.randn(1, 2, 3, 4, dtype=torch.float32)
-        fake_quant_ops["out_shape"] = (1, 2, 3, 4)
-
-        with pytest.raises(ValueError, match="unsupported layout"):
-            kv_quant_npu.fp8_rotate_quant_fa(query, key, value, layout="INVALID")
+def test_rotation_is_fixed_orthogonal_cached_and_preserves_rng():
+    kv_quant_npu.get_quant_attention_rotation.cache_clear()
+    before = torch.random.get_rng_state()
+    rot = kv_quant_npu.get_quant_attention_rotation(torch.device("cpu"), torch.float32, 64)
+    assert rot is kv_quant_npu.get_quant_attention_rotation(torch.device("cpu"), torch.float32, 64)
+    torch.testing.assert_close(rot @ rot.T, torch.eye(64))
+    assert torch.equal(before, torch.random.get_rng_state())
 
 
 @npu_smoke
-class TestKVQuantNPUSmoke:
-    """Smoke tests using real torch_npu/mindiesd stack, only on NPU."""
+@pytest.mark.npu
+@pytest.mark.parametrize("method", ["fp8", "mxfp8", "mxfp4"])
+@pytest.mark.parametrize("layout", ["BSND", "BNSD"])
+@pytest.mark.parametrize("seq_len", [256, 75600])
+def test_dense_runtime_backend_real_npu(method, layout, seq_len):
+    from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+    from vllm_omni.diffusion.attention.backends.flash_attn import FlashAttentionImpl
 
-    def test_fp8_rotate_quant_fa_real_npu_shape_contract(self):
-        try:
-            kv_quant_npu._load_quant_ops.cache_clear()
-            kv_quant_npu._load_quant_ops()
-        except ImportError:
-            pytest.skip("NPU quant dependencies are not fully installed.")
-
-        query = torch.randn(1, 2, 4, 64, dtype=torch.float16, device="npu")
-        key = torch.randn(1, 2, 4, 64, dtype=torch.float16, device="npu")
-        value = torch.randn(1, 2, 4, 64, dtype=torch.float16, device="npu")
-
-        out = kv_quant_npu.fp8_rotate_quant_fa(query, key, value, layout="BNSD")
-        assert out.shape == query.shape
-        assert out.dtype == query.dtype
+    # On NPU, missing Runtime symbols must fail this qualification test.
+    query = torch.randn(1, seq_len, 2, 128, dtype=torch.bfloat16, device="npu") * 0.1
+    # Distinct constant values per head detect head/layout mixing and tail writes.
+    value = torch.tensor([0.5, -0.5], dtype=query.dtype, device=query.device)
+    value = value.view(1, 1, 2, 1).expand_as(query).contiguous()
+    if layout == "BNSD":
+        query, value = query.transpose(1, 2), value.transpose(1, 2)
+    impl = FlashAttentionImpl(
+        num_heads=2,
+        head_size=128,
+        softmax_scale=128**-0.5,
+        qkv_layout=layout,
+    )
+    metadata = AttentionMetadata(extra={"kv_cache_dtype": method})
+    out = impl.forward_npu(query, query, value, metadata)
+    assert out.shape == query.shape and out.dtype == query.dtype
+    assert torch.isfinite(out).all()
+    torch.testing.assert_close(out.float().cpu(), value.float().cpu(), rtol=0.02, atol=0.02)
diff --git a/tests/platforms/npu/quant/test_mxfp4_step_fallback.py b/tests/platforms/npu/quant/test_mxfp4_step_fallback.py
new file mode 100644
index 000000000..8431ebf17
--- /dev/null
+++ b/tests/platforms/npu/quant/test_mxfp4_step_fallback.py
@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Real A5 kernels: step selection, bias, shape, and reuse of prepared W4 weights."""
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion, pytest.mark.npu]
+
+torch_npu = pytest.importorskip("torch_npu")
+
+
+@torch.inference_mode()
+def _exercise_mxfp4_fallback(with_bias, dtype, input_shape, mode, monkeypatch, *, policy, scale_alg=2):
+    from vllm_omni.diffusion.forward_context import (
+        ForwardContext,
+        override_forward_context,
+        set_forward_context_denoise_step_idx,
+    )
+    from vllm_omni.quantization.mxfp4_config import (
+        DiffusionMXFP4Config,
+        NPUMxfp4LinearMethod,
+        NPUMxfp4OnlineLinearMethod,
+    )
+
+    prefix = "blocks.10.attn1.to_qkv"
+    steps = [1] if policy in ("step", "layer_and_step") else []
+    layers = [prefix] if policy in ("layer", "layer_and_step") else []
+    fallback = {"w4a8_fallback_steps": steps, "w4a8_fallback_layers": layers, "mxfp4_scale_alg": scale_alg}
+    torch.manual_seed(42)
+    layer = torch.nn.Linear(1024, 128, bias=with_bias, device="npu", dtype=dtype)
+    if mode == "single":
+        method = NPUMxfp4OnlineLinearMethod(DiffusionMXFP4Config(**fallback), prefix=prefix)
+    elif mode == "single_offline":
+        method = NPUMxfp4LinearMethod(
+            DiffusionMXFP4Config(is_checkpoint_mxfp4_serialized=True, **fallback), prefix=prefix
+        )
+        layer.orig_dtype = dtype
+        values = torch.tensor([-4.0, -2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0])
+        layer.weight.copy_(values[torch.randint(8, (128, 1024))].to(layer.weight))
+        layer.register_parameter(
+            "weight_scale", torch.nn.Parameter(torch.full((128, 32), 124, dtype=torch.uint8, device="npu"), False)
+        )
+        layer.register_parameter("mul_scale", torch.nn.Parameter((torch.rand(1024) * 1.5 + 0.5).npu(), False))
+    else:
+        raise ValueError(f"Unsupported single-scale test mode: {mode}")
+    method.process_weights_after_loading(layer)
+    x = torch.randn(input_shape, device="npu", dtype=dtype)
+    pointers = (layer.weight.data_ptr(), layer.weight_scale.data_ptr())
+    method.process_weights_after_loading(layer)
+    quantize = torch_npu.npu_dynamic_mx_quant
+    activation_types = []
+
+    def record_quantize(x, **kwargs):
+        dst = kwargs["dst_type"]
+        expected_alg = 0 if dst == torch_npu.float8_e4m3fn else scale_alg
+        assert kwargs["scale_alg"] == expected_alg
+        assert kwargs["axis"] == -1 and kwargs["block_size"] == 32 and kwargs["round_mode"] == "rint"
+        if expected_alg == 2:
+            assert kwargs["dst_type_max"] == 7.25
+        else:
+            assert "dst_type_max" not in kwargs
+        activation_types.append(dst)
+        return quantize(x, **kwargs)
+
+    monkeypatch.setattr(torch_npu, "npu_dynamic_mx_quant", record_quantize)
+    results = []
+    for _request in range(2):
+        with override_forward_context(ForwardContext()):
+            for step in range(3):
+                set_forward_context_denoise_step_idx(step)
+                output = method.apply(layer, x, layer.bias)
+                torch.npu.synchronize()
+                assert output.shape == (*input_shape[:-1], 128)
+                assert output.dtype == dtype
+                assert torch.isfinite(output).all()
+                results.append(output.cpu())
+    expected_types = [
+        torch_npu.float8_e4m3fn if layers or step in steps else torch_npu.float4_e2m1fn_x2 for step in range(3)
+    ]
+    assert activation_types == expected_types * 2
+    assert (layer.weight.data_ptr(), layer.weight_scale.data_ptr()) == pointers
+    assert not hasattr(layer, "w4a8_weight")
+    assert not hasattr(layer, "w4a8_weight_scale")
+    for first, second in zip(results[:3], results[3:]):
+        torch.testing.assert_close(first, second, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("with_bias", [False, True])
+@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float16])
+@pytest.mark.parametrize("input_shape", [(16, 1024), (2, 8, 1024)])
+@pytest.mark.parametrize("mode", ["single", "single_offline"])
+def test_mxfp4_step_fallback(with_bias, dtype, input_shape, mode, monkeypatch):
+    _exercise_mxfp4_fallback(with_bias, dtype, input_shape, mode, monkeypatch, policy="step")
+
+
+@pytest.mark.cards_1
+@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float16])
+@torch.inference_mode()
+def test_single_scale_step_fallback_matches_independent_dense_reference(dtype):
+    if not torch.npu.is_available() or "Ascend950" not in torch.npu.get_device_name():
+        pytest.skip("MXFP4 kernels require an Ascend950 NPU")
+
+    from vllm_omni.diffusion.forward_context import (
+        ForwardContext,
+        override_forward_context,
+        set_forward_context_denoise_step_idx,
+    )
+    from vllm_omni.quantization.mxfp4_config import (
+        DiffusionMXFP4Config,
+        NPUMxfp4LinearMethod,
+    )
+
+    # Synthetic serialized single-scale values and E8M0 exponent bytes.
+    # Powers of two make both activation precisions exact: this independent
+    # CPU dense oracle needs no production packing, dequantization or apply.
+    # Real UOS-quantized checkpoint validation remains a separate checkpoint/E2E gate.
+    values = torch.tensor([1.0, -1.0, 2.0, -2.0]).repeat(32).unsqueeze(1).expand(128, 512)
+    weight = torch.cat((values, values), dim=1)
+    fine = torch.cat((torch.full((128, 16), 127), torch.full((128, 16), 128)), dim=1).to(torch.uint8)
+    smooth = torch.cat((torch.full((512,), 0.5), torch.full((512,), 2.0)))
+    bias = torch.tensor([0.25, -0.25]).repeat(64)
+    x = torch.tensor([1.0, -1.0, 0.5, -0.5]).repeat(4).unsqueeze(1).expand(16, 1024) / 64
+    expected = torch.nn.functional.linear(x * smooth, torch.cat((values, 2 * values), dim=1), bias)
+
+    layer = torch.nn.Linear(1024, 128, bias=True, device="npu", dtype=dtype)
+    layer.weight.copy_(weight)
+    layer.bias.copy_(bias)
+    layer.orig_dtype = dtype
+    for name, value in {"weight_scale": fine, "mul_scale": smooth}.items():
+        layer.register_parameter(name, torch.nn.Parameter(value.npu(), requires_grad=False))
+    method = NPUMxfp4LinearMethod(
+        DiffusionMXFP4Config(
+            is_checkpoint_mxfp4_serialized=True, require_smooth_scale=True, w4a8_fallback_steps=[1], mxfp4_scale_alg=2
+        )
+    )
+    method.process_weights_after_loading(layer)
+    prepared_pointers = (layer.weight.data_ptr(), layer.weight_scale.data_ptr())
+    assert set(layer.state_dict()) == {"weight", "bias", "weight_scale", "mul_scale"}
+    assert not hasattr(layer, "w4a8_weight")
+    assert not hasattr(layer, "w4a8_weight_scale")
+    x = x.to(device="npu", dtype=dtype)
+
+    with override_forward_context(ForwardContext()):
+        for step in range(3):
+            set_forward_context_denoise_step_idx(step)
+            actual = method.apply(layer, x, layer.bias).cpu()
+            # A8's documented GEMM output is BF16 before restoring the caller
+            # dtype; the reference does not reuse quantization or unpacking.
+            reference = expected.bfloat16().to(dtype) if step == 1 else expected.to(dtype)
+            torch.testing.assert_close(actual, reference, rtol=0, atol=0)
+            assert actual.dtype == dtype
+    assert (layer.weight.data_ptr(), layer.weight_scale.data_ptr()) == prepared_pointers
+
+
+@pytest.mark.cards_1
+@pytest.mark.parametrize("mode", ["single", "single_offline"])
+@pytest.mark.parametrize("policy", ["layer", "layer_and_step"])
+def test_mxfp4_layer_fallback(mode, policy, monkeypatch):
+    """Reuse the kernel/shape/cache assertions without multiplying the full dtype/bias matrix."""
+    _exercise_mxfp4_fallback(False, torch.bfloat16, (16, 1024), mode, monkeypatch, policy=policy)
+
+
+@pytest.mark.cards_1
+@pytest.mark.parametrize("mode", ["single", "single_offline"])
+def test_mxfp4_ocp_compatibility(mode, monkeypatch):
+    """OCP compatibility: A4 -> A8 -> A4 with the same W4 across requests."""
+    _exercise_mxfp4_fallback(False, torch.bfloat16, (16, 1024), mode, monkeypatch, policy="step", scale_alg=0)
diff --git a/tests/platforms/npu/test_moss_tts_codec_npugraph.py b/tests/platforms/npu/test_moss_tts_codec_npugraph.py
new file mode 100644
index 000000000..dee0f5e4d
--- /dev/null
+++ b/tests/platforms/npu/test_moss_tts_codec_npugraph.py
@@ -0,0 +1,205 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Ascend hardware validation for Moss-TTS codec streaming NPUGraph replay.
+
+Mirrors ``test_codec_cudagraph.py`` (non-streaming CUDA wrapper) but exercises
+the streaming :class:`NPUGraphStreamingDecoderWrapper` which captures
+``decode_streaming_tensors`` per ``(B_bucket, exact_T)`` signature.
+
+The synthetic codec is stateless — graph vs eager parity is verified for the
+same inputs.  State management (RingKVCache in-place updates) is covered by
+the E2E integration test (correct audio output confirmed on 910B).
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+import torch.nn as nn
+
+pytest.importorskip("vllm_ascend")
+
+from tests.helpers.mark import hardware_marks
+from vllm_omni.platforms.npu.models.moss_tts_streaming_decode_wrapper import (
+    NPUGraphStreamingDecoderWrapper,
+)
+
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.omni,
+    *hardware_marks(res={"npu": "A3"}, num_cards=1),
+]
+
+DEVICE = torch.device("npu:0")
+NQ = 4
+UPSAMPLE = 4
+HIDDEN = 32
+
+
+class SyntheticStreamingCodec(nn.Module):
+    """Minimal stateless stand-in for MossAudioTokenizerModel streaming decode.
+
+    Exposes ``decode_streaming_tensors`` + ``reset_decoder_state_slots`` with
+    the same interface the NPU wrapper expects.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.downsample_rate = UPSAMPLE
+        self.embed = nn.Conv1d(NQ, HIDDEN, kernel_size=3, padding=1)
+        self.conv = nn.Conv1d(HIDDEN, HIDDEN, kernel_size=3, padding=1)
+        self.up = nn.ConvTranspose1d(HIDDEN, 1, kernel_size=UPSAMPLE, stride=UPSAMPLE)
+
+    def decode_streaming_tensors(self, codes, lengths, slot_ids, valid_rows):
+        """codes [NQ,B,T] lengths [B] slot_ids [B] valid [B] -> audio [B,1,T*up]."""
+        nq, b, t = codes.shape
+        x = codes.permute(1, 0, 2).to(dtype=self.embed.weight.dtype)
+        x = torch.relu(self.embed(x))
+        x = torch.relu(self.conv(x))
+        audio = self.up(x)
+        audio_lengths = lengths * self.downsample_rate
+        return audio, audio_lengths
+
+    def reset_decoder_state_slots(self, slot_ids):
+        pass
+
+
+@pytest.fixture(scope="module")
+def codec():
+    torch.manual_seed(0)
+    return SyntheticStreamingCodec().to(DEVICE).eval()
+
+
+@pytest.fixture(scope="module")
+def wrapper(codec):
+    w = NPUGraphStreamingDecoderWrapper(
+        codec=codec,
+        state_capacity=16,
+        batch_sizes=[1, 2, 4],
+        frame_sizes=[4, 8],
+        num_quantizers=NQ,
+        vllm_config=SimpleNamespace(),
+    )
+    w.warmup(DEVICE)
+    return w
+
+
+def _codes(b, t, device=DEVICE):
+    return torch.randint(0, 64, (NQ, b, t), dtype=torch.long, device=device)
+
+
+def _eager(codec, codes, slot_ids):
+    b = codes.shape[1]
+    t = codes.shape[2]
+    lengths = torch.full((b,), t, dtype=torch.long, device=codes.device)
+    valid = torch.ones(b, dtype=torch.bool, device=codes.device)
+    with torch.no_grad():
+        return codec.decode_streaming_tensors(codes, lengths, slot_ids, valid)
+
+
+# ---------------------------------------------------------------------------
+# 1. Exact-size decode — graph replay must match eager
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("b,t", [(1, 4), (2, 8), (4, 4)])
+def test_exact_size_replay_matches_eager(codec, wrapper, b, t):
+    slots = torch.arange(b, dtype=torch.long, device=DEVICE)
+    codes = _codes(b, t)
+    ref = _eager(codec, codes, slots)
+    with torch.no_grad():
+        out = wrapper.decode(codes, slots)
+    assert out is not None
+    audio, _, actual_b = out
+    assert actual_b == b
+    torch.testing.assert_close(audio[:b], ref[0][:b], atol=1e-3, rtol=1e-3)
+
+
+# ---------------------------------------------------------------------------
+# 2. Padded batch — B < bucket or T < frame_size
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("b,t", [(1, 5), (2, 4), (3, 6)])
+def test_padded_batch_interior_matches(codec, wrapper, b, t):
+    """Padded batches must match eager run on the same padded input.
+
+    The graph wrapper zero-pads codes to the next frame_size bucket.  We run
+    eager on the same padded codes so both paths see identical input.
+    """
+    slots = torch.arange(b, dtype=torch.long, device=DEVICE)
+    codes = _codes(b, t)
+    graph_frame_size = next(fs for fs in wrapper.frame_sizes if fs >= t)
+    padded_codes = torch.zeros(NQ, b, graph_frame_size, dtype=torch.long, device=DEVICE)
+    padded_codes[:, :, :t] = codes
+    lengths = torch.full((b,), t, dtype=torch.long, device=DEVICE)
+    valid = torch.ones(b, dtype=torch.bool, device=DEVICE)
+    with torch.no_grad():
+        ref = codec.decode_streaming_tensors(padded_codes, lengths, slots, valid)
+    with torch.no_grad():
+        out = wrapper.decode(codes, slots, allow_frame_padding=True)
+    assert out is not None
+    audio, audio_lengths, actual_b = out
+    assert actual_b == b
+    expected_len = t * UPSAMPLE
+    for row in range(b):
+        assert int(audio_lengths[row]) == expected_len
+        torch.testing.assert_close(audio[row], ref[0][row], atol=1e-3, rtol=1e-3)
+
+
+# ---------------------------------------------------------------------------
+# 3. Terminal tail — finished request with T < frame_size, padded
+# ---------------------------------------------------------------------------
+
+
+def test_terminal_tail_matches_eager(codec, wrapper):
+    """Terminal tail (T=3 padded to frame_size=4) must match eager on the
+    same padded input."""
+    slots = torch.tensor([0], dtype=torch.long, device=DEVICE)
+    t = 3
+    codes = _codes(1, t)
+    graph_frame_size = next(fs for fs in wrapper.frame_sizes if fs >= t)
+    padded_codes = torch.zeros(NQ, 1, graph_frame_size, dtype=torch.long, device=DEVICE)
+    padded_codes[:, :, :t] = codes
+    lengths = torch.tensor([t], dtype=torch.long, device=DEVICE)
+    valid = torch.ones(1, dtype=torch.bool, device=DEVICE)
+    with torch.no_grad():
+        ref = codec.decode_streaming_tensors(padded_codes, lengths, slots, valid)
+    with torch.no_grad():
+        out = wrapper.decode(codes, slots, allow_frame_padding=True)
+    assert out is not None
+    audio, audio_lengths, _ = out
+    assert int(audio_lengths[0]) == t * UPSAMPLE
+    torch.testing.assert_close(audio[0], ref[0][0], atol=1e-3, rtol=1e-3)
+
+
+# ---------------------------------------------------------------------------
+# 4. Output not aliased across replays (static buffer clone)
+# ---------------------------------------------------------------------------
+
+
+def test_output_not_aliased(codec, wrapper):
+    """wrapper.decode returns cloned audio; a later replay must not overwrite
+    a previously returned tensor."""
+    slot = torch.tensor([0], dtype=torch.long, device=DEVICE)
+    with torch.no_grad():
+        out1 = wrapper.decode(_codes(1, 4), slot)
+        saved = out1[0].clone()
+        out2 = wrapper.decode(_codes(1, 4), slot)
+    assert out1 is not None and out2 is not None
+    torch.testing.assert_close(out1[0], saved, atol=0, rtol=0)
+
+
+# ---------------------------------------------------------------------------
+# 5. Unsupported device returns None (graceful skip)
+# ---------------------------------------------------------------------------
+
+
+def test_unsupported_device_returns_none(wrapper):
+    """decode on a non-NPU tensor must return None (no graph path)."""
+    if not torch.cuda.is_available():
+        pytest.skip("CUDA not available for cross-device test")
+    codes = _codes(1, 4, device=torch.device("cuda:0"))
+    slots = torch.tensor([0], dtype=torch.long, device=codes.device)
+    out = wrapper.decode(codes, slots)
+    assert out is None
diff --git a/tests/platforms/npu/test_npu_prefix_cache_wiring.py b/tests/platforms/npu/test_npu_prefix_cache_wiring.py
new file mode 100644
index 000000000..12cded5ba
--- /dev/null
+++ b/tests/platforms/npu/test_npu_prefix_cache_wiring.py
@@ -0,0 +1,158 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""NPU prefix-cache wiring: save_outputs -> sid -> materialize on CPU.
+
+The NPU runner consumes the prefix cache in eager mode (no CUDA streams) and
+hands the step id across execute_model()/sample_tokens() as the LAST field of
+its positionally-packed ``ExecuteModelState``. Neither path runs in CUDA CI,
+so a hit-read change can silently break them (`vllm_ascend` imports keep the
+runner modules out of reach of a plain unit test).
+
+Two layers of protection, both pure CPU:
+
+1. AST characterization of the ``ExecuteModelState`` field order in the NPU
+   and GPU runners — the pack/unpack sites pass fields positionally, so a
+   reorder or drop of ``prefix_cache_step_id`` corrupts the sid without any
+   import-time error.
+2. The eager-mode facade contract the NPU runner relies on: controller
+   auto-selects eager when CUDA is unavailable, and save -> materialize
+   returns byte-identical rows for both the miss and the hit-merge paths.
+"""
+
+import ast
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.core.prefix_cache.interface import PrefixCacheConfig
+from vllm_omni.core.prefix_cache.manager import OmniPrefixCacheManager
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_REPO_ROOT = Path(__file__).resolve().parents[3]
+_NPU_RUNNER = _REPO_ROOT / "vllm_omni/platforms/npu/worker/npu_ar_model_runner.py"
+_GPU_RUNNER = _REPO_ROOT / "vllm_omni/worker/gpu_ar_model_runner.py"
+
+NUM_BLOCKS = 16
+BLOCK_SIZE = 4
+HIDDEN = 8
+DTYPE = torch.float32
+
+
+def _named_tuple_fields(path: Path, class_name: str) -> list[str]:
+    tree = ast.parse(path.read_text())
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == class_name:
+            return [stmt.target.id for stmt in node.body if isinstance(stmt, ast.AnnAssign)]
+    raise AssertionError(f"{class_name} not found in {path}")
+
+
+def test_execute_model_state_keeps_prefix_cache_sid_last():
+    """Both runners pack ExecuteModelState positionally: the sid must stay
+    the LAST field, and the NPU field order is pinned exactly — a reorder
+    passes import and every CUDA test, then ships the wrong value as the
+    sid on hardware."""
+    npu_fields = _named_tuple_fields(_NPU_RUNNER, "ExecuteModelState")
+    assert npu_fields == [
+        "scheduler_output",
+        "logits",
+        "spec_decode_metadata",
+        "spec_decode_common_attn_metadata",
+        "hidden_states",
+        "sample_hidden_states",
+        "aux_hidden_states",
+        "attn_metadata",
+        "positions",
+        "ec_connector_output",
+        "cudagraph_stats",
+        "batch_desc",
+        "multimodal_outputs",
+        "prefix_cache_step_id",
+    ]
+    gpu_fields = _named_tuple_fields(_GPU_RUNNER, "ExecuteModelState")
+    assert gpu_fields[-1] == "prefix_cache_step_id"
+
+
+class _FakeView:
+    """Minimal group-view double (mirrors tests/core/test_prefix_cache)."""
+
+    def __init__(self):
+        self.block_size = BLOCK_SIZE
+        self.num_blocks = NUM_BLOCKS
+        self.req_blocks: dict[str, list[int]] = {}
+        self.order: list[str] = []
+        self.computed: dict[str, int] = {}
+
+    def slots_for(self, req_id, token_start, token_end):
+        blocks = self.req_blocks[req_id]
+        return torch.tensor(
+            [blocks[p // BLOCK_SIZE] * BLOCK_SIZE + p % BLOCK_SIZE for p in range(token_start, token_end)],
+            dtype=torch.long,
+        )
+
+    def batch_req_ids(self) -> list[str]:
+        return list(self.order)
+
+    def step_slots_cpu(self, req_ids, num_scheduled) -> torch.Tensor:
+        parts = []
+        for r in req_ids:
+            n = int(num_scheduled.get(r, 0))
+            if n > 0:
+                start = self.computed.get(r, 0)
+                parts.append(self.slots_for(r, start, start + n))
+        return torch.cat(parts) if parts else torch.empty((0,), dtype=torch.long)
+
+
+def _run_step(mgr, view, req_id, blocks, start_pos, sched, *, hit=0, finished=()):
+    """One NPU-shaped step: new_step_starts -> save_outputs -> sid."""
+    view.order = [req_id]
+    view.req_blocks[req_id] = blocks
+    view.computed[req_id] = start_pos
+    slots = view.slots_for(req_id, start_pos, start_pos + sched)
+    hidden = slots.to(DTYPE).unsqueeze(1).expand(sched, HIDDEN).clone()
+    sched_out = SimpleNamespace(
+        scheduled_new_reqs=[
+            SimpleNamespace(req_id=req_id, num_computed_tokens=hit, block_ids=[list(blocks)]),
+        ],
+        finished_req_ids=set(finished),
+        num_scheduled_tokens={req_id: sched},
+    )
+    mgr.new_step_starts(sched_out)
+    return mgr.save_outputs(hidden, {}, num_tokens_unpadded=sched, num_tokens_padded=sched)
+
+
+def _expected_rows(slots: torch.Tensor) -> torch.Tensor:
+    return slots.to(DTYPE).unsqueeze(1).expand(slots.numel(), HIDDEN)
+
+
+def _make_npu_mode_manager(monkeypatch) -> tuple[OmniPrefixCacheManager, _FakeView]:
+    # The NPU condition: no CUDA -> the controller must auto-select eager
+    # (submit() completes copy+scatter synchronously), exactly how
+    # npu_model_runner builds the manager with the default eager=None.
+    monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
+    view = _FakeView()
+    config = PrefixCacheConfig(num_blocks=NUM_BLOCKS, block_size=BLOCK_SIZE)
+    return OmniPrefixCacheManager(config, view), view
+
+
+def test_npu_mode_auto_selects_eager_and_roundtrips(monkeypatch):
+    mgr, view = _make_npu_mode_manager(monkeypatch)
+    assert mgr._controller._eager is True
+    sid = _run_step(mgr, view, "a", [0, 1], 0, 8)
+    outs = mgr.materialize(sid, ["a"])
+    assert torch.equal(outs.hidden_states["a"], _expected_rows(view.slots_for("a", 0, 8)))
+
+
+def test_npu_mode_hit_merges_cached_prefix(monkeypatch):
+    """The hit-read path in eager mode: consumer's merged output must be
+    [cached prefix rows + this step's rows], byte-identical."""
+    mgr, view = _make_npu_mode_manager(monkeypatch)
+    s1 = _run_step(mgr, view, "a", [0, 1], 0, 8)
+    mgr.materialize(s1, ["a"])
+    s2 = _run_step(mgr, view, "b", [0, 1, 2], 8, 4, hit=8, finished=["a"])
+    merged = mgr.materialize(s2, ["b"]).hidden_states["b"]
+    assert merged.shape == (12, HIDDEN)
+    assert torch.equal(merged[:8], _expected_rows(view.slots_for("b", 0, 8)))
+    assert torch.equal(merged[8:], _expected_rows(view.slots_for("b", 8, 12)))
diff --git a/tests/protocol/__init__.py b/tests/protocol/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/tests/protocol/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
diff --git a/tests/protocol/duplex/__init__.py b/tests/protocol/duplex/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/tests/protocol/duplex/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
diff --git a/tests/protocol/duplex/test_duplex_protocol_facade.py b/tests/protocol/duplex/test_duplex_protocol_facade.py
new file mode 100644
index 000000000..61dd15fe1
--- /dev/null
+++ b/tests/protocol/duplex/test_duplex_protocol_facade.py
@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``protocol.duplex`` is the only door a duplex consumer uses.
+
+The layering is a chain::
+
+    protocol.realtime  <-  protocol.duplex  <-  engine / entrypoints / clients
+
+The middle link only earns its keep if the last arrow is the *only* one. If the
+engine may also reach past it straight into ``protocol.realtime``, then giving a
+Tier 1 helper a duplex-specific version later means touching every call site
+instead of one file --- which is exactly the change
+``convert_input_audio_with_rate`` is expected to need (it resamples to
+MiniCPM-o's 16 kHz, not the client's rate).
+
+So this asserts two things: nobody skips the middle link, and the middle link is
+complete enough that nobody has to.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+#: Every module that speaks the duplex protocol. These import
+#: ``vllm_omni.protocol.duplex``; reaching into ``vllm_omni.protocol.realtime``
+#: from here skips the extension point.
+CONSUMER_PATHS = (
+    "vllm_omni/engine/duplex",
+    "vllm_omni/engine/duplex_omni_engine.py",
+    "vllm_omni/entrypoints/duplex",
+    "vllm_omni/entrypoints/duplex_omni.py",
+    "vllm_omni/clients/duplex.py",
+    "vllm_omni/clients/inline_duplex.py",
+)
+
+
+def _consumer_modules() -> list[Path]:
+    found: list[Path] = []
+    for entry in CONSUMER_PATHS:
+        path = REPO_ROOT / entry
+        found.extend(sorted(path.rglob("*.py")) if path.is_dir() else [path])
+    assert found, "consumer list is stale"
+    return found
+
+
+@pytest.mark.parametrize("module", _consumer_modules(), ids=lambda p: p.name)
+def test_a_duplex_consumer_does_not_skip_the_duplex_protocol_package(module: Path) -> None:
+    # Source-level, so a lazy import inside a function body is caught too.
+    tree = ast.parse(module.read_text())
+    offenders = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom) and (node.module or "").startswith("vllm_omni.protocol.realtime"):
+            offenders.append(f"line {node.lineno}: from {node.module} import ...")
+        elif isinstance(node, ast.Import):
+            offenders.extend(
+                f"line {node.lineno}: import {alias.name}"
+                for alias in node.names
+                if alias.name.startswith("vllm_omni.protocol.realtime")
+            )
+    assert not offenders, (
+        f"{module.relative_to(REPO_ROOT)} imports the Tier 1 package directly; "
+        f"import from vllm_omni.protocol.duplex instead:\n  " + "\n  ".join(offenders)
+    )
+
+
+def test_the_duplex_package_carries_the_whole_command_vocabulary() -> None:
+    from vllm_omni.engine.duplex import commands as engine_commands
+    from vllm_omni.protocol.duplex import commands as duplex_wire
+
+    # Every command the engine handles is nameable through the one door.
+    engine_names = {
+        name
+        for name in engine_commands.__all__
+        if isinstance(getattr(engine_commands, name), type)
+        and issubclass(getattr(engine_commands, name), engine_commands.DuplexCommand)
+        and getattr(engine_commands, name) is not engine_commands.DuplexCommand
+    }
+    assert engine_names <= set(duplex_wire.__all__)
+
+
+def test_the_duplex_package_carries_the_whole_event_vocabulary() -> None:
+    from vllm_omni.engine.duplex import events as engine_events
+    from vllm_omni.protocol.duplex import events as duplex_wire
+
+    engine_names = {
+        name
+        for name in engine_events.__all__
+        if isinstance(getattr(engine_events, name), type)
+        and issubclass(getattr(engine_events, name), engine_events.DuplexEvent)
+    }
+    assert engine_names <= set(duplex_wire.__all__)
+
+
+@pytest.mark.parametrize(
+    "module_pair",
+    [("events", "events"), ("commands", "commands")],
+    ids=["events", "commands"],
+)
+def test_a_reexported_tier1_name_is_the_tier1_object(module_pair: tuple[str, str]) -> None:
+    """Re-export, not re-declaration: the Tier 1 class is one object."""
+    import importlib
+
+    duplex_mod = importlib.import_module(f"vllm_omni.protocol.duplex.{module_pair[0]}")
+    realtime_mod = importlib.import_module(f"vllm_omni.protocol.realtime.{module_pair[1]}")
+
+    shared = [n for n in duplex_mod.__all__ if hasattr(realtime_mod, n)]
+    assert shared, "nothing re-exported --- the facade is not doing its job"
+    for name in shared:
+        duplex_obj = getattr(duplex_mod, name)
+        realtime_obj = getattr(realtime_mod, name)
+        if duplex_obj is realtime_obj:
+            continue
+        # The only permitted divergence is a Tier 2 class extending its twin.
+        assert isinstance(duplex_obj, type) and issubclass(duplex_obj, realtime_obj), (
+            f"{name} in protocol.duplex is neither the Tier 1 object nor a subclass of it"
+        )
+
+
+def test_duplex_event_is_an_alias_but_duplex_command_is_not() -> None:
+    """The asymmetry is deliberate, and a later reader should not 'fix' it.
+
+    An event has no engine-internal half --- what the session emits is what the
+    socket sends --- so ``DuplexEvent`` is simply ``RealtimeEvent``. A command
+    does: ``payload()`` renders the session runner's mailbox dictionary, and for
+    four of the seventeen the mailbox channel is not even the client event type.
+    """
+    from vllm_omni.engine.duplex.commands import DuplexCommand
+    from vllm_omni.protocol.duplex.events import DuplexEvent
+    from vllm_omni.protocol.realtime.commands import RealtimeCommand
+    from vllm_omni.protocol.realtime.events import RealtimeEvent
+
+    assert DuplexEvent is RealtimeEvent
+
+    assert DuplexCommand is not RealtimeCommand
+    assert issubclass(DuplexCommand, RealtimeCommand)
+    assert hasattr(DuplexCommand, "payload") and not hasattr(RealtimeCommand, "payload")
diff --git a/tests/protocol/realtime/__init__.py b/tests/protocol/realtime/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/tests/protocol/realtime/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
diff --git a/tests/protocol/realtime/test_protocol_import_boundary.py b/tests/protocol/realtime/test_protocol_import_boundary.py
new file mode 100644
index 000000000..a00d4da62
--- /dev/null
+++ b/tests/protocol/realtime/test_protocol_import_boundary.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The shared Realtime codec must not depend on any runtime that uses it.
+
+``vllm_omni.protocol.realtime`` exists so a second Realtime surface can reuse
+the wire codec without adopting the duplex session control plane. That only
+holds while the arrows point one way: the engine, the entrypoints and the model
+code import the protocol, never the reverse. Nothing in the package's own code
+enforces that, so it is asserted here --- once on the source (which catches a
+lazy import inside a function body) and once on a real import (which catches a
+dependency arriving through a third module).
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+PROTOCOL_DIR = REPO_ROOT / "vllm_omni" / "protocol"
+
+#: Packages that consume the protocol. A dependency on any of them would make
+#: the codec unusable outside the runtime it accidentally reached into.
+#: ``vllm_omni.utils`` is deliberately absent: it is leaf helpers (the audio
+#: resampler) that consume nothing, so depending on it costs a reuser nothing.
+FORBIDDEN_PREFIXES = (
+    "vllm_omni.engine",
+    "vllm_omni.entrypoints",
+    "vllm_omni.model_executor",
+    "vllm_omni.worker",
+    "vllm_omni.clients",
+)
+
+
+def _protocol_sources() -> list[Path]:
+    sources = sorted(PROTOCOL_DIR.rglob("*.py"))
+    assert sources, f"no python sources under {PROTOCOL_DIR}"
+    return sources
+
+
+def _imported_modules(source: Path) -> set[str]:
+    """Every module name imported anywhere in the file, lazy imports included."""
+    names: set[str] = set()
+    for node in ast.walk(ast.parse(source.read_text())):
+        if isinstance(node, ast.Import):
+            names.update(alias.name for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module:
+            names.add(node.module)
+    return names
+
+
+@pytest.mark.parametrize("source", _protocol_sources(), ids=lambda path: path.name)
+def test_protocol_sources_do_not_import_a_consumer(source: Path) -> None:
+    offenders = sorted(
+        name
+        for name in _imported_modules(source)
+        if any(name == prefix or name.startswith(prefix + ".") for prefix in FORBIDDEN_PREFIXES)
+    )
+    assert not offenders, f"{source.relative_to(REPO_ROOT)} imports {', '.join(offenders)}"
+
+
+def test_importing_the_protocol_package_loads_no_consumer() -> None:
+    # A child interpreter, because this test session has already imported the
+    # duplex engine: only a fresh process can tell what the package pulls in.
+    # ``vllm_omni`` itself is imported first, because its ``__init__`` loads a
+    # baseline graph (patches, the model registry) that has nothing to do with
+    # this package; only what the protocol import *adds* is measured.
+    env = os.environ.copy()
+    env.pop("CUDA_VISIBLE_DEVICES", None)
+    env.pop("HIP_VISIBLE_DEVICES", None)
+    script = f"""
+import sys
+
+import vllm_omni  # noqa: F401
+
+baseline = set(sys.modules)
+
+import vllm_omni.protocol.realtime  # noqa: F401
+
+forbidden_prefixes = {FORBIDDEN_PREFIXES!r}
+added = sorted(
+    name
+    for name in set(sys.modules) - baseline
+    if any(name == prefix or name.startswith(prefix + ".") for prefix in forbidden_prefixes)
+)
+if added:
+    raise SystemExit("the realtime protocol package loaded consumers: " + ", ".join(added))
+"""
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=REPO_ROOT,
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=180,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr
diff --git a/tests/protocol/realtime/test_realtime_capabilities.py b/tests/protocol/realtime/test_realtime_capabilities.py
new file mode 100644
index 000000000..2a05fc0a9
--- /dev/null
+++ b/tests/protocol/realtime/test_realtime_capabilities.py
@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``RealtimeProtocolCapabilities``: one consumer's answers, the codec's checking.
+
+This is the seam that lets a non-duplex Realtime surface validate a
+``session.update`` without a ``DuplexModelPlugin``. What it has to get right is
+narrow: the order the checks run in (formats before turn detection, because
+that is the order clients already see), the error codes, and that a consumer
+which declares a narrower format set is actually narrowed.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+import pytest
+
+from vllm_omni.protocol.realtime.capabilities import (
+    RealtimeProtocolCapabilities,
+    RealtimeSessionRejection,
+    validate_session_payload,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_DEFAULT = RealtimeProtocolCapabilities()
+
+
+def test_a_consumer_without_a_turn_detection_check_accepts_a_plain_session():
+    assert (
+        validate_session_payload({"model": "m", "audio": {"input": {"format": "pcm16"}}}, capabilities=_DEFAULT) is None
+    )
+
+
+def test_a_consumer_without_a_turn_detection_check_ignores_turn_detection():
+    payload = {"turn_detection": {"type": "semantic_vad"}}
+
+    assert validate_session_payload(payload, capabilities=_DEFAULT) is None
+
+
+def test_an_unsupported_input_format_is_rejected_with_the_realtime_code():
+    rejection = validate_session_payload({"input_audio_format": "opus"}, capabilities=_DEFAULT)
+
+    assert rejection == RealtimeSessionRejection(
+        code="unsupported_audio_format", message="Unsupported input_audio_format: opus"
+    )
+
+
+def test_a_consumer_may_declare_a_narrower_format_set():
+    pcm_only = RealtimeProtocolCapabilities(input_audio_formats=frozenset({"pcm16"}))
+
+    assert validate_session_payload({"input_audio_format": "pcm16"}, capabilities=pcm_only) is None
+    rejection = validate_session_payload({"input_audio_format": "g711_ulaw"}, capabilities=pcm_only)
+    assert rejection is not None
+    assert rejection.code == "unsupported_audio_format"
+    # The default capabilities still accept it: the narrowing is per consumer.
+    assert validate_session_payload({"input_audio_format": "g711_ulaw"}, capabilities=_DEFAULT) is None
+
+
+def test_the_turn_detection_check_runs_and_reports_its_own_code():
+    def reject_everything(session_payload: Mapping[str, object]) -> str | None:
+        del session_payload
+        return "server_vad is not available"
+
+    capabilities = RealtimeProtocolCapabilities(validate_turn_detection=reject_everything)
+
+    rejection = validate_session_payload({"turn_detection": {"type": "server_vad"}}, capabilities=capabilities)
+
+    assert rejection == RealtimeSessionRejection(
+        code="unsupported_turn_detection", message="server_vad is not available", param="turn_detection"
+    )
+
+
+def test_a_bad_format_is_reported_before_a_bad_turn_detection():
+    calls: list[Mapping[str, object]] = []
+
+    def record(session_payload: Mapping[str, object]) -> str | None:
+        calls.append(session_payload)
+        return "turn detection is wrong too"
+
+    capabilities = RealtimeProtocolCapabilities(validate_turn_detection=record)
+
+    rejection = validate_session_payload(
+        {"input_audio_format": "opus", "turn_detection": {"type": "semantic_vad"}},
+        capabilities=capabilities,
+    )
+
+    assert rejection is not None
+    assert rejection.code == "unsupported_audio_format"
+    assert calls == []
diff --git a/tests/protocol/realtime/test_realtime_codec_single_source.py b/tests/protocol/realtime/test_realtime_codec_single_source.py
new file mode 100644
index 000000000..2f719750b
--- /dev/null
+++ b/tests/protocol/realtime/test_realtime_codec_single_source.py
@@ -0,0 +1,256 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""There is one Realtime codec, and the duplex engine uses it.
+
+RFC #6592 P0a rejects the "copy the codec and fix it up" option because the two
+copies drift. The extraction is only worth anything while the duplex names are
+*the same objects* as the protocol ones, not lookalikes --- so assert identity,
+which a re-implementation cannot satisfy.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+import pytest
+
+from vllm_omni.engine.duplex import audio as duplex_audio
+from vllm_omni.engine.duplex import events as duplex_events
+from vllm_omni.engine.duplex import realtime_commands as duplex_codec
+from vllm_omni.engine.duplex.commands import DuplexCommandError
+from vllm_omni.protocol import realtime as protocol
+from vllm_omni.protocol.realtime.errors import RealtimeProtocolError
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+#: Names ``engine.duplex.realtime_commands`` re-exports for its existing importers.
+_REEXPORTED_FROM_PROTOCOL = (
+    "REALTIME_INPUT_AUDIO_FORMATS",
+    "REALTIME_INPUT_HINT_KEYS",
+    "REALTIME_OUTPUT_AUDIO_FORMATS",
+    "RealtimeInputDefaults",
+    "apply_realtime_session_defaults",
+    "copy_realtime_input_hints",
+    "input_audio_transcription_config",
+    "input_explicitly_non_speech",
+    "input_looks_like_speech",
+    "input_transcript_from_item",
+    "is_supported_realtime_input_format",
+    "json_safe_realtime_payload",
+    "normalize_conversation_item",
+    "parse_realtime_audio_format",
+    "realtime_audio_format_object",
+    "realtime_max_output_tokens",
+    "realtime_output_format",
+    "realtime_overlap_fields",
+    "text_chars_for_audio_ms_from_marks",
+    "truncate_realtime_item_content",
+    "validate_conversation_item_audio_formats",
+    "validate_realtime_item_truncate",
+    "validate_realtime_response_audio_formats",
+    "validate_realtime_session_audio_formats",
+    "validate_realtime_video_frames",
+)
+
+
+@pytest.mark.parametrize("name", _REEXPORTED_FROM_PROTOCOL)
+def test_the_duplex_codec_name_is_the_protocol_object(name: str) -> None:
+    assert getattr(duplex_codec, name) is getattr(protocol, name)
+
+
+@pytest.mark.parametrize(
+    "name",
+    ("convert_input_audio_with_rate", "convert_output_audio", "resample_pcm16_mono", "wav_payload_to_pcm16"),
+)
+def test_the_duplex_audio_shim_is_the_protocol_object(name: str) -> None:
+    assert getattr(duplex_audio, name) is getattr(protocol, name)
+
+
+def test_a_duplex_command_error_is_a_realtime_protocol_error() -> None:
+    # The duplex binding converts the codec's error into its own type; both
+    # carry the same code/event_id, which is what the error envelope renders.
+    error = DuplexCommandError("bad", code="bad_audio", event_id="event_1")
+
+    assert isinstance(error, RealtimeProtocolError)
+    assert (error.code, error.event_id) == ("bad_audio", "event_1")
+
+
+def test_the_duplex_append_command_is_built_from_the_shared_decoder() -> None:
+    defaults = protocol.RealtimeInputDefaults()
+    event = {"event_id": "event_1", "audio": "", "format": "pcm16", "duration_ms": 40}
+
+    decoded = protocol.decode_audio_append(event, defaults=defaults)
+    command = duplex_codec.build_append_audio(event, defaults=defaults)
+
+    assert (command.audio, command.format, command.sample_rate_hz) == (
+        decoded.audio,
+        decoded.format,
+        decoded.sample_rate_hz,
+    )
+    assert (command.is_speech, command.video_frames, command.duration_ms) == (
+        decoded.is_speech,
+        decoded.video_frames,
+        decoded.duration_ms,
+    )
+    assert (command.audio_end_ms, dict(command.hints), command.event_id) == (
+        decoded.audio_end_ms,
+        decoded.hints,
+        decoded.event_id,
+    )
+
+
+def test_the_shared_decoder_error_reaches_the_client_as_a_duplex_command_error() -> None:
+    defaults = protocol.RealtimeInputDefaults()
+    event = {"event_id": "event_1", "audio": "AAAA", "format": "opus"}
+
+    with pytest.raises(RealtimeProtocolError) as shared:
+        protocol.decode_audio_append(event, defaults=defaults)
+    with pytest.raises(DuplexCommandError) as duplex:
+        duplex_codec.build_append_audio(event, defaults=defaults)
+
+    assert (duplex.value.code, str(duplex.value)) == (shared.value.code, str(shared.value))
+    assert duplex.value.event_id == shared.value.event_id == "event_1"
+
+
+def test_the_duplex_capabilities_reject_unimplemented_turn_detection() -> None:
+    # The duplex answer comes from engine.duplex.turn_detection, reached through
+    # the capability object rather than imported by the codec.
+    rejection = protocol.validate_session_payload(
+        {"turn_detection": {"type": "semantic_vad"}},
+        capabilities=duplex_codec.DUPLEX_REALTIME_CAPABILITIES,
+    )
+
+    assert rejection is not None
+    assert rejection.code == "unsupported_turn_detection"
+
+
+# ---- the class split (RFC #6592 P0a, second half) ----
+#
+# The event and command classes moved out of the engine too. The same identity
+# rule applies: the duplex names must BE the protocol objects, and the mailbox
+# half must have stayed behind.
+
+# `docs/serving/realtime_duplex_api.md` sorts every message into three tiers.
+# Tier 1 is pure OpenAI and lives in protocol/realtime; Tier 2 (OpenAI names
+# carrying our extensions) and Tier 3 (ours alone) live in protocol/duplex.
+_TIER1_EVENTS = ("SessionUpdated", "ItemAdded", "ItemCreated", "TextDelta", "OutputItemAdded")
+_TIER2_EVENTS = (
+    "SessionCreated",
+    "ResponseCreated",
+    "ResponseDone",
+    "AudioDelta",
+    "InputCommitted",
+    "ItemDeleted",
+    "ItemTruncated",
+    "ErrorEvent",
+)
+_TIER3_EVENTS = ("Listen", "Speak", "OverlapDecision", "PlaybackAcknowledged", "SessionResumed")
+_TIER1_COMMANDS = ("UpdateSession", "CreateItem", "CancelResponse", "ClearInput")
+_TIER2_COMMANDS = ("AppendAudio", "Commit")
+_TIER3_COMMANDS = ("BargeIn", "AckPlayback", "Heartbeat", "SignalTurn", "CloseSession")
+
+
+@pytest.mark.parametrize("name", _TIER1_EVENTS)
+def test_tier1_events_are_the_pure_openai_objects(name: str) -> None:
+    from vllm_omni.protocol.realtime import events as realtime_events
+
+    assert duplex_events.__dict__[name] is getattr(realtime_events, name)
+
+
+@pytest.mark.parametrize("name", _TIER2_EVENTS + _TIER3_EVENTS)
+def test_tier2_and_tier3_events_come_from_protocol_duplex(name: str) -> None:
+    from vllm_omni.protocol.duplex import events as duplex_wire_events
+
+    assert duplex_events.__dict__[name] is getattr(duplex_wire_events, name)
+
+
+@pytest.mark.parametrize("name", _TIER2_EVENTS)
+def test_tier2_extends_its_tier1_twin_rather_than_replacing_it(name: str) -> None:
+    """A Tier 2 class must be its Tier 1 class plus fields, never a fork of it."""
+    from vllm_omni.protocol.duplex import events as duplex_wire_events
+    from vllm_omni.protocol.realtime import events as realtime_events
+
+    tier1 = getattr(realtime_events, name)
+    tier2 = getattr(duplex_wire_events, name)
+
+    assert issubclass(tier2, tier1)
+    assert tier2.wire_type == tier1.wire_type
+    tier1_fields = {f.name for f in dataclasses.fields(tier1)}
+    tier2_fields = {f.name for f in dataclasses.fields(tier2)}
+    # Purely additive: Tier 2 adds, never drops or renames.
+    assert tier1_fields < tier2_fields
+
+
+@pytest.mark.parametrize("name", _TIER1_EVENTS + _TIER1_COMMANDS)
+def test_tier1_carries_no_vllm_omni_extension_fields(name: str) -> None:
+    """The point of the split: protocol/realtime must be honestly pure OpenAI."""
+    from vllm_omni.protocol.realtime import commands as realtime_commands
+    from vllm_omni.protocol.realtime import events as realtime_events
+
+    cls = getattr(realtime_events, name, None) or getattr(realtime_commands, name)
+    fields = {f.name for f in dataclasses.fields(cls)}
+    # Extension fields catalogued as Tier 2 in the serving doc.
+    assert not (
+        fields
+        & {
+            "attachment_generation",
+            "resume_token",
+            "details",
+            "extra",
+            "is_speech",
+            "video_frames",
+            "hints",
+            "realtime_item_id",
+        }
+    )
+
+
+def test_the_error_code_vocabulary_is_tier3() -> None:
+    """OpenAI standardises the error classes, not our codes (doc: Tier 3)."""
+    from vllm_omni.protocol.duplex.errors import REALTIME_ERROR_TYPES_BY_CODE
+    from vllm_omni.protocol.realtime import errors as realtime_errors
+
+    assert duplex_events.REALTIME_ERROR_TYPES_BY_CODE is REALTIME_ERROR_TYPES_BY_CODE
+    assert not hasattr(realtime_errors, "REALTIME_ERROR_TYPES_BY_CODE")
+
+
+def test_the_tier1_error_event_reports_only_openai_classes() -> None:
+    from vllm_omni.protocol.duplex import events as duplex_wire_events
+    from vllm_omni.protocol.realtime import events as realtime_events
+
+    # Tier 1 knows the envelope shape but not our code vocabulary.
+    assert realtime_events.ErrorEvent(code="resource_exhausted").error_type == "invalid_request_error"
+    # Tier 2 resolves it through our table.
+    assert duplex_wire_events.ErrorEvent(code="resource_exhausted").error_type == "rate_limit_error"
+
+
+@pytest.mark.parametrize("name", _TIER1_COMMANDS + _TIER2_COMMANDS + _TIER3_COMMANDS)
+def test_engine_commands_subclass_their_protocol_wire_type(name: str) -> None:
+    from vllm_omni.engine.duplex import commands as engine_commands
+    from vllm_omni.protocol.duplex import commands as duplex_wire_commands
+    from vllm_omni.protocol.realtime import commands as realtime_commands
+
+    engine_cls = getattr(engine_commands, name)
+    wire_cls = getattr(duplex_wire_commands, name, None) or getattr(realtime_commands, name)
+
+    assert issubclass(engine_cls, wire_cls)
+    assert engine_cls.wire_type == wire_cls.wire_type
+
+
+def test_the_mailbox_channel_stayed_engine_side() -> None:
+    """``payload()``'s ``type`` is the runner's channel, not the client event.
+
+    These four are the proof that the two halves are genuinely different, and
+    so the reason the classes were split rather than relocated wholesale.
+    """
+    from vllm_omni.engine.duplex import commands as engine_commands
+    from vllm_omni.protocol.realtime import commands as realtime_commands
+
+    for name in ("UpdateSession", "CreateItem", "DeleteItem", "TruncateItem"):
+        engine_cls = getattr(engine_commands, name)
+        wire_cls = getattr(realtime_commands, name)
+        assert engine_cls.type == "turn.signal"
+        assert wire_cls.wire_type != "turn.signal"
+        # The wire class carries no mailbox vocabulary at all.
+        assert "type" not in vars(wire_cls)
diff --git a/tests/worker/test_fa3_scheduler_metadata_size.py b/tests/worker/test_fa3_scheduler_metadata_size.py
index 5e308bed7..ac7d1a752 100644
--- a/tests/worker/test_fa3_scheduler_metadata_size.py
+++ b/tests/worker/test_fa3_scheduler_metadata_size.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Characterization of ``OmniGPUModelRunner.initialize_metadata_builders``.
 
 Upstream ``FlashAttentionMetadataBuilder`` pre-allocates ``scheduler_metadata``
@@ -19,14 +19,12 @@ from types import SimpleNamespace
 
 import pytest
 import torch
+from vllm.v1.worker.gpu_model_runner import GPUModelRunner
 
 from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
-# The class ``super().initialize_metadata_builders`` dispatches to.
-_UPSTREAM_RUNNER = OmniGPUModelRunner.__mro__[1]
-
 
 def _builder(*, prealloc: int | None, max_num_splits: int) -> SimpleNamespace:
     sm = None if prealloc is None else torch.zeros(prealloc, dtype=torch.int32)
@@ -36,10 +34,14 @@ def _builder(*, prealloc: int | None, max_num_splits: int) -> SimpleNamespace:
 def _make_runner(monkeypatch, *, max_num_seqs: int, builders: list) -> OmniGPUModelRunner:
     # Stub the upstream initialize_metadata_builders; our fake runner already
     # carries the attn_groups the Omni override iterates over.
-    monkeypatch.setattr(_UPSTREAM_RUNNER, "initialize_metadata_builders", lambda self, *a, **k: None)
+    monkeypatch.setattr(GPUModelRunner, "initialize_metadata_builders", lambda self, *a, **k: None)
     runner = object.__new__(OmniGPUModelRunner)
     runner.scheduler_config = SimpleNamespace(max_num_seqs=max_num_seqs)
     runner.cache_config = SimpleNamespace(enable_prefix_caching=False)  # skip omni_prefix_cache branch
+    runner.vllm_config = SimpleNamespace(kv_transfer_config=None)
+    runner.model_config = SimpleNamespace()
+    runner.is_pooling_model = False
+    runner.speculative_config = None
     runner.attn_groups = [[SimpleNamespace(metadata_builders=builders)]]
     return runner
 
diff --git a/tests/worker/test_gpu_ar_model_runner.py b/tests/worker/test_gpu_ar_model_runner.py
index 33abbb618..d09282035 100644
--- a/tests/worker/test_gpu_ar_model_runner.py
+++ b/tests/worker/test_gpu_ar_model_runner.py
@@ -18,6 +18,7 @@ from vllm.sampling_params import SamplingParams
 from vllm.v1.worker import gpu_input_batch
 from vllm.v1.worker.gpu_input_batch import CachedRequestState, InputBatch
 
+from vllm_omni.core.prefix_cache import ModelCachePolicy
 from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
 from vllm_omni.entrypoints.openai.serving_speech import OmniOpenAIServingSpeech
 from vllm_omni.entrypoints.openai.tts_adapters.base import PreparedRequest
@@ -37,6 +38,8 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 def _make_runner(engine_output_type: str | None, downstream_req_ids: set[str]) -> GPUARModelRunner:
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.vllm_config = SimpleNamespace(
         model_config=SimpleNamespace(engine_output_type=engine_output_type),
     )
@@ -57,6 +60,8 @@ def _mtp_runner(*, async_scheduling: bool, buffers: dict[str, dict]) -> tuple[GP
         return torch.tensor([[11, 12, 13]], dtype=torch.long)
 
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.use_async_scheduling = async_scheduling
     runner.model = SimpleNamespace(post_sample_talker_mtp=post_sample_talker_mtp)
     runner.requests = {req_id: SimpleNamespace() for req_id in buffers}
@@ -143,6 +148,8 @@ def test_post_sample_talker_mtp_uses_gpu_token_with_async_scheduling() -> None:
 
 def test_post_sample_talker_mtp_skips_shape_validation_without_duplex_rows() -> None:
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.use_async_scheduling = False
     runner.model = SimpleNamespace(
         post_sample_talker_mtp=lambda **_: pytest.fail("hook must not run"),
@@ -178,6 +185,8 @@ def test_post_sample_talker_mtp_rejects_invalid_selected_token_shape(
     error_match: str,
 ) -> None:
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.use_async_scheduling = False
     runner.model = SimpleNamespace(
         post_sample_talker_mtp=lambda **_: pytest.fail("hook must not run"),
@@ -265,6 +274,8 @@ def test_speech_extra_params_reach_model_sampler_as_sampling_metadata(monkeypatc
 
     received = []
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.input_batch = input_batch
     runner.model = SimpleNamespace(
         prefer_model_sampler=True,
@@ -323,6 +334,8 @@ def test_sparse_mm_req_ids_requires_sparse_audio_marker():
 
 def test_runner_assisted_full_attention_metadata_request_is_opt_in():
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.model = object()
     runner.scheduler_config = SimpleNamespace(max_num_seqs=16)
 
@@ -377,6 +390,8 @@ def test_runner_assisted_full_attention_metadata_request_and_context_hooks():
             calls.append(("context", {"enabled": enabled, "num_reqs": num_reqs}))
 
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.model = Model()
     runner.scheduler_config = SimpleNamespace(max_num_seqs=8)
 
@@ -466,6 +481,8 @@ def test_omni_async_gpu_model_runner_output_reraises_background_exception():
 
 def _make_async_output_runner(engine_output_type: str = "audio"):
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     model_config = SimpleNamespace(
         engine_output_type=engine_output_type,
         async_chunk=True,
@@ -642,10 +659,11 @@ def test_async_omni_output_guard_requires_safe_conditions():
 
     assert GPUARModelRunner._should_use_async_omni_output(runner)
 
+    # Prefix cache no longer forces the sync output path; leftover mm is
+    # snapshotted at save so the builder can materialize a step late.
     runner.omni_prefix_cache = object()
-    assert not GPUARModelRunner._should_use_async_omni_output(runner)
+    assert GPUARModelRunner._should_use_async_omni_output(runner)
 
-    runner.omni_prefix_cache = None
     runner.model.has_postprocess = True
     assert not GPUARModelRunner._should_use_async_omni_output(runner)
 
@@ -656,6 +674,7 @@ def test_async_omni_output_guard_requires_safe_conditions():
 def test_build_omni_output_skips_hidden_when_model_opts_out(monkeypatch):
     runner = _make_async_output_runner(engine_output_type="latent")
     runner.model.omni_pooler_payload_include_hidden = False
+    runner._pooler_payload_include_hidden_flag = False
 
     monkeypatch.setattr(
         GPUARModelRunner,
@@ -699,6 +718,7 @@ def test_build_omni_output_skips_hidden_when_model_opts_out(monkeypatch):
 def test_build_omni_output_splits_mm_by_scheduled_tokens_when_hidden_is_tail_only(monkeypatch):
     runner = _make_async_output_runner(engine_output_type="latent")
     runner.model.omni_pooler_payload_include_hidden = False
+    runner._pooler_payload_include_hidden_flag = False
     runner._async_chunk = False
     runner.requests = {"r1": object(), "r2": object(), "r3": object()}
 
@@ -745,6 +765,7 @@ def test_build_omni_output_splits_mm_by_hidden_len_when_scheduled_is_padded(monk
     """Thinker mm rows align to hidden_states.shape[0], not padded scheduled count."""
     runner = _make_async_output_runner(engine_output_type="latent")
     runner.model.omni_pooler_payload_include_hidden = False
+    runner._pooler_payload_include_hidden_flag = False
     runner._async_chunk = False
     runner.requests = {"r1": object(), "r2": object(), "r3": object()}
 
@@ -790,6 +811,7 @@ def test_build_omni_output_splits_mm_by_hidden_len_when_scheduled_is_padded(monk
 def test_async_snapshot_payload_omits_hidden_when_model_opts_out():
     runner = _make_async_output_runner()
     runner.model.omni_pooler_payload_include_hidden = False
+    runner._pooler_payload_include_hidden_flag = False
 
     payload = GPUARModelRunner._build_omni_async_snapshot_payload(
         runner,
@@ -819,6 +841,8 @@ def test_runner_assisted_full_attention_metadata_refresh_pads_buffers():
             self.commits.append(num_reqs_padded)
 
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     block_table = BlockTable()
     runner.input_batch = SimpleNamespace(
         num_computed_tokens_cpu=torch.tensor([10, 20, 99, 99], dtype=torch.int32),
@@ -846,6 +870,8 @@ def test_runner_assisted_full_attention_metadata_refresh_pads_buffers():
 @pytest.mark.parametrize("query_start_loc_attr", ["method", "tensor_attr"])
 def test_sample_tokens_tail_only_prefix_cache_uses_staged_cpu_hidden_states(monkeypatch, query_start_loc_attr):
     runner = object.__new__(GPUARModelRunner)
+    runner._omni_cache_policy = ModelCachePolicy(needs_full_hidden_states=True)
+    runner._pooler_payload_include_hidden_flag = True
     runner.execute_model_state = ExecuteModelState(
         SimpleNamespace(
             total_num_scheduled_tokens=3,
@@ -908,12 +934,11 @@ def test_sample_tokens_tail_only_prefix_cache_uses_staged_cpu_hidden_states(monk
     )
     monkeypatch.setattr(GPUARModelRunner, "eplb_step", lambda self: None)
     monkeypatch.setattr(GPUARModelRunner, "_resolve_pooler_payload_req_ids", lambda self, req_ids: ("audio", req_ids))
-    monkeypatch.setattr(GPUARModelRunner, "_deferred_prefix_cache_mm_keys", lambda self: set())
     monkeypatch.setattr(GPUARModelRunner, "_model_needs_full_prefix_hidden_states", lambda self: False)
     monkeypatch.setattr(
         GPUARModelRunner,
-        "_maybe_get_combined_prefix_cache_tensors",
-        lambda *args, **kwargs: (None, None),
+        "_prepare_prefix_cache_pooler_payload_sources",
+        lambda self, **kwargs: (kwargs["staged_hidden_states_cpu"], None, None),
     )
     monkeypatch.setattr(GPUARModelRunner, "_process_additional_information_updates", lambda *args, **kwargs: None)
     monkeypatch.setattr(GPUARModelRunner, "_should_accumulate_full_payload_output", lambda self: False)
@@ -946,8 +971,6 @@ def test_build_omni_output_falls_back_to_mm_cpu_without_prefix_merge(monkeypatch
         lambda self, req_ids: ("latent", req_ids),
     )
     monkeypatch.setattr(GPUARModelRunner, "_model_needs_full_prefix_hidden_states", lambda self: False)
-    monkeypatch.setattr(GPUARModelRunner, "_deferred_prefix_cache_mm_keys", lambda self: {"codes.audio"})
-    monkeypatch.setattr(GPUARModelRunner, "_stage_deferred_prefix_cache_mm_outputs", lambda *args, **kwargs: None)
     monkeypatch.setattr(
         GPUARModelRunner,
         "_prepare_prefix_cache_pooler_payload_sources",
@@ -1095,8 +1118,6 @@ def test_build_omni_output_filters_multimodal_by_partial_downstream_batch(monkey
         lambda self, req_ids: ("latent", ["r1", "r3"]),
     )
     monkeypatch.setattr(GPUARModelRunner, "_model_needs_full_prefix_hidden_states", lambda self: False)
-    monkeypatch.setattr(GPUARModelRunner, "_deferred_prefix_cache_mm_keys", lambda self: {"codes.audio"})
-    monkeypatch.setattr(GPUARModelRunner, "_stage_deferred_prefix_cache_mm_outputs", lambda *args, **kwargs: None)
     monkeypatch.setattr(
         GPUARModelRunner,
         "_prepare_prefix_cache_pooler_payload_sources",
@@ -1172,8 +1193,6 @@ def test_build_omni_output_uses_combined_prefix_cache_mm_payload_for_partial_dow
         lambda self, req_ids: ("latent", ["r1", "r3"]),
     )
     monkeypatch.setattr(GPUARModelRunner, "_model_needs_full_prefix_hidden_states", lambda self: False)
-    monkeypatch.setattr(GPUARModelRunner, "_deferred_prefix_cache_mm_keys", lambda self: {"codes.audio"})
-    monkeypatch.setattr(GPUARModelRunner, "_stage_deferred_prefix_cache_mm_outputs", lambda *args, **kwargs: None)
     monkeypatch.setattr(
         GPUARModelRunner,
         "_prepare_prefix_cache_pooler_payload_sources",
diff --git a/tests/worker/test_min_tokens_stop_ids_guard.py b/tests/worker/test_min_tokens_stop_ids_guard.py
index 5d7591c99..a99e74b7d 100644
--- a/tests/worker/test_min_tokens_stop_ids_guard.py
+++ b/tests/worker/test_min_tokens_stop_ids_guard.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Guard against out-of-vocabulary stop ids in min-tokens masking (#4962).
 
 vLLM's input processor folds the stage tokenizer's EOS id into
@@ -19,7 +19,7 @@ from vllm.v1.sample.logits_processor import (
     MinTokensLogitsProcessor,
 )
 
-from vllm_omni.worker.sampling_utils import sanitize_min_tokens_stop_ids
+from vllm_omni.worker.sampling_utils import sanitize_min_tokens_stop_ids, sanitize_sampling_params_min_tokens_stop_ids
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -28,6 +28,12 @@ CODEC_EOS = 2150
 TEXT_EOS = 151645
 
 
+@pytest.fixture(autouse=True)
+def _disable_vllm_pin_memory_for_cpu(monkeypatch: pytest.MonkeyPatch):
+    """Keep the module-level H2D helper in CPU-only mode."""
+    monkeypatch.setattr("vllm.utils.torch_utils.PIN_MEMORY", False)
+
+
 def _make_min_tokens_proc(stop_token_ids: list[int], eos_token_id: int | None) -> MinTokensLogitsProcessor:
     """Build a MinTokensLogitsProcessor with one active request, mirroring
     the production path (engine folds the tokenizer EOS via
@@ -113,3 +119,14 @@ def test_guard_handles_multiple_requests():
     assert out[0, CODEC_EOS] == -float("inf")
     assert out[1, 7] == -float("inf")
     assert int((out == -float("inf")).sum()) == 2
+
+
+def test_sampling_params_guard_filters_only_unreachable_min_tokens_ids():
+    params = SamplingParams(min_tokens=2, stop_token_ids=[CODEC_EOS])
+    params.update_from_generation_config({}, TEXT_EOS)
+
+    sanitize_sampling_params_min_tokens_stop_ids(params, TALKER_VOCAB)
+
+    assert params.all_stop_token_ids == {CODEC_EOS}
+    assert params.stop_token_ids == [CODEC_EOS]
+    assert params.eos_token_id == TEXT_EOS
diff --git a/tests/worker/test_model_sampler_extra_args.py b/tests/worker/test_model_sampler_extra_args.py
new file mode 100644
index 000000000..3c996331e
--- /dev/null
+++ b/tests/worker/test_model_sampler_extra_args.py
@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for per-request model sampler arguments.
+
+Custom model samplers that set ``model_sampler_wants_extra_args = True``
+(e.g. HunyuanImage3's per-request ``ar_task_mode``, #6088) receive one
+``SamplingParams.extra_args`` entry per batch row, in ``input_batch.req_ids``
+order — the same order ``_build_model_sampler_output_token_ids`` uses. Pure CPU.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.worker.sampling_utils import build_model_sampler_extra_args, call_model_sampler
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _state(extra_args):
+    return SimpleNamespace(sampling_params=SimpleNamespace(extra_args=extra_args))
+
+
+def test_row_order_follows_req_ids():
+    input_batch = SimpleNamespace(req_ids=["b", "a"])
+    requests = {
+        "a": _state({"ar_task_mode": "comprehension"}),
+        "b": _state(None),
+    }
+    assert build_model_sampler_extra_args(input_batch, requests) == [None, {"ar_task_mode": "comprehension"}]
+
+
+def test_missing_request_state_yields_none():
+    assert build_model_sampler_extra_args(SimpleNamespace(req_ids=["gone"]), {}) == [None]
+
+
+def test_request_without_sampling_params_yields_none():
+    input_batch = SimpleNamespace(req_ids=["r0"])
+    assert build_model_sampler_extra_args(input_batch, {"r0": SimpleNamespace(sampling_params=None)}) == [None]
+
+
+def test_empty_batch():
+    assert build_model_sampler_extra_args(SimpleNamespace(req_ids=[]), {}) == []
+
+
+def test_opted_in_sampler_receives_per_request_extra_args(mocker):
+    model = SimpleNamespace(model_sampler_wants_extra_args=True)
+    model_sample = mocker.Mock(return_value="sampled")
+    input_batch = SimpleNamespace(req_ids=["a", "b"])
+    logits = torch.empty(0)
+    metadata = SimpleNamespace()
+    requests = {
+        "a": _state(None),
+        "b": _state({"ar_task_mode": "comprehension"}),
+    }
+
+    result = call_model_sampler(
+        model,
+        model_sample,
+        logits,
+        metadata,
+        input_batch=input_batch,
+        requests=requests,
+    )
+
+    assert result == "sampled"
+    model_sample.assert_called_once_with(
+        logits,
+        metadata,
+        per_req_extra_args=[None, {"ar_task_mode": "comprehension"}],
+    )
+
+
+def test_non_opted_in_sampler_keeps_two_argument_contract(mocker):
+    model = SimpleNamespace(model_sampler_wants_extra_args=False)
+    model_sample = mocker.Mock(return_value="sampled")
+    logits = torch.empty(0)
+    metadata = SimpleNamespace()
+
+    result = call_model_sampler(
+        model,
+        model_sample,
+        logits,
+        metadata,
+        input_batch=SimpleNamespace(req_ids=["a"]),
+        requests={"a": _state({"ar_task_mode": "comprehension"})},
+    )
+
+    assert result == "sampled"
+    model_sample.assert_called_once_with(logits, metadata)
diff --git a/tests/worker/test_native_duplex_hooks.py b/tests/worker/test_native_duplex_hooks.py
index 388e334cc..1b1bf4b7e 100644
--- a/tests/worker/test_native_duplex_hooks.py
+++ b/tests/worker/test_native_duplex_hooks.py
@@ -2639,7 +2639,7 @@ _REQUIRED_DUPLEX_CALLS = {
     "_sample": "_apply_duplex_sampling",
 }
 
-_MODEL_SAMPLER_CALL = "model_sample"
+_MODEL_SAMPLER_CALL = "call_model_sampler"
 
 
 def _repo_root():
diff --git a/tests/worker/test_omni_connector_mixin.py b/tests/worker/test_omni_connector_mixin.py
index 603ca65ff..bdf9936a4 100644
--- a/tests/worker/test_omni_connector_mixin.py
+++ b/tests/worker/test_omni_connector_mixin.py
@@ -397,7 +397,7 @@ class TestLoadCustomFuncSelection(unittest.TestCase):
     def test_skips_non_payload_stage_input_processors_for_full_payload_mode(self):
         incompatible_paths = [
             "vllm_omni.model_executor.stage_input_processors.mimo_audio.llm2code2wav",
-            "vllm_omni.model_executor.stage_input_processors.mammoth_moda2.ar2dit",
+            "vllm_omni.model_executor.stage_input_processors.mammoth_moda2.ar2diffusion",
             "vllm_omni.model_executor.stage_input_processors.cosyvoice3.text2flow",
             "vllm_omni.model_executor.stage_input_processors.glm_image.ar2diffusion",
         ]
@@ -1724,3 +1724,16 @@ class TestSendRetry(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+@pytest.mark.parametrize(
+    "fallback,external,expected", [("r", None, "mapped"), (None, "ext", "ext"), (None, None, None)]
+)
+def test_resolve_request_id_requires_internal_or_external_id(fallback, external, expected):
+    host = SimpleNamespace(_request_ids_mapping={"r": "mapped"})
+    request = SimpleNamespace(external_req_id=external)
+    if expected is None:
+        with pytest.raises(ValueError, match="request ID"):
+            OmniConnectorModelRunnerMixin._resolve_external_req_id(host, request, fallback)
+    else:
+        assert OmniConnectorModelRunnerMixin._resolve_external_req_id(host, request, fallback) == expected
diff --git a/tests/worker/test_omni_gpu_model_runner.py b/tests/worker/test_omni_gpu_model_runner.py
index 4155e5ffb..ee51b0f58 100644
--- a/tests/worker/test_omni_gpu_model_runner.py
+++ b/tests/worker/test_omni_gpu_model_runner.py
@@ -770,8 +770,10 @@ def test_accumulate_full_payload_output_keeps_all_zero_qwen3_omni_prefill_placeh
 def test_full_payload_output_accumulation_hook_matrix():
     assert _make_full_payload_accumulation_runner(model_stage="thinker")._should_accumulate_full_payload_output()
     assert _make_full_payload_accumulation_runner(model_stage="talker")._should_accumulate_full_payload_output()
-    assert not _make_full_payload_accumulation_runner(
-        model_stage="code2wav", final_output=True
+    # A stage may publish a user-visible output and still feed another stage
+    # (Qwen3-Omni thinker publishes text while sending audio state to talker).
+    assert _make_full_payload_accumulation_runner(
+        model_stage="thinker", final_output=True
     )._should_accumulate_full_payload_output()
     assert not _make_full_payload_accumulation_runner(
         model_stage="token2audio",
diff --git a/tests/worker/test_omni_v2_profile_dispatch.py b/tests/worker/test_omni_v2_profile_dispatch.py
new file mode 100644
index 000000000..4ff6fbfd4
--- /dev/null
+++ b/tests/worker/test_omni_v2_profile_dispatch.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+from vllm.compilation.cuda_graph import CUDAGraphMode
+
+from vllm_omni.worker_v2.omni_model_runner import OmniGPUModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize("dp_size", [1, 2])
+def test_dispatch_eager_and_manager_paths(monkeypatch, dp_size):
+    runner = object.__new__(OmniGPUModelRunner)
+    runner.cudagraph_manager = None
+    runner.dp_size = dp_size
+    runner.dp_rank = 1
+
+    import vllm.v1.worker.gpu.dp_utils as dp_utils
+
+    expected_tokens = object()
+    sync_calls = []
+
+    def sync_padding(*args, **kwargs):
+        sync_calls.append((args, kwargs))
+        return args[1], expected_tokens
+
+    monkeypatch.setattr(
+        dp_utils,
+        "sync_cudagraph_and_dp_padding",
+        sync_padding,
+    )
+
+    batch_desc, num_tokens_across_dp = runner._dispatch_batch_descriptor(
+        num_reqs=1, num_toks=8, uniform_tok_count=8, num_active_loras=0, use_eager=True, max_query_len=8
+    )
+    assert batch_desc.cg_mode == CUDAGraphMode.NONE
+    if dp_size == 1:
+        assert num_tokens_across_dp is None
+        assert sync_calls == []
+    else:
+        assert num_tokens_across_dp is expected_tokens
+
+    # Non-eager dispatch goes through the cudagraph manager.
+    expected = SimpleNamespace(cg_mode=CUDAGraphMode.PIECEWISE, num_tokens=8, num_reqs=1)
+    dispatch_calls = []
+
+    def dispatch(*args, **kwargs):
+        dispatch_calls.append((args, kwargs))
+        return expected
+
+    runner.cudagraph_manager = SimpleNamespace(dispatch=dispatch)
+    runner.dp_size = 1
+    batch_desc, _ = runner._dispatch_batch_descriptor(
+        num_reqs=1, num_toks=8, uniform_tok_count=8, num_active_loras=0, use_eager=False, max_query_len=8
+    )
+    assert batch_desc is expected
+    assert dispatch_calls == [((1, 8, 8), {"num_active_loras": 0, "max_query_len": 8})]
diff --git a/tests/worker/test_tts_sampling_seed.py b/tests/worker/test_tts_sampling_seed.py
new file mode 100644
index 000000000..f54280c36
--- /dev/null
+++ b/tests/worker/test_tts_sampling_seed.py
@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.worker import sampling_utils
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_fixed_seed_contract_separates_stage_sampler_from_talker_mtp_rng() -> None:
+    assert hasattr(sampling_utils, "apply_fixed_seed_to_sampling_params")
+    assert hasattr(sampling_utils, "get_tts_local_seed")
+
+    stage_only = SimpleNamespace(seed=None, extra_args=None)
+    sampling_utils.apply_fixed_seed_to_sampling_params(
+        stage_only,
+        17,
+        seed_talker_mtp=False,
+    )
+    assert stage_only.seed == 17
+    assert sampling_utils.get_tts_local_seed(stage_only) is None
+
+    talker = SimpleNamespace(seed=None, extra_args={"preserved": True})
+    sampling_utils.apply_fixed_seed_to_sampling_params(
+        talker,
+        23,
+        seed_talker_mtp=True,
+    )
+    assert talker.seed == 23
+    assert talker.extra_args == {"preserved": True, "tts_local_seed": 23}
+    assert sampling_utils.get_tts_local_seed(talker) == 23
diff --git a/vllm_omni/diffusion/layers/mot/__init__.py b/tests/worker_v2/__init__.py
similarity index 100%
rename from vllm_omni/diffusion/layers/mot/__init__.py
rename to tests/worker_v2/__init__.py
diff --git a/tests/worker_v2/test_intermediate_buffer.py b/tests/worker_v2/test_intermediate_buffer.py
new file mode 100644
index 000000000..a84fef711
--- /dev/null
+++ b/tests/worker_v2/test_intermediate_buffer.py
@@ -0,0 +1,96 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Unit tests for OmniIntermediateBuffer lifecycle.
+
+Retained contracts: wire decode with malformed-payload rejection, slot
+lifecycle with index migration on reuse, gather in batch order, update merge
+semantics (cpu/gpu-resident keys), single owned snapshot for
+update_gpu_tensor_rows, and decode-span merge until ack.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.engine import (
+    AdditionalInformationEntry,
+    AdditionalInformationPayload,
+    PromptEmbedsPayload,
+)
+from vllm_omni.worker_v2.model_states.intermediate_buffer import (
+    OmniIntermediateBuffer,
+    _resolve_additional_information,
+    _resolve_prompt_embeds,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_new_req_data(req_id="r1", **kwargs):
+    kwargs.setdefault("mm_features", [])
+    return SimpleNamespace(req_id=req_id, **kwargs)
+
+
+def test_wire_decode_passthrough_and_malformed_rejection():
+    tensor = torch.randn(3, 4)
+    assert _resolve_prompt_embeds(tensor) is not None
+    assert _resolve_prompt_embeds(None) is None
+    with pytest.raises(ValueError, match="Failed to decode prompt_embeds payload"):
+        _resolve_prompt_embeds(PromptEmbedsPayload(data=b"\x00", shape=[2, 2], dtype="float32"))
+
+    assert _resolve_additional_information({"key": "val"}) == {"key": "val"}
+    assert _resolve_additional_information(None) == {}
+    payload = AdditionalInformationPayload(
+        entries={
+            "embed.decode": AdditionalInformationEntry(tensor_data=b"\x00", tensor_shape=[2], tensor_dtype="float32")
+        }
+    )
+    with pytest.raises(ValueError, match="Failed to decode additional_information payload"):
+        _resolve_additional_information(payload)
+
+
+def test_slot_lifecycle_fields_reuse_and_remove_idempotent():
+    buf = OmniIntermediateBuffer(max_num_reqs=4)
+    embeds = torch.randn(2, 8)
+    features = [torch.randn(3, 4)]
+    params = SimpleNamespace(extra_args={"tts_local_seed": 1234})
+    buf.add_request(0, _make_new_req_data("r0", prompt_embeds=embeds, mm_features=features, sampling_params=params))
+    assert torch.equal(buf.buffers[0]["prompt_embeds_cpu"], embeds)
+    assert buf.buffers[0]["mm_features"] is features
+    assert buf.buffers[0]["sampling_params"] is params
+
+    buf.add_request(2, _make_new_req_data("r2"))
+    buf.add_request(3, _make_new_req_data("r3"))
+    batch = SimpleNamespace(idx_mapping_np=[2, 0, 3])
+    assert [g["req_id"] for g in buf.gather(batch)] == ["r2", "r0", "r3"]
+
+    # Slot reuse: req_id mapping migrates; duplicate removal is a no-op.
+    buf.add_request(0, _make_new_req_data("new"))
+    assert buf.req_id_to_index["new"] == 0
+    buf.remove_request(0)
+    buf.remove_request(0)
+    assert "new" not in buf.req_id_to_index
+    assert buf.buffers[0] == {}
+
+
+def test_update_merge_semantics(monkeypatch):
+    buf = OmniIntermediateBuffer(max_num_reqs=1)
+    buf.add_request(0, _make_new_req_data("r0"))
+
+    buf.update(0, {"hidden": torch.randn(4)})
+    assert buf.buffers[0]["hidden"].device == torch.device("cpu")  # default migrates to cpu
+    buf.update(0, {})
+    buf.update(0, {"a": torch.tensor([1.0])})
+    buf.update(0, {"b": torch.tensor([2.0])})
+    assert "a" in buf.buffers[0] and "b" in buf.buffers[0]
+
+    # GPU-resident keys keep values (including list items) off the cpu path.
+    tensor = torch.randn(2)
+    monkeypatch.setattr(torch.Tensor, "cpu", lambda *_a, **_k: pytest.fail("GPU-resident value must not move to CPU"))
+    buf.update(0, {"items": [tensor], "kv": torch.randn(4)}, gpu_resident_keys={"items", "kv"})
+    stored = buf.buffers[0]["items"][0]
+    assert stored is not tensor
+    assert torch.equal(stored, tensor)
+    assert "kv" in buf.buffers[0]
diff --git a/tests/worker_v2/test_intermediate_buffer_cuda_residency.py b/tests/worker_v2/test_intermediate_buffer_cuda_residency.py
new file mode 100644
index 000000000..8368d9fe2
--- /dev/null
+++ b/tests/worker_v2/test_intermediate_buffer_cuda_residency.py
@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CUDA-lane checks for GPU-resident intermediate buffer values."""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.worker_v2.model_states.intermediate_buffer import OmniIntermediateBuffer
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cuda]
+
+
+@pytest.mark.parametrize("key,dtype", [(("embed", "prefill"), torch.float32), (("codes", "ref"), torch.long)])
+def test_gpu_resident_values_stay_on_device_after_update(key, dtype):
+    # Declared gpu-resident keys must keep tensors on device (CLA snapshot real).
+    buffer = OmniIntermediateBuffer(1)
+    value = torch.ones(2, 3, device="cuda", dtype=dtype)
+    buffer.add_request(0, SimpleNamespace(req_id="r1", mm_features=[]))
+
+    buffer.update(0, {key[0]: {key[1]: value}}, {key})
+
+    stored = buffer.buffers[0][key[0]][key[1]]
+    assert stored.device.type == "cuda"
+    assert stored.dtype == dtype
+    assert torch.equal(stored.cpu(), value.cpu())
diff --git a/tests/worker_v2/test_omni_ar_model_runner.py b/tests/worker_v2/test_omni_ar_model_runner.py
new file mode 100644
index 000000000..d1f45b5cc
--- /dev/null
+++ b/tests/worker_v2/test_omni_ar_model_runner.py
@@ -0,0 +1,253 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Unit tests for OmniARModelRunner v2: async output staging, snapshot ownership, payload slicing."""
+
+from contextlib import contextmanager
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+import torch
+from vllm.v1.outputs import RoutedExpertsTensors
+from vllm.v1.worker.gpu.sample.output import SamplerOutput, SamplingMaskTensors
+
+import vllm_omni.worker_v2.omni_ar_model_runner as omni_ar_model_runner
+from vllm_omni.worker_v2.omni_ar_model_runner import OmniARModelRunner, OmniAsyncOutput
+from vllm_omni.worker_v2.output_snapshot import pack_output_snapshot
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeStream:
+    def wait_stream(self, _stream) -> None:
+        pass
+
+
+class _FakeEvent:
+    def record(self, _stream) -> None:
+        pass
+
+    def synchronize(self) -> None:
+        pass
+
+
+def _async_output(req_ids=("req-0",), **overrides) -> OmniAsyncOutput:
+    rid2idx = {rid: i for i, rid in enumerate(req_ids)}
+    mro = omni_ar_model_runner.OmniModelRunnerOutput(list(req_ids), rid2idx, None, prompt_logprobs_dict={})
+    sampler_output = SamplerOutput(torch.tensor([[123]]), None, None, None)
+    kwargs = dict(model_runner_output=mro, sampler_output=sampler_output)
+    kwargs.update(num_sampled_tokens=torch.tensor([1] * len(req_ids)), copy_event=_FakeEvent())
+    kwargs.update(main_stream=_FakeStream(), copy_stream=_FakeStream())
+    return OmniAsyncOutput(**(kwargs | overrides))
+
+
+def test_async_output_blocking_event_and_routing_masks(monkeypatch) -> None:
+    event_kwargs = []
+    monkeypatch.setattr(torch.cuda, "set_stream", lambda _stream: None)
+
+    def make_event(**kwargs):
+        event_kwargs.append(kwargs)
+        return _FakeEvent()
+
+    monkeypatch.setattr(torch.cuda, "Event", make_event)
+    masks = SamplingMaskTensors(torch.tensor([[5], [0]], dtype=torch.uint8), torch.tensor([2, 0]), 4)
+    sampler_output = SamplerOutput(torch.tensor([[2], [0]]), None, None, torch.tensor([1, 0]), None, masks)
+    routed = RoutedExpertsTensors(torch.tensor([[[2, 3]], [[4, 5]]]), torch.tensor([7, 9]))
+
+    output = _async_output(
+        req_ids=["decode", "prefill"],
+        sampler_output=sampler_output,
+        num_sampled_tokens=torch.tensor([1, 0]),
+        copy_event=None,  # None → constructor builds the default blocking event
+        routed_experts=routed,
+    ).get_output()
+    assert event_kwargs == [{"blocking": True}]  # blocking event by default
+    assert output.sampled_token_ids == [[2], []] and output.sampling_masks.cu_num_generated_tokens == [0, 1, 1]
+    np.testing.assert_array_equal(output.routed_experts.routing_data, [[[2, 3]], [[4, 5]]])
+    np.testing.assert_array_equal(output.routed_experts.slot_mapping, [7, 9])
+    np.testing.assert_array_equal(output.sampling_masks.token_ids, [0, 2])
+
+
+@pytest.mark.parametrize("needs_history", [False, True])
+def test_last_pp_rank_orchestration_and_kv_resolver(monkeypatch, needs_history) -> None:
+    runner = OmniARModelRunner.__new__(OmniARModelRunner)
+    input_batch = SimpleNamespace(req_ids=["req"], num_reqs=1, seq_lens=torch.tensor([3]))
+    input_batch.idx_mapping, input_batch.query_start_loc = torch.tensor([0]), torch.tensor([0, 1])
+    state = SimpleNamespace(input_batch=input_batch, hidden_states=torch.zeros(1, 2))
+    state.finished_req_ids, state.ec_connector_output, state.routed_experts = {"finished"}, None, None
+    runner.execute_model_state = state
+    runner._kv_extracted_req_ids = runner._last_aux_output = runner._last_multimodal_outputs = None
+    runner.is_last_pp_rank, runner.pp_handler, runner.check_ep_fault = True, None, False
+    runner.model_config = SimpleNamespace(async_chunk=False)
+    runner.vllm_config = SimpleNamespace(model_config=SimpleNamespace(engine_output_type="text"))
+    runner.model_state = SimpleNamespace(postprocess_model_output=MagicMock(return_value=(torch.zeros(1, 2), None)))
+    runner.model_state.intermediate_buffer = SimpleNamespace(buffers={0: {"global_request_id": "global-req"}})
+    runner.req_states = SimpleNamespace(req_id_to_index={"req": 0})
+    runner.req_states.all_token_ids = SimpleNamespace(gpu=torch.tensor([[1]]))
+    runner.req_states.num_computed_tokens = SimpleNamespace(gpu=torch.tensor([0]))
+    runner.req_states.prompt_len = SimpleNamespace(np=np.array([1]), gpu=torch.tensor([1]))
+    runner.main_stream = runner.output_copy_stream = MagicMock()
+    runner.eplb = runner._finalize_native_data_plane_output = runner._reserve_native_data_plane_outputs = MagicMock()
+    sampler_out = (SimpleNamespace(sampled_token_ids=torch.tensor([[2]])), MagicMock(), MagicMock())
+    sampling_active = False
+
+    @contextmanager
+    def sampling_context(*, req_ids, num_output_tokens):
+        nonlocal sampling_active
+        assert needs_history and req_ids == ["req"]
+        sampling_active = True
+        yield
+        sampling_active = False
+
+    runner.model = SimpleNamespace(compute_logits=None, logitsprocs_need_output_token_ids=needs_history)
+    runner.model.mrv2_sampling_context = sampling_context
+    runner.sample = MagicMock(return_value=sampler_out)
+    runner.sample.side_effect = lambda *_: sampler_out if sampling_active is needs_history else pytest.fail()
+    logprobs_mock = MagicMock(side_effect=lambda *_: pytest.fail("inside ctx") if sampling_active else {})
+    runner.prompt_logprobs_worker = SimpleNamespace(compute_prompt_logprobs=logprobs_mock)
+    runner.postprocess_sampled, connector_output = MagicMock(), object()
+
+    def post_forward(finished_req_ids):
+        runner.postprocess_sampled.assert_called_once()  # postprocess precedes kv_connector.post_forward
+        assert finished_req_ids == {"finished"}
+        return connector_output
+
+    runner.kv_connector = SimpleNamespace(post_forward=MagicMock(side_effect=post_forward))
+    mock_out = SimpleNamespace(copy_event=None)
+    monkeypatch.setattr(omni_ar_model_runner, "OmniAsyncOutput", MagicMock(return_value=mock_out))
+
+    assert runner.sample_tokens(None) is mock_out
+    built = omni_ar_model_runner.OmniAsyncOutput.call_args.kwargs["model_runner_output"]
+    assert built.kv_connector_output is connector_output
+    assert runner._resolve_global_request_id("req") == "global-req"  # from the intermediate buffer
+    assert runner._resolve_global_request_id("unknown") == "unknown"  # fallback to the local id
+
+
+def test_async_mm_snapshot_owns_output_until_copy_finishes() -> None:
+    runner = OmniARModelRunner.__new__(OmniARModelRunner)
+    runner.model_config = SimpleNamespace(async_chunk=True)
+    runner._async_mm_snapshot_slots, runner._async_mm_snapshot_events = [{}], [None]
+    runner._async_mm_snapshot_pending, runner._async_mm_snapshot_cursor = [False], 0
+    waited: list[object] = []
+    runner.main_stream = SimpleNamespace(wait_event=waited.append)
+    source = torch.tensor([[7, 8]], dtype=torch.long)
+
+    snapshot = runner._retain_multimodal_outputs({"codes": {"audio": source}})
+    source.fill_(99)
+
+    # Snapshot owns the data (graph replay cannot overwrite it)...
+    snap = snapshot["codes"]["audio"]
+    assert snap.tolist() == [[7, 8]] and snap.data_ptr() != source.data_ptr()
+    assert runner._last_multimodal_snapshot_slot == 0
+    # ...and slot reuse waits for the previous D2H copy event.
+    runner._release_multimodal_snapshot(0, copy_event := object())
+    runner._retain_multimodal_outputs({"codes": {"audio": torch.zeros(1, 2)}})
+    assert waited == [copy_event]
+
+
+def test_snapshot_slots_bounded_by_shape_and_packed_grouping_isolation(monkeypatch) -> None:
+    slot: dict[tuple[Any, ...], torch.Tensor] = {}
+    omni_ar_model_runner._copy_mm_to_snapshot_slot(torch.ones(1, 2), slot)
+    omni_ar_model_runner._copy_mm_to_snapshot_slot(torch.ones(4, 2), slot)
+    assert len(slot) == 2  # separate shapes do not share a buffer
+    monkeypatch.setattr(omni_ar_model_runner, "_ASYNC_MM_SNAPSHOT_MAX_BUCKETS_PER_SLOT", 1)
+    bounded: dict[tuple[Any, ...], torch.Tensor] = {}
+    kept = omni_ar_model_runner._copy_mm_to_snapshot_slot(torch.ones(2, 2), bounded)
+    overflow = omni_ar_model_runner._copy_mm_to_snapshot_slot(torch.ones(5, 2), bounded)
+    assert len(bounded) == 1 and overflow.data_ptr() != kept.data_ptr()  # overflow clones without evicting
+
+    source = torch.arange(12, dtype=torch.int64).view(3, 4).t()
+    payload = {"noncontiguous": source, "nested": [torch.tensor(7), (torch.tensor([1.5]),)], "meta": "ok"}
+    pack_slot: dict[tuple[Any, ...], torch.Tensor] = {}
+    snapshot = pack_output_snapshot(payload, pack_slot, max_buckets=4)
+    source.fill_(99)  # ownership: snapshot keeps pre-mutation values
+    copies = []
+
+    def copy(tensor):
+        copies.append(tensor.numel())
+        return tensor.clone()
+
+    host = snapshot.copy_to_cpu(copy)
+    assert len(copies) == 2  # grouped by dtype (int64, float32), not tensor count
+    assert host["noncontiguous"].tolist() == torch.arange(12).view(3, 4).t().tolist()
+    assert host["nested"][0].item() == 7 and isinstance(host["nested"][1], tuple) and host["meta"] == "ok"
+    pack_output_snapshot(payload, pack_slot, max_buckets=4)
+    assert host["noncontiguous"][0, 0].item() == 0  # repacking must not corrupt published host data
+
+
+@pytest.mark.parametrize("need_pooler,async_chunk", [(False, False), (False, True), (True, False), (True, True)])
+def test_guard_graph_replay_for_pooler_copy(need_pooler, async_chunk) -> None:
+    main_stream = MagicMock()
+    omni_ar_model_runner._guard_graph_replay_for_pooler_copy(
+        main_stream, object(), need_pooler=need_pooler, async_chunk=async_chunk
+    )
+    # Non-async pooler copies must gate the next graph replay on the copy event.
+    assert main_stream.wait_event.call_count == (1 if need_pooler and not async_chunk else 0)
+
+
+def test_build_async_chunk_outputs_slices_padded_axis_and_splits_channels() -> None:
+    # Graph-padded batch: padded_total_tokens > total_tokens; slice by the real token axis.
+    padded_codes = torch.arange(16, dtype=torch.long).reshape(8, 2)
+    build = OmniARModelRunner._build_async_chunk_outputs_from_mm
+    inter_stage, client = build({"codes": {"audio": padded_codes}}, np.array([0, 1, 2]), np.array([1, 1]), 2, 2, 8)
+    assert client is None
+    assert torch.equal(inter_stage[0]["codes.audio"], padded_codes[0:1])
+    assert torch.equal(inter_stage[1]["codes.audio"], padded_codes[1:2])
+
+    codes, audio = torch.arange(16, dtype=torch.long).reshape(4, 4), torch.randn(4, 8)
+    req_codes = [torch.arange(16 * i, 16 * (i + 1), dtype=torch.long).reshape(1, 16) for i in range(2)]
+    inter_stage, client = build(
+        {"codes": {"audio": codes}, "audio": audio}, np.array([0, 2, 4]), np.array([2, 2]), 2, 4
+    )
+    assert "hidden" not in inter_stage[0] and torch.equal(client[1]["audio"], audio[2:])  # channel split
+    assert torch.equal(inter_stage[1]["codes.audio"], codes[2:])  # inter-stage channel
+    # Per-request code lists pass through unsliced.
+    inter_stage, client = build({"codes": {"audio": req_codes}}, np.array([0, 1, 2]), np.array([1, 1]), 2, 2)
+    assert client is None and torch.equal(inter_stage[0]["codes.audio"], req_codes[0])
+
+
+def test_async_chunk_output_stages_mm_on_copy_stream_before_get_output(monkeypatch) -> None:
+    monkeypatch.setattr(torch.cuda, "set_stream", lambda _stream: None)
+    calls = []
+
+    def copy_mm(mm_outputs, total_tokens, **ctx):
+        calls.append((total_tokens, ctx))
+        return {"codes": {"audio": mm_outputs["codes"]["audio"].clone()}}
+
+    monkeypatch.setattr(omni_ar_model_runner, "_async_copy_mm", copy_mm)
+    source_codes = torch.tensor([[7, 8]], dtype=torch.long)
+    input_batch = SimpleNamespace(query_start_loc_np=np.array([0, 1]), num_scheduled_tokens=[1], num_reqs=1)
+    output = _async_output(
+        multimodal_outputs={"codes": {"audio": source_codes}},
+        input_batch=input_batch,
+        copy_stream=(copy_stream := _FakeStream()),
+        async_chunk=True,
+    )
+    # Staged once on the copy stream during construction, with one resolved pin-memory context for all D2H helpers.
+    [(total_tokens, ctx)] = calls
+    assert total_tokens == 1 and ctx["copy_stream"] is copy_stream and ctx["pin_memory"] is not None
+    assert output._mm_snapshot["codes"]["audio"].device.type == "cpu"
+    source_codes.fill_(99)  # a later graph replay cannot leak into the snapshot
+    assert torch.equal(output.get_output().inter_stage_outputs[0]["codes.audio"], torch.tensor([[7, 8]]))
+
+
+@pytest.mark.parametrize("prefill_first", [False, True])
+@pytest.mark.parametrize("padded", [False, True])
+def test_request_reference_codes_preserve_local_axis(prefill_first, padded):
+    lengths = np.array([255, 1] if prefill_first else [1, 255])
+    offsets = np.array([0, lengths[0], 256])
+    size = 512 if padded else 256
+    ref = torch.arange(size * 16).reshape(size, 16)
+    refs = [ref, torch.empty(0)] if prefill_first else [torch.empty(0), ref]
+    codes = torch.arange(size * 16).reshape(size, 16)
+    outputs, _ = OmniARModelRunner._build_async_chunk_outputs_from_mm(
+        {"codes": {"audio": codes, "ref": refs}}, offsets, lengths, 2, 256, size
+    )
+    index = 0 if prefill_first else 1
+    assert torch.equal(outputs[index]["codes.ref"], ref)
+    assert outputs[index]["codes.ref"].data_ptr() != ref.data_ptr()
+    for i in range(2):
+        assert torch.equal(outputs[i]["codes.audio"], codes[offsets[i] : offsets[i + 1]])
diff --git a/tests/worker_v2/test_omni_data_plane.py b/tests/worker_v2/test_omni_data_plane.py
new file mode 100644
index 000000000..a1629e0bf
--- /dev/null
+++ b/tests/worker_v2/test_omni_data_plane.py
@@ -0,0 +1,481 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Lifecycle contracts for OmniRunnerDataPlane/NativeOutputWorker."""
+
+import threading
+import time
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+import torch
+
+from vllm_omni.worker_v2.delivery import DeliveryCancelledError, DeliveryState, OmniDeliveryManager
+from vllm_omni.worker_v2.native_output_worker import NativeOutputWorker
+from vllm_omni.worker_v2.omni_data_plane import OmniRunnerDataPlane
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _complete(plane, payloads, token=21, req="internal"):
+    return plane.complete_outputs(
+        req_ids=[req], inter_stage_outputs=payloads, sampled_token_ids=[[token]] * len(payloads)
+    )
+
+
+def _new_request(req_id="internal", external_req_id="external"):
+    return SimpleNamespace(
+        req_id=req_id,
+        external_req_id=external_req_id,
+        prompt_token_ids=[10, 11],
+        num_computed_tokens=2,
+        resumable=True,
+        additional_information=SimpleNamespace(entries={}),
+        sampling_params=SimpleNamespace(stop_token_ids=[2150]),
+    )
+
+
+def _bare_plane(*, delivery_timeout_s=1.0, shutdown_timeout_s=1.0):
+    plane = object.__new__(OmniRunnerDataPlane)
+    plane.__dict__.update(
+        _native_requests={},
+        _native_output_lock=threading.RLock(),
+        _native_send_lock=threading.Lock(),
+        _native_output_error=None,
+        _native_output_error_lock=threading.Lock(),
+        _native_output_closed=False,
+        _native_outputs_in_flight=defaultdict(int),
+        _native_terminal_pending=set(),
+        _put_req_chunk=defaultdict(int),
+        _ramp_chunk_count=defaultdict(int),
+        _delivery_manager=OmniDeliveryManager(
+            delivery_timeout_s=delivery_timeout_s, shutdown_timeout_s=shutdown_timeout_s
+        ),
+    )
+    return plane
+
+
+def _make_plane(replace_send):
+    p = _bare_plane()
+    p.record = SimpleNamespace(batches=[], cleaned=[])
+    if replace_send:
+        p.send_chunks = lambda entries, **_kw: p.record.batches.append(entries) or len(entries)
+    p.get_omni_connector_output, p.cleanup_finished_request = (lambda: None), p.record.cleaned.append
+    return p
+
+
+@pytest.fixture
+def raw_plane():  # keeps the real connector send path
+    p = _make_plane(replace_send=False)
+    yield p
+    if getattr(p, "_native_output_worker", None) is not None:
+        p._stop_output_worker()
+
+
+@pytest.fixture
+def plane():
+    p = _make_plane(replace_send=True)
+    yield p
+    if getattr(p, "_native_output_worker", None) is not None:
+        p._stop_output_worker()
+
+
+def _gated_connector():
+    # put() blocks its first call until released (or forever without release).
+    conn = SimpleNamespace(
+        put_keys=[], put_started=threading.Event(), release=threading.Event(), close_called=threading.Event()
+    )
+
+    def put(**kwargs):
+        conn.put_keys.append(kwargs["put_key"])
+        if len(conn.put_keys) == 1:
+            conn.put_started.set()
+            assert conn.release.wait(timeout=2)
+        return True, 1, None
+
+    conn.put, conn.close = put, conn.close_called.set
+    return conn
+
+
+def _start_save_thread(plane, connector):
+    plane.__dict__.update(
+        _omni_connector=connector,
+        _stage_id=0,
+        _next_stage_id=1,
+        _lock=threading.Lock(),
+        _pending_save_reqs={},
+        _pending_save_counts=defaultdict(int),
+        _deferred_send_cleanup=set(),
+        _request_ids_mapping={},
+        _cached_ic={},
+        _send_side_request_payload={},
+        _code_prompt_token_ids=defaultdict(list),
+        _work_available=threading.Event(),
+        _stop_event=threading.Event(),
+        _MAX_SEND_RETRIES=0,
+        _can_send=True,
+        _recv_thread=None,
+        _custom_process_batch_func=lambda **kwargs: kwargs["pooling_outputs"],
+        is_data_transfer_rank=lambda: True,
+        _connector_send_error_sink=plane._record_output_error,
+    )
+    plane._save_thread = threading.Thread(target=plane._save_loop, daemon=True)
+    plane._save_thread.start()
+
+
+def _stop_save_thread(plane):
+    plane._stop_event.set()
+    plane._work_available.set()
+    plane._save_thread.join(timeout=2)
+    assert not plane._save_thread.is_alive()
+
+
+class _Output:
+    copy_event = None
+
+    def __init__(self, rid="internal", gate=None, started=None, error=None, payload=None, token=1):
+        self.rid, self.gate, self.started = rid, gate, started
+        self.error, self.payload, self.token = error, payload, token
+
+    def get_output(self):
+        if self.started is not None:
+            self.started.set()
+        if self.gate is not None:
+            assert self.gate.wait(timeout=3)
+        if self.error is not None:
+            raise self.error
+        return SimpleNamespace(
+            req_ids=[self.rid],
+            inter_stage_outputs=[self.payload] if self.payload is not None else None,
+            sampled_token_ids=[[self.token]],
+        )
+
+
+def test_emit_cohort_one_batch_and_trims_non_resumable_history(plane):
+    plane.send_chunk = lambda *_a, **_kw: pytest.fail("must not fall back to per-request send_chunk")
+    plane.register_request(_new_request("r0", "ext-0"))
+    plane.register_request(_new_request("r1", "ext-1"))
+    emitted = plane.emit_chunks(
+        req_ids=["r0", "r1"],
+        inter_stage_outputs=[{"codes.audio": "c0"}, {"codes.audio": "c1"}],
+        sampled_token_ids=[[21]],
+        terminal_req_ids={"r1"},
+    )
+    assert emitted == 2 and len(plane.record.batches) == 1  # the whole step cohort goes out in one batch
+    (req0, _), (req1, _) = plane.record.batches[0]
+    assert (
+        req0.all_token_ids == [10, 11, 21]
+        and not req0.is_finished()
+        and req1.is_finished()
+        and plane.record.cleaned == ["r1"]
+    )
+    # A non-resumable request omits token history after its first chunk.
+    plane.register_request(_new_request("r2", "ext-2"))
+    state = plane._native_requests["r2"]
+    state.resumable, state.output_token_ids, plane._put_req_chunk["ext-2"] = False, list(range(1024)), 1
+    plane.emit_chunks(
+        req_ids=["r2"], inter_stage_outputs=[{"h": "d"}], sampled_token_ids=[[1024]], terminal_req_ids={"r2"}
+    )
+    request, _ = plane.record.batches[1][0]
+    assert request.output_token_count == 1025 and request.all_token_ids == []
+
+
+def test_terminal_reserved_abort_and_cleanup_lifecycle(plane):
+    batches, cleaned = plane.record.batches, plane.record.cleaned
+    plane.register_request(_new_request())
+    plane.reserve_outputs(["internal"])
+    plane.reserve_outputs(["internal"])
+    # The terminal defers while reservations are in flight, and is idempotent.
+    assert plane.request_terminal({"internal"}) == 0
+    assert plane.request_terminal({"internal"}) == 0 and batches == []
+    assert _complete(plane, [{"codes.audio": "c0"}]) == 1 and not batches[0][0][0].is_finished()
+    assert _complete(plane, [{"codes.audio": "c1"}], token=22) == 2  # data chunk, then the released terminal
+    chunk, terminal = batches[1][0], batches[2][0]
+    assert chunk[1] == {"codes": {"audio": "c1"}} and chunk[0].output_token_ids == [21, 22]
+    assert terminal[1] is None and terminal[0].is_finished() and cleaned == ["internal"]
+    # Stale terminal/complete after cleanup are no-ops; cleanup ran exactly once.
+    assert plane.request_terminal({"internal"}) == 0 and _complete(plane, [{"codes.audio": "stale"}]) == 0
+    # Abort emits exactly one terminal and silently drops the stale deferred output.
+    plane.register_request(_new_request("ra"))
+    plane.reserve_outputs(["ra"])
+    plane.request_terminal({"ra"})
+    assert plane.abort_requests({"ra"}) == 1
+    request, payload = batches[-1][0]
+    assert request.is_finished() and payload is None and cleaned == ["internal", "ra"]
+    assert (
+        plane.abort_requests({"ra"}) == 0 and _complete(plane, [{"s": 1}], req="ra") == 0
+    )  # duplicate abort, stale output
+    assert sum(b[0][0].request_id == "ra" for b in batches) == 1  # terminal exactly once
+
+
+def test_abort_cannot_overtake_committed_output(plane):
+    in_lock, release, sent = threading.Event(), threading.Event(), threading.Event()
+
+    def gated(entries, _orig=plane._send_chunk_entries, **kw):
+        terminal = entries[0][0].is_finished()
+        if not terminal:
+            in_lock.set()
+            assert release.wait(timeout=2)  # hold the committed data send inside _native_send_lock
+        result = _orig(entries, **kw)
+        if terminal:
+            sent.set()
+        return result
+
+    plane._send_chunk_entries = gated
+    plane.register_request(_new_request())
+    plane.reserve_outputs(["internal"])
+    threads = [
+        threading.Thread(target=lambda: _complete(plane, [{"c": 0}])),
+        threading.Thread(target=plane.abort_requests, args=({"internal"},)),
+    ]
+    threads[0].start()
+    try:
+        assert in_lock.wait(timeout=2)
+        threads[1].start()
+        overtook = sent.wait(timeout=0.1)  # the terminal must not pass the committed data send
+    finally:
+        release.set()
+        for t in threads:
+            if t.ident is not None:
+                t.join(timeout=2)
+                assert not t.is_alive()
+    assert not overtook
+
+
+def test_output_worker_fifo_and_scheduler_not_blocked(plane):
+    batches, send_started, release_send = [], threading.Event(), threading.Event()
+
+    def send_chunks(entries, **_kw):
+        if not entries[0][0].is_finished():
+            send_started.set()
+            assert release_send.wait(timeout=2)
+        batches.append(entries)
+        return len(entries)
+
+    plane.send_chunks = send_chunks
+    plane._start_output_worker(max_pending_batches=2)
+    plane.register_request(_new_request())
+    plane.reserve_outputs(["internal"])
+    plane.enqueue_outputs(req_ids=["internal"], inter_stage_outputs=[{"c": 0}], sampled_token_ids=[[21]])
+    assert send_started.wait(timeout=2)
+    # A stuck deferred send must not block the scheduler path.
+    assert plane.request_terminal({"internal"}) == 0 and batches == []
+    release_send.set()
+    plane.drain_outputs()
+    assert [e[0].is_finished() for batch in batches for e in batch] == [False, True]
+
+
+def test_worker_failure_surfaces_and_close_drains_in_order(plane):
+    events = []
+    plane.send_chunks = lambda _e, **_kw: (_ for _ in ()).throw(RuntimeError("enqueue failed"))
+    plane.shutdown_omni_connectors = lambda: events.append("shutdown")
+    plane._start_output_worker(max_pending_batches=2)
+    plane.register_request(_new_request())
+    plane.enqueue_outputs(req_ids=["internal"], inter_stage_outputs=[{"c": 0}], sampled_token_ids=[[21]])
+    with pytest.raises(RuntimeError, match="enqueue failed"):
+        plane.drain_outputs()
+    with pytest.raises(RuntimeError, match="enqueue failed"):  # an errored worker rejects new submissions
+        plane.enqueue_outputs(req_ids=["internal"], inter_stage_outputs=[{"c": 1}], sampled_token_ids=[[22]])
+    # close() drains pending batches before shutting connectors down.
+    plane._native_output_error = None
+
+    def send_chunks(entries, **_kw):
+        events.append("send")
+        return len(entries)
+
+    plane.send_chunks = send_chunks
+    plane.enqueue_outputs(req_ids=["internal"], inter_stage_outputs=[{"c": 1}], sampled_token_ids=[[22]])
+    plane.close()
+    assert events == ["send", "shutdown"]
+
+
+def test_permanent_put_failure_quarantines_and_holds_state(raw_plane):
+    puts = []
+
+    def put(**_kw):
+        puts.append(1)
+        return False, 0, None
+
+    connector = SimpleNamespace(put=put, close=lambda: None)
+    _start_save_thread(raw_plane, connector)
+    raw_plane.register_request(_new_request())
+    raw_plane.reserve_outputs(["internal"])
+    raw_plane.request_terminal({"internal"})
+    with pytest.raises(RuntimeError, match="connector send failed"):
+        raw_plane.complete_outputs(req_ids=["internal"], inter_stage_outputs=[{"c": 0}], sampled_token_ids=[[21]])
+    assert len(puts) == 1 and raw_plane._native_output_error is not None  # fail fast, no retry
+    assert raw_plane._native_outputs_in_flight["internal"] == 1 and "internal" in raw_plane._native_terminal_pending
+    with pytest.raises(RuntimeError, match="quarantined"):  # the quarantine rejects new tickets
+        raw_plane._delivery_manager.create_ticket(request_id="other", put_key="other_0_0")
+    _stop_save_thread(raw_plane)
+
+
+def test_delivery_timeout_drops_queued_ticket(raw_plane):
+    raw_plane._delivery_manager = OmniDeliveryManager(delivery_timeout_s=0.05, shutdown_timeout_s=0.5)
+    connector = _gated_connector()
+    _start_save_thread(raw_plane, connector)
+    req = SimpleNamespace(request_id="external")
+    _, first = raw_plane._enqueue_chunk_payload(req, {"c": 1}, wait_for_delivery=True)
+    _, second = raw_plane._enqueue_chunk_payload(req, {"c": 2}, wait_for_delivery=True)
+    assert connector.put_started.wait(timeout=1)
+    with pytest.raises(TimeoutError, match="delivery timed out"):
+        first.wait()
+    assert raw_plane._delivery_manager.is_quarantined
+    connector.release.set()
+    deadline = time.monotonic() + 1
+    while time.monotonic() < deadline and "external" in raw_plane._pending_save_counts:  # the save loop drops it
+        time.sleep(0.001)
+    # After quarantine the queued ticket is never put and is marked FAILED.
+    assert connector.put_keys == [first.put_key] and second.state is DeliveryState.FAILED
+    assert "external" not in raw_plane._pending_save_counts and "external" not in raw_plane._pending_save_reqs
+    _stop_save_thread(raw_plane)
+
+
+def test_close_cancels_waiting_delivery_once_and_shutdown_stays_bounded():
+    # A queued delivery waiter is cancelled exactly once on shutdown.
+    manager = OmniDeliveryManager(delivery_timeout_s=30.0, shutdown_timeout_s=0.5)
+    ticket = manager.create_ticket(request_id="r", put_key="k")
+    manager.shutdown(RuntimeError("close"))
+    manager.shutdown(RuntimeError("again"))  # idempotent: cancelled at most once
+    with pytest.raises(DeliveryCancelledError, match="cancelled"):
+        ticket.wait()
+    # A connector put() that cannot be cancelled must not hang shutdown.
+    plane = _bare_plane(delivery_timeout_s=0.05, shutdown_timeout_s=0.2)
+    connector = _gated_connector()
+    _start_save_thread(plane, connector)
+    assert plane._enqueue_chunk_payload(SimpleNamespace(request_id="external"), {"c": 0}, wait_for_delivery=True)[0]
+    assert connector.put_started.wait(timeout=1)
+    start = time.monotonic()
+    with pytest.raises(RuntimeError, match="shutdown exceeded"):
+        plane.shutdown_omni_connectors()
+    assert time.monotonic() - start < 1.5 and connector.close_called.is_set()
+    connector.release.set()
+    _stop_save_thread(plane)
+
+
+@pytest.mark.parametrize("abort", [False, True])
+def test_materialization_fences_terminal_and_abort(plane, abort):
+    batches, cleaned, gate, started = plane.record.batches, plane.record.cleaned, threading.Event(), threading.Event()
+    plane._start_output_worker(max_pending_batches=2)
+    materializer = NativeOutputWorker(2)
+    try:
+        plane.register_request(_new_request())
+        plane.reserve_outputs(["internal"])
+        output = materializer.submit(
+            _Output(gate=gate, started=started, payload={"codes.audio": "c0"}, token=21), plane
+        )
+        assert started.wait(timeout=3)
+        assert plane.request_terminal({"internal"}) == 0  # fenced behind the in-flight materialization
+        assert not abort or plane.abort_requests({"internal"}) == 1
+        gate.set()
+        output.get_output()
+        materializer.close()
+        plane.drain_outputs()
+        assert cleaned == ["internal"] and len(batches) == (1 if abort else 2)
+        assert abort or (batches[0][0][1] == {"codes": {"audio": "c0"}} and not batches[0][0][0].is_finished())
+        assert batches[-1][0][0].is_finished()
+    finally:
+        gate.set()
+        materializer.close()
+
+
+def test_native_worker_fifo_thread_affinity_and_signals():
+    owner, gate = threading.get_ident(), threading.Event()
+    calls: list[tuple[Any, ...]] = []
+
+    def get_signals():
+        calls.append(("signals", threading.get_ident()))
+        return "ready"
+
+    plane = SimpleNamespace(
+        enqueue_outputs=lambda **kw: calls.append(("publish", kw["req_ids"], threading.get_ident())),
+        get_omni_connector_output=get_signals,
+    )
+    worker = NativeOutputWorker(2)
+    try:
+        a = worker.submit(_Output("a", gate=gate, payload={"v": 1}), plane)
+        b = worker.submit(_Output("b", payload={"v": 1}), plane)
+        gate.set()
+        b.get_output()  # publication of b implies a already published (FIFO, single worker thread)
+        publishes = [c for c in calls if c[0] == "publish"]
+        assert [c[1] for c in publishes] == [["a"], ["b"]]
+        assert all(c[2] != owner for c in publishes)  # published on the worker thread
+        result = a.get_output()
+        assert a.get_output() is result and result.inter_stage_outputs is None  # resolution is cached
+        assert result.omni_connector_output == "ready"
+        assert calls[-2:] == [("signals", owner)] * 2  # signals resolve lazily on the caller thread
+    finally:
+        gate.set()
+        worker.close()
+
+
+def test_native_worker_capacity_error_cache_and_tp_gates():
+    from vllm_omni.worker_v2.omni_model_runner import OmniGPUModelRunner
+
+    plane = SimpleNamespace(enqueue_outputs=lambda **kw: None, get_omni_connector_output=lambda: None)
+    worker, gate = NativeOutputWorker(1), threading.Event()
+    try:
+        first = worker.submit(_Output("a", gate=gate), plane)
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(worker.submit, _Output("b"), plane)
+            time.sleep(0.05)
+            assert not future.done()  # capacity 1: pending materialization is bounded
+            gate.set()
+            second = future.result(3)
+        assert first.get_output().req_ids == ["a"] and second.get_output().req_ids == ["b"]
+        bad = worker.submit(_Output("x", error=ValueError("crash")), plane)
+    finally:
+        gate.set()
+        worker.close()
+    # A failed materialization is cached: repeated reads raise the same error.
+    for _ in range(2):
+        with pytest.raises(ValueError, match="crash"):
+            bad.get_output()
+    runner = SimpleNamespace(
+        _omni_data_plane=object(), vllm_config=SimpleNamespace(parallel_config=SimpleNamespace(tensor_parallel_size=2))
+    )
+    assert OmniGPUModelRunner._uses_native_output_materializer(runner) is False  # TP>1 keeps TP consumers
+    runner.vllm_config.parallel_config.tensor_parallel_size = 1
+    assert OmniGPUModelRunner._uses_native_output_materializer(runner) is True
+
+
+def test_abort_before_first_chunk_cleans_receiver_state():
+    plane = _bare_plane()
+    plane._stage_id, plane._lock, plane._work_available = 1, threading.Lock(), threading.Event()
+    for name in (
+        "_pending_full_payload_send",
+        "_request_ids_mapping",
+        "_pending_save_counts",
+        "_send_side_request_payload",
+        "_code_prompt_token_ids",
+        "_cached_ic",
+        "_adaptive_states",
+        "_kv_pending_transfers",
+        "_get_req_chunk",
+        "_pending_load_reqs",
+        "_local_stage_payload_cache",
+        "_local_request_metadata",
+    ):
+        setattr(plane, name, {})
+    for name in (
+        "_deferred_send_cleanup",
+        "_kv_active_transfers",
+        "_kv_completed_transfers",
+        "_kv_triggered_requests",
+        "_finished_load_reqs",
+        "_chunk_ready_req_ids",
+        "_chunk_finished_req_ids",
+        "_chunk_stream_completed",
+        "_stage_recv_req_ids",
+        "_full_payload_pending_broadcast_req_ids",
+        "_async_chunk_updated_req_ids",
+    ):
+        setattr(plane, name, set())
+    plane.register_receivers([SimpleNamespace(request_id="r", external_req_id="external")])
+    plane._local_stage_payload_cache["r"] = {"codes": torch.ones(1)}
+    assert "r" in plane._pending_load_reqs and plane._request_ids_mapping["r"] == "external"
+    assert plane.abort_requests({"r"}) == 0
+    assert plane.abort_requests({"r"}) == 0
+    assert not plane._pending_load_reqs and not plane._request_ids_mapping and not plane._local_stage_payload_cache
diff --git a/tests/worker_v2/test_omni_generation_model_runner.py b/tests/worker_v2/test_omni_generation_model_runner.py
new file mode 100644
index 000000000..63c480291
--- /dev/null
+++ b/tests/worker_v2/test_omni_generation_model_runner.py
@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OmniGenerationModelRunner contracts: empty-step lifecycle, output partition,
+CPU-sync vs CUDA-async dispatch, and async-chunk slot recycling."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.outputs import OmniModelRunnerOutput
+from vllm_omni.worker_v2.omni_generation_model_runner import OmniGenerationModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeStagedField:
+    def __init__(self, data):
+        self.np = data
+        self._staged = []
+
+    def stage_write_elem(self, idx, value):
+        self._staged.append((idx, value))
+
+    def apply_write(self):
+        for idx, value in self._staged:
+            self.np[idx] = value
+        self._staged.clear()
+
+
+def _make_runner(model_output, num_reqs=1, prompt_len=10):
+    runner = object.__new__(OmniGenerationModelRunner)
+    runner.device = torch.device("cpu")
+    runner.model_config = MagicMock(hf_text_config=None)
+    del runner.model_config.eos_token_id
+    runner.postprocess = lambda *a, **kw: None
+    runner._gen_model_output = model_output
+    runner._gen_input_batch = SimpleNamespace(
+        num_reqs=num_reqs, req_ids=[f"req-{i}" for i in range(num_reqs)], idx_mapping_np=np.arange(num_reqs)
+    )
+    runner.execute_model_state = SimpleNamespace(finished_req_ids={"finished"}, ec_connector_output=None)
+    runner.kv_connector = SimpleNamespace(post_forward=MagicMock(return_value=None))
+    runner.check_ep_fault = False
+    runner.req_states = MagicMock(
+        prompt_len=SimpleNamespace(np=np.full(num_reqs, prompt_len, dtype=np.int32)),
+        num_computed_tokens=_FakeStagedField(np.zeros(num_reqs, dtype=np.int32)),
+    )
+    return runner
+
+
+def test_control_only_step_keeps_lifecycle_and_skips_input_construction():
+    runner = object.__new__(OmniGenerationModelRunner)
+    order = []
+    for name in (
+        "_prepare_native_data_plane",
+        "finish_requests",
+        "free_states",
+        "_apply_block_table_staged_writes_if_available",
+    ):
+        setattr(runner, name, lambda *args, name=name: order.append(name))
+    for name in ("_handle_async_chunk_updates", "add_requests", "update_requests", "_sync_native_data_plane_payloads"):
+        setattr(runner, name, MagicMock(side_effect=AssertionError("control step built model inputs")))
+    output = object()
+    runner.kv_connector = SimpleNamespace(no_forward=lambda _s: output)
+    runner._merge_ec_connector_no_forward = lambda _s, value: value
+    runner._attach_native_data_plane_signals = lambda value: value
+    scheduler_output = SimpleNamespace(
+        total_num_scheduled_tokens=0, scheduled_new_reqs=[], scheduled_cached_reqs=SimpleNamespace(req_ids=[])
+    )
+    assert runner.execute_model(scheduler_output) is output
+    assert order == [
+        "_prepare_native_data_plane",
+        "finish_requests",
+        "free_states",
+        "_apply_block_table_staged_writes_if_available",
+    ]
+
+
+def test_released_chunk_reuses_scheduler_output_and_slot_recycle_clears_state():
+    from vllm.v1.core.sched.output import SchedulerOutput
+
+    from vllm_omni.core.sched.output import OmniCachedRequestData
+
+    runner = object.__new__(OmniGenerationModelRunner)
+    runner.model = SimpleNamespace(logits_processor=None)
+    runner._remove_request = MagicMock()
+    req_id_to_index = MagicMock()
+    req_id_to_index.get.return_value = None
+    runner.req_states = SimpleNamespace(
+        add_request=MagicMock(), req_id_to_index=req_id_to_index, apply_staged_writes=MagicMock()
+    )
+    runner.pooling_runner = None
+    runner.encoder_cache = None
+    runner.model_state = SimpleNamespace(
+        add_request=MagicMock(),
+        apply_staged_writes=MagicMock(),
+        remove_request=MagicMock(),
+        intermediate_buffer=SimpleNamespace(remove_request=MagicMock()),
+    )
+    runner.block_tables = SimpleNamespace(append_block_ids=MagicMock())
+    runner.lora_state = SimpleNamespace(add_request=MagicMock())
+    runner.is_last_pp_rank = False
+    runner.adaptive_verification = None
+    runner.sampler = None
+    cached = OmniCachedRequestData(
+        req_ids=["req"],
+        resumed_req_ids=set(),
+        new_token_ids=[[]],
+        all_token_ids={"req": [1]},
+        new_block_ids=[()],
+        num_computed_tokens=[0],
+        num_output_tokens=[0],
+        prompt_token_ids={"req": [1]},
+        additional_information={"req": None},
+    )
+    scheduler_output = SchedulerOutput(
+        scheduled_new_reqs=[],
+        scheduled_cached_reqs=cached,
+        num_scheduled_tokens={"req": 1},
+        total_num_scheduled_tokens=1,
+        scheduled_spec_decode_tokens={},
+        scheduled_encoder_inputs={},
+        num_common_prefix_blocks=[0],
+        finished_req_ids=set(),
+        free_encoder_mm_hashes=[],
+    )
+    runner._handle_async_chunk_updates(scheduler_output)
+    added = runner.model_state.add_request.call_args.args[1]
+    assert (added.req_id, added.prompt_token_ids) == ("req", [1])
+
+
+def test_sample_tokens_cpu_sync_owns_outputs_and_runs_connector_last():
+    waveform = torch.arange(4, dtype=torch.float32)
+    output = OmniOutput(text_hidden_states=torch.empty(0), multimodal_outputs={"codes": {"audio": [waveform]}})
+    runner = _make_runner(output, num_reqs=1)
+    runner._reserve_native_data_plane_outputs = MagicMock()
+    runner._finalize_native_data_plane_output = MagicMock(side_effect=lambda value: value)
+
+    def post_forward(_finished):
+        assert runner.req_states.num_computed_tokens.np.tolist() == [10]
+
+    runner.kv_connector.post_forward.side_effect = post_forward
+    result = OmniGenerationModelRunner.sample_tokens(runner)
+    assert isinstance(result, OmniModelRunnerOutput)
+    # Reserve precedes finalize; connector runs after token state is applied.
+    runner._reserve_native_data_plane_outputs.assert_called_once_with(["req-0"])
+    runner.kv_connector.post_forward.assert_called_once_with({"finished"})
+    waveform.fill_(-1)
+    assert torch.equal(result.multimodal_outputs[0]["codes.audio"], torch.arange(4, dtype=torch.float32))
+
+
+def test_sample_tokens_uses_async_output_for_cuda_and_snapshots_req_ids(monkeypatch):
+    from vllm_omni.worker_v2 import omni_generation_model_runner as generation_runner
+
+    output = OmniOutput(text_hidden_states=torch.zeros(1), multimodal_outputs={"model_outputs": [torch.randn(4)]})
+    runner = _make_runner(output, num_reqs=1)
+    runner.device = SimpleNamespace(type="cuda")
+    runner.main_stream = object()
+    runner.output_copy_stream = object()
+    runner.model_config.async_chunk = True
+    runner._release_generation_slots = MagicMock()
+    runner._finalize_native_data_plane_output = MagicMock()
+    monkeypatch.setattr(generation_runner, "_contains_cuda_tensor", lambda _: True)
+    captured = {}
+
+    class _FakeAsyncOutput:
+        def __init__(self, **kwargs):
+            captured.update(kwargs)
+
+    monkeypatch.setattr(generation_runner, "OmniGenerationAsyncOutput", _FakeAsyncOutput)
+    input_batch = runner._gen_input_batch
+    result = generation_runner.OmniGenerationModelRunner.sample_tokens(runner)
+
+    assert isinstance(result, _FakeAsyncOutput)
+    assert captured["finalize_output"] is runner._finalize_native_data_plane_output
+    assert captured["model_runner_output"].sampled_token_ids == [[]]
+    runner._release_generation_slots.assert_called_once()
+    output_req_ids = captured["model_runner_output"].req_ids
+    input_batch.req_ids[0] = "reused"  # snapshot must insulate the published output
+    assert output_req_ids == ["req-0"]
diff --git a/tests/worker_v2/test_omni_gpu_model_runner.py b/tests/worker_v2/test_omni_gpu_model_runner.py
new file mode 100644
index 000000000..77cd6ee98
--- /dev/null
+++ b/tests/worker_v2/test_omni_gpu_model_runner.py
@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""MRV2 admission, capture, dispatch and request lifecycle contracts."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+import torch
+from vllm import SamplingParams
+from vllm.config.compilation import CUDAGraphMode
+from vllm.v1.core.sched.output import SchedulerOutput
+from vllm.v1.worker.gpu.model_runner import GPUModelRunner
+from vllm.v1.worker.gpu.sample.sampler import Sampler
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.worker_v2.model_states import init_omni_model_state
+from vllm_omni.worker_v2.model_states.omni_model_state import OmniModelState
+from vllm_omni.worker_v2.omni_model_runner import OmniGPUModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_runner():
+    """Create an OmniGPUModelRunner without calling __init__."""
+    runner = object.__new__(OmniGPUModelRunner)
+    runner.model = MagicMock()
+    runner.req_states = SimpleNamespace(req_id_to_index={"r1": 0, "r2": 1})
+    runner.execute_model_state = None
+    return runner
+
+
+def test_add_requests_empty_admission_and_stop_id_sanitization():
+    runner = _make_runner()
+    runner.sampler = Sampler.__new__(Sampler)
+    with patch.object(GPUModelRunner, "add_requests", return_value=None) as parent:
+        runner.add_requests(SchedulerOutput.make_empty())
+        parent.assert_not_called()
+
+        # New requests always go upstream; narrow logits heads sanitize stop ids.
+        sampling_params = SamplingParams(min_tokens=2, stop_token_ids=[2150])
+        sampling_params.update_from_generation_config({}, 151645)
+        runner.model = SimpleNamespace(logits_processor=SimpleNamespace(vocab_size=3072))
+        output = SchedulerOutput.make_empty()
+        output.scheduled_new_reqs = [SimpleNamespace(sampling_params=sampling_params)]
+        runner.add_requests(output)
+        parent.assert_called_once_with(output)
+    assert sampling_params.all_stop_token_ids == {2150}
+    assert sampling_params.eos_token_id == 151645
+
+
+def test_prepare_native_data_plane_terminal_abort_split_and_warmup_skip():
+    runner = _make_runner()
+    plane = SimpleNamespace(
+        register_request=MagicMock(),
+        register_receivers=MagicMock(),
+        request_terminal=MagicMock(),
+        abort_requests=MagicMock(),
+    )
+    runner._omni_data_plane = plane
+    new_req = SimpleNamespace(req_id="r1")
+    warmup_req = SimpleNamespace(req_id="_warmup_0_")
+    handle = SimpleNamespace(request_id="r2", external_req_id="ext-r2")
+    scheduler_output = SimpleNamespace(
+        scheduled_new_reqs=[new_req, warmup_req],
+        pending_input_registrations=[handle],
+        data_plane_terminal_req_ids={"r0"},
+        finished_req_ids={"r0", "aborted"},
+    )
+
+    runner._prepare_native_data_plane(scheduler_output)
+
+    plane.register_request.assert_called_once_with(new_req)  # warmup skipped
+    plane.register_receivers.assert_called_once_with([handle])
+    plane.request_terminal.assert_called_once_with({"r0"})
+    plane.abort_requests.assert_called_once_with({"aborted"})
+
+
+@pytest.mark.parametrize("output_form", ["tuple", "omni"])
+def test_capture_model_unwraps_exclude_full_and_capture_mtp(output_form):
+    runner = object.__new__(OmniGPUModelRunner)
+    hidden = torch.ones(1, 2)
+
+    def original_forward():
+        if output_form == "tuple":
+            return hidden, {"layers": {}}
+        return OmniOutput(text_hidden_states=hidden, multimodal_outputs={})
+
+    runner.model = SimpleNamespace(forward=original_forward)
+    runner._model_returns_tuple = True
+    runner._exclude_full_graph = True
+    runner.use_aux_hidden_state_outputs = False
+    piecewise = SimpleNamespace(cg_mode=CUDAGraphMode.PIECEWISE)
+    full = SimpleNamespace(cg_mode=CUDAGraphMode.FULL)
+    runner.cudagraph_manager = SimpleNamespace(
+        _capture_descs={CUDAGraphMode.PIECEWISE: [piecewise], CUDAGraphMode.FULL: [full]},
+        _candidates={(1, 0): [piecewise, full]},
+    )
+    runner.model_state = SimpleNamespace(capture_mtp_graphs=MagicMock())
+    runner._dispatch_mtp_batch_descriptor = MagicMock(return_value="desc")
+
+    def assert_unwrapped(_self):
+        assert torch.equal(runner.model.forward(), hidden)  # forward unwrapped during capture
+        return 3
+
+    with patch.object(GPUModelRunner, "capture_model", assert_unwrapped):
+        assert runner.capture_model() == 3
+
+    assert runner.model.forward is original_forward  # restored after capture
+    assert runner.cudagraph_manager._capture_descs == {CUDAGraphMode.PIECEWISE: [piecewise]}
+    runner.model_state.capture_mtp_graphs.assert_called_once_with(runner._dispatch_mtp_batch_descriptor)
+
+
+@pytest.mark.parametrize(
+    "parallel_config,match",
+    [
+        (dict(pipeline_parallel_size=2, prefill_context_parallel_size=1), "pipeline parallel"),
+        (dict(pipeline_parallel_size=1, prefill_context_parallel_size=2), "prefill context parallelism"),
+    ],
+)
+def test_mrv2_rejects_parallel_modes_at_startup(parallel_config, match):
+    runner = object.__new__(OmniGPUModelRunner)
+    runner.vllm_config = SimpleNamespace(parallel_config=SimpleNamespace(**parallel_config))
+    with pytest.raises(NotImplementedError, match=match):
+        runner._validate_parallel_support()
+
+
+@pytest.mark.parametrize(
+    "flag,expect_omni",
+    [(None, False), ("has_preprocess", True), ("has_postprocess", True), ("have_multimodal_outputs", True)],
+)
+def test_init_model_state_factory_dispatches_omni_only(monkeypatch, flag, expect_omni):
+    upstream = MagicMock(return_value=object())
+    monkeypatch.setattr("vllm_omni.worker_v2.model_states._upstream_init_model_state", upstream)
+    monkeypatch.setattr(OmniModelState, "__init__", lambda *args: None)
+    cfg = SimpleNamespace(model_config=SimpleNamespace(architectures=["CustomModel"]))
+    model = SimpleNamespace(**({flag: True} if flag else {}))
+    state = init_omni_model_state(cfg, model, None, torch.device("cpu"))
+
+    if expect_omni:
+        assert isinstance(state, OmniModelState)
+        upstream.assert_not_called()
+    else:
+        upstream.assert_called_once()
+        assert state is upstream.return_value
+
+
+def test_finish_requests_notifies_model_and_cleans_only_known_slots(monkeypatch):
+    runner = _make_runner()
+    calls = []
+    runner.model = SimpleNamespace(on_requests_finished=lambda ids: calls.append(set(ids)))
+    runner.model_state = MagicMock()
+    monkeypatch.setattr(GPUModelRunner, "finish_requests", lambda *args: None)
+    runner.finish_requests(SimpleNamespace(finished_req_ids={"released"}, preempted_req_ids={"r1"}))
+    assert calls == [{"released"}]
+    assert sorted(c.args[0] for c in runner.model_state.remove_request.call_args_list) == [0]
+
+
+@pytest.mark.parametrize("stage,declared", [("thinker", False), ("custom_ar", True)])
+def test_capture_contract_uses_model_declaration(stage, declared):
+    runner = _make_runner()
+    runner.model = SimpleNamespace(model_stage=stage, _returns_tuple=declared)
+    runner._configure_cudagraph_output_contract()
+    assert runner._model_returns_tuple is declared
+    assert runner._exclude_full_graph is declared
diff --git a/tests/worker_v2/test_omni_model_state.py b/tests/worker_v2/test_omni_model_state.py
new file mode 100644
index 000000000..34d0d8010
--- /dev/null
+++ b/tests/worker_v2/test_omni_model_state.py
@@ -0,0 +1,361 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""OmniModelState: mixed-batch reorder, state isolation/slot reuse, MTP
+graph/eager paths with per-request seed independence, async snapshot ownership."""
+
+from contextlib import nullcontext
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+import pytest
+import torch
+from vllm.v1.worker.gpu.model_states.default import DefaultModelState
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput, OwnedBatchTensor
+from vllm_omni.worker_v2.model_states.omni_model_state import OmniModelState, _make_safe_get_rope
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _DummyInputBatch:
+    input_ids: SimpleNamespace
+    query_start_loc: torch.Tensor
+
+    def __init__(self, indices, *, num_computed_tokens_cpu=None):
+        self.idx_mapping_np = indices
+        self.num_reqs = len(indices)
+        self.num_scheduled_tokens = [1] * len(indices)
+        self.query_start_loc_np = list(range(len(indices)))
+        if num_computed_tokens_cpu is not None:
+            self.num_computed_tokens_cpu = np.array(num_computed_tokens_cpu, dtype=np.int32)
+
+
+def _make_state(max_num_reqs=4, has_preprocess=False, has_postprocess=False, have_multimodal_outputs=False):
+    state = object.__new__(OmniModelState)
+    model = MagicMock()
+    model.has_preprocess = has_preprocess
+    model.has_postprocess = has_postprocess
+    model.have_multimodal_outputs = have_multimodal_outputs
+    model.gpu_resident_buffer_keys = set()
+    model.batched_gpu_staging_keys = set()
+    model.mtp_accepts_per_row_generators = False
+    model.mtp_accepts_req_infos = False
+    model.mtp_output_key = ("codes", "audio")
+    model.mtp_validity_key = None
+    model.mtp_sampling_params = {}
+    model.get_mtp_seed = lambda params: (getattr(params, "extra_args", None) or {}).get("test_seed")
+    model.preprocess_batch_mrv2 = None
+    model.preprocess_decode_batch_mrv2 = None
+    model.preprocess_decode_batch = None
+    model.postprocess_batch_mrv2 = None
+    state.model = model
+    state.scheduler_config = SimpleNamespace(max_num_seqs=max_num_reqs)
+    state.vllm_config = SimpleNamespace(model_config=SimpleNamespace(subtalker_sampling_params={}))
+    state.has_preprocess = has_preprocess
+    state.has_postprocess = has_postprocess
+    state.have_multimodal_outputs = have_multimodal_outputs
+
+    from vllm_omni.worker_v2.model_states.intermediate_buffer import OmniIntermediateBuffer
+
+    state.intermediate_buffer = OmniIntermediateBuffer(max_num_reqs)
+    state._static_inputs_embeds = None
+    state._mtp_generators = {}
+    state._mtp_runner = None
+    for name in ("_mtp_input_ids", "_mtp_input_embeds", "_mtp_hidden", "_mtp_text_step", "_mtp_offsets"):
+        setattr(state, name, None)
+    return state
+
+
+def _add(state, req_id="r1", idx=0, **req_kwargs):
+    with patch.object(DefaultModelState, "add_request", return_value=None):
+        state.add_request(idx, SimpleNamespace(req_id=req_id, mm_features=[], **req_kwargs))
+
+
+def _fill_buffers(state, *req_ids):
+    for idx, req_id in enumerate(req_ids):
+        state.intermediate_buffer.buffers[idx] = {"req_id": req_id}
+
+
+def _seeded(seed):
+    return SimpleNamespace(extra_args={"test_seed": seed}, seed=None)
+
+
+def _init_static(state, bsz, dim=3):
+    state._mtp_input_ids = torch.zeros(bsz, dtype=torch.long)
+    state._mtp_input_embeds = torch.zeros((bsz, dim))
+    state._mtp_hidden = torch.zeros((bsz, dim))
+    state._mtp_text_step = torch.zeros((bsz, dim))
+    state._mtp_offsets = torch.zeros(bsz, dtype=torch.long)
+
+
+def _mtp_batches(dim=3):
+    return [(0, 0, (torch.ones(dim), torch.ones(dim) * 2)), (1, 1, (torch.ones(dim) * 3, torch.ones(dim) * 4))]
+
+
+@pytest.fixture(autouse=True)
+def _fwd_ctx():
+    with patch("vllm.forward_context.set_forward_context", return_value=nullcontext()):
+        yield
+
+
+@pytest.mark.parametrize("req_id,expect_validity", [("_warmup_0_", True), ("r1", False)])
+def test_add_request_declared_validity_only_for_warmup(req_id, expect_validity):
+    # Real requests must not be masked with a fabricated validity key.
+    state = _make_state()
+    state.model.mtp_validity_key = ("meta", "codec_frame_valid")
+    _add(state, req_id, 0)
+    buf = state.intermediate_buffer.buffers[0]
+    assert ("meta" in buf) is expect_validity
+    if expect_validity:
+        assert buf["meta"]["codec_frame_valid"].item() is False
+
+
+@pytest.mark.parametrize("mode", ["index", "req_id", "unknown"])
+def test_remove_request_state_isolation(mode):
+    state = _make_state()
+    _add(state, "r1", 0)
+    state._mtp_generators["r1"] = torch.Generator(device="cpu")
+    if mode == "unknown":
+        state.remove_request("missing")
+        assert state.intermediate_buffer.buffers[0]["req_id"] == "r1"
+        assert "r1" in state._mtp_generators
+        return
+    state.remove_request(0 if mode == "index" else "r1")
+    assert state.intermediate_buffer.buffers[0] == {}
+    assert "r1" not in state._mtp_generators  # recycled slot inherits no seed stream
+
+
+def test_output_spans_follow_reordered_mixed_batch():
+    # batch=[2, 0]: prefill (3 tokens) reordered ahead of decode (1 token).
+    state = _make_state(have_multimodal_outputs=True)
+    batch = _DummyInputBatch([2, 0])
+    batch.num_scheduled_tokens = [3, 1]
+    batch.query_start_loc_np = [0, 3]
+    state.intermediate_buffer.buffers[2] = {"req_id": "prefill"}
+    state.intermediate_buffer.buffers[0] = {"req_id": "decode"}
+    seen = {}
+    state.model.make_omni_output = lambda hidden, **kwargs: (
+        seen.update(kwargs) or OmniOutput(text_hidden_states=hidden, multimodal_outputs={})
+    )
+    state.postprocess_model_output(torch.zeros(4, 2), batch, SimpleNamespace())
+    assert seen["request_token_spans"] == [(0, 3), (3, 4)]
+    assert [info["req_id"] for info in seen["model_intermediate_buffer"]] == ["prefill", "decode"]
+
+
+@pytest.mark.parametrize("hook_name", ["preprocess_decode_batch_mrv2", "preprocess_decode_batch", "legacy"])
+def test_decode_cohort_uses_batch_hook(hook_name):
+    state = _make_state(max_num_reqs=2, has_preprocess=True)
+    state.intermediate_buffer.buffers[0] = {"req_id": "r1", "meta": {"step": 1}}
+    state.intermediate_buffer.buffers[1] = {"req_id": "r2", "meta": {"step": 2}}
+    batch_calls = []
+
+    def preprocess_decode_batch(*, input_ids, input_embeds, req_infos):
+        batch_calls.append(list(req_infos))
+        return (
+            input_ids + 10,
+            input_embeds + 20,
+            torch.tensor([[31.0, 32.0], [41.0, 42.0]]),
+            torch.tensor([[51.0, 52.0], [61.0, 62.0]]),
+            [{"meta": {"step": 11}}, {"meta": {"step": 12}}],
+        )
+
+    if hook_name == "legacy":
+        # Legacy V1 hook without input_embeds is wrapped by the adapter.
+        state.model.preprocess_decode_batch = lambda *, input_ids, req_infos: preprocess_decode_batch(
+            input_ids=input_ids, input_embeds=model_inputs["inputs_embeds"], req_infos=req_infos
+        )
+    else:
+        setattr(state.model, hook_name, preprocess_decode_batch)
+        if hook_name == "preprocess_decode_batch_mrv2":
+            state.model.preprocess_decode_batch = MagicMock(
+                side_effect=AssertionError("MRV2 hook must take precedence")
+            )
+    state.model.preprocess = MagicMock(side_effect=AssertionError("decode requests must use the batch hook"))
+    seen_prepacked = []
+
+    def capture(batches, *_a, prepacked_mtp_inputs=None):
+        seen_prepacked.append(prepacked_mtp_inputs)
+
+    state._run_batched_mtp = capture
+    model_inputs = {
+        "input_ids": torch.tensor([101, 202], dtype=torch.long),
+        "inputs_embeds": torch.tensor([[1.0, 2.0], [3.0, 4.0]]),
+    }
+    state.run_preprocess(
+        _DummyInputBatch([0, 1], num_computed_tokens_cpu=[1, 1]),
+        model_inputs,
+        SimpleNamespace(prompt_len=np.array([1, 1], dtype=np.int32)),
+    )
+    state.model.preprocess.assert_not_called()
+    assert [info["req_id"] for info in batch_calls[0]] == ["r1", "r2"]
+    assert torch.equal(model_inputs["input_ids"], torch.tensor([111, 212]))
+    assert state.intermediate_buffer.buffers[0]["meta"]["step"] == 11
+    assert torch.equal(seen_prepacked[0][0], torch.tensor([[31.0, 32.0], [41.0, 42.0]]))
+
+
+def test_static_decode_embeddings_refresh_from_input_ids():
+    # FULL-graph replay reads the static buffer: it must hold fresh embeddings.
+    state = _make_state(has_preprocess=True)
+    static_embeds = torch.zeros(1, 4)
+    state._static_inputs_embeds = static_embeds
+    expected = torch.tensor([[1.0, 2.0, 3.0, 4.0]])
+    state.model.embed_input_ids = lambda input_ids: expected.to(input_ids.device)
+    state.model.preprocess = lambda input_ids, input_embeds, **_info: (input_ids, input_embeds, {})
+    state.intermediate_buffer.buffers[0] = {"req_id": "r1"}
+    state.run_preprocess(
+        _DummyInputBatch([0]),
+        {"input_ids": torch.tensor([1049], dtype=torch.long), "inputs_embeds": static_embeds[:1]},
+    )
+    assert torch.equal(static_embeds, expected)
+    original = torch.tensor([[1.0, 2.0]])
+    assert OmniModelState._preprocess_result_needs_writeback(original, original) is False
+    assert OmniModelState._preprocess_result_needs_writeback(original, original.view_as(original)) is True
+
+
+@pytest.mark.parametrize("owned", [False, True])
+def test_batched_postprocess_gpu_snapshot_writeback(owned):
+    # batch=[1, 0]: last-token indices follow the reordered batch, the scalar
+    # hook is not called, and both rows share one snapshot storage so a later
+    # graph replay cannot overwrite published rows. Owned producer batches
+    # skip the extra snapshot while borrowed graph output still gets one.
+    state = _make_state(max_num_reqs=2, has_postprocess=True)
+    state.model.gpu_resident_buffer_keys = {("hidden_states", "last")}
+    _fill_buffers(state, "r0", "r1")
+    state.model.postprocess = MagicMock(side_effect=AssertionError("batch hook must replace scalar postprocess"))
+    calls = []
+    produced = []
+
+    def postprocess_batch(*, hidden_states, last_token_indices):
+        calls.append(last_token_indices.clone())
+        gathered = hidden_states.index_select(0, last_token_indices)
+        produced.append(gathered)
+        if owned:
+            return (("hidden_states", "last"), OwnedBatchTensor(gathered))
+        return (("hidden_states", "last"), gathered)
+
+    state.model.postprocess_batch_mrv2 = postprocess_batch
+    batch = _DummyInputBatch([1, 0])
+    batch.num_scheduled_tokens = [2, 2]
+    batch.query_start_loc_np = [0, 2]
+    batch.query_start_loc = torch.tensor([0, 2, 4], dtype=torch.int32)
+    hidden = torch.tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]])
+    state.run_postprocess(hidden, batch)
+
+    state.model.postprocess.assert_not_called()
+    assert torch.equal(calls[0], torch.tensor([1, 3], dtype=torch.int32))
+    first = state.intermediate_buffer.buffers[0]["hidden_states"]["last"]
+    second = state.intermediate_buffer.buffers[1]["hidden_states"]["last"]
+    assert torch.equal(first, hidden[3])
+    assert torch.equal(second, hidden[1])
+    assert first.untyped_storage().data_ptr() == second.untyped_storage().data_ptr()
+    if owned:
+        # Owned output: rows view into the producer batch, no extra snapshot.
+        assert first.untyped_storage().data_ptr() == produced[0].untyped_storage().data_ptr()
+    else:
+        # Borrowed/graph output: the snapshot owns its storage, not the producer.
+        assert first.untyped_storage().data_ptr() != produced[0].untyped_storage().data_ptr()
+
+
+def test_seed_independence_resolve_once_and_sampling_kwargs():
+    state = _make_state(max_num_reqs=2)
+    # vLLM sampling seed must not produce a talker generator.
+    cpu = torch.device("cpu")
+    assert state._get_mtp_generator("r1", SimpleNamespace(extra_args={}, seed=42), cpu) is None
+    # Same model-local seed reproduces identical uniforms regardless of batch makeup.
+    state._mtp_sample_uniforms = torch.empty((2, 2, 4))
+    assert torch.equal(
+        state._prepare_mtp_sample_uniforms([torch.Generator().manual_seed(11)], 1).clone(),
+        state._prepare_mtp_sample_uniforms([torch.Generator().manual_seed(11)], 1),
+    )
+    # Per-request generators are resolved once per step and ride sampling kwargs.
+    state.model.mtp_sampling_params = {"do_sample": True, "temperature": 0.7}
+    state.model.mtp_accepts_per_row_generators = True
+    _init_static(state, 2)
+    state.intermediate_buffer.buffers[0] = {"req_id": "r0", "sampling_params": _seeded(11)}
+    state.intermediate_buffer.buffers[1] = {"req_id": "r1", "sampling_params": _seeded(22)}
+    resolver = MagicMock(wraps=state._get_mtp_generator)
+    state._get_mtp_generator = resolver
+
+    def mtp(input_ids, input_embeds, last_hidden, text_step, **kwargs):
+        assert (kwargs["do_sample"], kwargs["temperature"]) == (True, 0.7)
+        assert all(isinstance(g, torch.Generator) for g in kwargs["generators"])
+        return input_embeds + 10, torch.tensor([[1, 2, 3], [4, 5, 6]])
+
+    state.model.mtp = mtp
+    state._run_batched_mtp(
+        _mtp_batches(), torch.tensor([101, 202]), torch.zeros(2, 3), _DummyInputBatch([0, 1]), {("codes", "audio")}
+    )
+    assert resolver.call_count == 2
+    assert torch.equal(state.intermediate_buffer.buffers[0]["codes"]["audio"], torch.tensor([[1, 2, 3]]))
+    assert torch.equal(state.intermediate_buffer.buffers[1]["codes"]["audio"], torch.tensor([[4, 5, 6]]))
+
+
+def test_seeded_mtp_bypasses_outer_graph_runner():
+    state = _make_state(max_num_reqs=2)
+    raw_calls = []
+
+    def mtp(*args, **kwargs):
+        raw_calls.append(kwargs)
+        return args[1], args[0].reshape(-1, 1)
+
+    state.model.mtp = mtp
+    state._mtp_runner = MagicMock(side_effect=AssertionError("seeded sampling must not replay the graph"))
+    generators = [torch.Generator().manual_seed(11), torch.Generator().manual_seed(22)]
+    state._call_mtp_runner(
+        torch.tensor([101, 202]), torch.zeros(2, 3), torch.zeros(2, 3), torch.zeros(2, 3), generators=generators
+    )
+    assert raw_calls == [{"generators": generators}]
+    state._mtp_runner.assert_not_called()
+
+
+def test_run_batched_mtp_uses_dispatched_graph_descriptor():
+    state = _make_state(max_num_reqs=4)
+
+    class _FakeGraphRunner:
+        def __call__(self, input_ids, input_embeds, last_hidden, text_step, **kwargs):
+            assert input_ids.shape[0] == 4  # graph runs the padded descriptor size
+            return input_embeds + 2, torch.arange(12, dtype=torch.long).reshape(4, 3)
+
+    state._mtp_runner = _FakeGraphRunner()
+    _init_static(state, 4)
+    _fill_buffers(state, "r0", "r1")
+    graph_desc = SimpleNamespace(cg_mode="FULL", num_tokens=4)
+    set_ctx = MagicMock(return_value=nullcontext())
+    with (
+        patch(
+            "vllm_omni.worker_v2.model_states.omni_model_state.current_omni_platform.get_graph_wrapper_cls",
+            return_value=_FakeGraphRunner,
+        ),
+        patch("vllm.forward_context.set_forward_context", set_ctx),
+    ):
+        state._run_batched_mtp(
+            _mtp_batches(),
+            torch.tensor([101, 202]),
+            torch.zeros(2, 3),
+            _DummyInputBatch([0, 1]),
+            {("codes", "audio")},
+            lambda bsz: graph_desc,
+        )
+    _, kwargs = set_ctx.call_args
+    assert kwargs["batch_descriptor"] is graph_desc
+    assert kwargs["num_tokens"] == 4
+    assert torch.equal(state.intermediate_buffer.buffers[0]["codes"]["audio"], torch.tensor([[0, 1, 2]]))
+    assert torch.equal(state.intermediate_buffer.buffers[1]["codes"]["audio"], torch.tensor([[3, 4, 5]]))
+
+
+def test_rope_shim_propagates_type_error():
+    # vLLM rope API drift (TypeError) must not be swallowed by the shim.
+    def broken_get_rope(*_args, **_kwargs):
+        raise TypeError("vLLM rope API drift")
+
+    with pytest.raises(TypeError, match="rope API drift"):
+        _make_safe_get_rope(broken_get_rope)(SimpleNamespace(uses_mrope=False), object())
+
+
+@pytest.mark.parametrize("output_key", [None, ("only_one",)])
+def test_mtp_requires_model_declared_output_key(output_key):
+    state = _make_state()
+    model = SimpleNamespace(mtp=lambda: None, mtp_output_key=output_key)
+    with pytest.raises(TypeError, match="must declare mtp_output_key"):
+        state._init_mtp_runner(model)
diff --git a/tools/pre_commit/check_forbidden_imports.py b/tools/pre_commit/check_forbidden_imports.py
index 959007c30..3a8f89121 100644
--- a/tools/pre_commit/check_forbidden_imports.py
+++ b/tools/pre_commit/check_forbidden_imports.py
@@ -79,11 +79,12 @@ CHECK_IMPORTS = {
             "vllm_omni/entrypoints/openai/video_stream_base.py",
             "vllm_omni/entrypoints/openai/video_stream_session.py",
             "vllm_omni/experimental/fullduplex/client.py",
-            "vllm_omni/engine/duplex/audio.py",
             "vllm_omni/engine/duplex/commands.py",
             "vllm_omni/engine/duplex/contracts.py",
-            "vllm_omni/engine/duplex/events.py",
-            "vllm_omni/engine/duplex/realtime_commands.py",
+            "vllm_omni/protocol/realtime/audio.py",
+            "vllm_omni/protocol/realtime/audio_input.py",
+            "vllm_omni/protocol/realtime/events.py",
+            "vllm_omni/protocol/realtime/items.py",
             "vllm_omni/experimental/fullduplex/joyvl/memory/memory.py",
             "vllm_omni/model_executor/models/minicpmo_4_5/duplex/input.py",
             "vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py",
@@ -107,7 +108,7 @@ CHECK_IMPORTS = {
             "setup.py",
             "vllm_omni/benchmarks/data_modules/daily_omni_eval.py",
             "vllm_omni/config/stage_config.py",
-            "vllm_omni/diffusion/layers/mot/ops/mot_gemm.py",
+            "vllm_omni/diffusion/models/bagel/mot/ops/mot_gemm.py",
             "vllm_omni/diffusion/model_loader/diffusers_loader.py",
             "vllm_omni/diffusion/models/diffusers_adapter/pipeline_diffusers_adapter.py",
             "vllm_omni/diffusion/models/dreamid_omni/fusion.py",
diff --git a/tools/pre_commit/check_test_marks.py b/tools/pre_commit/check_test_marks.py
index 6af0ae825..2d84039de 100644
--- a/tools/pre_commit/check_test_marks.py
+++ b/tools/pre_commit/check_test_marks.py
@@ -33,6 +33,12 @@ HARDWARE_HELPERS = ("hardware_test", "hardware_marks")
 # The helper implementation is the only file allowed to write pytest.mark.<SKU>.
 _ALLOWED_DIRECT_SKU_FILES = frozenset({"tests/helpers/mark.py"})
 
+# Common diffusion tests receive per-case marks from this parametrization helper.
+_DELEGATED_MARK_SOURCES = {
+    "tests/model_tests/diffusion/test_common_offline.py": "tests/model_tests/diffusion/case_filtering.py",
+    "tests/model_tests/diffusion/test_common_online.py": "tests/model_tests/diffusion/case_filtering.py",
+}
+
 # Match mark.X since we could also do `from pytest import mark`.
 # \b prevents matching prefixes (e.g., mark.slow vs mark.slow_test).
 HELPER_RE = re.compile(r"(?:" + "|".join(HARDWARE_HELPERS) + r")\s*\(")
@@ -146,6 +152,9 @@ def get_files_missing_markers(
             missing = []
             if has_direct_sku_marker(path, contents):
                 missing.append(DIRECT_SKU_MARKER)
+            mark_source = _DELEGATED_MARK_SOURCES.get(_normalize_path(path))
+            if mark_source is not None and "get_parametrized_options(" in contents:
+                contents += "\n" + (read_test_file(str(_repo_root() / mark_source)) or "")
             if not has_level_marker(contents):
                 missing.append(MISSING_LEVEL_MARKER)
             if not has_hardware_marker(contents):
diff --git a/vllm_omni/attention/fish_kvcache_attn.py b/vllm_omni/attention/fish_kvcache_attn.py
index e7235168c..6e402ca54 100644
--- a/vllm_omni/attention/fish_kvcache_attn.py
+++ b/vllm_omni/attention/fish_kvcache_attn.py
@@ -24,6 +24,14 @@ def _triton_backend() -> Any:
 
 
 def is_available() -> bool:
+    # The Fish kvcache fast path is CUDA-only: it depends on FlashAttention's
+    # use_cascade metadata (absent from Ascend's metadata) and a Triton CUDA
+    # kernel. On other platforms report unavailable so the native attention
+    # backend takes over instead of crashing on attn_metadata.use_cascade.
+    from vllm.platforms import current_platform
+
+    if not current_platform.is_cuda():
+        return False
     return _triton_backend().is_available()
 
 
diff --git a/vllm_omni/benchmarks/data_modules/videomme_dataset.py b/vllm_omni/benchmarks/data_modules/videomme_dataset.py
new file mode 100644
index 000000000..e2f34e425
--- /dev/null
+++ b/vllm_omni/benchmarks/data_modules/videomme_dataset.py
@@ -0,0 +1,1008 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Video-MME dataset loader for vLLM-Omni bench serve.
+
+Video-MME (lmms-eval/Video-MME) is a full-spectrum video MLLM benchmark with
+900 videos / 2,700 MCQ pairs across short / medium / long durations.
+
+This loader follows OpenBMB OmniEvalKit's MiniCPM-o recipe
+(``o_e_Kit/configs/generation_configs.json``):
+
+- ``videomme`` (default): frames only, ``max_frames=96``, ``load_av=false``
+- ``videomme_short``-style: interleaved AV at 1fps via ``minicpm-interleave``
+
+Prompt template and option formatting match OmniEvalKit ``minicpmo.py``; frame
+timestamps match OmniEvalKit ``_sample_video_frame_indices``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import tempfile
+import time
+import zipfile
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+import pybase64 as base64
+import regex as re
+
+try:
+    from vllm.benchmarks.datasets import BenchmarkDataset, SampleRequest
+except ImportError:
+    from vllm.benchmarks.datasets import HuggingFaceDataset as BenchmarkDataset
+    from vllm.benchmarks.datasets import SampleRequest
+from vllm.tokenizers import TokenizerLike
+from vllm.tokenizers.hf import get_cached_tokenizer
+
+try:
+    from datasets import load_dataset
+except ImportError:
+    load_dataset = None
+
+from vllm_omni.benchmarks.data_modules.daily_omni_dataset import (
+    MINICPM_OMNI_SYSTEM_TEXT,
+    _ListDatasetIterator,
+    _numpy_to_wav_bytes,
+    _pil_to_jpeg_bytes,
+    _uniform_sample_indices,
+)
+
+logger = logging.getLogger(__name__)
+
+_MINICPM_AUDIO_SR = 16000
+
+# OmniEvalKit MiniCPM ``videomme`` / ``videomme_short`` defaults.
+VIDEOMME_DEFAULT_MAX_FRAMES = 96
+VIDEOMME_SHORT_MAX_FRAMES = 64
+VIDEOMME_DEFAULT_HF_REPO = "lmms-eval/Video-MME"
+
+#: Decode forward to reach a target this close, seek to the preceding keyframe beyond it.
+_SEEK_THRESHOLD_S = 3.0
+
+#: How often ``sample`` reports progress while warming a cold frame cache.
+_SAMPLE_PROGRESS_INTERVAL_S = 30.0
+
+VideoMMEPackMode = Literal["minicpm-frames", "minicpm-interleave", "video_url"]
+VideoMMEDurationFilter = Literal["all", "short", "medium", "long"]
+
+# OmniEvalKit ``generation_configs.json`` → ``videomme.user_prompt`` (``{media}`` stripped;
+# media parts are prepended as OpenAI content parts, matching ``build_content``).
+VIDEOMME_USER_PROMPT_TEMPLATE = (
+    "Carefully read the following question and select the letter corresponding to the "
+    "correct answer.Highlight the applicable choices without giving explanations.\n"
+    "{question}\n"
+    "Options:\n"
+    "{options}\n"
+    "Please select the correct answer from the options above. Only respond with the letter."
+)
+
+_OPTION_LETTERS = "ABCDEFGHIJKL"
+_OPTION_PREFIX_RE = re.compile(r"^([A-L])\s*[.、:：)]\s*(.*)$")
+
+_VIDEO_SUFFIXES = (".mp4", ".mkv", ".webm", ".avi")
+
+
+def _iter_video_files(root: Path) -> Iterator[Path]:
+    """Yield video files under ``root``, skipping dot-dirs such as the frame cache."""
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+        for name in filenames:
+            if os.path.splitext(name)[1].lower() in _VIDEO_SUFFIXES:
+                yield Path(dirpath) / name
+
+
+def _resolve_hf_cache_snapshot(path: Path) -> Path:
+    """Map a HF hub cache dir (``datasets--org--name``) to its checked-out snapshot dir."""
+    snapshots = path / "snapshots"
+    if not snapshots.is_dir():
+        return path
+    ref = path / "refs" / "main"
+    if ref.is_file():
+        try:
+            revision = ref.read_text(encoding="utf-8").strip()
+        except OSError:
+            revision = ""
+        # An empty or unreadable ref must not resolve to ``snapshots`` itself, which holds
+        # no dataset files; fall through to the newest revision below.
+        if revision and (snapshots / revision).is_dir():
+            return snapshots / revision
+    revisions = [p for p in snapshots.iterdir() if p.is_dir()]
+    if revisions:
+        return max(revisions, key=lambda p: p.stat().st_mtime)
+    return path
+
+
+def absolute_path(value: str | Path | None) -> Path | None:
+    """Return an absolute path, or ``None`` when ``value`` is empty."""
+    if value is None:
+        return None
+    raw = str(value).strip()
+    if not raw:
+        return None
+    return Path(raw).expanduser().resolve()
+
+
+def resolve_videomme_local_root(dataset_path: str | None) -> Path | None:
+    """Return a local Video-MME root if ``dataset_path`` points at an on-disk mirror.
+
+    Hub ids such as ``lmms-eval/Video-MME`` return ``None`` (they are not directories).
+    """
+    raw = (dataset_path or "").strip()
+    if not raw:
+        return None
+    path = Path(raw).expanduser()
+    if not path.is_dir():
+        return None
+    return _resolve_hf_cache_snapshot(path.resolve())
+
+
+def cached_videomme_snapshots() -> list[Path]:
+    """Usable Video-MME snapshots already in the Hub cache, whatever org published them.
+
+    The dataset is mirrored under several ids (``lmms-lab``/``lmms-eval``), so an offline
+    run routinely requests one while a sibling is what actually sits on disk.
+    """
+    from huggingface_hub import constants as hf_constants
+
+    cache = Path(hf_constants.HF_HUB_CACHE)
+    if not cache.is_dir():
+        return []
+
+    found: list[Path] = []
+    for entry in sorted(cache.iterdir()):
+        name = entry.name.lower()
+        if not entry.is_dir() or not name.startswith("datasets--") or not name.endswith("--video-mme"):
+            continue
+        snapshot = _resolve_hf_cache_snapshot(entry)
+        # A repo dir with no parquet is a partial download, not a usable root.
+        if videomme_local_parquet(snapshot) is not None:
+            found.append(snapshot)
+    return found
+
+
+def ensure_videomme_hub_root(repo_id: str) -> Path:
+    """Download the Video-MME dataset snapshot from Hugging Face and return its root.
+
+    Mirrors :func:`vllm_omni.benchmarks.data_modules.seed_tts_dataset.resolve_seed_tts_root`:
+    Hub ids trigger ``hf_api().snapshot_download``; callers then extract videos via
+    :func:`ensure_videomme_videos_extracted`.
+
+    Raises:
+        ImportError: if Hugging Face Hub helpers are not installed.
+        ValueError: if ``repo_id`` is empty.
+        FileNotFoundError: if the snapshot is neither cached nor downloadable.
+    """
+    rid = (repo_id or "").strip()
+    if not rid:
+        raise ValueError("repo_id is required to download Video-MME from Hugging Face")
+
+    try:
+        from huggingface_hub import constants as hf_constants
+        from huggingface_hub.errors import (
+            HfHubHTTPError,
+            HFValidationError,
+            LocalEntryNotFoundError,
+            OfflineModeIsEnabled,
+        )
+
+        from vllm_omni.transformers_utils.repo_utils import hf_api
+    except ImportError as e:
+        raise ImportError(
+            "Install huggingface_hub to download Video-MME from the Hub, or pass a local "
+            "--dataset-path / --videomme-video-dir with parquet + extracted videos."
+        ) from e
+
+    offline = bool(hf_constants.HF_HUB_OFFLINE)
+    try:
+        # Pull QA parquet + video/subtitle archives; skip unrelated repo files.
+        cache = hf_api().snapshot_download(
+            repo_id=rid,
+            repo_type="dataset",
+            # Offline runs otherwise resolve repo metadata over the network first and
+            # surface a connection failure instead of the missing cache entry.
+            local_files_only=offline,
+            allow_patterns=[
+                "videomme/**",
+                "*.parquet",
+                "videos_chunked_*.zip",
+                "subtitle.zip",
+                "subtitle/**",
+                "video/**",
+                "videos/**",
+            ],
+        )
+    # ``HfHubHTTPError`` also covers gated / missing repos; Video-MME requires accepting
+    # the dataset terms, so a plain token-less run lands here rather than downloading.
+    except (HFValidationError, HfHubHTTPError, LocalEntryNotFoundError, OfflineModeIsEnabled) as e:
+        if offline:
+            reason = f"HF_HUB_OFFLINE is set and it is not cached under {hf_constants.HF_HUB_CACHE}"
+        else:
+            reason = f"snapshot_download failed with {type(e).__name__}"
+
+        hints = [
+            "Point --dataset-path at a local Video-MME root (a directory holding "
+            "videomme/test-*.parquet plus video/ or videos_chunked_*.zip), or pass "
+            "--videomme-parquet / --videomme-video-dir."
+        ]
+        cached = cached_videomme_snapshots()
+        if cached:
+            hints.append(
+                "Video-MME is already cached under another repo id: " + ", ".join(str(p) for p in cached) + "."
+            )
+        if offline:
+            hints.append("Unset HF_HUB_OFFLINE to download it instead.")
+
+        raise FileNotFoundError(
+            f"Video-MME is unavailable from Hugging Face repo '{rid}': {reason}. " + " ".join(hints)
+        ) from e
+
+    root = _resolve_hf_cache_snapshot(Path(cache).resolve())
+    logger.info("Video-MME Hub snapshot ready at %s (repo=%s)", root, rid)
+    return root
+
+
+def resolve_videomme_root(dataset_path: str | None) -> Path:
+    """Return a Video-MME root containing parquet and (or zip) video assets.
+
+    * Existing local directories (absolute or relative) are used as-is.
+    * Otherwise ``dataset_path`` is treated as a Hugging Face dataset id and
+      downloaded via :func:`ensure_videomme_hub_root` (default
+      ``lmms-eval/Video-MME``).
+    """
+    local = resolve_videomme_local_root(dataset_path)
+    if local is not None:
+        return local
+    rid = (dataset_path or "").strip() or VIDEOMME_DEFAULT_HF_REPO
+    return ensure_videomme_hub_root(rid)
+
+
+def videomme_local_parquet(root: Path) -> Path | None:
+    for candidate in (
+        root / "videomme" / "test-00000-of-00001.parquet",
+        root / "test-00000-of-00001.parquet",
+    ):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def videomme_local_video_dir(root: Path) -> Path | None:
+    """Return a directory already holding extracted videos, flat or nested.
+
+    Unzipping ``videos_chunked_*.zip`` in place yields ``videos/videos_chunked_NN/data/*.mp4``,
+    so probing only for ``video/*.mp4`` would miss it and trigger a redundant re-extract of
+    the whole ~95GB archive set. Lookups below walk the tree, so any depth is acceptable.
+    """
+    for name in ("video", "videos", "data"):
+        candidate = root / name
+        if candidate.is_dir() and next(_iter_video_files(candidate), None) is not None:
+            return candidate
+    return None
+
+
+def videomme_local_subtitle_dir(root: Path) -> Path | None:
+    candidate = root / "subtitle"
+    return candidate if candidate.is_dir() else None
+
+
+def _unzip_member_flat(zf: zipfile.ZipFile, member: str, dest_dir: Path) -> None:
+    """Extract a zip member into ``dest_dir`` using only its basename (VLMEvalKit layout)."""
+    name = os.path.basename(member)
+    if not name:
+        return
+    dest = dest_dir / name
+    if dest.is_file() and dest.stat().st_size == zf.getinfo(member).file_size:
+        return
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    # Publish only after ZipFile has read and checked the complete member.
+    with tempfile.TemporaryDirectory(prefix=".videomme-", dir=dest_dir) as temporary:
+        temporary_path = Path(temporary) / name
+        with zf.open(member) as src, temporary_path.open("wb") as out:
+            shutil.copyfileobj(src, out)
+        temporary_path.replace(dest)
+
+
+def ensure_videomme_videos_extracted(root: Path) -> Path:
+    """Ensure ``video/*.mp4`` exists under ``root`` by unzipping ``videos_chunked_*.zip``."""
+    video_dir = root / "video"
+    marker = root / ".videomme_videos_extracted"
+    if marker.is_file() and video_dir.is_dir() and next(video_dir.glob("*.mp4"), None) is not None:
+        return video_dir
+
+    # Honour a tree someone unzipped by hand rather than re-extracting ~95GB alongside it.
+    existing = videomme_local_video_dir(root)
+    if existing is not None and existing != video_dir:
+        return existing
+
+    zips = [z for z in sorted(root.glob("videos_chunked_*.zip")) if z.is_file()]
+    if not zips and not video_dir.is_dir():
+        raise FileNotFoundError(f"No Video-MME videos under {root}: expected video/*.mp4 or videos_chunked_*.zip")
+
+    video_dir.mkdir(parents=True, exist_ok=True)
+    for zp in zips:
+        logger.info("Extracting Video-MME videos from %s -> %s", zp, video_dir)
+        with zipfile.ZipFile(zp, "r") as zf:
+            for member in zf.namelist():
+                if member.lower().endswith((".mp4", ".mkv", ".webm", ".avi")):
+                    _unzip_member_flat(zf, member, video_dir)
+
+    if next(_iter_video_files(video_dir), None) is None:
+        # Marking an empty tree as extracted would make every later request log
+        # "video not found" and yield a run with zero samples.
+        raise FileNotFoundError(f"No Video-MME videos under {root}: expected video/*.mp4 or videos_chunked_*.zip")
+    marker.write_text("ok", encoding="utf-8")
+    return video_dir
+
+
+def ensure_videomme_subtitles_extracted(root: Path) -> Path | None:
+    """Ensure ``subtitle/*.srt`` exists under ``root`` when ``subtitle.zip`` is present."""
+    subtitle_dir = root / "subtitle"
+    if subtitle_dir.is_dir() and next(subtitle_dir.glob("*.srt"), None) is not None:
+        return subtitle_dir
+
+    zip_path = root / "subtitle.zip"
+    if not zip_path.is_file():
+        return subtitle_dir if subtitle_dir.is_dir() else None
+
+    subtitle_dir.mkdir(parents=True, exist_ok=True)
+    logger.info("Extracting Video-MME subtitles from %s -> %s", zip_path, subtitle_dir)
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        for member in zf.namelist():
+            if member.lower().endswith(".srt"):
+                _unzip_member_flat(zf, member, subtitle_dir)
+    return subtitle_dir
+
+
+def _probe_video_duration(video_path: Path) -> float:
+    """Container duration in seconds, without decoding the stream.
+
+    Frame-counting fallbacks are deliberately avoided: Video-MME long videos run up to
+    an hour, and ``stream.frames == 0`` containers would otherwise force a full decode
+    just to learn the duration.
+    """
+    import av
+
+    with av.open(str(video_path)) as container:
+        stream = container.streams.video[0]
+        duration: float | None = None
+        if stream.duration is not None and stream.time_base is not None:
+            duration = float(stream.duration * stream.time_base)
+        elif container.duration is not None:
+            duration = container.duration / av.time_base
+        elif stream.frames and stream.average_rate:
+            duration = stream.frames / float(stream.average_rate)
+
+    if not duration or duration <= 0:
+        raise ValueError(f"Could not determine duration of {video_path}")
+    return duration
+
+
+def _decode_frames_at_timestamps(
+    video_path: Path,
+    timestamps: list[float],
+    *,
+    seek_threshold_s: float = _SEEK_THRESHOLD_S,
+) -> list[Any]:
+    """Decode one RGB ``PIL.Image`` at (or just after) each ascending timestamp.
+
+    A single forward pass over the stream — the Daily-Omni approach — is not affordable
+    here: Video-MME samples points spread across the whole video, so the last target sits
+    near the end and every frame of an hour-long file would be decoded. Targets within
+    ``seek_threshold_s`` of the decoder position are reached by decoding forward (cheaper
+    than a keyframe round-trip at 1fps spacing); farther ones seek to the preceding
+    keyframe first.
+    """
+    import av
+
+    if not timestamps:
+        return []
+
+    images: list[Any] = []
+    with av.open(str(video_path)) as container:
+        stream = container.streams.video[0]
+        stream.thread_type = "AUTO"
+        time_base = float(stream.time_base) if stream.time_base else 0.0
+        start_s = float(stream.start_time * stream.time_base) if stream.start_time else 0.0
+
+        decoder = None
+        frame = None
+        frame_time = -1.0
+        image = None
+
+        for ts in timestamps:
+            if decoder is None or ts < frame_time or (ts - frame_time) > seek_threshold_s:
+                if time_base > 0:
+                    container.seek(int((ts + start_s) / time_base), stream=stream, backward=True)
+                else:
+                    container.seek(0, stream=stream, backward=True)
+                decoder = container.decode(stream)
+                frame, image, frame_time = None, None, -1.0
+
+            while frame is None or frame_time < ts:
+                nxt = next(decoder, None)
+                if nxt is None:
+                    break
+                frame, image = nxt, None
+                if nxt.pts is not None and time_base > 0:
+                    frame_time = float(nxt.pts) * time_base - start_s
+
+            if frame is None:
+                break
+            if image is None:
+                image = frame.to_image()
+            images.append(image)
+
+    if not images:
+        raise ValueError(f"Decoded no frames from {video_path} at timestamps {timestamps[:4]}")
+    # Container duration can overshoot the real stream; repeat the last frame (decord clamping).
+    images.extend([images[-1]] * (len(timestamps) - len(images)))
+    return images
+
+
+@dataclass
+class VideoMMESampleRequest(SampleRequest):
+    """``SampleRequest`` with Video-MME gold labels for post-run accuracy scoring."""
+
+    videomme_gold_answer: str = ""
+    videomme_video_id: str = ""
+    videomme_question_id: str = ""
+    videomme_duration: str = ""
+    videomme_domain: str = ""
+    videomme_sub_category: str = ""
+    videomme_task_type: str = ""
+    videomme_skipped_rows: int = 0
+    omni_extra_body: dict[str, Any] | None = None
+    omni_chat_messages: list[dict[str, Any]] | None = None
+
+
+class VideoMMEDataset(BenchmarkDataset):
+    """Video-MME MCQ dataset for Omni bench serve (MiniCPM-oriented packing)."""
+
+    SUPPORTED_DATASET_PATHS: set[str] = {VIDEOMME_DEFAULT_HF_REPO}
+    DEFAULT_HF_DATASET_ID = VIDEOMME_DEFAULT_HF_REPO
+    IS_MULTIMODAL = True
+    DEFAULT_OUTPUT_LEN = 128
+
+    def __init__(
+        self,
+        dataset_path: str | None = None,
+        dataset_split: str = "test",
+        random_seed: int = 0,
+        video_dir: str | None = None,
+        subtitle_dir: str | None = None,
+        parquet_path: str | None = None,
+        pack_mode: VideoMMEPackMode = "minicpm-frames",
+        max_frames: int | None = None,
+        duration_filter: VideoMMEDurationFilter = "all",
+        use_subtitle: bool = False,
+        inline_local_video: bool = False,
+        trust_remote_code: bool = False,
+        dataset_subset: str | None = None,
+        no_stream: bool = False,
+        **kwargs,
+    ) -> None:
+        if pack_mode not in ("minicpm-frames", "minicpm-interleave", "video_url"):
+            raise ValueError(
+                f"pack_mode must be 'minicpm-frames', 'minicpm-interleave', or 'video_url', got {pack_mode!r}"
+            )
+        if duration_filter not in ("all", "short", "medium", "long"):
+            raise ValueError(f"duration_filter must be all|short|medium|long, got {duration_filter!r}")
+        if parquet_path is None and dataset_path is None:
+            raise ValueError("Either 'parquet_path' (local) or 'dataset_path' (HF id / local mirror) must be provided.")
+        if pack_mode == "minicpm-interleave" and duration_filter != "short":
+            logger.warning(
+                "Video-MME 'minicpm-interleave' ports the OmniEvalKit videomme_short recipe. Beyond the "
+                "short bucket, frames are spread across the whole clip and each paired audio segment covers "
+                "the gap between them (tens of seconds on medium/long videos), which inflates the audio "
+                "token count far past the 1s pairing the recipe assumes. Pass --videomme-duration short."
+            )
+
+        self.parquet_path = absolute_path(parquet_path)
+        self.dataset_path = dataset_path
+        self.dataset_split = dataset_split
+        self.dataset_subset = dataset_subset
+        self._hf_streaming = not no_stream
+        self.video_dir = absolute_path(video_dir)
+        self.subtitle_dir = absolute_path(subtitle_dir)
+        self.pack_mode: VideoMMEPackMode = pack_mode
+        self.duration_filter: VideoMMEDurationFilter = duration_filter
+        self.use_subtitle = use_subtitle
+        self.inline_local_video = inline_local_video
+        self.trust_remote_code = trust_remote_code
+        self.max_frames = int(
+            max_frames
+            if max_frames is not None
+            else (VIDEOMME_SHORT_MAX_FRAMES if pack_mode == "minicpm-interleave" else VIDEOMME_DEFAULT_MAX_FRAMES)
+        )
+        if self.max_frames <= 0:
+            raise ValueError("Video-MME max_frames must be positive")
+        #: In-process memo of content parts; the on-disk frame cache survives across runs.
+        self._frame_cache: dict[str, list[dict[str, Any]]] = {}
+        self._video_index: dict[str, Path] | None = None
+
+        super().__init__(
+            dataset_path=dataset_path,
+            random_seed=random_seed,
+            **kwargs,
+        )
+        self.load_data()
+        logger.info(
+            "Loaded Video-MME: source=%s, pack_mode=%s, max_frames=%d, duration_filter=%s, "
+            "use_subtitle=%s, video_dir=%s",
+            str(self.parquet_path) if self.parquet_path else f"{dataset_path}/{dataset_split}",
+            pack_mode,
+            self.max_frames,
+            duration_filter,
+            use_subtitle,
+            self.video_dir,
+        )
+
+    # ------------------------------------------------------------------ loading
+
+    def load_data(self) -> None:
+        """Resolve local/Hub assets once, shared by the CLI and direct callers."""
+        local_root = resolve_videomme_local_root(self.dataset_path)
+        if local_root is None and self.parquet_path is None and self.video_dir is None:
+            local_root = resolve_videomme_root(self.dataset_path)
+
+        if local_root is not None:
+            if self.parquet_path is None:
+                self.parquet_path = videomme_local_parquet(local_root)
+                if self.parquet_path is None:
+                    raise FileNotFoundError(f"No Video-MME parquet under {local_root}; pass --videomme-parquet.")
+            if self.video_dir is None:
+                self.video_dir = ensure_videomme_videos_extracted(local_root)
+            if self.use_subtitle and self.subtitle_dir is None:
+                self.subtitle_dir = ensure_videomme_subtitles_extracted(local_root)
+
+        if self.video_dir is None or not self.video_dir.is_dir():
+            raise ValueError(
+                "Video-MME requires --videomme-video-dir pointing at extracted videos, "
+                "or a local/Hub dataset root containing video/ or videos_chunked_*.zip."
+            )
+        if self.parquet_path is not None:
+            self._load_from_parquet(self.parquet_path)
+        else:
+            self._load_from_huggingface()
+
+    def _load_from_parquet(self, path: Path) -> None:
+        try:
+            import pandas as pd
+        except ImportError as e:
+            raise ImportError("pandas is required to load Video-MME parquet") from e
+        if not path.is_file():
+            raise FileNotFoundError(f"Video-MME parquet not found: {path}")
+        df = pd.read_parquet(path)
+        self._set_rows(df.to_dict(orient="records"))
+
+    def _load_from_huggingface(self) -> None:
+        if load_dataset is None:
+            raise ImportError(
+                "datasets library is required for HuggingFace Video-MME loading. "
+                "Install with: pip install datasets, or pass --videomme-parquet."
+            )
+        load_kw: dict[str, Any] = {
+            "split": self.dataset_split,
+            "streaming": self._hf_streaming,
+            "trust_remote_code": self.trust_remote_code,
+        }
+        if self.dataset_subset is not None:
+            load_kw["name"] = self.dataset_subset
+        ds = load_dataset(self.dataset_path, **load_kw)
+        self._set_rows(list(ds))
+
+    def _set_rows(self, rows: list[dict[str, Any]]) -> None:
+        """Apply the duration filter and shuffle, then expose rows as ``self.data``."""
+        if self.duration_filter != "all":
+            want = self.duration_filter.lower()
+            rows = [r for r in rows if str(r.get("duration") or "").strip().lower() == want]
+        if not getattr(self, "disable_shuffle", False) and self.random_seed is not None:
+            import random
+
+            rows = rows[:]
+            random.Random(self.random_seed).shuffle(rows)
+        self.data = _ListDatasetIterator(rows)
+
+    @staticmethod
+    def _normalize_fields(row: dict[str, Any]) -> dict[str, Any]:
+        # The parquet hands back a numpy array, whose truthiness raises, so an ``or`` chain
+        # over the alias keys is not usable here.
+        options: Any = []
+        for key in ("options", "candidates", "choices"):
+            value = row.get(key)
+            if value is not None and hasattr(value, "tolist"):
+                value = value.tolist()
+            if value is not None and len(value) > 0:
+                options = value
+                break
+        return {
+            "video_id": str(row.get("videoID") or row.get("video_id") or row.get("video") or "").strip(),
+            "question_id": str(row.get("question_id") or "").strip(),
+            "question": str(row.get("question") or "").strip(),
+            "options": [str(x) for x in list(options)],
+            "answer": str(row.get("answer") or "").strip(),
+            "duration": str(row.get("duration") or "").strip(),
+            "domain": str(row.get("domain") or "").strip(),
+            "sub_category": str(row.get("sub_category") or "").strip(),
+            "task_type": str(row.get("task_type") or "").strip(),
+        }
+
+    # ------------------------------------------------------------------ sampling
+
+    def sample(
+        self,
+        tokenizer: TokenizerLike,
+        num_requests: int,
+        output_len: int | None = None,
+        request_id_prefix: str = "",
+        no_oversample: bool = False,
+        **kwargs,
+    ) -> list[SampleRequest]:
+        if output_len is None:
+            output_len = self.DEFAULT_OUTPUT_LEN
+
+        sampled: list[SampleRequest] = []
+        cached_tokenizer = get_cached_tokenizer(tokenizer)
+        # A cold frame cache costs a few seconds per video, so the whole set takes tens of
+        # minutes before the first request goes out; report progress to keep that legible.
+        started = time.monotonic()
+        last_report = started
+        total = min(num_requests, len(self.data))
+        skipped_rows = 0
+        seen = 0
+        for seen, item in enumerate(self.data, start=1):  # noqa: B007
+            if len(sampled) >= num_requests:
+                break
+            req = self._create_sample_request(item, cached_tokenizer, output_len, request_id_prefix, len(sampled))
+            if req is not None:
+                sampled.append(req)
+            else:
+                skipped_rows += 1
+            now = time.monotonic()
+            if now - last_report >= _SAMPLE_PROGRESS_INTERVAL_S:
+                logger.info(
+                    "Video-MME preparing requests: %d/%d rows, %d ready, %.0fs elapsed",
+                    seen,
+                    total,
+                    len(sampled),
+                    now - started,
+                )
+                last_report = now
+
+        logger.info("Created %d sample requests from Video-MME in %.0fs", len(sampled), time.monotonic() - started)
+        if not sampled and num_requests > 0:
+            # Oversampling an empty list raises a bare IndexError; the usual cause is a
+            # video_dir that holds none of the videoIDs referenced by the QA rows.
+            raise ValueError(
+                f"Video-MME produced no requests from {seen} QA rows "
+                f"(duration_filter={self.duration_filter!r}, video_dir={self.video_dir}). "
+                "Check --videomme-duration and that --videomme-video-dir holds the videoIDs the rows reference."
+            )
+        for request in sampled:
+            assert isinstance(request, VideoMMESampleRequest)
+            request.videomme_skipped_rows = skipped_rows
+        self.maybe_oversample_requests(sampled, num_requests, request_id_prefix, no_oversample)
+        unique_questions = {getattr(req, "videomme_question_id", "") or req.request_id for req in sampled}
+        if len(sampled) > len(unique_questions):
+            logger.warning(
+                "Video-MME submitted %d requests covering %d unique questions "
+                "(missing media is skipped, then the remainder may be reused). "
+                "Submitted request count is not unique-question coverage.",
+                len(sampled),
+                len(unique_questions),
+            )
+        return sampled
+
+    def _create_sample_request(
+        self,
+        qa_item: dict[str, Any],
+        tokenizer: TokenizerLike,
+        output_len: int,
+        request_id_prefix: str,
+        index: int,
+    ) -> SampleRequest | None:
+        fields = self._normalize_fields(qa_item)
+        if not fields["video_id"] or not fields["question"]:
+            logger.warning("Skipping Video-MME item without videoID/question: %r", fields["video_id"])
+            return None
+
+        mm_payload, omni_extra = self._compose_multimodal(fields["video_id"])
+        if not mm_payload:
+            return None
+
+        user_text = self._build_user_prompt(fields)
+        return VideoMMESampleRequest(
+            prompt=user_text,
+            prompt_len=len(tokenizer.encode(user_text)),
+            expected_output_len=output_len,
+            multi_modal_data=None,
+            request_id=f"{request_id_prefix}{index}",
+            videomme_gold_answer=fields["answer"],
+            videomme_video_id=fields["video_id"],
+            videomme_question_id=fields["question_id"],
+            videomme_duration=fields["duration"],
+            videomme_domain=fields["domain"],
+            videomme_sub_category=fields["sub_category"],
+            videomme_task_type=fields["task_type"],
+            omni_extra_body=omni_extra,
+            omni_chat_messages=self._build_openai_messages(mm_payload, user_text),
+        )
+
+    # ------------------------------------------------------------------ prompt
+
+    @staticmethod
+    def _format_options(options: list[str]) -> str:
+        """Match OmniEvalKit ``_build_options_prompt`` (``A. content`` per line).
+
+        The Hub parquet already ships options as ``"A. content"``. Existing labels are
+        dropped before relabelling so the prompt never reads ``A. A. content``, but only
+        when *every* option carries one — otherwise contents such as ``A.M. shift`` would
+        be truncated.
+        """
+        if not options:
+            return ""
+        matches = [_OPTION_PREFIX_RE.match(str(o).strip()) for o in options]
+        relabel = all(m is not None and m.group(1) == key for m, key in zip(matches, _OPTION_LETTERS))
+        lines = []
+        for key, raw, m in zip(_OPTION_LETTERS, options, matches):
+            content = m.group(2).strip() if (relabel and m is not None) else str(raw).strip()
+            lines.append(f"{key}. {content}")
+        return "\n".join(lines)
+
+    def _build_user_prompt(self, fields: dict[str, Any]) -> str:
+        prompt = VIDEOMME_USER_PROMPT_TEMPLATE.format(
+            question=fields["question"],
+            options=self._format_options(fields["options"]),
+        )
+        if self.use_subtitle:
+            subs = self._load_subtitle_text(fields["video_id"])
+            if subs:
+                prompt = f"This video's subtitles are listed below:\n{subs}\n{prompt}"
+        return prompt
+
+    def _load_subtitle_text(self, video_id: str) -> str:
+        if not self.subtitle_dir:
+            return ""
+        path = self.subtitle_dir / f"{video_id}.srt"
+        if not path.is_file():
+            return ""
+        try:
+            raw = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            return ""
+        lines = [
+            s.replace("\\N", " ")
+            for s in (line.strip() for line in raw.splitlines())
+            if s and not s.isdigit() and "-->" not in s
+        ]
+        return "\n".join(lines)
+
+    def _build_openai_messages(
+        self,
+        mm_payload: dict[str, Any] | list[dict[str, Any]],
+        user_text: str,
+    ) -> list[dict[str, Any]]:
+        mm_list = mm_payload if isinstance(mm_payload, list) else [mm_payload]
+        messages: list[dict[str, Any]] = []
+        if MINICPM_OMNI_SYSTEM_TEXT:
+            messages.append({"role": "system", "content": [{"type": "text", "text": MINICPM_OMNI_SYSTEM_TEXT}]})
+        messages.append({"role": "user", "content": [*mm_list, {"type": "text", "text": user_text}]})
+        return messages
+
+    # ------------------------------------------------------------------ media
+
+    def _video_path_index(self) -> dict[str, Path]:
+        """Lazily map ``videoID -> path`` so nested layouts resolve after the flat probe misses."""
+        if self._video_index is None:
+            index: dict[str, Path] = {}
+            if self.video_dir is not None:
+                for path in _iter_video_files(self.video_dir):
+                    index.setdefault(path.stem, path)
+            logger.info("Indexed %d Video-MME video files under %s", len(index), self.video_dir)
+            self._video_index = index
+        return self._video_index
+
+    def _resolve_local_video_path(self, video_id: str) -> Path | None:
+        if not self.video_dir or not video_id:
+            return None
+        for p in (
+            self.video_dir / f"{video_id}.mp4",
+            self.video_dir / f"{video_id}.MP4",
+            self.video_dir / f"{video_id}.mkv",
+            self.video_dir / video_id / f"{video_id}.mp4",
+        ):
+            if p.is_file():
+                return p
+        return self._video_path_index().get(video_id)
+
+    def _media_part(self, path: Path, *, typ: str, mime: str) -> dict[str, Any]:
+        path = path.expanduser().resolve()
+        if self.inline_local_video:
+            b64 = base64.b64encode(path.read_bytes()).decode("ascii")
+            return {"type": typ, typ: {"url": f"data:{mime};base64,{b64}"}}
+        return {"type": typ, typ: {"url": path.as_uri()}}
+
+    def _compose_multimodal(
+        self,
+        video_id: str,
+    ) -> tuple[dict[str, Any] | list[dict[str, Any]] | None, dict[str, Any] | None]:
+        # OmniEvalKit ``minicpmo.py`` uses max_slice_nums=1 / use_image_id=False whenever the
+        # sample carries a video path: 9 slices per frame would blow past max_model_len and
+        # <image_id>N</image_id> would label each frame as a separate picture.
+        extra: dict[str, Any] = {
+            "mm_processor_kwargs": {
+                "use_audio_in_video": False,
+                "max_slice_nums": 1,
+                "use_image_id": False,
+            }
+        }
+
+        if self.pack_mode == "video_url":
+            video_path = self._resolve_local_video_path(video_id)
+            if video_path is None:
+                logger.warning("Video-MME video not found for video_id=%r under %s", video_id, self.video_dir)
+                return None, None
+            return self._media_part(video_path, typ="video_url", mime="video/mp4"), extra
+
+        parts = self._get_minicpm_frame_parts(video_id, include_audio=self.pack_mode == "minicpm-interleave")
+        if not parts:
+            return None, None
+        return parts, extra
+
+    def _frame_cache_dir(self, video_id: str, *, include_audio: bool) -> Path | None:
+        """Where the on-disk frame dump lives, or ``None`` when there is no ``video_dir`` to host it."""
+        if self.video_dir is None:
+            return None
+        tag = f"f{self.max_frames}{'_av' if include_audio else ''}"
+        return self.video_dir / ".minicpm_videomme_frames" / video_id / tag
+
+    def _cached_parts_from_disk(self, cache_dir: Path, *, include_audio: bool) -> list[dict[str, Any]] | None:
+        """Rebuild content parts from a previous run's frame dump, or ``None`` on a miss."""
+        manifest = cache_dir / "manifest.json"
+        if not manifest.is_file():
+            return None
+        try:
+            count = int(json.loads(manifest.read_text(encoding="utf-8"))["count"])
+        except (OSError, ValueError, KeyError, TypeError):
+            return None
+
+        parts: list[dict[str, Any]] = []
+        for i in range(count):
+            frame_path = cache_dir / f"frame_{i:04d}.jpg"
+            if not frame_path.is_file() or frame_path.stat().st_size == 0:
+                return None
+            parts.append({"type": "image_url", "image_url": {"url": frame_path.expanduser().resolve().as_uri()}})
+            if include_audio:
+                audio_path = cache_dir / f"audio_{i:04d}.wav"
+                if not audio_path.is_file() or audio_path.stat().st_size == 0:
+                    return None
+                parts.append({"type": "audio_url", "audio_url": {"url": audio_path.expanduser().resolve().as_uri()}})
+        return parts or None
+
+    def _get_minicpm_frame_parts(
+        self,
+        video_id: str,
+        *,
+        include_audio: bool,
+    ) -> list[dict[str, Any]] | None:
+        cache_key = f"{video_id}|audio={int(include_audio)}|frames={self.max_frames}"
+        cached = self._frame_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        # Inline base64 must not be persisted or retained: 900 videos would pin GBs of RSS.
+        cache_dir = None if self.inline_local_video else self._frame_cache_dir(video_id, include_audio=include_audio)
+        if cache_dir is not None:
+            disk_parts = self._cached_parts_from_disk(cache_dir, include_audio=include_audio)
+            if disk_parts is not None:
+                self._frame_cache[cache_key] = disk_parts
+                return disk_parts
+
+        video_path = self._resolve_local_video_path(video_id)
+        if video_path is None:
+            logger.warning(
+                "Video-MME MiniCPM pack requires local video under video_dir=%s for video_id=%r",
+                self.video_dir,
+                video_id,
+            )
+            return None
+
+        try:
+            frames, audio_segments = self._extract_frames_and_audio(
+                video_path,
+                include_audio=include_audio,
+                max_num_frames=self.max_frames,
+            )
+        except Exception:
+            logger.exception("Failed Video-MME frame extract for video_id=%r path=%s", video_id, video_path)
+            return None
+
+        if not frames:
+            logger.warning("No frames extracted for video_id=%r", video_id)
+            return None
+        if include_audio and len(audio_segments) != len(frames):
+            n = min(len(frames), len(audio_segments))
+            frames, audio_segments = frames[:n], audio_segments[:n]
+
+        if cache_dir is not None:
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            # A failed rebuild must not leave a manifest advertising a complete cache.
+            (cache_dir / "manifest.json").unlink(missing_ok=True)
+
+        parts: list[dict[str, Any]] = []
+        for i, frame in enumerate(frames):
+            parts.append(
+                self._emit_media(cache_dir, f"frame_{i:04d}.jpg", _pil_to_jpeg_bytes(frame), "image_url", "image/jpeg")
+            )
+            if include_audio:
+                parts.append(
+                    self._emit_media(
+                        cache_dir,
+                        f"audio_{i:04d}.wav",
+                        _numpy_to_wav_bytes(audio_segments[i]),
+                        "audio_url",
+                        "audio/wav",
+                    )
+                )
+
+        if cache_dir is not None:
+            (cache_dir / "manifest.json").write_text(json.dumps({"count": len(frames)}), encoding="utf-8")
+            self._frame_cache[cache_key] = parts
+        logger.debug("Video-MME packed video_id=%r frames=%d parts=%d", video_id, len(frames), len(parts))
+        return parts
+
+    @staticmethod
+    def _emit_media(cache_dir: Path | None, name: str, payload: bytes, typ: str, mime: str) -> dict[str, Any]:
+        """Write ``payload`` to the frame cache and return a file URL part, or inline base64."""
+        if cache_dir is None:
+            b64 = base64.b64encode(payload).decode("ascii")
+            return {"type": typ, typ: {"url": f"data:{mime};base64,{b64}"}}
+        path = (cache_dir / name).expanduser().resolve()
+        # Reaching this path means the cache missed validation. Replace residual
+        # files as well: a nonempty file may be from an interrupted write.
+        path.write_bytes(payload)
+        return {"type": typ, typ: {"url": path.as_uri()}}
+
+    @staticmethod
+    def _sample_timestamps(duration: float, max_num_frames: int) -> list[float]:
+        """Port of OmniEvalKit ``_sample_video_frame_indices`` timestamps."""
+        if duration > max_num_frames:
+            return [round(i * 0.1, 1) for i in _uniform_sample_indices(int(duration / 0.1), max_num_frames)]
+        # OmniEvalKit uses int(duration); clamp to >=1 so sub-second clips still yield a frame.
+        return [float(i) for i in range(max(1, int(duration)))]
+
+    @classmethod
+    def _extract_frames_and_audio(
+        cls,
+        video_path: Path,
+        *,
+        include_audio: bool,
+        max_num_frames: int,
+    ) -> tuple[list[Any], list[Any]]:
+        import numpy as np
+        from vllm.multimodal.media.audio import load_audio
+
+        duration = _probe_video_duration(video_path)
+        timestamps = cls._sample_timestamps(duration, max_num_frames)
+        frames = _decode_frames_at_timestamps(video_path, timestamps)
+
+        audio_segments: list[Any] = []
+        if include_audio:
+            audio_np, sr = load_audio(str(video_path), sr=_MINICPM_AUDIO_SR, mono=True)
+            for i, start_time in enumerate(timestamps):
+                end_time = timestamps[i + 1] if i < len(timestamps) - 1 else duration
+                segment = audio_np[int(start_time * sr) : int(end_time * sr)]
+                if i == len(timestamps) - 1 and len(segment) < 1600:
+                    segment = np.concatenate([segment, np.zeros(1600 - len(segment), dtype=segment.dtype)])
+                if len(segment) == 0:
+                    segment = np.zeros(1600, dtype=np.float32)
+                audio_segments.append(segment)
+
+        return frames, audio_segments
diff --git a/vllm_omni/benchmarks/data_modules/videomme_eval.py b/vllm_omni/benchmarks/data_modules/videomme_eval.py
new file mode 100644
index 000000000..cb8107e7a
--- /dev/null
+++ b/vllm_omni/benchmarks/data_modules/videomme_eval.py
@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Video-MME multiple-choice accuracy scoring for vLLM-Omni bench serve.
+
+Answer extraction ports ``extract_characters_regex`` from the official Video-MME
+script (MME-Benchmarks ``eval_your_results.py``, also used by lmms-eval).
+
+**Denominator:** responses where no A–D can be extracted are counted as wrong, which
+matches lmms-eval and OmniEvalKit (the numbers this bench is compared against). The
+official standalone script instead drops them from ``answered``; ``videomme_parse_failed``
+is reported so that view can be recovered.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import regex as re
+from vllm.benchmarks.lib.endpoint_request_func import RequestFuncOutput
+
+from vllm_omni.benchmarks.data_modules.videomme_dataset import VideoMMESampleRequest
+
+_VALID = frozenset("ABCD")
+
+VIDEOMME_DURATION_KEYS: tuple[str, ...] = ("short", "medium", "long")
+
+#: Report dimension -> ``VideoMMESampleRequest`` attribute (official Video-MME breakdowns).
+_DIMENSIONS: dict[str, str] = {
+    "duration": "videomme_duration",
+    "domain": "videomme_domain",
+    "sub_category": "videomme_sub_category",
+    "task": "videomme_task_type",
+}
+
+# Official prefix list, with the two accidental string concatenations in the upstream
+# tuple (missing commas after "The best option is" / "Best answer:") split apart.
+_ANSWER_PREFIXES = (
+    "The best answer is",
+    "The correct answer is",
+    "The answer is",
+    "The answer",
+    "The best option is",
+    "The correct option is",
+    "Best answer:",
+    "Best option:",
+    "Answer:",
+    "Option:",
+    "The correct answer",
+    "The correct option",
+)
+
+
+def extract_characters_regex(text: str | None) -> str | None:
+    """Port of official Video-MME / lmms-eval ``extract_characters_regex``."""
+    if not text:
+        return None
+    s = str(text).strip()
+    for prefix in _ANSWER_PREFIXES:
+        s = s.replace(prefix, "")
+    if len(s.split()) > 10 and not re.search(r"[ABCD]", s):
+        return None
+    match = re.search(r"[ABCD]", s)
+    return match.group(0) if match else None
+
+
+def normalize_gold_answer(gold: str) -> str | None:
+    g = (gold or "").strip().upper()
+    if len(g) == 1 and g in _VALID:
+        return g
+    m = re.search(r"([ABCD])\b", g)
+    return m.group(1).upper() if m else None
+
+
+def _bucket(req: VideoMMESampleRequest, dimension: str) -> str:
+    value = (getattr(req, _DIMENSIONS[dimension]) or "").strip()
+    if dimension == "duration":
+        return value.lower()
+    return value or "unknown"
+
+
+def compute_videomme_accuracy_metrics(
+    input_requests: list[Any],
+    outputs: list[RequestFuncOutput],
+    *,
+    include_per_item: bool = False,
+) -> dict[str, Any] | None:
+    """If all requests are :class:`VideoMMESampleRequest`, compute accuracy stats.
+
+    Rows without a gold answer are skipped (``no_gold``). Failed HTTP requests are
+    excluded from ``videomme_accuracy`` and counted in
+    ``videomme_accuracy_incl_http_fail`` instead. The accuracy wrapper gate
+    (``_validate_videomme``) additionally rejects HTTP failures, duplicate question
+    IDs, skipped source rows and missing gold answers. Direct
+    ``vllm bench serve`` still reports both metrics without that completeness
+    check.
+
+    ``videomme_submitted`` / ``videomme_unique_question_ids`` show when
+    oversampling made the request count differ from unique question coverage.
+    ``videomme_skipped_rows`` counts source rows skipped during sampling (for
+    example, missing or undecodable media), before any oversampling.
+    """
+    if not input_requests or len(input_requests) != len(outputs):
+        return None
+    if not all(isinstance(r, VideoMMESampleRequest) for r in input_requests):
+        return None
+
+    stats: dict[str, dict[str, dict[str, int]]] = {
+        dim: ({k: {"correct": 0, "total": 0} for k in VIDEOMME_DURATION_KEYS} if dim == "duration" else {})
+        for dim in _DIMENSIONS
+    }
+    items: list[dict[str, Any]] = []
+    correct = evaluated = no_gold = request_failed = parse_failed = 0
+
+    for req, out in zip(input_requests, outputs, strict=True):
+        assert isinstance(req, VideoMMESampleRequest)
+        gold_raw = (req.videomme_gold_answer or "").strip()
+        buckets = {dim: _bucket(req, dim) for dim in _DIMENSIONS}
+        row: dict[str, Any] = {
+            "request_id": req.request_id,
+            "video_id": req.videomme_video_id,
+            "question_id": req.videomme_question_id,
+            **buckets,
+        }
+
+        if not gold_raw:
+            no_gold += 1
+            if include_per_item:
+                items.append({**row, "skipped": True, "reason": "no_gold"})
+            continue
+
+        evaluated += 1
+        gold_norm = normalize_gold_answer(gold_raw)
+        pred = extract_characters_regex(out.generated_text) if out.success else None
+        is_correct = pred is not None and pred.upper() == (gold_norm or gold_raw).upper()
+
+        if not out.success:
+            request_failed += 1
+        else:
+            if pred is None:
+                parse_failed += 1
+            # Only successful responses enter the per-dimension denominators, mirroring
+            # the overall videomme_accuracy definition.
+            for dim, key in buckets.items():
+                bucket = stats[dim].setdefault(key, {"correct": 0, "total": 0})
+                bucket["total"] += 1
+                bucket["correct"] += int(is_correct)
+
+        if is_correct:
+            correct += 1
+
+        if include_per_item:
+            items.append(
+                {
+                    **row,
+                    "gold": gold_raw,
+                    "gold_normalized": gold_norm,
+                    "predicted": pred,
+                    "correct": is_correct,
+                    "parse_failed": out.success and pred is None,
+                    **({"error": (out.error or "")[:500]} if not out.success else {}),
+                }
+            )
+
+    evaluated_ok = evaluated - request_failed
+    unique_question_ids = {
+        (req.videomme_question_id or req.request_id) for req in input_requests if isinstance(req, VideoMMESampleRequest)
+    }
+    result: dict[str, Any] = {
+        "videomme_accuracy": (correct / evaluated_ok) if evaluated_ok else None,
+        "videomme_accuracy_incl_http_fail": (correct / evaluated) if evaluated else None,
+        "videomme_correct": correct,
+        "videomme_evaluated": evaluated,
+        "videomme_evaluated_ok": evaluated_ok,
+        "videomme_no_gold": no_gold,
+        "videomme_request_failed": request_failed,
+        "videomme_parse_failed": parse_failed,
+        "videomme_submitted": len(input_requests),
+        "videomme_unique_question_ids": len(unique_question_ids),
+        "videomme_skipped_rows": max(req.videomme_skipped_rows for req in input_requests),
+    }
+    for dim, per_bucket in stats.items():
+        result[f"videomme_per_{dim}"] = {k: dict(v) for k, v in per_bucket.items()}
+        result[f"videomme_per_{dim}_accuracy"] = {
+            k: (v["correct"] / v["total"]) if v["total"] else None for k, v in per_bucket.items()
+        }
+    if include_per_item:
+        result["videomme_eval_items"] = items
+    return result
+
+
+def print_videomme_accuracy_summary(metrics: dict[str, Any]) -> None:
+    """Pretty-print the Video-MME accuracy block (stdout)."""
+    acc = metrics.get("videomme_accuracy")
+    if acc is None and not metrics.get("videomme_evaluated", 0):
+        return
+
+    print("{s:{c}^{n}}".format(s=" Video-MME accuracy (MCQ) ", n=50, c="="))
+    ok = int(metrics.get("videomme_evaluated_ok", 0) or 0)
+    if ok and acc is not None:
+        print(f"Overall Accuracy: {metrics.get('videomme_correct', 0)}/{ok} = {acc:.2%}")
+    else:
+        print("Overall Accuracy: 0/0 = N/A (no successful HTTP responses)")
+    for label, key in (
+        ("Submitted (gold present):", "videomme_evaluated"),
+        ("Successful HTTP (denominator):", "videomme_evaluated_ok"),
+        ("Correct:", "videomme_correct"),
+        ("Skipped (no gold):", "videomme_no_gold"),
+        ("HTTP failed:", "videomme_request_failed"),
+        ("Parsed OK but no A-D found:", "videomme_parse_failed"),
+        ("Submitted requests:", "videomme_submitted"),
+        ("Unique questions:", "videomme_unique_question_ids"),
+        ("Skipped source rows:", "videomme_skipped_rows"),
+    ):
+        print(f"{label:<40} {metrics.get(key, 0):<10}")
+
+    for dim, title in (
+        ("duration", "Duration"),
+        ("domain", "Domain"),
+        ("sub_category", "Sub Category"),
+        ("task", "Task Type"),
+    ):
+        per_acc = metrics.get(f"videomme_per_{dim}_accuracy") or {}
+        if not per_acc:
+            continue
+        counts = metrics.get(f"videomme_per_{dim}") or {}
+        names = VIDEOMME_DURATION_KEYS if dim == "duration" else sorted(per_acc)
+        print(f"\n--- Accuracy by {title} ---")
+        for name in names:
+            st = counts.get(name) or {}
+            total = int(st.get("total", 0) or 0)
+            value = per_acc.get(name)
+            if total and value is not None:
+                print(f"{name}: {int(st.get('correct', 0))}/{total} = {value:.2%}")
+            else:
+                print(f"{name}: 0/0 = N/A")
+    print("=" * 50)
diff --git a/vllm_omni/benchmarks/duplex/omni_duplex_eval_eval.py b/vllm_omni/benchmarks/duplex/omni_duplex_eval_eval.py
index a92376bd7..1dfa68246 100644
--- a/vllm_omni/benchmarks/duplex/omni_duplex_eval_eval.py
+++ b/vllm_omni/benchmarks/duplex/omni_duplex_eval_eval.py
@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 import json
-import subprocess
 from pathlib import Path
 from typing import Any
 
@@ -168,7 +167,7 @@ def _extract_frames(path: str | Path, timestamps: list[float]) -> list[bytes]:
     for timestamp in timestamps:
         try:
             frame = extract_jpeg(path, timestamp=timestamp)
-        except (OSError, subprocess.CalledProcessError, ValueError):
+        except (OSError, ValueError):
             continue
         if frame.startswith(b"\xff\xd8"):
             frames.append(frame)
diff --git a/vllm_omni/benchmarks/duplex/omni_duplex_eval_media.py b/vllm_omni/benchmarks/duplex/omni_duplex_eval_media.py
index b45686fb8..ae198902a 100644
--- a/vllm_omni/benchmarks/duplex/omni_duplex_eval_media.py
+++ b/vllm_omni/benchmarks/duplex/omni_duplex_eval_media.py
@@ -1,12 +1,18 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Small ffmpeg-backed media helpers used by the duplex runner and judge."""
+"""Small media helpers used by the duplex runner and judge.
+
+Video and audio decoding is delegated to PyAV (``av``), which bundles a pinned
+FFmpeg version, so results do not depend on whatever ffmpeg binary the host
+provides (see #7364: host ffmpeg 4.4.2 could hang forever on some HEVC clips).
+"""
 
 from __future__ import annotations
 
+import io
+import logging
 import os
-import subprocess
 import tempfile
 import wave
 from collections.abc import Iterator
@@ -15,10 +21,7 @@ from typing import Any
 
 from vllm_omni.experimental.fullduplex.client import PCM16_BYTES_PER_SAMPLE, PCM16_SAMPLE_RATE
 
-
-def _run_ffmpeg(args: list[str]) -> bytes:
-    result = subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], capture_output=True, check=True)
-    return result.stdout
+logger = logging.getLogger(__name__)
 
 
 def materialize_media(value: Any, output_dir: str | Path, stem: str, suffix: str) -> Path:
@@ -77,31 +80,73 @@ def _write_media_bytes(payload: bytes | bytearray, output_dir: str | Path, stem:
 
 
 def video_duration(path: str | Path) -> float:
-    result = subprocess.run(
-        ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", str(path)],
-        capture_output=True,
-        text=True,
-        check=True,
-    )
-    return max(0.0, float(result.stdout.strip()))
+    """Return the video duration in seconds using PyAV (no ffprobe subprocess).
+
+    Raises:
+        OSError: If the file cannot be opened (missing file, permission denied, etc.).
+        ValueError: If the file is corrupt or cannot be parsed (e.g.
+            :class:`av.error.InvalidDataError`).
+    """
+    import av
+
+    try:
+        with av.open(str(path)) as container:
+            # Container-level duration is the same source ffprobe's format=duration reads.
+            if container.duration and container.duration > 0:
+                return max(0.0, container.duration / av.time_base)
+            if container.streams.video:
+                stream = container.streams.video[0]
+                if stream.duration is not None and stream.time_base is not None:
+                    return max(0.0, float(stream.duration * stream.time_base))
+            # Last resort: count decodable frames.
+            if container.streams.video:
+                stream = container.streams.video[0]
+                stream.thread_type = "AUTO"
+                frame_count = sum(1 for _ in container.decode(stream))
+                if stream.average_rate and frame_count > 0:
+                    return frame_count / float(stream.average_rate)
+            return 0.0
+    except (OSError, ValueError) as exc:
+        logger.warning("Failed to read video duration from %s: %s", path, exc)
+        raise
 
 
 def extract_jpeg(path: str | Path, *, timestamp: float, quality: int = 3) -> bytes:
-    return _run_ffmpeg(
-        [
-            "-ss",
-            f"{max(0.0, timestamp):.3f}",
-            "-i",
-            str(path),
-            "-frames:v",
-            "1",
-            "-q:v",
-            str(quality),
-            "-f",
-            "image2",
-            "pipe:1",
-        ]
-    )
+    """Extract a single JPEG frame at ``timestamp`` using PyAV.
+
+    ``quality`` follows the ffmpeg ``-q:v`` convention (lower = better, 1..31)
+    and is mapped to the PIL JPEG quality scale (higher = better).
+
+    After ``seek`` the function continues decoding until a frame with PTS >=
+    target_pts is found, matching the ``ffmpeg -ss`` semantic of returning the
+    first decodable frame *at or after* the requested timestamp.
+
+    Raises:
+        ValueError: If the file contains no video stream or no frame could be decoded.
+    """
+    import av
+
+    with av.open(str(path)) as container:
+        if not container.streams.video:
+            raise ValueError(f"no video stream in {path}")
+        stream = container.streams.video[0]
+        stream.thread_type = "AUTO"
+        time_base = stream.time_base
+        if time_base is None:
+            time_base = 1 / 90000
+        target_pts = int(max(0.0, timestamp) / time_base)
+        container.seek(target_pts, any_frame=False, backward=True, stream=stream)
+        closest_frame = None
+        for frame in container.decode(stream):
+            closest_frame = frame
+            if frame.pts is not None and frame.pts >= target_pts:
+                break
+        if closest_frame is not None:
+            image = closest_frame.to_image()
+            buf = io.BytesIO()
+            image.save(buf, format="JPEG", quality=_ffmpeg_q_to_pil_quality(quality))
+            return buf.getvalue()
+    raise ValueError(f"no decodable video frames in {path} at timestamp {timestamp}")
 
 
 def iter_jpegs(
@@ -113,7 +158,8 @@ def iter_jpegs(
     while timestamp < end:
         try:
             frame = extract_jpeg(path, timestamp=timestamp, quality=quality)
-        except (OSError, subprocess.CalledProcessError):
+        except (OSError, ValueError) as exc:
+            logger.warning("Frame extraction failed at %.3fs for %s: %s", timestamp, path, exc)
             break
         if frame:
             yield timestamp, frame
@@ -132,9 +178,28 @@ def read_audio_pcm16(path: str | Path) -> bytes:
                     and wav_file.getcomptype() == "NONE"
                 ):
                     return wav_file.readframes(wav_file.getnframes())
-        except wave.Error:
+        except (wave.Error, OSError):
             pass
-    return _run_ffmpeg(["-i", str(source), "-f", "s16le", "-ac", "1", "-ar", str(PCM16_SAMPLE_RATE), "pipe:1"])
+    # Non-WAV audio: decode and resample to mono s16 PCM via PyAV.
+    import av
+    import numpy as np
+
+    try:
+        resampler = av.AudioResampler(format="s16", layout="mono", rate=PCM16_SAMPLE_RATE)
+        chunks: list[Any] = []
+        with av.open(str(source)) as container:
+            for frame in container.decode(audio=0):
+                for resampled in resampler.resample(frame):
+                    chunks.append(resampled.to_ndarray())
+            # Flush the resampler to drain buffered tail samples (P3).
+            for resampled in resampler.resample(None):
+                chunks.append(resampled.to_ndarray())
+        if not chunks:
+            return b""
+        return np.concatenate([chunk.reshape(-1) for chunk in chunks]).astype(np.int16).tobytes()
+    except (OSError, ValueError) as exc:
+        logger.warning("Failed to decode audio in %s: %s", source, exc)
+        raise
 
 
 def iter_av_units(
@@ -150,3 +215,9 @@ def iter_av_units(
             frame = next_frame[1]
             next_frame = next(frame_iter, None)
         yield audio_pcm16[offset : offset + unit_bytes], frame
+
+
+def _ffmpeg_q_to_pil_quality(quality: int) -> int:
+    """Map ffmpeg ``-q:v`` (1..31, lower = better) to PIL JPEG quality (1..100, higher = better)."""
+    ffmpeg_q = max(1, min(31, int(quality)))
+    return max(1, min(100, round(95 - (ffmpeg_q - 1) * (93 / 30))))
diff --git a/vllm_omni/benchmarks/patch/patch.py b/vllm_omni/benchmarks/patch/patch.py
index bee910c90..87fdb2daa 100644
--- a/vllm_omni/benchmarks/patch/patch.py
+++ b/vllm_omni/benchmarks/patch/patch.py
@@ -14,7 +14,7 @@ import time
 import traceback
 import uuid
 import wave
-from collections.abc import Callable, Iterable, Mapping
+from collections.abc import Callable, Iterable, Iterator, Mapping
 from dataclasses import dataclass, replace
 from datetime import datetime
 from pathlib import Path
@@ -67,6 +67,12 @@ from vllm_omni.benchmarks.data_modules.seed_tts_dataset import (
 )
 from vllm_omni.benchmarks.data_modules.sound_effect_dataset import SoundEffectDataset
 from vllm_omni.benchmarks.data_modules.ttsd_dataset import TTSDDataset
+from vllm_omni.benchmarks.data_modules.videomme_dataset import (
+    VIDEOMME_DEFAULT_HF_REPO,
+    VideoMMEDataset,
+    VideoMMESampleRequest,
+    resolve_videomme_local_root,
+)
 from vllm_omni.benchmarks.omniinteract import (
     VIDEO_FPS,
     OmniInteractBenchmarkConfig,
@@ -283,14 +289,14 @@ def _merge_extra_body_mm_kwargs(base: dict | None, overlay: dict | None) -> dict
     return out
 
 
-def _attach_daily_omni_to_request_func_input(sample: SampleRequest, rfi: RequestFuncInput) -> None:
-    """Apply per-request OpenAI fields (``mm_processor_kwargs``, messages) for Daily-Omni."""
-    if not isinstance(sample, DailyOmniSampleRequest):
+def _attach_omni_chat_to_request_func_input(sample: SampleRequest, rfi: RequestFuncInput) -> None:
+    """Apply per-request OpenAI fields (``mm_processor_kwargs``, messages) for Daily-Omni / Video-MME."""
+    if not isinstance(sample, (DailyOmniSampleRequest, VideoMMESampleRequest)):
         return
     rfi.extra_body = _merge_extra_body_mm_kwargs(rfi.extra_body, sample.omni_extra_body)
     if sample.omni_chat_messages is not None:
         setattr(rfi, "omni_chat_messages", sample.omni_chat_messages)
-    else:
+    elif isinstance(sample, DailyOmniSampleRequest):
         setattr(rfi, "mm_position", sample.omni_chat_mm_position)
 
 
@@ -334,6 +340,29 @@ def _attach_omniinteract_to_request_func_input(sample: SampleRequest, rfi: Reque
     setattr(rfi, "omniinteract_prepared_input", sample.omniinteract_prepared_input)
 
 
+def _async_limiter(max_concurrency: int | None) -> contextlib.AbstractAsyncContextManager[object]:
+    if max_concurrency:
+        return asyncio.Semaphore(max_concurrency)
+    return contextlib.nullcontext()
+
+
+def _as_float(value: object, default: float = 0.0) -> float:
+    """Coerce loosely-typed metric dict values to ``float`` for mypy.
+
+    Strings are parsed rather than dropped: JSON-sourced session metrics such as
+    ``audio_duration_ms`` may arrive quoted, and silently reporting ``0.0`` would
+    corrupt the derived TTFT / RTF numbers.
+    """
+    if isinstance(value, bool) or value is None:
+        return default
+    if isinstance(value, (int, float, str)):
+        try:
+            return float(value)
+        except ValueError:
+            return default
+    return default
+
+
 def _append_error(existing: str, message: str) -> str:
     return f"{existing}\n{message}" if existing else message
 
@@ -404,9 +433,13 @@ def _prepare_omniinteract_batch(input_requests: list[SampleRequest]) -> None:
     for sample in input_requests:
         if not isinstance(sample, OmniInteractSampleRequest):
             continue
-        root = sample.omniinteract_options.output_root.resolve()
+        options = sample.omniinteract_options
+        case = sample.omniinteract_case
+        if options is None or case is None:
+            raise RuntimeError("OmniInteract benchmark input lost its dataset identity")
+        root = options.output_root.resolve()
         roots.add(root)
-        clear_case_artifacts(sample.omniinteract_options.output_root, sample.omniinteract_case)
+        clear_case_artifacts(options.output_root, case)
     for root in roots:
         clear_batch_artifacts(root)
 
@@ -428,11 +461,55 @@ def _daily_omni_repo_from_args(args) -> str | None:
     return None
 
 
+def _looks_like_hf_dataset_id(value: str) -> bool:
+    """True for Hub ids such as ``org/name``; false for local paths."""
+    raw = value.strip()
+    if not raw or raw.startswith((".", "~", "/")) or "\\" in raw:
+        return False
+    parts = raw.split("/")
+    return len(parts) == 2 and all(part.strip() and part.strip() not in (".", "..") for part in parts)
+
+
+def _videomme_repo_from_args(args, *, explicit: bool = False) -> str | None:
+    """Resolve a Hugging Face repo id for Video-MME from CLI args.
+
+    ``--dataset-name hf`` auto-detect only recognizes the official
+    ``lmms-eval/Video-MME`` id so a custom Hub dataset is not silently treated
+    as Video-MME. Explicit ``--dataset-name videomme`` accepts any ``org/name``
+    Hub id (for ``--videomme-repo`` / ``VLLM_VIDEOMME_REPO`` overrides) and
+    raises when ``--dataset-path`` is neither a local directory nor a Hub id.
+    """
+    official = {p.lower() for p in VideoMMEDataset.SUPPORTED_DATASET_PATHS}
+    official.add(VIDEOMME_DEFAULT_HF_REPO.lower())
+    candidates: list[str] = []
+    for attr in ("dataset_path", "hf_name"):
+        val = getattr(args, attr, None)
+        if isinstance(val, str) and val.strip():
+            candidates.append(val.strip())
+    for raw in candidates:
+        if resolve_videomme_local_root(raw) is not None:
+            continue
+        if raw.lower() in official:
+            return raw
+        if explicit and _looks_like_hf_dataset_id(raw):
+            return raw
+        if explicit:
+            raise ValueError(
+                f"Unsupported Video-MME --dataset-path={raw!r}. Pass an existing local "
+                "directory, a Hugging Face dataset id (org/name), or omit --dataset-path "
+                f"to use {VIDEOMME_DEFAULT_HF_REPO}."
+            )
+    return None
+
+
 def get_samples(args, tokenizer):
     # Daily-Omni: explicit dataset name, or hf + matching path/hf-name
     is_daily_omni = args.dataset_name == "daily-omni" or (
         args.dataset_name == "hf" and _daily_omni_repo_from_args(args) is not None
     )
+    is_videomme = args.dataset_name == "videomme" or (
+        args.dataset_name == "hf" and _videomme_repo_from_args(args) is not None
+    )
     is_seed_tts = args.dataset_name in (
         "seed-tts",
         "seed-tts-text",
@@ -449,7 +526,7 @@ def get_samples(args, tokenizer):
         "openai-realtime-duplex",
         "daily-omni",
     ]
-    is_omni_dataset = is_daily_omni or is_seed_tts or is_omniinteract or args.dataset_name == "random-mm"
+    is_omni_dataset = is_daily_omni or is_videomme or is_seed_tts or is_omniinteract or args.dataset_name == "random-mm"
 
     if not is_omni_backend and not is_omni_dataset:
         # Not an omni-related request, delegate to original implementation
@@ -625,6 +702,54 @@ def get_samples(args, tokenizer):
         )
         return input_requests
 
+    if is_videomme:
+        if args.backend not in ["openai-chat-omni", "daily-omni"]:
+            raise ValueError(
+                f"Video-MME dataset requires a multimodal backend that supports video. "
+                f"Got backend='{args.backend}'. Please use '--backend openai-chat-omni'"
+            )
+
+        # Resolve the source identity here; the dataset owns loading and extraction.
+        local_root = resolve_videomme_local_root(getattr(args, "dataset_path", None)) or (
+            resolve_videomme_local_root(getattr(args, "hf_name", None))
+        )
+        source = (
+            str(local_root)
+            if local_root is not None
+            else (_videomme_repo_from_args(args, explicit=args.dataset_name == "videomme") or VIDEOMME_DEFAULT_HF_REPO)
+        )
+        dataset = VideoMMEDataset(
+            parquet_path=getattr(args, "videomme_parquet", None),
+            dataset_path=source,
+            dataset_split=getattr(args, "hf_split", None) or "test",
+            dataset_subset=getattr(args, "hf_subset", None),
+            random_seed=args.seed,
+            video_dir=getattr(args, "videomme_video_dir", None),
+            subtitle_dir=getattr(args, "videomme_subtitle_dir", None),
+            pack_mode=getattr(args, "videomme_pack_mode", "minicpm-frames"),
+            max_frames=getattr(args, "videomme_max_frames", None),
+            duration_filter=getattr(args, "videomme_duration", "all"),
+            use_subtitle=getattr(args, "videomme_use_subtitle", False),
+            inline_local_video=getattr(args, "videomme_inline_local_video", False),
+            trust_remote_code=getattr(args, "trust_remote_code", False),
+            no_stream=getattr(args, "no_stream", False),
+            disable_shuffle=getattr(args, "disable_shuffle", False),
+        )
+
+        out_len = getattr(args, "output_len", None)
+        if out_len is None:
+            out_len = getattr(args, "hf_output_len", None)
+        if out_len is None:
+            out_len = VideoMMEDataset.DEFAULT_OUTPUT_LEN
+
+        return dataset.sample(
+            tokenizer=tokenizer,
+            num_requests=args.num_prompts,
+            output_len=out_len,
+            request_id_prefix=args.request_id_prefix,
+            no_oversample=args.no_oversample,
+        )
+
     if is_seed_tts:
         if args.backend not in (
             "openai-audio-speech",
@@ -711,7 +836,7 @@ datasets.get_samples = get_samples
 
 _serve_mod = sys.modules.get("vllm.benchmarks.serve")
 if _serve_mod is not None:
-    _serve_mod.get_samples = get_samples
+    setattr(_serve_mod, "get_samples", get_samples)
 
 
 @dataclass
@@ -2637,7 +2762,9 @@ async def async_request_openai_realtime_duplex(
         output.ttft = (metric_mean(session_metrics.get("ttft_ms")) or 0.0) / 1000.0
         output.audio_ttfp = (metric_mean(session_metrics.get("ttfp_ms")) or 0.0) / 1000.0
         output.audio_rtf = metric_mean(session_metrics.get("rtf")) or 0.0
-        output.audio_duration = sum(float(metric.get("audio_duration_ms") or 0.0) for metric in turn_metrics) / 1000.0
+        output.audio_duration = (
+            sum((_as_float(metric.get("audio_duration_ms")) for metric in turn_metrics), start=0.0) / 1000.0
+        )
         output.audio_frames = int(output.audio_duration * _SEED_TTS_OUTPUT_SAMPLE_RATE_HZ)
         output.latency = request_finished_at - output.start_time
         output.tts_turn_pcm_bytes = turn_pcm_bytes
@@ -2811,7 +2938,7 @@ async def benchmark(
         extra_body=test_extra_body,
         chat_messages=test_chat_messages,
     )
-    _attach_daily_omni_to_request_func_input(input_requests[0], test_input)
+    _attach_omni_chat_to_request_func_input(input_requests[0], test_input)
     _attach_seed_tts_to_request_func_input(input_requests[0], test_input)
     _attach_omniinteract_to_request_func_input(input_requests[0], test_input)
 
@@ -2836,7 +2963,7 @@ async def benchmark(
     if num_warmups > 0:
         print(f"Warming up with {num_warmups} requests...")
         warmup_pbar = None if disable_tqdm else tqdm(total=num_warmups)
-        warmup_semaphore = asyncio.Semaphore(max_concurrency) if max_concurrency else contextlib.nullcontext()
+        warmup_semaphore = _async_limiter(max_concurrency)
         warmup_tasks = []
 
         async def warmup_limited_request_func():
@@ -2854,12 +2981,13 @@ async def benchmark(
 
     print("Starting main benchmark run...")
 
+    lora_iter: Iterator[str] | None = None
     if lora_modules:
         lora_modules_list = list(lora_modules)
         if lora_assignment == "round-robin":
-            lora_modules = iter([lora_modules_list[i % len(lora_modules_list)] for i in range(len(input_requests))])
+            lora_iter = iter([lora_modules_list[i % len(lora_modules_list)] for i in range(len(input_requests))])
         else:
-            lora_modules = iter([random.choice(lora_modules_list) for _ in range(len(input_requests))])
+            lora_iter = iter([random.choice(lora_modules_list) for _ in range(len(input_requests))])
 
     if profile:
         print("Starting profiler...")
@@ -2877,7 +3005,7 @@ async def benchmark(
             extra_body=test_extra_body,
             chat_messages=test_chat_messages,
         )
-        _attach_daily_omni_to_request_func_input(input_requests[0], profile_input)
+        _attach_omni_chat_to_request_func_input(input_requests[0], profile_input)
         _attach_seed_tts_to_request_func_input(input_requests[0], profile_input)
         profile_output = await request_func(request_func_input=profile_input, session=session)
         if profile_output.success:
@@ -2898,7 +3026,7 @@ async def benchmark(
 
     pbar = None if disable_tqdm else tqdm(total=len(input_requests))
 
-    semaphore = asyncio.Semaphore(max_concurrency) if max_concurrency else contextlib.nullcontext()
+    semaphore = _async_limiter(max_concurrency)
 
     async def limited_request_func(request_func_input, session, pbar):
         async with semaphore:
@@ -2969,8 +3097,8 @@ async def benchmark(
         )
         per_request_extra_body = _merge_overrides(extra_body, request.request_overrides)
         req_model_id, req_model_name = model_id, model_name
-        if lora_modules:
-            req_lora_module = next(lora_modules)
+        if lora_iter is not None:
+            req_lora_module = next(lora_iter)
             req_model_id, req_model_name = req_lora_module, req_lora_module
 
         request_func_input = RequestFuncInput(
@@ -2988,7 +3116,7 @@ async def benchmark(
             request_id=request_id,
             chat_messages=request.chat_messages,
         )
-        _attach_daily_omni_to_request_func_input(request, request_func_input)
+        _attach_omni_chat_to_request_func_input(request, request_func_input)
         _attach_seed_tts_to_request_func_input(request, request_func_input)
         _attach_omniinteract_to_request_func_input(request, request_func_input)
         tasks.append(
@@ -3007,6 +3135,8 @@ async def benchmark(
 
     omniinteract_summary = _finalize_omniinteract_batch(input_requests, outputs)
 
+    metrics: Any
+    actual_output_lens: list[int] | int
     if task_type == TaskType.GENERATION:
         metrics, actual_output_lens = calculate_metrics(
             input_requests=input_requests,
@@ -3031,6 +3161,10 @@ async def benchmark(
         actual_output_lens = 0
 
     if isinstance(metrics, MultiModalsBenchmarkMetrics):
+        # ``make_dataclass`` types this class as ``type``, so isinstance()
+        # narrows to ``object`` and attribute access fails. Keep the runtime
+        # check and read fields through ``Any``.
+        mm_metrics: Any = metrics
 
         def measured_ttft(output: RequestFuncOutput) -> float | None:
             session_metrics = getattr(output, "duplex_session_metrics", None)
@@ -3040,33 +3174,33 @@ async def benchmark(
 
         result = {
             "duration": benchmark_duration,
-            "completed": metrics.completed,
-            "failed": metrics.failed,
-            "total_input_tokens": metrics.total_input,
-            "total_output_tokens": metrics.total_output,
-            "request_throughput": metrics.request_throughput,
-            "request_goodput": metrics.request_goodput if goodput_config_dict else None,
-            "output_throughput": metrics.output_throughput,
-            "total_token_throughput": metrics.total_token_throughput,
-            defs.TOTAL_AUDIO_DURATION_S: getattr(metrics, defs.TOTAL_AUDIO_DURATION_S),
-            defs.TOTAL_AUDIO_FRAMES: getattr(metrics, defs.TOTAL_AUDIO_FRAMES),
-            defs.AUDIO_THROUGHPUT: getattr(metrics, defs.AUDIO_THROUGHPUT),
-            defs.TOTAL_IMAGES: getattr(metrics, defs.TOTAL_IMAGES),
-            defs.IMAGE_THROUGHPUT: getattr(metrics, defs.IMAGE_THROUGHPUT),
-            defs.AVERAGE_PIXELS_PER_IMAGE: getattr(metrics, defs.AVERAGE_PIXELS_PER_IMAGE),
-            defs.MEAN_DENOISE_STEP_LATENCY_MS: getattr(metrics, defs.MEAN_DENOISE_STEP_LATENCY_MS),
-            defs.TOTAL_VIDEO_DURATION_S: getattr(metrics, defs.TOTAL_VIDEO_DURATION_S),
-            defs.TOTAL_VIDEO_FRAMES: getattr(metrics, defs.TOTAL_VIDEO_FRAMES),
-            defs.VIDEO_THROUGHPUT: getattr(metrics, defs.VIDEO_THROUGHPUT),
-            defs.MEAN_VIDEO_RTF: getattr(metrics, defs.MEAN_VIDEO_RTF),
-            defs.MEDIAN_VIDEO_RTF: getattr(metrics, defs.MEDIAN_VIDEO_RTF),
-            defs.PERCENTILES_VIDEO_RTF: getattr(metrics, defs.PERCENTILES_VIDEO_RTF),
-            defs.MEAN_VIDEO_GENERATION_MS: getattr(metrics, defs.MEAN_VIDEO_GENERATION_MS),
-            defs.MEDIAN_VIDEO_GENERATION_MS: getattr(metrics, defs.MEDIAN_VIDEO_GENERATION_MS),
-            defs.PERCENTILES_VIDEO_GENERATION_MS: getattr(metrics, defs.PERCENTILES_VIDEO_GENERATION_MS),
-            defs.MEAN_PEAK_MEMORY_MB: getattr(metrics, defs.MEAN_PEAK_MEMORY_MB),
-            defs.MEDIAN_PEAK_MEMORY_MB: getattr(metrics, defs.MEDIAN_PEAK_MEMORY_MB),
-            defs.PERCENTILES_PEAK_MEMORY_MB: getattr(metrics, defs.PERCENTILES_PEAK_MEMORY_MB),
+            "completed": mm_metrics.completed,
+            "failed": mm_metrics.failed,
+            "total_input_tokens": mm_metrics.total_input,
+            "total_output_tokens": mm_metrics.total_output,
+            "request_throughput": mm_metrics.request_throughput,
+            "request_goodput": mm_metrics.request_goodput if goodput_config_dict else None,
+            "output_throughput": mm_metrics.output_throughput,
+            "total_token_throughput": mm_metrics.total_token_throughput,
+            defs.TOTAL_AUDIO_DURATION_S: getattr(mm_metrics, defs.TOTAL_AUDIO_DURATION_S),
+            defs.TOTAL_AUDIO_FRAMES: getattr(mm_metrics, defs.TOTAL_AUDIO_FRAMES),
+            defs.AUDIO_THROUGHPUT: getattr(mm_metrics, defs.AUDIO_THROUGHPUT),
+            defs.TOTAL_IMAGES: getattr(mm_metrics, defs.TOTAL_IMAGES),
+            defs.IMAGE_THROUGHPUT: getattr(mm_metrics, defs.IMAGE_THROUGHPUT),
+            defs.AVERAGE_PIXELS_PER_IMAGE: getattr(mm_metrics, defs.AVERAGE_PIXELS_PER_IMAGE),
+            defs.MEAN_DENOISE_STEP_LATENCY_MS: getattr(mm_metrics, defs.MEAN_DENOISE_STEP_LATENCY_MS),
+            defs.TOTAL_VIDEO_DURATION_S: getattr(mm_metrics, defs.TOTAL_VIDEO_DURATION_S),
+            defs.TOTAL_VIDEO_FRAMES: getattr(mm_metrics, defs.TOTAL_VIDEO_FRAMES),
+            defs.VIDEO_THROUGHPUT: getattr(mm_metrics, defs.VIDEO_THROUGHPUT),
+            defs.MEAN_VIDEO_RTF: getattr(mm_metrics, defs.MEAN_VIDEO_RTF),
+            defs.MEDIAN_VIDEO_RTF: getattr(mm_metrics, defs.MEDIAN_VIDEO_RTF),
+            defs.PERCENTILES_VIDEO_RTF: getattr(mm_metrics, defs.PERCENTILES_VIDEO_RTF),
+            defs.MEAN_VIDEO_GENERATION_MS: getattr(mm_metrics, defs.MEAN_VIDEO_GENERATION_MS),
+            defs.MEDIAN_VIDEO_GENERATION_MS: getattr(mm_metrics, defs.MEDIAN_VIDEO_GENERATION_MS),
+            defs.PERCENTILES_VIDEO_GENERATION_MS: getattr(mm_metrics, defs.PERCENTILES_VIDEO_GENERATION_MS),
+            defs.MEAN_PEAK_MEMORY_MB: getattr(mm_metrics, defs.MEAN_PEAK_MEMORY_MB),
+            defs.MEDIAN_PEAK_MEMORY_MB: getattr(mm_metrics, defs.MEDIAN_PEAK_MEMORY_MB),
+            defs.PERCENTILES_PEAK_MEMORY_MB: getattr(mm_metrics, defs.PERCENTILES_PEAK_MEMORY_MB),
             "input_lens": [output.prompt_len for output in outputs],
             "start_times": [output.start_time for output in outputs],
             "output_lens": actual_output_lens,
@@ -3074,10 +3208,18 @@ async def benchmark(
             "itls": [output.itl for output in outputs],
             "generated_texts": [output.generated_text for output in outputs],
             "errors": [output.error for output in outputs],
-            "max_output_tokens_per_s": metrics.max_output_tokens_per_s,
-            "max_concurrent_requests": metrics.max_concurrent_requests,
-            "rtfx": metrics.rtfx,
+            "max_output_tokens_per_s": mm_metrics.max_output_tokens_per_s,
+            "max_concurrent_requests": mm_metrics.max_concurrent_requests,
+            "rtfx": mm_metrics.rtfx,
         }
+        for sample_count in (
+            "num_ttft_samples",
+            "num_tpot_samples",
+            "num_itl_samples",
+            "num_audio_ttfp_samples",
+            "num_audio_rtf_samples",
+        ):
+            result[sample_count] = getattr(metrics, sample_count)
     else:
         result = {
             "duration": benchmark_duration,
@@ -3142,6 +3284,21 @@ async def benchmark(
         result.update(_daily_acc)
         print_daily_omni_accuracy_summary(_daily_acc)
 
+    from vllm_omni.benchmarks.data_modules.videomme_eval import (
+        compute_videomme_accuracy_metrics,
+        print_videomme_accuracy_summary,
+    )
+
+    _save_vm = os.environ.get("VIDEOMME_SAVE_EVAL_ITEMS", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    )
+    _vm_acc = compute_videomme_accuracy_metrics(input_requests, outputs, include_per_item=_save_vm)
+    if _vm_acc is not None:
+        result.update(_vm_acc)
+        print_videomme_accuracy_summary(_vm_acc)
+
     if _seed_tts_capture_pcm_for_wer():
         from vllm_omni.benchmarks.data_modules.seed_tts_eval import (
             compute_seed_tts_wer_metrics,
diff --git a/vllm_omni/benchmarks/serve.py b/vllm_omni/benchmarks/serve.py
index 7d05eb24f..5a04b63da 100644
--- a/vllm_omni/benchmarks/serve.py
+++ b/vllm_omni/benchmarks/serve.py
@@ -43,7 +43,7 @@ def _normalize_endpoint(endpoint: str | None) -> str | None:
 
 
 def _use_endpoint_backend_when_implicit(args: argparse.Namespace) -> None:
-    explicit_keys = getattr(args, "explicit_keys", frozenset())
+    explicit_keys: frozenset[str] = getattr(args, "explicit_keys", frozenset())
     if "backend" in explicit_keys:
         return
     # Upstream vLLM defaults --backend to "openai". Treat that non-explicit
@@ -63,6 +63,8 @@ def main(args: argparse.Namespace) -> dict[str, Any]:
         os.environ["SEED_TTS_WER_SAVE_ITEMS"] = "1"
     if getattr(args, "daily_omni_save_eval_items", False):
         os.environ["DAILY_OMNI_SAVE_EVAL_ITEMS"] = "1"
+    if getattr(args, "videomme_save_eval_items", False):
+        os.environ["VIDEOMME_SAVE_EVAL_ITEMS"] = "1"
     request_timeout_s = getattr(args, "omni_request_timeout_s", None)
     if request_timeout_s is not None:
         set_request_timeout_s(request_timeout_s)
diff --git a/vllm_omni/clients/inline_duplex.py b/vllm_omni/clients/inline_duplex.py
index 79c09e014..5af8efc5f 100644
--- a/vllm_omni/clients/inline_duplex.py
+++ b/vllm_omni/clients/inline_duplex.py
@@ -32,8 +32,8 @@ from typing import TYPE_CHECKING
 from vllm_omni.clients.duplex import DuplexClientBase, DuplexConnectionError, SessionConfig
 
 if TYPE_CHECKING:
-    from vllm_omni.engine.duplex.realtime_commands import RealtimeInputDefaults
     from vllm_omni.entrypoints.duplex_omni import DuplexOmni, DuplexSessionHandle
+    from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
 __all__ = ["InlineDuplexClient"]
 
@@ -71,7 +71,7 @@ class InlineDuplexClient(DuplexClientBase):
 
     def _input_defaults(self) -> RealtimeInputDefaults:
         """Audio format / sample-rate / VAD defaults declared by this session's object."""
-        from vllm_omni.engine.duplex.realtime_commands import RealtimeInputDefaults
+        from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
         session_payload = self.session_info or self.config.to_session_payload(model=self.model)
         return RealtimeInputDefaults().with_session_payload(session_payload)
diff --git a/vllm_omni/config/composable_parallel/apply.py b/vllm_omni/config/composable_parallel/apply.py
index 879c7aec3..acfb9e229 100644
--- a/vllm_omni/config/composable_parallel/apply.py
+++ b/vllm_omni/config/composable_parallel/apply.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Apply declarative parallel strategies onto merged stage configs.
 
 This is the *override-after-merge* seam. ``merge_pipeline_deploy`` first fuses
@@ -198,10 +198,41 @@ def _check_devices(runtime: dict[str, Any], cfg: OmniParallelConfig, *, role: Ro
 
 
 def _apply_to_stage(stage: Any, cfg: OmniParallelConfig, *, role: RoleKey) -> None:
+    declared = set(cfg.l1_owners.keys())
+    if hasattr(stage, "parallel_config") and hasattr(stage, "runtime_config"):
+        parallel = stage.parallel_config
+        for kind, field_name in _ENGINE_FIELD_BY_KIND.items():
+            if kind in declared:
+                existing = getattr(parallel, field_name, None)
+                value = getattr(cfg, field_name)
+                if existing not in (None, 1, value):
+                    _fail(
+                        f"role {role!r}: strategy derives {field_name}={value} "
+                        f"but structured config already set {existing}"
+                    )
+                setattr(parallel, field_name, value)
+        if "ep" in declared and cfg.enable_expert_parallel:
+            setattr(parallel, "enable_expert_parallel", True)
+        if "stage_replica" in declared:
+            existing = stage.runtime_config.num_replicas
+            if existing not in (None, 1, cfg.stage_replica_size):
+                _fail(
+                    f"role {role!r}: strategy derives "
+                    f"num_replicas={cfg.stage_replica_size} but structured config already set {existing}"
+                )
+            stage.runtime_config.num_replicas = cfg.stage_replica_size
+        check_device_layout(
+            stage.runtime_config.devices,
+            tensor_parallel_size=cfg.tensor_parallel_size,
+            data_parallel_size=cfg.data_parallel_size,
+            pipeline_parallel_size=cfg.pipeline_parallel_size,
+            num_replicas=int(stage.runtime_config.num_replicas or 1),
+            role=role,
+        )
+        return
+
     engine_args = stage.yaml_engine_args
     runtime = stage.yaml_runtime
-
-    declared = set(cfg.l1_owners.keys())
     for kind, field_name in _ENGINE_FIELD_BY_KIND.items():
         if kind in declared:
             _set_explicit(engine_args, field_name, getattr(cfg, field_name), role=role)
@@ -209,7 +240,6 @@ def _apply_to_stage(stage: Any, cfg: OmniParallelConfig, *, role: RoleKey) -> No
         _set_explicit(engine_args, "enable_expert_parallel", True, role=role)
     if "stage_replica" in declared:
         _set_num_replicas(runtime, cfg.stage_replica_size, role=role)
-
     _check_devices(runtime, cfg, role=role)
 
 
diff --git a/vllm_omni/config/config_factory.py b/vllm_omni/config/config_factory.py
index 90108e7df..af0ea3e81 100644
--- a/vllm_omni/config/config_factory.py
+++ b/vllm_omni/config/config_factory.py
@@ -7,7 +7,7 @@ from __future__ import annotations
 import functools
 import json
 from collections.abc import Mapping
-from dataclasses import asdict, dataclass
+from dataclasses import asdict, dataclass, fields
 from pathlib import Path
 from typing import Any
 
@@ -18,13 +18,19 @@ from vllm.transformers_utils.repo_utils import get_hf_file_to_dict
 from vllm.transformers_utils.runai_utils import ObjectStorageModel, is_runai_obj_uri
 
 from vllm_omni.config.endpoint_policy import EndpointRestriction
-from vllm_omni.config.omni_config import VllmOmniConfig
+from vllm_omni.config.omni_config import (
+    VllmOmniConfig,
+    normalize_and_validate_diffusion_engine_ingress_kwargs,
+)
 from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, resolve_pipeline_config
 from vllm_omni.config.stage_config import (
     _DEPLOY_DIR,
     DeployConfig,
     PipelineConfig,
     StageConfig,
+    StageDeployConfig,
+    StageExecutionType,
+    StagePipelineConfig,
     StageType,
     build_stage_runtime_overrides,
     load_deploy_config,
@@ -373,6 +379,7 @@ class StageConfigFactory:
         trust_remote_code: bool | None,
         cli_overrides: dict[str, Any],
         deploy_config_path: str | None,
+        strategy_specs: Mapping[Any, Any] | None = None,
     ) -> VllmOmniConfig | None:
         """Build the structured Omni config for a model/deploy pair."""
         user_deploy_config = cls._load_user_deploy_config(deploy_config_path)
@@ -387,6 +394,20 @@ class StageConfigFactory:
         if pipeline_cfg is None:
             return None
 
+        # Keep the typed representation's topology in lockstep with the
+        # compatibility launch representation. The aligner is a real extra
+        # stage, not an engine-only setting, so it must be injected before
+        # either representation is built.
+        if user_deploy_config is None:
+            if pipeline_cfg.default_deploy_config_name is not None:
+                default_deploy_path = _DEPLOY_DIR / pipeline_cfg.default_deploy_config_name
+                user_deploy_config = load_deploy_config(default_deploy_path)
+                deploy_config_path = str(default_deploy_path)
+            else:
+                user_deploy_config = DeployConfig()
+        from vllm_omni.utils.forced_aligner import inject_forced_aligner_stage
+
+        pipeline_cfg, user_deploy_config = inject_forced_aligner_stage(pipeline_cfg, user_deploy_config, cli_overrides)
         registry_cli_overrides = with_trust_remote_code_override(
             {**cli_overrides, "model": model},
             trust_remote_code,
@@ -396,6 +417,7 @@ class StageConfigFactory:
             user_deploy_config=user_deploy_config,
             deploy_config_path=deploy_config_path,
             cli_overrides=registry_cli_overrides,
+            strategy_specs=strategy_specs,
         )
 
     @classmethod
@@ -621,13 +643,19 @@ class StageConfigFactory:
             )
 
     @classmethod
-    def create_default_diffusion(cls, kwargs: dict[str, Any]) -> list[dict[str, Any]]:
-        """Build the temporary runtime ABI for a generic diffusion stage.
-
-        The terminal diffusion config owns engine defaults and normalization;
-        this compatibility builder only adds Omni stage topology, request
-        defaults, and device placement.
-        """
+    def _normalize_default_diffusion(
+        cls,
+        kwargs: dict[str, Any],
+    ) -> tuple[dict[str, Any], DiffusionParallelConfig, dict[str, Any], str]:
+        """Normalize inputs shared by typed and compatibility diffusion builders."""
+        # Preserve the default builder's explicit top-level override of model
+        # extras before the strict same-source alias validator runs.
+        if kwargs.get("auxiliary_text_encoder") is not None:
+            kwargs = dict(kwargs)
+            extras = dict(kwargs.get("extras") or {})
+            extras.pop("auxiliary_text_encoder", None)
+            kwargs["extras"] = extras
+        kwargs = normalize_and_validate_diffusion_engine_ingress_kwargs(kwargs, stage_id=0)
         raw_sampling_params = kwargs.get("default_sampling_params")
         if isinstance(raw_sampling_params, str):
             try:
@@ -642,9 +670,15 @@ class StageConfigFactory:
         parallel_config = DiffusionParallelConfig.from_stage_overrides(kwargs)
         if kwargs.get("num_gpus") is not None:
             parallel_config.resolve_data_parallel_size(int(kwargs["num_gpus"]))
-        engine_args = OmniDiffusionConfig.normalize_init_kwargs(kwargs)
-        engine_args["parallel_config"] = asdict(parallel_config)
-        engine_args["model_stage"] = "diffusion"
+        # Ingress keeps the engine spelling; canonicalize it before filtering
+        # to terminal diffusion fields. Conflicts were validated at ingress.
+        quantization = kwargs.pop("quantization", None)
+        if quantization is not None:
+            kwargs["quantization_config"] = quantization
+        diffusion_config_fields = frozenset(config_field.name for config_field in fields(OmniDiffusionConfig))
+        engine_args = OmniDiffusionConfig.normalize_init_kwargs(
+            {name: value for name, value in kwargs.items() if name in diffusion_config_fields}
+        )
 
         extras = dict(engine_args.get("extras") or {})
         for key, default in (
@@ -665,6 +699,21 @@ class StageConfigFactory:
             final_output_type,
             model_class_name,
         )
+        return engine_args, parallel_config, default_sampling_params, final_output_type
+
+    @classmethod
+    def create_default_diffusion(cls, kwargs: dict[str, Any]) -> list[dict[str, Any]]:
+        """Build the temporary runtime ABI for a generic diffusion stage.
+
+        The terminal diffusion config owns engine defaults and normalization;
+        this compatibility builder only adds Omni stage topology, request
+        defaults, and device placement.
+        """
+        engine_args, parallel_config, default_sampling_params, final_output_type = cls._normalize_default_diffusion(
+            kwargs
+        )
+        engine_args["parallel_config"] = asdict(parallel_config)
+        engine_args["model_stage"] = "diffusion"
 
         return [
             {
@@ -681,6 +730,50 @@ class StageConfigFactory:
             }
         ]
 
+    @classmethod
+    def create_typed_default_diffusion(
+        cls,
+        model: str,
+        kwargs: dict[str, Any],
+    ) -> VllmOmniConfig:
+        """Build generic diffusion directly into the structured runtime config."""
+        engine_overrides, parallel_config, default_sampling_params, final_output_type = (
+            cls._normalize_default_diffusion(kwargs)
+        )
+        engine_overrides.update(asdict(parallel_config))
+        model_class_name = engine_overrides.get("model_class_name")
+        pipeline = PipelineConfig(
+            model_type="generic_diffusion",
+            model_arch=str(model_class_name or ""),
+            stages=(
+                StagePipelineConfig(
+                    stage_id=0,
+                    model_stage="diffusion",
+                    execution_type=StageExecutionType.DIFFUSION,
+                    final_output=True,
+                    final_output_type=final_output_type,
+                ),
+            ),
+        )
+
+        # These values have already been normalized for this diffusion stage.
+        # Scope them explicitly so diffusion-only fields such as engine_backend
+        # and extras are not filtered by the global LLM CLI argument surface.
+        stage_overrides = {
+            f"stage_0_{key}": value for key, value in engine_overrides.items() if key not in {"model", "stage_id"}
+        }
+        stage_overrides["stage_0_devices"] = (
+            kwargs.get("stage_0_devices")
+            or kwargs.get("devices")
+            or ",".join(str(i) for i in range(parallel_config.world_size))
+        )
+        # Caller defaults belong to deployment, not immutable pipeline constraints:
+        # explicit request sampling parameters must still be able to override them.
+        deploy = DeployConfig(stages=[StageDeployConfig(stage_id=0, default_sampling_params=default_sampling_params)])
+        return VllmOmniConfig.from_pipeline_config(
+            pipeline, user_deploy_config=deploy, cli_overrides={"model": model, **stage_overrides}
+        )
+
     @classmethod
     def _merge_cli_overrides(
         cls,
diff --git a/vllm_omni/config/endpoint_policy.py b/vllm_omni/config/endpoint_policy.py
index f0aca95eb..24dea97e2 100644
--- a/vllm_omni/config/endpoint_policy.py
+++ b/vllm_omni/config/endpoint_policy.py
@@ -24,6 +24,7 @@ class OmniServingCapability(Enum):
     """Serving capabilities that pipelines can shut down."""
 
     COMPLETIONS = RouteTarget("/v1/completions", frozenset({"POST"}))
+    IMAGE_EDITS = RouteTarget("/v1/images/edits", frozenset({"POST"}))
 
     @property
     def path(self) -> str:
diff --git a/vllm_omni/config/environment_variable_inventory.py b/vllm_omni/config/environment_variable_inventory.py
index 97782328d..f04bf8358 100644
--- a/vllm_omni/config/environment_variable_inventory.py
+++ b/vllm_omni/config/environment_variable_inventory.py
@@ -64,6 +64,7 @@ _PUBLIC_OMNI = (
     "SPEAKER_MAX_UPLOADED",
     "SPEAKER_SAMPLES_DIR",
     "VLLM_OMNI_ABORT_TIMEOUT",
+    "VLLM_OMNI_AR_DIFFUSION_KV_GATHER",
     "VLLM_OMNI_ASYNC_OUTPUT_TIMEOUT",
     "VLLM_OMNI_EVENT_DRIVEN_ORCH",
     "VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS",
@@ -145,13 +146,6 @@ _MODEL_PROMOTE = (
     "COSYVOICE3_ESTIMATOR_ONNX",
     "COSYVOICE3_TRT",
     "COSYVOICE3_TRT_CACHE",
-    "DYNIN_CONFIG_PATH",
-    "DYNIN_MAGVIT_REMOTE_CODE_LOCAL_FILES_ONLY",
-    "DYNIN_MAGVIT_REMOTE_CODE_REPO_ID",
-    "DYNIN_MAGVIT_REMOTE_CODE_REVISION",
-    "DYNIN_REMOTE_CODE_LOCAL_FILES_ONLY",
-    "DYNIN_REMOTE_CODE_REPO_ID",
-    "DYNIN_REMOTE_CODE_REVISION",
     "FASTVIDEO_VSA_SM100A",
     "HIGGS_AUDIO_TOKENIZER_PATH",
     "INTERNVLA_A1_COSMOS_DECODER_PATH",
@@ -179,7 +173,6 @@ _MODEL_PROMOTE = (
 )
 
 _MODEL_REQUEST_SCOPE = (
-    "DOTS_TTS_DIT_NUM_STEPS",
     "MAGI2_NEGATIVE_PROMPT",
     "STEP_AUDIO2_DEFAULT_PROMPT_WAV",
     "VLLM_GEPARD_END_FADE_MS",
@@ -194,8 +187,6 @@ _MODEL_EXTERNAL: tuple[str, ...] = ()
 
 _MODEL_INTERNALIZE = (
     "COSYVOICE3_BATCH_FLOW_DEBUG",
-    "DOTS_TTS_BETA_TRACE",
-    "DYNIN_S2U_VENDOR_ROOT",
     "DZ_PHASE_TIMING",
     "MAGI2_ALLOW_UNSUPPORTED_TOPOLOGY",
     "MAGI2_ROUTER_BIAS_SOURCE",
@@ -203,6 +194,7 @@ _MODEL_INTERNALIZE = (
     "MOSS_TTS_DEBUG_STOP",
     "NEMOTRON_VOICECHAT_DEBUG_FUNCTION_TIMELINE",
     "VLLM_OMNI_BREEZE_GOLDEN_DIR",
+    "VLLM_OMNI_QWEN_VISUAL_DEBUG_DIR",
     "VLLM_OMNI_QWEN3_CODE2WAV_BATCH_STATS",
     "VLLM_OMNI_QWEN3_CODE2WAV_BATCH_STATS_LOG_EVERY",
     "VLLM_OMNI_QWEN3_CODE2WAV_CUDAGRAPH_STATS",
@@ -213,6 +205,8 @@ _MODEL_INTERNALIZE = (
 _MODEL_DEPRECATE_REMOVE = (
     "HIGGS_AUDIO_V2_TOKENIZER_PATH",
     "VLLM_OMNI_LINGBOT_ACTION_ROOT",
+    "VLLM_OMNI_VAE_ENCODE_LEGACY_PREP",
+    "VLLM_OMNI_VAE_LEGACY_TEMPORAL",
     "VLLM_OMNI_VOXCPM_CODE_PATH",
     "XCODEC1_PATH",
     "model_stage",
@@ -235,6 +229,7 @@ _BENCHMARK_TRANSITIONAL = (
     "SEED_TTS_WER_EVAL",
     "SEED_TTS_WER_SAVE_AUDIO_DIR",
     "SEED_TTS_WER_SAVE_ITEMS",
+    "VIDEOMME_SAVE_EVAL_ITEMS",
     "VLLM_DAILY_OMNI_MEDIA_REPO",
     "VLLM_OMNI_BENCH_AUDIO_CHANNELS",
     "VLLM_OMNI_BENCH_AUDIO_CONTINUITY_THRESHOLD_S",
diff --git a/vllm_omni/config/model.py b/vllm_omni/config/model.py
index 7be569f47..a56e6148c 100644
--- a/vllm_omni/config/model.py
+++ b/vllm_omni/config/model.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from dataclasses import MISSING, field
 from typing import Any
 
@@ -124,6 +127,8 @@ class OmniModelConfig(ModelConfig):
     async_chunk: bool = False
     session_mode: str = "turn"
     retains_state_across_chunks: bool = False
+    use_v2_model_runner: bool = False
+    supports_native_mrv2_data_plane: bool = False
     # Stage-1 active stream slots; 0 keeps legacy chunk-level round-robin.
     active_stream_window: int = 0
     duplex_max_sessions: int = 1
@@ -134,6 +139,7 @@ class OmniModelConfig(ModelConfig):
     # Optional dotted path of a per-stage pooling-output decoder applied
     # worker-side before IPC. Read by the AR scheduler.
     pooling_output_decoder: str | None = None
+    final_output: bool = False
     hf_config_name: str | None = None
     custom_process_next_stage_input_func: str | None = None
     stage_connector_config: dict[str, Any] = field(
diff --git a/vllm_omni/config/omni_config.py b/vllm_omni/config/omni_config.py
index d86a3216f..d64372b84 100644
--- a/vllm_omni/config/omni_config.py
+++ b/vllm_omni/config/omni_config.py
@@ -18,6 +18,7 @@ from inspect import Parameter, signature
 from pathlib import Path
 from typing import Any, Literal, TypeAlias, TypedDict, cast
 
+import regex as re
 from pydantic import ConfigDict, Field, field_validator, model_validator
 from typing_extensions import Self
 from vllm.config import CacheConfig as VllmCacheConfig
@@ -29,7 +30,9 @@ from vllm.config import ProfilerConfig as VllmProfilerConfig
 from vllm.config import SchedulerConfig as VllmSchedulerConfig
 from vllm.config.utils import config
 from vllm.engine.arg_utils import EngineArgs as VllmEngineArgs
+from vllm.logger import init_logger
 from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
+from vllm.pooling_params import PoolingParams
 
 from vllm_omni.config.stage_config import (
     _DEPLOY_DIR,
@@ -41,18 +44,25 @@ from vllm_omni.config.stage_config import (
     StageExecutionType,
     StagePipelineConfig,
     StageType,
+    _apply_diffusion_parallel_runtime_overrides,
     _apply_platform_overrides,
+    _get_recursively_merged_dict,
     _resolve_scheduler,
     _scheduler_path,
     _select_processor_funcs,
     build_stage_runtime_overrides,
     load_deploy_config,
+    merge_pipeline_deploy,
     merge_sampling_constraints,
     normalize_pipeline_cli_overrides,
     reconcile_diffusion_attention_overrides,
+    resolve_stage_async_chunk,
+    validate_stage_async_chunk_edges,
 )
 from vllm_omni.diffusion.diffusion_kv.config import DiffusionKVCacheMode
 
+logger = init_logger(__name__)
+
 _EXECUTION_TYPE_TO_STAGE_WORKER: dict[StageExecutionType, tuple[StageType, str | None]] = {
     StageExecutionType.LLM_AR: (StageType.LLM, "ar"),
     StageExecutionType.LLM_GENERATION: (StageType.LLM, "generation"),
@@ -65,10 +75,14 @@ _NON_STAGE_ENGINE_CLI_FIELDS = frozenset(
     {
         "async_chunk",
         "disable_log_stats",
+        "command",
+        "headless",
         "model",
+        "model_tag",
         "omni",
         "output_modalities",
         "stage_id",
+        "subparser",
         "tokenizer",
     }
 )
@@ -86,6 +100,8 @@ _LEGACY_STAGE_METADATA_EXTRA_FIELDS = frozenset(
 
 _QuantizationConfigType: TypeAlias = QuantizationConfig | str | Mapping[str, Any] | None
 
+_DIFFUSION_SHARED_ONLY_ENGINE_FIELDS = frozenset({"kv_cache_dtype", "seed"})
+
 
 class _QuantizationEngineOverrides(TypedDict, total=False):
     quantization_config: _QuantizationConfigType
@@ -154,7 +170,10 @@ class _ModelEngineOverrides(TypedDict, total=False):
     limit_mm_per_prompt: dict[str, Any]
     interleave_mm_strings: bool
     media_io_kwargs: dict[str, Any]
+    final_output: bool
     active_stream_window: int
+    use_v2_model_runner: bool
+    supports_native_mrv2_data_plane: bool
     enable_sleep_mode: bool
     subtalker_sampling_params: dict[str, Any]
     silence_ban_frames: int
@@ -184,6 +203,11 @@ class _ModelEngineOverrides(TypedDict, total=False):
     enable_prompt_embeds: bool
 
 
+class _PoolingEngineOverrides(TypedDict, total=False):
+    runner: str
+    pooling_output_decoder: str
+
+
 class _LoadEngineOverrides(TypedDict, total=False):
     tokenizer: str
     download_dir: str
@@ -250,6 +274,7 @@ class _ParallelEngineOverrides(_ParallelConfigEngineOverrides, total=False):
 
 class _ConnectorEngineOverrides(TypedDict, total=False):
     omni_kv_config: dict[str, Any]
+    kv_transfer_config: KVTransferConfig | dict[str, Any]
 
 
 @dataclass(frozen=True)
@@ -259,6 +284,7 @@ class _StageEngineValues:
     quantization: _QuantizationEngineOverrides
     model: _ModelEngineOverrides
     load: _LoadEngineOverrides
+    pooling: _PoolingEngineOverrides
     cache: _CacheEngineOverrides
     scheduler: _SchedulerEngineOverrides
     connector: _ConnectorEngineOverrides
@@ -275,10 +301,6 @@ class _DiffusionEngineOverrides:
 
     _values: dict[str, Any]
 
-    @classmethod
-    def from_engine(cls, engine: Mapping[str, Any]) -> _DiffusionEngineOverrides:
-        return cls(_select_engine_overrides(engine, _DIFFUSION_STAGE_ENGINE_FIELDS))
-
     def to_kwargs(self) -> dict[str, Any]:
         return {name: _copy_value(value) for name, value in self._values.items()}
 
@@ -314,6 +336,8 @@ def _first_defined(*values: Any) -> Any:
 
 def _validate_async_chunk_support(pipeline: PipelineConfig, deploy: DeployConfig) -> None:
     has_inter_stage_edges = any(stage.input_sources for stage in pipeline.stages)
+    if deploy.async_chunk and any(stage.engine_extras.get("kv_transfer_config") for stage in deploy.stages):
+        raise ValueError("Native AR-to-DiT KV transfer requires async_chunk=False.")
     if (
         deploy.async_chunk
         and has_inter_stage_edges
@@ -344,12 +368,32 @@ def _stage_cli_overrides(
     *,
     execution_type: StageExecutionType | None = None,
 ) -> dict[str, Any]:
+    if execution_type == StageExecutionType.DIFFUSION:
+        stage_override_pattern = re.compile(r"^stage_\d+_")
+        stage_scoped = {
+            name: _copy_value(value) for name, value in cli_overrides.items() if stage_override_pattern.match(name)
+        }
+        global_inputs = {name: _copy_value(value) for name, value in cli_overrides.items() if name not in stage_scoped}
+        cli_overrides = {
+            **normalize_and_validate_diffusion_engine_ingress_kwargs(
+                global_inputs,
+                stage_id=stage_id,
+            ),
+            **stage_scoped,
+        }
     runtime_overrides = build_stage_runtime_overrides(stage_id, dict(cli_overrides))
     global_stage_fields = _global_stage_cli_fields()
     owned_fields = None if execution_type is None else _STAGE_ENGINE_FIELDS_BY_EXECUTION_TYPE[execution_type]
     result: dict[str, Any] = {}
     for key, value in runtime_overrides.items():
-        stage_specific = f"stage_{stage_id}_{key}" in cli_overrides
+        stage_key = f"stage_{stage_id}_{key}"
+        stage_specific = stage_key in cli_overrides
+        if (
+            execution_type == StageExecutionType.DIFFUSION
+            and key in _DIFFUSION_SHARED_ONLY_ENGINE_FIELDS
+            and not stage_specific
+        ):
+            continue
         if stage_specific or (key in global_stage_fields and (owned_fields is None or key in owned_fields)):
             result[key] = _copy_value(value)
 
@@ -357,6 +401,19 @@ def _stage_cli_overrides(
     # argument. Keep global and stage-scoped CLI values off AR/generation stages.
     if execution_type is not None and execution_type is not StageExecutionType.DIFFUSION:
         result.pop("step_execution", None)
+    if execution_type == StageExecutionType.DIFFUSION:
+        prefix = f"stage_{stage_id}_"
+        for key, value in cli_overrides.items():
+            if key.startswith(prefix):
+                field_name = key.removeprefix(prefix)
+                if field_name in {"model", "model_arch", "stage_id"}:
+                    raise ValueError(f"Diffusion stage {stage_id} cannot override identity field {field_name!r}.")
+                if field_name in _DIFFUSION_SHARED_ONLY_ENGINE_FIELDS:
+                    raise ValueError(
+                        f"Diffusion stage {stage_id} cannot override shared engine field {field_name!r}; "
+                        "it has no diffusion stage-config consumer."
+                    )
+                result.setdefault(field_name, _copy_value(value))
     return result
 
 
@@ -372,6 +429,10 @@ def _validate_global_stage_cli_ownership(
         field for stage in pipeline.stages for field in _STAGE_ENGINE_FIELDS_BY_EXECUTION_TYPE[stage.execution_type]
     }
     unowned_fields = explicit_global_fields - owned_fields
+    if any(stage.execution_type == StageExecutionType.DIFFUSION for stage in pipeline.stages):
+        # Mixed engine ingress accepts these shared globals, but diffusion
+        # stages deliberately leave them outside their terminal config.
+        unowned_fields -= _DIFFUSION_SHARED_ONLY_ENGINE_FIELDS
     if unowned_fields:
         names = ", ".join(sorted(unowned_fields))
         raise ValueError(
@@ -435,9 +496,12 @@ class OmniStageModelConfig(_TrackExplicitConfigFields):
     # MiniCPM interleaved AV packing and media decode knobs (Daily-Omni).
     interleave_mm_strings: bool | None = None
     media_io_kwargs: dict[str, Any] | None = None
+    final_output: bool = False
     active_stream_window: int = Field(default=0, ge=0)
     session_mode: str = "turn"
     duplex_max_sessions: int = Field(default=1, ge=1)
+    use_v2_model_runner: bool = False
+    supports_native_mrv2_data_plane: bool = False
     enable_sleep_mode: bool = False
     default_sampling_params: dict[str, Any] | None = None
     subtalker_sampling_params: dict[str, Any] | None = None
@@ -474,6 +538,15 @@ class OmniStageModelConfig(_TrackExplicitConfigFields):
     enable_prompt_embeds: bool | None = None
 
 
+@config(config=ConfigDict(arbitrary_types_allowed=True))
+class OmniStagePoolingConfig:
+    """Typed inputs owned by vLLM pooling stages."""
+
+    runner: str | None = None
+    pooling_output_decoder: str | None = None
+    default_pooling_params: PoolingParams | None = None
+
+
 @_enforce_keyword_only_init
 @config(kw_only=True)
 class OmniStageLoadConfig(_TrackExplicitConfigFields, VllmLoadConfig):
@@ -541,6 +614,7 @@ class OmniStageConnectorConfig:
 
     async_chunk: bool = False
     omni_kv_config: dict[str, Any] | None = None
+    kv_transfer_config: KVTransferConfig | None = None
     stage_connector: dict[str, Any] = field(
         default_factory=lambda: {
             "name": "SharedMemoryConnector",
@@ -712,7 +786,7 @@ class OmniStageDiffusionParallelConfig(OmniStageParallelConfig):
             self.world_size = other_parallel_world_size
 
 
-@config(config=ConfigDict(arbitrary_types_allowed=True))
+@config(config=ConfigDict(arbitrary_types_allowed=True, extra="forbid"))
 class _DiffusionConfigProjection:
     """Diffusion-specific per-stage settings.
 
@@ -815,6 +889,8 @@ class _DiffusionConfigProjection:
     enable_stage_verification: bool = True
     prompt_file_path: str | None = None
     quantization_config: _QuantizationConfigType = None
+    # Internal provenance, retained across config projection and worker transport.
+    quantization_config_is_auto_detected: bool = False
     extras: dict[str, Any] = field(default_factory=dict)
 
     @field_validator("kv_transfer_config", mode="before")
@@ -826,15 +902,19 @@ class _DiffusionConfigProjection:
 
     @classmethod
     def from_kwargs(cls, **kwargs: Any) -> _DiffusionConfigProjection:
-        from vllm_omni.diffusion.data import normalize_omni_diffusion_kwargs
+        from vllm_omni.diffusion.data import (
+            normalize_omni_diffusion_kwargs,
+            validate_omni_diffusion_kwargs,
+        )
         from vllm_omni.diffusion.offloader.config import parse_diffusion_offload_config
 
-        normalized_kwargs = normalize_omni_diffusion_kwargs(kwargs)
+        valid_fields = frozenset(f.name for f in fields(cast(Any, cls)))
+        normalized = normalize_omni_diffusion_kwargs(kwargs)
+        validate_omni_diffusion_kwargs(normalized, valid_fields)
         # Validate before stage construction while retaining the raw mapping
         # needed by dataclass/config serialization across process boundaries.
-        parse_diffusion_offload_config(normalized_kwargs.get("diffusion_offload_config"))
-        valid_fields = {f.name for f in fields(cast(Any, cls))}
-        return cls(**{k: v for k, v in normalized_kwargs.items() if k in valid_fields})
+        parse_diffusion_offload_config(normalized.get("diffusion_offload_config"))
+        return cls(**{name: value for name, value in normalized.items() if value is not None})
 
     def __post_init__(self) -> None:
         # Keep diffusion imports lazy so importing vllm_omni.config does not
@@ -962,6 +1042,8 @@ class _DiffusionConfigProjection:
             or (is_checkpoint_nvfp4 and self._is_generic_nvfp4_quant_config(self.quantization_config))
         )
         if should_use_checkpoint_config:
+            if self.quantization_config is None:
+                self.quantization_config_is_auto_detected = True
             self.quantization_config = quant_config
             if quant_method is not None:
                 self.additional_config.setdefault("auto_detected_quant_method", quant_method)
@@ -1067,20 +1149,7 @@ _DIFFUSION_MOVED_SHARED_FIELDS = frozenset(
 
 _STAGE_DEPLOY_ENGINE_FIELDS: tuple[str, ...] = tuple(_STAGE_DEPLOY_FIELDS)
 
-_DIFFUSION_BACKCOMPAT_ENGINE_FIELDS = frozenset(
-    {
-        "diffusion_attention_backend",
-        "fastvideo_vsa_topk",
-        "kv_cache_dtype",
-        "kv_cache_skip_layers",
-        "kv_cache_skip_steps",
-        "static_lora_scale",
-    }
-)
-_DIFFUSION_STAGE_ENGINE_FIELDS = (_DIFFUSION_CONFIG_FIELDS | _DIFFUSION_BACKCOMPAT_ENGINE_FIELDS) - {
-    "model",
-    "stage_id",
-}
+_DIFFUSION_STAGE_ENGINE_FIELDS = _DIFFUSION_CONFIG_FIELDS - {"model", "stage_id"}
 
 
 def _upstream_engine_field_map(
@@ -1139,6 +1208,7 @@ _MODEL_ENGINE_FIELDS = frozenset(_ModelEngineOverrides.__annotations__)
 _LOAD_ENGINE_FIELDS = frozenset(_LoadEngineOverrides.__annotations__)
 _CACHE_ENGINE_FIELDS = frozenset(_CacheEngineOverrides.__annotations__)
 _SCHEDULER_ENGINE_FIELDS = frozenset(_SchedulerEngineOverrides.__annotations__)
+_POOLING_ENGINE_FIELDS = frozenset(_PoolingEngineOverrides.__annotations__)
 _CONNECTOR_ENGINE_FIELDS = frozenset(_ConnectorEngineOverrides.__annotations__)
 _RUNTIME_ENGINE_FIELDS = frozenset(_RuntimeEngineOverrides.__annotations__)
 _DIRECT_VLLM_CONFIG_ENGINE_FIELDS = frozenset({"compilation_config", "profiler_config"})
@@ -1169,6 +1239,7 @@ _LLM_STAGE_ENGINE_FIELDS = (
     | _LLM_CACHE_ENGINE_FIELDS
     | _LLM_SCHEDULER_ENGINE_FIELDS
     | _LLM_PARALLEL_CONFIG_ENGINE_FIELDS
+    | _POOLING_ENGINE_FIELDS
     | {"parallel_config"}
 )
 _DIFFUSION_OWNED_STAGE_ENGINE_FIELDS = (
@@ -1218,6 +1289,8 @@ def _validate_stage_engine_override_ownership(
     stage_id: int,
     execution_type: StageExecutionType,
     overrides: Mapping[str, Any],
+    *,
+    validate_top_level: bool = True,
 ) -> None:
     try:
         owner_fields = _STAGE_ENGINE_FIELDS_BY_EXECUTION_TYPE[execution_type]
@@ -1226,7 +1299,7 @@ def _validate_stage_engine_override_ownership(
     except KeyError as exc:
         raise ValueError(f"Unsupported stage execution type: {execution_type!r}") from exc
 
-    unowned_fields = set(overrides) - owner_fields
+    unowned_fields = set(overrides) - owner_fields if validate_top_level else set()
     parallel_config = overrides.get("parallel_config")
     if isinstance(parallel_config, Mapping):
         # Nested values traditionally use upstream config names, while flat
@@ -1243,6 +1316,144 @@ def _validate_stage_engine_override_ownership(
         )
 
 
+_DIFFUSION_STAGE_METADATA_FIELDS = frozenset(
+    {
+        "async_chunk",
+        "custom_process_next_stage_input_func",
+        "engine_output_type",
+        "has_sampling_extra_args",
+        "hf_config_name",
+        "model_arch",
+        "model_stage",
+        "retains_state_across_chunks",
+        "scheduler_cls",
+        "stage_connector_spec",
+        "worker_type",
+    }
+)
+
+_DIFFUSION_ENGINE_ADAPTER_METADATA_FIELDS = frozenset(
+    {
+        # Serialized shared model settings are consumed outside the terminal
+        # diffusion config; accepting them here does not widen raw ingress.
+        "duplex_max_sessions",
+        "has_sampling_extra_args",
+        "inline_diffusion",
+        "requires_full_payload_input",
+        "sampling_extra_args_keys",
+        "session_mode",
+    }
+)
+_DIFFUSION_DEFAULT_FACTORY_FIELDS = frozenset(
+    {"default_llama_model_id", "default_sampling_params", "devices", "stage_0_devices"}
+)
+
+
+def _frontend_cli_fields() -> frozenset[str]:
+    """Return vLLM server fields that are consumed before stage startup."""
+    from vllm.entrypoints.launchers.cli_args import FrontendArgs
+
+    return frozenset(config_field.name for config_field in fields(FrontendArgs))
+
+
+def normalize_and_validate_diffusion_engine_ingress_kwargs(
+    kwargs: Mapping[str, Any],
+    *,
+    stage_id: int | str,
+) -> dict[str, Any]:
+    """Normalize and validate raw diffusion input without inserting defaults."""
+    from vllm_omni.diffusion.data import (
+        OmniDiffusionConfig,
+        normalize_omni_diffusion_kwargs,
+        validate_omni_diffusion_kwargs,
+    )
+    from vllm_omni.engine.arg_utils import orchestrator_field_names
+
+    mixed_kwargs = {name: _copy_value(value) for name, value in kwargs.items()}
+    engine_owned = {
+        name: mixed_kwargs.pop(name)
+        for name in _DIFFUSION_SHARED_ONLY_ENGINE_FIELDS | {"quantization"}
+        if name in mixed_kwargs
+    }
+    normalized = normalize_omni_diffusion_kwargs(mixed_kwargs, apply_defaults=False)
+    if engine_owned.get("quantization") is not None and normalized.get("quantization_config") is not None:
+        raise ValueError("Diffusion config fields 'quantization' and 'quantization_config' cannot both be provided.")
+    normalized.update(engine_owned)
+
+    diffusion_fields = frozenset(config_field.name for config_field in fields(OmniDiffusionConfig))
+    stage_consumed_fields = (
+        diffusion_fields
+        | _DIFFUSION_OWNED_STAGE_ENGINE_FIELDS
+        | frozenset(_STAGE_DEPLOY_ENGINE_FIELDS)
+        | frozenset(_PIPELINE_DEPLOY_CLI_FIELDS)
+        | _DIFFUSION_STAGE_METADATA_FIELDS
+        | _DIFFUSION_DEFAULT_FACTORY_FIELDS
+    ) - _DIFFUSION_SHARED_ONLY_ENGINE_FIELDS
+    externally_consumed_fields = (
+        _DIFFUSION_SHARED_ONLY_ENGINE_FIELDS
+        | _NON_STAGE_ENGINE_CLI_FIELDS
+        | _frontend_cli_fields()
+        | orchestrator_field_names()
+        # Coordination fields also live on the typed orchestrator config, not
+        # all of them are present on the CLI-only OrchestratorArgs dataclass.
+        | frozenset(config_field.name for config_field in fields(cast(Any, VllmOmniOrchestratorConfig)))
+    )
+    allowed_fields = stage_consumed_fields | externally_consumed_fields
+    validate_omni_diffusion_kwargs(normalized, allowed_fields, stage_id=stage_id)
+    return {name: value for name, value in normalized.items() if name in stage_consumed_fields}
+
+
+def extract_diffusion_stage_config_kwargs(
+    kwargs: Mapping[str, Any],
+    *,
+    stage_id: int | str,
+    include_engine_adapter_metadata: bool = False,
+) -> dict[str, Any]:
+    """Take the diffusion-owned payload from resolved mixed stage arguments."""
+    from vllm_omni.diffusion.data import (
+        OmniDiffusionConfig,
+        normalize_omni_diffusion_kwargs,
+        validate_omni_diffusion_kwargs,
+    )
+
+    shared_only_fields = sorted(_DIFFUSION_SHARED_ONLY_ENGINE_FIELDS.intersection(kwargs))
+    if shared_only_fields:
+        field_names = ", ".join(repr(name) for name in shared_only_fields)
+        raise ValueError(
+            f"Diffusion stage {stage_id} cannot consume shared engine field(s) {field_names}; "
+            "use diffusion-owned fields or request sampling parameters instead."
+        )
+
+    diffusion_fields = frozenset(config_field.name for config_field in fields(OmniDiffusionConfig))
+    fields_owned_elsewhere = (
+        frozenset(_STAGE_DEPLOY_ENGINE_FIELDS)
+        | frozenset(_PIPELINE_DEPLOY_CLI_FIELDS)
+        | _DIFFUSION_OWNED_STAGE_ENGINE_FIELDS
+        | _DIFFUSION_STAGE_METADATA_FIELDS
+    )
+    if include_engine_adapter_metadata:
+        fields_owned_elsewhere |= _DIFFUSION_ENGINE_ADAPTER_METADATA_FIELDS
+
+    # ``quantization`` is canonical in the mixed engine namespace. Hand it to
+    # the compatibility adapter without treating it as a deprecated alias.
+    mixed_kwargs = {name: _copy_value(value) for name, value in kwargs.items()}
+    engine_quantization = mixed_kwargs.pop("quantization", None)
+    normalized = normalize_omni_diffusion_kwargs(mixed_kwargs)
+    if engine_quantization is not None:
+        if normalized.get("quantization_config") is not None:
+            raise ValueError(
+                "Diffusion config fields 'quantization' and 'quantization_config' cannot both be provided."
+            )
+        normalized["quantization_config"] = engine_quantization
+
+    validate_omni_diffusion_kwargs(
+        normalized,
+        diffusion_fields | fields_owned_elsewhere,
+        stage_id=stage_id,
+    )
+    return {name: _copy_value(value) for name, value in normalized.items() if name in diffusion_fields}
+
+
 def _global_stage_cli_fields() -> frozenset[str]:
     # Lazy import avoids vllm_omni.config -> omni_config -> engine.arg_utils ->
     # vllm_omni.config during package-level config imports.
@@ -1255,6 +1466,7 @@ def _global_stage_cli_fields() -> frozenset[str]:
     )
     externally_consumed = (
         _NON_STAGE_ENGINE_CLI_FIELDS
+        | _frontend_cli_fields()
         | frozenset(f.name for f in fields(cast(Any, VllmOmniOrchestratorConfig)))
         | (orchestrator_field_names() - _STAGE_ENGINE_FIELDS)
     )
@@ -1299,14 +1511,29 @@ def _stage_engine_values(
     if topology.omni_kv_config:
         engine["omni_kv_config"] = _copy_value(topology.omni_kv_config)
     if stage_cli_overrides:
+        stage_cli_overrides = dict(stage_cli_overrides)
         if topology.execution_type == StageExecutionType.DIFFUSION:
             # Mirror StageConfig.to_omegaconf so both projections resolve alike.
+            # CLI parallel fields move into the nested ``parallel_config`` dict,
+            # otherwise the deploy YAML's nested values would win over flat CLI
+            # flags when ``_build_parallel_config`` merges nested over flat.
+            _apply_diffusion_parallel_runtime_overrides(engine, stage_cli_overrides)
             reconcile_diffusion_attention_overrides(engine, stage_cli_overrides)
-        engine.update(_copy_value(stage_cli_overrides))
+        for key, value in stage_cli_overrides.items():
+            existing = engine.get(key)
+            if key != "omni_kv_config" and isinstance(existing, dict) and isinstance(value, Mapping):
+                engine[key] = _get_recursively_merged_dict(existing, dict(value))
+            else:
+                engine[key] = _copy_value(value)
+    if topology.execution_type == StageExecutionType.DIFFUSION:
+        diffusion_kwargs = extract_diffusion_stage_config_kwargs(engine, stage_id=topology.stage_id)
+    else:
+        diffusion_kwargs = {}
     _validate_stage_engine_override_ownership(
         topology.stage_id,
         topology.execution_type,
         engine,
+        validate_top_level=topology.execution_type != StageExecutionType.DIFFUSION,
     )
     if topology.execution_type in {
         StageExecutionType.LLM_AR,
@@ -1328,6 +1555,10 @@ def _stage_engine_values(
         ),
         model=cast(_ModelEngineOverrides, _select_engine_overrides(engine, _MODEL_ENGINE_FIELDS)),
         load=cast(_LoadEngineOverrides, _select_engine_overrides(engine, load_engine_fields)),
+        pooling=cast(
+            _PoolingEngineOverrides,
+            _select_engine_overrides(engine, _POOLING_ENGINE_FIELDS),
+        ),
         cache=cast(_CacheEngineOverrides, _select_engine_overrides(engine, cache_engine_fields)),
         scheduler=cast(
             _SchedulerEngineOverrides,
@@ -1339,7 +1570,7 @@ def _stage_engine_values(
         ),
         runtime=cast(_RuntimeEngineOverrides, _select_engine_overrides(engine, runtime_engine_fields)),
         parallel=cast(_ParallelEngineOverrides, _select_engine_overrides(engine, _PARALLEL_ENGINE_FIELDS)),
-        diffusion=_DiffusionEngineOverrides.from_engine(engine),
+        diffusion=_DiffusionEngineOverrides(_select_engine_overrides(diffusion_kwargs, _DIFFUSION_STAGE_ENGINE_FIELDS)),
         compilation_config=_copy_value(engine.get("compilation_config")),
         profiler_config=_copy_value(engine.get("profiler_config")),
     )
@@ -1400,6 +1631,7 @@ class BaseVllmOmniStageConfig:
     cache_config: OmniStageCacheConfig = field(default_factory=OmniStageCacheConfig)
     scheduler_config: OmniStageSchedulerConfig = field(default_factory=OmniStageSchedulerConfig)
     connector_config: OmniStageConnectorConfig = field(default_factory=OmniStageConnectorConfig)
+    pooling_config: OmniStagePoolingConfig = field(default_factory=OmniStagePoolingConfig)
     runtime_config: OmniStageRuntimeConfig = field(default_factory=OmniStageRuntimeConfig)
     parallel_config: OmniStageParallelConfig = field(default_factory=OmniStageParallelConfig)
     compilation_config: VllmCompilationConfig | None = None
@@ -1484,6 +1716,10 @@ class BaseVllmOmniStageConfig:
     def prompt_transform_func(self) -> str | None:
         return self.stage_pipeline_config.prompt_transform_func
 
+    @property
+    def sampling_constraints(self) -> dict[str, Any]:
+        return dict(self.stage_pipeline_config.sampling_constraints)
+
     @property
     def cfg_kv_collect_func(self) -> str | None:
         return self.stage_pipeline_config.cfg_kv_collect_func
@@ -1520,7 +1756,7 @@ def _build_common_stage_config_kwargs(
     *,
     model: str | None,
 ) -> tuple[dict[str, Any], str | None, str | None]:
-    input_proc, next_stage_proc = _select_processor_funcs(topology, bool(deploy.async_chunk))
+    input_proc, next_stage_proc = _select_processor_funcs(topology, resolve_stage_async_chunk(deploy, stage_deploy))
     quantization_config = _build_quantization_config(deploy, engine.quantization)
     parallel_config = _build_parallel_config(deploy, engine.parallel, parallel_config_cls)
 
@@ -1537,6 +1773,7 @@ def _build_common_stage_config_kwargs(
                 model=model,
             ),
             "load_config": _build_load_config(topology, engine.load),
+            "pooling_config": _build_pooling_config(stage_deploy, engine.pooling),
             "cache_config": _build_cache_config(
                 deploy,
                 engine.cache,
@@ -1734,8 +1971,14 @@ def _build_model_config(
         kwargs["dtype"] = _copy_value(deploy.dtype)
     if "active_stream_window" not in kwargs:
         kwargs["active_stream_window"] = _copy_value(deploy.active_stream_window)
+    kwargs["final_output"] = topology.final_output
     if "custom_voice_dir" not in kwargs and deploy.custom_voice_dir is not None:
         kwargs["custom_voice_dir"] = _copy_value(deploy.custom_voice_dir)
+    kwargs.setdefault("use_v2_model_runner", deploy.model_runner == "v2")
+    kwargs.setdefault(
+        "supports_native_mrv2_data_plane",
+        topology.supports_native_mrv2_data_plane,
+    )
     if "has_sampling_extra_args" not in kwargs:
         kwargs["has_sampling_extra_args"] = bool((default_sampling_params or {}).get("extra_args"))
     if "model_subdir" not in kwargs and topology.model_subdir is not None:
@@ -1750,6 +1993,20 @@ def _build_model_config(
     )
 
 
+def _build_pooling_config(
+    stage_deploy: StageDeployConfig | None,
+    engine: _PoolingEngineOverrides,
+) -> OmniStagePoolingConfig:
+    default_pooling_params = None
+    if stage_deploy is not None and stage_deploy.default_pooling_params:
+        default_pooling_params = PoolingParams(**dict(stage_deploy.default_pooling_params))
+    return cast(Any, OmniStagePoolingConfig)(
+        runner=_copy_value(engine.get("runner")),
+        pooling_output_decoder=_copy_value(engine.get("pooling_output_decoder")),
+        default_pooling_params=default_pooling_params,
+    )
+
+
 def _build_load_config(
     topology: StagePipelineConfig,
     engine: _LoadEngineOverrides,
@@ -1835,8 +2092,9 @@ def _build_connector_config(
     output_connectors = stage_deploy.output_connectors if stage_deploy is not None else None
     input_connectors = stage_deploy.input_connectors if stage_deploy is not None else None
     return cast(Any, OmniStageConnectorConfig)(
-        async_chunk=bool(deploy.async_chunk),
+        async_chunk=resolve_stage_async_chunk(deploy, stage_deploy),
         omni_kv_config=_copy_value(engine.get("omni_kv_config")),
+        kv_transfer_config=_copy_value(engine.get("kv_transfer_config")),
         output_connectors=_copy_value(output_connectors) if output_connectors else None,
         input_connectors=_copy_value(input_connectors) if input_connectors else None,
     )
@@ -1928,6 +2186,10 @@ class VllmOmniConfig:
     pipeline_config: PipelineConfig
     stage_configs: tuple[StageConfigType, ...]
     orchestrator_config: VllmOmniOrchestratorConfig = field(default_factory=VllmOmniOrchestratorConfig)
+    # Keep strategy provenance separate from the effective orchestrator value:
+    # an explicit CLI policy may be present even when the strategy declares no
+    # stage-replica axis.
+    strategy_omni_lb_policy: str | None = None
 
     def stage_by_id(self, stage_id: int) -> StageConfigType:
         for stage in self.stage_configs:
@@ -1943,6 +2205,7 @@ class VllmOmniConfig:
         user_deploy_config: DeployConfig | None = None,
         deploy_config_path: str | None = None,
         cli_overrides: dict[str, Any] | None = None,
+        strategy_specs: Mapping[Any, Any] | None = None,
     ) -> VllmOmniConfig:
         """Create a structured config from a resolved pipeline and deploy YAML."""
         if cli_overrides is None:
@@ -1966,6 +2229,63 @@ class VllmOmniConfig:
         if len(pipeline_cfg.stages) <= 1:
             deploy.async_chunk = False
         _validate_async_chunk_support(pipeline_cfg, deploy)
+        validate_stage_async_chunk_edges(pipeline_cfg, deploy)
+
+        strategy_result = None
+        if strategy_specs:
+            from vllm_omni.config.composable_parallel import apply_strategy_specs
+
+            strategy_stages = merge_pipeline_deploy(pipeline_cfg, copy.deepcopy(deploy), {})
+            strategy_result = apply_strategy_specs(strategy_stages, strategy_specs)
+            strategy_overrides: dict[str, Any] = {}
+            axis_fields = {
+                "tp": "tensor_parallel_size",
+                "dp": "data_parallel_size",
+                "pp": "pipeline_parallel_size",
+            }
+            for stage_id, parallel in strategy_result.per_stage_config.items():
+                declared = set(parallel.l1_owners)
+                explicit = build_stage_runtime_overrides(stage_id, cli_overrides)
+                for axis, field_name in axis_fields.items():
+                    if axis not in declared:
+                        continue
+                    derived = getattr(parallel, field_name)
+                    value = explicit.get(field_name)
+                    if value is None:
+                        value = derived
+                    elif value != derived:
+                        logger.warning(
+                            "[composable_parallel] stage %s: CLI %s=%s overrides the "
+                            "strategy-derived %s=%s. The CLI value wins; remove one to avoid ambiguity.",
+                            stage_id,
+                            field_name,
+                            value,
+                            field_name,
+                            derived,
+                        )
+                    strategy_overrides[f"stage_{stage_id}_{field_name}"] = value
+                if "ep" in declared and parallel.enable_expert_parallel:
+                    strategy_overrides[f"stage_{stage_id}_enable_expert_parallel"] = bool(
+                        explicit.get("enable_expert_parallel", True)
+                    )
+                if "stage_replica" in declared:
+                    derived = parallel.stage_replica_size
+                    value = explicit.get("num_replicas")
+                    if value is None:
+                        value = derived
+                    elif value != derived:
+                        logger.warning(
+                            "[composable_parallel] stage %s: CLI num_replicas=%s overrides the "
+                            "strategy-derived num_replicas=%s. The CLI value wins; remove one to avoid ambiguity.",
+                            stage_id,
+                            value,
+                            derived,
+                        )
+                    strategy_overrides[f"stage_{stage_id}_num_replicas"] = value
+            cli_overrides = {**strategy_overrides, **cli_overrides}
+            if strategy_result.omni_lb_policy is not None and cli_overrides.get("omni_lb_policy") is None:
+                cli_overrides["omni_lb_policy"] = strategy_result.omni_lb_policy
+
         deploy_by_id = {stage.stage_id: stage for stage in deploy.stages}
         model = cli_overrides.get("model")
 
@@ -1988,6 +2308,20 @@ class VllmOmniConfig:
             )
             for topology in pipeline_cfg.stages
         )
+        if strategy_result is not None:
+            from vllm_omni.config.composable_parallel import check_device_layout
+
+            by_id = {stage.stage_id: stage for stage in stage_configs}
+            for stage_id in strategy_result.per_stage_config:
+                stage = by_id[stage_id]
+                check_device_layout(
+                    stage.runtime_config.devices,
+                    tensor_parallel_size=stage.parallel_config.tensor_parallel_size,
+                    data_parallel_size=stage.parallel_config.data_parallel_size,
+                    pipeline_parallel_size=stage.parallel_config.pipeline_parallel_size,
+                    num_replicas=stage.runtime_config.num_replicas,
+                    role=stage.model_stage,
+                )
 
         orchestrator_config = cast(Any, VllmOmniOrchestratorConfig)(
             deploy_config_path=loaded_deploy_config_path,
@@ -1997,6 +2331,7 @@ class VllmOmniConfig:
             pipeline_config=pipeline_cfg,
             stage_configs=stage_configs,
             orchestrator_config=orchestrator_config,
+            strategy_omni_lb_policy=(strategy_result.omni_lb_policy if strategy_result is not None else None),
         )
 
 
diff --git a/vllm_omni/config/pipeline_registry.py b/vllm_omni/config/pipeline_registry.py
index 92aad9f4d..4876bd0e1 100644
--- a/vllm_omni/config/pipeline_registry.py
+++ b/vllm_omni/config/pipeline_registry.py
@@ -33,6 +33,7 @@ from vllm_omni.config.stage_config import (
     PipelineConfig,
 )
 from vllm_omni.diffusion.models.pi0_pipeline_config import PI0_PIPELINE
+from vllm_omni.diffusion.models.pi05_pipeline_config import PI05_PIPELINE
 from vllm_omni.model_executor.models.audex.pipeline import (
     AUDEX_S2S_PIPELINE,
     AUDEX_THINKER_ONLY_PIPELINE,
@@ -51,9 +52,7 @@ from vllm_omni.model_executor.models.breeze_tts_2.pipeline import BREEZE_TTS_2_P
 from vllm_omni.model_executor.models.cosmos3.pipeline import COSMOS3_POLICY_PIPELINE
 from vllm_omni.model_executor.models.cosyvoice3.pipeline import COSYVOICE3_PIPELINE
 from vllm_omni.model_executor.models.covo_audio.pipeline import COVO_AUDIO_PIPELINE
-from vllm_omni.model_executor.models.dots_tts.pipeline import DOTS_TTS_PIPELINE
 from vllm_omni.model_executor.models.dreamzero.pipeline import DREAMZERO_PIPELINE
-from vllm_omni.model_executor.models.dynin_omni.pipeline import DYNIN_OMNI_PIPELINE
 from vllm_omni.model_executor.models.fish_speech.pipeline import FISH_SPEECH_PIPELINE
 from vllm_omni.model_executor.models.gepard.pipeline import GEPARD_PIPELINE
 from vllm_omni.model_executor.models.glm_image.pipeline import GLM_IMAGE_PIPELINE
@@ -153,6 +152,7 @@ OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "lingbot_world": LINGBOT_WORLD_PIPELINE,
     "Gr00tN1d7": GR00T_N1D7_PIPELINE,
     "pi0": PI0_PIPELINE,
+    "pi05": PI05_PIPELINE,
     # Cosmos3 policy checkpoints share HF metadata with the T2I/video Cosmos3
     # checkpoints (which stay on the single-stage diffusion fallback), so this
     # entry is only reachable through a deploy yaml's ``pipeline:`` key
@@ -166,7 +166,6 @@ OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "hunyuan_video_15": HUNYUAN_VIDEO_15_PIPELINE,
     "wan2_2_ti2v": WAN2_2_TI2V_PIPELINE,
     "voxcpm2": VOXCPM2_PIPELINE,
-    "dots_tts": DOTS_TTS_PIPELINE,
     "auk": AUK_PIPELINE,
     "cosyvoice3": COSYVOICE3_PIPELINE,
     "audex_tts": AUDEX_TTS_PIPELINE,
@@ -200,7 +199,6 @@ OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "minimax_music3": MINIMAX_MUSIC3_PIPELINE,
     "higgs_audio_v2": HIGGS_AUDIO_V2_PIPELINE,
     "higgs_multimodal_qwen3": HIGGS_AUDIO_V3_PIPELINE,
-    "dynin_omni": DYNIN_OMNI_PIPELINE,
     "indextts2": INDEXTTS2_PIPELINE,
     "indextts2_5": INDEXTTS25_PIPELINE,
 }
diff --git a/vllm_omni/config/resolver.py b/vllm_omni/config/resolver.py
index 4f5ee8a6c..76740aa06 100644
--- a/vllm_omni/config/resolver.py
+++ b/vllm_omni/config/resolver.py
@@ -5,6 +5,7 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass, fields, is_dataclass
+from pathlib import Path
 from typing import Any
 
 from vllm.logger import init_logger
@@ -14,9 +15,8 @@ from vllm_omni.config.config_factory import StageConfigFactory, with_trust_remot
 from vllm_omni.config.endpoint_policy import EndpointRestriction
 from vllm_omni.config.omni_config import VllmOmniConfig
 from vllm_omni.config.stage_config import PipelineConfig
-from vllm_omni.config.yaml_util import create_config
 from vllm_omni.diffusion.data import resolve_model_class_name
-from vllm_omni.diffusion.registry import DiffusionModelRegistry
+from vllm_omni.diffusion.registry import DiffusionModelRegistry, resolve_native_single_file
 from vllm_omni.diffusion.utils.hf_utils import is_diffusion_model
 
 logger = init_logger(__name__)
@@ -24,19 +24,10 @@ logger = init_logger(__name__)
 
 @dataclass(frozen=True)
 class OmniConfigResolution:
-    """Migration envelope returned by the production config resolver.
-
-    ``stage_configs`` intentionally carries the current OmegaConf-compatible
-    runtime ABI only until stage startup consumes ``VllmOmniConfig`` directly.
-    ``pipeline_config`` is the effective topology after runtime stage injection,
-    so both fields always describe the same set of stages.
-    It is not a stable authoring or extension API; new production callers
-    should resolve through :func:`resolve_omni_config` and must not construct or
-    merge this compatibility shape themselves.
-    """
+    """Canonical typed result returned by the production config resolver."""
 
     config_path: str | None
-    stage_configs: tuple[Any, ...]  # Temporary StageConfig/OmegaConf bridge.
+    stage_configs: tuple[Any, ...]
     pipeline_config: PipelineConfig | None = None
     omni_lb_policy: str | None = None
 
@@ -176,27 +167,13 @@ def _load_strategy_specs(strategy_config_path: str | None) -> Mapping[Any, Any]
 
 def _build_registered_resolution(
     structured_config: VllmOmniConfig,
-    *,
-    cli_overrides: dict[str, Any],
-    strategy_config_path: str | None,
 ) -> OmniConfigResolution:
-    """Build the temporary runtime view for an already-resolved pipeline."""
-    # Runtime consumers have not yet moved to typed per-stage configs. Use the
-    # factory-owned compatibility bridge instead of reimplementing legacy YAML
-    # discovery and merging in this resolver.
-    effective_deploy_path = structured_config.orchestrator_config.deploy_config_path
-    legacy_resolution = StageConfigFactory._resolve_legacy_from_registry(
-        structured_config.pipeline_config,
-        cli_overrides,
-        effective_deploy_path,
-        strategy_specs=_load_strategy_specs(strategy_config_path),
-    )
-
+    """Return the canonical structured runtime view for a resolved pipeline."""
     return OmniConfigResolution(
-        config_path=effective_deploy_path,
-        stage_configs=tuple(stage.to_omegaconf() for stage in legacy_resolution.stage_configs),
-        pipeline_config=legacy_resolution.pipeline_config,
-        omni_lb_policy=legacy_resolution.omni_lb_policy,
+        config_path=structured_config.orchestrator_config.deploy_config_path,
+        stage_configs=tuple(structured_config.stage_configs),
+        pipeline_config=structured_config.pipeline_config,
+        omni_lb_policy=getattr(structured_config, "strategy_omni_lb_policy", None),
     )
 
 
@@ -228,21 +205,26 @@ def resolve_omni_config(
     """Resolve registry/deploy inputs through the single public entrypoint."""
     normalized_overrides = _convert_dataclasses_to_dict(dict(cli_overrides or {}))
     normalized_overrides = with_trust_remote_code_override(normalized_overrides, trust_remote_code)
+    native_single_file_model = resolve_native_single_file(normalized_overrides.get("model_class_name"))
+    is_native_single_file = native_single_file_model is not None and Path(model).is_file()
+    if is_native_single_file:
+        normalized_overrides["model_class_name"] = native_single_file_model
     registry_overrides = dict(normalized_overrides)
     _flatten_stage_overrides(registry_overrides, stage_overrides)
 
-    structured_config = StageConfigFactory.create_from_model(
-        model,
-        trust_remote_code=trust_remote_code,
-        cli_overrides=registry_overrides,
-        deploy_config_path=deploy_config_path,
-    )
-    if structured_config is not None:
-        return _build_registered_resolution(
-            structured_config,
+    strategy_specs = _load_strategy_specs(strategy_config_path)
+    structured_config = None
+    # Native checkpoint files have no HF config or pipeline index to discover.
+    if deploy_config_path is not None or not is_native_single_file:
+        structured_config = StageConfigFactory.create_from_model(
+            model,
+            trust_remote_code=trust_remote_code,
             cli_overrides=registry_overrides,
-            strategy_config_path=strategy_config_path,
+            deploy_config_path=deploy_config_path,
+            strategy_specs=strategy_specs,
         )
+    if structured_config is not None:
+        return _build_registered_resolution(structured_config)
 
     _apply_generic_stage_overrides(normalized_overrides, stage_overrides)
     supported, model_class_name = _resolve_generic_diffusion_model_class(model, normalized_overrides)
@@ -252,11 +234,12 @@ def resolve_omni_config(
         )
     if model_class_name is not None:
         normalized_overrides.setdefault("model_class_name", model_class_name)
-    default_stages = StageConfigFactory.create_default_diffusion(normalized_overrides)
+    default_config = StageConfigFactory.create_typed_default_diffusion(model, normalized_overrides)
 
     return OmniConfigResolution(
         config_path=deploy_config_path,
-        stage_configs=tuple(create_config(_convert_dataclasses_to_dict(default_stages))),
+        stage_configs=tuple(default_config.stage_configs),
+        pipeline_config=default_config.pipeline_config,
     )
 
 
diff --git a/vllm_omni/config/stage_config.py b/vllm_omni/config/stage_config.py
index c96f514e8..aab4752e0 100644
--- a/vllm_omni/config/stage_config.py
+++ b/vllm_omni/config/stage_config.py
@@ -11,7 +11,7 @@ from collections.abc import Callable, Mapping
 from dataclasses import asdict, dataclass, field, fields
 from enum import Enum
 from pathlib import Path
-from typing import Any, NamedTuple
+from typing import Any, Literal, NamedTuple
 
 from transformers import PretrainedConfig
 from vllm.logger import init_logger
@@ -250,6 +250,7 @@ class StagePipelineConfig:
     # Alternates picked by ``merge_pipeline_deploy`` based on ``deploy.async_chunk``.
     async_chunk_process_next_stage_input_func: str | None = None
     sync_process_input_func: str | None = None
+    supports_native_mrv2_data_plane: bool = False
     # Rewrites the Stage-0 view of a raw prompt before vLLM input processing.
     # The callable receives ``(prompt, sampling_params_list)``; downstream
     # stages continue to receive the original prompt.
@@ -309,11 +310,11 @@ class PipelineConfig:
     diffusers_class_name: str | None = None
     diffusers_class_aliases: tuple[str, ...] = ()
     endpoint_restrictions: tuple[EndpointRestriction, ...] = ()
-    # Dotted path of the model's ``DuplexModelPlugin``. A pipeline is a duplex
-    # model iff this is set: ``vllm-omni serve`` then always runs it through
-    # ``DuplexOmni`` (every served surface runs on a duplex session) and the engine hosts one
-    # ``DuplexOrchestrator`` with the plugin loaded.
+    # Dotted path of the model's ``DuplexModelPlugin``. Online serving uses
+    # DuplexOmni only when the deploy configuration selects session_mode: duplex.
     duplex_plugin: str | None = None
+    # Preserve legacy turn deployments when adding an optional duplex plugin.
+    default_session_mode: str | None = None
     # Legacy duplex wiring of the models that are not ported to the plugin
     # framework yet (PersonaPlex, Nemotron VoiceChat). Nothing reads them: a
     # pipeline that only declares these is served turn-based. Each field goes
@@ -390,6 +391,9 @@ class StageDeployConfig:
     num_replicas: int = 1
     env: dict[str, Any] | None = None
 
+    # False opts this stage out of pipeline-wide async chunking.
+    async_chunk: bool | None = None
+
     # Inter-stage connector wiring and request defaults.
     output_connectors: dict[str, str] | None = None
     input_connectors: dict[str, str] | None = None
@@ -563,6 +567,7 @@ class DeployConfig:
 
     async_chunk: bool = True
     session_mode: str = "turn"
+    model_runner: Literal["v1", "v2"] = "v1"
     # Stage-1 active stream slots; 0 preserves legacy all-stream cycling.
     active_stream_window: int = 0
     duplex_session: DuplexSessionRuntimeConfig = field(default_factory=DuplexSessionRuntimeConfig)
@@ -587,6 +592,7 @@ class DeployConfig:
 
 _STAGE_RESERVED_KEYS = frozenset(
     {
+        "async_chunk",
         "stage_id",
         "devices",
         "num_replicas",
@@ -645,6 +651,7 @@ def _parse_stage_deploy(stage_data: dict[str, Any]) -> StageDeployConfig:
         if name in flat_args:
             kwargs[name] = flat_args.pop(name)
 
+    kwargs["async_chunk"] = stage_data.get("async_chunk")
     kwargs["output_connectors"] = stage_data.get("output_connectors")
     kwargs["input_connectors"] = stage_data.get("input_connectors")
     kwargs["default_sampling_params"] = stage_data.get("default_sampling_params")
@@ -731,6 +738,16 @@ def _merge_platforms(
     return merged
 
 
+def _merge_connectors(
+    base: dict[str, Any] | None,
+    overlay: dict[str, Any] | None,
+) -> dict[str, Any] | None:
+    """Deep-merge named connector definitions from a deploy overlay."""
+    if not base and not overlay:
+        return None
+    return _get_recursively_merged_dict(base or {}, overlay or {})
+
+
 def resolve_deploy_yaml(path: str | Path) -> dict[str, Any]:
     """Load a deploy YAML with optional ``base_config`` inheritance."""
     raw_dict = to_dict(load_yaml_config(path))
@@ -743,12 +760,15 @@ def resolve_deploy_yaml(path: str | Path) -> dict[str, Any]:
     base_path = Path(path).parent / base_path
     base_dict = resolve_deploy_yaml(base_path)
 
-    # Merge top-level scalars: overlay wins. ``stages:`` and ``platforms:``
-    # are deep-merged below so an overlay can layer on top of the base.
+    # Merge top-level scalars: overlay wins. Structured sections are merged
+    # below so a thin overlay does not discard inherited runtime contracts.
     merged = {
         **base_dict,
-        **{k: v for k, v in raw_dict.items() if k not in ("stages", "platforms")},
+        **{k: v for k, v in raw_dict.items() if k not in ("connectors", "stages", "platforms")},
     }
+    merged_connectors = _merge_connectors(base_dict.get("connectors"), raw_dict.get("connectors"))
+    if merged_connectors is not None:
+        merged["connectors"] = merged_connectors
     merged["stages"] = _merge_stage_lists(base_dict.get("stages"), raw_dict.get("stages"))
     merged_platforms = _merge_platforms(base_dict.get("platforms"), raw_dict.get("platforms"))
     if merged_platforms is not None:
@@ -768,9 +788,14 @@ def load_deploy_config(path: str | Path) -> DeployConfig:
 
     stages = [_parse_stage_deploy(s) for s in raw_dict.get("stages", [])]
 
+    model_runner = raw_dict.get("model_runner", "v1")
+    if model_runner not in ("v1", "v2"):
+        raise ValueError(f"model_runner must be one of ('v1', 'v2'), got {model_runner!r}")
+
     kwargs: dict[str, Any] = {
         "async_chunk": raw_dict.get("async_chunk", True),
         "session_mode": raw_dict.get("session_mode", "turn"),
+        "model_runner": model_runner,
         "active_stream_window": int(raw_dict.get("active_stream_window", 0) or 0),
         "duplex_session": DuplexSessionRuntimeConfig(**(raw_dict.get("duplex_session") or {})),
         "connectors": raw_dict.get("connectors", None),
@@ -823,15 +848,25 @@ def _apply_platform_overrides(
     deploy: DeployConfig,
     platform: str | None = None,
 ) -> DeployConfig:
-    """Merge platform-specific stage overrides into deploy config."""
+    """Merge platform-specific runner and stage overrides into deploy config."""
     if platform is None:
         from vllm_omni.platforms import current_omni_platform
 
         device_name = current_omni_platform.device_name
         platform = device_name.lower() if device_name is not None else None
+    platform_section = (deploy.platforms or {}).get(platform) if platform is not None else None
+    if platform_section is not None and "model_runner" in platform_section:
+        model_runner = platform_section["model_runner"]
+        if model_runner not in ("v1", "v2"):
+            raise ValueError(f"platform model_runner must be one of ('v1', 'v2'), got {model_runner!r}")
+        deploy.model_runner = model_runner
+    if deploy.model_runner == "v2" and platform in {"npu", "xpu"}:
+        raise NotImplementedError(
+            f"Model Runner V2 is not supported on {platform.upper()}: "
+            "the platform worker still uses the legacy chunk-transfer data plane."
+        )
     if platform is None or deploy.platforms is None:
         return deploy
-    platform_section = deploy.platforms.get(platform)
     if platform_section is None:
         return deploy
 
@@ -888,6 +923,28 @@ def _resolve_execution_mode(
     return _EXECUTION_TYPE_TO_STAGE_WORKER.get(execution_type, (StageType.LLM, None))
 
 
+def resolve_stage_async_chunk(deploy: DeployConfig, stage: StageDeployConfig | None) -> bool:
+    return bool(deploy.async_chunk and (stage is None or stage.async_chunk is not False))
+
+
+def validate_stage_async_chunk_edges(pipeline: PipelineConfig, deploy: DeployConfig) -> None:
+    stages = {stage.stage_id: stage for stage in pipeline.stages}
+    deploy_by_id = {stage.stage_id: stage for stage in deploy.stages}
+    for consumer in pipeline.stages:
+        for source_id in consumer.input_sources:
+            producer = stages[source_id]
+            if not producer.async_chunk_process_next_stage_input_func:
+                continue
+            producer_async = resolve_stage_async_chunk(deploy, deploy_by_id.get(source_id))
+            consumer_async = resolve_stage_async_chunk(deploy, deploy_by_id.get(consumer.stage_id))
+            if producer_async != consumer_async:
+                raise ValueError(
+                    f"Pipeline {pipeline.model_type!r} has incompatible async_chunk settings on "
+                    f"connector edge {source_id} -> {consumer.stage_id}. "
+                    "Set the same async_chunk mode on both stages or disable pipeline-wide async_chunk."
+                )
+
+
 def _select_processor_funcs(
     ps: StagePipelineConfig,
     async_chunk: bool,
@@ -964,15 +1021,35 @@ def _build_engine_args(
                 continue
             engine_args[k] = v
         engine_args.update(ds.engine_extras)
-    # Materialize the resolved pipeline-wide async_chunk value into every
-    # stage so explicit False overrides do not get lost downstream.
-    engine_args["async_chunk"] = bool(deploy.async_chunk)
+    engine_args["async_chunk"] = resolve_stage_async_chunk(deploy, ds)
     engine_args["session_mode"] = deploy.session_mode
     if deploy.session_mode == "duplex":
         # The engine admission limit is also the authoritative capacity for
         # model-owned streaming state. Propagate it to every stage instead of
         # making individual models duplicate the value in connector extras.
         engine_args["duplex_max_sessions"] = deploy.duplex_session.max_sessions
+    # The runner selection is a deploy-topology decision owned by the
+    # ``model_runner`` field; do not let an opaque ``engine_extras`` entry
+    # silently veto or force it per stage.
+    if ds is not None:
+        for reserved in ("use_v2_model_runner", "supports_native_mrv2_data_plane"):
+            if reserved in ds.engine_extras:
+                raise ValueError(
+                    f"stage {ds.stage_id}: {reserved!r} must not be set via engine_extras; "
+                    "it is derived from the deploy-level `model_runner` field and the "
+                    "pipeline's `supports_native_mrv2_data_plane` declaration."
+                )
+    engine_args["use_v2_model_runner"] = deploy.model_runner == "v2"
+    engine_args["supports_native_mrv2_data_plane"] = bool(ps.supports_native_mrv2_data_plane)
+    if deploy.model_runner == "v2" and not ps.supports_native_mrv2_data_plane:
+        logger.warning(
+            "Stage %s (%s) selects model_runner=v2 without declaring "
+            "supports_native_mrv2_data_plane. It will use the legacy transport path; "
+            "MRV2 support for this pipeline has not been validated. Use model_runner=v1 "
+            "unless you are validating a new MRV2 integration.",
+            ps.stage_id,
+            ps.model_arch or pipeline.model_arch or pipeline.model_type,
+        )
     if ps.omni_kv_config:
         engine_args["omni_kv_config"] = dict(ps.omni_kv_config)
     engine_args["requires_full_payload_input"] = ps.requires_full_payload_input
@@ -1060,11 +1137,12 @@ def merge_pipeline_deploy(
             "Either set async_chunk=False or implement an async-chunk producer on the pipeline."
         )
 
+    validate_stage_async_chunk_edges(pipeline, deploy)
     result: list[StageConfig] = []
     for ps in pipeline.stages:
         ds = deploy_by_id.get(ps.stage_id)
         stage_type, worker_type = _resolve_execution_mode(ps.execution_type)
-        input_proc, next_stage_proc = _select_processor_funcs(ps, deploy.async_chunk)
+        input_proc, next_stage_proc = _select_processor_funcs(ps, resolve_stage_async_chunk(deploy, ds))
         engine_args = _build_engine_args(ps, ds, pipeline, deploy, next_stage_proc)
         # Downstream stages may share a multimodal wrapper class without owning
         # an encoder. Do not make vLLM profile dummy multimodal inputs for them.
@@ -1170,6 +1248,9 @@ class StageConfig:
                 else:
                     engine_args[key] = value
 
+        # Terminal-stage ownership comes from topology, not engine overrides.
+        engine_args["final_output"] = self.final_output
+
         # Build runtime config from YAML defaults + CLI overrides
         runtime: dict[str, Any] = dict(self.yaml_runtime)
         runtime.setdefault("process", True)
diff --git a/vllm_omni/core/prefix_cache.py b/vllm_omni/core/prefix_cache.py
deleted file mode 100644
index 17a981140..000000000
--- a/vllm_omni/core/prefix_cache.py
+++ /dev/null
@@ -1,737 +0,0 @@
-"""
-Utilities for Prefix Caching in Omni models.
-"""
-
-from dataclasses import dataclass, field
-
-import torch
-from vllm.logger import init_logger
-from vllm.v1.worker.gpu_input_batch import InputBatch
-
-from vllm_omni.utils.mm_outputs import build_mm_cpu, to_payload_element
-
-logger = init_logger(__name__)
-
-
-@dataclass
-class _PendingAsyncWrite:
-    """One in-flight async write into the prefix cache.
-
-    Holds the CPU tensors that PyTorch implicitly allocated via
-    ``.to("cpu", non_blocking=True)`` together with a CUDA event recorded
-    on the copy stream. The consumer calls ``event.synchronize()`` once
-    (blocking) to guarantee the D2H has completed before reading.
-    """
-
-    event: "torch.cuda.Event"
-    num_tokens: int
-    slots_cpu: torch.Tensor
-    hidden_cpu: torch.Tensor | None
-    mm_cpu: dict[str, torch.Tensor] = field(default_factory=dict)
-
-
-class OmniTensorPrefixCache:
-    """Prefix cache for hidden states (model outputs) and model specific
-    multimodal outputs.
-
-    This class implements prefix caching in a non-invasive way on top of
-    vLLM by leveraging the same slot mappings that the vLLM scheduler uses
-    for the KV Cache.
-
-    Conceptually, this means we are mapping vLLM's cache mapping:
-                        (num_blocks, block_size)
-
-    to 3D tensors of shape:
-                   (num_blocks, block_size, feature_size)
-
-    Note that feature_size may vary across multimodal_outputs.
-    """
-
-    def __init__(
-        self,
-        num_blocks: int,
-        block_size: int,
-        hidden_size: int,
-        hs_dtype: torch.dtype,
-    ):
-        self.num_blocks = num_blocks
-        self.block_size = block_size
-        self.default_hidden_size = hidden_size
-
-        # Initialize the hidden states cache immediately
-        self.hidden_states_cache = self._get_cache_tensor(dtype=hs_dtype)
-
-        # Defer initialization of the mm_outputs_cache until we
-        # actually see mm output tensors dependent on num tokens.
-        self.mm_outputs_cache = {}
-        self.mm_cache_keys = set()
-        self._new_req_cache_hit_ids: set[str] = set()
-        self._deferred_mm_outputs: dict[str, dict[str, list[tuple[int, torch.Tensor]]]] = {}
-
-        # Async write pipeline state:
-        #   - one dedicated copy stream
-        #   - one in-flight pending write at a time (the producer is exactly
-        #     one forward step ahead of the consumer)
-        #   - schedule_async_write() consumes the *previous* pending write
-        #     (via event.synchronize() + scatter) before kicking off the new
-        #     D2H. By the time we hit synchronize, the previous step's GPU
-        #     work has been done for ~one forward step, so the sync is
-        #     near-zero wall-clock.
-        self._async_initialized: bool = False
-        self._async_copy_stream: torch.cuda.Stream | None = None
-        self._pending_write: _PendingAsyncWrite | None = None
-
-    def maybe_init_missing_mm_cache_keys(self, multimodal_outputs: dict, seq_len: int):
-        """Given multimodal outputs from executing the model, dynamically
-        determine which multimodal outputs are tensors depending on sequence
-        length and should be cached, and initialize the cache tensors
-        accordingly.
-
-        NOTE: This is done to avoid the need for explicit specification of
-        cache keys for every model/stage and aligns with the current way
-        that we slice the multimodal outputs based on the first dimension.
-
-        This will usually be called by the first forward pass, i.e.,
-        determined by the warmup.
-        """
-        for key, val in multimodal_outputs.items():
-            # Only cache per-token feature tensors: 2D+ with first dim == seq_len.
-            # A 1D tensor of shape (seq_len,) is a broadcast scalar (per-request
-            # metadata such as ref_code_len / codec_streaming), not per-token data;
-            # caching it by slot causes a shape mismatch when a later request has a
-            # different scheduled seq length.
-            if (
-                isinstance(val, torch.Tensor)
-                and val.ndim >= 2
-                and val.shape[0] == seq_len
-                and key not in self.mm_cache_keys
-            ):
-                feat_dim = val.shape[-1]
-                self.mm_outputs_cache[key] = self._get_cache_tensor(
-                    dtype=val.dtype,
-                    hidden_size=feat_dim,
-                )
-                self.mm_cache_keys.add(key)
-                new_tensor_shape = self.mm_outputs_cache[key].shape
-                logger.info("Initializing multimodal output cache of size %s for key: %s", list(new_tensor_shape), key)
-
-    def _get_cache_tensor(self, dtype: torch.dtype, hidden_size: int | None = None) -> torch.Tensor:
-        """Allocate a CPU cache tensor for a specific key.
-
-        When CUDA is available the tensor is pinned: this is what lets the
-        async-write pipeline ride the GPU->CPU copy on the dedicated copy
-        stream as a true async ``cudaMemcpyAsync`` and lets the post-copy CPU
-        scatter avoid page-resolution stalls. On CPU-only builds pinning is
-        unsupported (``torch.zeros(pin_memory=True)`` raises), and the async
-        pipeline is disabled anyway (``schedule_async_write`` early-returns
-        when ``torch.cuda.is_available()`` is False), so we fall back to a
-        plain pageable allocation with no behavioral change.
-        """
-        actual_hidden_size = hidden_size if hidden_size is not None else self.default_hidden_size
-        return torch.zeros(
-            (self.num_blocks, self.block_size, actual_hidden_size),
-            dtype=dtype,
-            device="cpu",
-            pin_memory=torch.cuda.is_available(),
-        )
-
-    # =====================================================================
-    # Async write pipeline:
-    #   schedule_async_write : called per forward step, enqueues a
-    #                          non-blocking D2H + records a CUDA event
-    #   drain_ready_async_writes : non-blocking poll, applies any writes
-    #                              whose D2H has completed
-    # =====================================================================
-
-    def _ensure_async_resources(self) -> None:
-        """Lazily allocate the dedicated copy stream.
-
-        The per-step CPU staging tensors are allocated by PyTorch on demand
-        inside ``.to("cpu", non_blocking=True)``, which gives them
-        implicitly-pinned memory and lets PyTorch's allocator amortize /
-        reuse them.
-        """
-        if self._async_initialized:
-            return
-        if not torch.cuda.is_available():
-            return
-        self._async_copy_stream = torch.cuda.Stream()
-        self._async_initialized = True
-        logger.info("Omni prefix cache async-write copy stream initialized.")
-
-    def schedule_async_write(
-        self,
-        hidden_states_gpu: torch.Tensor | None,
-        multimodal_outputs_gpu: dict[str, torch.Tensor] | None,
-        slot_mapping_gpu: torch.Tensor,
-        num_tokens_unpadded: int,
-        num_tokens_padded: int,
-        skip_mm_cache_keys: set[str] | None = None,
-    ) -> None:
-        """Kick off a non-blocking GPU->CPU copy for this step's writes.
-
-        1. **Consume the previous step's write** (if any): block on its
-           event and scatter the CPU tensors into the cache. By the time we
-           reach this point, the previous step's GPU work has been done for
-           ~one forward step, so the synchronize is near-zero wall-clock.
-        2. **Schedule THIS step's D2H** on a dedicated copy stream using
-           ``.to("cpu", non_blocking=True)``. PyTorch allocates the pinned
-           destination implicitly.
-        3. **Record an event** and stash everything for the next step's
-           consume.
-
-        Holding exactly one in-flight write at a time keeps the design
-        simple: no ring, no event-polling, no driver-mutex pressure from
-        repeated event.query() calls.
-        """
-        if not torch.cuda.is_available():
-            return
-
-        self._ensure_async_resources()
-        if not self._async_initialized:
-            return
-
-        # Decide which mm keys we'll cache. Init the dest cache tensors
-        # before scheduling the copies so the apply step has somewhere
-        # to scatter into.
-        skip = skip_mm_cache_keys or set()
-        cacheable_mm_keys: list[str] = []
-        if multimodal_outputs_gpu:
-            self.maybe_init_missing_mm_cache_keys(multimodal_outputs_gpu, seq_len=num_tokens_padded)
-            for k in self.mm_cache_keys:
-                if k in skip:
-                    continue
-                v = multimodal_outputs_gpu.get(k)
-                if not isinstance(v, torch.Tensor) or v.ndim < 2:
-                    continue
-                if v.shape[0] < num_tokens_unpadded:
-                    continue
-                cacheable_mm_keys.append(k)
-
-        # Step 1: consume the previous step's write FIRST. The previous
-        # step's event was recorded ~one forward step ago, so
-        # synchronize() is effectively a no-op cost-wise; the scatter
-        # into pinned CPU caches is also fast.
-        self._consume_pending_write()
-
-        if hidden_states_gpu is None and not cacheable_mm_keys:
-            return  # nothing to schedule this step
-
-        # Step 2: schedule the D2H on the copy stream. PyTorch implicitly
-        # allocates pinned host destinations for the ``.to("cpu",
-        # non_blocking=True)`` results.
-        copy_stream = self._async_copy_stream
-        default_stream = torch.cuda.current_stream()
-        with torch.cuda.stream(copy_stream):
-            copy_stream.wait_stream(default_stream)
-
-            # slot_mapping: copy as-is; the int64 cast required by
-            # ``index_copy_`` is deferred to ``_consume_pending_write``
-            # so we avoid launching an extra GPU kernel here that would
-            # contend the driver mutex with the compute stream.
-            slots_cpu = slot_mapping_gpu[:num_tokens_unpadded].to("cpu", non_blocking=True)
-            hidden_cpu: torch.Tensor | None = None
-            if hidden_states_gpu is not None:
-                hidden_cpu = hidden_states_gpu[:num_tokens_unpadded].to("cpu", non_blocking=True)
-            mm_cpu: dict[str, torch.Tensor] = {}
-            for k in cacheable_mm_keys:
-                mm_cpu[k] = multimodal_outputs_gpu[k][:num_tokens_unpadded].to("cpu", non_blocking=True)
-
-            event = torch.cuda.Event()
-            event.record()
-
-        # Step 3: stash for next step's consume.
-        self._pending_write = _PendingAsyncWrite(
-            event=event,
-            num_tokens=num_tokens_unpadded,
-            slots_cpu=slots_cpu,
-            hidden_cpu=hidden_cpu,
-            mm_cpu=mm_cpu,
-        )
-
-    def drain_ready_async_writes(self) -> int:
-        """Consume one in-flight write if it has finished (non-blocking).
-
-        Exposed so the model runner can drain at the top of
-        ``execute_model`` regardless of whether a new write will be
-        scheduled this step.
-        """
-        if self._pending_write is None:
-            return 0
-        if not self._pending_write.event.query():
-            return 0
-        self._consume_pending_write()
-        return 1
-
-    def _consume_pending_write(self) -> None:
-        """Synchronize on the pending event and scatter the CPU tensors
-        into the destination caches. Drops state on completion.
-        """
-        entry = self._pending_write
-        if entry is None:
-            return
-        self._pending_write = None
-        entry.event.synchronize()
-        n = entry.num_tokens
-        if n <= 0:
-            return
-
-        slots = entry.slots_cpu
-        if slots.dtype != torch.int64:
-            slots = slots.to(torch.int64)
-
-        # NOTE: ``index_copy_(0, idx, src)`` is the row-scatter primitive in
-        # PyTorch. It's semantically identical to ``flat[idx] = src`` but
-        # dispatches to a much simpler CPU implementation (single dim,
-        # no broadcasting, no accumulate), which on pinned memory at large
-        # row sizes is observed to be much faster than the generic
-        # ``aten::index_put_`` path used by advanced-indexing assignment.
-        if entry.hidden_cpu is not None:
-            flat = self.hidden_states_cache.view(-1, self.hidden_states_cache.shape[-1])
-            flat.index_copy_(0, slots, entry.hidden_cpu)
-        for k, src_cpu in entry.mm_cpu.items():
-            mm_cache = self.mm_outputs_cache.get(k)
-            if mm_cache is None:
-                continue
-            flat = mm_cache.view(-1, mm_cache.shape[-1])
-            flat.index_copy_(0, slots, src_cpu)
-
-    def add_prefix_cached_new_req_id(self, req_id: str):
-        """Adds a new request ID to the set of prefix cache hits on the batch."""
-        self._new_req_cache_hit_ids.add(req_id)
-
-    def reset_prefix_cached_new_req_ids(self):
-        """Clears the cache hit IDs to prepare for a new engine step."""
-        self._new_req_cache_hit_ids.clear()
-
-    def has_prefix_cached_new_req_ids(self) -> bool:
-        """Return True when this step contains a newly scheduled prefix hit."""
-        return bool(self._new_req_cache_hit_ids)
-
-    @staticmethod
-    def _coerce_to_cpu_tensor(maybe_gpu_tensor: torch.Tensor) -> torch.Tensor:
-        """Convert GPU tensors -> contiguous CPU tensors if needed."""
-        return maybe_gpu_tensor.detach().cpu().contiguous()
-
-    @staticmethod
-    def _resolve_hidden_states_cpu(
-        hidden_states: torch.Tensor,
-        num_tokens: int,
-        hidden_states_cpu: torch.Tensor | None,
-    ) -> torch.Tensor:
-        if hidden_states_cpu is None:
-            return OmniTensorPrefixCache._coerce_to_cpu_tensor(hidden_states[:num_tokens])
-        if hidden_states_cpu.device.type != "cpu":
-            raise RuntimeError("hidden_states_cpu must be a CPU tensor.")
-        if not hidden_states_cpu.is_contiguous():
-            raise RuntimeError("hidden_states_cpu must be contiguous.")
-        if hidden_states_cpu.dtype != hidden_states.dtype:
-            raise RuntimeError(
-                "hidden_states_cpu has an incompatible dtype: "
-                f"got {hidden_states_cpu.dtype}, expected {hidden_states.dtype}."
-            )
-        if hidden_states_cpu.shape[1:] != hidden_states.shape[1:]:
-            raise RuntimeError(
-                "hidden_states_cpu has an incompatible feature shape: "
-                f"got {tuple(hidden_states_cpu.shape[1:])}, expected {tuple(hidden_states.shape[1:])}."
-            )
-        if hidden_states_cpu.shape[0] < num_tokens:
-            raise RuntimeError(
-                "hidden_states_cpu does not cover the requested hidden states "
-                f"slice: got {hidden_states_cpu.shape[0]} tokens, need {num_tokens}."
-            )
-        return hidden_states_cpu[:num_tokens]
-
-    def update_omni_tensor_prefix_cache(
-        self,
-        hidden_states: torch.Tensor | None,
-        multimodal_outputs: dict[str, torch.Tensor] | None,
-        num_tokens_unpadded: int,
-        slot_mapping: torch.Tensor,
-        num_tokens_padded: int | None = None,
-        skip_mm_cache_keys: set[str] | None = None,
-        hidden_states_cpu: torch.Tensor | None = None,
-    ):
-        """Updates the hidden cache state for the provided hidden states and multimodal outputs.
-
-        Args:
-            hidden_states: Hidden states tensor to cache (if any)
-            multimodal_outputs: Multimodal dict whose tensors may be cached
-            num_tokens_unpadded: Number of tokens without padding
-            slot_mapping: Slot mapping for the input sequence
-            num_tokens_padded: Total number of tokens including padding
-            skip_mm_cache_keys: Multimodal keys whose CPU cache writes are deferred
-            hidden_states_cpu: Optional pre-staged CPU view of hidden_states.
-                When provided, it must be contiguous, live on CPU, match the
-                feature shape of hidden_states, and cover num_tokens_unpadded.
-        """
-        unpadded_slot_mapping = slot_mapping[:num_tokens_unpadded]
-        if num_tokens_padded is None:
-            num_tokens_padded = num_tokens_unpadded
-        skip_mm_cache_keys = skip_mm_cache_keys or set()
-
-        if hidden_states is not None:
-            # Slice to unpadded portion before caching
-            hidden_states = OmniTensorPrefixCache._resolve_hidden_states_cpu(
-                hidden_states,
-                num_tokens_unpadded,
-                hidden_states_cpu,
-            )
-            # View the cache as 2D so that we can treat our slots as row indices.
-            # ``index_copy_`` is the row-scatter primitive — it's semantically
-            # ``cache[idx] = src`` but dispatches to a faster CPU path than the
-            # generic advanced-indexing assignment (which goes through
-            # ``aten::index_put_`` and is dominated by per-row dispatch
-            # overhead on large feature widths).
-            flat_cache = self.hidden_states_cache.view(-1, self.hidden_states_cache.shape[-1])
-            slot_idx = unpadded_slot_mapping
-            if slot_idx.dtype != torch.int64:
-                slot_idx = slot_idx.to(torch.int64)
-            flat_cache.index_copy_(0, slot_idx, hidden_states)
-            logger.debug("Writing to hidden states for %s tokens", num_tokens_unpadded)
-
-        # Do the same for the stage's cached multimodal outputs
-        if multimodal_outputs is not None:
-            # If we haven't initialized the keys already, do it now
-            # We check against the padded token count since we haven't sliced yet
-            self.maybe_init_missing_mm_cache_keys(
-                multimodal_outputs,
-                seq_len=num_tokens_padded,
-            )
-
-            for mm_out_key, mm_cache in self.mm_outputs_cache.items():
-                if mm_out_key in multimodal_outputs:
-                    if mm_out_key in skip_mm_cache_keys:
-                        continue
-                    # Slice to unpadded portion before caching
-                    mm_state = multimodal_outputs[mm_out_key][:num_tokens_unpadded]
-                    mm_state = OmniTensorPrefixCache._coerce_to_cpu_tensor(mm_state)
-                    flat_cache = mm_cache.view(-1, mm_cache.shape[-1])
-                    slot_idx = unpadded_slot_mapping
-                    if slot_idx.dtype != torch.int64:
-                        slot_idx = slot_idx.to(torch.int64)
-                    flat_cache.index_copy_(0, slot_idx, mm_state)
-            logger.debug("Writing to mm output cache for %s tokens", num_tokens_unpadded)
-
-    def stage_deferred_mm_outputs(
-        self,
-        query_start_loc: torch.Tensor,
-        input_batch: InputBatch,
-        multimodal_outputs: dict[str, torch.Tensor] | None,
-        num_scheduled_tokens: dict[str, int],
-        deferred_mm_cache_keys: set[str],
-    ) -> None:
-        """Keep GPU multimodal chunks until a request finishes.
-
-        The normal prefix-cache write path copies every cached multimodal tensor
-        to CPU on every step.  For model outputs that are only needed by future
-        full-block prefix hits, we can keep detached GPU chunks and materialize
-        the CPU cache once when the request completes.
-        """
-        if not multimodal_outputs or not deferred_mm_cache_keys:
-            return
-
-        for mm_key in deferred_mm_cache_keys:
-            mm_state = multimodal_outputs.get(mm_key)
-            if not isinstance(mm_state, torch.Tensor) or mm_state.ndim < 2:
-                continue
-            for req_id in input_batch.req_ids:
-                req_idx = input_batch.req_id_to_index[req_id]
-                sched = int(num_scheduled_tokens.get(req_id, 0))
-                if sched <= 0:
-                    continue
-                start = int(query_start_loc[req_idx])
-                end = start + sched
-                if start >= int(mm_state.shape[0]):
-                    continue
-                end = min(end, int(mm_state.shape[0]))
-                if end <= start:
-                    continue
-
-                computed_end = int(input_batch.num_computed_tokens_cpu[req_idx])
-                token_start = max(0, computed_end - sched)
-                chunk = mm_state[start:end].detach()
-                self._deferred_mm_outputs.setdefault(req_id, {}).setdefault(mm_key, []).append((token_start, chunk))
-
-    def commit_deferred_mm_outputs(
-        self,
-        finished_req_ids: set[str] | list[str],
-        input_batch: InputBatch,
-    ) -> None:
-        """Write deferred multimodal chunks into the CPU prefix cache.
-
-        This must run before finished requests are removed from ``input_batch``,
-        because the block table is needed to map logical token positions to KV
-        cache slots.
-        """
-        if not finished_req_ids or not self._deferred_mm_outputs:
-            return
-
-        for req_id in tuple(finished_req_ids):
-            per_key = self._deferred_mm_outputs.pop(req_id, None)
-            if not per_key:
-                continue
-            req_idx = input_batch.req_id_to_index.get(req_id)
-            if req_idx is None:
-                continue
-            for mm_key, chunks in per_key.items():
-                self._commit_deferred_mm_key(req_idx, input_batch, mm_key, chunks)
-
-    def discard_deferred_mm_outputs(self, req_id: str) -> None:
-        """Drop deferred chunks for requests that leave without a cache commit."""
-        self._deferred_mm_outputs.pop(req_id, None)
-
-    def _commit_deferred_mm_key(
-        self,
-        req_idx: int,
-        input_batch: InputBatch,
-        mm_key: str,
-        chunks: list[tuple[int, torch.Tensor]],
-    ) -> None:
-        if not chunks:
-            return
-
-        chunks = sorted(chunks, key=lambda item: item[0])
-        first_start = chunks[0][0]
-        expected_start = first_start
-        tensors: list[torch.Tensor] = []
-        for token_start, tensor in chunks:
-            if tensor.numel() == 0:
-                continue
-            if token_start != expected_start:
-                if tensors:
-                    self._write_deferred_mm_tensor(req_idx, input_batch, mm_key, tensors, first_start)
-                first_start = token_start
-                expected_start = token_start
-                tensors = []
-            tensors.append(tensor)
-            expected_start += int(tensor.shape[0])
-
-        if tensors:
-            self._write_deferred_mm_tensor(req_idx, input_batch, mm_key, tensors, first_start)
-
-    def _write_deferred_mm_tensor(
-        self,
-        req_idx: int,
-        input_batch: InputBatch,
-        mm_key: str,
-        tensors: list[torch.Tensor],
-        token_start: int,
-    ) -> None:
-        mm_state = tensors[0] if len(tensors) == 1 else torch.cat(tensors, dim=0)
-        if mm_state.ndim < 2 or mm_state.shape[0] == 0:
-            return
-
-        if mm_key not in self.mm_cache_keys:
-            self.mm_outputs_cache[mm_key] = self._get_cache_tensor(
-                dtype=mm_state.dtype,
-                hidden_size=int(mm_state.shape[-1]),
-            )
-            self.mm_cache_keys.add(mm_key)
-            logger.info(
-                "Initializing deferred multimodal output cache of size %s for key: %s",
-                list(self.mm_outputs_cache[mm_key].shape),
-                mm_key,
-            )
-
-        slots = self._get_slot_ids_for_token_range(
-            req_idx=req_idx,
-            input_batch=input_batch,
-            token_start=token_start,
-            num_tokens=int(mm_state.shape[0]),
-        )
-        if slots.numel() == 0:
-            return
-
-        mm_state_cpu = OmniTensorPrefixCache._coerce_to_cpu_tensor(mm_state[: slots.numel()])
-        mm_cache = self.mm_outputs_cache[mm_key]
-        flat_cache = mm_cache.view(-1, mm_cache.shape[-1])
-        if slots.dtype != torch.int64:
-            slots = slots.to(torch.int64)
-        flat_cache.index_copy_(0, slots, mm_state_cpu)
-
-    def _get_slot_ids_for_token_range(
-        self,
-        req_idx: int,
-        input_batch: InputBatch,
-        token_start: int,
-        num_tokens: int,
-    ) -> torch.Tensor:
-        if num_tokens <= 0:
-            return torch.empty((0,), dtype=torch.long)
-
-        block_table = input_batch.block_table[0].block_table.cpu
-        token_positions = torch.arange(token_start, token_start + num_tokens, dtype=torch.long)
-        block_offsets = token_positions // self.block_size
-        max_blocks = int(block_table.shape[1])
-        valid = block_offsets < max_blocks
-        if not bool(valid.all()):
-            token_positions = token_positions[valid]
-            block_offsets = block_offsets[valid]
-        if token_positions.numel() == 0:
-            return torch.empty((0,), dtype=torch.long)
-
-        block_ids = block_table[req_idx, block_offsets].to(torch.long)
-        return block_ids * self.block_size + (token_positions % self.block_size)
-
-    def _coerce_to_payload_dict(
-        self,
-        element: object,
-        query_start_loc: torch.Tensor,
-        input_batch: InputBatch,
-        num_scheduled_tokens: dict[str, int],
-    ) -> dict[str, object]:
-        """Build the multimodal passthrough data per request for
-        the object under consideration. This mirrors the no-prefix-cache
-        path: a tensor whose first dimension matches the total scheduled
-        token count is sliced per request, so 1D (seq_len,) metadata that
-        is intentionally not cached (e.g. ref_code_len, codec_streaming)
-        is still split per request instead of leaking the whole batch.
-        """
-        total_scheduled_tokens = sum(int(num_scheduled_tokens[r]) for r in input_batch.req_ids)
-        elem_dict = {}
-        for req_id in input_batch.req_ids:
-            req_idx = input_batch.req_id_to_index[req_id]
-            start = query_start_loc[req_idx]
-            end = start + num_scheduled_tokens[req_id]
-            elem_dict[req_id] = to_payload_element(
-                element,
-                req_idx,
-                start=start,
-                end=end,
-                pass_lists_through=True,
-                seq_len=total_scheduled_tokens,
-            )
-        return elem_dict
-
-    def get_merged_multimodal_states(
-        self,
-        query_start_loc: torch.Tensor,
-        input_batch: InputBatch,
-        multimodal_outputs: dict | None,
-        num_scheduled_tokens: dict[str, int],
-    ):
-        """Get the merged multimodal states if hidden state prefix caching is enabled."""
-        combined_multimodal_outputs = {}
-        # Talkers that produce multimodal outputs only at decode (e.g. Higgs
-        # Audio v3's audio codes) have ``multimodal_outputs is None`` at the
-        # initial prefill step. Treat it as an empty mapping so the merger
-        # short-circuits cleanly and the cache merge still runs once codes
-        # start arriving.
-        mm_outputs = multimodal_outputs if multimodal_outputs is not None else {}
-        # First get the prefix cached tensors that are present in the mm data
-        for mm_key in self.mm_cache_keys:
-            if mm_key in mm_outputs:
-                combined_multimodal_outputs[mm_key] = self._get_merged_tensors(
-                    query_start_loc=query_start_loc,
-                    input_batch=input_batch,
-                    cache=self.mm_outputs_cache[mm_key],
-                    hidden_states=mm_outputs[mm_key],
-                    num_scheduled_tokens=num_scheduled_tokens,
-                )
-
-        # Then, get everything else (passthrough data); first, convert to CPU
-        # tensors similarly to the non prefix cached path, and then populate
-        # the subdicts mapping request IDs -> payload objects
-        passthrough_keys = set(mm_outputs.keys()) - self.mm_cache_keys
-        passthrough_mm_data = {k: v for k, v in mm_outputs.items() if k in passthrough_keys}
-        mm_cpu = build_mm_cpu(multimodal_outputs=passthrough_mm_data)
-
-        for mm_key, mm_val in mm_cpu.items():
-            combined_multimodal_outputs[mm_key] = self._coerce_to_payload_dict(
-                element=mm_val,
-                query_start_loc=query_start_loc,
-                input_batch=input_batch,
-                num_scheduled_tokens=num_scheduled_tokens,
-            )
-        return combined_multimodal_outputs
-
-    def get_merged_hidden_states(
-        self,
-        query_start_loc: torch.Tensor,
-        input_batch: InputBatch,
-        hidden_states: torch.Tensor,
-        num_scheduled_tokens: dict[str, int],
-        hidden_states_cpu: torch.Tensor | None = None,
-    ) -> dict[str, torch.Tensor]:
-        """Get merged hidden states, optionally reusing pre-staged CPU states.
-
-        When provided, hidden_states_cpu follows the same contract as
-        update_omni_tensor_prefix_cache: CPU, contiguous, same dtype and feature
-        shape as hidden_states, and covering every scheduled-token span derived
-        from query_start_loc and num_scheduled_tokens.
-        """
-        return self._get_merged_tensors(
-            query_start_loc=query_start_loc,
-            input_batch=input_batch,
-            hidden_states=hidden_states,
-            num_scheduled_tokens=num_scheduled_tokens,
-            staged_cpu_tensor=hidden_states_cpu,
-            cache=self.hidden_states_cache,
-        )
-
-    def _get_merged_tensors(
-        self,
-        query_start_loc: torch.Tensor,
-        input_batch: InputBatch,
-        cache: torch.Tensor,
-        hidden_states: torch.Tensor,
-        num_scheduled_tokens: dict[str, int],
-        staged_cpu_tensor: torch.Tensor | None = None,
-    ) -> dict[str, torch.Tensor]:
-        """When hidden state caching is enabled, takes the input hidden_states,
-        which only correspond to the scheduled tokens, and returns a mapping
-        from request IDs to their full hidden states. This is accomplished by
-        looking up the block IDs & scheduled token counts to split the
-        hidden_states. staged_cpu_tensor can supply the already materialized CPU
-        scheduled-token view; None preserves the legacy per-call CPU conversion.
-        """
-        # We do not support hybrid caches at the moment.
-        if len(input_batch.block_table.block_tables) > 1:
-            logger.warning_once(
-                "Omni prefix caching is enabled, but the batch block table appears to"
-                " have multiple kv groups; only the first group will be used!"
-            )
-
-        combined_hidden_states = {}
-        required_tokens = 0
-        for req_id in input_batch.req_ids:
-            req_idx = input_batch.req_id_to_index[req_id]
-            start = query_start_loc[req_idx]
-            end = start + num_scheduled_tokens[req_id]
-            required_tokens = max(required_tokens, int(end))
-        hidden_states = OmniTensorPrefixCache._resolve_hidden_states_cpu(
-            hidden_states,
-            required_tokens,
-            staged_cpu_tensor,
-        )
-        for req_id in input_batch.req_ids:
-            req_idx = input_batch.req_id_to_index[req_id]
-
-            if req_id in self._new_req_cache_hit_ids:
-                block_ids = self._get_cached_block_ids(req_idx, input_batch)
-                cached_hs = cache[block_ids].reshape(-1, cache.shape[-1])
-
-                # Slice the hidden states corresponding to this request;
-                # we do this by using the query start
-                start = query_start_loc[req_idx]
-                new_hs = hidden_states[start : start + num_scheduled_tokens[req_id]]
-                combined_hidden_states[req_id] = torch.cat([cached_hs, new_hs], dim=0)
-            else:
-                # cache miss for this request, pass through normally
-                start = query_start_loc[req_idx]
-                new_hs = hidden_states[start : start + num_scheduled_tokens[req_id]]
-                combined_hidden_states[req_id] = new_hs
-
-        return combined_hidden_states
-
-    def _get_cached_block_ids(self, req_idx: int, input_batch: InputBatch) -> torch.Tensor:
-        """Given an input batch and request index in the batch (not ID), get the
-        block IDs corresponding to the cache hit.
-        """
-        num_computed = input_batch.num_computed_tokens_cpu[req_idx]
-        # NOTE: vLLM only caches full blocks
-        num_cached_blocks = num_computed // self.block_size
-        # Get the block IDs attached to this cache hit and reindex into
-        # the flattened cached hidden states (i.e., 1 row per token).
-        return input_batch.block_table[0].block_table.cpu[req_idx, :num_cached_blocks]
diff --git a/vllm_omni/core/prefix_cache/__init__.py b/vllm_omni/core/prefix_cache/__init__.py
new file mode 100644
index 000000000..4d14da6fa
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/__init__.py
@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Omni prefix cache.
+
+Structure mirrors vllm/v1/core.
+
+Import invariant: this package must not import ``vllm`` at module
+scope (``TYPE_CHECKING`` and function-body imports are fine).
+``tests/core/test_prefix_cache.py`` loads these modules without a
+vllm install; a top-level ``from vllm...`` turns that suite red.
+
+That is also why these files use ``logging.getLogger`` instead of
+the repo-wide ``init_logger`` — ``init_logger`` comes from
+``vllm.logger``. The deviation is required, not an oversight.
+
+``_merge_uncached_mm`` is the exception at *call* time: it lazily
+imports ``vllm_omni.utils.mm_outputs``, which pulls in vllm. Import
+of this package still succeeds without vllm; materialize of leftover
+mm does not.
+"""
+
+from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+from vllm_omni.core.prefix_cache.controller import OmniPrefixCacheController
+from vllm_omni.core.prefix_cache.group_view import (
+    FullAttentionGroupView,
+    check_prefix_cache_kv_groups,
+    check_prefix_cache_kv_transfer,
+    get_prefix_cache_group_view,
+    stage_prefix_cache_config,
+)
+from vllm_omni.core.prefix_cache.interface import (
+    HIDDEN_KEY,
+    ModelCachePolicy,
+    OmniPrefixCacheStagingTimeoutError,
+    OmniPrefixCacheUnmatchError,
+    PrefixCacheConfig,
+    StageCacheOutputs,
+    WriteSchedule,
+)
+from vllm_omni.core.prefix_cache.manager import OmniPrefixCacheManager
+
+__all__ = [
+    "HIDDEN_KEY",
+    "FullAttentionGroupView",
+    "ModelCachePolicy",
+    "OmniPrefixCacheController",
+    "OmniPrefixCacheManager",
+    "OmniPrefixCacheStagingTimeoutError",
+    "OmniPrefixCacheUnmatchError",
+    "StageCacheOutputs",
+    "PrefixBlockPool",
+    "PrefixCacheConfig",
+    "WriteSchedule",
+    "check_prefix_cache_kv_groups",
+    "check_prefix_cache_kv_transfer",
+    "get_prefix_cache_group_view",
+    "stage_prefix_cache_config",
+]
diff --git a/vllm_omni/core/prefix_cache/block_pool.py b/vllm_omni/core/prefix_cache/block_pool.py
new file mode 100644
index 000000000..9cf34cb2d
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/block_pool.py
@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Pinned CPU block mirror (mirrors vLLM BlockPool)."""
+
+import logging
+
+import torch
+
+from vllm_omni.core.prefix_cache.interface import PrefixCacheConfig, TensorName
+
+logger = logging.getLogger(__name__)
+
+
+class PrefixBlockPool:
+    """Durable CPU mirror of vLLM KV slots, one tensor per name.
+
+    Storage is ``(num_blocks, block_size, feat)`` per key, viewed flat as
+    ``(num_slots, feat)`` so vLLM slot ids index rows directly. Write
+    access is single-writer (the controller committer thread); readers
+    take row views.
+
+    ``_caches`` is not an unbounded store and has no LRU. Dict keys are
+    tensor names (``__hidden_states__`` plus mm whose first dim is tokens),
+    opened once by ``ensure_key`` and never dropped — a model emits a
+    handful of those names, not a per-request set. Each value is a
+    fixed tensor sized to the same ``num_blocks`` as the upstream KV
+    pool. Rows *are* those kv slots: when vLLM recycles a block, the
+    next pool write overwrites that row. Slot reuse is the eviction.
+    """
+
+    def __init__(self, config: PrefixCacheConfig):
+        self._config = config
+        self._caches: dict[TensorName, torch.Tensor] = {}
+
+    def _alloc(self, dtype: torch.dtype, feat: int) -> torch.Tensor:
+        return torch.zeros(
+            (self._config.num_blocks, self._config.block_size, feat),
+            dtype=dtype,
+            device="cpu",
+            # Pinning lets device→host overlap compute; unsupported on
+            # CPU-only builds where that overlap is off anyway.
+            pin_memory=torch.cuda.is_available(),
+        )
+
+    def alloc_key(self, key: str, dtype: torch.dtype, feat: int) -> torch.Tensor | None:
+        """Allocate storage for a new ``key`` without publishing it (None if
+        already open). Pinned allocation is slow; run this unlocked and
+        hand the tensor to ``install_key`` under the manager's state lock."""
+        if key in self._caches:
+            return None
+        return self._alloc(dtype, feat)
+
+    def install_key(self, key: str, storage: torch.Tensor) -> None:
+        if key in self._caches:
+            return
+        self._caches[key] = storage
+        logger.info("prefix_cache: initialized mirror %s for key %s", list(storage.shape), key)
+
+    def ensure_key(self, key: str, dtype: torch.dtype, feat: int) -> None:
+        storage = self.alloc_key(key, dtype, feat)
+        if storage is not None:
+            self.install_key(key, storage)
+
+    def has_key(self, key: str) -> bool:
+        return key in self._caches
+
+    def keys(self) -> set[TensorName]:
+        return set(self._caches.keys())
+
+    def _flat(self, key: str) -> torch.Tensor:
+        cache = self._caches[key]
+        return cache.view(-1, cache.shape[-1])
+
+    def rows(self, key: str, slots: torch.Tensor) -> torch.Tensor:
+        """Gather rows for non-contiguous slots (returns a copy)."""
+        return self._flat(key).index_select(0, slots)
+
+    def write(self, key: str, slots: torch.Tensor, src_cpu: torch.Tensor) -> None:
+        """Write rows into the pool; caller (committer thread) is the single writer."""
+        if slots.dtype != torch.int64:
+            slots = slots.to(torch.int64)
+        # index_copy_ dispatches to a faster single-dim CPU path than
+        # advanced-indexing assignment (aten::index_put_).
+        self._flat(key).index_copy_(0, slots, src_cpu)
diff --git a/vllm_omni/core/prefix_cache/controller.py b/vllm_omni/core/prefix_cache/controller.py
new file mode 100644
index 000000000..4c26ac055
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/controller.py
@@ -0,0 +1,976 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Runs WriteTasks and the step device→host staging pool.
+
+The manager owns request/slot identity and when to submit. This class
+owns the staging pool, the GPU-byte budget, the copy queues, and the
+single committer that writes into the CPU block pool.
+
+Two device→host paths — the step path does not write `chunk.host` in
+the committer:
+
+    JOIN_NEXT_STEP   save already launched a whole-step device→host into
+                     a staging slot and set `chunk.host` as views.
+                     Committer waits that `step_d2h_event`, then writes
+                     the pool.
+    JOIN_ON_FINISH   committer copies the device clone → owned host
+                     tensors, then writes the pool.
+
+Async: high-priority then low-priority queues, then pool write.
+Eager: submit() does wait+write inline (CPU tests / no CUDA).
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Literal, NamedTuple
+
+import torch
+
+from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+from vllm_omni.core.prefix_cache.interface import (
+    OmniPrefixCacheStagingTimeoutError,
+    OmniPrefixCacheUnmatchError,
+    PrefixCacheConfig,
+    ReqId,
+    TensorName,
+    Tid,
+    WriteSchedule,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StagingBufferHolder(NamedTuple):
+    """One owner of a staging-buffer slot. The slot is free when none remain.
+
+    Not a buffer state — concurrent owners share the same slot:
+    - for_step: claimed at save, released when materialize/discard consumes the ctx
+    - for_task: bound before WriteTask submit, released when that task completes
+    """
+
+    kind: Literal["step", "task"]
+    owner_id: int
+
+    @classmethod
+    def for_step(cls, step_id: int) -> StagingBufferHolder:
+        return cls("step", step_id)
+
+    @classmethod
+    def for_task(cls, tid: int) -> StagingBufferHolder:
+        return cls("task", tid)
+
+
+@dataclass
+class _BudgetTicket:
+    """GPU-byte-budget charge for one device clone shared by several writes.
+
+    Charged once at ``reserve()``; freed when the last pinned tid releases.
+    Immediate: the whole-step clone, pinned by that step's JOIN_NEXT_STEP
+    tasks. Deferred: the shared deferred clone, pinned by every task a
+    chunk of it was appended to. Does not store tensors.
+    """
+
+    nbytes: int
+    tids: set[Tid] = field(default_factory=set)
+    _freed: bool = False
+
+    def release(self, tid: Tid) -> int:
+        """Drop `tid`; return the bytes to uncharge (nbytes once, when the
+        last holder leaves; 0 otherwise). Idempotent per tid."""
+        self.tids.discard(tid)
+        if self.tids or self._freed:
+            return 0
+        self._freed = True
+        return self.nbytes
+
+
+@dataclass
+class _WriteChunk:
+    """One save's slots + tensors appended onto a WriteTask.
+
+    Controller identity is the parent ``tid``, not a request. Deferred
+    writes grow by appending one chunk per save.
+    """
+
+    slots_cpu: torch.Tensor  # int64 flat row ids, in token order
+    tensors: dict[TensorName, torch.Tensor]  # freeze (device or eager CPU)
+    host: dict[TensorName, torch.Tensor] = field(default_factory=dict)  # host view of rows [0:n)
+    # GPU-byte charge of the clone these tensors view; shared across the
+    # chunks cut from one save. None for chunks with no device clone.
+    budget: _BudgetTicket | None = None
+
+
+class TaskState(Enum):
+    """WriteTask lifecycle: a strict chain, plus FAILED from any non-terminal.
+
+        PENDING -> QUEUED -> COPYING -> HOST_READY -> WRITTEN
+
+    PENDING     registered, not on a copy queue (deferred: waiting for
+                finish / budget pressure)
+    QUEUED      on a copy queue
+    COPYING     one thread owns the copy stage (staging: waits the step
+                device→host; deferred: copies the device clone)
+    HOST_READY  host rows ready (`host_ready` set); device clone dropped
+    WRITTEN     in the CPU pool (`done` set)
+    FAILED      committer could not finish (`host_ready` + `done` set;
+                manager raises from every later entry)
+
+    Moves only through `WriteTask.transition`; skipping a step is illegal.
+    """
+
+    PENDING = auto()
+    QUEUED = auto()
+    COPYING = auto()
+    HOST_READY = auto()
+    WRITTEN = auto()
+    FAILED = auto()
+
+    @property
+    def is_terminal(self) -> bool:
+        return self in (TaskState.WRITTEN, TaskState.FAILED)
+
+
+# The one legal forward move from each non-terminal state.
+_CHAIN: dict[TaskState, TaskState] = {
+    TaskState.PENDING: TaskState.QUEUED,
+    TaskState.QUEUED: TaskState.COPYING,
+    TaskState.COPYING: TaskState.HOST_READY,
+    TaskState.HOST_READY: TaskState.WRITTEN,
+}
+_NOT_YET_COPYING = frozenset({TaskState.PENDING, TaskState.QUEUED})
+
+
+def _is_legal_move(frm: TaskState, to: TaskState) -> bool:
+    return (to is TaskState.FAILED and not frm.is_terminal) or _CHAIN.get(frm) is to
+
+
+@dataclass
+class WriteTask:
+    """One write of (slot, key) rows for a single request.
+
+    Identity: `tid` is the handle in the manager's (slot, key) tables.
+    `req_id` + `write_n` mark whose write this is and the nth time that
+    request opened a write. One write may cover several keys.
+
+    `state` is the single source of truth for where the write is (see
+    `TaskState`). `host_ready` / `done` are wait primitives set by the
+    transitions into HOST_READY / WRITTEN / FAILED, never directly.
+
+    How HOST_READY is reached:
+    - JOIN_NEXT_STEP: `chunk.host` is a staging view set at save; the
+      copy stage only waits `step_d2h_event`.
+    - JOIN_ON_FINISH: the copy stage copies device→host into `chunk.host`.
+
+    `JOIN_NEXT_STEP` is queued at submit. `JOIN_ON_FINISH` stays
+    PENDING until finish or GPU-byte-budget pressure escalates it;
+    budget flush takes the unfinished task with the oldest `enqueued_time`.
+
+    Concurrent readers/writers:
+    - Staging readers (materialize clone, committer pool write) all wait
+      the same `step_d2h_event` before touching the view.
+    - A later task taking the same (slot, key) records those rows in
+      `reassigned`; the old pool write skips them.
+    - `append_chunk` is refused once the copy stage is claimed; the caller
+      opens a fresh task rather than mutating a closed one.
+    - `lock` covers `state` / `reassigned` / `append_chunk` / host↔freeze /
+      `slot_to_row`. `scatter_rows` snapshots `reassigned`.
+    """
+
+    tid: Tid
+    req_id: ReqId
+    write_n: int  # 1-based: nth write opened by this request
+    schedule: WriteSchedule
+    chunks: list[_WriteChunk]
+    # On-device clone finished on the compute stream. Copy/read streams
+    # must wait this before touching `chunks[].tensors`, or they can read
+    # the next CUDA-graph static-buffer overwrite.
+    freeze_event: torch.cuda.Event | None = None
+    state: TaskState = TaskState.PENDING
+    # Slots this write no longer owns (a newer write took them over).
+    reassigned: dict[TensorName, torch.Tensor] = field(default_factory=dict)
+    # Set on entering HOST_READY (or FAILED): this write's host rows are ready.
+    host_ready: threading.Event = field(default_factory=threading.Event)
+    # Set on entering WRITTEN (or FAILED): the CPU-pool write is over.
+    done: threading.Event = field(default_factory=threading.Event)
+    # Guards state / reassigned / append / host↔freeze.
+    lock: threading.Lock = field(default_factory=threading.Lock)
+    # time.monotonic() at submit; GPU-byte flush picks the oldest of these.
+    enqueued_time: float = field(default_factory=time.monotonic)
+    # Immediate path: this write's view into the shared step staging page.
+    staging_slot: int | None = None
+    # Immediate path: this step's CUDA device→host event (shared). None if deferred.
+    step_d2h_event: torch.cuda.Event | None = None
+    # slot -> (which chunk, row in that tensor). Built on demand
+    # when a write has more than one `_WriteChunk`; pool write uses slot, the tensor uses row.
+    _slot_to_row: dict[int, tuple[int, int]] | None = None
+
+    def add_reassigned(self, key: str, slots: torch.Tensor) -> None:
+        with self.lock:
+            prev = self.reassigned.get(key)
+            self.reassigned[key] = slots.clone() if prev is None else torch.cat([prev, slots])
+
+    def reassigned_intersects(self, chunk: _WriteChunk) -> bool:
+        """True if this write already lost ownership of any (key, slot) the
+        chunk would add; the caller opens a fresh WriteTask instead."""
+        with self.lock:
+            if not self.reassigned:
+                return False
+            for key in chunk.tensors:
+                taken = self.reassigned.get(key)
+                if taken is not None and taken.numel() and bool(torch.isin(chunk.slots_cpu, taken).any()):
+                    return True
+            return False
+
+    # ------------------------------------------------------------ lifecycle
+
+    def transition(self, to: TaskState) -> None:
+        """Move to `to`; raises unless it is the next chain step or FAILED."""
+        with self.lock:
+            self._transition_locked(to)
+
+    def try_transition(self, to: TaskState) -> bool:
+        """Move to `to` if legal from the current state. True if moved."""
+        with self.lock:
+            if not _is_legal_move(self.state, to):
+                return False
+            self._transition_locked(to)
+            return True
+
+    def _transition_locked(self, to: TaskState, wake: bool = True) -> None:
+        if not _is_legal_move(self.state, to):
+            raise OmniPrefixCacheUnmatchError(f"task {self.tid}: illegal transition {self.state.name} -> {to.name}")
+        self.state = to
+        if not wake:
+            return
+        if to is TaskState.HOST_READY:
+            self.host_ready.set()
+        elif to is TaskState.WRITTEN:
+            self.done.set()
+        elif to is TaskState.FAILED:
+            self.host_ready.set()
+            self.done.set()
+
+    def claim_copy(self) -> bool:
+        """QUEUED -> COPYING. Only one thread may run the copy stage; True if this caller won."""
+        return self.try_transition(TaskState.COPYING)
+
+    @property
+    def is_terminal(self) -> bool:
+        return self.state.is_terminal
+
+    def append_chunk(self, chunk: _WriteChunk, freeze_event: torch.cuda.Event | None = None) -> TaskState | None:
+        """Grow this write with one save's rows. Returns None when appended,
+        else the state that closed the task (COPYING or later).
+
+        `freeze_event` is stored in the same snapshot: events on one compute
+        stream are ordered, so the newest also covers every earlier clone.
+        """
+        with self.lock:
+            if self.state not in _NOT_YET_COPYING:
+                return self.state
+            self.chunks.append(chunk)
+            self._slot_to_row = None
+            if freeze_event is not None:
+                self.freeze_event = freeze_event
+            return None
+
+    def get_host_tensor(self, si: int, key: str) -> torch.Tensor | None:
+        """`chunks[si]` host if written, else device freeze. One snapshot."""
+        with self.lock:
+            chunk = self.chunks[si]
+            src = chunk.host.get(key)
+            if src is None:
+                src = chunk.tensors.get(key)
+            return src
+
+    def set_host_tensor(self, rows: list[tuple[_WriteChunk, str, torch.Tensor]]) -> None:
+        """COPYING -> HOST_READY: write these host tensors, drop the device freeze."""
+        with self.lock:
+            for chunk, key, tensor in rows:
+                chunk.host[key] = tensor
+            self._clear_tensors()
+            self._transition_locked(TaskState.HOST_READY)
+
+    def mark_host_ready(self) -> None:
+        """COPYING -> HOST_READY for staging views: wait the step device→host, drop freeze."""
+        if self.step_d2h_event is not None:
+            self.step_d2h_event.synchronize()
+        with self.lock:
+            self._clear_tensors()
+            self._transition_locked(TaskState.HOST_READY)
+
+    def mark_failed(self, *, defer_wake: bool = False) -> bool:
+        """-> FAILED from any non-terminal state; unblocks joiners. False if
+        already terminal. ``defer_wake``: the caller publishes the failure
+        record first, then calls ``wake_failed_waiters``."""
+        with self.lock:
+            if self.state.is_terminal:
+                return False
+            self._clear_tensors()
+            self._transition_locked(TaskState.FAILED, wake=not defer_wake)
+            return True
+
+    def wake_failed_waiters(self) -> None:
+        """Set the events after the failure record is published (see
+        ``mark_failed(defer_wake=True)``): a woken joiner must find it."""
+        self.host_ready.set()
+        self.done.set()
+
+    def mark_done(self) -> None:
+        """HOST_READY -> WRITTEN."""
+        self.transition(TaskState.WRITTEN)
+
+    def scatter_rows(self) -> list[tuple[TensorName, torch.Tensor, torch.Tensor]]:
+        """`(key, slots, host)` to write, one entry per key. Omits slots in
+        `reassigned`. A slot written twice by this task (preempt + resume
+        onto the same block) keeps the later chunk's row.
+        """
+        with self.lock:
+            reassigned = {k: s.clone() for k, s in self.reassigned.items()}
+        by_key: dict[TensorName, tuple[list[torch.Tensor], list[torch.Tensor]]] = {}
+        for chunk in self.chunks:
+            for k, host in chunk.host.items():
+                s, h = by_key.setdefault(k, ([], []))
+                s.append(chunk.slots_cpu)
+                h.append(host)
+        out: list[tuple[TensorName, torch.Tensor, torch.Tensor]] = []
+        for k, (s, h) in by_key.items():
+            slots = s[0] if len(s) == 1 else torch.cat(s)
+            host = h[0] if len(h) == 1 else torch.cat(h, dim=0)
+            if len(s) > 1 and torch.unique(slots).numel() != slots.numel():
+                last_pos = {int(slot): i for i, slot in enumerate(slots.tolist())}
+                keep_idx = torch.tensor(sorted(last_pos.values()), dtype=torch.int64)
+                slots, host = slots[keep_idx], host[keep_idx]
+            taken = reassigned.get(k)
+            if taken is not None and taken.numel():
+                keep = ~torch.isin(slots, taken)
+                if not bool(keep.any()):
+                    continue
+                slots, host = slots[keep], host[keep]
+            out.append((k, slots, host))
+        return out
+
+    def clear_tensors(self) -> None:
+        """Drop the device freeze. Host is unchanged (staging wait / fail)."""
+        with self.lock:
+            self._clear_tensors()
+
+    def _clear_tensors(self) -> None:
+        for chunk in self.chunks:
+            chunk.tensors = {}
+
+    def budget_tickets(self) -> list[_BudgetTicket]:
+        """Distinct tickets across this task's chunks (by identity; one per save)."""
+        out: dict[int, _BudgetTicket] = {}
+        for chunk in self.chunks:
+            if chunk.budget is not None:
+                out.setdefault(id(chunk.budget), chunk.budget)
+        return list(out.values())
+
+    def slot_to_row(self) -> dict[int, tuple[int, int]]:
+        with self.lock:
+            if self._slot_to_row is None:
+                m: dict[int, tuple[int, int]] = {}
+                for si, chunk in enumerate(self.chunks):
+                    for ri, slot in enumerate(chunk.slots_cpu.tolist()):
+                        m[slot] = (si, ri)
+                self._slot_to_row = m
+            return self._slot_to_row
+
+
+class StagingBufferPool:
+    """Reusable pinned landing zone for ONE whole-step device→host at save.
+
+    Per-task `chunk.host` is a row-range view into a slot, so the committer
+    skips a per-task device→host. Slots recycle; this is not the CPU block pool.
+
+    A slot stays busy while anyone still holds it: the step (until
+    materialize/discard) and each immediate write that views the page
+    (until its pool write). Prefix hits do not hold a slot —
+    they wait for the pool write and read the durable pool.
+
+    Saves with only leftover mm still claim a slot (empty views) so
+    every step id shares this bound. A full pool waits; timeout then errors.
+    """
+
+    def __init__(self, depth: int, capacity: int):
+        self.depth = depth
+        self.capacity = capacity  # rows per slot; a larger step raises
+        self._bufs: dict[TensorName, torch.Tensor] = {}  # [depth*capacity, width]
+        self._busy: list[set[StagingBufferHolder]] = [set() for _ in range(depth)]
+        self._slot_free_condition = threading.Condition()
+        self._closed = False
+
+    def _buf(self, key: str, width: int, dtype: torch.dtype, pin: bool) -> torch.Tensor:
+        buf = self._bufs.get(key)
+        if buf is None or buf.shape[-1] != width or buf.dtype != dtype:
+            buf = torch.empty((self.depth * self.capacity, width), dtype=dtype, pin_memory=pin)
+            self._bufs[key] = buf
+        return buf
+
+    def claim(self, holder: StagingBufferHolder, timeout: float) -> int:
+        """Grab a free slot for `holder`. Waits until one is free, then
+        times out. ``timeout<=0`` fails immediately if none are free.
+        """
+        deadline = time.monotonic() + max(0.0, timeout)
+        with self._slot_free_condition:
+            while True:
+                if self._closed:
+                    raise OmniPrefixCacheUnmatchError("staging pool shut down while waiting for a slot")
+                for slot in range(self.depth):
+                    if not self._busy[slot]:
+                        self._busy[slot].add(holder)
+                        return slot
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise OmniPrefixCacheStagingTimeoutError(f"timed out waiting for a staging slot after {timeout}s")
+                self._slot_free_condition.wait(timeout=remaining)
+
+    def bind(self, slot: int, holder: StagingBufferHolder) -> None:
+        with self._slot_free_condition:
+            self._busy[slot].add(holder)
+
+    def release(self, slot: int, holder: StagingBufferHolder) -> None:
+        with self._slot_free_condition:
+            self._busy[slot].discard(holder)
+            if not self._busy[slot]:
+                self._slot_free_condition.notify()
+
+    def close(self) -> None:
+        with self._slot_free_condition:
+            self._closed = True
+            self._slot_free_condition.notify_all()
+
+    def views(self, slot: int, key: str, n: int, width: int, dtype: torch.dtype, pin: bool) -> torch.Tensor:
+        base = slot * self.capacity
+        return self._buf(key, width, dtype, pin)[base : base + n]
+
+
+@dataclass
+class StepD2HClaim:
+    """One whole-step landing in StagingBufferPool.
+
+    Return of ``stage_step_host``. The manager stores this on
+    ``_StepContext`` until materialize/discard releases the step holder.
+    """
+
+    staging_slot: int  # StagingBufferPool index
+    views: dict[TensorName, torch.Tensor]  # host rows [0:n)
+    event: torch.cuda.Event | None = None  # torch.cuda.Event; None on eager/CPU
+
+
+class OmniPrefixCacheController:
+    """Staging pool + committer. Step device→host is launched at save;
+    this thread waits that event (JOIN_NEXT_STEP) or copies deferred
+    rows (JOIN_ON_FINISH), then writes into the CPU pool.
+    """
+
+    def __init__(self, pool: PrefixBlockPool, config: PrefixCacheConfig, eager: bool | None = None):
+        self._pool = pool
+        self._config = config
+        self._eager = (not torch.cuda.is_available()) if eager is None else eager
+        self._tasks: dict[Tid, WriteTask] = {}
+        self._completed: deque[Tid] = deque()  # pool write done, awaiting manager drain
+        self._failed: deque[Tid] = deque()  # write failed; manager raises from every later entry (sticky)
+        self._staged_bytes = 0
+        self._lock = threading.Lock()
+        self._wake = threading.Condition(self._lock)
+        self._queue_hi: deque[Tid] = deque()  # JOIN_NEXT_STEP + forced JOIN_ON_FINISH
+        self._queue_lo: deque[Tid] = deque()  # JOIN_ON_FINISH waiting for finish/budget
+        self._blocked: list[Tid] = []  # host copy done, awaiting pool write
+        self._shutdown = False
+        self._copy_stream: torch.cuda.Stream | None = None
+        self._read_stream: torch.cuda.Stream | None = None
+        self._worker: threading.Thread | None = None
+        self._staging_pool = StagingBufferPool(config.staging_depth, config.staging_capacity_tokens)
+        if not self._eager:
+            self._copy_stream = torch.cuda.Stream()
+            self._read_stream = torch.cuda.Stream()
+            self._worker = threading.Thread(target=self._worker_loop, name="omni-prefix-cache-committer", daemon=True)
+            self._worker.start()
+
+    # --------------------------------------------------------- step device→host staging
+
+    def _d2h_on_stream(
+        self,
+        stream: torch.cuda.Stream,
+        freeze_event: torch.cuda.Event | None,
+        copy: Callable[[], None],
+    ) -> torch.cuda.Event:
+        """Issue device→host on `stream` after freeze; return the done event."""
+        with torch.cuda.stream(stream):
+            if freeze_event is not None:
+                stream.wait_event(freeze_event)
+            copy()
+            ev = torch.cuda.Event()
+            ev.record()
+        return ev
+
+    def stage_step_host(
+        self,
+        tensors: dict[str, torch.Tensor],
+        n: int,
+        freeze_event: torch.cuda.Event | None,
+        step_holder: StagingBufferHolder,
+    ) -> StepD2HClaim:
+        """Claim a staging slot and, when `tensors` is non-empty, launch
+        ONE whole-step device→host into it.
+
+        Leftover-only saves pass empty `tensors` and still take a slot
+        (empty views) so every step id shares this bound. A full pool
+        waits for materialize/discard; timeout then errors. A step
+        larger than the page overflows the next slot — that is a config
+        break. The caller binds tasks after submit; `step_holder` is
+        released by materialize/discard via staging_release.
+        """
+        if tensors and n > self._staging_pool.capacity:
+            raise OmniPrefixCacheUnmatchError(
+                f"step has {n} tokens; staging capacity is {self._staging_pool.capacity} "
+                "(size staging_capacity_tokens to max_num_batched_tokens)"
+            )
+        slot = self._staging_pool.claim(step_holder, self._config.staging_claim_timeout_s)
+        try:
+            pin = not self._eager
+            views: dict[str, torch.Tensor] = {}
+            event: torch.cuda.Event | None = None
+            if self._eager or all(t.device.type == "cpu" for t in tensors.values()):
+                for key, src in tensors.items():
+                    v = self._staging_pool.views(slot, key, n, int(src.shape[-1]), src.dtype, pin)
+                    v.copy_(src)
+                    views[key] = v
+            else:
+
+                def _copy_to_staging() -> None:
+                    for key, src in tensors.items():
+                        v = self._staging_pool.views(slot, key, n, int(src.shape[-1]), src.dtype, pin)
+                        v.copy_(src, non_blocking=True)
+                        views[key] = v
+
+                event = self._d2h_on_stream(self._copy_stream, freeze_event, _copy_to_staging)
+            return StepD2HClaim(staging_slot=slot, views=views, event=event)
+        except Exception:
+            self._staging_pool.release(slot, step_holder)
+            raise
+
+    def staging_bind(self, slot: int, holder: StagingBufferHolder) -> None:
+        self._staging_pool.bind(slot, holder)
+
+    def staging_release(self, slot: int, holder: StagingBufferHolder) -> None:
+        self._staging_pool.release(slot, holder)
+
+    def _release_task_slot(self, task: WriteTask) -> None:
+        """Drop the task's staging hold at a terminal state (pool write or failure)."""
+        if task.staging_slot is not None:
+            self._staging_pool.release(task.staging_slot, StagingBufferHolder.for_task(task.tid))
+
+    def in_flight_tasks(self) -> int:
+        """Registered tasks not yet drained (diagnostics only)."""
+        return len(self._tasks)
+
+    # ------------------------------------------------------------------ submit
+
+    def register(self, task: WriteTask, queued: bool = True) -> None:
+        """Make a task visible (registry + QUEUED) without running anything;
+        safe under the manager's state lock. queued=False (deferred tasks)
+        stays PENDING on the GPU clone until finish/abort or the GPU-byte
+        budget forces a copy. Queued tasks must then go through
+        ``dispatch``.
+
+        Caller must reserve() the task bytes first (budget flush can
+        block; the manager does that outside the state lock) and pin the
+        task on its budget ticket(s) before register.
+        """
+        task.enqueued_time = time.monotonic()
+        with self._lock:
+            self._tasks[task.tid] = task
+            if queued:
+                task.transition(TaskState.QUEUED)
+
+    def dispatch(self, tasks: list[WriteTask]) -> None:
+        """Hand registered, queued tasks to the copy path. Threaded: enqueue.
+        Eager: the copy + pool write run here, inline — never call this
+        under the manager's state lock."""
+        if not tasks:
+            return
+        if self._eager:
+            try:
+                for task in tasks:
+                    self._run_eager(task)
+            except Exception:
+                # Later tasks were registered but will never be dispatched.
+                # Fail them too so shared budget owners and waiters release.
+                for task in tasks:
+                    self._fail_task(task.tid)
+                raise
+            return
+        with self._wake:
+            for task in tasks:
+                (self._queue_hi if task.schedule is WriteSchedule.JOIN_NEXT_STEP else self._queue_lo).append(task.tid)
+            self._wake.notify_all()
+
+    def submit(self, task: WriteTask, queued: bool = True) -> None:
+        """register + dispatch in one call (callers not holding the state lock)."""
+        self.register(task, queued)
+        if queued:
+            self.dispatch([task])
+
+    def append_chunk(
+        self, task: WriteTask, chunk: _WriteChunk, freeze_event: torch.cuda.Event | None = None
+    ) -> TaskState | None:
+        """Append to a pending task. None when appended, else the closing state."""
+        return task.append_chunk(chunk, freeze_event)
+
+    def pin_budget(self, ticket: _BudgetTicket, tid: int) -> None:
+        """Record that ``tid`` holds a view of the clone ``ticket`` charges."""
+        with self._lock:
+            ticket.tids.add(tid)
+
+    def reserve(self, nbytes: int) -> None:
+        """Reserve GPU-clone bytes; blocking flush happens here, so callers
+        must not hold the manager's state lock."""
+        self._reserve_bytes(nbytes)
+
+    def _release_staged_bytes(self, task: WriteTask) -> None:
+        """Drop this task's hold on its budget ticket(s). Idempotent; a
+        ticket uncharges once, when its last holder leaves."""
+        tickets = task.budget_tickets()
+        with self._wake:
+            for ticket in tickets:
+                self._staged_bytes -= ticket.release(task.tid)
+
+    def _reserve_bytes(self, nbytes: int) -> None:
+        # GPU-byte budget: force-copy oldest pending tasks until under
+        # budget. Bounded wait: their device→host has usually long completed.
+        while True:
+            with self._lock:
+                pending = [tid for tid, t in self._tasks.items() if not t.is_terminal]
+                if self._staged_bytes + nbytes <= self._config.gpu_staging_bytes or not pending:
+                    # Under budget or no pending tasks; admit reservation.
+                    self._staged_bytes += nbytes
+                    return
+                oldest = min(pending, key=lambda tid: self._tasks[tid].enqueued_time)
+            logger.warning("omni prefix cache: staging cap hit, force-flushing task %d", oldest)
+            self.escalate([oldest])
+            self.join([oldest])
+
+    # ------------------------------------------------------------- lifecycle
+
+    def escalate(self, tids: list[int]) -> None:
+        """Move pending tasks to the front of the high-priority queue.
+
+        PENDING -> QUEUED at the head; QUEUED on the low-priority queue
+        moves up; QUEUED already high-priority is a no-op. COPYING and later
+        belong to the worker and are untouched: the worker claims under
+        `_wake` too, so a task cannot be popped and re-queued behind its back.
+        """
+        if self._eager:
+            self.dispatch([task for tid in tids if (task := self._tasks.get(tid)) is not None and not task.is_terminal])
+            return
+        with self._wake:
+            for tid in tids:
+                task = self._tasks.get(tid)
+                if task is None:
+                    continue
+                if task.try_transition(TaskState.QUEUED):
+                    self._queue_hi.appendleft(tid)
+                elif task.state is TaskState.QUEUED and tid in self._queue_lo:
+                    self._queue_lo.remove(tid)
+                    self._queue_hi.appendleft(tid)
+            self._wake.notify_all()
+
+    def join(self, tids: list[int]) -> None:
+        """Block until each task has finished the CPU-pool write (or failed)."""
+        self._wait_tasks(tids, "done")
+
+    def join_host_ready(self, tids: list[int]) -> None:
+        """Block until each task's device→host is complete (`host_ready`).
+
+        Staging: committer has waited `step_d2h_event`. Deferred: committer
+        has written `chunk.host`. Does not wait for the CPU-pool write.
+        """
+        self._wait_tasks(tids, "host_ready")
+
+    def _wait_tasks(self, tids: list[int], event: Literal["done", "host_ready"]) -> None:
+        timeout = self._config.staging_claim_timeout_s
+        deadline = time.monotonic() + timeout
+        for tid in tids:
+            task = self._tasks.get(tid)
+            if task is None:
+                continue
+            if not getattr(task, event).wait(max(0.0, deadline - time.monotonic())):
+                raise OmniPrefixCacheUnmatchError(
+                    f"task {tid} ({task.schedule.value}) did not reach {event} within {timeout:g}s "
+                    f"(state={task.state.name}, in_flight_tasks={len(self._tasks)})"
+                )
+            if task.state is TaskState.FAILED:
+                # FAILED sets both events; success here would read rows the
+                # write never produced. The one-shot failure record may have
+                # been drained by another thread — do not rely on it.
+                raise OmniPrefixCacheUnmatchError(f"task {tid} ({task.schedule.value}) write failed before {event}")
+
+    def drain_completed(self) -> list[int]:
+        """Pop pool-written tasks from `_completed` and drop them from `_tasks`.
+        Staging holders were already released at the pool write."""
+        out: list[int] = []
+        with self._lock:
+            while self._completed:
+                out.append(self._completed.popleft())
+            for tid in out:
+                self._tasks.pop(tid, None)
+        return out
+
+    def drain_failed(self) -> list[int]:
+        """Pop failed task ids from `_failed`. Does not drop `_tasks`."""
+        out: list[int] = []
+        with self._lock:
+            while self._failed:
+                out.append(self._failed.popleft())
+        return out
+
+    def get_task(self, tid: int) -> WriteTask | None:
+        return self._tasks.get(tid)
+
+    def shutdown(self) -> None:
+        self._staging_pool.close()
+        with self._wake:
+            self._shutdown = True
+            self._wake.notify_all()
+        if self._worker is not None:
+            self._worker.join(timeout=5.0)
+
+    # ------------------------------------------------------------ fetch_host
+
+    @torch.inference_mode()
+    def fetch_host(self, task: WriteTask, slots: torch.Tensor, key: str) -> torch.Tensor:
+        """Rows for `slots` of one not-yet-done JOIN_ON_FINISH task.
+
+        `_slot_ref` puts JOIN_NEXT_STEP tids in `join_tids` (wait then
+        pool). This path reads committer-written `chunk.host`, or the
+        device clone if that device→host has not landed.
+        """
+        if task.step_d2h_event is not None:
+            task.step_d2h_event.synchronize()
+        return self._rows_from(task, slots, key)
+
+    def _rows_from(self, task: WriteTask, slots: torch.Tensor, key: str) -> torch.Tensor:
+        """Map `slots` to rows across one or more `_WriteChunk`s; preserve caller order."""
+        s2r = task.slot_to_row()
+        idx = [s2r[int(s)] for s in slots.tolist()]
+        parts: list[torch.Tensor] = []
+        order: list[int] = []
+        pos = 0
+        rows_groups: dict[int, list[tuple[int, int]]] = {}
+        for si, ri in idx:
+            rows_groups.setdefault(si, []).append((pos, ri))
+            pos += 1
+        for si, items in rows_groups.items():
+            src = task.get_host_tensor(si, key)
+            if src is None:
+                continue
+            rows_idx = torch.tensor([ri for _, ri in items], dtype=torch.long)
+            picked = self._slice_rows(task, src, rows_idx, host=(src.device.type == "cpu"))
+            parts.append(picked)
+            order.extend(p for p, _ in items)
+        if not parts:
+            raise KeyError(f"key {key} not present in task {task.tid}")
+        cat = torch.cat(parts, dim=0)
+        out = torch.empty_like(cat)
+        out[torch.tensor(order, dtype=torch.long)] = cat
+        return out
+
+    def _slice_rows(self, task: WriteTask, src: torch.Tensor, rows_idx: torch.Tensor, host: bool) -> torch.Tensor:
+        n = int(rows_idx.numel())
+        # Ascending-run check without materializing an arange: endpoints plus
+        # a monotonic diff are enough, and the common case is one long run.
+        contiguous = (
+            n > 0 and int(rows_idx[-1]) - int(rows_idx[0]) == n - 1 and (n < 2 or bool((rows_idx.diff() == 1).all()))
+        )
+
+        def _pick() -> torch.Tensor:
+            return src[rows_idx[0] : rows_idx[0] + n] if contiguous else src.index_select(0, rows_idx)
+
+        if host or src.device.type == "cpu":
+            return _pick()
+        if self._read_stream is None:
+            return _pick().detach().cpu()
+        copied: list[torch.Tensor] = []
+
+        def _copy_to_cpu() -> None:
+            copied.append(_pick().to("cpu", non_blocking=True))
+
+        ev = self._d2h_on_stream(self._read_stream, task.freeze_event, _copy_to_cpu)
+        ev.synchronize()
+        return copied[0]
+
+    # ------------------------------------------------------------ eager mode
+
+    @torch.inference_mode()
+    def _run_eager(self, task: WriteTask) -> None:
+        """Eager stand-in for queue + worker: walk the whole chain inline."""
+        task.try_transition(TaskState.QUEUED)  # no-op if submit already queued it
+        if not task.claim_copy():
+            # Copy stage already ran (a held stub, or a prior escalate); finish the write.
+            if task.state is TaskState.HOST_READY:
+                self._scatter(task)
+            return
+        if task.schedule is WriteSchedule.JOIN_NEXT_STEP:
+            # Host is already a staging view (copied at save). Drop freeze.
+            # `step_d2h_event` is None on CPU; `mark_host_ready` skips wait.
+            task.mark_host_ready()
+        else:
+            # JOIN_ON_FINISH: no copy stream; freeze → owned host inline.
+            task.set_host_tensor(
+                [
+                    (chunk, k, t.detach().cpu() if t.device.type != "cpu" else t.clone())
+                    for chunk in task.chunks
+                    for k, t in chunk.tensors.items()
+                ]
+            )
+        self._release_staged_bytes(task)
+        self._scatter(task)
+
+    # ---------------------------------------------------------- worker loop
+
+    def _worker_loop(self) -> None:
+        # A dying committer would strand every join() forever, so the loop
+        # never propagates: it fails the offending task and keeps serving.
+        while True:
+            tid = None
+            try:
+                task: WriteTask | None = None
+                with self._wake:
+                    while not self._shutdown and not self._queue_hi and not self._queue_lo:
+                        if self._blocked:
+                            break
+                        # submit / escalate / shutdown all notify.
+                        self._wake.wait()
+                    if self._shutdown and not self._queue_hi and not self._queue_lo and not self._blocked:
+                        return
+                    if self._queue_hi:
+                        tid = self._queue_hi.popleft()
+                    elif self._queue_lo:
+                        tid = self._queue_lo.popleft()
+                    if tid is not None:
+                        task = self._tasks.get(tid)
+                        if task is not None:
+                            # Claim in the same critical section as the pop:
+                            # escalate holds `_wake` and sees COPYING.
+                            task.transition(TaskState.COPYING)
+                if task is not None:
+                    self._copy_task(task)
+                    with self._wake:
+                        assert task.tid not in self._blocked, f"task {task.tid} reached HOST_READY twice"
+                        self._blocked.append(task.tid)
+                self._scatter_host_ready()
+            except BaseException:
+                logger.exception("omni prefix cache committer failed on task %s; releasing waiters", tid)
+                self._fail_task(tid)
+
+    @torch.inference_mode()
+    def _copy_task(self, task: WriteTask) -> None:
+        """COPYING -> HOST_READY. Staging: wait the save-time device→host event.
+        Deferred: this is the device→host into owned `chunk.host` tensors.
+        """
+        if task.schedule is WriteSchedule.JOIN_NEXT_STEP:
+            # `chunk.host` is already a staging view; device→host ran at save.
+            # `mark_host_ready` waits `step_d2h_event` if one was recorded.
+            # No per-task copy. Pool write is `_scatter_host_ready`.
+            task.mark_host_ready()
+            self._release_staged_bytes(task)
+            return
+        # One device cat + one device→host per key, not one per chunk (a
+        # long request has one chunk per step).
+        chunk_bytes = self._config.copy_chunk_bytes
+        by_key: dict[str, list[_WriteChunk]] = {}
+        for chunk in task.chunks:
+            for k in chunk.tensors:
+                by_key.setdefault(k, []).append(chunk)
+        pending: list[tuple[str, list[_WriteChunk], list[torch.Tensor]]] = []
+        if self._copy_stream is None:
+            raise OmniPrefixCacheUnmatchError("deferred prefix cache copy requires a CUDA copy stream")
+        with torch.cuda.stream(self._copy_stream):
+            if task.freeze_event is not None:
+                self._copy_stream.wait_event(task.freeze_event)
+            for k, chunks in by_key.items():
+                srcs = [c.tensors[k] for c in chunks]
+                src = srcs[0] if len(srcs) == 1 else torch.cat(srcs, dim=0)
+                rows = int(src.shape[0])
+                row_bytes = max(1, src[:1].numel() * src.element_size())
+                step = max(1, rows if rows * row_bytes <= chunk_bytes else chunk_bytes // row_bytes)
+                parts = [src[s : s + step].to("cpu", non_blocking=True) for s in range(0, max(rows, 1), step)]
+                pending.append((k, chunks, parts))
+            ev = torch.cuda.Event()
+            ev.record()
+        ev.synchronize()
+        rows_out: list[tuple[_WriteChunk, str, torch.Tensor]] = []
+        for k, chunks, parts in pending:
+            host = parts[0] if len(parts) == 1 else torch.cat(parts, dim=0)
+            if len(chunks) == 1:
+                rows_out.append((chunks[0], k, host))
+                continue
+            for chunk, view in zip(chunks, torch.split(host, [int(c.tensors[k].shape[0]) for c in chunks], dim=0)):
+                rows_out.append((chunk, k, view))
+        task.set_host_tensor(rows_out)
+        self._release_staged_bytes(task)
+
+    def _fail_task(self, tid: int | None) -> None:
+        """-> FAILED: release waiters for a task the committer could not complete.
+
+        No-op once the task is terminal. Budget release is idempotent, so a
+        raise after a successful copy stage does not uncharge twice.
+        """
+        task = self._tasks.get(tid) if tid is not None else None
+        if task is None or not task.mark_failed(defer_wake=True):
+            return
+        self._release_staged_bytes(task)
+        with self._wake:
+            if tid in self._blocked:
+                self._blocked.remove(tid)
+        self._release_task_slot(task)
+        with self._lock:
+            # Publish the failure: rows behind already-published block hashes
+            # never landed, which the manager must raise on (hiding it would
+            # crash on every future hit that touches these slots).
+            self._failed.append(task.tid)
+        # Events last: a joiner woken by them must find the record on drain,
+        # not read never-written pool rows in a done-but-unpublished window.
+        task.wake_failed_waiters()
+
+    @torch.inference_mode()
+    def _scatter_host_ready(self) -> None:
+        """HOST_READY -> WRITTEN for every `_blocked` task that has reached HOST_READY."""
+        with self._wake:
+            ready = [tid for tid in self._blocked if (t := self._tasks.get(tid)) and t.state is TaskState.HOST_READY]
+            for tid in ready:
+                self._blocked.remove(tid)
+        for tid in ready:
+            task = self._tasks[tid]
+            try:
+                self._scatter(task)
+            except BaseException:
+                # Attribute the failure to THIS task: letting it propagate
+                # would fail whichever entry the worker loop happened to be
+                # copying, double-release its bytes, and strand this one's
+                # join() forever.
+                logger.exception("omni prefix cache scatter failed on task %s; releasing waiters", tid)
+                self._fail_task(tid)
+
+    @torch.inference_mode()
+    def _scatter(self, task: WriteTask) -> None:
+        for key, slots, host in task.scatter_rows():
+            self._pool.write(key, slots, host)
+        # `done` is set LAST: a join(done) waiter (the save barrier) must find
+        # the completion record on its next drain and the staging slot free —
+        # a done-but-undrained window would leave occupancy IN_TRANSIT and
+        # make the COW preserve skip the reused rows.
+        self._release_task_slot(task)
+        with self._lock:
+            self._completed.append(task.tid)
+        task.mark_done()
diff --git a/vllm_omni/core/prefix_cache/group_view.py b/vllm_omni/core/prefix_cache/group_view.py
new file mode 100644
index 000000000..c935f72b6
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/group_view.py
@@ -0,0 +1,208 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""KV-cache group access for the omni prefix cache.
+
+The sole path through which the prefix cache touches vLLM scheduler
+internals (block tables, slot mappings). Group-spec rejection happens
+at kv-cache init via ``check_prefix_cache_kv_groups``; the factory only
+returns None when the input batch has no block table.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from vllm_omni.core.prefix_cache.interface import OmniPrefixCacheUnmatchError, PrefixCacheConfig
+
+if TYPE_CHECKING:
+    from vllm.v1.worker.gpu_input_batch import InputBatch
+
+
+class FullAttentionGroupView:
+    """View over the first (full-attention) KV-cache group.
+
+    Step slots come from the CPU block table (`step_slots_cpu`), not the
+    device slot_mapping.
+    """
+
+    def __init__(self, input_batch: InputBatch, block_size: int):
+        self._input_batch = input_batch
+        self.block_size = block_size
+        check_prefix_cache_block_layout(input_batch.block_table[0], block_size)
+
+    def _block_table_cpu(self) -> torch.Tensor:
+        return self._input_batch.block_table[0].block_table.cpu
+
+    def batch_req_ids(self) -> list[str]:
+        return list(self._input_batch.req_ids)
+
+    def step_slots_cpu(self, req_ids: list[str], num_scheduled: dict[str, int]) -> torch.Tensor:
+        """This step's slot mapping, computed on CPU from the block table.
+
+        The device slot_mapping would need a stream sync to read back, which
+        stalls the whole forward; the CPU block table carries the same
+        information (positions are num_computed .. +num_scheduled per request).
+        """
+        block_table = self._block_table_cpu()
+        bs = self.block_size
+        max_blocks = int(block_table.shape[1])
+        computed = self._input_batch.num_computed_tokens_cpu
+        parts: list[torch.Tensor] = []
+        for req_id in req_ids:
+            n = int(num_scheduled.get(req_id, 0))
+            if n <= 0:
+                continue
+            req_idx = self._input_batch.req_id_to_index[req_id]
+            start = int(computed[req_idx])
+            pos = torch.arange(start, start + n, dtype=torch.long)
+            offs = pos // bs
+            if int(offs[-1]) >= max_blocks:
+                keep = offs < max_blocks
+                pos, offs = pos[keep], offs[keep]
+                if pos.numel() == 0:
+                    continue
+            parts.append(block_table[req_idx, offs].to(torch.long) * bs + (pos % bs))
+        return torch.cat(parts) if parts else torch.empty((0,), dtype=torch.long)
+
+
+def check_prefix_cache_block_layout(block_table: object, block_size: int) -> None:
+    """Reject block-table layouts ``step_slots_cpu`` cannot mirror.
+
+    The CPU slot math is ``table[req, pos // block_size] * block_size +
+    pos % block_size`` over allocator block ids. vLLM breaks that in two
+    cases: hybrid kernel blocks (the row holds ``blocks_per_kv_block``
+    kernel ids per allocator block, e.g. FlashInfer/FlashMLA with
+    ``--block-size 128``) and decode context parallel (tokens are striped
+    across ranks and hashed at ``block_size * dcp_world_size``).
+    """
+    if getattr(block_table, "use_hybrid_blocks", False) or int(getattr(block_table, "blocks_per_kv_block", 1)) != 1:
+        raise OmniPrefixCacheUnmatchError(
+            "omni prefix caching requires kernel_block_size == block_size; the attention backend "
+            f"splits each block into {getattr(block_table, 'blocks_per_kv_block', '?')} kernel blocks. "
+            "Pick a --block-size the backend supports natively or disable enable_prefix_caching"
+        )
+    if int(getattr(block_table, "dcp_world_size", 1)) != 1:
+        raise OmniPrefixCacheUnmatchError(
+            "omni prefix caching does not support decode context parallel "
+            f"(dcp_world_size={getattr(block_table, 'dcp_world_size', '?')}); disable enable_prefix_caching"
+        )
+    kv_bs = getattr(block_table, "kv_cache_block_size", block_size)
+    if int(kv_bs) != int(block_size):
+        raise OmniPrefixCacheUnmatchError(
+            f"omni prefix caching block_size {block_size} does not match the kv-cache block table ({kv_bs})"
+        )
+
+
+def check_prefix_cache_kv_groups(kv_cache_groups: object) -> None:
+    """Reject hybrid / multi-group models at kv-cache init, not first step.
+
+    Only needs ``kv_cache_config.kv_cache_groups``. ``FullAttentionSpec``
+    is imported here so ``tests/core`` can load this module without vllm.
+    """
+    groups = list(kv_cache_groups or ())
+    if len(groups) != 1:
+        raise OmniPrefixCacheUnmatchError(
+            "omni prefix caching requires a single full-attention kv-cache group; "
+            f"found {len(groups)}. disable enable_prefix_caching for this model"
+        )
+    from vllm.v1.kv_cache_interface import FullAttentionSpec
+
+    spec = getattr(groups[0], "kv_cache_spec", None)
+    if not isinstance(spec, FullAttentionSpec):
+        raise OmniPrefixCacheUnmatchError(
+            "omni prefix caching requires a single full-attention kv-cache group; "
+            f"found {type(spec).__name__}. disable enable_prefix_caching for this model"
+        )
+
+
+def check_prefix_cache_kv_transfer(kv_transfer_config: object) -> None:
+    """Reject kv_consumer / kv_both stages.
+
+    KV loaded from a producer also shows up as ``num_computed_tokens``; the
+    manager would read it as a local hit with no rows behind it.
+    """
+    if kv_transfer_config is not None and getattr(kv_transfer_config, "is_kv_consumer", False):
+        raise OmniPrefixCacheUnmatchError(
+            "omni prefix caching cannot tell locally cached tokens from KV received "
+            "through a KV connector; disable enable_prefix_caching on kv_consumer / "
+            "kv_both stages"
+        )
+
+
+def check_prefix_cache_token_accounting(cache_config: object, speculative_config: object) -> None:
+    """Reject configs where ``num_computed_tokens`` stops meaning "first
+    scheduled position, block aligned".
+
+    Speculative decoding: with async scheduling vLLM keeps
+    ``num_computed_tokens_cpu`` optimistic (all drafts accepted) during the
+    forward and corrects it after; ``step_slots_cpu`` would read the
+    uncorrected value and mirror rows at the wrong slots. Refused as a
+    whole until that path is verified. ``prefix_match_unit`` smaller than
+    the block enables sub-block hits, which the hit registry rejects as
+    unaligned on the first hit; refuse at init instead.
+    """
+    if speculative_config is not None:
+        raise OmniPrefixCacheUnmatchError(
+            "omni prefix caching is not supported together with speculative decoding; "
+            "disable enable_prefix_caching on this stage"
+        )
+    unit = getattr(cache_config, "prefix_match_unit", None)
+    block_size = getattr(cache_config, "block_size", None)
+    if unit is not None and block_size is not None and int(unit) != int(block_size):
+        raise OmniPrefixCacheUnmatchError(
+            f"omni prefix caching requires block-aligned hits; prefix_match_unit={unit} with block_size={block_size} "
+            "enables sub-block hits. Unset prefix_match_unit or disable enable_prefix_caching"
+        )
+
+
+def stage_prefix_cache_config(
+    *,
+    kv_cache_config: object,
+    cache_config: object,
+    kv_transfer_config: object,
+    scheduler_config: object,
+    model_config: object,
+    is_pooling_model: bool,
+    speculative_config: object = None,
+) -> PrefixCacheConfig | None:
+    """Runner-side gate shared by the GPU and NPU model runners.
+
+    Returns None when the stage does not run an omni prefix cache
+    (``enable_prefix_caching`` off, or a pooling stage that never saves).
+    Otherwise refuses kv_consumer / kv_both, speculative decoding,
+    sub-block matching and hybrid kv groups, then sizes the config from
+    the scheduler. One place so a platform runner cannot silently skip a
+    refusal the other one has.
+    """
+    if not getattr(cache_config, "enable_prefix_caching", False) or is_pooling_model:
+        return None
+    check_prefix_cache_kv_transfer(kv_transfer_config)
+    check_prefix_cache_token_accounting(cache_config, speculative_config)
+    check_prefix_cache_kv_groups(getattr(kv_cache_config, "kv_cache_groups", None))
+    return PrefixCacheConfig.from_vllm_config(
+        num_blocks=kv_cache_config.num_blocks,  # type: ignore[attr-defined]
+        block_size=cache_config.block_size,  # type: ignore[attr-defined]
+        scheduler_config=scheduler_config,
+        model_config=model_config,
+    )
+
+
+def get_prefix_cache_group_view(
+    input_batch: InputBatch,
+    block_size: int,
+    kv_cache_groups: object = None,
+) -> FullAttentionGroupView | None:
+    """Build the group view; None only if the batch has no block table.
+
+    Group spec is checked first (raises). Selection is by spec, not by
+    counting block tables: a hybrid model's group 0 is not necessarily
+    full attention, and a narrower per-group table would make
+    step_slots_cpu silently clamp.
+    """
+    check_prefix_cache_kv_groups(kv_cache_groups)
+    block_tables = getattr(input_batch.block_table, "block_tables", None)
+    if not block_tables:
+        return None
+    return FullAttentionGroupView(input_batch, block_size)
diff --git a/vllm_omni/core/prefix_cache/interface.py b/vllm_omni/core/prefix_cache/interface.py
new file mode 100644
index 000000000..274706f75
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/interface.py
@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Interface types for the omni prefix cache.
+
+Naming aligns with vLLM's v1/core KV-cache design.
+"""
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, NamedTuple, TypeAlias
+
+import torch
+
+# Four identities (still str/int at runtime, not interchangeable):
+#   TensorName  which cached tensor (hidden / mm), not a prefix hash
+#   ReqId       vLLM request id
+#   Tid         WriteTask handle
+#   StepId      save_outputs id; materialize or discard exactly once
+TensorName: TypeAlias = str
+ReqId: TypeAlias = str
+Tid: TypeAlias = int
+StepId: TypeAlias = int
+
+# Reserved pool key for hidden states (mm keys are flat dotted names).
+# Identity only — whether a model caches it lives on ModelCachePolicy.
+HIDDEN_KEY: TensorName = "__hidden_states__"
+
+
+def is_hidden_key(key: TensorName) -> bool:
+    return key == HIDDEN_KEY
+
+
+def without_hidden(keys: Iterable[TensorName]) -> set[TensorName]:
+    """Drop the reserved hidden identity; the rest are mm names."""
+    return {k for k in keys if k != HIDDEN_KEY}
+
+
+class WriteSchedule(Enum):
+    """Write scheduling policy for one WriteTask."""
+
+    # Immediately-cached keys: device→host launched at save into the
+    # staging pool; committer waits that event and writes the CPU pool.
+    # The next save waits done (a reused slot must be pool-complete).
+    JOIN_NEXT_STEP = "join_next_step"
+    # Deferred mm: stays on the GPU clone until finish/abort (GPU-byte
+    # budget may force a copy earlier). One WriteTask per request.
+    JOIN_ON_FINISH = "join_on_finish"
+
+
+@dataclass(frozen=True)
+class PrefixCacheConfig:
+    """Sizing and flow-control knobs (mirrors KVCacheConfig)."""
+
+    num_blocks: int
+    block_size: int
+    # GPU-clone byte budget for JOIN_ON_FINISH; exceeding it forces a copy.
+    gpu_staging_bytes: int = 512 * 1024 * 1024
+    # Device→host staging: circular slots, one whole step each (not per request).
+    # Host memory per key ≈ staging_depth * staging_capacity_tokens * width * dtype.
+    # Prefer from_vllm_config so staging_capacity_tokens tracks max_num_batched_tokens.
+    staging_depth: int = 4
+    staging_capacity_tokens: int = 1024
+    # How long save waits for a free staging slot, and join/join_host_ready
+    # for the committer; exceeding it raises.
+    staging_claim_timeout_s: float = 30.0
+    # Device→host chunk size for JOIN_ON_FINISH (copied a piece at a time).
+    copy_chunk_bytes: int = 16 * 1024 * 1024
+
+    @classmethod
+    def from_vllm_config(
+        cls,
+        *,
+        num_blocks: int,
+        block_size: int,
+        scheduler_config: Any = None,
+        model_config: Any = None,
+    ) -> "PrefixCacheConfig":
+        """Size device→host staging from the running scheduler.
+
+        A slot holds one *step* (the whole batch), not one request:
+        ``staging_capacity_tokens`` is ``max_num_batched_tokens`` (falls back
+        to ``max_model_len``); ``staging_depth`` is how many unconsumed
+        step ids may exist at once, not ``max_num_seqs``.
+
+        Pinned staging is allocated lazily per key at
+        ``depth * capacity_tokens * width * dtype``. There is no clamp: a
+        step larger than capacity raises. A 16k-token thinking batch at
+        hidden=2048 bf16 is ~256 MiB for hidden alone; each mm key adds
+        another pool tensor.
+
+        ``staging_depth`` is the dataclass default (4). There is no CLI or
+        deploy YAML knob — changing it is a code change. Every save that
+        issues a step id claims one slot, including saves with only leftover
+        mm. A full pool waits for materialize/discard;
+        ``staging_claim_timeout_s`` then errors.
+        """
+        batched = getattr(scheduler_config, "max_num_batched_tokens", None)
+        model_len = getattr(scheduler_config, "max_model_len", None)
+        if not model_len and model_config is not None:
+            model_len = getattr(model_config, "max_model_len", None)
+        try:
+            capacity = int(batched or model_len or 1024)
+        except (TypeError, ValueError):
+            capacity = 1024
+        return cls(
+            num_blocks=num_blocks,
+            block_size=block_size,
+            staging_capacity_tokens=max(1, capacity),
+        )
+
+
+class StageCacheOutputs(NamedTuple):
+    """Plain value object: per-request merged stage outputs."""
+
+    # req -> full-prompt hidden states (None when policy skips them)
+    hidden_states: dict[ReqId, torch.Tensor] | None
+    # tensor name -> req -> payload element
+    mm_outputs: dict[TensorName, dict[ReqId, Any]]
+
+
+class OmniPrefixCacheUnmatchError(RuntimeError):
+    """Contract, config, or KV-occupancy error that must raise.
+
+    Includes hit spans that resolve to absent slots (omni cache diverged
+    from vLLM KV), a step id consumed twice or never saved, a step larger
+    than the staging page, and a failed write. Do not pretend these
+    were a miss.
+    """
+
+
+class OmniPrefixCacheStagingTimeoutError(OmniPrefixCacheUnmatchError):
+    """Save waited for a free staging slot and timed out."""
+
+
+@dataclass(frozen=True)
+class ModelCachePolicy:
+    """Replaces getattr probing on models for cache behavior decisions.
+
+    Hidden's *name* is ``HIDDEN_KEY`` (shared identity). This object
+    answers whether this model caches it, and which mm keys are deferred.
+    """
+
+    needs_full_hidden_states: bool = True
+    # Mm whose first dim is this step's token count; stays on the GPU
+    # clone until finish/abort (JOIN_ON_FINISH). Also skipped by the
+    # immediate on-device clone / device→host path.
+    deferred_keys: frozenset[TensorName] = frozenset()
+
+    @property
+    def hidden_key(self) -> TensorName | None:
+        """Pool key for hidden, or None when this model opts out."""
+        return HIDDEN_KEY if self.needs_full_hidden_states else None
+
+    def get_hit_keys(self, keys: Iterable[TensorName]) -> list[TensorName]:
+        """Keys to plan/prefetch for a hit: hidden first (if cached), then mm."""
+        mm = sorted(without_hidden(keys))
+        return [HIDDEN_KEY, *mm] if self.needs_full_hidden_states else mm
+
+    def skip_immediate_mm(self, key: TensorName) -> bool:
+        """Immediate on-device clone must not take hidden or deferred keys from mm."""
+        return is_hidden_key(key) or key in self.deferred_keys
+
+    @classmethod
+    def from_model(cls, model: Any) -> "ModelCachePolicy":
+        """Shim over legacy per-model attributes (deprecation window)."""
+        deferred = frozenset(getattr(model, "deferred_prefix_cache_mm_keys", ()) or ())
+        return cls(
+            needs_full_hidden_states=bool(getattr(model, "requires_full_prefix_cached_hidden_states", True)),
+            deferred_keys=deferred,
+        )
diff --git a/vllm_omni/core/prefix_cache/manager.py b/vllm_omni/core/prefix_cache/manager.py
new file mode 100644
index 000000000..5294a25d4
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/manager.py
@@ -0,0 +1,1475 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Omni prefix cache, manager side.
+
+Owns slot occupancy, the request-task table, the hit/span registry,
+per-step snapshots, and the merge. The controller owns the staging
+pool, copy queues, and writing rows into the CPU block pool. The
+state lock covers those tables only — never a wait-for-copy, a
+GPU-byte-budget flush, or a memcpy.
+
+Helper docstrings mark ``_state_lock`` (non-reentrant):
+
+    Caller holds   already inside a critical section; do not acquire
+    Takes          acquires here (``@_locked`` or ``with``)
+
+Two host stores:
+
+    StagingBufferPool   reusable step-sized pages. save copies this
+                        step's immediately-cached keys (hidden +
+                        non-deferred mm) device→host into one page.
+                        Per-task `chunk.host` is a view into that page,
+                        not a second copy.
+    PrefixBlockPool     durable (kv_slot, key) prefix cache. The
+                        committer only writes into it.
+
+Two write paths (which keys, not how many tokens):
+
+    JOIN_NEXT_STEP      immediately-cached keys. Device→host is already
+                        in flight at submit; the committer waits
+                        `step_d2h_event` then copies host→pool. The next
+                        save waits `done`: reused slots must not leave a
+                        pending pool write behind.
+    JOIN_ON_FINISH      deferred mm. Stays on the device clone; the
+                        committer does that device→host, then writes the
+                        pool. Forced onto the high-priority queue on
+                        finish/abort or GPU-byte-budget pressure.
+
+Per real scheduler_output, engine-thread order:
+
+    new_step_starts   before _update_states drops finished requests
+                      (register hits, start prefix prefetch)
+    forward
+    save_outputs      clone off live buffers + launch staging copy;
+                      returns step id
+    materialize or discard_step   exactly one of the two, once
+
+materialize may run on the async output builder while the engine is
+already in the next step. Warmup/dummy runs are never fed.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from collections import deque
+from collections.abc import Iterable, Mapping
+from concurrent.futures import Future, ThreadPoolExecutor
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any, NamedTuple, NoReturn
+
+import torch
+
+from vllm_omni.core.prefix_cache.block_pool import PrefixBlockPool
+from vllm_omni.core.prefix_cache.controller import (
+    OmniPrefixCacheController,
+    StagingBufferHolder,
+    StepD2HClaim,
+    WriteTask,
+    _BudgetTicket,
+    _WriteChunk,
+)
+from vllm_omni.core.prefix_cache.interface import (
+    ModelCachePolicy,
+    OmniPrefixCacheStagingTimeoutError,
+    OmniPrefixCacheUnmatchError,
+    PrefixCacheConfig,
+    ReqId,
+    StageCacheOutputs,
+    StepId,
+    TensorName,
+    Tid,
+    WriteSchedule,
+    is_hidden_key,
+    without_hidden,
+)
+
+if TYPE_CHECKING:
+    from vllm.v1.core.sched.output import SchedulerOutput
+
+    from vllm_omni.core.prefix_cache.group_view import FullAttentionGroupView
+
+logger = logging.getLogger(__name__)
+
+
+class _Occupancy(IntEnum):
+    ABSENT = 0
+    IN_TRANSIT = 1
+    COMMITTED = 2
+
+
+def _is_step_token_tensor(val: Any, n: int, padded: int) -> bool:
+    """2D+ tensor whose first dim is this step's token count (``n`` or padded).
+
+    True means callers may take ``val[:n]``. Leftover tensors (``codes.ref``),
+    lists, and other shapes are False.
+    """
+    return isinstance(val, torch.Tensor) and val.ndim >= 2 and int(val.shape[0]) in (n, padded)
+
+
+def _raise_unreadable_hit(req_id: str, key: str, why: str) -> NoReturn:
+    raise OmniPrefixCacheUnmatchError(f"hit span for req {req_id} key={key} is not readable ({why})")
+
+
+def _snapshot_leftover_mm_cpu(
+    mm_outputs: dict[str, Any],
+    device_snapshot_keys: set[str],
+    num_tokens_unpadded: int,
+    num_tokens_padded: int | None = None,
+) -> tuple[dict[str, Any], torch.cuda.Event | None]:
+    """CPU copy of mm that did not land on the staging page.
+
+    Skip ``device_snapshot_keys`` (those already have a device→host page).
+    Copy the rest — deferred mm, lists, ``codes.ref`` — so materialize can
+    run after the next forward overwrites graph buffers. Slice ``[:n]``
+    only when ``shape[0] == n``; ``>= n`` would clip ``codes.ref``.
+
+    CUDA tensors land in pinned memory through a non-blocking copy on the
+    current stream: stream order keeps it ahead of the next forward, and
+    the engine thread does not wait for this forward to finish. The
+    returned event (None when nothing was on CUDA) must be synchronized
+    before the snapshot is read.
+    """
+    n = num_tokens_unpadded
+    padded = n if num_tokens_padded is None else int(num_tokens_padded)
+    on_cuda = False
+
+    def _copy(val: Any) -> Any:
+        nonlocal on_cuda
+        if isinstance(val, torch.Tensor):
+            t = val[:n] if _is_step_token_tensor(val, n, padded) and int(val.shape[0]) == n else val
+            t = t.detach()
+            if t.is_cuda:
+                host = torch.empty(t.shape, dtype=t.dtype, device="cpu", pin_memory=True)
+                host.copy_(t, non_blocking=True)
+                on_cuda = True
+                return host
+            # .cpu() copies other device tensors; CPU/pinned views still share storage.
+            copied = t.cpu() if t.device.type != "cpu" else t.clone()
+            return copied.contiguous()
+        if isinstance(val, Mapping):
+            return {k: _copy(v) for k, v in val.items()}
+        if isinstance(val, list):
+            return [_copy(v) for v in val]
+        if isinstance(val, tuple):
+            return tuple(_copy(v) for v in val)
+        return val
+
+    leftover = {
+        key: _copy(val) for key, val in mm_outputs.items() if key not in device_snapshot_keys and not is_hidden_key(key)
+    }
+    event = None
+    if on_cuda:
+        event = torch.cuda.Event()
+        event.record()
+    return leftover, event
+
+
+def _unpin_leftover(val: Any) -> Any:
+    """Clone pinned tensors out so the payload does not hold pinned pages."""
+    if isinstance(val, torch.Tensor):
+        return val.clone() if val.is_pinned() else val
+    if isinstance(val, Mapping):
+        return {k: _unpin_leftover(v) for k, v in val.items()}
+    if isinstance(val, list):
+        return [_unpin_leftover(v) for v in val]
+    if isinstance(val, tuple):
+        return tuple(_unpin_leftover(v) for v in val)
+    return val
+
+
+@dataclass
+class _StepOutputs:
+    """This step's outputs split by consumer.
+
+    A tensor whose first dim equals this step's token count (or the
+    CUDA-graph padded count) can be sliced ``[:n]`` into per-token rows.
+    ``codes.ref`` and lists are not that shape.
+
+    ``immediate``: those per-token rows copied device→host this step
+    (hidden + non-deferred mm). ``deferred_chunks``: per-token deferred
+    mm, packed per request for JOIN_ON_FINISH. ``leftover``: CPU replica
+    for this step's materialize of everything that did not get a staging
+    page.
+    A deferred per-token key is in both ``deferred_chunks`` (later cache
+    write) and ``leftover`` (this-step read) — two consumers, not a
+    duplicate store.
+
+    ``immediate_budget`` charges the immediate clones once; every
+    JOIN_NEXT_STEP task of the step pins it. Deferred chunks carry their
+    own shared ticket.
+    """
+
+    immediate: dict[str, torch.Tensor]
+    deferred_chunks: list[tuple[str, _WriteChunk]]
+    leftover: dict[str, Any]
+    # Completion of the leftover device→host copies; None when none ran on CUDA.
+    leftover_event: torch.cuda.Event | None = None
+    immediate_budget: _BudgetTicket | None = None
+    # Pool storage allocated (unlocked) for keys first seen this step;
+    # published into the pool / occupancy tables under the state lock.
+    new_key_storage: dict[str, torch.Tensor] = field(default_factory=dict)
+
+    @property
+    def deferred_budget(self) -> _BudgetTicket | None:
+        return self.deferred_chunks[0][1].budget if self.deferred_chunks else None
+
+    def freeze_targets(self) -> list[torch.Tensor]:
+        """Device clones the freeze event must cover."""
+        return list(self.immediate.values()) + [t for _, c in self.deferred_chunks for t in c.tensors.values()]
+
+    def budget_bytes(self) -> int:
+        return sum(t.nbytes for t in (self.immediate_budget, self.deferred_budget) if t is not None)
+
+
+def _locked(fn):
+    """Serialize public entry points: the async output builder calls
+    materialize() while the engine thread is in the next step."""
+
+    def wrapper(self, *args, **kwargs):
+        with self._state_lock:
+            return fn(self, *args, **kwargs)
+
+    wrapper.__name__ = fn.__name__
+    wrapper.__doc__ = fn.__doc__
+    return wrapper
+
+
+@dataclass
+class _SlotRef:
+    """Where one (req, key) span's slots live: planned under the lock, fetched outside it.
+
+    Schedule split, not a single read tier:
+    - JOIN_NEXT_STEP in-transit: ``join_tids``. Fetch waits ``done``,
+      drains, then reads the pool. Staging views are never sliced.
+    - JOIN_ON_FINISH in-transit: ``staged_list`` task refs. Fetch uses
+      ``fetch_host`` (device freeze / committer host).
+    - Already in the CPU pool: ``already_staged`` → pool.
+
+    A JOIN_NEXT_STEP task may disappear between plan and join (another
+    entry already published it into the pool); ``join`` no-ops and the
+    pool rows persist.
+    """
+
+    slots: torch.Tensor  # KV slot ids (PrefixBlockPool rows)
+    key: TensorName
+    req_id: ReqId
+    already_staged: bool  # this key is already in the CPU pool
+    staged_list: list[tuple[WriteTask, torch.Tensor]]  # JOIN_ON_FINISH only
+    join_tids: list[Tid] = field(default_factory=list)  # JOIN_NEXT_STEP in-transit
+    # Slot version snapshot at plan time, checked on fetch.
+    reserved_version: torch.Tensor | None = None
+    # Copy-on-write rescue: slot's committed rows for pending reads.
+    preserved: dict[int, torch.Tensor] = field(default_factory=dict)
+
+
+@dataclass(kw_only=True)
+class _StepContext:
+    """Save-time snapshot of one step; consumed exactly once.
+
+    Built on the engine thread in save_outputs so materialize (possibly on
+    the async builder) never reads the live batch. Host rows live on `d2h`
+    (empty views when this save only had leftover mm). materialize or
+    discard_step pops it and frees the staging slot. A later save waits
+    if all slots are still held.
+    """
+
+    # Packed layout in batch order: req -> [start, end) of this step's rows.
+    spans: dict[ReqId, tuple[int, int]]
+    num_tokens_unpadded: int = 0
+
+    # Hits snapshotted at new_step_starts. Prefetch fills [hit | empty tail]
+    # during forward; materialize writes the tail.
+    hits: dict[ReqId, tuple[int, list[int]]]  # (hit_upto, blocks)
+    hit_prefetch: dict[ReqId, dict[TensorName, Future]] = field(default_factory=dict)
+
+    # Key split frozen at save: recompute at materialize races ensure_key.
+    cached_keys: set[TensorName] = field(default_factory=set)
+    # Leftover mm copied to CPU at save (this-step deferred rows + mm
+    # that is not written to the pool).
+    mm_cpu_snapshot: dict[TensorName, Any] = field(default_factory=dict)
+    # Wait this before reading mm_cpu_snapshot (None when nothing was on CUDA).
+    mm_cpu_snapshot_event: torch.cuda.Event | None = None
+
+    # Staging slot for this step id (empty views when only leftover mm).
+    d2h: StepD2HClaim | None = None
+
+
+class _SlotStatus(NamedTuple):
+    """Occupancy row for one tensor name (views into the table, not copies)."""
+
+    state: torch.Tensor  # int8[num_slots]
+    tids: torch.Tensor  # Tid per kv slot; 0 = none
+    slot_version: torch.Tensor  # int64[num_slots]; bumped each time a new write claims the slot
+
+
+class _SlotStatusTable:
+    """Per (KV slot, tensor name): empty, being written, or already in the pool.
+
+    Hidden and a deferred mm field on the same slot are independent.
+    ``map_slots`` marks a write in progress; if another task still owns
+    the slot, the manager records those rows as no longer owned by it.
+    ``commit`` runs after the pool write: still-owned slots become
+    committed.
+    """
+
+    def __init__(self, num_slots: int) -> None:
+        self.num_slots = num_slots
+        self.state: dict[TensorName, torch.Tensor] = {}  # int8[num_slots]
+        self.tids: dict[TensorName, torch.Tensor] = {}  # Tid per kv slot; 0 = none
+        self.slot_versions: dict[TensorName, torch.Tensor] = {}  # int64[num_slots]; bumped on each new write claim
+        self.task_slots: dict[Tid, torch.Tensor] = {}  # kv slots
+        self.task_keys: dict[Tid, tuple[TensorName, ...]] = {}
+
+    def init_table(self, key: TensorName) -> None:
+        """Allocate occupancy tensors for ``key`` if they do not exist."""
+        if key in self.state:
+            return
+        self.state[key] = torch.zeros(self.num_slots, dtype=torch.int8)
+        self.tids[key] = torch.zeros(self.num_slots, dtype=torch.int64)
+        self.slot_versions[key] = torch.zeros(self.num_slots, dtype=torch.int64)
+
+    def get_slot_status(self, key: TensorName) -> _SlotStatus:
+        """Occupancy tensors for ``key``. ``init_table`` must have run."""
+        return _SlotStatus(state=self.state[key], tids=self.tids[key], slot_version=self.slot_versions[key])
+
+    def map_slots(
+        self, slots: torch.Tensor, tid: Tid, keys: Iterable[TensorName]
+    ) -> list[tuple[Tid, TensorName, torch.Tensor]]:
+        """Record ``tid`` on these (slot, key). Return in-transit rows
+        another write still owned (caller marks them skipped on it)."""
+        keys = tuple(keys)
+        stolen: list[tuple[Tid, TensorName, torch.Tensor]] = []
+        for key in keys:
+            status = self.get_slot_status(key)
+            cur = status.tids[slots]
+            stale = (status.state[slots] == _Occupancy.IN_TRANSIT) & (cur != tid) & (cur != 0)
+            if bool(stale.any()):
+                for old in {int(o) for o in cur[stale].tolist()}:
+                    stolen.append((old, key, slots[stale & (cur == old)]))
+            status.state[slots] = _Occupancy.IN_TRANSIT
+            status.tids[slots] = tid
+            # Bump the version so a reader that captured an older one detects
+            # this claim even after it later commits (COMMITTED, not IN_TRANSIT).
+            status.slot_version[slots] += 1
+        prev = self.task_slots.get(tid)
+        if prev is None:
+            self.task_slots[tid] = slots
+            self.task_keys[tid] = keys
+        else:
+            # Deferred tasks grow one `_WriteChunk` per step.
+            self.task_slots[tid] = torch.cat([prev, slots])
+            self.task_keys[tid] = tuple(dict.fromkeys(self.task_keys[tid] + keys))
+        return stolen
+
+    def commit(self, tids: Iterable[Tid]) -> None:
+        """Flip still-owned slots to COMMITTED and drop the reverse index."""
+        for tid in tids:
+            slots = self.task_slots.pop(tid, None)
+            keys = self.task_keys.pop(tid, ())
+            if slots is None:
+                continue
+            for key in keys:
+                status = self.get_slot_status(key)
+                still_ours = status.tids[slots] == tid
+                idx = slots[still_ours]
+                status.state[idx] = _Occupancy.COMMITTED
+                status.tids[idx] = 0
+
+
+class _RequestTaskTable:
+    """Per request: still live, which WriteTasks it opened, deferred task.
+
+    Also allocates ``tid`` and increments per-request ``write_n``.
+    Device→host copy and pool write stay on the controller.
+    """
+
+    def __init__(self) -> None:
+        self._next_tid: Tid = 1
+        self.write_n: dict[ReqId, int] = {}  # last write_n issued
+        self.tasks: dict[ReqId, set[Tid]] = {}
+        self.deferred: dict[ReqId, WriteTask] = {}
+        self.live_reqs: set[ReqId] = set()
+
+    def alloc_tid(self) -> Tid:
+        tid = self._next_tid
+        self._next_tid += 1
+        return tid
+
+    def increment_write_n(self, req_id: ReqId) -> int:
+        n = self.write_n.get(req_id, 0) + 1
+        self.write_n[req_id] = n
+        return n
+
+    def track(self, req_id: ReqId, tid: Tid) -> None:
+        self.tasks.setdefault(req_id, set()).add(tid)
+
+    def finish(self, req_id: ReqId) -> tuple[set[Tid], WriteTask | None]:
+        """Drop this request's rows. Returns owned tids + deferred task."""
+        self.live_reqs.discard(req_id)
+        self.write_n.pop(req_id, None)
+        tids = self.tasks.pop(req_id, set())
+        dtask = self.deferred.pop(req_id, None)
+        return tids, dtask
+
+    def drop_completed(self, tids: Iterable[Tid]) -> None:
+        done = set(tids)
+        if not done:
+            return
+        for req_tids in self.tasks.values():
+            req_tids -= done
+
+
+class OmniPrefixCacheManager:
+    def __init__(
+        self,
+        config: PrefixCacheConfig,
+        view: FullAttentionGroupView,
+        *,
+        eager: bool | None = None,
+    ):
+        self._config = config
+        self._view = view
+        self._pool = PrefixBlockPool(config)
+        self._controller = OmniPrefixCacheController(self._pool, config, eager=eager)
+        self._policy = ModelCachePolicy()
+        # Serializes engine vs async-builder public entries. Non-reentrant:
+        # those entries never call each other, and the lock must not cover
+        # a wait-for-copy, GPU-byte-budget flush, or device→host copy.
+        self._state_lock = threading.Lock()
+
+        self._slot_status = _SlotStatusTable(config.num_blocks * config.block_size)
+        # Hidden is known from the default policy; mm rows at init_table.
+        if (hk := self._policy.hidden_key) is not None:
+            self._slot_status.init_table(hk)
+        self._request_tasks = _RequestTaskTable()
+        # Join worklists — not occupancy, not the request-task table.
+        self._join_next_step_tids: list[Tid] = []
+        self._join_finished_tids: set[Tid] = set()  # escalated on finish/abort
+
+        # This step's hits (copied into _StepContext at save).
+        self._cur_num_scheduled: dict[ReqId, int] = {}
+        self._hit_spans: dict[ReqId, tuple[int, list[int]]] = {}  # (upto, blocks)
+        self._hit_prefetch: dict[ReqId, dict[TensorName, Future]] = {}
+
+        # Planned-but-unread slot refs. A write reusing their slots copies the
+        # old rows into ``_SlotRef.preserved`` before overwriting (COW). Guarded
+        # by ``_state_lock``; each ref is dropped when its fetch completes.
+        self._pending_reads: list[_SlotRef] = []
+        # Sticky fatal set on the first drained write failure; every later
+        # facade entry re-raises it (see _commit_drained_writes).
+        self._fatal_write_failure: str | None = None
+
+        # Prefix gather during forward (CPU work releases the GIL).
+        # One worker: complete in submit order; pop finished work from the head.
+        self._prefetch_pool = ThreadPoolExecutor(1, thread_name_prefix="omni-prefix-cache-prefetch")
+        self._prefetch_queue: deque[tuple[Future, _SlotRef]] = deque()
+
+        # One snapshot per step id; consume with materialize or discard_step.
+        self._next_step_id: StepId = 1
+        self._step_ctxs: dict[StepId, _StepContext] = {}
+
+    # ------------------------------------------------------ public entries
+
+    def register_policy(self, policy: ModelCachePolicy) -> None:
+        self._policy = policy
+        if (hk := policy.hidden_key) is not None:
+            self._slot_status.init_table(hk)
+
+    @torch.inference_mode()
+    def new_step_starts(self, scheduler_output: SchedulerOutput) -> None:
+        """Handle one scheduler_output.
+
+        Engine thread only; before _update_states removes finished
+        requests; exactly once per real step. Registers new-request prefix
+        hits (copying their block tables) and forces finished/aborted
+        requests' still-open writes onto the high-priority copy queue —
+        a block hash that entered the batch must land in the cache,
+        abort included. ``escalate`` (eager: the copy + pool write) runs
+        after ``_state_lock`` is released.
+        """
+        to_escalate: list[int] = []
+        with self._state_lock:
+            # 1. Publish writes the committer has already written into the pool.
+            self._commit_drained_writes()
+
+            # 2. Finished/aborted reqs: collect still-open writes. Abort too:
+            #    those block hashes are already in vLLM; dropping the write
+            #    would leave future hits ABSENT. The next save waits
+            #    join_host_ready. (Not leftover_mm — those are this-step reads.)
+            finished = getattr(scheduler_output, "finished_req_ids", None) or ()
+            for req_id in finished:
+                tids, dtask = self._request_tasks.finish(req_id)
+                if dtask is not None:
+                    tids.add(dtask.tid)
+                pending_tasks = [tid for tid in tids if self._controller.get_task(tid) is not None]
+                if pending_tasks:
+                    to_escalate.extend(pending_tasks)
+                    self._join_finished_tids.update(pending_tasks)
+
+            # 3. Copy this arrival's prefix-hit block ids. scheduled_new_reqs
+            #    is the only place they appear; after _update_states they sit
+            #    on the live request and grow as decode allocates more blocks.
+            #    materialize (async builder) must not reread that live table.
+            self._clear_hit_infos()
+            for new_req in getattr(scheduler_output, "scheduled_new_reqs", ()) or ():
+                req_id = new_req.req_id
+                if req_id in self._request_tasks.live_reqs:
+                    # Already live: async_chunk continuation, or a V2-runner
+                    # resume after preemption (V1 resumes via
+                    # scheduled_cached_reqs). Either way num_computed_tokens is
+                    # not mirrored as a hit span; see the design doc.
+                    continue
+                self._request_tasks.live_reqs.add(req_id)
+                num_computed = int(getattr(new_req, "num_computed_tokens", 0) or 0)
+                if num_computed > 0:
+                    # block_ids is per-kv-group; group 0 only.
+                    blocks = getattr(new_req, "block_ids", None)
+                    if blocks is not None and len(blocks) > 0 and not isinstance(blocks[0], int):
+                        blocks = blocks[0]
+                    if not blocks:
+                        # Fail at the cause: a hit we cannot snapshot now would
+                        # crash at materialize time with less context (materialize is
+                        # forbidden from reading the live batch).
+                        raise OmniPrefixCacheUnmatchError(
+                            f"prefix hit for req {req_id} ({num_computed} tokens) carries no block_ids"
+                        )
+                    bs = self._config.block_size
+                    if num_computed % bs != 0:
+                        raise OmniPrefixCacheUnmatchError(
+                            f"prefix hit not block aligned (req={req_id}, hit_upto={num_computed}, block_size={bs})"
+                        )
+                    hit_blocks = list(blocks[: num_computed // bs])
+                    self._hit_spans[req_id] = (num_computed, hit_blocks)
+
+            # 4. Gather those spans on the prefetch thread; overlaps this forward.
+            while self._prefetch_queue and self._prefetch_queue[0][0].done():
+                self._prefetch_queue.popleft()
+            self._cur_num_scheduled = dict(scheduler_output.num_scheduled_tokens)
+            if self._hit_spans:
+                self._prefetch_hit_spans()
+        if to_escalate:
+            self._controller.escalate(to_escalate)
+
+    @torch.inference_mode()
+    def save_outputs(
+        self,
+        hidden_states: torch.Tensor | None,
+        mm_outputs: dict[str, Any] | None,
+        *,
+        num_tokens_unpadded: int,
+        num_tokens_padded: int,
+    ) -> int:
+        """Write this step's outputs into the cache; returns the step id.
+
+        Engine thread only, after the forward and before materialize.
+        Immediately-cached rows: one on-device clone, one whole-step
+        device→host into the staging pool, then one JOIN_NEXT_STEP
+        WriteTask per request whose `chunk.host` is a view of that page.
+        Deferred rows stay on the device clone (JOIN_ON_FINISH); the
+        committer copies them later. Leftover mm (this-step deferred rows
+        + mm not written to the pool) is copied to CPU here so materialize
+        never reads live graph buffers.
+        Snapshots everything materialize needs. The returned step id MUST
+        be consumed exactly once — by materialize() or discard_step().
+        Every step id claims one staging slot (saves with only leftover mm
+        included); a later save waits for a free slot and times out if
+        none return.
+
+        The state lock never covers a blocking wait: the previous step's
+        JOIN_NEXT_STEP wait, the clone build, the GPU-byte-budget reserve
+        (which may flush), and the staging-slot claim all run unlocked.
+        """
+        # 1. Join the previous step's host copies (unlocked).
+        self._wait_for_host_ready()
+
+        # 2. Packed batch layout for this step (req -> [start, end)).
+        req_order = self._view.batch_req_ids()
+        num_sched = {r: int(self._cur_num_scheduled.get(r, 0)) for r in req_order}
+        query_start: dict[str, int] = {}
+        current_start_idx = 0
+        for req_id in req_order:
+            query_start[req_id] = current_start_idx
+            current_start_idx += num_sched[req_id]
+
+        slots_cpu: torch.Tensor | None = None
+        mm_outputs = mm_outputs or {}
+        freeze_event = None
+
+        # 3. Slot map, then split into immediate / deferred / leftover.
+        if num_tokens_unpadded > 0:
+            # Derive the slot mapping on CPU: reading the device one back
+            # would need a stream sync that waits on the whole forward.
+            slots_cpu = self._view.step_slots_cpu(req_order, num_sched)
+            if int(slots_cpu.numel()) != num_tokens_unpadded:
+                # Fail at the cause: skipping the save would leave rows absent
+                # behind hashes vLLM already published — a delayed crash at
+                # some future hit instead of a debuggable one here.
+                raise OmniPrefixCacheUnmatchError(
+                    f"slot mapping covers {int(slots_cpu.numel())} of {num_tokens_unpadded} scheduled tokens; "
+                    "CPU-side slot derivation out of sync with the batch"
+                )
+        step_outputs = self._split_step_outputs(
+            hidden_states,
+            mm_outputs,
+            num_tokens_unpadded,
+            num_tokens_padded,
+            slots_cpu=slots_cpu,
+            req_order=req_order,
+            num_sched=num_sched,
+            query_start=query_start,
+        )
+
+        # 4. Freeze the device clones and reserve the GPU-byte budget (unlocked).
+        freezed_tensors = step_outputs.freeze_targets()
+        if freezed_tensors:
+            if torch.cuda.is_available() and any(t.is_cuda for t in freezed_tensors):
+                freeze_event = torch.cuda.Event()
+                freeze_event.record()
+            # One ticket per clone (immediate step clone, shared deferred
+            # clone); per-request slices are views and charge nothing.
+            # Reserve may block on a flush: outside the lock. The flush may
+            # close a deferred task this step appends to; _stage_deferred
+            # then opens a fresh one, so a long request cannot pin the
+            # whole budget.
+            self._controller.reserve(step_outputs.budget_bytes())
+
+        # 5. Claim a staging slot (unlocked), optional device→host into it,
+        #    register the writes + store the step snapshot (locked), then
+        #    dispatch the queued writes (unlocked: in eager mode dispatch
+        #    is the copy + pool write itself). Saves with only leftover mm
+        #    still claim. Full pool waits; timeout lists unused step ids.
+        d2h_claim: StepD2HClaim | None = None
+        step_holder = StagingBufferHolder.for_step(self._next_step_id)
+        transferred = False
+        bound_tids: list[int] = []
+        try:
+            d2h_claim = self._stage_step_host(step_outputs.immediate, num_tokens_unpadded, freeze_event, step_holder)
+
+            step_id, queued = self._publish_saved_step(
+                req_order=req_order,
+                query_start=query_start,
+                num_sched=num_sched,
+                num_tokens_unpadded=num_tokens_unpadded,
+                step_outputs=step_outputs,
+                slots_cpu=slots_cpu,
+                mm_keys=set(mm_outputs.keys()),
+                freeze_event=freeze_event,
+                d2h_claim=d2h_claim,
+                bound_tids=bound_tids,
+            )
+            self._controller.dispatch(queued)
+            transferred = True
+            return step_id
+        finally:
+            # Slot claim is outside the lock; a later raise must release
+            # the step and any task that already bound this slot.
+            if not transferred and d2h_claim is not None:
+                # A dispatch failure has no caller that can consume this step.
+                with self._state_lock:
+                    self._step_ctxs.pop(step_holder.owner_id, None)
+                self._release_staging_on_failed_save(d2h_claim.staging_slot, step_holder, bound_tids)
+
+    @torch.inference_mode()
+    def materialize(self, step_id: int, req_ids: list[str]) -> StageCacheOutputs:
+        """Per-request merged outputs for the step saved as `step_id`.
+
+        Any thread. `req_ids` must be (a subset of) the save-time snapshot;
+        an outside id means the caller is reading the live batch.
+        A request without a hit is a plain miss and gets exactly
+        this step's rows — normal path, nothing logged. A hit span that
+        resolves to absent rows raises OmniPrefixCacheUnmatchError: fatal
+        by contract (do not pretend it was a miss).
+
+        Two phases: under the lock, publish finished writes and pin every
+        row source (task refs + masks, absent checks included) — not yet
+        reading the tensors. Unlocked: wait this step's `step_d2h_event`,
+        clone the staging views (then drop the step holder), and merge.
+        The engine thread never waits on this thread's device→host copy.
+        """
+        ctx = None
+        step_released = False
+        try:
+            with self._state_lock:
+                ctx = self._take_step_ctx(step_id)
+                self._commit_drained_writes()
+
+                # The builder must pass (a subset of) the req list captured at
+                # save time — an id outside the snapshot means it is reading the
+                # live batch, which the contract forbids. Not a fallback that
+                # serves a miss.
+                unknown = set(req_ids) - set(ctx.spans)
+                if unknown:
+                    raise OmniPrefixCacheUnmatchError(
+                        f"materialize(step {step_id}) got req ids outside the save snapshot: {sorted(unknown)[:8]}"
+                    )
+
+                cached_keys = ctx.cached_keys
+
+                hit_sources: dict[tuple[str, str], _SlotRef | Future] = {}
+                for req_id in req_ids:
+                    hit = ctx.hits.get(req_id)
+                    if not hit:
+                        continue
+                    hit_upto, hit_blocks = hit
+                    prefetched = ctx.hit_prefetch.get(req_id, {})
+                    slots = self._get_hit_slots(hit_upto, hit_blocks)
+                    keys = self._policy.get_hit_keys(cached_keys)
+                    for key in keys:
+                        fut = prefetched.get(key)
+                        if fut is not None:
+                            hit_sources[(req_id, key)] = fut
+                            continue
+                        hit_sources[(req_id, key)] = self._slot_ref(slots, key, req_id)
+
+            # ---- unlocked: data movement + merge ----
+            if ctx.mm_cpu_snapshot_event is not None:
+                ctx.mm_cpu_snapshot_event.synchronize()
+                ctx.mm_cpu_snapshot = _unpin_leftover(ctx.mm_cpu_snapshot)
+            current: dict[str, torch.Tensor] = {}
+            if ctx.d2h is not None:
+                # Whole-step device→host was launched at save. One event wait
+                # (usually already complete), then a contiguous copy-out per
+                # key so consumers no longer depend on the reusable slot.
+                if ctx.d2h.event is not None:
+                    ctx.d2h.event.synchronize()
+                current = {k: v.clone() for k, v in ctx.d2h.views.items()}
+                self._release_step_staging(ctx, step_id)
+                step_released = True
+
+            hidden_out: dict[str, torch.Tensor] | None = None
+            hidden_key = self._policy.hidden_key
+            if hidden_key is not None and hidden_key in current:
+                hidden_out = {}
+                for req_id in req_ids:
+                    hidden_out[req_id] = self._merge_cached_for_req(
+                        ctx, req_id, hidden_key, current[hidden_key], hit_sources
+                    )
+
+            mm_out: dict[str, dict[str, Any]] = {}
+            for key in cached_keys:
+                cur = current.get(key)
+                if cur is None:
+                    val = ctx.mm_cpu_snapshot.get(key)
+                    if not isinstance(val, torch.Tensor):
+                        continue
+                    # Leftover snapshot; spans stay within [0, n), no re-slice.
+                    cur = val
+                mm_out[key] = {
+                    req_id: self._merge_cached_for_req(ctx, req_id, key, cur, hit_sources) for req_id in req_ids
+                }
+
+            self._merge_uncached_mm(ctx, req_ids, cached_keys, mm_out)
+            return StageCacheOutputs(hidden_states=hidden_out, mm_outputs=mm_out)
+        finally:
+            if ctx is not None and not step_released:
+                self._release_step_staging(ctx, step_id)
+
+    @_locked
+    def discard_step(self, step_id: int) -> None:
+        """Consume the step context when nothing will materialize it.
+
+        Any thread; same exactly-once contract as materialize (unknown or
+        duplicate id raises). Only the read-side snapshot is dropped —
+        the cache write proceeds unchanged.
+        """
+        ctx = self._take_step_ctx(step_id)
+        self._release_step_staging(ctx, step_id)
+
+    def shutdown(self) -> None:
+        self._prefetch_pool.shutdown(wait=False, cancel_futures=True)
+        self._prefetch_queue.clear()
+        self._controller.shutdown()
+
+    # ------------------------------------------------------ new_step
+
+    def _clear_hit_infos(self) -> None:
+        """Drop the live hit / prefetch tables. Caller holds ``_state_lock``."""
+        self._hit_spans.clear()
+        self._hit_prefetch.clear()
+
+    def _prefetch_hit_spans(self) -> None:
+        """Caller holds ``_state_lock``. Plan each hit span not yet planned
+        and gather it on the prefetch thread.
+
+        Called twice per step: at new_step_starts (overlaps the forward)
+        and again at publish for spans that could not plan then — same-step
+        hits, whose rows this step's save has only now registered. Starting
+        the gather at publish, not at materialize, means it runs before the
+        next step can hand those blocks to a new tenant; a span that still
+        fails to plan is left to materialize, which raises if unread.
+        """
+        keys = self._policy.get_hit_keys(self._pool.keys())
+        for req_id, (hit_upto, hit_blocks) in self._hit_spans.items():
+            futs = self._hit_prefetch.setdefault(req_id, {})
+            if all(key in futs for key in keys):
+                continue
+            n_new = int(self._cur_num_scheduled.get(req_id, 0))
+            slots = self._get_hit_slots(hit_upto, hit_blocks)
+            for key in keys:
+                if key in futs:
+                    continue
+                try:
+                    src = self._slot_ref(slots, key, req_id)
+                except OmniPrefixCacheUnmatchError:
+                    continue
+                fut = self._prefetch_pool.submit(self._prefetch_hit, src, n_new)
+                self._prefetch_queue.append((fut, src))
+                futs[key] = fut
+            if not futs:
+                del self._hit_prefetch[req_id]
+
+    @torch.inference_mode()
+    def _prefetch_hit(self, src: _SlotRef, n_new: int) -> torch.Tensor:
+        """Prefetch thread: gather the hit span and pre-build the merged
+        buffer with the prefix filled. materialize writes only this step's
+        rows at the tail — the gather AND the prefix copy both happen while
+        the forward runs, and the cat leaves the critical path."""
+        rows = self._fetch_source(src)
+        out = torch.empty((rows.shape[0] + n_new, rows.shape[-1]), dtype=rows.dtype)
+        out[: rows.shape[0]] = rows
+        return out
+
+    # ---------------------------------------------------------- save
+
+    def _stage_step_host(
+        self,
+        device_snapshot: dict[str, torch.Tensor],
+        num_tokens_unpadded: int,
+        freeze_event: torch.cuda.Event | None,
+        step_holder: StagingBufferHolder,
+    ) -> StepD2HClaim:
+        """Claim a staging slot (wait + timeout) and copy device→host if this step has rows.
+
+        Unlocked. Timeout is annotated with the unconsumed sids and the
+        task count so a leaked consume or a stuck write is visible.
+        """
+        try:
+            return self._controller.stage_step_host(device_snapshot, num_tokens_unpadded, freeze_event, step_holder)
+        except OmniPrefixCacheStagingTimeoutError as e:
+            with self._state_lock:
+                ids = sorted(self._step_ctxs)
+            raise OmniPrefixCacheStagingTimeoutError(
+                f"{e}; unconsumed step contexts (ids={ids}) or a stuck write "
+                f"(in_flight_tasks={self._controller.in_flight_tasks()})"
+            ) from e
+
+    def _wait_for_host_ready(self) -> None:
+        """Pop last step's join worklists and wait them out, unlocked.
+
+        JOIN_NEXT_STEP waits ``done``, not ``host_ready``: this save may reuse
+        those slots, and a pool write still pending behind a reused slot is
+        unreadable for a delayed hit read (scatter skips reassigned rows).
+        Escalated deferred writes keep ``host_ready`` — their readers hold the
+        task in ``staged_list``. Lock covers only the pop.
+        """
+        with self._state_lock:
+            finished_ids = list(self._join_finished_tids)
+            next_step_ids = list(self._join_next_step_tids)
+            self._join_finished_tids.clear()
+            self._join_next_step_tids.clear()
+        if finished_ids:
+            self._controller.join_host_ready(finished_ids)
+        if next_step_ids:
+            self._controller.join(next_step_ids)
+
+    @_locked
+    def _publish_saved_step(
+        self,
+        *,
+        req_order: list[str],
+        query_start: dict[str, int],
+        num_sched: dict[str, int],
+        num_tokens_unpadded: int,
+        step_outputs: _StepOutputs,
+        slots_cpu: torch.Tensor | None,
+        mm_keys: set[str],
+        freeze_event: torch.cuda.Event | None,
+        d2h_claim: StepD2HClaim,
+        bound_tids: list[int],
+    ) -> tuple[StepId, list[WriteTask]]:
+        """Takes ``_state_lock``. Register this step's writes and store the
+        consume-once snapshot. Copies live hits into the snapshot, then
+        clears them. Returns the queued tasks for the caller to dispatch
+        unlocked; device→host, budget flush and the eager copy stay outside.
+        """
+        self._commit_drained_writes()
+        for key, storage in step_outputs.new_key_storage.items():
+            self._pool.install_key(key, storage)
+            self._slot_status.init_table(key)
+        queued: list[WriteTask] = []
+        if step_outputs.immediate:
+            queued = self._submit_step_writes(
+                req_order,
+                query_start,
+                num_sched,
+                step_outputs.immediate,
+                step_outputs.immediate_budget,
+                slots_cpu,
+                d2h_claim.views,
+                freeze_event,
+                d2h_claim.staging_slot,
+                d2h_claim.event,
+                bound_tids,
+            )
+        self._stage_deferred(step_outputs.deferred_chunks, freeze_event)
+        if self._hit_spans:
+            # Same-step hits: their rows are registered now (IN_TRANSIT on
+            # this step's tasks); start the gather before the next step.
+            self._prefetch_hit_spans()
+        step_id = self._next_step_id
+        self._next_step_id += 1
+        self._step_ctxs[step_id] = _StepContext(
+            spans={r: (query_start[r], query_start[r] + num_sched[r]) for r in req_order},
+            num_tokens_unpadded=num_tokens_unpadded,
+            hits=dict(self._hit_spans),
+            hit_prefetch=dict(self._hit_prefetch),
+            cached_keys=without_hidden(self._pool.keys()) & mm_keys,
+            mm_cpu_snapshot=step_outputs.leftover,
+            mm_cpu_snapshot_event=step_outputs.leftover_event,
+            d2h=d2h_claim,
+        )
+        self._clear_hit_infos()
+        return step_id, queued
+
+    def _split_step_outputs(
+        self,
+        hidden_states: torch.Tensor | None,
+        mm_outputs: dict[str, Any],
+        num_tokens_unpadded: int,
+        num_tokens_padded: int,
+        *,
+        slots_cpu: torch.Tensor | None,
+        req_order: list[str],
+        num_sched: dict[str, int],
+        query_start: dict[str, int],
+    ) -> _StepOutputs:
+        """Split this step's outputs into immediate / deferred / leftover.
+
+        Unlocked. One pass over ``mm_outputs``. ``n==0`` has only leftover
+        mm (no device clones). A deferred key whose first dim is this
+        step's token count is cloned for the JOIN_ON_FINISH write and
+        CPU-copied into leftover for this-step materialize. Talker
+        ``codes.audio`` stays unpadded while hidden is padded; both must
+        open a pool key.
+        Lists and other shapes stay leftover.
+        """
+        n = num_tokens_unpadded
+        immediate: dict[str, torch.Tensor] = {}
+        deferred_tensors: dict[str, torch.Tensor] = {}
+        new_key_storage: dict[str, torch.Tensor] = {}
+
+        def alloc_key(key: str, val: torch.Tensor) -> None:
+            # Pinned allocation, unlocked; installed under the lock at publish.
+            storage = self._pool.alloc_key(key, val.dtype, int(val.shape[-1]))
+            if storage is not None:
+                new_key_storage[key] = storage
+
+        if n > 0:
+            if hidden_states is not None and (hk := self._policy.hidden_key) is not None:
+                if hidden_states.ndim < 2 or hidden_states.shape[0] < n:
+                    rows = 0 if hidden_states.ndim < 2 else int(hidden_states.shape[0])
+                    raise OmniPrefixCacheUnmatchError(f"hidden_states has {rows} rows, need {n}")
+                alloc_key(hk, hidden_states)
+                immediate[hk] = hidden_states[:n].clone()
+            for key, val in mm_outputs.items():
+                is_step_rows = _is_step_token_tensor(val, n, num_tokens_padded)
+                if key in self._policy.deferred_keys:
+                    if is_step_rows:
+                        alloc_key(key, val)
+                        deferred_tensors[key] = val[:n].clone()
+                    continue
+                if self._policy.skip_immediate_mm(key) or not is_step_rows:
+                    continue
+                alloc_key(key, val)
+                immediate[key] = val[:n].clone()
+        leftover, leftover_event = _snapshot_leftover_mm_cpu(mm_outputs, set(immediate), n, num_tokens_padded)
+        deferred_chunks: list[tuple[str, _WriteChunk]] = []
+        if deferred_tensors:
+            assert slots_cpu is not None
+            deferred_chunks = self._pack_deferred_chunks(deferred_tensors, slots_cpu, req_order, num_sched, query_start)
+        immediate_budget = (
+            _BudgetTicket(nbytes=sum(t.numel() * t.element_size() for t in immediate.values())) if immediate else None
+        )
+        return _StepOutputs(
+            immediate=immediate,
+            deferred_chunks=deferred_chunks,
+            leftover=leftover,
+            leftover_event=leftover_event,
+            immediate_budget=immediate_budget,
+            new_key_storage=new_key_storage,
+        )
+
+    def _pack_deferred_chunks(
+        self,
+        deferred_tensors: dict[str, torch.Tensor],
+        slots_cpu: torch.Tensor,
+        req_order: list[str],
+        num_sched: dict[str, int],
+        query_start: dict[str, int],
+    ) -> list[tuple[str, _WriteChunk]]:
+        """Per-req views of already-cloned deferred tensors. No further clone."""
+        ticket = _BudgetTicket(nbytes=sum(t.numel() * t.element_size() for t in deferred_tensors.values()))
+        out: list[tuple[str, _WriteChunk]] = []
+        for req_id in req_order:
+            sched = num_sched[req_id]
+            if sched <= 0:
+                continue
+            start = query_start[req_id]
+            end = start + sched
+            out.append(
+                (
+                    req_id,
+                    _WriteChunk(
+                        slots_cpu=slots_cpu[start:end],
+                        tensors={k: v[start:end] for k, v in deferred_tensors.items()},
+                        budget=ticket,
+                    ),
+                )
+            )
+        return out
+
+    def _submit_step_writes(
+        self,
+        req_order: list[str],
+        query_start: dict[str, int],
+        num_sched: dict[str, int],
+        device_snapshot: dict[str, torch.Tensor],
+        budget: _BudgetTicket | None,
+        slots_cpu: torch.Tensor,
+        host_views: dict[str, torch.Tensor],
+        freeze_event,
+        staging_slot: int,
+        step_d2h_event,
+        bound_tids: list[int],
+    ) -> list[WriteTask]:
+        """Caller holds ``_state_lock``. Register one WriteTask per request;
+        returns them for the caller to dispatch once the lock is released.
+
+        Per-req views of the shared device snapshot: one on-device clone, req-scoped
+        finish/abort, reassigned rows, and completion. Appends bound tids to
+        `bound_tids` as it goes so a mid-loop raise still unwinds holders.
+        """
+        tasks: list[WriteTask] = []
+        for req_id in req_order:
+            start = query_start[req_id]
+            end = start + num_sched[req_id]
+            if end == start:
+                continue
+            tensors = {k: v[start:end] for k, v in device_snapshot.items()}
+            tid = self._request_tasks.alloc_tid()
+            chunk = _WriteChunk(slots_cpu=slots_cpu[start:end], tensors=tensors, budget=budget)
+            # Host rows are views into the slot; the committer only waits
+            # the shared step event. Device→host is already in flight.
+            chunk.host = {k: v[start:end] for k, v in host_views.items()}
+            task = WriteTask(
+                tid=tid,
+                req_id=req_id,
+                write_n=self._request_tasks.increment_write_n(req_id),
+                schedule=WriteSchedule.JOIN_NEXT_STEP,
+                chunks=[chunk],
+                freeze_event=freeze_event,
+                staging_slot=staging_slot,
+                step_d2h_event=step_d2h_event,
+            )
+            self._map_slots(slots_cpu[start:end], tid, tensors.keys())
+            # Bind and pin before register: the slot must never be holder-free
+            # while the task is live (released at its pool write).
+            self._controller.staging_bind(staging_slot, StagingBufferHolder.for_task(tid))
+            bound_tids.append(tid)
+            if budget is not None:
+                self._controller.pin_budget(budget, tid)
+            self._controller.register(task)
+            self._request_tasks.track(req_id, tid)
+            self._join_next_step_tids.append(tid)
+            tasks.append(task)
+        return tasks
+
+    def _stage_deferred(self, deferred_chunks: list[tuple[str, _WriteChunk]], freeze_event) -> None:
+        """Caller holds ``_state_lock``. Register pre-built deferred `_WriteChunk`s
+        (bytes already reserved by save_outputs).
+
+        A new write (``write_n`` + 1) starts when the open task was closed by
+        the budget flush, or when a chunk re-acquires a (key, slot) the task
+        already lost — appending there would let its own reassigned tombstone
+        drop the fresh rows at scatter. Hits read both through ``staged_list``.
+        """
+        for req_id, chunk in deferred_chunks:
+            task = self._request_tasks.deferred.get(req_id)
+            if task is not None and (
+                task.reassigned_intersects(chunk)
+                or self._controller.append_chunk(task, chunk, freeze_event) is not None
+            ):
+                task = None
+            if task is None:
+                task = WriteTask(
+                    tid=self._request_tasks.alloc_tid(),
+                    req_id=req_id,
+                    write_n=self._request_tasks.increment_write_n(req_id),
+                    schedule=WriteSchedule.JOIN_ON_FINISH,
+                    chunks=[chunk],
+                    freeze_event=freeze_event,
+                )
+                self._request_tasks.deferred[req_id] = task
+                self._request_tasks.track(req_id, task.tid)
+                self._controller.register(task, queued=False)
+            if chunk.budget is not None:
+                # Safe after register: queued=False keeps the task PENDING
+                # until escalate, which only this thread calls.
+                self._controller.pin_budget(chunk.budget, task.tid)
+            # Block reuse across deferred tenants (preemption path) is
+            # handled inside _map_slots: the old tenant's rows are skipped.
+            self._map_slots(chunk.slots_cpu, task.tid, chunk.tensors.keys())
+
+    # ----------------------------------------------------- occupancy
+
+    def _map_slots(self, slots: torch.Tensor, tid: int, keys: Iterable[str]) -> None:
+        """Caller holds ``_state_lock``. Record `tid` on these (slot, key);
+        if another write still owns them, mark those rows skipped on it."""
+        keys = tuple(keys)
+        # Copy committed rows aside before this claim overwrites them.
+        if self._pending_reads:
+            self._preserve_for_pending_reads(slots, keys)
+        for old, key, stolen in self._slot_status.map_slots(slots, tid, keys):
+            old_task = self._controller.get_task(old)
+            if old_task is not None:
+                old_task.add_reassigned(key, stolen)
+
+    def _preserve_for_pending_reads(self, new_slots: torch.Tensor, keys: tuple[str, ...]) -> None:
+        """Caller holds ``_state_lock``. Copy still-valid committed rows into
+        each pending ref before ``new_slots`` are claimed.
+
+        Only COMMITTED rows at the reserved version need rescuing: the save
+        barrier joins JOIN_NEXT_STEP writes to ``done`` and publish drains
+        before claiming, and JOIN_ON_FINISH in-transit rows are read through
+        ``staged_list`` task refs directly.
+        """
+        new_set = {int(s) for s in new_slots.tolist()}
+        for ref in self._pending_reads:
+            if ref.key not in keys or ref.reserved_version is None or not self._pool.has_key(ref.key):
+                continue
+            status = self._slot_status.get_slot_status(ref.key)
+            take: list[tuple[int, int]] = []  # (row index in ref, slot)
+            for i, s in enumerate(ref.slots.tolist()):
+                s = int(s)
+                if s not in new_set or s in ref.preserved:
+                    continue
+                committed = int(status.state[s]) == _Occupancy.COMMITTED
+                if committed and int(status.slot_version[s]) == int(ref.reserved_version[i]):
+                    take.append((i, s))
+            if not take:
+                continue
+            rows = self._pool.rows(ref.key, torch.tensor([s for _, s in take], dtype=torch.long))
+            for j, (_, s) in enumerate(take):
+                ref.preserved[s] = rows[j].clone()
+
+    @torch.inference_mode()
+    def _commit_drained_writes(self) -> None:
+        """Fold completed/failed writes into occupancy. Caller holds ``_state_lock``.
+
+        A failed write leaves rows absent behind hashes vLLM already
+        published — unservable and unrecoverable, so fatal. The fatality is
+        sticky: the drained record is one-shot and the first raise can land
+        in a swallowed path (a prefetch Future dropped by discard_step), so
+        every later entry must keep raising rather than serve zeros.
+        """
+        if self._fatal_write_failure is not None:
+            raise OmniPrefixCacheUnmatchError(self._fatal_write_failure)
+        failed = self._controller.drain_failed()
+        if failed:
+            self._fatal_write_failure = (
+                f"prefix cache write failed for task(s) {failed}; cached rows lost behind published hashes"
+            )
+            raise OmniPrefixCacheUnmatchError(self._fatal_write_failure)
+        drained = self._controller.drain_completed()
+        if drained:
+            self._slot_status.commit(drained)
+            self._request_tasks.drop_completed(drained)
+
+    # --------------------------------------------------- consume-once
+
+    def _take_step_ctx(self, step_id: int) -> _StepContext:
+        """Pop the context for this step id (exactly once). Caller holds ``_state_lock``."""
+        ctx = self._step_ctxs.pop(step_id, None)
+        if ctx is None:
+            raise OmniPrefixCacheUnmatchError(
+                f"step context {step_id} missing (have {sorted(self._step_ctxs)}); already consumed or never saved"
+            )
+        return ctx
+
+    def _release_step_staging_slot(self, slot: int, step_id: int) -> None:
+        self._controller.staging_release(slot, StagingBufferHolder.for_step(step_id))
+
+    def _release_step_staging(self, ctx: _StepContext, step_id: int) -> None:
+        """Drop this step's staging hold. Does not require ``_state_lock``.
+
+        materialize/discard: task holds leave at their pool write.
+        """
+        if ctx.d2h is not None:
+            self._release_step_staging_slot(ctx.d2h.staging_slot, step_id)
+
+    def _release_staging_on_failed_save(
+        self, slot: int, step_holder: StagingBufferHolder, bound_tids: list[int]
+    ) -> None:
+        """save raised after claiming the slot: drop the step hold and any
+        task holds. Does not require ``_state_lock``.
+        """
+        self._release_step_staging_slot(slot, step_holder.owner_id)
+        for tid in bound_tids:
+            self._controller.staging_release(slot, StagingBufferHolder.for_task(tid))
+
+    # -------------------------------------------------- slot ref / fetch
+
+    def _get_hit_slots(self, hit_upto: int, hit_blocks: list[int]) -> torch.Tensor:
+        """Prefix-hit block ids → KV slot ids. Alignment is checked at
+        ``new_step_starts``. Does not require ``_state_lock``.
+        """
+        bs = self._config.block_size
+        block_ids = torch.tensor(hit_blocks, dtype=torch.int64)
+        return (block_ids.unsqueeze(1) * bs + torch.arange(bs)).reshape(-1)[:hit_upto]
+
+    def _slot_ref(self, slots: torch.Tensor, key: str, req_id: str) -> _SlotRef:
+        """Caller holds ``_state_lock``. Pin a ``_SlotRef`` for `slots` (no data movement).
+
+        Rows still being written win over the CPU pool: they may not have
+        landed yet, and a pool read would return zero/stale values.
+        JOIN_NEXT_STEP tasks go in ``join_tids`` (wait-then-pool at
+        fetch). JOIN_ON_FINISH tasks stay as refs for fetch_host.
+
+        Hidden rejects any empty hole (prefetch skips; materialize
+        raises). Other keys only need a source — holes fall to the pool.
+
+        The ref is registered in ``_pending_reads`` so a write that later
+        reuses one of these slots copies the old row aside first (COW). Reads
+        are planned synchronously under the lock at hit time (prefetch runs at
+        ``new_step_starts`` / publish), before the block can be reused, so this
+        registration always precedes the reuse. ``_fetch_source`` unregisters.
+        """
+        status = self._slot_status.get_slot_status(key)
+        states = status.state[slots]
+        tids = status.tids[slots]
+        reserved_version = status.slot_version[slots].clone()
+        staged_mask = states == _Occupancy.IN_TRANSIT
+
+        staged: list[tuple[WriteTask, torch.Tensor]] = []
+        join_tids: list[int] = []
+        for tid in {int(t) for t in tids[staged_mask].tolist()}:
+            task = self._controller.get_task(tid) if tid != 0 else None
+            if task is None:
+                _raise_unreadable_hit(req_id, key, f"in-transit entry {tid} cannot serve them")
+            if task.schedule is WriteSchedule.JOIN_NEXT_STEP:
+                join_tids.append(task.tid)
+            else:
+                staged.append((task, staged_mask & (tids == tid)))
+
+        already_staged = self._pool.has_key(key)
+        has_source = already_staged or bool(staged) or bool(join_tids)
+        if is_hidden_key(key):
+            n_abs = int((states == _Occupancy.ABSENT).sum())
+            if n_abs or not has_source:
+                _raise_unreadable_hit(req_id, key, f"{n_abs} absent slots")
+        ref = _SlotRef(
+            slots=slots,
+            key=key,
+            req_id=req_id,
+            already_staged=already_staged,
+            staged_list=staged,
+            join_tids=join_tids,
+            reserved_version=reserved_version,
+        )
+        self._pending_reads.append(ref)
+        return ref
+
+    def _apply_preserved_rows(self, src: _SlotRef, out: torch.Tensor) -> torch.Tensor:
+        """Write ``src.preserved`` rows over the matching slots in ``out``."""
+        if not src.preserved:
+            return out
+        for i, s in enumerate(src.slots.tolist()):
+            row = src.preserved.get(int(s))
+            if row is not None:
+                out[i] = row
+        return out
+
+    def _unregister_pending_read(self, src: _SlotRef) -> None:
+        """Drop ``src`` from ``_pending_reads``. Identity, not dataclass eq
+        (tensors in the ref make ``==`` unusable). Safe if already removed."""
+        with self._state_lock:
+            self._pending_reads = [ref for ref in self._pending_reads if ref is not src]
+
+    def _fetch_source(self, src: _SlotRef) -> torch.Tensor:
+        """Fetch a planned row source (execute phase, no lock).
+
+        One key is one schedule: ``join_tids`` (JOIN_NEXT_STEP) and
+        ``staged_list`` (JOIN_ON_FINISH) do not coexist. Immediate: wait
+        ``done``, drain, read the pool. Deferred: pool rows already
+        written, overlay ``fetch_host`` on the still-in-progress mask.
+        Slots a later write reused are served from ``src.preserved``
+        (copied under the lock before that write claimed them).
+        """
+        try:
+            return self._fetch_source_inner(src)
+        finally:
+            self._unregister_pending_read(src)
+
+    def _fetch_source_inner(self, src: _SlotRef) -> torch.Tensor:
+        # For JOIN_NEXT_STEP, wait `done`, drain, read the pool
+        if src.join_tids:
+            self._controller.join(src.join_tids)
+            with self._state_lock:
+                self._commit_drained_writes()
+            joined = self._apply_preserved_rows(src, self._pool.rows(src.key, src.slots))
+            self._ensure_not_reassigned(
+                src.slots,
+                src.key,
+                req_id=src.req_id,
+                planned_version=src.reserved_version,
+                preserved_slots=src.preserved,
+            )
+            return joined
+
+        # For JOIN_ON_FINISH, pool rows already written, overlay `fetch_host`
+        n = int(src.slots.numel())
+        out: torch.Tensor | None = None
+        if src.already_staged:
+            out = self._pool.rows(src.key, src.slots)
+        in_transit = None
+        for task, mask in src.staged_list:
+            try:
+                rows = self._controller.fetch_host(task, src.slots[mask], src.key)
+            except KeyError:
+                _raise_unreadable_hit(
+                    src.req_id,
+                    src.key,
+                    f"entry {task.tid} (req {task.req_id}, write_n {task.write_n}) cannot serve them",
+                )
+            if out is None:
+                out = torch.zeros((n, rows.shape[-1]), dtype=rows.dtype)
+            out[mask] = rows
+            in_transit = mask if in_transit is None else in_transit | mask
+        if out is not None:
+            out = self._apply_preserved_rows(src, out)
+        self._ensure_not_reassigned(
+            src.slots,
+            src.key,
+            in_transit_mask=in_transit,
+            req_id=src.req_id,
+            planned_version=src.reserved_version,
+            preserved_slots=src.preserved,
+        )
+        if out is None:
+            _raise_unreadable_hit(src.req_id, src.key, "no source")
+        return out
+
+    def _ensure_not_reassigned(
+        self,
+        slots: torch.Tensor,
+        key: str,
+        *,
+        in_transit_mask: torch.Tensor | None = None,
+        req_id: str = "?",
+        planned_version: torch.Tensor | None = None,
+        preserved_slots: dict[int, torch.Tensor] | None = None,
+    ) -> None:
+        """Takes ``_state_lock``. Post-fetch check: rows read unlocked may
+        have been given to a newer write between plan and read (block reuse).
+
+        vLLM frees a request's blocks when it finishes or is aborted, one
+        step before ``finished_req_ids`` reaches us, and may reuse them at
+        once. A planned ``_SlotRef`` is registered in ``_pending_reads``;
+        the reusing write copy-on-writes those COMMITTED rows into
+        ``preserved`` before it claims the slots. Those slots are safe.
+        A version mismatch with no preserved copy means the pool rows are
+        a newer tenant's — raise for live and finished alike, never serve
+        them.
+
+        ``planned_version`` is the per-slot version captured at plan time.
+        ``in_transit_mask`` excludes JOIN_ON_FINISH slots this task itself
+        still serves through ``fetch_host``.
+        """
+        with self._state_lock:
+            status = self._slot_status.get_slot_status(key)
+            if planned_version is not None:
+                violated = status.slot_version[slots] != planned_version
+            else:
+                violated = status.state[slots] == _Occupancy.IN_TRANSIT
+            if in_transit_mask is not None:
+                violated &= ~in_transit_mask
+            if preserved_slots:
+                for i, s in enumerate(slots.tolist()):
+                    if int(s) in preserved_slots:
+                        violated[i] = False
+            if not bool(violated.any()):
+                return
+            live = req_id in self._request_tasks.live_reqs
+        _raise_unreadable_hit(
+            req_id,
+            key,
+            f"{int(violated.sum())} hit slots reassigned before this delayed read "
+            f"({'live' if live else 'finished'} req, block reuse)",
+        )
+
+    # ---------------------------------------------------------- merge
+
+    def _merge_cached_for_req(
+        self,
+        ctx: _StepContext,
+        req_id: str,
+        key: str,
+        current_cpu: torch.Tensor,
+        hit_sources: dict[tuple[str, str], _SlotRef | Future],
+    ) -> torch.Tensor:
+        """Hit prefix + this step's rows for one (req, key).
+
+        No hit → this step's slice only. Prefetch Future → write the
+        slice into the reserved tail. Else cat(fetch, new).
+        """
+        start, end = ctx.spans[req_id]
+        new_rows = current_cpu[start:end]
+        src = hit_sources.get((req_id, key))
+        if src is None:
+            return new_rows
+        if isinstance(src, Future):
+            # Prefetched during the forward, prefix already in place; only
+            # this step's rows land here. result() re-raises fetch/validation
+            # errors — unread hits still raise after the thread hop.
+            merged = src.result()
+            merged[merged.shape[0] - new_rows.shape[0] :] = new_rows
+            return merged
+        cached = self._fetch_source(src)
+        return torch.cat([cached, new_rows], dim=0)
+
+    def _merge_uncached_mm(
+        self,
+        ctx: _StepContext,
+        req_ids: list[str],
+        cached_keys: set[str],
+        mm_out: dict[str, dict[str, Any]],
+    ) -> None:
+        """Write leftover mm that is not a pool key into mm_out.
+
+        No hit concat: leftover mm was already copied to CPU at save
+        (``ctx.mm_cpu_snapshot``). cached_keys already went through
+        _merge_cached_for_req. ``req_ids`` is a subset of ``ctx.spans``.
+        """
+        leftover = {k: v for k, v in ctx.mm_cpu_snapshot.items() if k not in cached_keys and not is_hidden_key(k)}
+        if not leftover:
+            return
+        from vllm_omni.utils.mm_outputs import to_payload_element
+
+        order = list(ctx.spans)
+        total_length = sum(e - s for s, e in ctx.spans.values())
+        for key, val in leftover.items():
+            per_req: dict[str, Any] = {}
+            for req_id in req_ids:
+                idx = order.index(req_id)
+                start, end = ctx.spans[req_id]
+                per_req[req_id] = to_payload_element(
+                    val,
+                    idx,
+                    start=start,
+                    end=end,
+                    pass_lists_through=True,
+                    seq_len=total_length,
+                )
+            mm_out[key] = per_req
diff --git a/vllm_omni/core/prefix_cache/runner_mixin.py b/vllm_omni/core/prefix_cache/runner_mixin.py
new file mode 100644
index 000000000..25fa4fe2b
--- /dev/null
+++ b/vllm_omni/core/prefix_cache/runner_mixin.py
@@ -0,0 +1,148 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Runner-facing access layer for the omni prefix cache.
+
+One copy of the integration rules shared by the GPU and NPU runners:
+one-shot manager construction, the model cache-policy snapshot, and the
+per-step lifecycle entry. The manager/controller state machines and the
+platform output-building flows stay in their owners.
+
+Not exported from the package ``__init__``; runners import this module
+directly. No module-level vLLM import (``get_pp_group`` is resolved at
+call time) so ``tests/core`` keeps loading the package without vLLM.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from vllm_omni.core.prefix_cache.group_view import get_prefix_cache_group_view
+from vllm_omni.core.prefix_cache.interface import (
+    ModelCachePolicy,
+    OmniPrefixCacheUnmatchError,
+    PrefixCacheConfig,
+)
+from vllm_omni.core.prefix_cache.manager import OmniPrefixCacheManager
+from vllm_omni.data_entry_keys import flatten_payload
+
+if TYPE_CHECKING:
+    import torch
+    from vllm.v1.core.sched.output import SchedulerOutput
+
+
+class PrefixCacheRunnerMixin:
+    """Prefix-cache integration for a model runner (no state machine here).
+
+    Host-class contract — the runner must provide:
+        ``input_batch``        live batch with the group-0 block table
+        ``kv_cache_config``    for ``kv_cache_groups`` at construction
+        ``omni_prefix_cache``  set here; ``None`` until first-step build
+        ``_omni_prefix_cache_cfg``  staged by the runner's kv-cache init
+                               (``stage_prefix_cache_config``), consumed here
+
+    No cooperative ``__init__``: the class attributes below are safe
+    defaults (``ModelCachePolicy`` is frozen); runners keep initializing
+    their instance fields as before.
+    """
+
+    # Host-class fields (annotation only; the runner initializes them).
+    input_batch: Any
+    kv_cache_config: Any
+    is_pooling_model: bool
+
+    omni_prefix_cache: OmniPrefixCacheManager | None = None
+    _omni_prefix_cache_cfg: PrefixCacheConfig | None = None
+    # Snapshotted once at load_model; the hot path must not re-probe model
+    # attributes every step. The same object is registered on the manager.
+    _omni_cache_policy: ModelCachePolicy = ModelCachePolicy()
+
+    def _snapshot_prefix_cache_model_policy(self, model) -> None:
+        """Freeze the model's cache policy at load_model."""
+        self._omni_cache_policy = ModelCachePolicy.from_model(model)
+
+    def _model_needs_full_prefix_hidden_states(self) -> bool:
+        """Opt-out hook for models whose postprocess only consumes the tail.
+
+        When False, we skip both the per-step hidden-state write into the
+        omni prefix cache and the merged-tensor reconstruction on hits;
+        postprocess receives the normal scheduled-token slice instead. Models
+        that need the full cached_prefix + new_tail span (default) are not
+        affected.
+        """
+        return self._omni_cache_policy.needs_full_hidden_states
+
+    def _ensure_omni_prefix_cache(self) -> None:
+        """One-shot construction (caller gates on the staged config).
+
+        Only the last PP rank writes and materializes the cache. Other ranks
+        would register hits they can never serve (save_outputs is last-rank
+        only), so skip construction there.
+        """
+        from vllm.distributed.parallel_state import get_pp_group
+
+        cfg = self._omni_prefix_cache_cfg
+        self._omni_prefix_cache_cfg = None
+        if cfg is None or not get_pp_group().is_last_rank:
+            return
+        view = get_prefix_cache_group_view(
+            self.input_batch,
+            cfg.block_size,
+            kv_cache_groups=getattr(self.kv_cache_config, "kv_cache_groups", None),
+        )
+        if view is None:
+            raise OmniPrefixCacheUnmatchError(
+                "omni prefix caching requires a block table on the input batch; "
+                "disable enable_prefix_caching for this model"
+            )
+        manager = OmniPrefixCacheManager(cfg, view)
+        manager.register_policy(self._omni_cache_policy)
+        self.omni_prefix_cache = manager
+
+    def _prefix_cache_step_begin(self, scheduler_output: SchedulerOutput) -> None:
+        """Per-step lifecycle entry; must run before ``_update_states``
+        removes finished requests (finished/abort escalation happens inside
+        ``new_step_starts``). Builds the manager on the first real step."""
+        if self.omni_prefix_cache is None and self._omni_prefix_cache_cfg is not None:
+            self._ensure_omni_prefix_cache()
+        if self.omni_prefix_cache is not None:
+            self.omni_prefix_cache.new_step_starts(scheduler_output)
+
+    def _prefix_cache_save_step(
+        self,
+        hidden_states: torch.Tensor,
+        multimodal_outputs: dict | None,
+        *,
+        num_tokens_unpadded: int,
+        num_tokens_padded: int,
+    ) -> int | None:
+        """Write this step's outputs into the cache.
+
+        None when this stage/rank does not write (pooling, cache off, or not
+        the last PP rank). The returned step id must be consumed exactly once
+        — materialize or discard_step — by the output path.
+        """
+        from vllm.distributed.parallel_state import get_pp_group
+
+        if self.is_pooling_model or self.omni_prefix_cache is None or not get_pp_group().is_last_rank:
+            return None
+        return self.omni_prefix_cache.save_outputs(
+            hidden_states,
+            flatten_payload(multimodal_outputs) if multimodal_outputs else {},
+            num_tokens_unpadded=num_tokens_unpadded,
+            num_tokens_padded=num_tokens_padded,
+        )
+
+    def _prefix_cache_materialize(
+        self, step_id: int | None, req_ids: list[str]
+    ) -> tuple[dict[str, torch.Tensor] | None, dict | None]:
+        """Per-request merged outputs for a saved step.
+
+        ``req_ids`` must be the save-time snapshot, never the live
+        ``input_batch`` (under async output this runs a step late).
+        ``step_id`` None means save did not run — nothing to consume.
+        ``mm_outputs`` is all-or-nothing; empty only when the step had no mm.
+        """
+        if step_id is None or self.omni_prefix_cache is None:
+            return None, None
+        outs = self.omni_prefix_cache.materialize(step_id, list(req_ids))
+        return outs.hidden_states, (outs.mm_outputs or None)
diff --git a/vllm_omni/core/sched/omni_ar_scheduler.py b/vllm_omni/core/sched/omni_ar_scheduler.py
index 3d866fda7..4d55c55f8 100644
--- a/vllm_omni/core/sched/omni_ar_scheduler.py
+++ b/vllm_omni/core/sched/omni_ar_scheduler.py
@@ -23,13 +23,31 @@ from vllm.v1.request import Request, RequestStatus, StreamingUpdate
 from vllm.v1.spec_decode.metrics import SpecDecodingStats
 
 from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
-from vllm_omni.core.sched.utils import omni_routed_experts_for_request
+from vllm_omni.core.sched.utils import (
+    free_kv_blocks_in_physical_order,
+    omni_routed_experts_for_request,
+)
 from vllm_omni.engine import OmniEngineCoreOutput
 from vllm_omni.engine.serialization import deserialize_additional_information
 
 logger = init_logger(__name__)
 
 
+def _should_emit_engine_output(
+    model_config: Any,
+    *,
+    stopped: bool,
+    has_control: bool,
+) -> bool:
+    if stopped or has_control:
+        return True
+    return not (
+        bool(getattr(model_config, "use_v2_model_runner", False))
+        and bool(getattr(model_config, "async_chunk", False))
+        and not bool(getattr(model_config, "final_output", False))
+    )
+
+
 class SampledLogprobContractError(RuntimeError):
     """The model runner returned unusable sampled-token logprobs."""
 
@@ -81,6 +99,8 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
     core scheduling logic.
     """
 
+    max_num_running_reqs: int
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # Track requests that need KV cache transfer when finished
@@ -127,6 +147,26 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         # Output placeholders are zero when async scheduling isn't used
         return request.num_computed_tokens - request.num_output_placeholders
 
+    def _uses_native_mooncake_connector(self) -> bool:
+        kv_config = getattr(self.vllm_config, "kv_transfer_config", None)
+        return getattr(kv_config, "kv_connector", None) == "MooncakeConnector"
+
+    def _free_request_blocks(self, request: Request) -> None:
+        """Keep native Mooncake pages coalescible without changing vLLM APIs."""
+
+        if not self._uses_native_mooncake_connector() or self.kv_cache_manager.enable_caching:
+            super()._free_request_blocks(request)
+            return
+        if not self.defer_block_free or request.last_sched_seq <= self.processed_step_seq:
+            free_kv_blocks_in_physical_order(self.kv_cache_manager, request)
+            return
+        blocks = self.kv_cache_manager.pop_blocks_for_free(request)
+        if blocks:
+            # vLLM's deferred-free drain reverses this list before returning
+            # it to BlockPool, so store the inverse of the desired order.
+            blocks.sort(key=lambda block: block.block_id, reverse=True)
+            self.deferred_frees.append((self.sched_step_seq, blocks))
+
     def _resolve_kv_connector_type(self) -> str:
         """Connector backend name for the ``kv_wait_s`` label, or ``unknown``."""
         connector_cfg = self._get_omni_kv_config_value("connector_config")
@@ -177,9 +217,10 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         finished_status: RequestStatus,
     ) -> list[Request]:
         """Finish requests and discard any incomplete KV-wait timing."""
+        cleanup_ids: Iterable[str]
         if isinstance(request_ids, str):
             cleanup_ids = (request_ids,)
-            finish_request_ids: str | tuple[str, ...] | None = request_ids
+            finish_request_ids: str | Iterable[str] | None = request_ids
         elif request_ids is None:
             cleanup_ids = ()
             finish_request_ids = None
@@ -306,15 +347,22 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         self._process_pending_omni_inputs(model_mode="ar")
         self._drop_aborted_queued_requests()
         self._resync_streaming_input_counter()
-
         original_waiting = None
         if self._should_defer_waiting_admission():
             original_waiting = waiting
             self.waiting = create_request_queue(self.policy)
 
+        original_max_num_running_reqs = self.max_num_running_reqs
+        async_chunk_transport = self._async_chunk_transport_enabled()
+        reserved_running_slots = (
+            self._get_async_chunk_reserved_running_slots() if async_chunk_transport and self.use_v2_model_runner else 0
+        )
+        if reserved_running_slots:
+            self.max_num_running_reqs = max(0, original_max_num_running_reqs - reserved_running_slots)
         try:
             scheduler_output = super().schedule(throttle_prefills)
         finally:
+            self.max_num_running_reqs = original_max_num_running_reqs
             if original_waiting is not None:
                 deferred_waiting = list(self.waiting)
                 if deferred_waiting:
@@ -418,7 +466,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             assert num_tokens_scheduled > 0
             request = self.requests.get(req_id)
             if request is not None:
-                # vLLM 0.26: settle the in-flight tokens counted in schedule().
+                # Settle the in-flight tokens counted in schedule().
                 # Must happen before the skips below — failed-KV-load and
                 # already-finished requests were incremented too, and the two
                 # readers (allocate_slots, _connector_finished) clamp with
@@ -586,6 +634,11 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
             confirmed_num_computed_tokens = None
             boundary_generation = None
+            # Capture before resumable stop handling can clear token history.
+            output_token_ids: Any = getattr(request, "output_token_ids", None)
+            if output_token_ids is None:
+                output_token_ids = getattr(request, "_output_token_ids", ())
+            num_generation_tokens = len(output_token_ids)
             if stopped:
                 if self.chunk_transfer_adapter is not None:
                     confirmed_num_computed_tokens = self.chunk_transfer_adapter._confirmed_num_computed_tokens(request)
@@ -604,6 +657,8 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                 is_segment_finished = not finished
                 if finished:
                     request.resumable = False
+                    if self._native_data_plane:
+                        self._pending_data_plane_terminal_req_ids.add(req_id)
                 if not finished:
                     # for streaming input request only
                     if self.chunk_transfer_adapter:
@@ -660,7 +715,18 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
             # Get prompt logprobs for this request.
             prompt_logprobs_tensors = prompt_logprobs_dict.get(req_id)
-            if new_token_ids or mm_output is not None or pooler_output is not None or kv_transfer_params or stopped:
+            has_stage_output = (
+                bool(new_token_ids)
+                or mm_output is not None
+                or pooler_output is not None
+                or kv_transfer_params
+                or stopped
+            )
+            if has_stage_output and _should_emit_engine_output(
+                self.vllm_config.model_config,
+                stopped=stopped,
+                has_control=kv_transfer_params is not None,
+            ):
                 OmniSchedulerMixin._append_request_output(
                     self,
                     outputs,
@@ -679,6 +745,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                     num_nans_in_logits=request.num_nans_in_logits,
                     is_segment_finished=is_segment_finished,
                     new_prompt_len_snapshot=self._new_prompt_len_snapshot.get(req_id),
+                    num_generation_tokens=num_generation_tokens,
                 )
             else:
                 # Invariant: EngineCore returns no partial prefill outputs.
@@ -755,9 +822,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                     if req_id in self.waiting_for_transfer_free:
                         req = self.requests.get(req_id)
                         if req:
-                            self.kv_cache_manager.free(req)
-                            if req_id in self.requests:
-                                del self.requests[req_id]
+                            self._free_blocks(req)
                             if req_id in self.transfer_triggered_requests:
                                 self.transfer_triggered_requests.remove(req_id)
                             self.active_kv_transfers.discard(req_id)
@@ -856,7 +921,8 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                 # This streaming update has already been dequeued. Report the
                 # permanent contract failure so the next scheduling pass
                 # finishes only this request instead of crashing EngineCore.
-                self.chunk_transfer_adapter.record_receive_failure(req_id, str(exc))
+                if self.chunk_transfer_adapter is not None:
+                    self.chunk_transfer_adapter.record_receive_failure(req_id, str(exc))
                 return
             if replaced is not None:
                 if replaced:
@@ -1041,7 +1107,36 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         getattr(self, "_inflight_prefills", set()).discard(request)
 
         # 1. Standard cleanup parts from base _free_request
-        connector_delay_free_blocks, kv_xfer_params = self._connector_finished(request)
+        status = getattr(request, "status", None)
+        transfer_params = getattr(request, "kv_transfer_params", None)
+        native_transfer = (
+            transfer_params
+            and transfer_params.get("do_remote_decode")
+            and getattr(getattr(self.vllm_config, "kv_transfer_config", None), "kv_connector", None)
+            == "MooncakeConnector"
+        )
+        if native_transfer and status == RequestStatus.FINISHED_STOPPED:
+            request.status = RequestStatus.FINISHED_LENGTH_CAPPED
+        num_computed_tokens = None
+        if native_transfer:
+            # vLLM clips the block table with
+            # get_block_ids_for_computed_tokens(). Exclude Omni's optimistic
+            # async output placeholders from the physical transfer boundary.
+            num_computed_tokens = request.num_computed_tokens
+            request.num_computed_tokens = self._get_confirmed_num_computed_tokens(request)
+        try:
+            connector_delay_free_blocks, kv_xfer_params = self._connector_finished(request)
+        finally:
+            if num_computed_tokens is not None:
+                request.num_computed_tokens = num_computed_tokens
+            if status is not None:
+                request.status = status
+        if native_transfer and connector_delay_free_blocks:
+            kv_xfer_params = {
+                **(kv_xfer_params or {}),
+                "transfer_id": transfer_params["transfer_id"],
+                "num_transfer_tokens": self._get_confirmed_num_computed_tokens(request),
+            }
 
         # EC Connector: mirror the KV hook (upstream v0.28 _free_request).
         # The contract requires firing before the encoder cache is freed so
diff --git a/vllm_omni/core/sched/omni_generation_scheduler.py b/vllm_omni/core/sched/omni_generation_scheduler.py
index db0eedcf7..9ec55ddf7 100644
--- a/vllm_omni/core/sched/omni_generation_scheduler.py
+++ b/vllm_omni/core/sched/omni_generation_scheduler.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import time
 from collections import defaultdict
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from vllm.compilation.cuda_graph import CUDAGraphStat
 from vllm.logger import init_logger
@@ -15,11 +15,7 @@ from vllm.v1.core.sched.output import SchedulerOutput
 from vllm.v1.core.sched.request_queue import create_request_queue
 from vllm.v1.core.sched.scheduler import Scheduler as VLLMScheduler
 from vllm.v1.core.sched.utils import remove_all
-from vllm.v1.engine import (
-    EngineCoreEventType,
-    EngineCoreOutput,
-    EngineCoreOutputs,
-)
+from vllm.v1.engine import EngineCoreEventType, EngineCoreOutput, EngineCoreOutputs
 from vllm.v1.metrics.perf import PerfStats
 from vllm.v1.request import Request, RequestStatus, StreamingUpdate
 from vllm.v1.spec_decode.metrics import SpecDecodingStats
@@ -27,12 +23,33 @@ from vllm.v1.spec_decode.metrics import SpecDecodingStats
 from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
 from vllm_omni.core.sched.output import OmniCachedRequestData, OmniNewRequestData
 from vllm_omni.core.sched.utils import omni_routed_experts_for_request
+from vllm_omni.engine.serialization import deserialize_additional_information
 from vllm_omni.outputs import OmniModelRunnerOutput
 
+if TYPE_CHECKING:
+    from vllm.v1.core.sched.request_queue import RequestQueue
+
+
 logger = init_logger(__name__)
 
 
+def _has_async_chunk_payload_to_run(request: Request) -> bool:
+    additional_information = getattr(request, "additional_information", None)
+    if not isinstance(additional_information, dict):
+        additional_information = deserialize_additional_information(additional_information)
+
+    codes = additional_information.get("codes")
+    audio = codes.get("audio") if isinstance(codes, dict) else additional_information.get("codes.audio")
+    if audio is None:
+        return False
+    if hasattr(audio, "numel"):
+        return bool(audio.numel())
+    return bool(audio)
+
+
 class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
+    waiting: RequestQueue
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         model_config = self.vllm_config.model_config
@@ -40,6 +57,25 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         self._retains_state_across_chunks = bool(getattr(model_config, "retains_state_across_chunks", False))
         self._pending_finish_reqs: list[Request] = []
 
+    def _is_done_receiving_chunks(self, request_id: str) -> bool:
+        if self.chunk_transfer_adapter is not None:
+            return self.chunk_transfer_adapter.is_done_receiving_chunks(request_id)
+        coordinator = self.input_coordinator
+        return bool(self._native_data_plane and coordinator is not None and request_id in coordinator.finished_requests)
+
+    def _input_execution_is_terminal(
+        self,
+        request_id: str,
+        scheduler_output: SchedulerOutput,
+    ) -> bool:
+        if self._native_data_plane:
+            return request_id in getattr(
+                scheduler_output,
+                "input_terminal_req_ids",
+                set(),
+            )
+        return self._is_done_receiving_chunks(request_id)
+
     @staticmethod
     def _record_prefill_stats(request: Request) -> None:
         """Mirror upstream first-prefill prompt accounting for generation stages.
@@ -73,6 +109,29 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             return False
         return super()._handle_stopped_request(request)
 
+    def _requeue_completed_native_chunks(self) -> None:
+        """Return completed native generation chunks to the admission queue.
+
+        A generation batch slot belongs to one chunk, not the entire stream.
+        Keep requests with outstanding output in ``running`` so their state
+        cannot be reused before completion. Other live requests join the tail
+        of ``waiting`` without freeing their decoder state or KV blocks.
+        Preserve WAITING_FOR_CHUNK until the coordinator observes fresh input.
+        Stateful codecs retain lifetime admission until their decoder state is
+        released, even when no chunk is currently executing.
+        """
+        if not getattr(self, "_native_data_plane", False) or self._retains_state_across_chunks:
+            return
+        in_flight: list[Request] = []
+        for request in self.running:
+            if request.num_in_flight_tokens > 0 or request.is_finished():
+                in_flight.append(request)
+                continue
+            if request.status == RequestStatus.RUNNING:
+                request.status = RequestStatus.WAITING
+            self.waiting.add_request(request)
+        self.running = in_flight
+
     def schedule(self, throttle_prefills: bool = False) -> SchedulerOutput:
         """One-shot generation fast path:
         - Feed all input tokens of the request at once
@@ -82,6 +141,7 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         """
 
         token_budget = self.max_num_scheduled_tokens
+        execution_batch_size = self.max_num_running_reqs
         if self._pause_state == PauseState.PAUSED_ALL:
             token_budget = 0
         scheduled_timestamp = time.monotonic()
@@ -102,14 +162,22 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         skipped_waiting_requests = create_request_queue(self.policy)
         req_index = 0
         self._drop_aborted_queued_requests()
+        self._requeue_completed_native_chunks()
         self._process_pending_omni_inputs(model_mode="generation")
         self._drop_aborted_queued_requests()
         self._resync_streaming_input_counter()
+        async_chunk_transport = self._async_chunk_transport_enabled()
+        native_chunks = bool(getattr(self, "_native_data_plane", False))
+        # Parking releases an execution slot, but stateful codecs retain their
+        # request-owned state until completion or abort, in either runner.
+        reserved_running_slots = (
+            self._get_async_chunk_reserved_running_slots() if self._retains_state_across_chunks else 0
+        )
 
         # OMNI: Track requests that are already finished (e.g., marked by connector)
         # These should be removed from running and not scheduled
         already_finished_reqs: set[Request] = set()
-        while req_index < len(self.running) and token_budget > 0:
+        while req_index < len(self.running) and token_budget > 0 and len(num_scheduled_tokens) < execution_batch_size:
             request = self.running[req_index]
             # OMNI: Skip requests that are not in self.requests
             if request.request_id not in self.requests or (
@@ -119,6 +187,12 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                 req_index += 1
                 continue
 
+            if native_chunks and request.num_in_flight_tokens > 0:
+                # Overlap different streams, never two stateful chunks from
+                # the same stream. Readiness remains pending for the next step.
+                req_index += 1
+                continue
+
             num_computed_tokens = request.num_computed_tokens
             required_tokens = len(request.prompt_token_ids) - num_computed_tokens
             if not self.scheduler_config.enable_chunked_prefill and required_tokens > token_budget:
@@ -127,12 +201,16 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                 break
             # async_chunk: don't schedule placeholder tokens when no new chunk is available.
             if required_tokens <= 0:
-                if self.chunk_transfer_adapter is not None and self.chunk_transfer_adapter.is_done_receiving_chunks(
-                    request.request_id
-                ):
-                    self._pending_finish_reqs.append(request)
-                req_index += 1
-                continue
+                if async_chunk_transport and self._is_done_receiving_chunks(request.request_id):
+                    if len(request.prompt_token_ids) == 0 and _has_async_chunk_payload_to_run(request):
+                        required_tokens = 1
+                    else:
+                        self._pending_finish_reqs.append(request)
+                        req_index += 1
+                        continue
+                else:
+                    req_index += 1
+                    continue
             num_new_tokens = min(required_tokens, token_budget)
             new_blocks = self.kv_cache_manager.allocate_slots(
                 request,
@@ -161,20 +239,27 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         if already_finished_reqs:
             self.running = remove_all(self.running, already_finished_reqs)
 
-        # Fast path selection and scheduling for one-shot generation requests,
-        # independent of pooling_params.
-        while self.waiting and token_budget > 0 and self._pause_state == PauseState.UNPAUSED:
-            # Requests waiting for their next chunk are temporarily absent
-            # from `running`, but stateful models still retain their model
-            # runner slot. Mirror vLLM's treatment of
-            # `num_waiting_for_streaming_input` when enforcing max_num_seqs.
-            num_running = len(self.running)
-            if self._retains_state_across_chunks and self.chunk_transfer_adapter is not None:
-                num_running += self.chunk_transfer_adapter.num_running_waiting_for_chunk
-            if num_running >= self.max_num_running_reqs:
-                break
-
+        # Fast path selection and scheduling (treat all as diffusion requests,
+        # independent of pooling_params)
+        while (
+            self.waiting
+            and token_budget > 0
+            and len(num_scheduled_tokens) < execution_batch_size
+            and (
+                len(num_scheduled_tokens)
+                if native_chunks and not self._retains_state_across_chunks
+                else len(self.running) + reserved_running_slots
+            )
+            < self.max_num_running_reqs
+            and self._pause_state == PauseState.UNPAUSED
+        ):
             request = self.waiting.peek_request()
+            if native_chunks and request.num_in_flight_tokens > 0:
+                # A restored waiting entry can still own an outstanding batch.
+                # Do not let it block other ready streams or execute it twice.
+                self.waiting.pop_request()
+                skipped_waiting_requests.add_request(request)
+                continue
             # OMNI: Skip requests that are not in self.requests
             if request.request_id not in self.requests or (
                 self.chunk_transfer_adapter is None and request.status == RequestStatus.FINISHED_STOPPED
@@ -184,11 +269,12 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                 continue
 
             # async_chunk: wait for the first upstream chunk (don't start with placeholders).
-            if self.chunk_transfer_adapter is not None and len(request.prompt_token_ids) == 0:
-                if self.chunk_transfer_adapter.is_done_receiving_chunks(request.request_id):
-                    self.waiting.pop_request()
-                    self._pending_finish_reqs.append(request)
-                    continue
+            if async_chunk_transport and len(request.prompt_token_ids) == 0:
+                if self._is_done_receiving_chunks(request.request_id):
+                    if not _has_async_chunk_payload_to_run(request):
+                        self.waiting.pop_request()
+                        self._pending_finish_reqs.append(request)
+                        continue
                 else:
                     self.waiting.pop_request()
                     skipped_waiting_requests.prepend_request(request)
@@ -197,6 +283,22 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             # Allocate all input tokens for the request in one shot
             # (allocate 1 placeholder if zero)
             required_tokens = max(len(request.prompt_token_ids), 1)
+            if native_chunks:
+                required_tokens = len(request.prompt_token_ids) - request.num_computed_tokens
+                if required_tokens <= 0:
+                    if (
+                        self._is_done_receiving_chunks(request.request_id)
+                        and not request.prompt_token_ids
+                        and _has_async_chunk_payload_to_run(request)
+                    ):
+                        required_tokens = 1
+                    else:
+                        self.waiting.pop_request()
+                        if self._is_done_receiving_chunks(request.request_id):
+                            self._pending_finish_reqs.append(request)
+                        else:
+                            skipped_waiting_requests.add_request(request)
+                        continue
             num_new_tokens = min(required_tokens, token_budget)
             new_blocks = self.kv_cache_manager.allocate_slots(
                 request,
@@ -229,7 +331,7 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
 
         # If fast path scheduled none, fall back to the original scheduling
         if not num_scheduled_tokens:
-            if self.chunk_transfer_adapter:
+            if async_chunk_transport:
                 # Don't fall back: base scheduler doesn't handle async_chunk
                 # requests with empty prompt_token_ids.
                 self._restore_omni_wait_queues()
@@ -245,7 +347,7 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             any_request = self.running[0]
             num_common_prefix_blocks = self.kv_cache_manager.get_num_common_prefix_blocks(any_request.request_id)
 
-        # Assemble SchedulerOutput (align with v0.14.0)
+        # Assemble the current SchedulerOutput contract.
         if self.use_v2_model_runner:
             # No resumed reqs in fast path; pass prefill_token_ids for new reqs.
             new_reqs_data = [
@@ -284,7 +386,7 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
 
         total_num_scheduled_tokens = sum(num_scheduled_tokens.values())
 
-        # Record the request ids scheduled in this step (v0.14.0 behavior).
+        # Record request ids scheduled in this step for the next update.
         self.prev_step_scheduled_req_ids.clear()
         self.prev_step_scheduled_req_ids.update(num_scheduled_tokens.keys())
 
@@ -404,7 +506,7 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             assert num_tokens_scheduled > 0
             request = self.requests.get(req_id)
             if request is not None:
-                # vLLM 0.26: settle the in-flight tokens counted in schedule().
+                # Settle the in-flight tokens counted in schedule().
                 # Must happen before the skips below — failed-KV-load and
                 # already-finished requests were incremented too, and the two
                 # readers (allocate_slots, _connector_finished) clamp with
@@ -496,10 +598,16 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             if (
                 request.status == RequestStatus.FINISHED_ERROR
                 or request.status == RequestStatus.FINISHED_STOPPED
-                or (self.chunk_transfer_adapter is None and request.num_computed_tokens >= request.num_prompt_tokens)
                 or (
-                    self.chunk_transfer_adapter is not None
-                    and self.chunk_transfer_adapter.is_done_receiving_chunks(request.request_id)
+                    not self._async_chunk_transport_enabled()
+                    and request.num_computed_tokens >= request.num_prompt_tokens
+                )
+                or (
+                    self._async_chunk_transport_enabled()
+                    and self._input_execution_is_terminal(
+                        request.request_id,
+                        scheduler_output,
+                    )
                     and request.num_computed_tokens >= len(request.prompt_token_ids)
                 )
             ):
@@ -526,6 +634,8 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                 finish_reason = request.get_finished_reason()
                 finished = self._handle_stopped_request(request)
                 is_segment_finished = not finished
+                if finished and self._native_data_plane:
+                    self._pending_data_plane_terminal_req_ids.add(req_id)
                 if not finished:
                     # for streaming input request only
                     if self.chunk_transfer_adapter:
diff --git a/vllm_omni/core/sched/omni_scheduler_mixin.py b/vllm_omni/core/sched/omni_scheduler_mixin.py
index f33359835..d714d2665 100644
--- a/vllm_omni/core/sched/omni_scheduler_mixin.py
+++ b/vllm_omni/core/sched/omni_scheduler_mixin.py
@@ -5,17 +5,20 @@ from __future__ import annotations
 
 import math
 import os
+import queue
 import time
 from collections.abc import Iterable, Iterator
 from typing import Any
 
 import torch
 from vllm.compilation.cuda_graph import CUDAGraphStat
+from vllm.config import VllmConfig
 from vllm.distributed.kv_events import KVEventBatch
 from vllm.distributed.kv_transfer.kv_connector.v1.metrics import KVConnectorStats
 from vllm.logger import init_logger
 from vllm.utils.import_utils import resolve_obj_by_qualname
 from vllm.v1.core.sched.output import SchedulerOutput
+from vllm.v1.core.sched.request_queue import RequestQueue
 from vllm.v1.core.sched.utils import remove_all
 from vllm.v1.engine import (
     EngineCoreEventType,
@@ -31,6 +34,7 @@ from vllm.v1.spec_decode.metrics import SpecDecodingStats
 from vllm_omni.core.sched.omni_scheduling_coordinator import (
     OmniSchedulingCoordinator,
     uses_full_payload_input_coordinator,
+    uses_native_mrv2_data_plane,
 )
 from vllm_omni.core.sched.output import (
     OmniChunkRecvHandle,
@@ -41,6 +45,8 @@ from vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapt
     OmniChunkTransferAdapter,
 )
 from vllm_omni.engine import OmniEngineCoreOutput
+from vllm_omni.engine.serialization import serialize_additional_information
+from vllm_omni.outputs import OmniConnectorOutput
 
 logger = init_logger(__name__)
 
@@ -101,6 +107,19 @@ elif DEFAULT_INPUT_WAIT_TIMEOUT_S == 0:
 class OmniSchedulerMixin:
     """Shared scheduler helpers for omni-specific request handling."""
 
+    # Provided by the concrete vLLM scheduler.
+    vllm_config: VllmConfig
+    requests: dict[str, Request]
+    waiting: RequestQueue
+    running: list[Request]
+
+    def _init_omni_connector_output_inbox(self) -> None:
+        self._omni_connector_output_inbox: queue.SimpleQueue[OmniConnectorOutput] = queue.SimpleQueue()
+
+    def enqueue_omni_connector_output(self, output: OmniConnectorOutput) -> None:
+        """Accept a lightweight readiness event from the local runner thread."""
+        self._omni_connector_output_inbox.put(output)
+
     # ------------------------------------------------------------------ #
     #  Shared scheduler/output helpers (lift the AR / generation duplicates)
     # ------------------------------------------------------------------ #
@@ -119,15 +138,30 @@ class OmniSchedulerMixin:
             self.use_v2_model_runner = False
 
         model_config = self.vllm_config.model_config
-        self.chunk_transfer_adapter = (
-            OmniChunkTransferAdapter(self.vllm_config) if getattr(model_config, "async_chunk", False) else None
+        self.use_v2_model_runner = bool(getattr(model_config, "use_v2_model_runner", False))
+        self._native_data_plane = uses_native_mrv2_data_plane(
+            model_config,
+            use_v2_model_runner=self.use_v2_model_runner,
         )
-        self.input_coordinator = (
-            OmniSchedulingCoordinator(stage_id=getattr(model_config, "stage_id", 0))
-            if uses_full_payload_input_coordinator(model_config)
+        self.chunk_transfer_adapter = (
+            OmniChunkTransferAdapter(self.vllm_config)
+            if getattr(model_config, "async_chunk", False) and not self._native_data_plane
             else None
         )
-        self._latest_omni_connector_output = None
+        self.input_coordinator: OmniSchedulingCoordinator | None = None
+        if self._native_data_plane:
+            self.input_coordinator = OmniSchedulingCoordinator(
+                scheduler_max_num_seqs=self.vllm_config.scheduler_config.max_num_seqs,
+                stage_id=getattr(model_config, "stage_id", 0),
+                async_chunk=True,
+            )
+        elif uses_full_payload_input_coordinator(model_config):
+            self.input_coordinator = OmniSchedulingCoordinator(
+                stage_id=getattr(model_config, "stage_id", 0),
+            )
+        self._latest_omni_connector_output: OmniConnectorOutput | None = None
+        self._init_omni_connector_output_inbox()
+        self._pending_data_plane_terminal_req_ids: set[str] = set()
         # Optional per-stage pooling-output decoder hook (dotted path in
         # model_config); applied worker-side before IPC.
         self._pooling_output_decoder = None
@@ -214,6 +248,35 @@ class OmniSchedulerMixin:
         session.num_prompt_tokens = len(new_prompt)
         self._finish_streaming_session_update(session, update)
 
+    def _async_chunk_transport_enabled(self) -> bool:
+        return getattr(self, "chunk_transfer_adapter", None) is not None or bool(
+            getattr(self, "_native_data_plane", False)
+        )
+
+    def _get_async_chunk_reserved_running_slots(self) -> int:
+        adapter = getattr(self, "chunk_transfer_adapter", None)
+        live_requests = self.requests
+        reserved_ids: set[str] = set()
+        if adapter is not None:
+            parked = getattr(adapter, "waiting_for_chunk_running_requests", ())
+            held = getattr(adapter, "_held_non_active", ())
+        else:
+            coordinator = getattr(self, "input_coordinator", None)
+            parked = getattr(coordinator, "_waiting_for_chunk_running", ())
+            held = ()
+        for request in parked:
+            req_id = getattr(request, "request_id", None)
+            if req_id is not None and req_id in live_requests:
+                reserved_ids.add(req_id)
+        for request in held:
+            req_id = getattr(request, "request_id", None)
+            if req_id is not None and req_id in live_requests:
+                reserved_ids.add(req_id)
+        return len(reserved_ids)
+
+    # ------------------------------------------------------------------ #
+    #  Shared scheduler/output helpers (lift the AR / generation duplicates)
+    # ------------------------------------------------------------------ #
     def _release_replaced_streaming_prompt_cache(self, session: Request) -> None:
         """Discard cache state that belongs to a replaced prompt."""
         # A prompt replacement is not a normal streaming extension: none of
@@ -259,19 +322,55 @@ class OmniSchedulerMixin:
         AR and generation schedulers except for the ``model_mode`` argument
         forwarded to ``update_request_metadata``.
         """
+        connector_outputs: list[OmniConnectorOutput] = []
+        inbox = getattr(self, "_omni_connector_output_inbox", None)
+        if inbox is not None:
+            while True:
+                try:
+                    connector_outputs.append(inbox.get_nowait())
+                except queue.Empty:
+                    break
         connector_output = getattr(self, "_latest_omni_connector_output", None)
         self._latest_omni_connector_output = None
+        if connector_output is not None:
+            connector_outputs.append(connector_output)
         input_coordinator = getattr(self, "input_coordinator", None)
         if input_coordinator is None:
             return
-        if connector_output and connector_output.request_metadata:
+        request_metadata: dict[str, dict[str, Any]] = {}
+        chunk_ready_req_ids: set[str] = set()
+        chunk_finished_req_ids: set[str] = set()
+        stage_recv_req_ids: set[str] = set()
+        for output in connector_outputs:
+            request_metadata.update(output.request_metadata)
+            chunk_ready_req_ids.update(output.chunk_ready_req_ids)
+            chunk_finished_req_ids.update(output.chunk_finished_req_ids)
+            stage_recv_req_ids.update(output.stage_recv_req_ids)
+        live_request_ids = self.requests.keys()
+        request_metadata = {
+            req_id: metadata for req_id, metadata in request_metadata.items() if req_id in live_request_ids
+        }
+        chunk_ready_req_ids.intersection_update(live_request_ids)
+        chunk_finished_req_ids.intersection_update(live_request_ids)
+        stage_recv_req_ids.intersection_update(live_request_ids)
+        if request_metadata:
             input_coordinator.update_request_metadata(
-                self.requests, connector_output.request_metadata, model_mode=model_mode
+                self.requests,
+                request_metadata,
+                model_mode=model_mode,
+            )
+        if input_coordinator._async_chunk:
+            input_coordinator.process_pending_chunks(
+                self.waiting,
+                self.running,
+                chunk_ready_req_ids,
+                chunk_finished_req_ids,
+            )
+        else:
+            input_coordinator.process_pending_full_payload_inputs(
+                self.waiting,
+                stage_recv_req_ids,
             )
-        input_coordinator.process_pending_full_payload_inputs(
-            self.waiting,
-            connector_output.stage_recv_req_ids if connector_output else set(),
-        )
 
     def _process_pending_omni_inputs(self, model_mode: str) -> None:
         """Apply pending connector inputs, timeouts, and async chunks."""
@@ -316,7 +415,7 @@ class OmniSchedulerMixin:
                 scheduler_requests=self.requests,
             )
         if self.input_coordinator:
-            self.input_coordinator.restore_queues(self.waiting)
+            self.input_coordinator.restore_queues(self.waiting, self.running)
 
     def _process_pending_input_timeouts(self) -> None:
         """Force-fail requests waiting on the full-payload coordinator too long.
@@ -458,6 +557,8 @@ class OmniSchedulerMixin:
         *,
         finished_requests_needing_kv_transfer: dict | None = None,
         pending_input_registrations: list[OmniChunkRecvHandle] | None = None,
+        data_plane_terminal_req_ids: set[str] | None = None,
+        input_terminal_req_ids: set[str] | None = None,
     ) -> OmniSchedulerOutput:
         """Wrap a base ``SchedulerOutput`` in ``OmniSchedulerOutput``.
 
@@ -468,11 +569,31 @@ class OmniSchedulerMixin:
         base_data = {name: getattr(base, name) for name in SchedulerOutput.__dataclass_fields__}
         input_coordinator = getattr(self, "input_coordinator", None)
         if pending_input_registrations is None:
-            pending_input_registrations = input_coordinator.pending_input_registrations if input_coordinator else []
+            if input_coordinator is None:
+                pending_input_registrations = []
+            elif input_coordinator._async_chunk:
+                pending_input_registrations = input_coordinator.pending_chunk_registrations
+            else:
+                pending_input_registrations = input_coordinator.pending_input_registrations
+        if data_plane_terminal_req_ids is None:
+            pending_terminal: set[str] = getattr(self, "_pending_data_plane_terminal_req_ids", set())
+            data_plane_terminal_req_ids = set(pending_terminal)
+            pending_terminal.clear()
+        if input_coordinator is not None:
+            scheduled_terminal_req_ids = input_coordinator.get_scheduled_input_terminal_req_ids(base)
+            if input_terminal_req_ids is None:
+                input_terminal_req_ids = scheduled_terminal_req_ids
+            else:
+                input_terminal_req_ids = set(input_terminal_req_ids).union(
+                    scheduled_terminal_req_ids,
+                )
+            input_coordinator.postprocess_scheduler_output(base)
         return OmniSchedulerOutput(
             **base_data,
             finished_requests_needing_kv_transfer=finished_requests_needing_kv_transfer or {},
             pending_input_registrations=pending_input_registrations,
+            data_plane_terminal_req_ids=data_plane_terminal_req_ids,
+            input_terminal_req_ids=input_terminal_req_ids or set(),
         )
 
     def _rewrap_scheduled_new_reqs(self, scheduler_output: SchedulerOutput) -> None:
@@ -520,8 +641,14 @@ class OmniSchedulerMixin:
         num_nans_in_logits: int = 0,
         is_segment_finished: bool | None = False,
         new_prompt_len_snapshot: int | None = None,
+        num_generation_tokens: int | None = None,
     ) -> OmniEngineCoreOutput:
         """Build the common request-output envelope used by LLM schedulers."""
+        pooling_output_payload = None
+        if isinstance(pooling_output, dict):
+            pooling_output_payload = serialize_additional_information(pooling_output)
+            pooling_output = None
+
         return OmniEngineCoreOutput(
             request_id=request.request_id,
             new_token_ids=new_token_ids,
@@ -529,6 +656,7 @@ class OmniSchedulerMixin:
             new_logprobs=new_logprobs,
             new_prompt_logprobs_tensors=new_prompt_logprobs_tensors,
             pooling_output=pooling_output,
+            pooling_output_payload=pooling_output_payload,
             multimodal_output=multimodal_output,
             stop_reason=stop_reason,
             events=request.take_events(),
@@ -540,6 +668,7 @@ class OmniSchedulerMixin:
             num_nans_in_logits=num_nans_in_logits,
             is_segment_finished=is_segment_finished,
             new_prompt_len_snapshot=new_prompt_len_snapshot,
+            num_generation_tokens=num_generation_tokens,
         )
 
     def _append_request_output(
@@ -953,10 +1082,10 @@ class OmniSchedulerMixin:
         self.running[:] = [req for req in self.running if keep_running(req)]
 
     def _drop_aborted_queued_requests(self) -> None:
-        for queue in (self.waiting, self.skipped_waiting):
-            aborted = [req for req in queue if req.status == RequestStatus.FINISHED_ABORTED]
+        for request_queue in (self.waiting, self.skipped_waiting):
+            aborted = [req for req in request_queue if req.status == RequestStatus.FINISHED_ABORTED]
             if aborted:
-                queue.remove_requests(aborted)
+                request_queue.remove_requests(aborted)
         self.running[:] = [req for req in self.running if req.status != RequestStatus.FINISHED_ABORTED]
 
     def _resync_streaming_input_counter(self) -> None:
diff --git a/vllm_omni/core/sched/omni_scheduling_coordinator.py b/vllm_omni/core/sched/omni_scheduling_coordinator.py
index 3d516f5e3..70b682ac0 100644
--- a/vllm_omni/core/sched/omni_scheduling_coordinator.py
+++ b/vllm_omni/core/sched/omni_scheduling_coordinator.py
@@ -1,11 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Scheduling-side coordination for full_payload input waiting.
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Scheduling-side coordination for chunk and full-payload input waiting.
 
-Manages WAITING_FOR_INPUT state transitions based on readiness signals
-from OmniConnectorOutput, without ever calling connector.put()/get().
-
-Chunk waiting (WAITING_FOR_CHUNK) lives on OmniChunkTransferAdapter.
+Manages WAITING_FOR_CHUNK and WAITING_FOR_INPUT state transitions based on
+readiness signals from OmniConnectorOutput, without calling connector I/O.
 """
 
 from __future__ import annotations
@@ -22,6 +20,18 @@ from vllm_omni.core.sched.output import OmniChunkRecvHandle
 logger = init_logger(__name__)
 
 
+def uses_native_mrv2_data_plane(
+    model_config: Any,
+    *,
+    use_v2_model_runner: bool,
+) -> bool:
+    return bool(
+        use_v2_model_runner
+        and getattr(model_config, "async_chunk", False)
+        and getattr(model_config, "supports_native_mrv2_data_plane", False)
+    )
+
+
 def uses_full_payload_input_coordinator(model_config: Any) -> bool:
     """Returns True if this stage parks pending requests in
     WAITING_FOR_INPUT awaiting a full_payload delivery on the worker connector.
@@ -38,7 +48,7 @@ def uses_full_payload_input_coordinator(model_config: Any) -> bool:
 
 
 class OmniSchedulingCoordinator:
-    """Pure-scheduling coordinator for full_payload input waiting.
+    """Pure-scheduling coordinator for chunk and full-payload input waiting.
 
     The Scheduler owns an instance of this class.  It consumes readiness
     signals produced by the Model Runner's ``OmniConnectorModelRunnerMixin``
@@ -46,12 +56,28 @@ class OmniSchedulingCoordinator:
     transitions accordingly.
     """
 
-    def __init__(self, stage_id: int = 0):
+    def __init__(
+        self,
+        scheduler_max_num_seqs: int = 0,
+        stage_id: int = 0,
+        async_chunk: bool = False,
+    ) -> None:
         self._stage_id = stage_id
+        self._scheduler_max_num_seqs = scheduler_max_num_seqs
+        self._async_chunk = async_chunk
 
         self.finished_requests: set[str] = set()
+        self.requests_with_ready_chunks: set[str] = set()
+        self.input_terminal_req_ids: set[str] = set()
         self._full_payload_input_received: set[str] = set()
 
+        self._waiting_for_chunk_waiting: deque[Any] = deque()
+        self._waiting_for_chunk_running: deque[Any] = deque()
+
+        # Request IDs that were newly registered for chunk recv this cycle.
+        # The engine/Model Runner should call register_chunk_recv() for these
+        # so the bg thread starts polling.
+        self.pending_chunk_registrations: list[OmniChunkRecvHandle] = []
         # Requests waiting for full_payload stage input (WAITING_FOR_INPUT).
         self._waiting_for_input: deque[Any] = deque()
         # Per-cycle list of minimal handles to ship to the model runner so it
@@ -69,6 +95,47 @@ class OmniSchedulingCoordinator:
     #  Core scheduling methods
     # ------------------------------------------------------------------ #
 
+    def process_pending_chunks(
+        self,
+        waiting_queue: Any,
+        running_queue: list[Request],
+        chunk_ready_req_ids: set[str],
+        chunk_finished_req_ids: set[str],
+    ) -> None:
+        """Transition requests whose chunks have arrived.
+
+        Args:
+            waiting_queue: Scheduler's waiting request queue.
+            running_queue: Scheduler's running request list.
+            chunk_ready_req_ids: IDs with a newly arrived chunk this cycle.
+            chunk_finished_req_ids: IDs whose final chunk has arrived.
+        """
+        if self._stage_id == 0 or not self._async_chunk:
+            return
+
+        self.finished_requests.update(chunk_finished_req_ids)
+        self.pending_chunk_registrations = []
+
+        self._process_chunk_queue(
+            waiting_queue,
+            self._waiting_for_chunk_waiting,
+            RequestStatus.WAITING,
+            chunk_ready_req_ids,
+        )
+        self._process_chunk_queue(
+            running_queue,
+            self._waiting_for_chunk_running,
+            RequestStatus.RUNNING,
+            chunk_ready_req_ids,
+        )
+        while len(running_queue) > self._scheduler_max_num_seqs:
+            request = running_queue.pop()
+            # Must reset status to WAITING so the scheduler treats it as
+            # schedulable work.  KV blocks are NOT freed here (unlike a
+            # real preemption), so PREEMPTED would be incorrect.
+            request.status = RequestStatus.WAITING
+            waiting_queue.prepend_requests([request])
+
     def process_pending_full_payload_inputs(
         self,
         waiting_queue: Any,
@@ -144,10 +211,29 @@ class OmniSchedulingCoordinator:
             waiting_queue.remove_requests(to_remove)
 
     def free_finished_request(self, request_id: str) -> None:
-        """Prune internal tracking sets for a freed request to prevent unbounded growth."""
+        """Prune all coordinator state owned by a freed request."""
         self._full_payload_input_received.discard(request_id)
         self.finished_requests.discard(request_id)
+        self.requests_with_ready_chunks.discard(request_id)
+        self.input_terminal_req_ids.discard(request_id)
         self._waiting_since.pop(request_id, None)
+        for queue_attr in (
+            "_waiting_for_chunk_waiting",
+            "_waiting_for_chunk_running",
+            "_waiting_for_input",
+        ):
+            queue = getattr(self, queue_attr)
+            setattr(
+                self,
+                queue_attr,
+                deque(request for request in queue if request.request_id != request_id),
+            )
+        self.pending_chunk_registrations = [
+            handle for handle in self.pending_chunk_registrations if handle.request_id != request_id
+        ]
+        self.pending_input_registrations = [
+            handle for handle in self.pending_input_registrations if handle.request_id != request_id
+        ]
 
     def collect_timed_out_request_ids(
         self,
@@ -178,11 +264,14 @@ class OmniSchedulingCoordinator:
 
         # Defensively remove from coordinator internal queues (may already
         # be empty if restore_queues() has run).
-        remaining: deque[Any] = deque()
-        for request in self._waiting_for_input:
-            if request.request_id not in timed_out_ids:
-                remaining.append(request)
-        self._waiting_for_input = remaining
+        for queue_attr in (
+            "_waiting_for_chunk_waiting",
+            "_waiting_for_chunk_running",
+            "_waiting_for_input",
+        ):
+            queue = getattr(self, queue_attr)
+            remaining = deque(request for request in queue if request.request_id not in timed_out_ids)
+            setattr(self, queue_attr, remaining)
 
         for req_id in timed_out_ids:
             self._waiting_since.pop(req_id, None)
@@ -198,8 +287,17 @@ class OmniSchedulingCoordinator:
     def restore_queues(
         self,
         waiting_queue: Any,
+        running_queue: list[Request] | None = None,
     ) -> None:
-        """Return waiting-for-input requests to the waiting queue."""
+        """Return waiting-for-chunk/input requests to scheduling queues."""
+        for request in self._waiting_for_chunk_waiting:
+            waiting_queue.add_request(request)
+        self._waiting_for_chunk_waiting = deque()
+
+        if running_queue is not None and self._waiting_for_chunk_running:
+            running_queue.extend(self._waiting_for_chunk_running)
+        self._waiting_for_chunk_running = deque()
+
         for request in self._waiting_for_input:
             waiting_queue.add_request(request)
         self._waiting_for_input = deque()
@@ -247,6 +345,9 @@ class OmniSchedulingCoordinator:
             if request is None:
                 continue
 
+            if metadata.get("input_terminal") is True:
+                self.input_terminal_req_ids.add(req_id)
+
             # Handle next_stage_prompt_len if present (for models like Qwen3-Omni).
             # Only apply when the request has not started decoding yet
             # (no output tokens). Resetting a mid-decode request would
@@ -255,8 +356,7 @@ class OmniSchedulingCoordinator:
                 next_len = metadata["next_stage_prompt_len"]
                 if isinstance(next_len, int) and next_len > 0:
                     output_token_ids = getattr(request, "_output_token_ids", None)
-                    has_decode_output = output_token_ids is not None and len(output_token_ids) > 0
-                    if has_decode_output:
+                    if output_token_ids is not None and len(output_token_ids) > 0:
                         logger.debug(
                             "[Coordinator stage-%s] Skipping prompt resize for req %s: "
                             "request already has %s output tokens",
@@ -284,6 +384,12 @@ class OmniSchedulingCoordinator:
 
             if model_mode != "ar":
                 new_ids = self._flatten_prompt_token_ids(metadata.get("code_predictor_codes"))
+                runtime_seed = None
+                if "left_context_size" in metadata:
+                    runtime_seed = {
+                        "meta": {"left_context_size": metadata["left_context_size"]},
+                    }
+                request._omni_initial_model_buffer = runtime_seed
                 if new_ids:
                     request.prompt_token_ids = new_ids
                     request.num_prompt_tokens = len(new_ids)
@@ -291,3 +397,103 @@ class OmniSchedulingCoordinator:
                     request._all_token_ids.extend(new_ids)
                     request._output_token_ids.clear()
                     request.num_computed_tokens = 0
+
+    def postprocess_scheduler_output(
+        self,
+        scheduler_output: Any,
+        requests: dict[str, Request] | None = None,
+    ) -> None:
+        """Clear per-cycle ready state after scheduler output is materialized."""
+        self._clear_chunk_ready(scheduler_output)
+        self.input_terminal_req_ids.difference_update(
+            self._scheduled_request_ids(scheduler_output),
+        )
+
+    def get_scheduled_input_terminal_req_ids(
+        self,
+        scheduler_output: Any,
+    ) -> set[str]:
+        """Return terminal inputs executed by this immutable scheduler step."""
+        return self.input_terminal_req_ids.intersection(
+            self._scheduled_request_ids(scheduler_output),
+        )
+
+    @staticmethod
+    def _scheduled_request_ids(scheduler_output: Any) -> set[str]:
+        num_scheduled_tokens = getattr(
+            scheduler_output,
+            "num_scheduled_tokens",
+            None,
+        )
+        if num_scheduled_tokens is not None:
+            return set(num_scheduled_tokens)
+
+        request_ids = {req.req_id for req in getattr(scheduler_output, "scheduled_new_reqs", ())}
+        cached_reqs = getattr(scheduler_output, "scheduled_cached_reqs", None)
+        request_ids.update(getattr(cached_reqs, "req_ids", ()))
+        return request_ids
+
+    # ------------------------------------------------------------------ #
+    #  Internal helpers
+    # ------------------------------------------------------------------ #
+
+    def _process_chunk_queue(
+        self,
+        queue: Any,
+        waiting_for_chunk_list: deque[Any],
+        target_status: RequestStatus,
+        chunk_ready_req_ids: set[str],
+    ) -> None:
+        queue_snapshot = list(queue)
+        for request in queue_snapshot:
+            request_can_run = self._request_can_run(request, chunk_ready_req_ids)
+            if request.status != RequestStatus.WAITING_FOR_CHUNK:
+                if request_can_run:
+                    if request.request_id in chunk_ready_req_ids:
+                        self.requests_with_ready_chunks.add(request.request_id)
+                    continue
+                if request.status == RequestStatus.WAITING_FOR_INPUT:
+                    continue
+                self.pending_chunk_registrations.append(
+                    OmniChunkRecvHandle(
+                        request_id=request.request_id,
+                        external_req_id=getattr(request, "external_req_id", None),
+                    )
+                )
+                request.status = RequestStatus.WAITING_FOR_CHUNK
+                self._waiting_since.setdefault(request.request_id, time.monotonic())
+            else:
+                if request_can_run:
+                    request.status = target_status
+                    if request.request_id in chunk_ready_req_ids:
+                        self.requests_with_ready_chunks.add(request.request_id)
+                    self._waiting_since.pop(request.request_id, None)
+                    continue
+            if isinstance(queue, list):
+                queue.remove(request)
+            else:
+                queue.remove_request(request)
+            waiting_for_chunk_list.append(request)
+
+    def _request_can_run(
+        self,
+        request: Request,
+        chunk_ready_req_ids: set[str],
+    ) -> bool:
+        req_id = request.request_id
+        if req_id in self.finished_requests:
+            # Admit the final payload or terminal marker for cleanup.
+            return True
+
+        return req_id in chunk_ready_req_ids or req_id in self.requests_with_ready_chunks
+
+    def _clear_chunk_ready(self, scheduler_output: Any) -> None:
+        if scheduler_output.scheduled_new_reqs:
+            for req_data in scheduler_output.scheduled_new_reqs:
+                req_id = getattr(req_data, "req_id", None)
+                if req_id is not None:
+                    self.requests_with_ready_chunks.discard(req_id)
+
+        if scheduler_output.scheduled_cached_reqs:
+            for req_id in scheduler_output.scheduled_cached_reqs.req_ids:
+                self.requests_with_ready_chunks.discard(req_id)
diff --git a/vllm_omni/core/sched/output.py b/vllm_omni/core/sched/output.py
index deaf44df8..58aafea01 100644
--- a/vllm_omni/core/sched/output.py
+++ b/vllm_omni/core/sched/output.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from dataclasses import dataclass, field, fields
 
 from vllm.v1.core.sched.output import CachedRequestData, NewRequestData, SchedulerOutput
@@ -18,14 +21,14 @@ class OmniNewRequestData(NewRequestData):
 
     Args:
         external_req_id: Optional external request ID for tracking
-        additional_information: Optional serialized additional information
+        additional_information: Optional serialized or materialized additional information
             dictionary containing tensors or lists
         model_intermediate_buffer: Optional runner-owned payload for
             GPUModelRunner.model_intermediate_buffer
     """
 
     external_req_id: str | None = None
-    additional_information: AdditionalInformationPayload | None = None
+    additional_information: AdditionalInformationPayload | dict[str, object] | None = None
     model_intermediate_buffer: dict[str, object] | None = None
 
     @classmethod
@@ -114,3 +117,5 @@ class OmniSchedulerOutput(SchedulerOutput):
 
     finished_requests_needing_kv_transfer: dict[str, dict] = field(default_factory=dict)
     pending_input_registrations: list[OmniChunkRecvHandle] = field(default_factory=list)
+    data_plane_terminal_req_ids: set[str] = field(default_factory=set)
+    input_terminal_req_ids: set[str] = field(default_factory=set)
diff --git a/vllm_omni/core/sched/utils.py b/vllm_omni/core/sched/utils.py
index 7e0c16bd4..12cadae73 100644
--- a/vllm_omni/core/sched/utils.py
+++ b/vllm_omni/core/sched/utils.py
@@ -3,7 +3,9 @@
 """Shared utilities for omni schedulers."""
 
 import numpy as np
+from vllm.v1.core.kv_cache_manager import KVCacheManager
 from vllm.v1.outputs import RoutedExpertsLists
+from vllm.v1.request import Request
 
 
 def omni_routed_experts_for_request(routed_experts: RoutedExpertsLists, request) -> np.ndarray | None:
@@ -21,3 +23,19 @@ def omni_routed_experts_for_request(routed_experts: RoutedExpertsLists, request)
     mask = np.isin(routed_experts.slot_mapping, list(slot_set))
     data = routed_experts.routing_data[mask]
     return data if data.size > 0 else None
+
+
+def free_kv_blocks_in_physical_order(manager: KVCacheManager, request: Request) -> None:
+    """Return non-cached request blocks in increasing physical order.
+
+    vLLM's block pool deliberately honors the eviction-priority order passed
+    to ``free_blocks``.  For a non-caching P/D pool there is no LRU priority to
+    preserve, so physical order lets native connectors coalesce adjacent
+    source/destination pages on the next allocation.
+    """
+
+    if manager.enable_caching:
+        manager.free(request)
+        return
+    blocks = manager.pop_blocks_for_free(request)
+    manager.block_pool.free_blocks(sorted(blocks, key=lambda block: block.block_id))
diff --git a/vllm_omni/data_entry_keys.py b/vllm_omni/data_entry_keys.py
index 3e92eb37a..52c27f20e 100644
--- a/vllm_omni/data_entry_keys.py
+++ b/vllm_omni/data_entry_keys.py
@@ -34,9 +34,14 @@ class HiddenStates(TypedDict, total=False):
 
 
 class Embeddings(TypedDict, total=False):
+    prepared_prefill: torch.Tensor
     prefill: torch.Tensor
     decode: torch.Tensor
+    decode_token_start: int
+    decode_token_end: int
     cached_decode: torch.Tensor
+    cached_decode_token_start: int
+    cached_decode_token_end: int
     tts_bos: torch.Tensor
     tts_eos: torch.Tensor
     tts_pad: torch.Tensor
@@ -54,6 +59,7 @@ class Codes(TypedDict, total=False):
 
 
 class Ids(TypedDict, total=False):
+    prepared_prefill: torch.Tensor
     all: list[int]
     prompt: list[int]
     output: list[int]
@@ -81,6 +87,7 @@ class OmniPayloadMeta(TypedDict, total=False):
     next_stage_prompt_len: int
     next_stage_generation_tokens: int
     replace_streaming_prompt: bool
+    next_stage_prompt_ids: list[int]
     streaming_prompt_recompute: bool
     streaming_condition_seq: int
     replace_runtime_additional_information: bool
@@ -94,6 +101,7 @@ class OmniPayloadMeta(TypedDict, total=False):
     width: int
     decode_flag: bool
     codec_streaming: bool
+    codec_frame_valid: bool | torch.Tensor
     ref_code_len: int
     ref_context_size: int
     ref_context_request_id: str
@@ -148,6 +156,8 @@ class EmbeddingsStruct(_StructBase):
     decode_token_start: int | None = None
     decode_token_end: int | None = None
     cached_decode: torch.Tensor | None = None
+    cached_decode_token_start: int | None = None
+    cached_decode_token_end: int | None = None
     tts_bos: torch.Tensor | None = None
     tts_eos: torch.Tensor | None = None
     tts_pad: torch.Tensor | None = None
@@ -190,6 +200,7 @@ class MetaStruct(_StructBase):
     next_stage_prompt_len: int | None = None
     next_stage_generation_tokens: int | None = None
     replace_streaming_prompt: bool | None = None
+    next_stage_prompt_ids: list[int] | None = None
     streaming_prompt_recompute: bool | None = None
     streaming_condition_seq: int | None = None
     replace_runtime_additional_information: bool | None = None
@@ -203,6 +214,7 @@ class MetaStruct(_StructBase):
     width: int | None = None
     decode_flag: bool | None = None
     codec_streaming: bool | None = None
+    codec_frame_valid: torch.Tensor | None = None
     ref_code_len: int | None = None
     # Expected FINAL length of a growing async-chunk sequence, when the
     # producer knows it up front (e.g. a frame-locked AR stage whose
diff --git a/vllm_omni/deploy/audex_s2s.yaml b/vllm_omni/deploy/audex_s2s.yaml
index 861106315..e6635ec6c 100644
--- a/vllm_omni/deploy/audex_s2s.yaml
+++ b/vllm_omni/deploy/audex_s2s.yaml
@@ -14,7 +14,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/audex_s2s_30b.yaml b/vllm_omni/deploy/audex_s2s_30b.yaml
index 5921e8308..75b4c77ff 100644
--- a/vllm_omni/deploy/audex_s2s_30b.yaml
+++ b/vllm_omni/deploy/audex_s2s_30b.yaml
@@ -9,7 +9,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/audex_tta.yaml b/vllm_omni/deploy/audex_tta.yaml
index d5419e00b..8fe904f51 100644
--- a/vllm_omni/deploy/audex_tta.yaml
+++ b/vllm_omni/deploy/audex_tta.yaml
@@ -21,7 +21,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
       connector_get_max_wait: 300
diff --git a/vllm_omni/deploy/audex_tta_30b.yaml b/vllm_omni/deploy/audex_tta_30b.yaml
index 52c7fdc27..7547f09f9 100644
--- a/vllm_omni/deploy/audex_tta_30b.yaml
+++ b/vllm_omni/deploy/audex_tta_30b.yaml
@@ -9,7 +9,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
       connector_get_max_wait: 300
diff --git a/vllm_omni/deploy/audex_tts.yaml b/vllm_omni/deploy/audex_tts.yaml
index f0509ec30..df04f3004 100644
--- a/vllm_omni/deploy/audex_tts.yaml
+++ b/vllm_omni/deploy/audex_tts.yaml
@@ -26,7 +26,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/audex_tts_30b.yaml b/vllm_omni/deploy/audex_tts_30b.yaml
index a4aa2d4cc..aaa75fc15 100644
--- a/vllm_omni/deploy/audex_tts_30b.yaml
+++ b/vllm_omni/deploy/audex_tts_30b.yaml
@@ -26,7 +26,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/breeze_tts_2.yaml b/vllm_omni/deploy/breeze_tts_2.yaml
index 1d1b85391..fd75dd69e 100644
--- a/vllm_omni/deploy/breeze_tts_2.yaml
+++ b/vllm_omni/deploy/breeze_tts_2.yaml
@@ -32,8 +32,12 @@ stages:
       temperature: 0.0
       top_p: 1.0
       top_k: -1
+      # Match upstream's penalty on generated codebook-0 history.
+      repetition_penalty: 1.1
       max_tokens: 2048
-      min_tokens: 1
+      # min_tokens also masks the tokenizer's EOS 1 despite ignore_eos.
+      # Keep valid codec token 1 and an immediate backbone EOS available.
+      min_tokens: 0
 
   - stage_id: 1
     max_num_seqs: 8
diff --git a/vllm_omni/deploy/dots_tts.yaml b/vllm_omni/deploy/dots_tts.yaml
deleted file mode 100644
index acd28de52..000000000
--- a/vllm_omni/deploy/dots_tts.yaml
+++ /dev/null
@@ -1,28 +0,0 @@
-# dots.tts deployment config (single-stage AR talker).
-#
-# Conservative first-integration settings: eager execution, no CUDA
-# Graphs, no batched side-path optimizations yet — see voxcpm2.yaml for
-# the runtime knobs a mature deployment of this model family grows.
-#
-# Verified locally on RTX 5080 16GB.
-
-async_chunk: false
-dtype: bfloat16
-
-stages:
-  - stage_id: 0
-    max_num_seqs: 4
-    gpu_memory_utilization: 0.8
-    enforce_eager: true
-    trust_remote_code: true
-    enable_prefix_caching: false
-    async_scheduling: true
-    max_num_batched_tokens: 4096
-    max_model_len: 4096
-    devices: "0"
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 4096
-      repetition_penalty: 1.0
diff --git a/vllm_omni/deploy/dynin_omni.yaml b/vllm_omni/deploy/dynin_omni.yaml
deleted file mode 100644
index f7a457695..000000000
--- a/vllm_omni/deploy/dynin_omni.yaml
+++ /dev/null
@@ -1,38 +0,0 @@
-# Dynin-Omni 3-stage deploy: token2text → token2image → token2audio.
-#
-# Topology (stages, processor functions, model_arch) is frozen in
-# vllm_omni/model_executor/models/dynin_omni/pipeline.py. This file carries
-# only the deploy-time knobs (devices, GPU memory, batched tokens).
-#
-# async_chunk=false: dynin hands the full token payload across stages through
-# the worker-connector data plane (``*_full_payload`` producers), not chunked
-# streaming. Pipeline-wide ``trust_remote_code`` is required by the custom
-# Dynin HF modeling code.
-async_chunk: false
-trust_remote_code: true
-enable_prefix_caching: false
-
-stages:
-  - stage_id: 0
-    devices: "0"
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.5
-    max_num_batched_tokens: 32768
-    enforce_eager: true
-    async_scheduling: false
-
-  - stage_id: 1
-    devices: "0"
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.1
-    max_num_batched_tokens: 32768
-    enforce_eager: true
-    async_scheduling: false
-
-  - stage_id: 2
-    devices: "0"
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.1
-    max_num_batched_tokens: 32768
-    enforce_eager: true
-    async_scheduling: false
diff --git a/vllm_omni/deploy/dynin_omni_ci.yaml b/vllm_omni/deploy/dynin_omni_ci.yaml
deleted file mode 100644
index ce20c093b..000000000
--- a/vllm_omni/deploy/dynin_omni_ci.yaml
+++ /dev/null
@@ -1,35 +0,0 @@
-# Dynin-Omni deploy for e2e smoke tests (3-stage, one GPU).
-#
-# Topology is frozen in models/dynin_omni/pipeline.py; ``pipeline: dynin_omni``
-# pins it explicitly so this CI YAML resolves regardless of model_type
-# auto-detection. Differs from the default deploy only in reduced GPU memory
-# and a smaller max_num_batched_tokens so the pipeline fits L4-class CI GPUs.
-pipeline: dynin_omni
-async_chunk: false
-trust_remote_code: true
-enable_prefix_caching: false
-
-stages:
-  - stage_id: 0
-    devices: "0"
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.5
-    max_num_batched_tokens: 4096
-    enforce_eager: true
-    async_scheduling: false
-
-  - stage_id: 1
-    devices: "0"
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.2
-    max_num_batched_tokens: 4096
-    enforce_eager: true
-    async_scheduling: false
-
-  - stage_id: 2
-    devices: "0"
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.2
-    max_num_batched_tokens: 4096
-    enforce_eager: true
-    async_scheduling: false
diff --git a/vllm_omni/deploy/dynin_omni_multiconnector.yaml b/vllm_omni/deploy/dynin_omni_multiconnector.yaml
deleted file mode 100644
index 5abb4c5a3..000000000
--- a/vllm_omni/deploy/dynin_omni_multiconnector.yaml
+++ /dev/null
@@ -1,63 +0,0 @@
-# Dynin-Omni 3-stage deploy with cross-node connectors (Mooncake demo).
-#
-# Topology is frozen in models/dynin_omni/pipeline.py (``pipeline: dynin_omni``).
-# This variant wires a MooncakeConnector for each stage hand-off in place of
-# the default SharedMemoryConnector. Update the ``extra`` host/master/metadata
-# fields to match your Mooncake deployment before use.
-pipeline: dynin_omni
-async_chunk: false
-trust_remote_code: false
-enable_prefix_caching: false
-
-connectors:
-  # Mooncake connector for cross-node/intra-node communication.
-  mooncake_connector:
-    name: MooncakeConnector
-    extra:
-      host: "127.0.0.1"
-      metadata_server: "http://10.90.67.86:8080/metadata"
-      master: "10.90.67.86:50051"
-      segment: 512000000    # 512MB
-      localbuf: 64000000    # 64MB
-      proto: "tcp"
-
-  # Yuanrong connector for cross-node/intra-node communication.
-  yuanrong_connector:
-    name: YuanrongConnector
-    extra:
-      host: "127.0.0.1"
-      port: "35000"
-
-  # Alternative SHM connector with an explicit threshold.
-  shared_memory_connector:
-    name: SharedMemoryConnector
-
-stages:
-  - stage_id: 0
-    devices: "0"
-    max_num_seqs: 1
-    max_num_batched_tokens: 32768
-    enforce_eager: true
-    async_scheduling: false
-    output_connectors:
-      to_stage_1: mooncake_connector
-
-  - stage_id: 1
-    devices: "0"
-    max_num_seqs: 1
-    max_num_batched_tokens: 32768
-    enforce_eager: true
-    async_scheduling: false
-    input_connectors:
-      from_stage_0: mooncake_connector
-    output_connectors:
-      to_stage_2: mooncake_connector
-
-  - stage_id: 2
-    devices: "0"
-    max_num_seqs: 1
-    max_num_batched_tokens: 32768
-    enforce_eager: true
-    async_scheduling: false
-    input_connectors:
-      from_stage_1: mooncake_connector
diff --git a/vllm_omni/deploy/fish_qwen3_omni.yaml b/vllm_omni/deploy/fish_qwen3_omni.yaml
index f10ed1656..0f4866a1f 100644
--- a/vllm_omni/deploy/fish_qwen3_omni.yaml
+++ b/vllm_omni/deploy/fish_qwen3_omni.yaml
@@ -64,6 +64,15 @@ stages:
       repetition_penalty: 1.0
 
 platforms:
+  npu:
+    # Ascend paged attention only accepts 128-token cache blocks
+    # (AscendAttentionBackend.get_supported_kernel_block_sizes() == [128]),
+    # while vLLM's CacheConfig default is 16. Without this override stage 0
+    # aborts during KV-cache init with:
+    #   ValueError: No common block size for 16.
+    stages:
+      - stage_id: 0
+        block_size: 128
   xpu:
     stages:
       # Verified on Intel Arc B60.
diff --git a/vllm_omni/deploy/hunyuan-image-3-mooncakeconnector.yaml b/vllm_omni/deploy/hunyuan-image-3-mooncakeconnector.yaml
new file mode 100644
index 000000000..ea088f916
--- /dev/null
+++ b/vllm_omni/deploy/hunyuan-image-3-mooncakeconnector.yaml
@@ -0,0 +1,82 @@
+pipeline: hunyuan_image_3_moe
+async_chunk: false
+trust_remote_code: true
+
+stages:
+  - stage_id: 0
+    is_comprehension: true
+    # Return AR text (including CoT) alongside the final image.
+    final_output: true
+    final_output_type: text
+    num_replicas: 2
+    devices: "0,1,2,3"
+    tensor_parallel_size: 2
+    max_num_seqs: 1
+    max_num_batched_tokens: 32768
+    kv_cache_memory_bytes: 2147483648
+    gpu_memory_utilization: 0.95
+    enforce_eager: true
+    moe_backend: triton
+    env:
+      MC_TCP_ENABLE_CONNECTION_POOL: "1"
+      MC_TCP_SLICE_SIZE: "4194304"
+      VLLM_USE_FLASHINFER_SAMPLER: "0"
+    hf_overrides:
+      rope_parameters:
+        mrope_section: [0, 32, 32]
+        rope_type: default
+    kv_transfer_config:
+      kv_connector: MooncakeConnector
+      kv_role: kv_producer
+      engine_id: hunyuan-image3-ar
+      kv_ip: 127.0.0.1
+      kv_connector_extra_config:
+        mooncake_protocol: tcp
+        bootstrap_port: 8998
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      detokenize: true
+      skip_special_tokens: false
+      include_stop_str_in_output: true
+
+  - stage_id: 1
+    num_replicas: 2
+    devices: "4,5,6,7"
+    max_num_seqs: 1
+    max_num_batched_tokens: 16384
+    max_model_len: 12288
+    kv_cache_memory_bytes: 1073741824
+    enforce_eager: true
+    # Registered Mooncake KV pages must remain mapped for the connector lifetime.
+    enable_sleep_mode: false
+    moe_backend: triton
+    env:
+      MC_TCP_ENABLE_CONNECTION_POOL: "1"
+      MC_TCP_SLICE_SIZE: "4194304"
+      PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
+    distributed_executor_backend: mp
+    diffusion_kv_mode: paged_scheduler
+    diffusion_kv_max_rows_per_request: 2
+    kv_transfer_config:
+      kv_connector: MooncakeConnector
+      kv_role: kv_consumer
+      engine_id: hunyuan-image3-dit
+      kv_connector_extra_config:
+        mooncake_protocol: tcp
+        # Seconds to wait before failing a request; in-flight pages remain reserved.
+        transfer_timeout: 60.0
+    parallel_config:
+      tensor_parallel_size: 2
+      enable_expert_parallel: true
+    default_sampling_params:
+      num_inference_steps: 2
+      guidance_scale: 2.0
+      height: 512
+      width: 512
+
+edges:
+  - from: 0
+    to: 1
+    window_size: -1
+    max_inflight: 1
diff --git a/vllm_omni/deploy/hunyuan_image_3_moe.yaml b/vllm_omni/deploy/hunyuan_image_3_moe.yaml
index 4ae4520a7..657af0481 100644
--- a/vllm_omni/deploy/hunyuan_image_3_moe.yaml
+++ b/vllm_omni/deploy/hunyuan_image_3_moe.yaml
@@ -106,11 +106,14 @@ platforms:
 
   xpu:
     stages:
+      # Both stages stay resident, so they cannot share cards.
       - stage_id: 0
         gpu_memory_utilization: 0.95
-        devices: "0,1,2,3,4,5,6,7"
-        tensor_parallel_size: 8
-        max_num_batched_tokens: 32784
+        devices: "0,1,2,3"
+        tensor_parallel_size: 4
+        # fp8 AR weights leave under 1 GiB for KV; 22800 tokens will not fit.
+        max_num_batched_tokens: 8192
+        max_model_len: 8192
         quantization: fp8
         enable_expert_parallel: true
         worker_cls: vllm_omni.platforms.xpu.worker.xpu_ar_worker.XPUARWorker
@@ -120,12 +123,12 @@ platforms:
           repetition_penalty: 1.1
       - stage_id: 1
         gpu_memory_utilization: 0.9
-        devices: "0,1,2,3,4,5,6,7"
+        devices: "4,5,6,7"
         quantization: fp8
         parallel_config:
           pipeline_parallel_size: 1
           data_parallel_size: 1
-          tensor_parallel_size: 8
+          tensor_parallel_size: 4
           enable_expert_parallel: true
           sequence_parallel_size: 1
           ulysses_degree: 1
diff --git a/vllm_omni/deploy/mammoth_moda2.yaml b/vllm_omni/deploy/mammoth_moda2.yaml
index afae38ee0..76027424c 100644
--- a/vllm_omni/deploy/mammoth_moda2.yaml
+++ b/vllm_omni/deploy/mammoth_moda2.yaml
@@ -20,8 +20,3 @@ stages:
     enforce_eager: true
     trust_remote_code: true
     enable_prefix_caching: false
-    default_sampling_params:
-      extra_args:
-        text_guidance_scale: 9.0
-        cfg_range: [0.0, 1.0]
-        num_inference_steps: 50
diff --git a/vllm_omni/deploy/minicpmo_4_5.yaml b/vllm_omni/deploy/minicpmo_4_5.yaml
index 5c26fc2c6..07090660b 100644
--- a/vllm_omni/deploy/minicpmo_4_5.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5.yaml
@@ -1,8 +1,7 @@
 # MiniCPM-o 4.5 three-stage deploy on one large-memory GPU.
 pipeline: minicpmo_4_5
 async_chunk: true
-# session_mode: duplex makes vllm-omni serve run this model duplex-only
-# (/v1/realtime?duplex=1); every other duplex_session knob keeps its runtime default.
+# Use minicpmo_4_5_turn.yaml to select the ordinary turn-based serving engine.
 session_mode: duplex
 # Keep the active window aligned with the session and stage capacities below.
 # A smaller window serializes first-packet generation for concurrent chat turns.
@@ -48,7 +47,7 @@ stages:
         fps: 1
         num_frames: 128
     limit_mm_per_prompt:
-      # Daily-Omni MiniCPM pack: up to 64 interleaved image/audio pairs (1fps).
+      # Daily-Omni: up to 64 interleaved image/audio pairs (1fps).
       image: 64
       audio: 64
       video: 1
diff --git a/vllm_omni/deploy/minicpmo_4_5_turn.yaml b/vllm_omni/deploy/minicpmo_4_5_turn.yaml
new file mode 100644
index 000000000..8dada1257
--- /dev/null
+++ b/vllm_omni/deploy/minicpmo_4_5_turn.yaml
@@ -0,0 +1,3 @@
+# MiniCPM-o 4.5 using the turn-based engine and ordinary HTTP serving.
+base_config: minicpmo_4_5.yaml
+session_mode: turn
diff --git a/vllm_omni/deploy/minimax_music3.yaml b/vllm_omni/deploy/minimax_music3.yaml
index 6e8a13d9d..ba0101cde 100644
--- a/vllm_omni/deploy/minimax_music3.yaml
+++ b/vllm_omni/deploy/minimax_music3.yaml
@@ -25,7 +25,6 @@ connectors:
       # Window geometry is fixed by the checkpoint (200-frame windows on a
       # 100-frame hop, models/minimax_music3/constants.py), so there are no
       # codec_chunk_frames knobs here: changing the window changes the audio.
-      shm_threshold_bytes: 65536
       connector_get_sleep_s: 0.01
       # One window is 200 AR frames = 8 s of music, so stage 1 waits far longer
       # for a chunk than a per-step codec stage would. First chunk additionally
diff --git a/vllm_omni/deploy/minimax_music3_2gpu.yaml b/vllm_omni/deploy/minimax_music3_2gpu.yaml
index 8c463e0e7..fca04d04c 100644
--- a/vllm_omni/deploy/minimax_music3_2gpu.yaml
+++ b/vllm_omni/deploy/minimax_music3_2gpu.yaml
@@ -22,7 +22,6 @@ connectors:
       # Window geometry is fixed by the checkpoint (200-frame windows on a
       # 100-frame hop, models/minimax_music3/constants.py), so there are no
       # codec_chunk_frames knobs here: changing the window changes the audio.
-      shm_threshold_bytes: 65536
       connector_get_sleep_s: 0.01
       # One window is 200 AR frames = 8 s of music, so stage 1 waits far longer
       # for a chunk than a per-step codec stage would. First chunk additionally
diff --git a/vllm_omni/deploy/moss_tts.yaml b/vllm_omni/deploy/moss_tts.yaml
index 92bd2f3ba..229377431 100644
--- a/vllm_omni/deploy/moss_tts.yaml
+++ b/vllm_omni/deploy/moss_tts.yaml
@@ -57,3 +57,11 @@ stages:
       max_tokens: 65536
       seed: 42
       repetition_penalty: 1.0
+
+platforms:
+  rocm:
+    stages:
+      - stage_id: 1
+        # MIOPEN_FIND_MODE=FAST changes solver selection, not HIP graph safety.
+        # Keep the Conv1d codec outside the outer vLLM graph on ROCm.
+        enforce_eager: true
diff --git a/vllm_omni/deploy/moss_tts_local.yaml b/vllm_omni/deploy/moss_tts_local.yaml
index 5f0bf9a14..ad16a6dea 100644
--- a/vllm_omni/deploy/moss_tts_local.yaml
+++ b/vllm_omni/deploy/moss_tts_local.yaml
@@ -64,3 +64,14 @@ stages:
       max_tokens: 65536
       seed: 42
       repetition_penalty: 1.0
+
+# Stage 1 NPU override: PIECEWISE cudagraph for NPUGraph capture; set enforce_eager: true to disable.
+platforms:
+  npu:
+    stages:
+      - stage_id: 1
+        compilation_config:
+          cudagraph_mode: PIECEWISE
+          # Re-declared: _apply_platform_overrides() wholesale-replaces compilation_config.
+          cudagraph_capture_sizes: [1, 2, 4, 8, 16, 32, 64]
+          cudagraph_num_of_warmups: 1
diff --git a/vllm_omni/deploy/nemotron_labs_voicechat.yaml b/vllm_omni/deploy/nemotron_labs_voicechat.yaml
index 8c9ee8646..f03c07c8f 100644
--- a/vllm_omni/deploy/nemotron_labs_voicechat.yaml
+++ b/vllm_omni/deploy/nemotron_labs_voicechat.yaml
@@ -25,8 +25,6 @@ async_chunk: false
 connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
-    extra:
-      shm_threshold_bytes: 65536
 
 stages:
   - stage_id: 0  # thinker: speech -> frame-locked text (final text output)
diff --git a/vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml b/vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml
index 8927b1226..18ba3dca0 100644
--- a/vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml
+++ b/vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml
@@ -58,7 +58,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_chunk_frames: 1
       # PARITY: delete this line together with the stage-1 hf_overrides
       # below (the vendored talker drains chunks model-side and keeps the
diff --git a/vllm_omni/deploy/nemotron_labs_voicechat_streaming.yaml b/vllm_omni/deploy/nemotron_labs_voicechat_streaming.yaml
index 0a3ee158b..60e781d51 100644
--- a/vllm_omni/deploy/nemotron_labs_voicechat_streaming.yaml
+++ b/vllm_omni/deploy/nemotron_labs_voicechat_streaming.yaml
@@ -22,7 +22,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       # Streaming cadence for talker -> code2wav: emit a chunk once this many
       # NEW frames (80 ms each) have accumulated (5 frames = 0.4 s of audio).
       # Small chunks are cheap because the incremental codec cache decodes
diff --git a/vllm_omni/deploy/personaplex.yaml b/vllm_omni/deploy/personaplex.yaml
index 9f1da7e63..65cdec6d6 100644
--- a/vllm_omni/deploy/personaplex.yaml
+++ b/vllm_omni/deploy/personaplex.yaml
@@ -23,14 +23,9 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
-      connector_get_sleep_s: 0.01
-      connector_get_max_wait_first_chunk: 3000
-      connector_get_max_wait: 300
       # Mimi runs at 12.5 Hz (80 ms / frame). Stream a few frames per chunk.
       codec_chunk_frames: 5
-      codec_left_context_frames: 10
       # Emit only the first audio chunk early, then return to codec_chunk_frames.
       initial_codec_chunk_frames: 1
 
diff --git a/vllm_omni/deploy/pi05.yaml b/vllm_omni/deploy/pi05.yaml
new file mode 100644
index 000000000..aec8e88f0
--- /dev/null
+++ b/vllm_omni/deploy/pi05.yaml
@@ -0,0 +1,51 @@
+# π0.5 VLA: one diffusion stage, one GPU, eager, bsz 1 (OpenPI policy serving is
+# one observation -> one action reply). Every key below is documented in
+# recipes/lerobot/Pi05.md.
+
+pipeline: pi05
+async_chunk: false
+distributed_executor_backend: mp
+# float32 or bfloat16. bfloat16 is faster and halves memory at a numerical cost;
+# read "Choosing a dtype" in the recipe before switching.
+dtype: float32
+
+stages:
+  - stage_id: 0
+    devices: "0"
+    max_num_seqs: 1
+    enforce_eager: true
+    model_class_name: Pi05Pipeline
+    model_config:
+      paligemma_variant: gemma_2b
+      action_expert_variant: gemma_300m
+      chunk_size: 50
+      # Must equal chunk_size: this endpoint returns the whole chunk and keeps no
+      # action queue, so "execute the first N steps, then replan" is not available.
+      n_action_steps: 50
+      max_action_dim: 32
+      max_state_dim: 32
+      num_inference_steps: 10
+      image_resolution: [224, 224]
+      tokenizer_max_length: 200
+      state_num_bins: 256
+      max_cameras: 3
+      image_feature_keys:
+        - observation.images.base_0_rgb
+        - observation.images.left_wrist_0_rgb
+        - observation.images.right_wrist_0_rgb
+      image_key_map: {}
+      use_relative_actions: false
+      relative_exclude_joints:
+        - gripper
+      # OpenPI handshake metadata advertised to the robot client.
+      policy_server_config:
+        image_resolution: [224, 224]
+        n_external_cameras: 1
+        needs_wrist_camera: true
+        needs_stereo_camera: false
+        needs_session_id: false
+        action_space: joint_position
+        action_horizon: 50
+        action_dim: 32
+        max_action_dim: 32
+        max_cameras: 3
diff --git a/vllm_omni/deploy/qwen3_omni_duplex.yaml b/vllm_omni/deploy/qwen3_omni_duplex.yaml
new file mode 100644
index 000000000..31bfcaadb
--- /dev/null
+++ b/vllm_omni/deploy/qwen3_omni_duplex.yaml
@@ -0,0 +1,8 @@
+# Concurrent input / interruptible VAD turns; not native streaming input KV.
+base_config: qwen3_omni_moe.yaml
+session_mode: duplex
+stages:
+  - stage_id: 0
+    limit_mm_per_prompt:
+      audio: 4
+      image: 8
diff --git a/vllm_omni/deploy/qwen3_tts.yaml b/vllm_omni/deploy/qwen3_tts.yaml
index 4019f10aa..8f5ab584d 100644
--- a/vllm_omni/deploy/qwen3_tts.yaml
+++ b/vllm_omni/deploy/qwen3_tts.yaml
@@ -63,11 +63,12 @@ stages:
     max_num_seqs: 64
     gpu_memory_utilization: 0.3
     trust_remote_code: true
-    # Prefix caching on by default. The HS opt-out (talker only consumes the
-    # last token's hidden state) and deferred mm-output writes added in this
-    # PR make per-step bookkeeping negligible, and any text repetition across
-    # requests (same voice or shared ref_audio) is a net throughput win.
-    # Disable explicitly if memory headroom is tight on a single-GPU deploy.
+    # Omni prefix cache (reuse of talker codec rows on shared prefixes). Off
+    # by default; set true when text repeats across requests (same voice or
+    # shared ref_audio). The talker opts out of hidden-state caching and
+    # defers codes.audio writes, so per-step cost is small. Stage 1 (codec
+    # decoder) is not a supported prefix-cache stage: keep it false there.
+    # See docs/design/feature/prefix_caching.md for the stage matrix.
     enable_prefix_caching: false
     async_scheduling: true
     max_num_batched_tokens: 32768
diff --git a/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml b/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
index 7914ecd52..36c85e41d 100644
--- a/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
+++ b/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
@@ -9,6 +9,15 @@
 # Profile validated for the c64 / PROMPTS=512 performance experiments:
 # Stage 0 talker on GPU 0 with S0=64, Stage 1 Code2Wav on GPU 1 with S1=10.
 #
+# For CPU-bound frontend or orchestration workloads, this profile can be used
+# with ``--api-server-count 2`` or higher to run multiple API frontends over
+# one shared set of local stage engines. This can improve request parsing,
+# multimodal/audio preprocessing, and response handling under concurrency;
+# it does not duplicate GPU engines or make a single GPU-bound request faster.
+# Each frontend keeps process-local state, so runtime voice mutations, sleep /
+# wakeup, async video jobs, and resumable duplex sessions are not supported
+# with more than one API worker. See docs/cli/serve.md for the full boundary.
+#
 async_chunk: true
 
 connectors:
diff --git a/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2.yaml b/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2.yaml
new file mode 100644
index 000000000..b6ebcf67f
--- /dev/null
+++ b/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2.yaml
@@ -0,0 +1,28 @@
+# Opt-in CUDA Model Runner V2 profile. The base profile retains V1.
+base_config: qwen3_tts_high_concurrency.yaml
+model_runner: v2
+
+platforms:
+  npu:
+    model_runner: v1
+  xpu:
+    model_runner: v1
+  rocm:
+    model_runner: v1
+  musa:
+    model_runner: v1
+
+connectors:
+  connector_of_shared_memory:
+    extra:
+      # Keep unqualified prefix-graph optimizations disabled in this profile.
+      code_predictor_prefix_graphs: false
+      ref_audio_artifact_cache_max_entries: 1024
+      # Opt-in B2 codec graphs. Validate quality for the deployment workload.
+      decode_batch_max_size: 2
+      decode_cudagraph_batch_sizes: [1, 2]
+
+stages:
+  - stage_id: 1
+    # Enable the decoder's inner graphs; the generation runner stays eager.
+    enforce_eager: false
diff --git a/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_b4.yaml b/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_b4.yaml
new file mode 100644
index 000000000..4551e35d9
--- /dev/null
+++ b/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_b4.yaml
@@ -0,0 +1,8 @@
+# Experimental B4 profile. Early first audio can require startup buffering.
+# MPS is a separate operator setting and is not enabled by this file.
+base_config: qwen3_tts_high_concurrency_mrv2.yaml
+connectors:
+  connector_of_shared_memory:
+    extra:
+      decode_batch_max_size: 4
+      decode_cudagraph_batch_sizes: [1, 2, 3, 4]
diff --git a/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_single_gpu.yaml b/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_single_gpu.yaml
new file mode 100644
index 000000000..da6a90cf4
--- /dev/null
+++ b/vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_single_gpu.yaml
@@ -0,0 +1,23 @@
+# Opt-in single-GPU throughput profile, measured on H200 at concurrency 128
+# with Qwen3-TTS-12Hz-1.7B-Base. Warm the full pipeline before benchmarking.
+# B8 uses more graph memory than B4; this is not a low-latency profile.
+# MPS is optional and is not enabled by this file.
+#
+# vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-Base --omni \
+#   --deploy-config vllm_omni/deploy/qwen3_tts_high_concurrency_mrv2_single_gpu.yaml
+base_config: qwen3_tts_high_concurrency_mrv2.yaml
+
+connectors:
+  connector_of_shared_memory:
+    extra:
+      decode_batch_max_size: 8
+      decode_cudagraph_batch_sizes: [1, 2, 3, 4, 5, 6, 7, 8]
+
+stages:
+  - stage_id: 0
+    devices: "0"
+    max_num_seqs: 128
+  - stage_id: 1
+    devices: "0"
+    # Admission candidates are grouped by codec phase before B8 execution.
+    max_num_seqs: 32
diff --git a/vllm_omni/deploy/qwen3_tts_mrv2.yaml b/vllm_omni/deploy/qwen3_tts_mrv2.yaml
new file mode 100644
index 000000000..228076c8e
--- /dev/null
+++ b/vllm_omni/deploy/qwen3_tts_mrv2.yaml
@@ -0,0 +1,18 @@
+# Opt-in CUDA Model Runner V2 profile. The base profile retains V1.
+base_config: qwen3_tts.yaml
+model_runner: v2
+
+platforms:
+  npu:
+    model_runner: v1
+  xpu:
+    model_runner: v1
+  rocm:
+    model_runner: v1
+  musa:
+    model_runner: v1
+
+stages:
+  - stage_id: 0
+    # Bound per-step prefill work, matching the high-concurrency TTS profile.
+    max_num_batched_tokens: 512
diff --git a/vllm_omni/diffusion/attention/backends/flash_attn.py b/vllm_omni/diffusion/attention/backends/flash_attn.py
index d1f09b51a..679bf4955 100644
--- a/vllm_omni/diffusion/attention/backends/flash_attn.py
+++ b/vllm_omni/diffusion/attention/backends/flash_attn.py
@@ -2,6 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import os
+from collections.abc import Callable
 from functools import cache, partial
 
 import torch
@@ -75,18 +76,18 @@ class FlashAttentionBackend(AttentionBackend):
 
 
 class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
-    # Per-platform FP8 KV quantization support.
-    # To enable FP8 on a new platform, add its OmniPlatformEnum value here
+    # Per-platform attention quantization support.
+    # To enable a method on a new platform, add its OmniPlatformEnum value here
     # and handle kv_cache_dtype in the corresponding forward_{platform}().
     #
-    # TODO(quant-backend): The FP8 quant path currently lives inside
+    # TODO(quant-backend): The quantized path currently lives inside
     # FlashAttentionImpl gated by ``attn_metadata.extra["kv_cache_dtype"]``.
     # Eventually extract it into a dedicated FlashAttentionQuantBackend so
-    # backend selection (not metadata) decides quant. Until then, model
-    # authors can opt a specific Attention layer out via
+    # backend selection decides quant.
+    # Until then, model authors can opt a specific Attention layer out via
     # ``Attention(disable_kv_quant=True)``.
     _supported_kv_cache_dtypes = {
-        "npu": {"fp8"},
+        "npu": {"fp8", "mxfp8", "mxfp4"},
     }
 
     def __init__(
@@ -310,11 +311,17 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
         if native_impl is None:
             raise RuntimeError(f"Native attention implementation is not bound for diffusion layer {layer.layer_name!r}")
         prewrite_kv = current_omni_platform.requires_diffusion_paged_kv_prewrite()
-        read_kv_from_cache = prewrite_kv and layer.attn_backend.forward_includes_kv_cache_update
+        forward_updates_cache = layer.attn_backend.forward_includes_kv_cache_update
+        # Match vLLM's split update/attention contract. Once K/V has been
+        # written by do_kv_cache_update(), decoder attention consumes the
+        # paged cache and does not need segment-local K/V tensors. In
+        # particular, this avoids packing the same K/V projection view once
+        # for every piecewise segment.
+        read_kv_from_cache = not forward_updates_cache or prewrite_kv
         # The GPU/default path preserves native cache-update ownership. Ascend
         # prewrites through vLLM-Ascend's normal-layout writer so piecewise FIA
         # segments do not repeatedly scatter the same layer K/V.
-        if not layer.attn_backend.forward_includes_kv_cache_update or prewrite_kv:
+        if not forward_updates_cache or prewrite_kv:
             cache_update = getattr(native_impl, "do_kv_cache_update", None)
             if not callable(cache_update):
                 raise RuntimeError(
@@ -352,14 +359,11 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
             )
 
         if paged_kv_context.piecewise_plan is not None:
-            # Ascend FIA can execute identical CFG rows as one batched call
-            # per piece.  Keep that batch layout through the piecewise runner
-            # so it can concatenate row-major results instead of emitting an
-            # indexed ScatterUpdate for every segment.  The CUDA path keeps
-            # its existing output-buffer contract (including graph capture).
-            use_homogeneous_batch = (
-                current_omni_platform.is_npu() and paged_kv_context.piecewise_plan.homogeneous_batch_shape is not None
-            )
+            # Identical CFG rows can execute as one batched call per piece.
+            # Keep that batch layout through the piecewise runner so Q/K/V use
+            # strided slices instead of indexed gathers and results can be
+            # concatenated in row-major order.
+            use_homogeneous_batch = paged_kv_context.piecewise_plan.homogeneous_batch_shape is not None
             output = None
             if not use_homogeneous_batch:
                 output = torch.empty(
@@ -526,11 +530,47 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
     ) -> torch.Tensor:
         """NPU attention implementation using mindiesd."""
 
-        kv_cache_dtype = attn_metadata.extra.get("kv_cache_dtype") if attn_metadata else None
-        if kv_cache_dtype is not None:
+        extra = attn_metadata.extra if attn_metadata else {}
+        method = extra.get("kv_cache_dtype")
+        if method not in (None, "float", "auto"):
             return self.forward_fa_quant_npu(query, key, value, attn_metadata)
         return self.forward_fa_npu(query, key, value, attn_metadata)
 
+    @staticmethod
+    def _load_quant_runtime(method: str) -> Callable[..., torch.Tensor]:
+        if method not in ("fp8", "mxfp8", "mxfp4"):
+            raise ValueError(f"Unsupported NPU attention quantization method {method!r}.")
+        from mindiesd import quant_attention
+
+        return quant_attention
+
+    def _validate_quant_request(
+        self,
+        method: str,
+        query: torch.Tensor,
+        attn_metadata: AttentionMetadata | None,
+    ) -> None:
+        extra = attn_metadata.extra if attn_metadata else {}
+        reason = None
+        if self.causal:
+            reason = "causal quantized FA is not supported"
+        elif any(name in extra for name in ("cu_seqlens_q", "cu_seqlens_k")) or extra.get("npu_attn_varlen"):
+            reason = "packed/varlen metadata requires the float attention path"
+        elif attn_metadata is not None and attn_metadata.full_attn_spans is not None:
+            reason = "piecewise attention requires the float attention path"
+        elif attn_metadata is not None and attn_metadata.attn_mask is not None:
+            reason = "caller masks require the float attention path"
+        elif method in ("fp8", "mxfp8", "mxfp4") and (
+            query.ndim != 4 or query.shape[-1] <= 0 or query.shape[-1] & (query.shape[-1] - 1)
+        ):
+            reason = "generated Hadamard rotations require a four-dimensional input and power-of-two head size"
+        if reason is not None:
+            raise ValueError(
+                f"NPU attention precision {method!r} is unavailable: {reason}. "
+                "Set diffusion_kv_cache_dtype to a supported method, or set it to "
+                "'auto'. Automatic precision fallback is not performed."
+            )
+
     def forward_fa_quant_npu(
         self,
         query: torch.Tensor,
@@ -538,18 +578,29 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
         value: torch.Tensor,
         attn_metadata: AttentionMetadata | None = None,
     ) -> torch.Tensor:
-        from vllm_omni.platforms.npu.quant.kv_quant_npu import fp8_rotate_quant_fa
+        extra = attn_metadata.extra if attn_metadata else {}
+        method = extra.get("kv_cache_dtype", "fp8")
+        layout = self.qkv_layout or "BSND"
+        self._validate_quant_request(method, query, attn_metadata)
+        try:
+            runtime = self._load_quant_runtime(method)
+        except ImportError as exc:
+            raise ImportError(
+                f"NPU attention precision {method!r} requires a compatible MindIE-SD "
+                "quant Runtime. Install a compatible MindIE-SD build, select another "
+                "diffusion_kv_cache_dtype, or set it to 'auto'. Automatic precision "
+                "fallback is not performed."
+            ) from exc
+        kwargs = dict(precision=method, layout=layout, scale=self.softmax_scale)
+        # Apply Omni's deterministic Q/K rotation before every Dense quantized path.
+        if method in ("fp8", "mxfp8", "mxfp4"):
+            from vllm_omni.platforms.npu.quant.kv_quant_npu import get_quant_attention_rotation
 
-        layout = self.qkv_layout or "BNSD"
-        # Models pass (B, S, H, D); NPU fused op expects (B, N, S, D).
-        out = fp8_rotate_quant_fa(
-            query.transpose(1, 2),
-            key.transpose(1, 2),
-            value.transpose(1, 2),
-            layout=layout,
-            softmax_scale=self.softmax_scale,
-        )
-        return out.transpose(1, 2)
+            rotation = get_quant_attention_rotation(query.device, query.dtype, query.shape[-1])
+            kwargs.update(q_rot=rotation, k_rot=rotation)
+        logger.info_once("NPU attention uses MindIE-SD %s Runtime, layout=%s.", method, layout)
+        # Execution errors propagate. Never retry with another precision.
+        return runtime(query, key, value, **kwargs)
 
     def forward_fa_npu(
         self,
diff --git a/vllm_omni/diffusion/attention/backends/rainfusion_attn.py b/vllm_omni/diffusion/attention/backends/rainfusion_attn.py
index 9bbde02fa..d4219fa05 100644
--- a/vllm_omni/diffusion/attention/backends/rainfusion_attn.py
+++ b/vllm_omni/diffusion/attention/backends/rainfusion_attn.py
@@ -135,6 +135,11 @@ class RainFusionPlan:
 class RainFusionAttentionBackend(AttentionBackend):
     accept_output_buffer: bool = True
     supported_platforms: tuple[str, ...] = ("npu",)
+    # The impl trims [real, pad] packed tensors to the valid prefix with
+    # [:, :used] itself, so models may run the padded layout without
+    # materializing a padding mask (a forward that carries one anyway falls
+    # back dense in _resolve_plan).
+    supports_prefix_kv_slicing: bool = True
 
     @classmethod
     def validate_available(cls) -> None:
@@ -146,8 +151,10 @@ class RainFusionAttentionBackend(AttentionBackend):
             from mindiesd import sparse_attention
         except ImportError as exc:
             raise ValueError(_MISSING_MINDIESD) from exc
-        if not _supports_video_spans(sparse_attention):
-            raise ValueError(_INCOMPATIBLE_MINDIESD)
+        if not callable(sparse_attention):
+            raise ValueError(_MISSING_MINDIESD)
+        # Single-video Wan only needs the legacy geometry. Check video_spans
+        # when a forward actually carries multiple videos.
 
     @staticmethod
     def get_supported_head_sizes() -> list[int]:
@@ -174,6 +181,8 @@ class RainFusionAttentionImpl(AttentionImpl):
     irregular video tail internally, retaining it outside the sparse blocks.
     """
 
+    _supported_kv_cache_dtypes = {"npu": {"fp8", "mxfp4"}}
+
     def __init__(
         self,
         num_heads: int,
@@ -222,6 +231,8 @@ class RainFusionAttentionImpl(AttentionImpl):
     def _validate_parallel_config(self) -> None:
         config = get_current_diffusion_config_or_none()
         parallel_config = getattr(config, "parallel_config", None)
+        if getattr(parallel_config, "allgather_degree", 1) > 1:
+            raise ValueError("RAINFUSION_ATTN requires full Q/K/V sequences; AllGather-KV SP is unsupported.")
         ring_degree = getattr(parallel_config, "ring_degree", 1)
         if ring_degree > 1:
             # Ring gives each rank a slice of the sequence, so block selection
@@ -262,7 +273,9 @@ class RainFusionAttentionImpl(AttentionImpl):
         plan = self._resolve_plan(attn_metadata)
         if plan is None:
             return self.dense_fallback.forward_npu(query, key, value, attn_metadata)
-        return self._forward_sparse_npu(query, key, value, plan)
+        if query.ndim != 4 or key.shape != query.shape or value.shape != query.shape or plan.used_len > query.shape[1]:
+            raise ValueError("RainFusion video geometry must fit identical full-sequence BSND Q/K/V tensors.")
+        return self._forward_sparse_npu(query, key, value, plan, attn_metadata)
 
     def _resolve_plan(self, attn_metadata: AttentionMetadata | None) -> RainFusionPlan | None:
         """Return the rf_v2 geometry, or None when this forward must stay dense."""
@@ -271,18 +284,17 @@ class RainFusionAttentionImpl(AttentionImpl):
             return None
         if self.layer_idx is not None and self.layer_idx in rf.skip_layers:
             return None
+        step_idx = total_steps = None
         if is_forward_context_available():
             step_idx = get_forward_context().denoise_step_idx
             total_steps = get_forward_context().total_denoise_steps
-            if step_idx is not None and step_idx < rf.start_step:
+        if (rf.start_step and step_idx is None) or (rf.end_step and (step_idx is None or total_steps is None)):
+            return None
+        if step_idx is not None:
+            if step_idx < rf.start_step:
                 return None
             # Tail fallback: keep the last ``end_step`` denoise steps dense.
-            if (
-                rf.end_step > 0
-                and step_idx is not None
-                and total_steps is not None
-                and step_idx >= total_steps - rf.end_step
-            ):
+            if rf.end_step > 0 and total_steps is not None and step_idx >= total_steps - rf.end_step:
                 return None
         if self.qkv_layout is None:
             # The sparse path reads the sequence off dim 1, which the tensors alone
@@ -308,7 +320,16 @@ class RainFusionAttentionImpl(AttentionImpl):
                 "model must publish AttentionMetadata.video_layout for the sequence to be sparsified."
             )
             return None
-        max_seqlen_q = attn_metadata.extra.get("max_seqlen_q")
+
+        # The sparse Runtime constructs its own block mask. It cannot preserve
+        # an arbitrary caller-supplied mask or piecewise visibility constraints.
+        mask = attn_metadata.attn_mask
+        padding_only = layout.used_len is not None
+        if attn_metadata.full_attn_spans is not None or (
+            mask is not None and not (padding_only and mask.ndim == 2 and mask.dtype == torch.bool)
+        ):
+            return None
+        max_seqlen_q = attn_metadata.extra.get("max_seqlen_q", layout.used_len)
         if max_seqlen_q is None:
             logger.warning_once(
                 "RAINFUSION_ATTN staying dense: attention metadata is missing max_seqlen_q, so the "
@@ -459,31 +480,56 @@ class RainFusionAttentionImpl(AttentionImpl):
         key: torch.Tensor,
         value: torch.Tensor,
         plan: RainFusionPlan,
+        attn_metadata: AttentionMetadata | None = None,
     ) -> torch.Tensor:
         try:
             from mindiesd import sparse_attention
         except ImportError:
             raise ImportError(_MISSING_MINDIESD)
-        if self.rainfusion.precision != "bf16" and not _mindiesd_supports_precision():
-            raise RuntimeError(
-                f"block_sparse.precision={self.rainfusion.precision!r} requires MindIE-SD "
-                "with sparse_attention(precision=...) support; the installed mindiesd "
-                "silently ignores it and would run the BF16 path. Install a compatible "
-                "MindIE-SD release or use precision='bf16'."
+        if plan.video_spans is not None and not _supports_video_spans(sparse_attention):
+            raise ValueError(_INCOMPATIBLE_MINDIESD)
+        extra = attn_metadata.extra if attn_metadata else {}
+        requested = extra.get("kv_cache_dtype", self.rainfusion.precision)
+        reason = None
+        if requested in ("float", "bf16"):
+            precision = "bf16"
+        else:
+            precision = requested
+            if requested not in ("fp8", "mxfp4", "mix"):
+                reason = f"sparse {requested} is not supported"
+            elif not _mindiesd_supports_precision():
+                reason = "MindIE-SD sparse_attention must explicitly support precision"
+            elif plan.video_spans is not None:
+                reason = "quantized multi-video RainFusion is not supported"
+            elif requested in ("fp8", "mxfp4") and query.shape[0] != 1:
+                reason = "quantized Wan BSA requires batch size 1"
+            elif requested in ("fp8", "mxfp4") and (query.shape[-1] < 64 or query.shape[-1] & (query.shape[-1] - 1)):
+                reason = "BSA Hadamard rotations require a power-of-two head dimension of at least 64"
+        if reason is not None:
+            raise ValueError(
+                f"RainFusion precision {requested!r} is unavailable: {reason}. "
+                "Set diffusion_kv_cache_dtype or block_sparse.precision to a method supported by the installed "
+                "MindIE-SD, or disable attention quantization. Automatic precision fallback is not performed."
             )
 
+        logger.info_once("RainFusion uses MindIE-SD sparse attention, precision=%s.", precision)
         used = plan.used_len
-        q, k, v = (tensor[:, :used] for tensor in (query, key, value))
+        # Split query once: the valid prefix drives the kernel, the padding
+        # tail is reused verbatim as the output padding below. All views,
+        # zero-copy. split_with_sizes always yields both parts, including an
+        # empty tail when the sequence needs no padding.
+        q, q_pad = torch.split(query, [used, query.shape[1] - used], dim=1)
+        k, v = key[:, :used], value[:, :used]
         # Ulysses has already gathered the full sequence onto this rank and split
         # the heads, so read the head count off the tensor rather than num_heads.
         common_kwargs: dict[str, object] = {
             "scale": self.softmax_scale,
             "head_num": query.shape[-2],
             "input_layout": _INPUT_LAYOUT,
-            "inner_precise": _INNER_PRECISE,
+            "inner_precise": 4 if precision != "bf16" else _INNER_PRECISE,
             "block_size": _BLOCK_SIZE,
             "sparsity": self.rainfusion.sparsity,
-            "precision": self.rainfusion.precision,
+            "precision": precision,
         }
         if plan.video_spans is not None:
             out = sparse_attention(
@@ -497,7 +543,9 @@ class RainFusionAttentionImpl(AttentionImpl):
         else:
             assert plan.prefix_len is not None and plan.latent_shape is not None
             common_kwargs.update(
-                sparse_type="rf_v2",
+                # rf_v2 ignores precision on non-A5 devices. Select the explicit
+                # quantized high-level path so mask/rearrangement remain in MindIE.
+                sparse_type="rf_v3" if precision != "bf16" else "rf_v2",
                 txt_len=plan.prefix_len,
                 latent_shape_q=plan.latent_shape,
                 latent_shape_k=plan.latent_shape,
@@ -505,6 +553,9 @@ class RainFusionAttentionImpl(AttentionImpl):
             out = sparse_attention(q, k, v, **common_kwargs)
         if used == query.shape[1]:
             return out
-        padded = torch.zeros_like(query)
-        padded[:, :used] = out
-        return padded
+        # Only the first ``used`` rows are read back downstream, so the padding
+        # payload is free. Reuse the query tail split off above instead of
+        # zeroing a fresh buffer: a single cat write, no extra allocation, and
+        # always finite values (uninitialized memory could hold NaN bit
+        # patterns).
+        return torch.cat([out, q_pad], dim=1)
diff --git a/vllm_omni/diffusion/attention/layer.py b/vllm_omni/diffusion/attention/layer.py
index 2e0b2604d..0ad41e80f 100644
--- a/vllm_omni/diffusion/attention/layer.py
+++ b/vllm_omni/diffusion/attention/layer.py
@@ -321,7 +321,7 @@ class Attention(nn.Module):
             dtype = None
         parallel_config = getattr(config, "parallel_config", None)
         ring_degree = getattr(parallel_config, "ring_degree", 1)
-        if dtype:
+        if dtype and dtype != "float":
             if ring_degree > 1:
                 raise ValueError(
                     "KV quantization is not compatible with ring attention "
@@ -338,13 +338,15 @@ class Attention(nn.Module):
         self._kv_cache_dtype = dtype
         self._kv_cache_skip_steps = getattr(config, "diffusion_kv_cache_skip_step_indices", None)
         self._kv_cache_skip_layers = getattr(config, "diffusion_kv_cache_skip_layer_indices", None)
+        if self._kv_cache_skip_layers and self.layer_idx is None and not self._disable_kv_quant:
+            raise ValueError("Attention quantization skip_layers requires a parseable transformer block index.")
 
     def _should_apply_kv_cache_quant(self) -> bool:
         skip_steps = self._kv_cache_skip_steps
         skip_layers = self._kv_cache_skip_layers
         if skip_steps is not None:
             step_idx = get_forward_context().denoise_step_idx if is_forward_context_available() else None
-            if step_idx is not None and step_idx in skip_steps:
+            if skip_steps and (step_idx is None or step_idx in skip_steps):
                 return False
         if skip_layers is not None:
             if self.layer_idx is not None and self.layer_idx in skip_layers:
@@ -352,18 +354,21 @@ class Attention(nn.Module):
         return True
 
     def _with_kv_cache_dtype(self, attn_metadata: AttentionMetadata | None) -> AttentionMetadata | None:
-        kv_cache_dtype = self._kv_cache_dtype
-        if kv_cache_dtype is None or self._disable_kv_quant or not self._should_apply_kv_cache_quant():
-            if attn_metadata is None or "kv_cache_dtype" not in attn_metadata.extra:
-                return attn_metadata
-            extra = dict(attn_metadata.extra)
-            extra.pop("kv_cache_dtype", None)
-            return replace(attn_metadata, extra=extra)
-
+        disabled = self._disable_kv_quant or not self._should_apply_kv_cache_quant()
+        dtype = self._kv_cache_dtype
+        if dtype in (None, "float"):
+            dtype = None
+        elif disabled:
+            dtype = "float"
+        if dtype is None and (attn_metadata is None or "kv_cache_dtype" not in attn_metadata.extra):
+            return attn_metadata
+        extra = dict(attn_metadata.extra) if attn_metadata is not None else {}
+        # Recompute per forward so shared metadata cannot retain another step's policy.
+        extra.pop("kv_cache_dtype", None)
+        if dtype is not None:
+            extra["kv_cache_dtype"] = dtype
         if attn_metadata is None:
-            return AttentionMetadata(extra={"kv_cache_dtype": kv_cache_dtype})
-        extra = dict(attn_metadata.extra)
-        extra["kv_cache_dtype"] = kv_cache_dtype
+            return AttentionMetadata(extra=extra) if extra else None
         return replace(attn_metadata, extra=extra)
 
     def forward(
diff --git a/vllm_omni/diffusion/data.py b/vllm_omni/diffusion/data.py
index e1ce550d4..9dd69502f 100644
--- a/vllm_omni/diffusion/data.py
+++ b/vllm_omni/diffusion/data.py
@@ -6,6 +6,7 @@ import json
 import math
 import os
 import random
+import warnings
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field, fields
 from enum import Enum
@@ -44,55 +45,63 @@ if TYPE_CHECKING:
 logger = init_logger(__name__)
 
 
-def normalize_omni_diffusion_kwargs(raw_kwargs: Mapping[str, Any]) -> dict[str, Any]:
-    """Normalize legacy diffusion kwargs before config construction."""
+def _move_diffusion_alias(
+    normalized: dict[str, Any],
+    legacy_name: str,
+    canonical_name: str,
+) -> None:
+    legacy_value = normalized.pop(legacy_name, None)
+    if legacy_value is None:
+        return
+    if normalized.get(canonical_name) is not None:
+        raise ValueError(f"Diffusion config fields {legacy_name!r} and {canonical_name!r} cannot both be provided.")
+    warnings.warn(
+        f"Diffusion config field {legacy_name!r} is deprecated; use {canonical_name!r}.",
+        FutureWarning,
+        stacklevel=3,
+    )
+    normalized[canonical_name] = legacy_value
+
+
+def normalize_omni_diffusion_kwargs(
+    raw_kwargs: Mapping[str, Any],
+    *,
+    apply_defaults: bool = True,
+) -> dict[str, Any]:
+    """Normalize diffusion kwargs, deferring defaults until sources are merged."""
     config_kwargs = dict(raw_kwargs)
 
     dtype = config_kwargs.get("dtype")
     if dtype is None:
-        config_kwargs["dtype"] = "auto"
+        if apply_defaults:
+            config_kwargs["dtype"] = "auto"
     elif isinstance(dtype, torch.dtype):
         config_kwargs["dtype"] = str(dtype).removeprefix("torch.")
     elif not isinstance(dtype, str):
         raise TypeError(f"Provided dtype must be a string or torch.dtype, got {type(dtype).__name__}")
 
-    # Backwards-compatibility: older callers may use a diffusion-specific
-    # "static_lora_scale" kwarg. Normalize it to the canonical "lora_scale".
-    if "static_lora_scale" in config_kwargs:
-        if "lora_scale" not in config_kwargs:
-            config_kwargs["lora_scale"] = config_kwargs["static_lora_scale"]
-        config_kwargs.pop("static_lora_scale", None)
-
-    diffusion_quantization = config_kwargs.pop("diffusion_quantization_config", None)
-    if config_kwargs.get("quantization_config") is None and diffusion_quantization is not None:
-        config_kwargs["quantization_config"] = diffusion_quantization
-
-    # Backwards-compatibility: map "quantization" to "quantization_config"
-    # so callers using the old field name still work.
-    if "quantization" in config_kwargs and config_kwargs.get("quantization_config", None) is None:
-        config_kwargs["quantization_config"] = config_kwargs.pop("quantization")
-    else:
-        config_kwargs.pop("quantization", None)
-
-    # Renamed from kv_cache_* to avoid clashing with vLLM's --kv-cache-dtype.
-    if config_kwargs.get("diffusion_kv_cache_dtype") is None and "kv_cache_dtype" in config_kwargs:
-        config_kwargs["diffusion_kv_cache_dtype"] = config_kwargs.pop("kv_cache_dtype")
-    else:
-        config_kwargs.pop("kv_cache_dtype", None)
-    if config_kwargs.get("diffusion_kv_cache_skip_steps") is None and "kv_cache_skip_steps" in config_kwargs:
-        config_kwargs["diffusion_kv_cache_skip_steps"] = config_kwargs.pop("kv_cache_skip_steps")
-    else:
-        config_kwargs.pop("kv_cache_skip_steps", None)
-    if config_kwargs.get("diffusion_kv_cache_skip_layers") is None and "kv_cache_skip_layers" in config_kwargs:
-        config_kwargs["diffusion_kv_cache_skip_layers"] = config_kwargs.pop("kv_cache_skip_layers")
-    else:
-        config_kwargs.pop("kv_cache_skip_layers", None)
+    for legacy, canonical in (
+        ("static_lora_scale", "lora_scale"),
+        ("quantization", "quantization_config"),
+        ("diffusion_quantization_config", "quantization_config"),
+        ("max_batch_size", "max_num_seqs"),
+        ("kv_cache_skip_steps", "diffusion_kv_cache_skip_steps"),
+        ("kv_cache_skip_layers", "diffusion_kv_cache_skip_layers"),
+    ):
+        _move_diffusion_alias(config_kwargs, legacy, canonical)
+    _move_diffusion_alias(config_kwargs, "kv_cache_dtype", "diffusion_kv_cache_dtype")
 
     # Handle "diffusion_attention_backend" shorthand: merge into
     # diffusion_attention_config before field filtering.
     diffusion_attn_backend = config_kwargs.pop("diffusion_attention_backend", None)
     fastvideo_vsa_topk = config_kwargs.pop("fastvideo_vsa_topk", None)
     if diffusion_attn_backend is not None or fastvideo_vsa_topk is not None:
+        if diffusion_attn_backend is not None:
+            warnings.warn(
+                "Diffusion config field 'diffusion_attention_backend' is deprecated; use 'diffusion_attention_config'.",
+                FutureWarning,
+                stacklevel=2,
+            )
         existing = config_kwargs.get("diffusion_attention_config")
         config_kwargs["diffusion_attention_config"] = parse_attention_config(
             existing,
@@ -100,12 +109,23 @@ def normalize_omni_diffusion_kwargs(raw_kwargs: Mapping[str, Any]) -> dict[str,
             fastvideo_vsa_topk=fastvideo_vsa_topk,
         )
 
+    auxiliary_text_encoder = config_kwargs.pop("auxiliary_text_encoder", None)
+    if auxiliary_text_encoder is not None:
+        extras = dict(config_kwargs.get("extras") or {})
+        if extras.get("auxiliary_text_encoder") is not None:
+            raise ValueError(
+                "Diffusion engine field 'auxiliary_text_encoder' cannot be provided both at the top level and in "
+                "'extras'."
+            )
+        extras["auxiliary_text_encoder"] = auxiliary_text_encoder
+        config_kwargs["extras"] = extras
+
     # Check environment variable as fallback for cache_backend.
     # Support both old DIFFUSION_CACHE_ADAPTER and new DIFFUSION_CACHE_BACKEND.
-    if "cache_backend" not in config_kwargs:
+    if "cache_backend" not in config_kwargs and apply_defaults:
         cache_backend = os.environ.get("DIFFUSION_CACHE_BACKEND") or os.environ.get("DIFFUSION_CACHE_ADAPTER")
         config_kwargs["cache_backend"] = cache_backend.lower() if cache_backend else "none"
-    elif config_kwargs["cache_backend"] is None:
+    elif "cache_backend" in config_kwargs and config_kwargs["cache_backend"] is None and apply_defaults:
         # Callers (e.g. example CLIs with `default=None`) pass an explicit
         # None for "no cache"; canonicalize it so every consumer sees the
         # declared `str` value instead of relying on per-model None handling.
@@ -162,6 +182,20 @@ def validate_dlo_host_registration_options(
     return value
 
 
+def validate_omni_diffusion_kwargs(
+    kwargs: Mapping[str, Any],
+    allowed_fields: set[str] | frozenset[str],
+    *,
+    stage_id: int | str | None = None,
+) -> None:
+    """Reject every field without an owner."""
+    unknown = set(kwargs) - allowed_fields
+    if unknown:
+        names = ", ".join(repr(name) for name in sorted(unknown))
+        suffix = "" if stage_id is None else f" for stage {stage_id}"
+        raise ValueError(f"Unknown diffusion config field(s){suffix}: {names}")
+
+
 def parse_kv_cache_skip_selector(
     selector: str | list[int] | tuple[int, ...] | set[int] | None,
 ) -> set[int] | None:
@@ -1021,16 +1055,15 @@ class OmniDiffusionConfig:
     # str is resolved to {"method": <str>} internally.
     # Per-component: {"transformer": {"method": "fp8"}, "vae": None}
     quantization_config: str | QuantizationConfig | dict[str, Any] | None = None
+    # Internal provenance, retained across config projection and worker transport.
+    quantization_config_is_auto_detected: bool = False
     # Explicit runtime override for ModelOpt FP8 diffusion checkpoints. This
     # does not enable FP8 by itself; it only selects CUTLASS once the checkpoint
     # has already resolved to vLLM's ModelOpt FP8 linear method.
     force_cutlass_fp8: bool = False
 
-    # Diffusion attention KV cache dtype (not vLLM's --kv-cache-dtype for AR models).
-    # None = native dtype (no quantization).
-    # "fp8" = dynamic FP8 (float8_e4m3fn) quantization per forward pass.
-    # On Hopper+FA3: native FP8 attention (memory + compute savings).
-    # On other backends: no benefit, backends skip quantization.
+    # Runtime diffusion attention method (not vLLM's --kv-cache-dtype for AR models).
+    # None/"auto" keeps native dtype; other values are validated by the selected backend.
     diffusion_kv_cache_dtype: str | None = None
     # Optional skip selectors for KV-cache quantization. Format: "0-9,20,25-30".
     # Listed steps/layers skip quantization; others keep quantized execution.
@@ -1192,6 +1225,8 @@ class OmniDiffusionConfig:
             if self.diffusion_kv_mode is not DiffusionKVCacheMode.PAGED_SCHEDULER:
                 raise ValueError("native kv_transfer_config requires diffusion_kv_mode='paged_scheduler'")
             self.kv_transfer_config = parse_kv_transfer_config(self.kv_transfer_config)
+            if self.enable_sleep_mode:
+                raise ValueError("Native KV transfer does not support sleep mode: registered pages must remain mapped")
 
         self.master_port = self._resolve_master_port()
         self.request_batch_max_wait_ms = float(self.request_batch_max_wait_ms or 0.0)
@@ -1346,6 +1381,10 @@ class OmniDiffusionConfig:
                     self.model,
                 )
 
+    @property
+    def is_single_file(self) -> bool:
+        return isinstance(self.model, str) and os.path.isfile(self.model)
+
     def _propagate_quantization_from_tf_config(self, tf_config: "TransformerConfig") -> None:
         if tf_config.quant_config is None:
             return
@@ -1358,6 +1397,8 @@ class OmniDiffusionConfig:
             or (is_checkpoint_nvfp4 and self._is_generic_nvfp4_quant_config(self.quantization_config))
         )
         if should_use_checkpoint_config:
+            if self.quantization_config is None:
+                self.quantization_config_is_auto_detected = True
             self.quantization_config = tf_config.quant_config
             logger.info(
                 "Auto-detected quantization '%s' from model config",
@@ -1448,12 +1489,22 @@ class OmniDiffusionConfig:
         """
         from vllm.transformers_utils.config import get_hf_file_to_dict
 
+        from vllm_omni.diffusion.registry import resolve_native_single_file
         from vllm_omni.diffusion.utils.hf_utils import (
             get_diffusion_model_index,
             resolve_native_diffusion_model_class,
         )
 
         assert self.model is not None
+
+        native_single_file_model = resolve_native_single_file(self.model_class_name)
+        if self.is_single_file and native_single_file_model is not None:
+            self.diffusion_load_format = "default"
+            self.model_class_name = native_single_file_model
+            self.diffusers_pipeline_cls = None
+            self.set_tf_model_config(TransformerConfig())
+            return
+
         try:
             config_dict = get_diffusion_model_index(
                 self.model,
@@ -1611,6 +1662,11 @@ class OmniDiffusionConfig:
                         self.model_class_name = "Pi0Pipeline"
                     self.set_tf_model_config(TransformerConfig())
                     self.update_multimodal_support()
+                elif cfg.get("type") == "pi05":
+                    if self.model_class_name is None:
+                        self.model_class_name = "Pi05Pipeline"
+                    self.set_tf_model_config(TransformerConfig())
+                    self.update_multimodal_support()
                 elif architectures and len(architectures) == 1:
                     architecture = architectures[0]
                     from vllm_omni.diffusion.registry import DiffusionModelRegistry
@@ -1625,8 +1681,9 @@ class OmniDiffusionConfig:
 
     @classmethod
     def normalize_init_kwargs(cls, raw_kwargs: Mapping[str, Any]) -> dict[str, Any]:
+        valid_fields = frozenset(f.name for f in fields(cls))
         config_kwargs = normalize_omni_diffusion_kwargs(raw_kwargs)
-        valid_fields = {f.name for f in fields(cls)}
+        validate_omni_diffusion_kwargs(config_kwargs, valid_fields)
         # Remaining ``None`` values mean "unset" at the CLI/deploy boundary.
         # Drop them so non-optional dataclass defaults are not overwritten.
         # Fields where ``None`` has normalization semantics (for example dtype
diff --git a/vllm_omni/diffusion/diffusion_engine.py b/vllm_omni/diffusion/diffusion_engine.py
index 6e53b5909..5e3082f45 100644
--- a/vllm_omni/diffusion/diffusion_engine.py
+++ b/vllm_omni/diffusion/diffusion_engine.py
@@ -603,7 +603,11 @@ class DiffusionEngine:
 
                 self._wait_for_admission_if_needed_locked()
 
-                sched_output = self.scheduler.schedule()
+                try:
+                    sched_output = self.scheduler.schedule()
+                except Exception as exc:
+                    self._fail_engine(exc)
+                    return
                 self._scheduler_num_waiting_reqs = max(int(sched_output.num_waiting_reqs), 0)
 
             self._emit_request_started_outputs(sched_output)
@@ -613,8 +617,17 @@ class DiffusionEngine:
                 continue
 
             try:
-                runner_output: BaseRunnerOutput = self.execute_fn(sched_output)  # pyright: ignore[reportAssignmentType]
+                self._prepare_kv_for_forward(sched_output)
+                runner_output: BaseRunnerOutput = (
+                    self.execute_fn(sched_output)
+                    if sched_output.scheduled_request_ids
+                    else BatchRunnerOutput.from_list([])
+                )
+                worker_execution_completed = True
             except Exception as exc:
+                if self._closed:
+                    return
+                worker_execution_completed = False
                 logger.error(
                     "Execution failed for diffusion requests %s", sched_output.scheduled_request_ids, exc_info=True
                 )
@@ -632,8 +645,23 @@ class DiffusionEngine:
 
             self._process_aborts_queue()
             self._process_rpc_queue()
-            finished_req_ids = self.scheduler.update_from_output(sched_output, runner_output)
-            self._emit_outputs(finished_req_ids, sched_output.scheduled_request_ids, runner_output)
+            try:
+                finished_req_ids = self.scheduler.update_from_output(sched_output, runner_output)
+                self._emit_outputs(
+                    finished_req_ids,
+                    sched_output.scheduled_request_ids,
+                    runner_output,
+                    worker_execution_completed=worker_execution_completed,
+                )
+            except Exception as exc:
+                self._fail_engine(exc)
+                return
+
+            if not sched_output.scheduled_request_ids and self.scheduler._kv_draining_requests:
+                # Only exceptional in-flight receives need idle polling. New
+                # requests / aborts wake this wait immediately.
+                with self._cv:
+                    self._cv.wait(timeout=0.01)
 
         # Engine is stopping: fail any RPCs still queued so callers don't hang.
         self._fail_pending_rpcs(RuntimeError("DiffusionEngine is shutting down."))
@@ -755,15 +783,80 @@ class DiffusionEngine:
             return
         unique_request_ids = list(dict.fromkeys(request_ids))
         if unique_request_ids:
-            self.executor.remove_diffusion_kv_requests(unique_request_ids)
+            scheduler = getattr(self, "scheduler", None)
+            target_builder = getattr(scheduler, "get_diffusion_kv_cleanup_targets", None)
+            cleanup_targets = target_builder(unique_request_ids) if target_builder is not None else unique_request_ids
+            try:
+                if cleanup_targets:
+                    self.executor.remove_diffusion_kv_requests(cleanup_targets)
+            except Exception as exc:
+                self._fail_engine(exc)
+                raise
+
+    def _prepare_kv_for_forward(self, sched_output: DiffusionSchedulerOutput) -> None:
+        if getattr(sched_output, "kv_connector_metadata", None) is None:
+            return
+        try:
+            output = self.executor.prepare_kv_for_forward(sched_output)
+            assert output is not None
+            self.scheduler.update_kv_connector_output(output)
+            if not self.abort_queue.empty():
+                self._process_aborts_queue()
+            incomplete = sched_output.kv_transfer_request_ids - (output.finished_recving or set())
+            sched_output.finished_req_ids.update(self.scheduler.fail_incomplete_kv_loads(incomplete))
+            # Timed-out/cancelled requests must never reach model execution.
+            terminal = {
+                rid
+                for rid in sched_output.scheduled_request_ids
+                if (state := self.scheduler.get_request_state(rid)) is not None and state.is_finished()
+            }
+            if terminal:
+                sched_output.finished_req_ids.update(terminal)
+                sched_output.scheduled_new_reqs = [
+                    req for req in sched_output.scheduled_new_reqs if req.request_id not in terminal
+                ]
+                sched_output.scheduled_cached_reqs.request_ids = [
+                    rid for rid in sched_output.scheduled_cached_reqs.request_ids if rid not in terminal
+                ]
+                # is_empty / started-output handling may have already cached it.
+                sched_output.__dict__.pop("scheduled_request_ids", None)
+            drained = self.scheduler.completed_kv_drains()
+            if drained:
+                self._remove_diffusion_kv_requests(drained)
+                self.scheduler.release_kv_drains(drained)
+        except Exception as exc:
+            self._fail_engine(exc)
+            raise
+
+    def _fail_engine(self, exc: Exception) -> None:
+        if getattr(self, "_shutdown_complete", False):
+            return
+        logger.error("Diffusion engine failed; stopping workers before releasing KV pages", exc_info=exc)
+        with self._cv:
+            self._closed = True
+            if self.stop_event is not None:
+                self.stop_event.set()
+            streams = list(self._out_streams.values())
+            self._cv.notify_all()
+        for stream in streams:
+            self._put_queue_output(stream, DiffusionOutput.from_exception(exc))
+        self._fail_pending_rpcs(exc)
+        try:
+            self.executor.shutdown()
+        finally:
+            try:
+                self.scheduler.close()
+            finally:
+                self._shutdown_complete = True
 
     def _emit_finished_outputs(
         self,
         finished_ids: set[str],
         runner_output: BaseRunnerOutput | None = None,
         missing_result_error: str = "Diffusion execution finished without a final output",
+        worker_cleaned_ids: set[str] | None = None,
     ) -> None:
-        self._remove_diffusion_kv_requests(finished_ids)
+        self._remove_diffusion_kv_requests(finished_ids - (worker_cleaned_ids or set()))
         for rid in finished_ids:
             if runner_output is not None:
                 _output = runner_output.get_request_output(rid)
@@ -777,13 +870,21 @@ class DiffusionEngine:
         finished_ids: set[str],
         scheduled_request_ids: list[str],
         runner_output: BaseRunnerOutput,
+        *,
+        worker_execution_completed: bool = False,
     ) -> None:
         """Emit output chunks for every request through the unified output stream."""
+        finished_ids = set(finished_ids)
+        worker_cleaned_ids = finished_ids.intersection(scheduled_request_ids) if worker_execution_completed else set()
         if self.execution_mode != DiffusionExecutionMode.STEP_BATCH:
-            self._emit_finished_outputs(finished_ids, runner_output)
+            self._emit_finished_outputs(
+                finished_ids,
+                runner_output,
+                worker_cleaned_ids=worker_cleaned_ids,
+            )
             return
 
-        self._remove_diffusion_kv_requests(finished_ids)
+        self._remove_diffusion_kv_requests(finished_ids - worker_cleaned_ids)
 
         delivered_finished_req_ids: set[str] = set()
 
@@ -975,7 +1076,11 @@ class DiffusionEngine:
             # keep scheduling and executing until the target request is finished
             while True:
                 self._process_aborts_queue()
-                sched_output = self.scheduler.schedule()
+                try:
+                    sched_output = self.scheduler.schedule()
+                except Exception as exc:
+                    self._fail_engine(exc)
+                    raise
                 if sched_output.is_empty:
                     if target_request_id in sched_output.finished_req_ids:
                         self._remove_diffusion_kv_requests([target_request_id])
@@ -986,12 +1091,19 @@ class DiffusionEngine:
 
                 # NOTE: add_req_and_wait_for_response() is synchronous, will be only called
                 # within _dummy_run, only one request will be scheduled
-                request_id = sched_output.scheduled_request_ids[0]
+                request_id = target_request_id
                 try:
-                    runner_output: BaseRunnerOutput = self.execute_fn(sched_output)  # pyright: ignore[reportAssignmentType]
+                    self._prepare_kv_for_forward(sched_output)
+                    runner_output: BaseRunnerOutput = (
+                        self.execute_fn(sched_output)
+                        if sched_output.scheduled_request_ids
+                        else BatchRunnerOutput.from_list([])
+                    )
                 except EngineDeadError:
                     raise
                 except Exception as exc:
+                    if self._closed:
+                        raise
                     logger.error("Execution failed for diffusion request %s", request_id, exc_info=True)
                     runner_output = RunnerOutput(
                         request_id=request_id,
@@ -1005,7 +1117,11 @@ class DiffusionEngine:
                 finished_req_ids = self.scheduler.update_from_output(sched_output, runner_output)
 
                 # sync func should receive one result
-                if not isinstance(runner_output, RunnerOutput) and not len(runner_output) == 1:
+                if (
+                    sched_output.scheduled_request_ids
+                    and not isinstance(runner_output, RunnerOutput)
+                    and len(runner_output) != 1
+                ):
                     raise ValueError("Sync func should receive one result at one time")
                 if target_request_id in finished_req_ids:
                     self._remove_diffusion_kv_requests([target_request_id])
@@ -1100,7 +1216,8 @@ class DiffusionEngine:
         executes one request from the collective wave.
 
         Hunyuan is currently the only model integrated with
-        ``paged_scheduler``; 1024x1024, enabled CFG, and the maximum advertised
+        ``paged_scheduler``. The stage's configured default resolution (or
+        1024x1024 when absent), enabled CFG, and the maximum advertised
         reference-image count exercise its first-step activation peak.
         Admission compares each preprocessed request's CFG count and tokenized
         sequence/target shape with the resulting per-request profile envelope.
@@ -1117,9 +1234,12 @@ class DiffusionEngine:
         model_class_name = self.od_config.model_class_name
         if model_class_name is None:
             raise RuntimeError("Diffusion KV profiling requires a resolved model_class_name")
+        additional_config = getattr(self.od_config, "additional_config", {}) or {}
+        profile_height = additional_config.get("diffusion_kv_profile_height", 1024)
+        profile_width = additional_config.get("diffusion_kv_profile_width", 1024)
         request = self._make_dummy_request(
-            height=1024,
-            width=1024,
+            height=profile_height,
+            width=profile_width,
             guidance_scale=5.0,
             num_image_inputs=get_dummy_run_num_image_inputs(model_class_name),
         )
@@ -1335,7 +1455,11 @@ class DiffusionEngine:
 
     def _process_aborts_queue(self) -> None:
         with self._cv:
-            self._drain_abort_queue()
+            try:
+                self._drain_abort_queue()
+            except Exception as exc:
+                self._fail_engine(exc)
+                raise
 
     def _drain_abort_queue(self) -> None:
         if self.abort_queue.empty():
@@ -1352,11 +1476,10 @@ class DiffusionEngine:
         request_ids = [request_ids] if isinstance(request_ids, str) else list(request_ids)
         request_ids = list(dict.fromkeys(request_ids))
 
-        self._remove_diffusion_kv_requests(request_ids)
-
         for request_id in request_ids:
             if self.scheduler.get_request_state(request_id) is not None:
                 self.scheduler.finish_requests(request_id, DiffusionRequestStatus.FINISHED_ABORTED)
+        self._remove_diffusion_kv_requests(request_ids)
 
     def _finalize_finished_request(
         self,
diff --git a/vllm_omni/diffusion/diffusion_kv/kv_connector.py b/vllm_omni/diffusion/diffusion_kv/kv_connector.py
index 47c609860..eaa478300 100644
--- a/vllm_omni/diffusion/diffusion_kv/kv_connector.py
+++ b/vllm_omni/diffusion/diffusion_kv/kv_connector.py
@@ -1,35 +1,40 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Diffusion-side assembly facade built on the upstream Mooncake KV connector.
-
-The configured ``kv_connector`` (currently ``MooncakeConnector``) is created
-through vLLM's native ``KVConnectorFactory``. PR0 only validates configuration
-and creates the Scheduler/Worker connector objects; it does not subclass or
-reimplement Mooncake's transfer runtime. Real page sizing, cache registration,
-admission, and remote loading belong to the follow-up landing PR.
-"""
+"""Assemble native vLLM KV connectors for Scheduler-owned diffusion pages."""
 
 from __future__ import annotations
 
+import math
+import time
+from collections import Counter
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any
 
-import torch
 from vllm.config import KVTransferConfig, VllmConfig
 from vllm.distributed.kv_transfer.kv_connector.factory import KVConnectorFactory
 from vllm.distributed.kv_transfer.kv_connector.v1.base import KVConnectorRole
 from vllm.distributed.kv_transfer.kv_transfer_state import ensure_kv_transfer_initialized, ensure_kv_transfer_shutdown
 from vllm.logger import init_logger
+from vllm.v1.core.kv_cache_manager import KVCacheBlocks
 from vllm.v1.kv_cache_interface import KVCacheConfig
+from vllm.v1.outputs import KVConnectorOutput
 
 if TYPE_CHECKING:
     from vllm.distributed.kv_transfer.kv_connector.v1.base import KVConnectorBase_V1
+    from vllm.v1.core.kv_cache_manager import KVCacheManager
+    from vllm.v1.worker.gpu.kv_connector import ActiveKVConnector
 
     from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.diffusion_kv.request import DiffusionKVRequest
+    from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput
 
 logger = init_logger(__name__)
 
 
+class KVTransferRegistrationError(ValueError):
+    """A failed handoff whose destination pages have not been dispatched."""
+
+
 def mint_transfer_id(request_id: str) -> str:
     """Return the stable ticket shared by one AR -> Diffusion handoff."""
 
@@ -110,6 +115,8 @@ def parse_kv_transfer_config(value: object | None) -> KVTransferConfig | None:
 
 def create_scheduler_kv_connector(
     od_config: OmniDiffusionConfig,
+    kv_cache_config: KVCacheConfig | None = None,
+    vllm_config: VllmConfig | None = None,
 ) -> KVConnectorBase_V1 | None:
     """Create a Scheduler-role connector when native config is present."""
 
@@ -121,14 +128,15 @@ def create_scheduler_kv_connector(
             f"Diffusion native kv_transfer_config must be KVTransferConfig, got {type(kv_transfer_config)!r}"
         )
 
-    vllm_config = _build_native_vllm_config(od_config)
+    if kv_cache_config is None or vllm_config is None:
+        raise ValueError("KV transfer requires paged_scheduler and a native cache configuration")
     connector = KVConnectorFactory.create_connector(
         config=vllm_config,
         role=KVConnectorRole.SCHEDULER,
-        kv_cache_config=_empty_kv_cache_config(),
+        kv_cache_config=kv_cache_config,
     )
     logger.info(
-        "Created KV connector stub (SCHEDULER role): connector=%s engine_id=%s",
+        "Created KV connector (SCHEDULER role): connector=%s engine_id=%s",
         kv_transfer_config.kv_connector,
         kv_transfer_config.engine_id,
     )
@@ -140,9 +148,27 @@ def init_worker_kv_connector(vllm_config: VllmConfig, kv_cache_config: KVCacheCo
 
     if vllm_config.kv_transfer_config is None:
         return
-    ensure_kv_transfer_initialized(vllm_config, kv_cache_config)
+    import vllm.distributed.parallel_state as parallel_state
+
+    from vllm_omni.diffusion.distributed.parallel_state import get_sp_group
+
+    # vLLM 0.29 Mooncake snapshots tp_rank/tp_size in its Worker constructor;
+    # consumer receive/region mapping use those saved values, not get_tp_group.
+    # Restrict this compatibility bridge to that connector and restore the
+    # model's TP group even when construction fails. Never remap model TP for
+    # the connector's entire lifetime (it would change model collectives).
+    tp_group = parallel_state._TP
+    parallel_config = getattr(vllm_config, "parallel_config", None)
+    if getattr(parallel_config, "prefill_context_parallel_size", 1) > 1 and tp_group.world_size == 1:
+        if vllm_config.kv_transfer_config.kv_connector != "MooncakeConnector":
+            raise ValueError("Native SP KV transfer currently requires MooncakeConnector")
+        parallel_state._TP = get_sp_group()
+    try:
+        ensure_kv_transfer_initialized(vllm_config, kv_cache_config)
+    finally:
+        parallel_state._TP = tp_group
     logger.info(
-        "Initialized KV connector stub (WORKER role): connector=%s engine_id=%s",
+        "Initialized KV connector (WORKER role): connector=%s engine_id=%s",
         vllm_config.kv_transfer_config.kv_connector,
         vllm_config.kv_transfer_config.engine_id,
     )
@@ -156,26 +182,165 @@ def shutdown_kv_connector(*, scheduler_connector: KVConnectorBase_V1 | None = No
     ensure_kv_transfer_shutdown()
 
 
-def _empty_kv_cache_config() -> KVCacheConfig:
-    """Empty cache config used only for PR0 connector assembly."""
-
-    return KVCacheConfig(num_blocks=0, kv_cache_tensors=[], kv_cache_groups=[])
+def prepare_kv_requests(requests: tuple[DiffusionKVRequest, ...], params: Mapping[str, Any]) -> None:
+    for request in requests:
+        request.kv_transfer_params = dict(params)
+        num_tokens = min(len(request.prompt_token_ids), params["num_transfer_tokens"])
+        request.prompt_token_ids = request.prompt_token_ids[:num_tokens]
+        request.num_prompt_tokens = num_tokens
 
 
-def _build_native_vllm_config(od_config: OmniDiffusionConfig) -> VllmConfig:
-    from vllm_omni.diffusion.vllm_config import create_diffusion_vllm_config
+def install_mooncake_cfg_fanout(connector: KVConnectorBase_V1) -> None:
+    """Account for multiple CFG destinations on one native Mooncake ticket.
 
-    kv_transfer_config = getattr(od_config, "kv_transfer_config", None)
-    assert isinstance(kv_transfer_config, KVTransferConfig)
-    vllm_config = create_diffusion_vllm_config(torch.device("cpu"), od_config)
-    vllm_config.kv_transfer_config = kv_transfer_config
-    return vllm_config
+    vLLM 0.29 initializes ``need_send`` to the paired consumer rank count,
+    but increments ``sent`` per consumer request. Adapt only this producer
+    instance, after KV initialization and before serving requests. Keep the
+    upstream address planning, transport, timeout and completion code intact.
+    """
+    from vllm.distributed.kv_transfer.kv_connector.v1.mooncake.mooncake_connector import MooncakeConnector
+
+    if not isinstance(connector, MooncakeConnector):
+        return
+    worker = connector.connector_worker
+    if worker is None or worker.is_kv_consumer or getattr(worker, "_omni_cfg_fanout_installed", False):
+        return
+    build_transfer_params = worker._build_transfer_params
+
+    async def build_with_fanout(ready_reqs, agent_meta, local_regions, remote_regions):
+        # commit_kv_load registers all rows before build_connector_meta. Thus
+        # each rank's message contains the complete row set for each ticket,
+        # including empty-block notifications. Count the full message, not
+        # just the subset whose producer-ready events fired in this iteration.
+        rows_per_ticket = Counter(transfer_id for transfer_id, _ in agent_meta.req_blocks.values())
+        tickets = {send_meta.transfer_id: send_meta for _, send_meta in ready_reqs}
+        for transfer_id, send_meta in tickets.items():
+            rows = rows_per_ticket[transfer_id]
+            previous = getattr(send_meta, "_omni_cfg_rows", None)
+            if rows < 1 or (previous is not None and previous != rows):
+                # Use the upstream transfer-error path: it decrements sending
+                # without incrementing sent, so a malformed rank cannot free
+                # source pages still needed by another rank.
+                return [], [], [], [req_id for req_id, _ in ready_reqs], "Inconsistent Mooncake CFG receive count"
+        # No await between checking and updating: all handlers run on the
+        # sender loop. The marker belongs to the ticket, not to a request-global
+        # variable; it disappears with the upstream ticket on completion/expiry.
+        for transfer_id, send_meta in tickets.items():
+            if getattr(send_meta, "_omni_cfg_rows", None) is None:
+                send_meta.need_send *= rows_per_ticket[transfer_id]
+                send_meta._omni_cfg_rows = rows_per_ticket[transfer_id]
+        return await build_transfer_params(ready_reqs, agent_meta, local_regions, remote_regions)
+
+    worker._build_transfer_params = build_with_fanout  # type: ignore[method-assign]
+    setattr(worker, "_omni_cfg_fanout_installed", True)
+
+
+def commit_kv_load(
+    connector: KVConnectorBase_V1,
+    manager: KVCacheManager,
+    requests: tuple[DiffusionKVRequest, ...],
+    matched_tokens: list[int],
+) -> set[str]:
+    expected = set()
+    allocations = []
+    # All rows sharing a transfer_id must reach the same connector metadata:
+    # the producer uses this complete per-rank row set for fan-out accounting.
+    # Validate every CFG row before mutating any connector state.
+    for request, num_tokens in zip(requests, matched_tokens, strict=True):
+        blocks = manager.get_blocks(request.request_id)
+        # Mooncake's producer advertises complete physical blocks. Keep every
+        # CFG receiver on that same block boundary so the native connector can
+        # use its normal one-to-one page mapping even when the branches have
+        # different logical prefix lengths. Bytes beyond ``num_tokens`` are
+        # not marked computed and are overwritten by the DiT prefill.
+        transfer_tokens = num_tokens
+        if num_tokens > 0 and request.kv_transfer_params is not None:
+            transfer_tokens = request.kv_transfer_params["num_transfer_tokens"]
+            if type(transfer_tokens) is not int or not num_tokens <= transfer_tokens <= request.num_tokens:
+                raise KVTransferRegistrationError(
+                    "Diffusion KV transfer boundary must cover the reusable prefix "
+                    f"without exceeding the allocated sequence: reusable={num_tokens}, "
+                    f"transfer={transfer_tokens!r}, allocated={request.num_tokens}"
+                )
+        prefix_blocks = KVCacheBlocks(
+            tuple(
+                group[: (transfer_tokens + spec.kv_cache_spec.block_size - 1) // spec.kv_cache_spec.block_size]
+                for group, spec in zip(blocks.blocks, manager.kv_cache_config.kv_cache_groups, strict=True)
+            )
+        )
+        allocations.append((request, prefix_blocks, num_tokens))
+    try:
+        for request, prefix_blocks, num_tokens in allocations:
+            connector.update_state_after_alloc(request, prefix_blocks, num_tokens)
+            request.num_computed_tokens = num_tokens
+            if request.kv_transfer_params is not None:
+                expected.add(request.request_id)
+    except Exception as exc:
+        from vllm.distributed.kv_transfer.kv_connector.v1.mooncake.mooncake_connector import MooncakeConnector
+        from vllm.v1.request import RequestStatus
+
+        if not isinstance(connector, MooncakeConnector):
+            # Unknown connectors may have started I/O during registration.
+            raise
+        # Mooncake only queues metadata here; no Worker has seen addresses yet.
+        # Re-arm its pre-scheduling abort hook to replace even partially
+        # registered CFG receives with empty-block notifications to the producer.
+        for request in requests:
+            if request.kv_transfer_params is not None:
+                request.kv_transfer_params["do_remote_prefill"] = True
+                request.status = RequestStatus.FINISHED_ABORTED
+                delay_free, _ = connector.request_finished(request, [])
+                if delay_free:
+                    raise RuntimeError("Connector could not cancel an undispatched KV load") from exc
+        raise KVTransferRegistrationError(f"Could not register diffusion KV receive: {exc}") from exc
+    return expected
+
+
+def wait_for_kv_load(
+    active_connector: ActiveKVConnector, scheduler_output: DiffusionSchedulerOutput, timeout: float
+) -> KVConnectorOutput:
+    connector = active_connector.kv_connector
+    active_connector.pre_forward(scheduler_output)
+    pending = set(scheduler_output.kv_transfer_request_ids)
+    finished_ids = scheduler_output.kv_finished_request_ids
+    if not pending:
+        output = active_connector.post_forward(finished_ids)
+        if output.invalid_block_ids:
+            raise RuntimeError("Diffusion KV connector reported invalid remote pages")
+        return output
+
+    received, sent = set(), set()
+    deadline = time.monotonic() + timeout
+    while True:
+        finished_sending, finished_recving = connector.get_finished(finished_ids)
+        sent.update(finished_sending or ())
+        received.update(finished_recving or ())
+        pending.difference_update(received)
+        if connector.get_block_ids_with_load_errors():
+            raise RuntimeError("Diffusion KV connector reported invalid remote pages")
+        if not pending:
+            break
+        if time.monotonic() >= deadline:
+            # A timeout is not a cancellation acknowledgement. Return partial
+            # completion; Scheduler quarantines the remaining destination pages.
+            break
+        time.sleep(0.001)
+    output = active_connector.post_forward(finished_ids)
+    output.finished_sending = sent | (output.finished_sending or set())
+    output.finished_recving = received | (output.finished_recving or set())
+    if output.invalid_block_ids:
+        raise RuntimeError("Diffusion KV connector reported invalid remote pages")
+    return output
 
 
 def _validate_kv_transfer_config(config: KVTransferConfig) -> None:
     engine_id = config.engine_id
     if not isinstance(engine_id, str) or not engine_id.strip():
         raise ValueError("Diffusion native kv_transfer_config requires a non-empty engine_id")
+    extra_config = config.kv_connector_extra_config or {}
+    timeout = extra_config.get("transfer_timeout", 60.0)
+    if isinstance(timeout, bool) or not isinstance(timeout, (int, float)) or not math.isfinite(timeout) or timeout <= 0:
+        raise ValueError("Diffusion transfer_timeout must be a positive finite number of seconds")
     if config.kv_connector is not None and config.kv_role is None:
         raise ValueError("Diffusion native kv_transfer_config requires kv_role when kv_connector is set")
     if config.kv_role not in (None, "kv_consumer", "kv_producer", "kv_both"):
diff --git a/vllm_omni/diffusion/diffusion_kv/manager.py b/vllm_omni/diffusion/diffusion_kv/manager.py
index eee51b864..3b2fb3b42 100644
--- a/vllm_omni/diffusion/diffusion_kv/manager.py
+++ b/vllm_omni/diffusion/diffusion_kv/manager.py
@@ -8,6 +8,7 @@ from collections.abc import Sequence
 from vllm.v1.core.kv_cache_manager import KVCacheManager
 from vllm.v1.kv_cache_interface import KVCacheConfig
 
+from vllm_omni.core.sched.utils import free_kv_blocks_in_physical_order
 from vllm_omni.diffusion.diffusion_kv.metadata import (
     DiffusionKVMetadata,
     DiffusionKVSequenceMetadata,
@@ -179,7 +180,7 @@ class DiffusionKVCacheManager:
         requests = self._requests.pop(public_request_id, ())
         self._metadata.pop(public_request_id, None)
         for request in reversed(requests):
-            self.native_manager.free(request)
+            free_kv_blocks_in_physical_order(self.native_manager, request)
             self._internal_request_ids.discard(request.request_id)
 
     def close(self) -> None:
@@ -188,4 +189,4 @@ class DiffusionKVCacheManager:
 
     def _rollback(self, requests: Sequence[DiffusionKVRequest]) -> None:
         for request in reversed(requests):
-            self.native_manager.free(request)
+            free_kv_blocks_in_physical_order(self.native_manager, request)
diff --git a/vllm_omni/diffusion/diffusion_kv/metadata.py b/vllm_omni/diffusion/diffusion_kv/metadata.py
index db6cb54ec..19ecd1dc3 100644
--- a/vllm_omni/diffusion/diffusion_kv/metadata.py
+++ b/vllm_omni/diffusion/diffusion_kv/metadata.py
@@ -41,6 +41,7 @@ class DiffusionKVSequenceMetadata:
     seq_len: int
     block_ids: tuple[list[int], ...]
     context_ids: tuple[str, ...] = ()
+    num_computed_tokens: int = 0
 
 
 @dataclass
diff --git a/vllm_omni/diffusion/diffusion_kv/model_runner_backend.py b/vllm_omni/diffusion/diffusion_kv/model_runner_backend.py
index 20f4db165..578946cb0 100644
--- a/vllm_omni/diffusion/diffusion_kv/model_runner_backend.py
+++ b/vllm_omni/diffusion/diffusion_kv/model_runner_backend.py
@@ -190,6 +190,10 @@ class DiffusionKVModelRunnerBackend:
             )
         return ulysses_degree
 
+    @property
+    def kv_caches_by_layer(self) -> dict[str, torch.Tensor]:
+        return {name: layer.kv_cache for name, layer in self._kv_cache_layer_adapters.items()}
+
     def _get_max_rows_per_request(self) -> int:
         max_rows = getattr(self.od_config, "diffusion_kv_max_rows_per_request", None)
         if type(max_rows) is not int or max_rows <= 0:
@@ -245,7 +249,9 @@ class DiffusionKVModelRunnerBackend:
             for capacity, block_size in zip(unaligned_max_num_blocks_per_group, block_sizes, strict=True)
         ]
 
-        max_num_reqs = max_num_seqs * max_rows_per_request
+        max_num_reqs = max_num_seqs
+        if max_num_reqs % max_rows_per_request:
+            raise ValueError("scheduler_config.max_num_seqs must be a multiple of diffusion_kv_max_rows_per_request")
         max_num_batched_tokens = getattr(scheduler_config, "max_num_batched_tokens", None)
         if type(max_num_batched_tokens) is not int or max_num_batched_tokens <= 0:
             raise ValueError("scheduler_config.max_num_batched_tokens must be a positive integer")
@@ -254,9 +260,6 @@ class DiffusionKVModelRunnerBackend:
         cp_rank = get_dcp_group().rank_in_group if cp_size > 1 else 0
         cp_interleave = parallel_config.cp_kv_cache_interleave_size
 
-        # Native metadata builders size per-row buffers from max_num_seqs.
-        # A diffusion public request can occupy several sequence/context rows.
-        scheduler_config.max_num_seqs = max_num_reqs
         kv_caches: list[torch.Tensor | list[torch.Tensor]] = []
         previous_adapter_caches = {
             layer_name: adapter.kv_cache for layer_name, adapter in self._kv_cache_layer_adapters.items()
@@ -303,7 +306,6 @@ class DiffusionKVModelRunnerBackend:
                     self.vllm_config,
                 )
         except Exception:
-            scheduler_config.max_num_seqs = max_num_seqs
             for layer_name, previous_cache in previous_adapter_caches.items():
                 self._kv_cache_layer_adapters[layer_name].kv_cache = previous_cache
             raise
@@ -591,7 +593,7 @@ class DiffusionKVModelRunnerBackend:
                     )
         raise RuntimeError(f"Diffusion KV request state is missing logical length for {identity!r}")
 
-    def remove_diffusion_kv_requests(self, request_ids: list[str]) -> int:
+    def remove_diffusion_kv_requests(self, request_ids: list[str | tuple[str, int]]) -> int:
         """Retire Worker rows without logically freeing Scheduler-owned blocks."""
         if (
             not is_scheduler_paged_kv_mode(
@@ -600,11 +602,25 @@ class DiffusionKVModelRunnerBackend:
             or self.block_tables is None
         ):
             return 0
-        request_id_set = set(request_ids)
+        request_generations = {
+            request_id: generation
+            for item in request_ids
+            if isinstance(item, tuple)
+            for request_id, generation in (item,)
+            if isinstance(request_id, str) and type(generation) is int
+        }
+        request_id_set = {item if isinstance(item, str) else item[0] for item in request_ids}
         identities_and_rows = [
             (identity, row)
             for identity, row in self._diffusion_kv_identity_to_row.items()
             if identity[0] in request_id_set
+            and (
+                identity[0] not in request_generations
+                or (
+                    (request_state := self._diffusion_kv_request_states.get(identity[0])) is not None
+                    and request_state.generation == request_generations[identity[0]]
+                )
+            )
         ]
         rows = [row for _, row in identities_and_rows]
         if rows:
@@ -620,9 +636,10 @@ class DiffusionKVModelRunnerBackend:
             ]
             self._apply_rows(rows, installs)
 
+        removed_request_ids = {identity[0] for identity, _ in identities_and_rows}
         for identity, _ in identities_and_rows:
             del self._diffusion_kv_identity_to_row[identity]
-        for request_id in request_id_set:
+        for request_id in removed_request_ids:
             self._diffusion_kv_request_states.pop(request_id, None)
         self._diffusion_kv_free_rows.extend(rows)
         self._diffusion_kv_free_rows.sort(reverse=True)
diff --git a/vllm_omni/diffusion/diffusion_kv/paged_attention_adapter.py b/vllm_omni/diffusion/diffusion_kv/paged_attention_adapter.py
index a76a5434c..697f0b968 100644
--- a/vllm_omni/diffusion/diffusion_kv/paged_attention_adapter.py
+++ b/vllm_omni/diffusion/diffusion_kv/paged_attention_adapter.py
@@ -84,12 +84,14 @@ class DiffusionPagedAttentionLayerAdapter(AttentionLayerBase):
         attention_config = vllm_config.attention_config
         previous_backend = attention_config.backend
         previous_backend_per_kind = attention_config.backend_per_kind
+        previous_pcp_size = vllm_config.parallel_config.prefill_context_parallel_size
         try:
             # This is a portable vLLM backend request. The active platform
             # resolves it to its native implementation, such as FlashAttention
             # on CUDA or AscendAttentionBackend on NPU.
             attention_config.backend = AttentionBackendEnum.FLASH_ATTN
             attention_config.backend_per_kind = {}
+            vllm_config.parallel_config.prefill_context_parallel_size = 1
             with set_current_vllm_config(vllm_config):
                 attn_backend = get_attn_backend(
                     head_size=spec.head_size,
@@ -101,6 +103,7 @@ class DiffusionPagedAttentionLayerAdapter(AttentionLayerBase):
         finally:
             attention_config.backend = previous_backend
             attention_config.backend_per_kind = previous_backend_per_kind
+            vllm_config.parallel_config.prefill_context_parallel_size = previous_pcp_size
         attn_backend = current_omni_platform.get_diffusion_paged_kv_attn_backend(
             attn_backend,
             ulysses_degree=ulysses_degree,
@@ -758,6 +761,19 @@ class DiffusionPagedAttentionAdapter:
                 slot_mappings=slot_mappings,
                 causal=(row_segments[0].mode == "causal"),
             )
+            # FA2's ``num_splits=0`` auto policy selects SplitKV for these
+            # already-small piecewise calls. Reuse vLLM's supported metadata
+            # control to select the single-pass kernel and avoid its extra
+            # partial-output/reduction work. Leave newer native backends and
+            # metadata without this control untouched.
+            for layer_name, native_metadata in segment_metadata.items():
+                layer = self.layers.get(layer_name)
+                if (
+                    layer is not None
+                    and getattr(layer.impl, "vllm_flash_attn_version", None) == 2
+                    and hasattr(native_metadata, "max_num_splits")
+                ):
+                    native_metadata.max_num_splits = 1
             # FA3's full-CUDA-graph metadata builder reuses one persistent
             # scheduler buffer across builds. Piecewise attention prepares all
             # segments before executing any of them, so each segment needs its
@@ -901,9 +917,17 @@ class DiffusionPagedAttentionAdapter:
                 raise KeyError(
                     f"No piecewise native attention metadata was built for diffusion layer {layer_name!r}"
                 ) from exc
+        # Identical rows are sliced and packed once per segment by the
+        # homogeneous piecewise runner.  Keeping the projection view here
+        # avoids first copying the complete Q tensor only to copy each segment
+        # again immediately afterwards.  Other native paths still require one
+        # packed query buffer.
+        query_input = query_flat
+        if piecewise_plan is None or piecewise_plan.homogeneous_batch_shape is None:
+            query_input = query_flat.contiguous()
         return DiffusionPagedAttentionContext(
             layer=layer,
-            query=query_flat.contiguous(),
+            query=query_input,
             key_write=key_flat,
             value_write=value_flat,
             slot_mapping=slot_mapping,
diff --git a/vllm_omni/diffusion/diffusion_kv/request.py b/vllm_omni/diffusion/diffusion_kv/request.py
index 83f9bffdb..694af587c 100644
--- a/vllm_omni/diffusion/diffusion_kv/request.py
+++ b/vllm_omni/diffusion/diffusion_kv/request.py
@@ -113,8 +113,6 @@ class DiffusionKVRequest:
         self.shared_prefix_boundary = 0
         # Opaque request-scoped parameters consumed by an upstream KVConnector.
         self.kv_transfer_params = kv_transfer_params
-        # Mooncake derives the remote-load length from this list. PR0 carries
-        # the field without creating a placeholder or starting a load.
         self.prompt_token_ids = prompt_token_ids
 
     @property
diff --git a/vllm_omni/diffusion/distributed/autoencoders/wan_spatial_shard.py b/vllm_omni/diffusion/distributed/autoencoders/wan_spatial_shard.py
index ac5ea472b..16fdd13a4 100644
--- a/vllm_omni/diffusion/distributed/autoencoders/wan_spatial_shard.py
+++ b/vllm_omni/diffusion/distributed/autoencoders/wan_spatial_shard.py
@@ -505,22 +505,8 @@ class WanDistCausalConv3d(nn.Conv3d):
         self._trim_cache: dict[int, tuple[int, int, int]] = {}
 
     def forward(self, x: torch.Tensor, cache_x: torch.Tensor | None = None) -> torch.Tensor:
-        padding = list(self._padding)
-        if cache_x is not None and padding[4] > 0:
-            cache_x = cache_x.to(x.device)
-            x = torch.cat([cache_x, x], dim=2)
-            padding[4] -= cache_x.shape[2]
-
-        x = F.pad(x, padding)
-        x_padded, self._halo_recv_top_buf, self._halo_recv_bottom_buf = halo_exchange(
-            x,
-            group=self.group,
-            halo_size=self.halo_size,
-            split_dim=self.split_dim,
-            recv_top_buf=self._halo_recv_top_buf,
-            recv_bottom_buf=self._halo_recv_bottom_buf,
-        )
-        shift, start, upper_bound = self._get_trim_params(x.shape[self.split_tensor_dim])
+        x_padded, local_extent = self._assemble_input(x, cache_x)
+        shift, start, upper_bound = self._get_trim_params(local_extent)
         if shift:
             x_padded = _narrow_along_dim(
                 x_padded,
@@ -532,6 +518,83 @@ class WanDistCausalConv3d(nn.Conv3d):
         out = _trim_local_conv_output(out, self.halo_size, start, upper_bound, split_dim=self.split_dim)
         return _zero_invalid_extent(out, split_dim=self.split_dim)
 
+    def _assemble_input(self, x: torch.Tensor, cache_x: torch.Tensor | None) -> tuple[torch.Tensor, int]:
+        """Build the conv input -- cached frames, causal/spatial zero padding and the halo columns -- in one pass.
+
+        The straightforward version wrote the activation three times per call: ``torch.cat`` of the cached
+        frames, ``F.pad`` for the causal and spatial zeros, then another ``torch.cat`` to attach the halos the
+        neighbours sent. Every causal conv of the decoder runs this on every latent frame, so at 480x832 that
+        was the largest single source of memory traffic in the decode. Here the final tensor is allocated once
+        and the cached frames and the new frames are copied straight into their slots; only the padding slices
+        are zeroed. The halo rows are exchanged through contiguous send and receive buffers (a P2P op needs a
+        contiguous tensor and the halo slot of a 5D tensor is a strided view) and copied into their slots. The
+        conv sees the same tensor as before, byte for byte.
+
+        Returns the assembled tensor and the extent along the split dimension the trim parameters are keyed by
+        (the extent before halos, as ``halo_exchange`` saw it).
+        """
+        pad_w0, pad_w1, pad_h0, pad_h1, pad_t0, pad_t1 = self._padding
+        cache_frames = 0
+        if cache_x is not None and pad_t0 > 0:
+            cache_x = cache_x.to(x.device)
+            cache_frames = int(cache_x.shape[2])
+            pad_t0 -= cache_frames
+        assert pad_t0 >= 0, "Wan temporal cache exceeds the causal padding"
+        rank, world_size = _rank_world(self.group)
+        halo = self.halo_size if world_size > 1 else 0
+        halo_h = halo if self.split_dim == "height" else 0
+        halo_w = halo if self.split_dim == "width" else 0
+
+        batch, channels, frames, height, width = x.shape
+        top, left = pad_h0 + halo_h, pad_w0 + halo_w
+        total_frames = pad_t0 + cache_frames + frames + pad_t1
+        total_height = top + height + pad_h1 + halo_h
+        total_width = left + width + pad_w1 + halo_w
+        buf = torch.empty((batch, channels, total_frames, total_height, total_width), dtype=x.dtype, device=x.device)
+        # Zero only what the conv must read as zeros: the causal frames in
+        # front (and any trailing ones) and the spatial padding rows/columns.
+        # The halo columns are filled below.
+        if pad_t0:
+            buf[:, :, :pad_t0].zero_()
+        if pad_t1:
+            buf[:, :, total_frames - pad_t1 :].zero_()
+        if pad_h0:
+            buf[:, :, :, halo_h:top].zero_()
+        if pad_h1:
+            buf[:, :, :, total_height - halo_h - pad_h1 : total_height - halo_h].zero_()
+        if pad_w0:
+            buf[:, :, :, :, halo_w:left].zero_()
+        if pad_w1:
+            buf[:, :, :, :, total_width - halo_w - pad_w1 : total_width - halo_w].zero_()
+        interior = buf[:, :, pad_t0 : pad_t0 + cache_frames + frames, top : top + height, left : left + width]
+        if cache_frames:
+            interior[:, :, :cache_frames].copy_(cache_x)
+            interior[:, :, cache_frames:].copy_(x)
+        else:
+            interior.copy_(x)
+
+        dim = self.split_tensor_dim
+        local_extent = buf.shape[dim] - 2 * halo
+        if halo:
+            # What halo_exchange sends: the padded tensor's first and last
+            # ``halo`` rows along the split dimension, padding included.
+            top_row_ref = _narrow_along_dim(buf, dim, halo, halo)
+            bottom_row_ref = _narrow_along_dim(buf, dim, buf.shape[dim] - 2 * halo, halo)
+            self._halo_recv_top_buf = _ensure_recv_buf(self._halo_recv_top_buf, top_row_ref)
+            self._halo_recv_bottom_buf = _ensure_recv_buf(self._halo_recv_bottom_buf, bottom_row_ref)
+            _halo_exchange_p2p(
+                rank=rank,
+                world_size=world_size,
+                group=self.group,
+                top_row_ref=top_row_ref,
+                bottom_row_ref=bottom_row_ref,
+                recv_top_buf=self._halo_recv_top_buf,
+                recv_bottom_buf=self._halo_recv_bottom_buf,
+            )
+            _narrow_along_dim(buf, dim, 0, halo).copy_(self._halo_recv_top_buf)
+            _narrow_along_dim(buf, dim, buf.shape[dim] - halo, halo).copy_(self._halo_recv_bottom_buf)
+        return buf, local_extent
+
     def _get_trim_params(self, local_extent: int) -> tuple[int, int, int]:
         trim_params = self._trim_cache.get(local_extent)
         if trim_params is None:
diff --git a/vllm_omni/diffusion/distributed/parallel_state.py b/vllm_omni/diffusion/distributed/parallel_state.py
index 335418254..858a2e398 100644
--- a/vllm_omni/diffusion/distributed/parallel_state.py
+++ b/vllm_omni/diffusion/distributed/parallel_state.py
@@ -438,6 +438,17 @@ def init_distributed_environment(
             "world group already initialized with a different world size"
         )
 
+    # Now, initialize vLLM's distributed environment; we need to do this before initializing
+    # model parallel in Omni. Otherwise, if we use vLLM's native coordinator, we may run into
+    # issues with _NODE_COUNT / _WORLD (in vLLM, not the Omni _WORLD var above) being unset.
+    vllm_parallel_state.init_distributed_environment(
+        world_size=world_size,
+        rank=rank,
+        distributed_init_method=distributed_init_method,
+        local_rank=local_rank,
+        backend=backend,
+    )
+
 
 def model_parallel_is_initialized():
     """Check if tensor and pipeline parallel groups are initialized."""
@@ -1061,8 +1072,8 @@ def destroy_distributed_environment():
     if _WORLD:
         _WORLD.destroy()
     _WORLD = None
-    if torch.distributed.is_initialized():
-        torch.distributed.destroy_process_group()
+    # We only need to destroy / clear the Omni world; this takes care of the torch process groups
+    vllm_parallel_state.destroy_distributed_environment()
 
 
 def destroy_distributed_env():
diff --git a/vllm_omni/diffusion/executor/abstract.py b/vllm_omni/diffusion/executor/abstract.py
index f15db04bd..9b0f71e23 100644
--- a/vllm_omni/diffusion/executor/abstract.py
+++ b/vllm_omni/diffusion/executor/abstract.py
@@ -1,13 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from dataclasses import replace
 from typing import TYPE_CHECKING, Any
 
 from vllm.utils.import_utils import resolve_obj_by_qualname
 from vllm.v1.kv_cache_interface import KVCacheConfig, KVCacheSpec
+from vllm.v1.outputs import KVConnectorOutput
 
 from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.sched.interface import CachedRequestData
 
 if TYPE_CHECKING:
     from vllm_omni.diffusion.request import OmniDiffusionRequest
@@ -159,7 +165,7 @@ class DiffusionExecutor(ABC):
         # ranks are not silently dropped.
         self.collective_rpc("set_kv_cache_configs", args=(kv_cache_configs, resolved_max_model_len))
 
-    def remove_diffusion_kv_requests(self, request_ids: list[str]) -> None:
+    def remove_diffusion_kv_requests(self, request_ids: list[str | tuple[str, int]]) -> None:
         """Clear request rows on every Worker after Scheduler retirement."""
 
         unique_request_ids = list(dict.fromkeys(request_ids))
@@ -170,6 +176,35 @@ class DiffusionExecutor(ABC):
             args=(unique_request_ids,),
         )
 
+    def prepare_kv_for_forward(self, scheduler_output: DiffusionSchedulerOutput) -> KVConnectorOutput | None:
+        if scheduler_output.kv_connector_metadata is None:
+            return
+        transfer_output = replace(
+            scheduler_output,
+            scheduled_new_reqs=[],
+            scheduled_cached_reqs=CachedRequestData.make_empty(),
+            kv_prefetch_job=None,
+        )
+        outputs: list[KVConnectorOutput] = self.collective_rpc(
+            "prepare_kv_for_forward",
+            args=(transfer_output,),
+            unique_reply_rank=0,
+            exec_all_ranks=True,
+        )
+        if len(outputs) != self.od_config.num_gpus or any(output.invalid_block_ids for output in outputs):
+            # Missing ranks / invalid pages cannot establish safe ownership.
+            raise RuntimeError("Diffusion KV receive failed on one or more ranks")
+        completed = getattr(self, "_kv_receive_completed_ranks", {})
+        for rank, output in enumerate(outputs):
+            for request_id in output.finished_recving or ():
+                completed.setdefault(request_id, set()).add(rank)
+        finished = {request_id for request_id, ranks in completed.items() if len(ranks) == len(outputs)}
+        for request_id in finished:
+            del completed[request_id]
+        self._kv_receive_completed_ranks = completed
+        outputs[0].finished_recving = finished
+        return outputs[0]
+
     @abstractmethod
     def shutdown(self) -> None:
         """Shutdown the executor and release resources."""
diff --git a/vllm_omni/diffusion/forward_context.py b/vllm_omni/diffusion/forward_context.py
index 1459da495..496f384d7 100644
--- a/vllm_omni/diffusion/forward_context.py
+++ b/vllm_omni/diffusion/forward_context.py
@@ -282,6 +282,47 @@ def set_forward_context_denoise_step_idx(step_idx: int | None) -> None:
                 ensure_active(step_idx)
 
 
+def get_paged_kv_computed_tokens() -> tuple[int, ...]:
+    runtime = _forward_context.paged_kv_runtime if _forward_context is not None else None
+    if runtime is None:
+        return ()
+    return tuple(row.kv_start_pos for row in runtime.metadata.prefill_rows)
+
+
+@contextmanager
+def paged_kv_prefill(sequence_id: int, num_tokens: int):
+    from dataclasses import replace
+
+    runtime = get_forward_context().paged_kv_runtime
+    if runtime is None:
+        raise RuntimeError("Paged KV prefill requires an active runtime")
+    rows = runtime.metadata.prefill_rows
+    matching_rows = [row for row in rows if row.sequence_id == sequence_id]
+    if len(matching_rows) != 1:
+        raise ValueError(
+            f"Paged KV prefill requires exactly one active row for sequence {sequence_id}; found {len(matching_rows)}"
+        )
+    row = matching_rows[0]
+    if type(num_tokens) is not int or not row.kv_start_pos < num_tokens <= row.seq_len:
+        raise ValueError(
+            "Paged KV prefill target must extend the active prefix without exceeding its allocation: "
+            f"start={row.kv_start_pos}, target={num_tokens!r}, allocated={row.seq_len}"
+        )
+    prefill = replace(row, query_len=num_tokens - row.kv_start_pos, seq_len=num_tokens)
+    batch = runtime.adapter.prepare_batch((prefill,))
+    with runtime.adapter.activate(batch):
+        yield
+    runtime.metadata = replace(
+        runtime.metadata,
+        prefill_rows=tuple(
+            replace(item, kv_start_pos=num_tokens, query_len=item.seq_len - num_tokens)
+            if item.sequence_id == sequence_id
+            else item
+            for item in rows
+        ),
+    )
+
+
 def set_forward_context_denoise_timestep(timestep: float | None) -> None:
     """Set the normalized (descending, 1 -> 0) denoise timestep.
 
diff --git a/vllm_omni/diffusion/interaction/coordinator.py b/vllm_omni/diffusion/interaction/coordinator.py
index 5b4986d88..d99f3e47a 100644
--- a/vllm_omni/diffusion/interaction/coordinator.py
+++ b/vllm_omni/diffusion/interaction/coordinator.py
@@ -11,8 +11,9 @@ from vllm_omni.diffusion.interaction.types import (
     InteractionChunkMetadata,
     InteractionPayload,
     merge_interaction_metadata,
+    synchronized_monotonic_time,
 )
-from vllm_omni.diffusion.models.interface import supports_interaction_apply
+from vllm_omni.diffusion.models.interface import SupportsInteractionApply, supports_interaction_apply
 from vllm_omni.diffusion.worker.utils import StepRequestState
 
 if TYPE_CHECKING:
@@ -52,7 +53,7 @@ class InteractionCoordinator:
 
     @property
     def needs_chunk_media(self) -> bool:
-        """Whether any registered handler needs chunk ``num_frames``/``fps``."""
+        """Whether any registered handler needs chunk media/latent counts + fps."""
         return any(handler.needs_chunk_media for handler in self._handlers.values())
 
     def get_handler(self, modality: str) -> InteractionHandler:
@@ -83,31 +84,109 @@ class InteractionCoordinator:
             transition_chunks=transition_chunks,
         )
 
+    def enqueue_parts(
+        self,
+        state: StepRequestState,
+        *,
+        parts: list[tuple[str, InteractionPayload]],
+        event_id: str,
+        received_at: float,
+        transition_chunks: int | None,
+    ) -> None:
+        """Ensure every modality is supported and every payload validates, then enqueue.
+
+        Composite events must not partially mutate queues when a later track is
+        unsupported or carries an invalid payload.
+        """
+        if not parts:
+            raise ValueError("interaction event requires prompt and/or multi_modal_data")
+
+        # Reconcile rank-local samples so USP/SP shards share one arrival time.
+        received_at = synchronized_monotonic_time(received_at)
+
+        handlers = [(self.get_handler(modality), payload) for modality, payload in parts]
+        for handler, payload in handlers:
+            handler.validate_payload(
+                state,
+                event_id=event_id,
+                payload=payload,
+                transition_chunks=transition_chunks,
+            )
+        for (modality, payload), (handler, _) in zip(parts, handlers, strict=True):
+            del handler
+            self.enqueue(
+                state,
+                modality=modality,
+                event_id=event_id,
+                received_at=received_at,
+                payload=payload,
+                transition_chunks=transition_chunks,
+            )
+
+    def maybe_prepare_initial_session(
+        self,
+        state: StepRequestState,
+        pipeline: SupportsInteractionApply,
+    ) -> InteractionChunkMetadata:
+        """Materialize non-lazy modality sessions before chunk 0 denoise.
+
+        Handlers with ``lazy_initialize_session=False`` (e.g. camera) must exist
+        before the first chunk even with no client enqueue.
+        """
+        num_media_frames: int | None = None
+        fps: float | None = None
+        num_latent_frames: int | None = None
+        if any(
+            (not handler.lazy_initialize_session) and handler.needs_chunk_media for handler in self._handlers.values()
+        ):
+            media = pipeline.peek_chunk_media(state)
+            num_media_frames = media.num_media_frames
+            fps = media.fps
+            num_latent_frames = media.num_latent_frames
+
+        boundary_at = synchronized_monotonic_time()
+        chunk_index = state.chunk_index
+        metas: list[InteractionChunkMetadata] = []
+        for handler in self._handlers_in_apply_order():
+            if handler.lazy_initialize_session:
+                continue
+            meta = handler.apply_at_chunk_boundary(
+                state,
+                boundary_at=boundary_at,
+                chunk_index=chunk_index,
+                num_media_frames=num_media_frames,
+                fps=fps,
+                num_latent_frames=num_latent_frames,
+            )
+            if meta is not None:
+                metas.append(meta)
+        return merge_interaction_metadata(metas)
+
     def apply_at_chunk_boundary(
         self,
         state: StepRequestState,
         *,
         boundary_at: float,
         chunk_index: int | None = None,
-        num_frames: int | None = None,
+        num_media_frames: int | None = None,
         fps: float | None = None,
+        num_latent_frames: int | None = None,
     ) -> InteractionChunkMetadata:
         """Fan out chunk-boundary apply to handlers in stable order (prompt first)."""
         if chunk_index is None:
             chunk_index = state.chunk_index
         metas: list[InteractionChunkMetadata] = []
         for handler in self._handlers_in_apply_order():
-            if handler.modality not in state.interaction_sessions:
-                # This function is always called at chunk boundary without knowing if an interaction is really enqueued.
-                # `state.interaction_sessions[this modality]` is lazy-populated after the first interaction is enqueued.
-                # So, check here and skip a modality handler if this modality's session is not yet created.
+            if handler.lazy_initialize_session and handler.modality not in state.interaction_sessions:
+                # Lazy modalities skip apply until the first enqueue creates the session.
                 continue
             meta = handler.apply_at_chunk_boundary(
                 state,
                 boundary_at=boundary_at,
                 chunk_index=chunk_index,
-                num_frames=num_frames,
+                num_media_frames=num_media_frames,
                 fps=fps,
+                num_latent_frames=num_latent_frames,
             )
             if meta is not None:
                 metas.append(meta)
diff --git a/vllm_omni/diffusion/interaction/mixin.py b/vllm_omni/diffusion/interaction/mixin.py
index 366e90588..8627ec591 100644
--- a/vllm_omni/diffusion/interaction/mixin.py
+++ b/vllm_omni/diffusion/interaction/mixin.py
@@ -4,9 +4,9 @@
 
 from __future__ import annotations
 
-import time
 from typing import TYPE_CHECKING, cast
 
+from vllm_omni.diffusion.interaction.types import synchronized_monotonic_time
 from vllm_omni.diffusion.models.interface import SupportsInteractionApply
 from vllm_omni.diffusion.worker.utils import StepRequestState
 
@@ -35,18 +35,21 @@ class InteractionMixin:
                 "onto the pipeline before chunked generation"
             )
 
-        num_frames: int | None = None
+        num_media_frames: int | None = None
         fps: float | None = None
+        num_latent_frames: int | None = None
         if self._interaction_coordinator.needs_chunk_media:
             media = cast(SupportsInteractionApply, self).peek_chunk_media(state)
-            num_frames = media.num_frames
+            num_media_frames = media.num_media_frames
             fps = media.fps
+            num_latent_frames = media.num_latent_frames
 
         merged = self._interaction_coordinator.apply_at_chunk_boundary(
             state,
-            boundary_at=time.monotonic(),
-            num_frames=num_frames,
+            boundary_at=synchronized_monotonic_time(),
+            num_media_frames=num_media_frames,
             fps=fps,
+            num_latent_frames=num_latent_frames,
         )
         state.interaction_chunk_metadata = merged
 
diff --git a/vllm_omni/diffusion/interaction/modality_handlers/base.py b/vllm_omni/diffusion/interaction/modality_handlers/base.py
index 61f548fcd..9f8ccfe4e 100644
--- a/vllm_omni/diffusion/interaction/modality_handlers/base.py
+++ b/vllm_omni/diffusion/interaction/modality_handlers/base.py
@@ -5,7 +5,9 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import ClassVar, Self
+from typing import ClassVar
+
+from typing_extensions import Self
 
 from vllm_omni.diffusion.interaction.types import (
     InteractionChunkMetadata,
@@ -23,9 +25,14 @@ class InteractionHandler(ABC):
     """
 
     modality: ClassVar[str]
-    # When True, chunk-boundary apply needs ``ChunkMediaSpec`` (num_frames/fps)
+    # When True, chunk-boundary apply needs ``ChunkMediaSpec`` (frame count & fps)
     # Those information are useful when interaction handler needs interpolation/integration on a frame-by-frame basis
     needs_chunk_media: ClassVar[bool] = False
+    # When True, the coordinator skips ``apply_at_chunk_boundary`` until a session
+    # exists (normally created on the first enqueue). When False, every chunk
+    # boundary runs apply even with no prior enqueue so the handler can create
+    # its session and materialize default chunk data (e.g. identity camera hold).
+    lazy_initialize_session: ClassVar[bool] = True
 
     @classmethod
     def from_pipeline(cls, pipeline: object) -> Self:
@@ -37,6 +44,21 @@ class InteractionHandler(ABC):
         del pipeline
         return cls()
 
+    @abstractmethod
+    def validate_payload(
+        self,
+        state: StepRequestState,
+        *,
+        event_id: str,
+        payload: InteractionPayload,
+        transition_chunks: int | None,
+    ) -> None:
+        """Validate a modality payload without mutating request state.
+
+        Used by ``InteractionCoordinator.enqueue_parts`` so composite events
+        fail before any track is queued.
+        """
+
     @abstractmethod
     def enqueue(
         self,
@@ -56,7 +78,9 @@ class InteractionHandler(ABC):
         *,
         boundary_at: float,
         chunk_index: int | None = None,  # defaults to state.chunk_index when omitted
-        num_frames: int | None = None,  # only set when at least one interaction handler needs it
-        fps: float | None = None,  # only set when at least one interaction handler needs it
+        # Optional chunk media information. Only present when at least one initialized interaction handler needs it
+        num_media_frames: int | None = None,
+        fps: float | None = None,
+        num_latent_frames: int | None = None,
     ) -> InteractionChunkMetadata | None:
         """Advance request-local state and materialize this chunk's effects."""
diff --git a/vllm_omni/diffusion/interaction/modality_handlers/camera.py b/vllm_omni/diffusion/interaction/modality_handlers/camera.py
new file mode 100644
index 000000000..df1c9af1d
--- /dev/null
+++ b/vllm_omni/diffusion/interaction/modality_handlers/camera.py
@@ -0,0 +1,490 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Camera modality interaction handlers.
+
+Payload is structural SE(3): ``translation`` (xyz) + unit
+quaternion ``rotation`` (x, y, z, w). WASD-style key tokens belong in
+clients, not in the engine.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import ClassVar, cast
+
+import torch
+from typing_extensions import Self, override
+
+from vllm_omni.diffusion.interaction.modality_handlers.base import InteractionHandler
+from vllm_omni.diffusion.interaction.types import (
+    InteractionChunkMetadata,
+    InteractionEvent,
+    InteractionMode,
+    InteractionPayload,
+    InteractionSession,
+    resolve_event_frame_offset,
+)
+from vllm_omni.diffusion.worker.utils import StepRequestState
+
+Vec3 = tuple[float, float, float]
+# Unit quaternion in ``(x, y, z, w)`` order. Identity is ``(0, 0, 0, 1)``.
+Quat = tuple[float, float, float, float]
+
+_IDENTITY_QUAT: Quat = (0.0, 0.0, 0.0, 1.0)
+
+
+@dataclass
+class CameraPose:
+    """Canonical absolute camera pose used by the shared timeline.
+
+    Coordinates follow Unity semantics: ``+X`` right, ``+Y`` up,
+    ``+Z`` forward. Session start is the identity transform;
+    ``target`` poses are relative to that origin.
+    """
+
+    translation: Vec3 = (0.0, 0.0, 0.0)
+    rotation: Quat = _IDENTITY_QUAT
+
+    @classmethod
+    def identity(cls) -> CameraPose:
+        return cls()
+
+    def clone(self) -> CameraPose:
+        return CameraPose(translation=self.translation, rotation=self.rotation)
+
+    def as_matrix(self) -> torch.Tensor:
+        """Return a 4x4 rigid transform from translation + unit quaternion."""
+        mat = torch.eye(4, dtype=torch.float64)
+        mat[:3, :3] = _quat_to_rotmat(self.rotation)
+        mat[0, 3] = float(self.translation[0])
+        mat[1, 3] = float(self.translation[1])
+        mat[2, 3] = float(self.translation[2])
+        return mat
+
+    @classmethod
+    def from_matrix(cls, matrix: torch.Tensor) -> CameraPose:
+        if matrix.shape != (4, 4):
+            raise ValueError("camera pose matrix must be 4x4")
+        rotation = _rotmat_to_quat(matrix[:3, :3].detach().cpu().double())
+        translation = (
+            float(matrix[0, 3]),
+            float(matrix[1, 3]),
+            float(matrix[2, 3]),
+        )
+        return cls(translation=translation, rotation=rotation)
+
+
+@dataclass(kw_only=True)
+class QueuedCameraEvent(InteractionEvent):
+    """Timestamped camera command waiting for the next chunk boundary."""
+
+    # Absolute pose for ``target``; per-frame SE3 delta for ``velocity``.
+    pose: CameraPose = field(default_factory=CameraPose.identity)
+    # Integer frame progress for ``target`` lerps (avoids float reciprocal drift).
+    elapsed_transition_frames: int = 0
+
+
+@dataclass
+class CameraSession(InteractionSession):
+    """Request-local camera timeline under ``state.interaction_sessions['camera']``."""
+
+    current_pose: CameraPose = field(default_factory=CameraPose.identity)
+    pending_events: list[QueuedCameraEvent] = field(default_factory=list)
+    # In-flight command; ``elapsed_transition_chunks`` lives on the event.
+    active_event: QueuedCameraEvent | None = None
+    target_source: CameraPose | None = None
+    # Absolute C2W poses ``[num_latent_frames, 4, 4]`` for the most recent chunk.
+    last_absolute_poses: torch.Tensor | None = None
+    # Since a camera session is not lazily initialized, use this field to mark that a client enqueue is ever received.
+    has_received_input: bool = False
+
+
+class SE3DeltaCameraHandler(InteractionHandler):
+    """Generic camera timeline that samples absolute poses per frame.
+
+    * ``mode=target``: lerp toward an absolute pose (relative to session start).
+    * ``mode=velocity``: hold a structural SE3 delta until replaced.
+
+    ``received_at`` is resolved on the media grid (``num_media_frames``/``fps``), then mapped onto latent steps.
+    Later integration and ``last_absolute_poses`` aligns with ``num_latent_frames``.
+    """
+
+    modality: ClassVar[str] = "camera"
+    needs_chunk_media: ClassVar[bool] = True
+    # Camera conditioning must exist every chunk; apply creates the session and
+    # materializes identity/hold poses before any client enqueue.
+    lazy_initialize_session: ClassVar[bool] = False
+    default_transition_chunks: ClassVar[int] = 1
+
+    @classmethod
+    @override
+    def from_pipeline(cls, pipeline: object) -> Self:
+        """It doesn't need anything from the pipeline (e.g., `encode_prompt` method)"""
+        del pipeline
+        return cls()
+
+    @override
+    def validate_payload(
+        self,
+        state: StepRequestState,
+        *,
+        event_id: str,
+        payload: InteractionPayload,
+        transition_chunks: int | None,
+    ) -> None:
+        if not event_id:
+            raise ValueError("event_id must be non-empty")
+
+        mode = payload.get("mode", "target")
+        if mode not in ("target", "velocity"):
+            raise ValueError("camera mode must be 'target' or 'velocity'")
+        data = payload.get("data")
+        if not isinstance(data, Mapping):
+            raise ValueError("camera data must be an object")
+        if "actions" in data:
+            raise ValueError(
+                "camera data.actions (WASD keys) is not accepted by the engine; "
+                "send structural translation/rotation instead"
+            )
+        _parse_pose(data)
+        if mode == "target":
+            duration = self.default_transition_chunks if transition_chunks is None else int(transition_chunks)
+            if duration < 0:
+                raise ValueError("transition_chunks must be >= 0")
+        del state
+
+    @override
+    def enqueue(
+        self,
+        state: StepRequestState,
+        *,
+        event_id: str,
+        received_at: float,
+        payload: InteractionPayload,
+        transition_chunks: int | None,
+    ) -> None:
+        self.validate_payload(
+            state,
+            event_id=event_id,
+            payload=payload,
+            transition_chunks=transition_chunks,
+        )
+        mode = payload.get("mode", "target")
+        camera_mode = cast(InteractionMode, mode)
+        data = cast(Mapping[str, object], payload.get("data"))
+        pose = _parse_pose(data)
+        if camera_mode == "target":
+            duration = self.default_transition_chunks if transition_chunks is None else int(transition_chunks)
+        else:
+            duration = 0
+
+        session = state.interaction_sessions.setdefault("camera", CameraSession())
+        assert isinstance(session, CameraSession)
+        with session.lock:
+            session.has_received_input = True
+            session.pending_events.append(
+                QueuedCameraEvent(
+                    event_id=event_id,
+                    received_at=received_at,
+                    mode=camera_mode,
+                    transition_chunks=duration,
+                    pose=pose,
+                )
+            )
+
+    @override
+    def apply_at_chunk_boundary(
+        self,
+        state: StepRequestState,
+        *,
+        boundary_at: float,
+        chunk_index: int | None = None,
+        num_media_frames: int | None = None,
+        fps: float | None = None,
+        num_latent_frames: int | None = None,
+    ) -> InteractionChunkMetadata | None:
+        """Advance camera state for one chunk and store latent-aligned poses.
+
+        .. note::
+            Hardcoded the following policy of per-frame alignment:
+
+            - Resolve ``received_at`` on the media grid, then map each media index onto a latent step.
+            - Integrate one velocity step per **latent frame**, so holding speed ``0.05`` for a chunk with
+              ``num_latent_frames=3`` yields total travel ``0.15``.
+            - ``last_absolute_poses.shape[0] == num_latent_frames``: interpolation is latent-aligned.
+
+            If future models need different scale/alignment policies, can refactor interaction registry
+            to be able to mark a policy.
+        """
+        del chunk_index
+        if num_media_frames is None or fps is None:
+            raise ValueError("SE3DeltaCameraHandler requires chunk num_media_frames and fps")
+        if num_latent_frames is None:
+            num_latent_frames = num_media_frames
+        if int(num_latent_frames) <= 0:
+            raise ValueError(f"num_latent_frames must be > 0, got {num_latent_frames}")
+
+        session = state.interaction_sessions.setdefault("camera", CameraSession())
+        assert isinstance(session, CameraSession)
+        with session.lock:
+            poses, started, active, completed = self._step_one_chunk(
+                session,
+                num_media_frames=num_media_frames,
+                fps=fps,
+                num_latent_frames=num_latent_frames,
+                boundary_at=boundary_at,
+            )
+            if poses:
+                session.last_absolute_poses = torch.stack([p.as_matrix() for p in poses], dim=0)
+            else:
+                session.last_absolute_poses = torch.zeros((0, 4, 4), dtype=torch.float64)
+
+        return InteractionChunkMetadata(
+            started_event_ids=started,
+            active_event_ids=active,
+            completed_event_ids=completed,
+        )
+
+    def _step_one_chunk(
+        self,
+        session: CameraSession,
+        *,
+        num_media_frames: int,
+        fps: float,
+        num_latent_frames: int,
+        boundary_at: float,
+    ) -> tuple[list[CameraPose], list[str], list[str], list[str]]:
+        """Sample absolute poses for this chunk under target/velocity semantics."""
+        num_media_frames = max(int(num_media_frames), 1)
+        num_latent_frames = max(int(num_latent_frames), 1)
+        pending = list(session.pending_events)
+        session.pending_events.clear()
+
+        by_latent: dict[int, list[QueuedCameraEvent]] = {}
+        for event in pending:
+            media_frame = resolve_event_frame_offset(
+                received_at=event.received_at,
+                previous_boundary_at=session.last_boundary_at,
+                num_frames=num_media_frames,
+                fps=fps,
+            )
+            latent_idx = _media_frame_to_latent(
+                media_frame,
+                num_media_frames=num_media_frames,
+                num_latent_frames=num_latent_frames,
+            )
+            by_latent.setdefault(latent_idx, []).append(event)
+        for events in by_latent.values():
+            events.sort(key=lambda item: item.received_at)
+
+        started: list[str] = []
+        completed: list[str] = []
+        seen_completed: set[str] = set()
+        poses: list[CameraPose] = []
+
+        def _mark_completed(event_id: str) -> None:
+            if event_id not in seen_completed:
+                seen_completed.add(event_id)
+                completed.append(event_id)
+
+        for latent_idx in range(num_latent_frames):
+            for event in by_latent.get(latent_idx, []):
+                started.append(event.event_id)
+                cancelled_id = self._activate_event(session, event)
+                if cancelled_id is not None:
+                    _mark_completed(cancelled_id)
+            just_completed = self._step_one_frame(session, num_latent_frames)
+            poses.append(session.current_pose.clone())
+            if just_completed is not None:
+                _mark_completed(just_completed)
+
+        active: list[str] = []
+        if session.active_event is not None:
+            active.append(session.active_event.event_id)
+
+        session.last_boundary_at = boundary_at
+        return poses, started, active, completed
+
+    def _activate_event(self, session: CameraSession, event: QueuedCameraEvent) -> str | None:
+        """Activate ``event``, returning the event_id cancelled by this replacement if any."""
+        cancelled_id: str | None = None
+        if session.active_event is not None and session.active_event.event_id != event.event_id:
+            cancelled_id = session.active_event.event_id
+
+        event.elapsed_transition_chunks = 0.0
+        event.elapsed_transition_frames = 0
+        session.active_event = event
+        if event.mode == "target":
+            session.target_source = session.current_pose.clone()
+        else:
+            session.target_source = None
+        return cancelled_id
+
+    def _clear_active_target(self, session: CameraSession) -> str:
+        """Snap to the target pose, clear the active target track, and return its event_id."""
+        assert session.active_event is not None and session.active_event.mode == "target"
+        event = session.active_event
+        event_id = event.event_id
+        session.current_pose = event.pose.clone()
+        session.active_event = None
+        session.target_source = None
+        return event_id
+
+    def _step_one_frame(self, session: CameraSession, total_num_frames_this_chunk: int) -> str | None:
+        """Advance the active camera command by one frame."""
+        event = session.active_event
+        if event is None:
+            return None
+
+        if event.mode == "target":
+            duration = event.transition_chunks
+            source = session.target_source or session.current_pose
+            target = event.pose
+            if duration <= 0:
+                return self._clear_active_target(session)
+
+            total_frames = max(1, int(round(duration * float(total_num_frames_this_chunk))))
+            event.elapsed_transition_frames += 1
+            event.elapsed_transition_chunks = event.elapsed_transition_frames / float(total_num_frames_this_chunk)
+            alpha = min(1.0, event.elapsed_transition_frames / float(total_frames))
+            session.current_pose = _lerp_pose(source, target, alpha)
+            if event.elapsed_transition_frames >= total_frames:
+                return self._clear_active_target(session)
+            return None
+
+        # Velocity: apply the held structural SE3 delta once per frame.
+        session.current_pose = _compose_pose(session.current_pose, event.pose)
+        return None
+
+
+def _media_frame_to_latent(
+    media_frame: int,
+    *,
+    num_media_frames: int,
+    num_latent_frames: int,
+) -> int:
+    """Map a media-timeline frame index onto the latent control grid."""
+    if num_latent_frames <= 1 or num_media_frames <= 1:
+        return 0
+    return min(int(media_frame) * int(num_latent_frames) // int(num_media_frames), num_latent_frames - 1)
+
+
+def _as_xyz(value: object, *, name: str) -> Vec3:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)) or len(value) != 3:
+        raise ValueError(f"camera {name} must be a length-3 list/tuple")
+    if any(math.isnan(v) or math.isinf(v) for v in value):
+        raise ValueError(f"camera {name} must be non-nan and non-inf")
+    return (float(value[0]), float(value[1]), float(value[2]))
+
+
+def _as_quat(value: object, *, name: str) -> Quat:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)) or len(value) != 4:
+        raise ValueError(f"camera {name} must be a length-4 list/tuple (x, y, z, w)")
+    if any(math.isnan(v) or math.isinf(v) for v in value):
+        raise ValueError(f"camera {name} must be non-nan and non-inf")
+    return _quat_normalize((float(value[0]), float(value[1]), float(value[2]), float(value[3])))
+
+
+def _parse_pose(data: Mapping[str, object]) -> CameraPose:
+    translation = _as_xyz(data.get("translation", (0.0, 0.0, 0.0)), name="translation")
+    rotation = _as_quat(data.get("rotation", _IDENTITY_QUAT), name="rotation")
+    return CameraPose(translation=translation, rotation=rotation)
+
+
+def _lerp(a: float, b: float, alpha: float) -> float:
+    return a + (b - a) * alpha
+
+
+def _lerp_pose(source: CameraPose, target: CameraPose, alpha: float) -> CameraPose:
+    alpha = min(1.0, max(0.0, alpha))
+    return CameraPose(
+        translation=cast(
+            Vec3,
+            tuple(_lerp(s, t, alpha) for s, t in zip(source.translation, target.translation)),
+        ),
+        rotation=_quat_nlerp(source.rotation, target.rotation, alpha),
+    )
+
+
+def _compose_pose(base: CameraPose, delta: CameraPose) -> CameraPose:
+    """Apply ``delta`` after ``base`` in the session frame (T_new = T_base @ T_delta)."""
+    return CameraPose.from_matrix(base.as_matrix() @ delta.as_matrix())
+
+
+def _quat_normalize(q: Quat) -> Quat:
+    x, y, z, w = q
+    norm = math.sqrt(x * x + y * y + z * z + w * w)
+    if norm <= 0.0:
+        raise ValueError("camera rotation quaternion must be non-zero")
+    return (x / norm, y / norm, z / norm, w / norm)
+
+
+def _quat_nlerp(a: Quat, b: Quat, alpha: float) -> Quat:
+    """Normalized linear interpolation; flips ``b`` when needed for shortest path."""
+    dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]
+    if dot < 0.0:
+        b = (-b[0], -b[1], -b[2], -b[3])
+    return _quat_normalize(
+        (
+            _lerp(a[0], b[0], alpha),
+            _lerp(a[1], b[1], alpha),
+            _lerp(a[2], b[2], alpha),
+            _lerp(a[3], b[3], alpha),
+        )
+    )
+
+
+def _quat_to_rotmat(q: Quat) -> torch.Tensor:
+    x, y, z, w = q
+    xx, yy, zz = x * x, y * y, z * z
+    xy, xz, yz = x * y, x * z, y * z
+    wx, wy, wz = w * x, w * y, w * z
+    return torch.tensor(
+        [
+            [1.0 - 2.0 * (yy + zz), 2.0 * (xy - wz), 2.0 * (xz + wy)],
+            [2.0 * (xy + wz), 1.0 - 2.0 * (xx + zz), 2.0 * (yz - wx)],
+            [2.0 * (xz - wy), 2.0 * (yz + wx), 1.0 - 2.0 * (xx + yy)],
+        ],
+        dtype=torch.float64,
+    )
+
+
+def _rotmat_to_quat(rotation: torch.Tensor) -> Quat:
+    """Convert a 3x3 rotation matrix to a unit quaternion ``(x, y, z, w)``."""
+    m = rotation
+    trace = float(m[0, 0] + m[1, 1] + m[2, 2])
+    if trace > 0.0:
+        s = math.sqrt(trace + 1.0) * 2.0
+        w = 0.25 * s
+        x = (float(m[2, 1]) - float(m[1, 2])) / s
+        y = (float(m[0, 2]) - float(m[2, 0])) / s
+        z = (float(m[1, 0]) - float(m[0, 1])) / s
+    elif float(m[0, 0]) > float(m[1, 1]) and float(m[0, 0]) > float(m[2, 2]):
+        s = math.sqrt(1.0 + float(m[0, 0]) - float(m[1, 1]) - float(m[2, 2])) * 2.0
+        w = (float(m[2, 1]) - float(m[1, 2])) / s
+        x = 0.25 * s
+        y = (float(m[0, 1]) + float(m[1, 0])) / s
+        z = (float(m[0, 2]) + float(m[2, 0])) / s
+    elif float(m[1, 1]) > float(m[2, 2]):
+        s = math.sqrt(1.0 + float(m[1, 1]) - float(m[0, 0]) - float(m[2, 2])) * 2.0
+        w = (float(m[0, 2]) - float(m[2, 0])) / s
+        x = (float(m[0, 1]) + float(m[1, 0])) / s
+        y = 0.25 * s
+        z = (float(m[1, 2]) + float(m[2, 1])) / s
+    else:
+        s = math.sqrt(1.0 + float(m[2, 2]) - float(m[0, 0]) - float(m[1, 1])) * 2.0
+        w = (float(m[1, 0]) - float(m[0, 1])) / s
+        x = (float(m[0, 2]) + float(m[2, 0])) / s
+        y = (float(m[1, 2]) + float(m[2, 1])) / s
+        z = 0.25 * s
+    return _quat_normalize((x, y, z, w))
+
+
+__all__ = [
+    "CameraPose",
+    "CameraSession",
+    "QueuedCameraEvent",
+    "SE3DeltaCameraHandler",
+]
diff --git a/vllm_omni/diffusion/interaction/modality_handlers/prompt.py b/vllm_omni/diffusion/interaction/modality_handlers/prompt.py
index e87d9029b..818abe173 100644
--- a/vllm_omni/diffusion/interaction/modality_handlers/prompt.py
+++ b/vllm_omni/diffusion/interaction/modality_handlers/prompt.py
@@ -90,6 +90,7 @@ class PromptInteractionHandler(InteractionHandler):
     """
 
     modality: ClassVar[str] = "prompt"
+    lazy_initialize_session: ClassVar[bool] = True
 
     def __init__(
         self,
@@ -113,16 +114,14 @@ class PromptInteractionHandler(InteractionHandler):
         )
 
     @override
-    def enqueue(
+    def validate_payload(
         self,
         state: StepRequestState,
         *,
         event_id: str,
-        received_at: float,
         payload: InteractionPayload,
         transition_chunks: int | None,
     ) -> None:
-        """Prompt updates are last-write-win and unbuffered at chunk boundary."""
         prompt = payload.get("prompt")
         if not isinstance(prompt, str) or not prompt:
             raise ValueError("prompt must be non-empty")
@@ -136,6 +135,27 @@ class PromptInteractionHandler(InteractionHandler):
         if duration < 0:
             raise ValueError("transition_chunks must be >= 0")
 
+    @override
+    def enqueue(
+        self,
+        state: StepRequestState,
+        *,
+        event_id: str,
+        received_at: float,
+        payload: InteractionPayload,
+        transition_chunks: int | None,
+    ) -> None:
+        """Prompt updates are last-write-win and unbuffered at chunk boundary."""
+        self.validate_payload(
+            state,
+            event_id=event_id,
+            payload=payload,
+            transition_chunks=transition_chunks,
+        )
+        prompt = payload.get("prompt")
+        assert isinstance(prompt, str)
+        duration = DEFAULT_TRANSITION_CHUNKS if transition_chunks is None else transition_chunks
+
         target_prompt_embeds, _ = self._encode_prompt(
             prompt=prompt,
             negative_prompt=None,
@@ -164,12 +184,13 @@ class PromptInteractionHandler(InteractionHandler):
         *,
         boundary_at: float,
         chunk_index: int | None = None,
-        num_frames: int | None = None,
+        num_media_frames: int | None = None,
         fps: float | None = None,
+        num_latent_frames: int | None = None,
     ) -> InteractionChunkMetadata | None:
         """Advance or start prompt interpolation before the next chunk."""
         # Prompt lerp is chunk-LWW; media timeline and caller chunk_index unused.
-        del chunk_index, num_frames, fps
+        del chunk_index, num_media_frames, fps, num_latent_frames
         session = state.interaction_sessions.get("prompt")
         assert isinstance(session, PromptSession)
 
diff --git a/vllm_omni/diffusion/interaction/registry.py b/vllm_omni/diffusion/interaction/registry.py
index f86dab902..9e8d3c9af 100644
--- a/vllm_omni/diffusion/interaction/registry.py
+++ b/vllm_omni/diffusion/interaction/registry.py
@@ -5,12 +5,13 @@ A pipeline only declares the modalities that it supports.
 And a pipeline can choose which handler for each modality (there can be more than one handler for a modality).
 
 Outer key: pipeline architecture name (``od_config.model_class_name``).
-Inner key: modality name (e.g. ``\"prompt\"``).
+Inner key: modality name (e.g. ``\"camera\"``).
 """
 
 from __future__ import annotations
 
 from vllm_omni.diffusion.interaction.modality_handlers.base import InteractionHandler
+from vllm_omni.diffusion.interaction.modality_handlers.camera import SE3DeltaCameraHandler
 from vllm_omni.diffusion.interaction.modality_handlers.prompt import PromptInteractionHandler
 
 STRUCTURED_HANDLER_REGISTRY: dict[str, dict[str, type[InteractionHandler]]] = {
@@ -21,4 +22,7 @@ STRUCTURED_HANDLER_REGISTRY: dict[str, dict[str, type[InteractionHandler]]] = {
     "HeliosPyramidPipeline": {
         "prompt": PromptInteractionHandler,
     },
+    "LingBotWorldCausalDMDPipeline": {
+        "camera": SE3DeltaCameraHandler,
+    },
 }
diff --git a/vllm_omni/diffusion/interaction/types.py b/vllm_omni/diffusion/interaction/types.py
index 904552129..942940102 100644
--- a/vllm_omni/diffusion/interaction/types.py
+++ b/vllm_omni/diffusion/interaction/types.py
@@ -1,38 +1,75 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Shared types for midway interaction handlers."""
 
 from __future__ import annotations
 
+import math
+import time
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 from threading import Lock
 from typing import Literal
 
+import torch
+
 # Wire payload for one modality track. Handlers validate keys they need.
 InteractionPayload = Mapping[str, object]
 
 # Shared command semantics across modalities that support them.
-# Prompt specialization uses ``"target"`` only.
-InteractionMode = Literal["target"]
+# Prompt specialization narrows this to ``"target"`` only.
+InteractionMode = Literal["target", "velocity"]
+
+
+def synchronized_monotonic_time(stamp: float | None = None) -> float:
+    """Return a monotonic timestamp shared across DiT ranks.
+
+    ``submit_interaction`` and chunk-boundary apply run as collectives, but
+    ``time.monotonic()`` is rank-local. Under USP/SP, inter-rank skew that
+    straddles a ``1/fps`` bucket edge would schedule the same event onto
+    different frames per shard. Rank 0's stamp is broadcast (callers may pass
+    a local sample; non-source ranks' values are ignored).
+    """
+    if stamp is None:
+        stamp = time.monotonic()
+    if not torch.distributed.is_initialized():
+        return stamp
+    try:
+        from vllm_omni.diffusion.distributed.parallel_state import get_world_group
+
+        group = get_world_group()
+    except Exception:
+        return stamp
+    if group.world_size <= 1:
+        return stamp
+    return group.broadcast_object(stamp, src=0)
 
 
 @dataclass(frozen=True)
 class ChunkMediaSpec:
-    """Media extent of one generation chunk, for interaction timeline mapping."""
+    """Decoded media extent and latent step count for one generation chunk.
 
-    num_frames: int
+    Attributes:
+        num_media_frames: Number of frames in this chunk when decoded into playable media.
+        fps: Frames per second of the media.
+        num_latent_frames: Number of latent frames in this chunk (internal DiT units).
+    """
+
+    num_media_frames: int
     fps: float
+    num_latent_frames: int
 
     def __post_init__(self) -> None:
-        if self.num_frames <= 0:
-            raise ValueError(f"ChunkMediaSpec.num_frames must be > 0, got {self.num_frames}")
+        if self.num_media_frames <= 0:
+            raise ValueError(f"ChunkMediaSpec.num_media_frames must be > 0, got {self.num_media_frames}")
+        if self.num_latent_frames <= 0:
+            raise ValueError(f"ChunkMediaSpec.num_latent_frames must be > 0, got {self.num_latent_frames}")
         if self.fps <= 0:
             raise ValueError(f"ChunkMediaSpec.fps must be > 0, got {self.fps}")
 
     @property
     def duration_s(self) -> float:
-        return float(self.num_frames) / float(self.fps)
+        return float(self.num_media_frames) / float(self.fps)
 
 
 @dataclass(kw_only=True)
@@ -41,6 +78,7 @@ class InteractionEvent:
 
     Example:
     - ``QueuedPromptEvent`` in ``vllm_omni.diffusion.interaction.modality_handlers.prompt``
+    - ``QueuedCameraEvent`` in ``vllm_omni.diffusion.interaction.modality_handlers.camera``
     """
 
     event_id: str
@@ -60,12 +98,37 @@ class InteractionSession:
 
     Example:
     - ``PromptSession`` in ``vllm_omni.diffusion.interaction.modality_handlers.prompt``
+    - ``CameraSession`` in ``vllm_omni.diffusion.interaction.modality_handlers.camera``
     """
 
     lock: Lock = field(default_factory=Lock, repr=False)
     last_boundary_at: float | None = None
 
 
+def resolve_event_frame_offset(
+    *,
+    received_at: float,
+    previous_boundary_at: float | None,
+    num_frames: int,
+    fps: float,
+) -> int:
+    """Map an event arrival time onto ``[0, num_frames - 1]`` for this chunk.
+
+    * Uses ``floor((received_at - previous_boundary_at) * fps)``.
+    * Events without a prior boundary (or with non-positive fps) map to frame 0.
+    * Offsets past the represented media window are clamped to the final frame.
+    """
+    num_frames = max(int(num_frames), 1)
+    if previous_boundary_at is None or fps <= 0:
+        return 0
+    offset = math.floor((received_at - previous_boundary_at) * float(fps))
+    if offset < 0:
+        return 0
+    if offset >= num_frames:
+        return num_frames - 1
+    return int(offset)
+
+
 @dataclass
 class InteractionChunkMetadata:
     """Per-modality (or merged) event-id bookkeeping for one chunk boundary."""
diff --git a/vllm_omni/diffusion/layers/fused_qk_norm_rope.py b/vllm_omni/diffusion/layers/fused_qk_norm_rope.py
index 9f6605726..9d530919a 100644
--- a/vllm_omni/diffusion/layers/fused_qk_norm_rope.py
+++ b/vllm_omni/diffusion/layers/fused_qk_norm_rope.py
@@ -124,7 +124,8 @@ if HAS_TRITON:
         eps: tl.constexpr,
         heads_per_program: tl.constexpr,
     ):
-        token = tl.program_id(0)
+        # Long-video Q/K views can span more than 2**31 elements of fused QKV storage.
+        token = tl.program_id(0).to(tl.int64)
         head_group = tl.program_id(1)
         heads = head_group * heads_per_program + tl.arange(0, heads_per_program)
         dims = tl.arange(0, head_dim)
@@ -216,7 +217,8 @@ if HAS_TRITON:
         (partial rotary or lane padding) the output is the normalized value
         unchanged.
         """
-        token = tl.program_id(0)
+        # Long-video Q/K views can span more than 2**31 elements of fused QKV storage.
+        token = tl.program_id(0).to(tl.int64)
         head_group = tl.program_id(1)
         dims = tl.arange(0, padded_dim)
         dim_mask = dims < head_dim
diff --git a/vllm_omni/diffusion/layers/fused_qk_rope.py b/vllm_omni/diffusion/layers/fused_qk_rope.py
new file mode 100644
index 000000000..95b24451b
--- /dev/null
+++ b/vllm_omni/diffusion/layers/fused_qk_rope.py
@@ -0,0 +1,251 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Bit-exact paired Q/K full-width interleaved RoPE for CUDA.
+
+The operator accepts already-normalized BF16 query and key tensors in BSND
+layout and full-width FP32 cosine/sine tables.  It deliberately performs two
+round-to-nearest FP32 multiplies followed by one round-to-nearest FP32 add,
+then rounds only once when storing BF16 output.  This matches Diffusers'
+``apply_rotary_emb`` arithmetic while combining its separate Q and K calls.
+"""
+
+from __future__ import annotations
+
+import torch
+from torch.library import Library
+from vllm.platforms import current_platform
+from vllm.triton_utils import HAS_TRITON, tl, triton
+from vllm.utils.torch_utils import direct_register_custom_op
+
+_HEAD_DIM = 128
+_HEADS_PER_PROGRAM = 4
+
+
+if HAS_TRITON:
+
+    @triton.jit
+    def _mul_rn_f32(x, y):
+        return tl.inline_asm_elementwise(
+            asm="mul.rn.f32 $0, $1, $2;",
+            constraints="=f,f,f",
+            args=[x, y],
+            dtype=tl.float32,
+            is_pure=True,
+            pack=1,
+        )
+
+    @triton.jit
+    def _add_rn_f32(x, y):
+        return tl.inline_asm_elementwise(
+            asm="add.rn.f32 $0, $1, $2;",
+            constraints="=f,f,f",
+            args=[x, y],
+            dtype=tl.float32,
+            is_pure=True,
+            pack=1,
+        )
+
+    @triton.jit
+    def _qk_rope_exact_kernel(
+        q_ptr,
+        k_ptr,
+        cos_ptr,
+        sin_ptr,
+        q_output_ptr,
+        k_output_ptr,
+        q_stride_token,
+        q_stride_head,
+        q_stride_dim,
+        k_stride_token,
+        k_stride_head,
+        k_stride_dim,
+        q_output_stride_token,
+        q_output_stride_head,
+        q_output_stride_dim,
+        k_output_stride_token,
+        k_output_stride_head,
+        k_output_stride_dim,
+        table_stride_sequence,
+        table_stride_dim,
+        sequence,
+        num_heads: tl.constexpr,
+        head_dim: tl.constexpr,
+        heads_per_program: tl.constexpr,
+    ):
+        token = tl.program_id(0)
+        group = tl.program_id(1)
+        is_key = tl.program_id(2) == 1
+        heads = group * heads_per_program + tl.arange(0, heads_per_program)
+        dims = tl.arange(0, head_dim)
+        valid = heads[:, None] < num_heads
+
+        q_offsets = token * q_stride_token + heads[:, None] * q_stride_head + dims[None, :] * q_stride_dim
+        k_offsets = token * k_stride_token + heads[:, None] * k_stride_head + dims[None, :] * k_stride_dim
+        input_ptrs = tl.where(is_key, k_ptr + k_offsets, q_ptr + q_offsets)
+
+        pair_dims = dims ^ 1
+        q_pair_offsets = token * q_stride_token + heads[:, None] * q_stride_head + pair_dims[None, :] * q_stride_dim
+        k_pair_offsets = token * k_stride_token + heads[:, None] * k_stride_head + pair_dims[None, :] * k_stride_dim
+        pair_ptrs = tl.where(is_key, k_ptr + k_pair_offsets, q_ptr + q_pair_offsets)
+        values = tl.load(input_ptrs, mask=valid, other=0.0).to(tl.float32)
+        pairs = tl.load(pair_ptrs, mask=valid, other=0.0).to(tl.float32)
+        signed_pairs = tl.where((dims[None, :] & 1) == 0, -pairs, pairs)
+
+        sequence_index = token % sequence
+        table_offsets = sequence_index * table_stride_sequence + dims * table_stride_dim
+        cos = tl.load(cos_ptr + table_offsets).to(tl.float32)[None, :]
+        sin = tl.load(sin_ptr + table_offsets).to(tl.float32)[None, :]
+
+        # Do not let the compiler contract this expression into an FMA.  The
+        # reference has two independently rounded FP32 multiplies and one
+        # independently rounded FP32 add, followed by the final BF16 store.
+        first = _mul_rn_f32(values, cos)
+        second = _mul_rn_f32(signed_pairs, sin)
+        output = _add_rn_f32(first, second)
+        q_output_offsets = (
+            token * q_output_stride_token + heads[:, None] * q_output_stride_head + dims[None, :] * q_output_stride_dim
+        )
+        k_output_offsets = (
+            token * k_output_stride_token + heads[:, None] * k_output_stride_head + dims[None, :] * k_output_stride_dim
+        )
+        output_ptrs = tl.where(
+            is_key,
+            k_output_ptr + k_output_offsets,
+            q_output_ptr + q_output_offsets,
+        )
+        tl.store(output_ptrs, output, mask=valid)
+
+
+def fused_qk_rope_supported(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> bool:
+    """Return whether the exact CUDA kernel can consume these tensors."""
+
+    if not (
+        HAS_TRITON
+        and torch.version.hip is None
+        and current_platform.is_cuda()
+        and not torch.is_grad_enabled()
+        and q.is_cuda
+        and k.is_cuda
+        and q.device == k.device
+        and q.dtype is torch.bfloat16
+        and k.dtype is q.dtype
+        and q.ndim == 4
+        and k.shape == q.shape
+        and q.numel() > 0
+        and q.is_contiguous()
+        and k.is_contiguous()
+    ):
+        return False
+
+    batch, sequence, _heads, head_dim = q.shape
+    del batch
+    if head_dim != _HEAD_DIM:
+        return False
+    if not (
+        cos.shape == (sequence, head_dim)
+        and sin.shape == cos.shape
+        and cos.device == q.device
+        and sin.device == q.device
+        and cos.dtype is torch.float32
+        and sin.dtype is torch.float32
+        and cos.is_contiguous()
+        and sin.is_contiguous()
+    ):
+        return False
+    return True
+
+
+def _launch_fused_qk_rope(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    q_output = torch.empty_like(q)
+    k_output = torch.empty_like(k)
+    tokens = q.shape[0] * q.shape[1]
+    head_groups = triton.cdiv(q.shape[2], _HEADS_PER_PROGRAM)
+    grid = (tokens, head_groups, 2)
+    with torch.accelerator.device_index(q.device.index):
+        _qk_rope_exact_kernel[grid](
+            q,
+            k,
+            cos,
+            sin,
+            q_output,
+            k_output,
+            q.stride(1),
+            q.stride(2),
+            q.stride(3),
+            k.stride(1),
+            k.stride(2),
+            k.stride(3),
+            q_output.stride(1),
+            q_output.stride(2),
+            q_output.stride(3),
+            k_output.stride(1),
+            k_output.stride(2),
+            k_output.stride(3),
+            cos.stride(0),
+            cos.stride(1),
+            q.shape[1],
+            num_heads=q.shape[2],
+            head_dim=q.shape[-1],
+            heads_per_program=_HEADS_PER_PROGRAM,
+            num_warps=4,
+        )
+    return q_output, k_output
+
+
+def _fused_qk_rope_impl(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if not fused_qk_rope_supported(q, k, cos, sin):
+        raise ValueError("fused_qk_rope received unsupported inputs")
+    return _launch_fused_qk_rope(q, k, cos, sin)
+
+
+def _fused_qk_rope_fake(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    del cos, sin
+    return torch.empty_like(q), torch.empty_like(k)
+
+
+_OMNI_OP_LIB = Library("vllm_omni", "FRAGMENT")
+if not hasattr(torch.ops.vllm_omni, "fused_qk_rope"):
+    direct_register_custom_op(
+        op_name="fused_qk_rope",
+        op_func=_fused_qk_rope_impl,
+        fake_impl=_fused_qk_rope_fake,
+        mutates_args=[],
+        target_lib=_OMNI_OP_LIB,
+    )
+
+
+def fused_qk_rope(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Apply paired full-width adjacent/interleaved RoPE on CUDA."""
+
+    if not fused_qk_rope_supported(q, k, cos, sin):
+        raise ValueError("fused_qk_rope requires contiguous CUDA BF16 Q/K and contiguous full-width CUDA FP32 tables")
+    return torch.ops.vllm_omni.fused_qk_rope(q, k, cos, sin)
+
+
+__all__ = ["fused_qk_rope", "fused_qk_rope_supported"]
diff --git a/vllm_omni/diffusion/layers/indexed_modulation.py b/vllm_omni/diffusion/layers/indexed_modulation.py
index 385ce1a1b..9fd402dec 100644
--- a/vllm_omni/diffusion/layers/indexed_modulation.py
+++ b/vllm_omni/diffusion/layers/indexed_modulation.py
@@ -112,13 +112,16 @@ def _rms_norm_indexed_scale_shift_kernel(
     x = tl.load(x_ptr + row * stride_x_row + columns, mask=mask, other=0.0).to(tl.float32)
     weight = tl.load(weight_ptr + columns, mask=mask, other=0.0).to(tl.float32)
     variance = tl.sum(x * x, axis=0) / hidden_size
+    # Keep RMSNorm and AdaLN intermediates in FP32 on every architecture.
+    # Rounding the normalized value to BF16 before the affine transform
+    # changes the fused computation, including values at rounding boundaries.
     normalized = x * tl.rsqrt(variance + eps) * weight
-
     shift = tl.load(shift_ptr + index * stride_shift_row + columns, mask=mask, other=0.0).to(tl.float32)
     scale = tl.load(scale_ptr + index * stride_scale_row + columns, mask=mask, other=0.0).to(tl.float32)
+    output = normalized * (1.0 + scale) + shift
     tl.store(
         output_ptr + row * hidden_size + columns,
-        normalized * (1.0 + scale) + shift,
+        output,
         mask=mask,
     )
 
@@ -162,9 +165,10 @@ def _indexed_gate_rms_norm_scale_shift_kernel(
     normalized = updated * tl.rsqrt(variance + eps) * weight
     shift = tl.load(shift_ptr + index * stride_shift_row + columns, mask=mask, other=0.0).to(tl.float32)
     scale = tl.load(scale_ptr + index * stride_scale_row + columns, mask=mask, other=0.0).to(tl.float32)
+    output = normalized * (1.0 + scale) + shift
     tl.store(
         modulated_out_ptr + row * hidden_size + columns,
-        normalized * (1.0 + scale) + shift,
+        output,
         mask=mask,
     )
 
diff --git a/vllm_omni/diffusion/layers/norm.py b/vllm_omni/diffusion/layers/norm.py
index d9e116ec7..478fc0d09 100644
--- a/vllm_omni/diffusion/layers/norm.py
+++ b/vllm_omni/diffusion/layers/norm.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from importlib.util import find_spec
 
 import torch
@@ -163,75 +166,3 @@ class RMSNorm(CustomOp):
         out = self.weight.to(torch.float32) * out
         out = out.to(input_dtype)
         return (out, residual) if residual is not None else out
-
-
-class RMSNormVAE(CustomOp):
-    """Root Mean Square Layer Normalization for Channel-First or Last"""
-
-    def __init__(
-        self,
-        dim: int,
-        channel_first: bool = True,
-        images: bool = True,
-        bias: bool = False,
-        epsilon: float = 1e-6,
-    ) -> None:
-        super().__init__()
-        broadcastable_dims = (1, 1, 1) if not images else (1, 1)
-        shape = (dim, *broadcastable_dims) if channel_first else (dim,)
-
-        self.channel_first = channel_first
-        self.scale = dim**0.5
-        self.gamma = nn.Parameter(torch.ones(shape))
-        self.bias = nn.Parameter(torch.zeros(shape)) if bias else None
-        self.epsilon = epsilon
-
-        self.gamma_rmsnorm = None
-
-    def forward_cuda(
-        self,
-        x: torch.Tensor,
-    ) -> torch.Tensor:
-        return self.forward_native(x)
-
-    def forward_hip(
-        self,
-        x: torch.Tensor,
-    ) -> torch.Tensor:
-        return self.forward_native(x)
-
-    def forward_npu(
-        self,
-        x: torch.Tensor,
-    ) -> torch.Tensor:
-        import torch_npu
-
-        if self.gamma_rmsnorm is None:
-            self.gamma_rmsnorm = self.gamma.reshape(-1)
-
-        if self.channel_first:
-            x = x.transpose(1, -1)
-            out = torch_npu.npu_rms_norm(x, self.gamma_rmsnorm, epsilon=self.epsilon)[0].transpose(1, -1)
-        else:
-            out = torch_npu.npu_rms_norm(x, self.gamma_rmsnorm, epsilon=self.epsilon)[0]
-
-        if self.bias is not None:
-            out = out + self.bias
-        return out
-
-    def forward_native(
-        self,
-        x: torch.Tensor,
-    ) -> torch.Tensor:
-        out = (
-            F.normalize(
-                x,
-                dim=(1 if self.channel_first else -1),
-                eps=self.epsilon,
-            )
-            * self.scale
-            * self.gamma
-        )
-        if self.bias is not None:
-            out = out + self.bias
-        return out
diff --git a/vllm_omni/diffusion/layers/rope.py b/vllm_omni/diffusion/layers/rope.py
index 37b2ed835..c7c788fe5 100644
--- a/vllm_omni/diffusion/layers/rope.py
+++ b/vllm_omni/diffusion/layers/rope.py
@@ -344,140 +344,6 @@ def apply_rope_to_qk(
     return query, key
 
 
-class WanS2VRotaryPosEmbed(torch.nn.Module):
-    """Precompute complex-valued RoPE embeddings for S2V multi-grid positions.
-
-    Owns the base frequency buffer and provides forward() to compute position
-    embeddings given hidden_states (for shape) and grid_sizes.
-    """
-
-    def __init__(self, num_heads: int, head_dim: int, max_seq_len: int = 1024):
-        super().__init__()
-        self.num_heads = num_heads
-        self.head_dim = head_dim
-        d = head_dim
-        freqs = torch.cat(
-            [
-                self._rope_params(max_seq_len, d - 4 * (d // 6)),
-                self._rope_params(max_seq_len, 2 * (d // 6)),
-                self._rope_params(max_seq_len, 2 * (d // 6)),
-            ],
-            dim=1,
-        )
-        self.register_buffer("freqs", freqs.to(torch.complex64), persistent=False)
-
-    @staticmethod
-    @torch.amp.autocast(current_omni_platform.device_type, enabled=False)
-    def _rope_params(max_seq_len, dim, theta=10000):
-        if dim % 2 != 0:
-            raise ValueError(f"dim ({dim}) must be even")
-        freqs = torch.outer(
-            torch.arange(max_seq_len), 1.0 / torch.pow(theta, torch.arange(0, dim, 2).to(torch.float64).div(dim))
-        )
-        return torch.polar(torch.ones_like(freqs), freqs)
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        grid_sizes: list,
-        trainable_freqs: torch.Tensor | None = None,
-    ) -> torch.Tensor:
-        """Precompute RoPE embeddings for the given grid layout.
-
-        Args:
-            hidden_states: Tensor [B, S, ...] (used for batch/seq shape and device)
-            grid_sizes: Grid specification (list of [offsets, sizes, totals])
-            trainable_freqs: Optional trainable frequency overrides for t_f < 0
-
-        Returns:
-            Complex tensor [B, S, 1, head_dim//2] of precomputed position embeddings
-        """
-        b, s = hidden_states.shape[0], hidden_states.shape[1]
-        c = self.head_dim // 2
-        device = hidden_states.device
-
-        freqs = self.freqs.to(device)
-        if trainable_freqs is not None:
-            freqs_input = [freqs, trainable_freqs]
-        else:
-            freqs_input = freqs
-
-        if isinstance(freqs_input, list):
-            trainable_f = freqs_input[1]
-            freqs_split = freqs_input[0]
-        else:
-            trainable_f = None
-            freqs_split = freqs_input
-        freqs_split = freqs_split.split([c - 2 * (c // 3), c // 3, c // 3], dim=1)
-
-        output = torch.empty((b, s, 1, c), device=device, dtype=torch.complex64)
-        seq_bucket = [0]
-        if not isinstance(grid_sizes, list):
-            grid_sizes = [grid_sizes]
-        for g in grid_sizes:
-            if not isinstance(g, list):
-                g = [torch.zeros_like(g), g]
-            batch_size = g[0].shape[0]
-            for i in range(batch_size):
-                f_o, h_o, w_o = g[0][i]
-                f, h, w = g[1][i]
-                t_f, t_h, t_w = g[2][i]
-                seq_f, seq_h, seq_w = f - f_o, h - h_o, w - w_o
-                seq_len = int(seq_f * seq_h * seq_w)
-                if seq_len > 0:
-                    if t_f > 0:
-                        assert f_o * f >= 0 and h_o * h >= 0 and w_o * w >= 0
-                        seq_f_int = int(seq_f)
-                        seq_h_int = int(seq_h)
-                        seq_w_int = int(seq_w)
-
-                        if f_o >= 0:
-                            f_sam = torch.linspace(int(f_o), int(t_f + f_o) - 1, seq_f_int, device=device).long()
-                        else:
-                            f_sam = torch.linspace(int(-f_o), int(-t_f - f_o) + 1, seq_f_int, device=device).long()
-                        h_sam = torch.linspace(int(h_o), int(t_h + h_o) - 1, seq_h_int, device=device).long()
-                        w_sam = torch.linspace(int(w_o), int(t_w + w_o) - 1, seq_w_int, device=device).long()
-
-                        freqs_0 = torch.index_select(freqs_split[0] if f_o >= 0 else freqs_split[0].conj(), 0, f_sam)
-                        freqs_0 = freqs_0.view(seq_f_int, 1, 1, -1)
-
-                        freqs_i = torch.cat(
-                            [
-                                freqs_0.expand(seq_f_int, seq_h_int, seq_w_int, -1),
-                                torch.index_select(freqs_split[1], 0, h_sam)
-                                .view(1, seq_h_int, 1, -1)
-                                .expand(seq_f_int, seq_h_int, seq_w_int, -1),
-                                torch.index_select(freqs_split[2], 0, w_sam)
-                                .view(1, 1, seq_w_int, -1)
-                                .expand(seq_f_int, seq_h_int, seq_w_int, -1),
-                            ],
-                            dim=-1,
-                        ).reshape(seq_len, 1, -1)
-                    elif t_f < 0:
-                        freqs_i = trainable_f.unsqueeze(1)
-                    output[i, seq_bucket[-1] : seq_bucket[-1] + seq_len] = freqs_i
-            seq_bucket.append(seq_bucket[-1] + seq_len)
-        return output
-
-
-class RotaryEmbeddingWanS2V(RotaryEmbeddingWan):
-    """Apply RoPE using precomputed complex freqs for Wan S2V main transformer.
-
-    Converts complex freqs (from WanS2VRotaryPosEmbed) to cos/sin and delegates
-    to RotaryEmbeddingWan for platform-optimized application (float32 kernel).
-    Under TP, freqs has 1 head — broadcasts automatically via cos/sin.
-    """
-
-    def __init__(self) -> None:
-        super().__init__(is_neox_style=False, half_head_dim=True)
-
-    def forward(self, x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
-        freqs_sliced = freqs[:, : x.size(1)]
-        cos = freqs_sliced.real.to(x.dtype)
-        sin = freqs_sliced.imag.to(x.dtype)
-        return super().forward(x, cos, sin)
-
-
 class RotaryEmbeddingS2VGrid(torch.nn.Module):
     """Grid-based RoPE for S2V motioner/init attention.
 
diff --git a/vllm_omni/diffusion/lora/loader.py b/vllm_omni/diffusion/lora/loader.py
index eb3f35188..8ed60ea06 100644
--- a/vllm_omni/diffusion/lora/loader.py
+++ b/vllm_omni/diffusion/lora/loader.py
@@ -13,6 +13,7 @@ from diffusers.loaders.lora_conversion_utils import (
 from safetensors.torch import load_file
 from vllm.logger import init_logger
 
+from vllm_omni.diffusion.distributed.utils import get_local_device
 from vllm_omni.diffusion.utils.tf_utils import get_transformer_from_pipeline
 from vllm_omni.transformers_utils.repo_utils import hf_api
 
@@ -120,6 +121,22 @@ def _prepare_lora_delta(
     return delta, used_keys
 
 
+def _resolve_lora_compute_device() -> torch.device | None:
+    """Return the local accelerator device if actually usable, else None.
+
+    get_local_device() may return cuda:N/npu:N even when no physical device is
+    present, so probe with a tiny allocation before trusting the lookup.
+    """
+    try:
+        dev = get_local_device()
+        if dev.type != "cpu":
+            torch.empty(1, device=dev)
+            return dev
+    except Exception:
+        pass
+    return None
+
+
 def _load_lora_state_dict(
     pretrained_model_name_or_path: str,
     weights_name: str | None = None,
@@ -270,6 +287,9 @@ class LoraLoaderMixin:
             for param_name, weight_name, _ in module.stacked_params_mapping:
                 param_to_weight_names[param_name].append(weight_name)
 
+        # Resolve the accelerator fallback once, outside the parameter loop.
+        accel_dev = _resolve_lora_compute_device()
+
         for name, params in module.named_parameters(prefix):
             is_bias = False
             if name.endswith(".bias"):
@@ -280,7 +300,7 @@ class LoraLoaderMixin:
             else:
                 continue
 
-            compute_dev = params.device if params.device.type != "cpu" else None
+            compute_dev = params.device if params.device.type != "cpu" else accel_dev
             delta, used_keys = _prepare_lora_delta(
                 state_dict,
                 base_key,
@@ -324,6 +344,9 @@ class LoraLoaderMixin:
             for param_name, weight_name, _ in module.stacked_params_mapping:
                 param_to_weight_names[param_name].append(weight_name)
 
+        # Resolve the accelerator fallback once, outside the parameter loop.
+        accel_dev = _resolve_lora_compute_device()
+
         for name, param in module.named_parameters(prefix):
             is_bias = False
             if name.endswith(".bias"):
@@ -334,7 +357,7 @@ class LoraLoaderMixin:
             else:
                 continue
 
-            compute_dev = param.device if param.device.type != "cpu" else None
+            compute_dev = param.device if param.device.type != "cpu" else accel_dev
             delta, used_keys = _prepare_lora_delta(
                 state_dict,
                 base_key,
diff --git a/vllm_omni/diffusion/model_loader/diffusers_loader.py b/vllm_omni/diffusion/model_loader/diffusers_loader.py
index 78247e7b9..c47eab7f7 100644
--- a/vllm_omni/diffusion/model_loader/diffusers_loader.py
+++ b/vllm_omni/diffusion/model_loader/diffusers_loader.py
@@ -7,7 +7,7 @@ import json
 import os
 import re
 import time
-from collections.abc import Generator, Iterable, Sequence
+from collections.abc import Callable, Generator, Iterable, Sequence
 from pathlib import Path
 from typing import cast
 
@@ -481,8 +481,14 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         )
 
     def _get_expected_parameter_names(self, model: nn.Module) -> set[str]:
-        """Return parameter names that should be covered by strict load checks."""
-        all_parameter_names = {name for name, _ in model.named_parameters()}
+        """Return parameter names that should be covered by strict load checks.
+
+        A parameter with an initialized checkpoint default can explicitly set
+        ``is_checkpoint_optional``. It is still loaded when present on disk.
+        """
+        all_parameter_names = {
+            name for name, param in model.named_parameters() if not getattr(param, "is_checkpoint_optional", False)
+        }
         sources = self._get_weight_sources(model)
 
         # Keep strict behavior if no source metadata exists.
@@ -673,10 +679,21 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         with set_default_torch_dtype(self.od_config.dtype):
             if self.parallel_config.use_hsdp:
                 model = self._load_model_with_hsdp(
-                    target_device=device, load_format=load_format, custom_pipeline_name=custom_pipeline_name
+                    target_device=device,
+                    load_format=load_format,
+                    custom_pipeline_name=custom_pipeline_name,
+                    offload_after_quant=offload_after_quant,
                 )
             else:
-                model = self._init_from_load_format(load_format, target_device, custom_pipeline_name, is_hsdp=False)
+                # The model is headed back to host memory right after online
+                # quantization, so over-wide NPU-unquantizable fallback weights
+                # load straight into host memory instead of round-tripping
+                # through the accelerator (~24 GiB startup peak on MiniMax H3).
+                from vllm_omni.quantization.int8_config import load_unquantizable_fallback_on_cpu
+
+                fallback_ctx = load_unquantizable_fallback_on_cpu() if offload_after_quant else contextlib.nullcontext()
+                with fallback_ctx:
+                    model = self._init_from_load_format(load_format, target_device, custom_pipeline_name, is_hsdp=False)
 
                 resolved_offload = resolve_offload(self.od_config)
                 distributed_offload = resolved_offload.strategy is OffloadStrategy.DISTRIBUTED_LAYER_WISE
@@ -715,8 +732,9 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
                     if unsupported_methods:
                         raise ValueError(
                             "DLO+AllGather supports online quantization only for "
-                            "per-tensor FP8, INT8, and MXFP8 linears; unsupported "
-                            f"online methods: {', '.join(sorted(unsupported_methods))}. "
+                            "per-tensor FP8, INT8, and MXFP8 linears "
+                            "(host-loaded unquantized fallback layers are also allowed); "
+                            f"unsupported online methods: {', '.join(sorted(unsupported_methods))}. "
                             "Use rank-local transfer for the affected component or "
                             "disable online quantization."
                         )
@@ -853,9 +871,24 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
                     del model
                     return self.load_fresh_canonical_model()
             raise
+        self._log_w4a8_fallback_load_summaries(model)
         self._attach_offload_startup_state(model)
         return model
 
+    @staticmethod
+    def _log_w4a8_fallback_load_summaries(model: nn.Module) -> None:
+        """Ask discovered DiTs to report W4A8 state at the common load exit.
+
+        Each DiT derives readiness from its processed layers, so a deferred
+        weight plan cannot be mistaken for the ordinary or HSDP load path.
+        """
+        components = ModuleDiscovery.discover(model)
+        for component_name, dit in zip(components.dit_names, components.dits):
+            candidate = getattr(dit, "_log_w4a8_fallback_load_summary", None)
+            if callable(candidate):
+                reporter = cast(Callable[[str], None], candidate)
+                reporter(component_name)
+
     @staticmethod
     def _request_offload_after_quant(model: nn.Module) -> int:
         """Ask online-quant layers to return to host memory once quantized.
@@ -909,6 +942,11 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         scale, packing, or aliasing layouts (e.g. dual-scale fp4 pairs,
         swizzled or NZ hardware formats) and remain fail-closed until
         validated.
+
+        ``UnquantizedHostLinearMethod`` is also allowed: it backs layers too
+        wide for npu_quant_matmul, loads their weights straight into host
+        memory, and its runtime layout is a plain contiguous bf16 weight —
+        identical to the ordinary unquantized path DLO already shards.
         """
         from vllm.model_executor.layers.quantization.online.fp8 import (
             Fp8PerTensorOnlineLinearMethod,
@@ -917,6 +955,7 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         from vllm_omni.quantization.int8_config import (
             Int8OnlineLinearMethod,
             NPUInt8OnlineLinearMethod,
+            UnquantizedHostLinearMethod,
         )
 
         try:
@@ -938,6 +977,7 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
             Fp8PerTensorOnlineLinearMethod,
             Int8OnlineLinearMethod,
             NPUInt8OnlineLinearMethod,
+            UnquantizedHostLinearMethod,
             *mxfp8_online_methods,
         )
 
@@ -1065,6 +1105,16 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         # that have loaded weights tracking currently.
         if loaded_weights is not None:
             weights_not_loaded = weights_to_load - loaded_weights
+            # Offline formats can require scales that older online loaders
+            # were allowed to synthesize. Do not apply that legacy tolerance
+            # to an explicitly required checkpoint tensor.
+            required_missing = {
+                name
+                for name, param in model.named_parameters()
+                if name in weights_not_loaded and getattr(param, "is_checkpoint_required", False)
+            }
+            if required_missing:
+                raise ValueError(f"Required weights were not initialized from checkpoint: {required_missing}")
             # NOTE: if the model is quantized, ignore not_loaded check for scale
             # weights. ModelOpt FP8 carries a per-tensor `weight_scale` and a
             # static activation `input_scale`, which the quant method may
@@ -1177,6 +1227,7 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         target_device: torch.device,
         load_format: str = "default",
         custom_pipeline_name: str | type[nn.Module] | None = None,
+        offload_after_quant: bool = False,
     ) -> nn.Module:
         """Load model with HSDP sharding for inference.
 
@@ -1200,40 +1251,54 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         # mapping (QKV fusion, etc.).
         if load_format == "diffusers":
             raise ValueError("HSDP is not supported with the diffusers adapter load format")
-        model = self._init_from_load_format(load_format, target_device, custom_pipeline_name, is_hsdp=True)
-        world_size = 1
-        rank = 0
-        if torch.distributed.is_initialized():
-            world_size = torch.distributed.get_world_size()
-            rank = torch.distributed.get_rank()
+        # Same host-fallback bound as the ordinary path: with a quant config the
+        # HSDP path initializes on the accelerator (hsdp_defer_to_cpu=False), so
+        # over-wide NPU-unquantizable fallback weights would otherwise round-trip
+        # through the device before apply_hsdp_to_model shards them. Loading them
+        # straight into host memory keeps the load-time device peak at the
+        # quantizable layers alone; sharding then distributes the fallback like
+        # any other parameter. Broadcast loading excludes online quantization
+        # already, so the context below only ever matters on the ordinary
+        # per-rank branch -- but spanning both is harmless.
+        from vllm_omni.quantization.int8_config import load_unquantizable_fallback_on_cpu
 
-        has_online_quant = self._has_online_quant(model) or (
-            self.quant_config is not None and not getattr(self.quant_config, "is_checkpoint_quantized", False)
-        )
-        enable_broadcast = bool(getattr(self.od_config, "enable_broadcast_weight_load", False)) and world_size > 1
+        fallback_ctx = load_unquantizable_fallback_on_cpu() if offload_after_quant else contextlib.nullcontext()
+        with fallback_ctx:
+            model = self._init_from_load_format(load_format, target_device, custom_pipeline_name, is_hsdp=True)
+            world_size = 1
+            rank = 0
+            if torch.distributed.is_initialized():
+                world_size = torch.distributed.get_world_size()
+                rank = torch.distributed.get_rank()
 
-        if enable_broadcast and has_online_quant:
-            logger.info(
-                "Worker %d: Online quantization detected; falling back to ordinary per-rank weight loading for HSDP",
-                rank,
+            has_online_quant = self._has_online_quant(model) or (
+                self.quant_config is not None and not getattr(self.quant_config, "is_checkpoint_quantized", False)
             )
-            enable_broadcast = False
+            enable_broadcast = bool(getattr(self.od_config, "enable_broadcast_weight_load", False)) and world_size > 1
 
-        if enable_broadcast:
-            if rank == 0:
+            if enable_broadcast and has_online_quant:
+                logger.info(
+                    "Worker %d: Online quantization detected; falling back to ordinary "
+                    "per-rank weight loading for HSDP",
+                    rank,
+                )
+                enable_broadcast = False
+
+            if enable_broadcast:
+                if rank == 0:
+                    self.load_weights(model)
+                    self._maybe_fuse_distilled_lora(model)
+                self._broadcast_model_weights(model, target_device=target_device, src_rank=0)
+                if (
+                    rank != 0
+                    and getattr(self.od_config, "lora_backend", None) in (LoRABackend.DISTILL, "distill")
+                    and getattr(self.od_config, "lora_path", None)
+                    and hasattr(model, "load_lora_weights")
+                ):
+                    setattr(model, "lora_is_fused", True)
+            else:
                 self.load_weights(model)
                 self._maybe_fuse_distilled_lora(model)
-            self._broadcast_model_weights(model, target_device=target_device, src_rank=0)
-            if (
-                rank != 0
-                and getattr(self.od_config, "lora_backend", None) in (LoRABackend.DISTILL, "distill")
-                and getattr(self.od_config, "lora_path", None)
-                and hasattr(model, "load_lora_weights")
-            ):
-                setattr(model, "lora_is_fused", True)
-        else:
-            self.load_weights(model)
-            self._maybe_fuse_distilled_lora(model)
 
         # Quantization methods must finish while parameters are ordinary local
         # tensors. Some post-load transforms use operations (for example,
diff --git a/vllm_omni/diffusion/model_loader/hub_prefetch.py b/vllm_omni/diffusion/model_loader/hub_prefetch.py
index a1e893b3b..a99751d6f 100644
--- a/vllm_omni/diffusion/model_loader/hub_prefetch.py
+++ b/vllm_omni/diffusion/model_loader/hub_prefetch.py
@@ -30,8 +30,7 @@ Two environmental factors mask the race on main:
   ``cached_files`` (plural) which batch-resolves every shard listed in the
   index up-front via ``os.path.isfile`` and raises immediately if any shard
   is still sitting under its ``*.incomplete`` name. Same wave of v5 changes
-  that introduced ``tie_weights(missing_keys=..., recompute_mapping=...)``
-  (see the Dynin shim in ``dynin_omni_token2text.py``).
+  that introduced ``tie_weights(missing_keys=..., recompute_mapping=...)``.
 * CI shares ``HF_HOME=/fsx/hf_cache`` across pipelines (both the
   ``vllm-omni`` and ``vllm-omni-rebase`` pipelines mount the same FS). That
   cache is normally warm for long-lived repos like ``Qwen-Image-Edit-2509``,
@@ -195,19 +194,22 @@ def _repo_prefetch_lock(model: str) -> Iterator[None]:
     flock_held = False
 
     # --- fcntl.flock path ---
+    fcntl_mod: Any = None
     try:
-        import fcntl  # type: ignore[import-not-found]
-    except ImportError:  # pragma: no cover - non-POSIX (Windows)
-        fcntl = None
+        import fcntl as _fcntl
 
-    if fcntl is not None:
+        fcntl_mod = _fcntl
+    except ImportError:  # pragma: no cover - non-POSIX (Windows)
+        pass
+
+    if fcntl_mod is not None:
         try:
             lock_dir = _node_lock_dir()
         except OSError as exc:
             logger.warning("Could not allocate lock dir for prefetch of %s (%s); skipping flock", model, exc)
-            fcntl = None  # force dotfile fallback
+            fcntl_mod = None  # force dotfile fallback
 
-    if fcntl is not None and lock_dir is not None:
+    if fcntl_mod is not None and lock_dir is not None:
         lock_path = os.path.join(lock_dir, _safe_repo_filename(model))
         try:
             fd = os.open(lock_path, os.O_RDWR | os.O_CREAT, 0o644)
@@ -217,7 +219,7 @@ def _repo_prefetch_lock(model: str) -> Iterator[None]:
 
         if fd is not None:
             try:
-                fcntl.flock(fd, fcntl.LOCK_EX)
+                fcntl_mod.flock(fd, fcntl_mod.LOCK_EX)
                 flock_held = True
                 logger.info("Acquired flock prefetch lock for %s at %s", model, lock_path)
             except OSError as exc:
@@ -249,9 +251,9 @@ def _repo_prefetch_lock(model: str) -> Iterator[None]:
     try:
         yield
     finally:
-        if flock_held and fd is not None:
+        if flock_held and fd is not None and fcntl_mod is not None:
             with contextlib.suppress(OSError):
-                fcntl.flock(fd, fcntl.LOCK_UN)
+                fcntl_mod.flock(fd, fcntl_mod.LOCK_UN)
         if fd is not None:
             with contextlib.suppress(OSError):
                 os.close(fd)
diff --git a/vllm_omni/diffusion/model_metadata.py b/vllm_omni/diffusion/model_metadata.py
index 2ee1b1f4b..1059093b6 100644
--- a/vllm_omni/diffusion/model_metadata.py
+++ b/vllm_omni/diffusion/model_metadata.py
@@ -17,6 +17,10 @@ class DiffusionModelMetadata:
     supported_control_upload_types: tuple[str, ...] = ()
     attention_mask_free: bool = False
     final_output_type: str | None = None
+    # Whether ``/v1/videos`` accepts source media plus per-token video/audio
+    # noise masks for latent initialization. Unknown pipelines must remain
+    # opted out so uploaded files never reach a model that cannot consume them.
+    supports_latent_mask_editing: bool = False
 
 
 # FLUX.2 Klein supports up to four reference images.
@@ -52,6 +56,7 @@ _DIFFUSION_MODEL_METADATA: dict[str, DiffusionModelMetadata] = {
         supports_multimodal_inputs=True,
         max_multimodal_image_inputs=9,
         supports_mixed_reference_inputs=True,
+        supports_latent_mask_editing=True,
         final_output_type="video",
         # H3 represents alignment padding as a second packed sequence.  The
         # packed TRTLLM backend consumes cu_seqlens and isolates that padding.
@@ -66,6 +71,7 @@ _DIFFUSION_MODEL_METADATA: dict[str, DiffusionModelMetadata] = {
         supports_multimodal_inputs=True,
         max_multimodal_image_inputs=9,
         supports_mixed_reference_inputs=True,
+        supports_latent_mask_editing=True,
         final_output_type="video",
         attention_mask_free=True,
     ),
diff --git a/vllm_omni/diffusion/models/anima/__init__.py b/vllm_omni/diffusion/models/anima/__init__.py
new file mode 100644
index 000000000..ddbabbcee
--- /dev/null
+++ b/vllm_omni/diffusion/models/anima/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from vllm_omni.diffusion.models.anima.pipeline_anima import AnimaPipeline
+
+__all__ = [
+    "AnimaPipeline",
+]
diff --git a/vllm_omni/diffusion/models/anima/anima_text_conditioner.py b/vllm_omni/diffusion/models/anima/anima_text_conditioner.py
new file mode 100644
index 000000000..84c3e4a2c
--- /dev/null
+++ b/vllm_omni/diffusion/models/anima/anima_text_conditioner.py
@@ -0,0 +1,321 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from collections.abc import Iterable
+from types import SimpleNamespace
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.layer import Attention
+
+ANIMA_TEXT_CONDITIONER_CONFIG = {
+    "source_dim": 1024,
+    "target_dim": 1024,
+    "model_dim": 1024,
+    "num_layers": 6,
+    "num_attention_heads": 16,
+    "mlp_ratio": 4.0,
+    "target_vocab_size": 32128,
+    "use_self_attention": True,
+    "use_layer_norm": False,
+    "min_sequence_length": 512,
+}
+
+
+def _rotate_half(hidden_states: torch.Tensor) -> torch.Tensor:
+    hidden_states_1 = hidden_states[..., : hidden_states.shape[-1] // 2]
+    hidden_states_2 = hidden_states[..., hidden_states.shape[-1] // 2 :]
+    return torch.cat((-hidden_states_2, hidden_states_1), dim=-1)
+
+
+def _apply_rotary_pos_emb(
+    hidden_states: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    unsqueeze_dim: int = 1,
+) -> torch.Tensor:
+    cos = cos.unsqueeze(unsqueeze_dim)
+    sin = sin.unsqueeze(unsqueeze_dim)
+    return (hidden_states * cos) + (_rotate_half(hidden_states) * sin)
+
+
+class AnimaRotaryEmbedding(nn.Module):
+    def __init__(self, head_dim: int, rope_theta: float = 10000.0) -> None:
+        super().__init__()
+        inv_freq = 1.0 / (
+            rope_theta ** (torch.arange(0, head_dim, 2, dtype=torch.int64).to(dtype=torch.float32) / head_dim)
+        )
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+    def forward(self, hidden_states: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1)
+        inv_freq_expanded = inv_freq_expanded.to(hidden_states.device)
+        position_ids_expanded = position_ids[:, None, :].float()
+
+        freqs = (inv_freq_expanded @ position_ids_expanded).transpose(1, 2)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        cos = emb.cos()
+        sin = emb.sin()
+        return cos.to(dtype=hidden_states.dtype), sin.to(dtype=hidden_states.dtype)
+
+
+class AnimaTextConditionerAttention(nn.Module):
+    def __init__(
+        self,
+        query_dim: int,
+        context_dim: int,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        inner_dim = num_attention_heads * attention_head_dim
+
+        self.num_attention_heads = num_attention_heads
+        self.attention_head_dim = attention_head_dim
+        self.q_proj = nn.Linear(query_dim, inner_dim, bias=False)
+        self.q_norm = nn.RMSNorm(attention_head_dim, eps=1e-6)
+        self.k_proj = nn.Linear(context_dim, inner_dim, bias=False)
+        self.k_norm = nn.RMSNorm(attention_head_dim, eps=1e-6)
+        self.v_proj = nn.Linear(context_dim, inner_dim, bias=False)
+        self.o_proj = nn.Linear(inner_dim, query_dim, bias=False)
+        self.attn = Attention(
+            num_heads=num_attention_heads,
+            head_size=attention_head_dim,
+            softmax_scale=1.0 / (attention_head_dim**0.5),
+            causal=False,
+            num_kv_heads=num_attention_heads,
+            prefix=prefix,
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+        encoder_hidden_states: torch.Tensor | None = None,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+        encoder_position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        encoder_hidden_states = hidden_states if encoder_hidden_states is None else encoder_hidden_states
+        input_shape = hidden_states.shape[:-1]
+        encoder_input_shape = encoder_hidden_states.shape[:-1]
+
+        query = self.q_proj(hidden_states)
+        key = self.k_proj(encoder_hidden_states)
+        value = self.v_proj(encoder_hidden_states)
+
+        query = query.view(*input_shape, self.num_attention_heads, self.attention_head_dim)
+        key = key.view(*encoder_input_shape, self.num_attention_heads, self.attention_head_dim)
+        value = value.view(*encoder_input_shape, self.num_attention_heads, self.attention_head_dim)
+
+        query = self.q_norm(query)
+        key = self.k_norm(key)
+
+        if position_embeddings is not None:
+            if encoder_position_embeddings is None:
+                raise ValueError("encoder_position_embeddings is required with rotary embeddings.")
+            cos, sin = position_embeddings
+            query = _apply_rotary_pos_emb(query, cos, sin, unsqueeze_dim=2)
+            cos, sin = encoder_position_embeddings
+            key = _apply_rotary_pos_emb(key, cos, sin, unsqueeze_dim=2)
+
+        attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
+        hidden_states = self.attn(query, key, value, attn_metadata=attn_metadata)
+        hidden_states = hidden_states.flatten(2, 3).contiguous()
+        return self.o_proj(hidden_states)
+
+
+class AnimaTextConditionerBlock(nn.Module):
+    def __init__(
+        self,
+        source_dim: int,
+        model_dim: int,
+        num_attention_heads: int = 16,
+        mlp_ratio: float = 4.0,
+        use_self_attention: bool = True,
+        use_layer_norm: bool = False,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.use_self_attention = use_self_attention
+        norm_cls = nn.LayerNorm if use_layer_norm else nn.RMSNorm
+        norm_kwargs = {} if use_layer_norm else {"eps": 1e-6}
+
+        if use_self_attention:
+            self.norm_self_attn = norm_cls(model_dim, **norm_kwargs)
+            self.self_attn = AnimaTextConditionerAttention(
+                query_dim=model_dim,
+                context_dim=model_dim,
+                num_attention_heads=num_attention_heads,
+                attention_head_dim=model_dim // num_attention_heads,
+                prefix=f"{prefix}.self_attn" if prefix else "self_attn",
+            )
+
+        self.norm_cross_attn = norm_cls(model_dim, **norm_kwargs)
+        self.cross_attn = AnimaTextConditionerAttention(
+            query_dim=model_dim,
+            context_dim=source_dim,
+            num_attention_heads=num_attention_heads,
+            attention_head_dim=model_dim // num_attention_heads,
+            prefix=f"{prefix}.cross_attn" if prefix else "cross_attn",
+        )
+        self.norm_mlp = norm_cls(model_dim, **norm_kwargs)
+        self.mlp = nn.Sequential(
+            nn.Linear(model_dim, int(model_dim * mlp_ratio)),
+            nn.GELU(),
+            nn.Linear(int(model_dim * mlp_ratio), model_dim),
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        target_attention_mask: torch.Tensor | None = None,
+        source_attention_mask: torch.Tensor | None = None,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+        source_position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        if self.use_self_attention:
+            norm_hidden_states = self.norm_self_attn(hidden_states)
+            attn_hidden_states = self.self_attn(
+                norm_hidden_states,
+                attention_mask=target_attention_mask,
+                position_embeddings=position_embeddings,
+                encoder_position_embeddings=position_embeddings,
+            )
+            hidden_states = hidden_states + attn_hidden_states
+
+        norm_hidden_states = self.norm_cross_attn(hidden_states)
+        attn_hidden_states = self.cross_attn(
+            norm_hidden_states,
+            attention_mask=source_attention_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            position_embeddings=position_embeddings,
+            encoder_position_embeddings=source_position_embeddings,
+        )
+        hidden_states = hidden_states + attn_hidden_states
+        hidden_states = hidden_states + self.mlp(self.norm_mlp(hidden_states))
+        return hidden_states
+
+
+def is_conditioner_block_module(name: str, module: nn.Module) -> bool:
+    return "blocks" in name and name.split(".")[-1].isdigit()
+
+
+class AnimaTextConditioner(nn.Module):
+    _repeated_blocks = ["AnimaTextConditionerBlock"]
+    _hsdp_shard_conditions = [is_conditioner_block_module]
+
+    def __init__(
+        self,
+        source_dim: int = 1024,
+        target_dim: int = 1024,
+        model_dim: int = 1024,
+        num_layers: int = 6,
+        num_attention_heads: int = 16,
+        mlp_ratio: float = 4.0,
+        target_vocab_size: int = 32128,
+        use_self_attention: bool = True,
+        use_layer_norm: bool = False,
+        min_sequence_length: int = 512,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__()
+        self.config = SimpleNamespace(
+            source_dim=source_dim,
+            target_dim=target_dim,
+            model_dim=model_dim,
+            num_layers=num_layers,
+            num_attention_heads=num_attention_heads,
+            mlp_ratio=mlp_ratio,
+            target_vocab_size=target_vocab_size,
+            use_self_attention=use_self_attention,
+            use_layer_norm=use_layer_norm,
+            min_sequence_length=min_sequence_length,
+            extra_config=kwargs,
+        )
+        self.embed = nn.Embedding(target_vocab_size, target_dim)
+        self.in_proj = nn.Linear(target_dim, model_dim) if model_dim != target_dim else nn.Identity()
+        self.rotary_emb = AnimaRotaryEmbedding(model_dim // num_attention_heads)
+        self.blocks = nn.ModuleList(
+            [
+                AnimaTextConditionerBlock(
+                    source_dim=source_dim,
+                    model_dim=model_dim,
+                    num_attention_heads=num_attention_heads,
+                    mlp_ratio=mlp_ratio,
+                    use_self_attention=use_self_attention,
+                    use_layer_norm=use_layer_norm,
+                    prefix=f"blocks.{i}",
+                )
+                for i in range(num_layers)
+            ]
+        )
+        self.out_proj = nn.Linear(model_dim, target_dim)
+        self.norm = nn.RMSNorm(target_dim, eps=1e-6)
+        self.gradient_checkpointing = False
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+    @staticmethod
+    def _prepare_attention_mask(attention_mask: torch.Tensor | None) -> torch.Tensor | None:
+        if attention_mask is None:
+            return None
+        return attention_mask.to(torch.bool)
+
+    def forward(
+        self,
+        source_hidden_states: torch.Tensor,
+        target_input_ids: torch.Tensor,
+        target_attention_mask: torch.Tensor | None = None,
+        source_attention_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        target_attention_mask = self._prepare_attention_mask(target_attention_mask)
+        source_attention_mask = self._prepare_attention_mask(source_attention_mask)
+
+        hidden_states = self.embed(target_input_ids).to(dtype=source_hidden_states.dtype)
+        hidden_states = self.in_proj(hidden_states)
+
+        position_ids = torch.arange(hidden_states.shape[1], device=hidden_states.device).unsqueeze(0)
+        source_position_ids = torch.arange(source_hidden_states.shape[1], device=hidden_states.device).unsqueeze(0)
+        position_embeddings = self.rotary_emb(hidden_states, position_ids)
+        source_position_embeddings = self.rotary_emb(hidden_states, source_position_ids)
+
+        for block in self.blocks:
+            hidden_states = block(
+                hidden_states,
+                source_hidden_states,
+                target_attention_mask=target_attention_mask,
+                source_attention_mask=source_attention_mask,
+                position_embeddings=position_embeddings,
+                source_position_embeddings=source_position_embeddings,
+            )
+
+        hidden_states = self.norm(self.out_proj(hidden_states))
+
+        if target_attention_mask is not None:
+            hidden_states = hidden_states * target_attention_mask.to(hidden_states).unsqueeze(-1)
+
+        if hidden_states.shape[1] < self.config.min_sequence_length:
+            hidden_states = F.pad(hidden_states, (0, 0, 0, self.config.min_sequence_length - hidden_states.shape[1]))
+
+        return hidden_states
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        params = dict(self.named_parameters())
+        loaded = set()
+        for name, tensor in weights:
+            if name not in params:
+                continue
+            param = params[name]
+            weight_loader = getattr(param, "weight_loader", default_weight_loader)
+            weight_loader(param, tensor)
+            loaded.add(name)
+        return loaded
diff --git a/vllm_omni/diffusion/models/anima/anima_transformer.py b/vllm_omni/diffusion/models/anima/anima_transformer.py
new file mode 100644
index 000000000..4c92a4ff3
--- /dev/null
+++ b/vllm_omni/diffusion/models/anima/anima_transformer.py
@@ -0,0 +1,705 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from collections.abc import Iterable
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from diffusers.models.embeddings import Timesteps, apply_rotary_emb
+from diffusers.models.modeling_outputs import Transformer2DModelOutput
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.layer import Attention
+from vllm_omni.diffusion.distributed.hsdp_utils import is_transformer_block_module
+
+ANIMA_TRANSFORMER_CONFIG = {
+    "in_channels": 16,
+    "out_channels": 16,
+    "num_attention_heads": 16,
+    "attention_head_dim": 128,
+    "num_layers": 28,
+    "mlp_ratio": 4.0,
+    "text_embed_dim": 1024,
+    "adaln_lora_dim": 256,
+    "max_size": (128, 240, 240),
+    "patch_size": (1, 2, 2),
+    "rope_scale": (1.0, 4.0, 4.0),
+    "concat_padding_mask": True,
+    "extra_pos_embed_type": None,
+}
+
+
+# NOTE: We import and use diffusers' `apply_rotary_emb` instead of a custom native implementation
+# to prevent numerical drift in bfloat16. Diffusers upcasts queries, keys, and rotary frequency
+# tensors to float32 before computing the rotation, and casts back to bfloat16 at the end.
+# Performing the entire computation in bfloat16 accumulates precision errors across the 28
+# transformer blocks, which is heavily amplified by Classifier-Free Guidance (CFG).
+
+
+class CosmosPatchEmbed(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        patch_size: tuple[int, int, int],
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        self.patch_size = patch_size
+        self.proj = nn.Linear(in_channels * patch_size[0] * patch_size[1] * patch_size[2], out_channels, bias=bias)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+        p_t, p_h, p_w = self.patch_size
+        hidden_states = hidden_states.reshape(
+            batch_size,
+            num_channels,
+            num_frames // p_t,
+            p_t,
+            height // p_h,
+            p_h,
+            width // p_w,
+            p_w,
+        )
+        hidden_states = hidden_states.permute(0, 2, 4, 6, 1, 3, 5, 7).flatten(4, 7)
+        return self.proj(hidden_states)
+
+
+class CosmosTimestepEmbedding(nn.Module):
+    def __init__(self, in_features: int, out_features: int) -> None:
+        super().__init__()
+        self.linear_1 = nn.Linear(in_features, out_features, bias=False)
+        self.activation = nn.SiLU()
+        self.linear_2 = nn.Linear(out_features, 3 * out_features, bias=False)
+
+    def forward(self, timesteps: torch.Tensor) -> torch.Tensor:
+        emb = self.linear_1(timesteps)
+        emb = self.activation(emb)
+        return self.linear_2(emb)
+
+
+class CosmosEmbedding(nn.Module):
+    def __init__(self, embedding_dim: int, condition_dim: int) -> None:
+        super().__init__()
+        self.time_proj = Timesteps(embedding_dim, flip_sin_to_cos=True, downscale_freq_shift=0.0)
+        self.t_embedder = CosmosTimestepEmbedding(embedding_dim, condition_dim)
+        self.norm = nn.RMSNorm(embedding_dim, eps=1e-6)
+
+    def forward(self, hidden_states: torch.Tensor, timestep: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        timesteps_proj = self.time_proj(timestep).type_as(hidden_states)
+        temb = self.t_embedder(timesteps_proj)
+        embedded_timestep = self.norm(timesteps_proj)
+        return temb, embedded_timestep
+
+
+class CosmosAdaLayerNorm(nn.Module):
+    def __init__(self, in_features: int, hidden_features: int) -> None:
+        super().__init__()
+        self.embedding_dim = in_features
+        self.activation = nn.SiLU()
+        self.norm = nn.LayerNorm(in_features, elementwise_affine=False, eps=1e-6)
+        self.linear_1 = nn.Linear(in_features, hidden_features, bias=False)
+        self.linear_2 = nn.Linear(hidden_features, 2 * in_features, bias=False)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        embedded_timestep: torch.Tensor,
+        temb: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        embedded_timestep = self.activation(embedded_timestep)
+        embedded_timestep = self.linear_1(embedded_timestep)
+        embedded_timestep = self.linear_2(embedded_timestep)
+
+        if temb is not None:
+            embedded_timestep = embedded_timestep + temb[..., : 2 * self.embedding_dim]
+
+        shift, scale = embedded_timestep.chunk(2, dim=-1)
+        hidden_states = self.norm(hidden_states)
+
+        if embedded_timestep.ndim == 2:
+            shift, scale = (x.unsqueeze(1) for x in (shift, scale))
+
+        return hidden_states * (1 + scale) + shift
+
+
+class CosmosAdaLayerNormZero(nn.Module):
+    def __init__(self, in_features: int, hidden_features: int | None = None) -> None:
+        super().__init__()
+        self.norm = nn.LayerNorm(in_features, elementwise_affine=False, eps=1e-6)
+        self.activation = nn.SiLU()
+        self.linear_1 = (
+            nn.Identity() if hidden_features is None else nn.Linear(in_features, hidden_features, bias=False)
+        )
+        self.linear_2 = nn.Linear(hidden_features or in_features, 3 * in_features, bias=False)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        embedded_timestep: torch.Tensor,
+        temb: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        embedded_timestep = self.activation(embedded_timestep)
+        embedded_timestep = self.linear_1(embedded_timestep)
+        embedded_timestep = self.linear_2(embedded_timestep)
+
+        if temb is not None:
+            embedded_timestep = embedded_timestep + temb
+
+        shift, scale, gate = embedded_timestep.chunk(3, dim=-1)
+        hidden_states = self.norm(hidden_states)
+
+        if embedded_timestep.ndim == 2:
+            shift, scale, gate = (x.unsqueeze(1) for x in (shift, scale, gate))
+
+        hidden_states = hidden_states * (1 + scale) + shift
+        return hidden_states, gate
+
+
+class CosmosGELU(nn.Module):
+    def __init__(self, dim: int, inner_dim: int, bias: bool = False) -> None:
+        super().__init__()
+        self.proj = nn.Linear(dim, inner_dim, bias=bias)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return F.gelu(self.proj(hidden_states))
+
+
+class CosmosFeedForward(nn.Module):
+    def __init__(self, dim: int, mult: float = 4.0, bias: bool = False) -> None:
+        super().__init__()
+        inner_dim = int(dim * mult)
+        self.net = nn.ModuleList(
+            [
+                CosmosGELU(dim, inner_dim, bias=bias),
+                nn.Identity(),
+                nn.Linear(inner_dim, dim, bias=bias),
+            ]
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        for module in self.net:
+            hidden_states = module(hidden_states)
+        return hidden_states
+
+
+class CosmosAttention(nn.Module):
+    def __init__(
+        self,
+        query_dim: int,
+        cross_attention_dim: int | None = None,
+        heads: int = 8,
+        dim_head: int = 64,
+        out_bias: bool = False,
+        img_context: bool = False,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        inner_dim = heads * dim_head
+        cross_attention_dim = query_dim if cross_attention_dim is None else cross_attention_dim
+
+        self.heads = heads
+        self.dim_head = dim_head
+        self.out_dim = inner_dim
+        self.query_dim = query_dim
+        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(cross_attention_dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(cross_attention_dim, inner_dim, bias=False)
+        self.norm_q = nn.RMSNorm(dim_head, eps=1e-6)
+        self.norm_k = nn.RMSNorm(dim_head, eps=1e-6)
+        self.to_out = nn.ModuleList([nn.Linear(inner_dim, query_dim, bias=out_bias), nn.Identity()])
+        self.attn = Attention(
+            num_heads=heads,
+            head_size=dim_head,
+            softmax_scale=1.0 / (dim_head**0.5),
+            causal=False,
+            num_kv_heads=heads,
+            prefix=prefix,
+        )
+
+        self.img_context = img_context
+        if img_context:
+            self.q_img = nn.Linear(query_dim, inner_dim, bias=False)
+            self.k_img = nn.Linear(query_dim, inner_dim, bias=False)
+            self.v_img = nn.Linear(query_dim, inner_dim, bias=False)
+            self.q_img_norm = nn.RMSNorm(dim_head, eps=1e-6)
+            self.k_img_norm = nn.RMSNorm(dim_head, eps=1e-6)
+            self.img_attn = Attention(
+                num_heads=heads,
+                head_size=dim_head,
+                softmax_scale=1.0 / (dim_head**0.5),
+                causal=False,
+                num_kv_heads=heads,
+                prefix=f"{prefix}.img_attn" if prefix else "img_attn",
+            )
+
+    def _attention(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        encoder_hidden_states = hidden_states if encoder_hidden_states is None else encoder_hidden_states
+        batch_size, seq_len, _ = hidden_states.shape
+        encoder_seq_len = encoder_hidden_states.shape[1]
+
+        query = self.to_q(hidden_states).view(batch_size, seq_len, self.heads, self.dim_head)
+        key = self.to_k(encoder_hidden_states).view(batch_size, encoder_seq_len, self.heads, self.dim_head)
+        value = self.to_v(encoder_hidden_states).view(batch_size, encoder_seq_len, self.heads, self.dim_head)
+
+        query = self.norm_q(query)
+        key = self.norm_k(key)
+
+        if image_rotary_emb is not None:
+            # We use diffusers' apply_rotary_emb to leverage its internal float32 rotation upcasting
+            # logic, resolving the bfloat16 cumulative precision drift vs. the reference pipeline.
+            query = apply_rotary_emb(query, image_rotary_emb, sequence_dim=1, use_real_unbind_dim=-2)
+            key = apply_rotary_emb(key, image_rotary_emb, sequence_dim=1, use_real_unbind_dim=-2)
+
+        attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
+        hidden_states = self.attn(query, key, value, attn_metadata=attn_metadata)
+        return hidden_states.flatten(2, 3).type_as(query)
+
+    def _image_attention(
+        self,
+        hidden_states: torch.Tensor,
+        img_context: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        batch_size, seq_len, _ = hidden_states.shape
+        img_seq_len = img_context.shape[1]
+
+        query = self.q_img(hidden_states).view(batch_size, seq_len, self.heads, self.dim_head)
+        key = self.k_img(img_context).view(batch_size, img_seq_len, self.heads, self.dim_head)
+        value = self.v_img(img_context).view(batch_size, img_seq_len, self.heads, self.dim_head)
+
+        query = self.q_img_norm(query)
+        key = self.k_img_norm(key)
+
+        attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
+        hidden_states = self.img_attn(query, key, value, attn_metadata=attn_metadata)
+        return hidden_states.flatten(2, 3).type_as(query)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | tuple[torch.Tensor, torch.Tensor | None] | None = None,
+        attention_mask: torch.Tensor | tuple[torch.Tensor | None, torch.Tensor | None] | None = None,
+        image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        if self.img_context:
+            if not isinstance(encoder_hidden_states, tuple):
+                raise ValueError("Expected encoder_hidden_states as (text_context, img_context).")
+            text_context, img_context = encoder_hidden_states
+            text_mask, img_mask = attention_mask if attention_mask is not None else (None, None)
+            query_states = hidden_states
+            hidden_states = self._attention(query_states, text_context, text_mask, image_rotary_emb)
+            if img_context is not None:
+                hidden_states = hidden_states + self._image_attention(query_states, img_context, img_mask)
+        else:
+            hidden_states = self._attention(hidden_states, encoder_hidden_states, attention_mask, image_rotary_emb)
+
+        hidden_states = self.to_out[0](hidden_states)
+        return self.to_out[1](hidden_states)
+
+
+class CosmosTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        cross_attention_dim: int,
+        mlp_ratio: float = 4.0,
+        adaln_lora_dim: int = 256,
+        out_bias: bool = False,
+        img_context: bool = False,
+        before_proj: bool = False,
+        after_proj: bool = False,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        hidden_size = num_attention_heads * attention_head_dim
+
+        self.norm1 = CosmosAdaLayerNormZero(in_features=hidden_size, hidden_features=adaln_lora_dim)
+        self.img_context = img_context
+        self.attn1 = CosmosAttention(
+            query_dim=hidden_size,
+            cross_attention_dim=None,
+            heads=num_attention_heads,
+            dim_head=attention_head_dim,
+            out_bias=out_bias,
+            prefix=f"{prefix}.attn1" if prefix else "attn1",
+        )
+        self.norm2 = CosmosAdaLayerNormZero(in_features=hidden_size, hidden_features=adaln_lora_dim)
+        self.attn2 = CosmosAttention(
+            query_dim=hidden_size,
+            cross_attention_dim=cross_attention_dim,
+            heads=num_attention_heads,
+            dim_head=attention_head_dim,
+            out_bias=out_bias,
+            img_context=img_context,
+            prefix=f"{prefix}.attn2" if prefix else "attn2",
+        )
+        self.norm3 = CosmosAdaLayerNormZero(in_features=hidden_size, hidden_features=adaln_lora_dim)
+        self.ff = CosmosFeedForward(hidden_size, mult=mlp_ratio, bias=out_bias)
+
+        self.before_proj = nn.Linear(hidden_size, hidden_size) if before_proj else None
+        self.after_proj = nn.Linear(hidden_size, hidden_size) if after_proj else None
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | tuple[torch.Tensor, torch.Tensor | None],
+        embedded_timestep: torch.Tensor,
+        temb: torch.Tensor | None = None,
+        image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        extra_pos_emb: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | tuple[torch.Tensor | None, torch.Tensor | None] | None = None,
+        controlnet_residual: torch.Tensor | None = None,
+        latents: torch.Tensor | None = None,
+        block_idx: int | None = None,
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        if self.before_proj is not None:
+            hidden_states = self.before_proj(hidden_states) + latents
+
+        if extra_pos_emb is not None:
+            hidden_states = hidden_states + extra_pos_emb
+
+        norm_hidden_states, gate = self.norm1(hidden_states, embedded_timestep, temb)
+        attn_output = self.attn1(norm_hidden_states, image_rotary_emb=image_rotary_emb)
+        hidden_states = hidden_states + gate * attn_output
+
+        norm_hidden_states, gate = self.norm2(hidden_states, embedded_timestep, temb)
+        attn_output = self.attn2(
+            norm_hidden_states, encoder_hidden_states=encoder_hidden_states, attention_mask=attention_mask
+        )
+        hidden_states = hidden_states + gate * attn_output
+
+        norm_hidden_states, gate = self.norm3(hidden_states, embedded_timestep, temb)
+        ff_output = self.ff(norm_hidden_states)
+        hidden_states = hidden_states + gate * ff_output
+
+        if controlnet_residual is not None:
+            if self.after_proj is not None:
+                raise ValueError("controlnet_residual is incompatible with after_proj.")
+            hidden_states = hidden_states + controlnet_residual
+
+        if self.after_proj is not None:
+            return hidden_states, self.after_proj(hidden_states)
+
+        return hidden_states
+
+
+class CosmosRotaryPosEmbed(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        max_size: tuple[int, int, int] = (128, 240, 240),
+        patch_size: tuple[int, int, int] = (1, 2, 2),
+        base_fps: int = 24,
+        rope_scale: tuple[float, float, float] = (2.0, 1.0, 1.0),
+    ) -> None:
+        super().__init__()
+        self.max_size = [size // patch for size, patch in zip(max_size, patch_size)]
+        self.patch_size = patch_size
+        self.base_fps = base_fps
+
+        self.dim_h = hidden_size // 6 * 2
+        self.dim_w = hidden_size // 6 * 2
+        self.dim_t = hidden_size - self.dim_h - self.dim_w
+
+        self.h_ntk_factor = rope_scale[1] ** (self.dim_h / (self.dim_h - 2))
+        self.w_ntk_factor = rope_scale[2] ** (self.dim_w / (self.dim_w - 2))
+        self.t_ntk_factor = rope_scale[0] ** (self.dim_t / (self.dim_t - 2))
+
+    def forward(self, hidden_states: torch.Tensor, fps: float | None = None) -> tuple[torch.Tensor, torch.Tensor]:
+        _, _, num_frames, height, width = hidden_states.shape
+        pe_size = [num_frames // self.patch_size[0], height // self.patch_size[1], width // self.patch_size[2]]
+        device = hidden_states.device
+
+        h_theta = 10000.0 * self.h_ntk_factor
+        w_theta = 10000.0 * self.w_ntk_factor
+        t_theta = 10000.0 * self.t_ntk_factor
+
+        seq = torch.arange(max(self.max_size), device=device, dtype=torch.float32)
+        dim_h_range = torch.arange(0, self.dim_h, 2, device=device, dtype=torch.float32)[: self.dim_h // 2] / self.dim_h
+        dim_w_range = torch.arange(0, self.dim_w, 2, device=device, dtype=torch.float32)[: self.dim_w // 2] / self.dim_w
+        dim_t_range = torch.arange(0, self.dim_t, 2, device=device, dtype=torch.float32)[: self.dim_t // 2] / self.dim_t
+        h_spatial_freqs = 1.0 / (h_theta**dim_h_range)
+        w_spatial_freqs = 1.0 / (w_theta**dim_w_range)
+        temporal_freqs = 1.0 / (t_theta**dim_t_range)
+
+        emb_h = torch.outer(seq[: pe_size[1]], h_spatial_freqs)[None, :, None, :].repeat(pe_size[0], 1, pe_size[2], 1)
+        emb_w = torch.outer(seq[: pe_size[2]], w_spatial_freqs)[None, None, :, :].repeat(pe_size[0], pe_size[1], 1, 1)
+        if fps is None:
+            emb_t = torch.outer(seq[: pe_size[0]], temporal_freqs)
+        else:
+            emb_t = torch.outer(seq[: pe_size[0]] / fps * self.base_fps, temporal_freqs)
+        emb_t = emb_t[:, None, None, :].repeat(1, pe_size[1], pe_size[2], 1)
+
+        freqs = torch.cat([emb_t, emb_h, emb_w] * 2, dim=-1).flatten(0, 2).float()
+        return torch.cos(freqs), torch.sin(freqs)
+
+
+class CosmosLearnablePositionalEmbed(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        max_size: tuple[int, int, int],
+        patch_size: tuple[int, int, int],
+        eps: float = 1e-6,
+    ) -> None:
+        super().__init__()
+        self.max_size = [size // patch for size, patch in zip(max_size, patch_size)]
+        self.patch_size = patch_size
+        self.eps = eps
+        self.pos_emb_t = nn.Parameter(torch.zeros(self.max_size[0], hidden_size))
+        self.pos_emb_h = nn.Parameter(torch.zeros(self.max_size[1], hidden_size))
+        self.pos_emb_w = nn.Parameter(torch.zeros(self.max_size[2], hidden_size))
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, _, num_frames, height, width = hidden_states.shape
+        pe_size = [num_frames // self.patch_size[0], height // self.patch_size[1], width // self.patch_size[2]]
+
+        emb_t = self.pos_emb_t[: pe_size[0]][None, :, None, None, :].repeat(batch_size, 1, pe_size[1], pe_size[2], 1)
+        emb_h = self.pos_emb_h[: pe_size[1]][None, None, :, None, :].repeat(batch_size, pe_size[0], 1, pe_size[2], 1)
+        emb_w = self.pos_emb_w[: pe_size[2]][None, None, None, :, :].repeat(batch_size, pe_size[0], pe_size[1], 1, 1)
+        emb = (emb_t + emb_h + emb_w).flatten(1, 3)
+
+        norm = torch.linalg.vector_norm(emb, dim=-1, keepdim=True, dtype=torch.float32)
+        norm = torch.add(self.eps, norm, alpha=np.sqrt(norm.numel() / emb.numel()))
+        return (emb / norm).type_as(hidden_states)
+
+
+class AnimaTransformer3DModel(nn.Module):
+    _repeated_blocks = ["CosmosTransformerBlock"]
+    _hsdp_shard_conditions = [is_transformer_block_module]
+
+    def __init__(
+        self,
+        in_channels: int = 16,
+        out_channels: int = 16,
+        num_attention_heads: int = 32,
+        attention_head_dim: int = 128,
+        num_layers: int = 28,
+        mlp_ratio: float = 4.0,
+        text_embed_dim: int = 1024,
+        adaln_lora_dim: int = 256,
+        max_size: tuple[int, int, int] = (128, 240, 240),
+        patch_size: tuple[int, int, int] = (1, 2, 2),
+        rope_scale: tuple[float, float, float] = (2.0, 1.0, 1.0),
+        concat_padding_mask: bool = True,
+        extra_pos_embed_type: str | None = "learnable",
+        use_crossattn_projection: bool = False,
+        crossattn_proj_in_channels: int = 1024,
+        encoder_hidden_states_channels: int = 1024,
+        controlnet_block_every_n: int | None = None,
+        img_context_dim_in: int | None = None,
+        img_context_num_tokens: int = 256,
+        img_context_dim_out: int = 2048,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__()
+        hidden_size = num_attention_heads * attention_head_dim
+        self.config = SimpleNamespace(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            num_attention_heads=num_attention_heads,
+            attention_head_dim=attention_head_dim,
+            num_layers=num_layers,
+            mlp_ratio=mlp_ratio,
+            text_embed_dim=text_embed_dim,
+            adaln_lora_dim=adaln_lora_dim,
+            max_size=max_size,
+            patch_size=patch_size,
+            rope_scale=rope_scale,
+            concat_padding_mask=concat_padding_mask,
+            extra_pos_embed_type=extra_pos_embed_type,
+            use_crossattn_projection=use_crossattn_projection,
+            crossattn_proj_in_channels=crossattn_proj_in_channels,
+            encoder_hidden_states_channels=encoder_hidden_states_channels,
+            controlnet_block_every_n=controlnet_block_every_n,
+            img_context_dim_in=img_context_dim_in,
+            img_context_num_tokens=img_context_num_tokens,
+            img_context_dim_out=img_context_dim_out,
+            extra_config=kwargs,
+        )
+
+        patch_embed_in_channels = in_channels + 1 if concat_padding_mask else in_channels
+        self.patch_embed = CosmosPatchEmbed(patch_embed_in_channels, hidden_size, patch_size, bias=False)
+        self.rope = CosmosRotaryPosEmbed(
+            hidden_size=attention_head_dim,
+            max_size=max_size,
+            patch_size=patch_size,
+            rope_scale=rope_scale,
+        )
+        self.learnable_pos_embed: CosmosLearnablePositionalEmbed | None = None
+        if extra_pos_embed_type == "learnable":
+            self.learnable_pos_embed = CosmosLearnablePositionalEmbed(
+                hidden_size=hidden_size,
+                max_size=max_size,
+                patch_size=patch_size,
+            )
+        self.time_embed = CosmosEmbedding(hidden_size, hidden_size)
+        self.transformer_blocks = nn.ModuleList(
+            [
+                CosmosTransformerBlock(
+                    num_attention_heads=num_attention_heads,
+                    attention_head_dim=attention_head_dim,
+                    cross_attention_dim=text_embed_dim,
+                    mlp_ratio=mlp_ratio,
+                    adaln_lora_dim=adaln_lora_dim,
+                    out_bias=False,
+                    img_context=img_context_dim_in is not None and img_context_dim_in > 0,
+                    prefix=f"transformer_blocks.{i}",
+                )
+                for i in range(num_layers)
+            ]
+        )
+        self.norm_out = CosmosAdaLayerNorm(hidden_size, adaln_lora_dim)
+        self.proj_out = nn.Linear(hidden_size, patch_size[0] * patch_size[1] * patch_size[2] * out_channels, bias=False)
+
+        self.crossattn_proj: nn.Module | None = None
+        if use_crossattn_projection:
+            self.crossattn_proj = nn.Sequential(
+                nn.Linear(crossattn_proj_in_channels, encoder_hidden_states_channels, bias=True),
+                nn.GELU(),
+            )
+
+        self.img_context_proj: nn.Module | None = None
+        if img_context_dim_in:
+            self.img_context_proj = nn.Sequential(
+                nn.Linear(img_context_dim_in, img_context_dim_out, bias=True),
+                nn.GELU(),
+            )
+
+        self.gradient_checkpointing = False
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | tuple[torch.Tensor, torch.Tensor | None],
+        block_controlnet_hidden_states: list[torch.Tensor] | None = None,
+        attention_mask: torch.Tensor | tuple[torch.Tensor | None, torch.Tensor | None] | None = None,
+        fps: float | None = None,
+        condition_mask: torch.Tensor | None = None,
+        padding_mask: torch.Tensor | None = None,
+        return_dict: bool = True,
+    ) -> Transformer2DModelOutput | tuple[torch.Tensor]:
+        batch_size, _, num_frames, height, width = hidden_states.shape
+
+        if condition_mask is not None:
+            hidden_states = torch.cat([hidden_states, condition_mask], dim=1)
+
+        if self.config.concat_padding_mask:
+            if padding_mask is None:
+                raise ValueError("padding_mask is required when concat_padding_mask=True.")
+            padding_mask_resized = F.interpolate(
+                padding_mask,
+                size=list(hidden_states.shape[-2:]),
+                mode="nearest",
+            )
+            hidden_states = torch.cat(
+                [hidden_states, padding_mask_resized.unsqueeze(2).repeat(batch_size, 1, num_frames, 1, 1)],
+                dim=1,
+            )
+
+        if isinstance(attention_mask, torch.Tensor) and attention_mask.ndim != 2:
+            attention_mask = attention_mask.squeeze(1).squeeze(1)
+
+        image_rotary_emb = self.rope(hidden_states, fps=fps)
+        extra_pos_emb = self.learnable_pos_embed(hidden_states) if self.learnable_pos_embed is not None else None
+
+        p_t, p_h, p_w = self.config.patch_size
+        post_patch_num_frames = num_frames // p_t
+        post_patch_height = height // p_h
+        post_patch_width = width // p_w
+
+        hidden_states = self.patch_embed(hidden_states)
+        hidden_states = hidden_states.flatten(1, 3)
+
+        if timestep.ndim == 1:
+            temb, embedded_timestep = self.time_embed(hidden_states, timestep)
+        elif timestep.ndim == 5:
+            if timestep.shape != (batch_size, 1, num_frames, 1, 1):
+                raise ValueError(f"Expected timestep shape [B, 1, T, 1, 1], got {timestep.shape}.")
+            timestep = timestep.flatten()
+            temb, embedded_timestep = self.time_embed(hidden_states, timestep)
+            temb, embedded_timestep = (
+                x.view(batch_size, post_patch_num_frames, 1, 1, -1)
+                .expand(-1, -1, post_patch_height, post_patch_width, -1)
+                .flatten(1, 3)
+                for x in (temb, embedded_timestep)
+            )
+        else:
+            raise ValueError(f"Expected timestep shape [B, 1, T, 1, 1] or [T], got {timestep.shape}.")
+
+        text_context, img_context = (
+            encoder_hidden_states if isinstance(encoder_hidden_states, tuple) else (encoder_hidden_states, None)
+        )
+        if self.config.use_crossattn_projection:
+            if self.crossattn_proj is None:
+                raise ValueError("crossattn_proj is required when use_crossattn_projection=True.")
+            text_context = self.crossattn_proj(text_context)
+        if img_context is not None and self.config.img_context_dim_in:
+            if self.img_context_proj is None:
+                raise ValueError("img_context_proj is required when img_context_dim_in is set.")
+            img_context = self.img_context_proj(img_context)
+        processed_encoder_hidden_states = (
+            (text_context, img_context) if isinstance(encoder_hidden_states, tuple) else text_context
+        )
+
+        controlnet_block_index_map = {}
+        if block_controlnet_hidden_states is not None:
+            n_blocks = len(self.transformer_blocks)
+            controlnet_block_index_map = {
+                block_idx: block_controlnet_hidden_states[idx]
+                for idx, block_idx in list(enumerate(range(0, n_blocks, self.config.controlnet_block_every_n)))
+            }
+
+        for block_idx, block in enumerate(self.transformer_blocks):
+            hidden_states = block(
+                hidden_states,
+                processed_encoder_hidden_states,
+                embedded_timestep,
+                temb,
+                image_rotary_emb,
+                extra_pos_emb,
+                attention_mask,
+                controlnet_block_index_map.get(block_idx),
+            )
+
+        hidden_states = self.norm_out(hidden_states, embedded_timestep, temb)
+        hidden_states = self.proj_out(hidden_states)
+        hidden_states = hidden_states.unflatten(2, (p_h, p_w, p_t, -1))
+        hidden_states = hidden_states.unflatten(1, (post_patch_num_frames, post_patch_height, post_patch_width))
+        hidden_states = hidden_states.permute(0, 7, 1, 6, 2, 4, 3, 5)
+        hidden_states = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+        if not return_dict:
+            return (hidden_states,)
+
+        return Transformer2DModelOutput(sample=hidden_states)
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        params = dict(self.named_parameters())
+        loaded = set()
+        for name, tensor in weights:
+            if name not in params:
+                continue
+            param = params[name]
+            weight_loader = getattr(param, "weight_loader", default_weight_loader)
+            weight_loader(param, tensor)
+            loaded.add(name)
+        return loaded
diff --git a/vllm_omni/diffusion/models/anima/pipeline_anima.py b/vllm_omni/diffusion/models/anima/pipeline_anima.py
new file mode 100644
index 000000000..63fdb7794
--- /dev/null
+++ b/vllm_omni/diffusion/models/anima/pipeline_anima.py
@@ -0,0 +1,795 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import inspect
+import json
+import logging
+import os
+from collections.abc import Callable, Iterable
+from pathlib import Path
+from typing import Any, cast
+
+import numpy as np
+import torch
+from diffusers.image_processor import VaeImageProcessor
+from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
+from diffusers.utils.torch_utils import randn_tensor
+from safetensors.torch import load_file
+from torch import nn
+from transformers import AutoTokenizer, Qwen3Model, T5TokenizerFast
+
+from vllm_omni.diffusion.config import set_current_diffusion_config
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_qwenimage import DistributedAutoencoderKLQwenImage
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.models.anima.anima_text_conditioner import (
+    ANIMA_TEXT_CONDITIONER_CONFIG,
+    AnimaTextConditioner,
+)
+from vllm_omni.diffusion.models.anima.anima_transformer import ANIMA_TRANSFORMER_CONFIG, AnimaTransformer3DModel
+from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
+from vllm_omni.diffusion.offloader.config import OffloadStrategy, resolve_offload_strategy
+from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
+from vllm_omni.diffusion.utils.size_utils import normalize_min_aligned_size
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+
+logger = logging.getLogger(__name__)
+
+ANIMA_VAE_SCALE_FACTOR = 8
+
+
+def retrieve_timesteps(
+    scheduler: Any,
+    num_inference_steps: int | None = None,
+    device: str | torch.device | None = None,
+    timesteps: list[int] | None = None,
+    sigmas: list[float] | None = None,
+    **kwargs: Any,
+) -> tuple[torch.Tensor, int]:
+    if timesteps is not None and sigmas is not None:
+        raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values")
+    if timesteps is not None:
+        if "timesteps" not in inspect.signature(scheduler.set_timesteps).parameters:
+            raise ValueError(
+                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
+                f" timestep schedules. Please check whether you are using the correct scheduler."
+            )
+        scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
+        scheduler_timesteps = scheduler.timesteps
+        num_inference_steps = len(scheduler_timesteps)
+    elif sigmas is not None:
+        if "sigmas" not in inspect.signature(scheduler.set_timesteps).parameters:
+            raise ValueError(
+                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
+                f" sigmas schedules. Please check whether you are using the correct scheduler."
+            )
+        scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs)
+        scheduler_timesteps = scheduler.timesteps
+        num_inference_steps = len(scheduler_timesteps)
+    else:
+        scheduler.set_timesteps(num_inference_steps, device=device, **kwargs)
+        scheduler_timesteps = scheduler.timesteps
+    if num_inference_steps is None:
+        num_inference_steps = len(scheduler_timesteps)
+    return cast(torch.Tensor, scheduler_timesteps), num_inference_steps
+
+
+_ANIMA_ORIGINAL_TRANSFORMER_RENAMES = {
+    "t_embedder.1": "time_embed.t_embedder",
+    "t_embedding_norm": "time_embed.norm",
+    "blocks": "transformer_blocks",
+    "adaln_modulation_self_attn.1": "norm1.linear_1",
+    "adaln_modulation_self_attn.2": "norm1.linear_2",
+    "adaln_modulation_cross_attn.1": "norm2.linear_1",
+    "adaln_modulation_cross_attn.2": "norm2.linear_2",
+    "adaln_modulation_mlp.1": "norm3.linear_1",
+    "adaln_modulation_mlp.2": "norm3.linear_2",
+    "self_attn": "attn1",
+    "cross_attn": "attn2",
+    "q_proj": "to_q",
+    "k_proj": "to_k",
+    "v_proj": "to_v",
+    "output_proj": "to_out.0",
+    "q_norm": "norm_q",
+    "k_norm": "norm_k",
+    "mlp.layer1": "ff.net.0.proj",
+    "mlp.layer2": "ff.net.2",
+    "x_embedder.proj.1": "patch_embed.proj",
+    "final_layer.adaln_modulation.1": "norm_out.linear_1",
+    "final_layer.adaln_modulation.2": "norm_out.linear_2",
+    "final_layer.linear": "proj_out",
+}
+
+_ANIMA_ORIGINAL_TRANSFORMER_DROP_KEYS = (
+    "accum_video_sample_counter",
+    "accum_image_sample_counter",
+    "accum_iteration",
+    "accum_train_in_hours",
+    "pos_embedder.seq",
+    "pos_embedder.dim_spatial_range",
+    "pos_embedder.dim_temporal_range",
+    "_extra_state",
+)
+
+
+def _anima_vae_scale_factor_from_vae(vae: Any) -> int:
+    vae_config = getattr(vae, "config", None)
+    spatial_compression_ratio = getattr(vae_config, "spatial_compression_ratio", None)
+    if spatial_compression_ratio is not None:
+        return int(spatial_compression_ratio)
+    temporal_downsample = getattr(vae, "temperal_downsample", None)
+    if temporal_downsample is not None:
+        return int(2 ** len(temporal_downsample))
+    return ANIMA_VAE_SCALE_FACTOR
+
+
+def get_anima_post_process_func(od_config: OmniDiffusionConfig) -> Callable[[torch.Tensor], Any]:
+    image_processor = VaeImageProcessor(vae_scale_factor=ANIMA_VAE_SCALE_FACTOR)
+
+    def post_process_func(images: torch.Tensor) -> Any:
+        return image_processor.postprocess(images)
+
+    return post_process_func
+
+
+class AnimaPipeline(nn.Module, DiffusionPipelineProfilerMixin, ProgressBarMixin):
+    """Native Anima model path.
+
+    The Anima transformer checkpoint is distributed as a single safetensors
+    file. This loader builds the native pipeline components and runs the denoise
+    transformer/text-conditioner directly.
+    """
+
+    supports_step_execution = False
+
+    def __init__(self, *, od_config: OmniDiffusionConfig, device: torch.device | str | None = None) -> None:
+        super().__init__()
+        self.od_config = od_config
+        self.parallel_config = od_config.parallel_config
+        self.device = device or get_local_device()
+        self.weights_sources: list[str] = []
+
+        self._raise_unsupported_features()
+
+        self._interrupt = False
+        self._guidance_scale = 1.0
+        self._num_timesteps = 0
+        self._current_timestep = None
+        self._profiler_initialized = False
+
+    def _raise_unsupported_features(self) -> None:
+        pc = self.od_config.parallel_config
+        if pc.cfg_parallel_size > 1:
+            raise NotImplementedError("AnimaPipeline does not yet support CFG parallel. Validate native CFG first.")
+        if pc.sequence_parallel_size is not None and pc.sequence_parallel_size > 1:
+            raise NotImplementedError("AnimaPipeline does not yet support sequence parallelism. Add an _sp_plan first.")
+        if pc.tensor_parallel_size > 1:
+            raise NotImplementedError("AnimaPipeline does not yet support tensor parallelism. Port TP linears first.")
+        if pc.use_hsdp:
+            raise NotImplementedError("AnimaPipeline does not yet support HSDP. Validate sharding after native load.")
+        if self.od_config.cache_backend not in ("none", None):
+            raise NotImplementedError("AnimaPipeline does not yet support TeaCache or Cache-DiT.")
+        if self.od_config.quantization_config is not None:
+            raise NotImplementedError("AnimaPipeline does not yet support quantized checkpoints.")
+        if resolve_offload_strategy(self.od_config) is not OffloadStrategy.NONE:
+            raise NotImplementedError("AnimaPipeline does not yet support CPU offload.")
+
+    @staticmethod
+    def _sub_state_dict(state_dict: dict[str, torch.Tensor], prefix: str) -> dict[str, torch.Tensor]:
+        return {key.removeprefix(prefix): value for key, value in state_dict.items() if key.startswith(prefix)}
+
+    @staticmethod
+    def _convert_original_transformer_state_dict(state_dict: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
+        if "patch_embed.proj.weight" in state_dict:
+            return state_dict
+
+        # The raw Anima checkpoint uses the original training names for a
+        # Cosmos-style denoiser. Convert those keys to the local
+        # AnimaTransformer3DModel module names before strict loading.
+        converted_state_dict = {}
+        for key, value in state_dict.items():
+            new_key = key.removeprefix("net.")
+            if any(drop_key in new_key for drop_key in _ANIMA_ORIGINAL_TRANSFORMER_DROP_KEYS):
+                continue
+            for old_key, new_name in _ANIMA_ORIGINAL_TRANSFORMER_RENAMES.items():
+                new_key = new_key.replace(old_key, new_name)
+            if new_key in converted_state_dict:
+                raise ValueError(f"Duplicate converted Anima transformer key: {new_key}")
+            converted_state_dict[new_key] = value
+        return converted_state_dict
+
+    @staticmethod
+    def _split_single_file_state_dict(
+        state_dict: dict[str, torch.Tensor],
+    ) -> tuple[dict[str, torch.Tensor], dict[str, torch.Tensor]]:
+        transformer_state_dict = AnimaPipeline._sub_state_dict(state_dict, "transformer.")
+        text_conditioner_state_dict = AnimaPipeline._sub_state_dict(state_dict, "text_conditioner.")
+        if transformer_state_dict and text_conditioner_state_dict:
+            return transformer_state_dict, text_conditioner_state_dict
+
+        text_conditioner_state_dict = AnimaPipeline._sub_state_dict(state_dict, "net.llm_adapter.")
+        if text_conditioner_state_dict:
+            transformer_state_dict = {
+                key: value for key, value in state_dict.items() if not key.startswith("net.llm_adapter.")
+            }
+            return transformer_state_dict, text_conditioner_state_dict
+
+        raise ValueError(
+            "Anima native loader could not find text-conditioner weights. Expected either "
+            "`text_conditioner.*` Diffusers keys or `net.llm_adapter.*` original Anima keys."
+        )
+
+    def _load_native_denoiser_components(
+        self,
+        state_dict: dict[str, torch.Tensor] | None = None,
+    ) -> tuple[AnimaTransformer3DModel, AnimaTextConditioner]:
+        if state_dict is None:
+            model_path = self.od_config.model
+            if not isinstance(model_path, str) or not os.path.isfile(model_path):
+                raise ValueError(f"AnimaPipeline currently requires a local file path, got: {model_path}")
+
+            state_dict = load_file(model_path, device="cpu")
+        transformer_state_dict, text_conditioner_state_dict = self._split_single_file_state_dict(state_dict)
+        del state_dict
+        transformer_state_dict = self._convert_original_transformer_state_dict(transformer_state_dict)
+
+        config_path = Path(self.od_config.model).with_suffix(".json")
+        config = json.loads(config_path.read_text()) if config_path.is_file() else {}
+        text_conditioner_config = {**ANIMA_TEXT_CONDITIONER_CONFIG, **config.get("text_conditioner", {})}
+        transformer_config = {**ANIMA_TRANSFORMER_CONFIG, **config.get("transformer", {})}
+
+        native_text_conditioner = AnimaTextConditioner(**cast(dict[str, Any], text_conditioner_config))
+        native_text_conditioner.load_state_dict(text_conditioner_state_dict, strict=True)
+        native_text_conditioner.to(device=self.device, dtype=self.od_config.dtype)
+        del text_conditioner_state_dict
+
+        native_transformer = AnimaTransformer3DModel(**cast(dict[str, Any], transformer_config))
+        native_transformer.load_state_dict(transformer_state_dict, strict=True)
+        native_transformer.to(device=self.device, dtype=self.od_config.dtype)
+        del transformer_state_dict
+
+        return native_transformer, native_text_conditioner
+
+    def _component_path(self, name: str, default_model: str) -> str:
+        custom_args = self.od_config.custom_pipeline_args or {}
+        return str(custom_args.get(f"{name}_model", custom_args.get(f"{name}_path", default_model)))
+
+    @staticmethod
+    def _from_pretrained_kwargs(model: str, subfolder: str | None = None) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {"local_files_only": os.path.exists(model)}
+        if subfolder is not None and os.path.isdir(os.path.join(model, subfolder)):
+            kwargs["subfolder"] = subfolder
+        return kwargs
+
+    def _load_outer_components(self) -> tuple[Any, Any, Any, Any, Any]:
+        custom_args = self.od_config.custom_pipeline_args or {}
+        components_model_value = custom_args.get("components_model", custom_args.get("components_path"))
+        if components_model_value is None:
+            if not isinstance(self.od_config.model, str):
+                raise ValueError("AnimaPipeline requires `model` or `components_model` to load outer components.")
+            checkpoint_dir = os.path.dirname(os.path.abspath(self.od_config.model))
+            components_model = checkpoint_dir if os.path.isdir(checkpoint_dir) else self.od_config.model
+        else:
+            components_model = str(components_model_value)
+
+        text_encoder_model = self._component_path("text_encoder", components_model)
+        vae_model = self._component_path("vae", components_model)
+        tokenizer_model = self._component_path("tokenizer", components_model)
+        t5_tokenizer_model = self._component_path("t5_tokenizer", components_model)
+
+        text_encoder = Qwen3Model.from_pretrained(
+            text_encoder_model,
+            torch_dtype=self.od_config.dtype,
+            **self._from_pretrained_kwargs(text_encoder_model, "text_encoder"),
+        ).to(self.device)
+        vae = DistributedAutoencoderKLQwenImage.from_pretrained(
+            vae_model,
+            torch_dtype=self.od_config.dtype,
+            **self._from_pretrained_kwargs(vae_model, "vae"),
+        ).to(self.device)
+        tokenizer = AutoTokenizer.from_pretrained(
+            tokenizer_model,
+            **self._from_pretrained_kwargs(tokenizer_model, "tokenizer"),
+        )
+        t5_tokenizer = T5TokenizerFast.from_pretrained(
+            t5_tokenizer_model,
+            **self._from_pretrained_kwargs(t5_tokenizer_model, "t5_tokenizer"),
+        )
+
+        scheduler_model = self._component_path("scheduler", components_model)
+        has_scheduler_config = os.path.isfile(os.path.join(scheduler_model, "scheduler_config.json")) or os.path.isdir(
+            os.path.join(scheduler_model, "scheduler")
+        )
+        if has_scheduler_config:
+            scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
+                scheduler_model,
+                **self._from_pretrained_kwargs(scheduler_model, "scheduler"),
+            )
+        else:
+            scheduler = FlowMatchEulerDiscreteScheduler(shift=3.0)
+
+        return text_encoder, tokenizer, t5_tokenizer, vae, scheduler
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]] | None = None) -> set[str]:
+        logger.info("Loading Anima transformer/text-conditioner directly from single-file checkpoint.")
+        state_dict = dict(weights) if weights is not None else None
+        loaded = set(state_dict.keys()) if state_dict is not None else set()
+        if not state_dict:
+            state_dict = None
+        with set_current_diffusion_config(self.od_config):
+            native_transformer, native_text_conditioner = self._load_native_denoiser_components(state_dict)
+        text_encoder, tokenizer, t5_tokenizer, vae, scheduler = self._load_outer_components()
+
+        self.transformer = native_transformer
+        self.text_conditioner = native_text_conditioner
+        self.text_encoder = text_encoder
+        self.tokenizer = tokenizer
+        self.t5_tokenizer = t5_tokenizer
+        self.vae = vae
+        self.scheduler = scheduler
+        self.vae_scale_factor = _anima_vae_scale_factor_from_vae(self.vae)
+        self._setup_profiler()
+        return loaded
+
+    def _setup_profiler(self) -> None:
+        if self._profiler_initialized:
+            return
+        self.setup_diffusion_pipeline_profiler(
+            profiler_targets=["vae.decode", "diffuse", "text_encoder.forward"],
+            enable_diffusion_pipeline_profiler=self.od_config.enable_diffusion_pipeline_profiler,
+        )
+        self._profiler_initialized = True
+
+    def _extract_prompts(self, prompts: list[Any]) -> tuple[str | list[str] | None, str | list[str] | None]:
+        """Extract prompt and negative_prompt from OmniPromptType list."""
+        prompt = [p if isinstance(p, str) else (p.get("prompt") or "") for p in prompts] or None
+        if all(isinstance(p, str) or p.get("negative_prompt") is None for p in prompts):
+            negative_prompt = None
+        elif prompts:
+            negative_prompt = ["" if isinstance(p, str) else (p.get("negative_prompt") or "") for p in prompts]
+        else:
+            negative_prompt = None
+        return prompt, negative_prompt
+
+    def _get_qwen_prompt_embeds(
+        self,
+        prompt: str | list[str],
+        max_sequence_length: int,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+
+        text_inputs = self.tokenizer(
+            prompt,
+            padding="longest",
+            max_length=max_sequence_length,
+            truncation=True,
+            return_tensors="pt",
+        )
+        text_input_ids = text_inputs.input_ids.to(device)
+        prompt_attention_mask = text_inputs.attention_mask.to(device)
+        if text_input_ids.shape[-1] == 0:
+            text_input_ids = text_input_ids.new_zeros((text_input_ids.shape[0], 1))
+            prompt_attention_mask = prompt_attention_mask.new_zeros((prompt_attention_mask.shape[0], 1))
+
+        prompt_embeds = self.text_encoder(
+            input_ids=text_input_ids,
+            attention_mask=prompt_attention_mask,
+            output_hidden_states=False,
+        ).last_hidden_state
+        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+        prompt_embeds = prompt_embeds * prompt_attention_mask.to(prompt_embeds).unsqueeze(-1)
+
+        return prompt_embeds, prompt_attention_mask
+
+    def _get_t5_prompt_ids(
+        self,
+        prompt: str | list[str],
+        max_sequence_length: int,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+
+        text_inputs = self.t5_tokenizer(
+            prompt,
+            padding="longest",
+            max_length=max_sequence_length,
+            truncation=True,
+            return_tensors="pt",
+        )
+        return text_inputs.input_ids.to(device), text_inputs.attention_mask.to(device)
+
+    def encode_prompt(
+        self,
+        prompt: str | list[str],
+        negative_prompt: str | list[str] | None = None,
+        prepare_unconditional_embeds: bool = True,
+        max_sequence_length: int = 512,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> dict[str, torch.Tensor | None]:
+        device = device or self.device
+        dtype = dtype or self.text_encoder.dtype
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        batch_size = len(prompt)
+
+        prompt_embeds, prompt_attention_mask = self._get_qwen_prompt_embeds(
+            prompt=prompt,
+            max_sequence_length=max_sequence_length,
+            device=device,
+            dtype=dtype,
+        )
+        t5_input_ids, t5_attention_mask = self._get_t5_prompt_ids(
+            prompt=prompt,
+            max_sequence_length=max_sequence_length,
+            device=device,
+        )
+
+        negative_prompt_embeds = None
+        negative_prompt_attention_mask = None
+        negative_t5_input_ids = None
+        negative_t5_attention_mask = None
+        if prepare_unconditional_embeds:
+            if negative_prompt is None:
+                negative_prompt = ""
+            if isinstance(negative_prompt, str):
+                negative_prompt = [negative_prompt] * batch_size
+            elif len(negative_prompt) != batch_size:
+                raise ValueError(
+                    f"`negative_prompt` length ({len(negative_prompt)}) must match prompt batch size ({batch_size})."
+                )
+
+            negative_prompt_embeds, negative_prompt_attention_mask = self._get_qwen_prompt_embeds(
+                prompt=negative_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+            negative_t5_input_ids, negative_t5_attention_mask = self._get_t5_prompt_ids(
+                prompt=negative_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+            )
+
+        return {
+            "qwen_prompt_embeds": prompt_embeds,
+            "qwen_attention_mask": prompt_attention_mask,
+            "t5_input_ids": t5_input_ids,
+            "t5_attention_mask": t5_attention_mask,
+            "negative_qwen_prompt_embeds": negative_prompt_embeds,
+            "negative_qwen_attention_mask": negative_prompt_attention_mask,
+            "negative_t5_input_ids": negative_t5_input_ids,
+            "negative_t5_attention_mask": negative_t5_attention_mask,
+        }
+
+    def condition_prompt_embeds(
+        self,
+        qwen_prompt_embeds: torch.Tensor,
+        qwen_attention_mask: torch.Tensor,
+        t5_input_ids: torch.Tensor,
+        t5_attention_mask: torch.Tensor,
+        device: torch.device | None = None,
+        conditioning_dtype: torch.dtype | None = None,
+        output_dtype: torch.dtype | None = None,
+    ) -> torch.Tensor:
+        device = device or self.device
+        conditioning_dtype = conditioning_dtype or self.text_conditioner.dtype
+        output_dtype = output_dtype or self.transformer.dtype
+
+        prompt_embeds = self.text_conditioner(
+            source_hidden_states=qwen_prompt_embeds.to(device=device, dtype=conditioning_dtype),
+            target_input_ids=t5_input_ids.to(device),
+            target_attention_mask=t5_attention_mask.to(device),
+            source_attention_mask=qwen_attention_mask.to(device),
+        )
+        return prompt_embeds.to(dtype=output_dtype, device=device)
+
+    def prepare_latents(
+        self,
+        batch_size: int,
+        num_channels_latents: int,
+        height: int,
+        width: int,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        device = device or self.device
+        dtype = dtype or self.transformer.dtype
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype)
+
+        latent_height = height // self.vae_scale_factor
+        latent_width = width // self.vae_scale_factor
+        shape = (batch_size, num_channels_latents, 1, latent_height, latent_width)
+
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        # Draw latents in float32 then cast
+        latents = randn_tensor(shape, generator=generator, device=device, dtype=torch.float32)
+        sigma_max = (
+            getattr(self.scheduler.config, "sigma_max", 1.0)
+            if hasattr(self, "scheduler") and hasattr(self.scheduler, "config")
+            else 1.0
+        )
+        return latents.to(dtype=dtype) * sigma_max
+
+    def prepare_timesteps(
+        self,
+        num_inference_steps: int,
+        sigmas: list[float] | None = None,
+        device: torch.device | None = None,
+    ) -> tuple[torch.Tensor, int]:
+        device = device or self.device
+        sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps) if sigmas is None else sigmas
+        return retrieve_timesteps(
+            self.scheduler,
+            device=device,
+            sigmas=sigmas,
+        )
+
+    def diffuse(
+        self,
+        prompt_embeds: torch.Tensor,
+        negative_prompt_embeds: torch.Tensor | None,
+        latents: torch.Tensor,
+        padding_mask: torch.Tensor,
+        timesteps: torch.Tensor,
+        do_true_cfg: bool,
+        true_cfg_scale: float,
+    ) -> torch.Tensor:
+        self.scheduler.set_begin_index(0)
+
+        with self.progress_bar(total=len(timesteps)) as pbar:
+            for i, t in enumerate(timesteps):
+                if self.interrupt:
+                    continue
+                self._current_timestep = t
+
+                # Broadcast timestep to match batch size
+                timestep = t.expand(latents.shape[0]).to(dtype=self.transformer.dtype, device=latents.device)
+                timestep = timestep / 1000.0  # normalize to 0..1 range
+
+                # Predict noise
+                latent_model_input = latents.to(self.transformer.dtype)
+
+                # Positive pass
+                noise_pred = self.transformer(
+                    hidden_states=latent_model_input,
+                    timestep=timestep,
+                    encoder_hidden_states=prompt_embeds,
+                    padding_mask=padding_mask,
+                    return_dict=False,
+                )[0]
+
+                # Negative / uncond pass
+                if do_true_cfg and negative_prompt_embeds is not None:
+                    noise_pred_uncond = self.transformer(
+                        hidden_states=latent_model_input,
+                        timestep=timestep,
+                        encoder_hidden_states=negative_prompt_embeds,
+                        padding_mask=padding_mask,
+                        return_dict=False,
+                    )[0]
+                    noise_pred = noise_pred_uncond + true_cfg_scale * (noise_pred - noise_pred_uncond)
+
+                # Scheduler step
+                latents_dtype = latents.dtype
+                latents = self.scheduler.step(noise_pred.to(latents_dtype), t, latents, return_dict=False)[0]
+                if latents.dtype != latents_dtype:
+                    latents = latents.to(latents_dtype)
+
+                pbar.update()
+
+        return latents
+
+    def decode_latents(
+        self,
+        latents: torch.Tensor,
+        output_type: str = "pil",
+    ) -> DiffusionOutput:
+        """Decode final latents."""
+        if output_type == "latent":
+            return DiffusionOutput(
+                output=latents,
+                stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
+            )
+
+        latents = latents.to(self.vae.dtype)
+        latents_mean = (
+            torch.tensor(self.vae.config.latents_mean)
+            .view(1, self.vae.config.z_dim, 1, 1, 1)
+            .to(latents.device, latents.dtype)
+        )
+        latents_std = (
+            torch.tensor(self.vae.config.latents_std)
+            .view(1, self.vae.config.z_dim, 1, 1, 1)
+            .to(latents.device, latents.dtype)
+        )
+        latents = latents * latents_std + latents_mean
+        image = self.vae.decode(latents, return_dict=False)[0][:, :, 0]
+        return DiffusionOutput(
+            output=image,
+            stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
+        )
+
+    def forward(
+        self,
+        req: DiffusionRequestBatch,
+        prompt: str | list[str] | None = None,
+        negative_prompt: str | list[str] | None = None,
+        true_cfg_scale: float = 4.0,
+        height: int | None = None,
+        width: int | None = None,
+        num_inference_steps: int = 50,
+        sigmas: list[float] | None = None,
+        guidance_scale: float = 4.0,
+        num_images_per_prompt: int = 1,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        output_type: str | None = "pil",
+        max_sequence_length: int = 512,
+    ) -> list[DiffusionOutput]:
+        if req.num_reqs != 1:
+            raise ValueError("AnimaPipeline supports one request per forward.")
+        extracted_prompt, negative_prompt = self._extract_prompts(req.prompts)
+        prompt = extracted_prompt or prompt
+        if prompt is None:
+            prompt = ""
+
+        height = req.sampling_params.height or height or 1024
+        width = req.sampling_params.width or width or 1024
+        height, width = normalize_min_aligned_size(height, width, self.vae_scale_factor * 2)
+        if height is None or width is None:
+            raise ValueError("AnimaPipeline requires resolved height and width.")
+        height = int(height)
+        width = int(width)
+        if req.sampling_params.output_type is not None:
+            output_type = req.sampling_params.output_type
+        output_type = output_type or "pil"
+
+        num_inference_steps = req.sampling_params.num_inference_steps or num_inference_steps
+        sigmas = req.sampling_params.sigmas or sigmas
+        max_sequence_length = req.sampling_params.max_sequence_length or max_sequence_length
+        generator = req.sampling_params.generator or generator
+        if req.sampling_params.guidance_scale_provided:
+            guidance_scale = req.sampling_params.guidance_scale
+            if req.sampling_params.true_cfg_scale is None:
+                true_cfg_scale = guidance_scale
+        if req.sampling_params.true_cfg_scale is not None:
+            true_cfg_scale = req.sampling_params.true_cfg_scale
+        num_images_per_prompt = (
+            req.sampling_params.num_outputs_per_prompt
+            if req.sampling_params.num_outputs_per_prompt > 0
+            else num_images_per_prompt
+        )
+
+        self._guidance_scale = guidance_scale
+        self._interrupt = False
+
+        if isinstance(prompt, str):
+            batch_size = 1
+        else:
+            batch_size = len(prompt)
+
+        do_true_cfg = guidance_scale > 1.0
+
+        # Encode prompts
+        enc_out = self.encode_prompt(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            prepare_unconditional_embeds=do_true_cfg,
+            max_sequence_length=max_sequence_length,
+            device=self.device,
+            dtype=self.text_encoder.dtype,
+        )
+        qwen_prompt_embeds = enc_out["qwen_prompt_embeds"]
+        qwen_attention_mask = enc_out["qwen_attention_mask"]
+        t5_input_ids = enc_out["t5_input_ids"]
+        t5_attention_mask = enc_out["t5_attention_mask"]
+        if (
+            qwen_prompt_embeds is None
+            or qwen_attention_mask is None
+            or t5_input_ids is None
+            or t5_attention_mask is None
+        ):
+            raise ValueError("Anima prompt encoding did not produce all required positive embeddings.")
+
+        # Condition prompt embeds
+        prompt_embeds = self.condition_prompt_embeds(
+            qwen_prompt_embeds=qwen_prompt_embeds,
+            qwen_attention_mask=qwen_attention_mask,
+            t5_input_ids=t5_input_ids,
+            t5_attention_mask=t5_attention_mask,
+            device=self.device,
+        )
+
+        negative_prompt_embeds = None
+        negative_qwen_prompt_embeds = enc_out["negative_qwen_prompt_embeds"]
+        if do_true_cfg and negative_qwen_prompt_embeds is not None:
+            negative_qwen_attention_mask = enc_out["negative_qwen_attention_mask"]
+            negative_t5_input_ids = enc_out["negative_t5_input_ids"]
+            negative_t5_attention_mask = enc_out["negative_t5_attention_mask"]
+            if (
+                negative_qwen_attention_mask is None
+                or negative_t5_input_ids is None
+                or negative_t5_attention_mask is None
+            ):
+                raise ValueError("Anima prompt encoding did not produce all required negative embeddings.")
+            negative_prompt_embeds = self.condition_prompt_embeds(
+                qwen_prompt_embeds=negative_qwen_prompt_embeds,
+                qwen_attention_mask=negative_qwen_attention_mask,
+                t5_input_ids=negative_t5_input_ids,
+                t5_attention_mask=negative_t5_attention_mask,
+                device=self.device,
+            )
+
+        # Repeat for num_images_per_prompt
+        _, seq_len, _ = prompt_embeds.shape
+        prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
+        prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
+
+        if negative_prompt_embeds is not None:
+            _, seq_len, _ = negative_prompt_embeds.shape
+            negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
+            negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
+
+        # Prepare latents
+        latents = self.prepare_latents(
+            batch_size=batch_size * num_images_per_prompt,
+            num_channels_latents=16,  # Cosmos/Anima has 16 channels
+            height=height,
+            width=width,
+            dtype=torch.float32,
+            device=self.device,
+            generator=generator,
+            latents=latents,
+        )
+
+        # Prepare padding mask
+        padding_mask = latents.new_zeros(1, 1, height, width, dtype=self.transformer.dtype)
+
+        # Prepare timesteps
+        timesteps, num_inference_steps = self.prepare_timesteps(
+            num_inference_steps=num_inference_steps,
+            sigmas=sigmas,
+            device=self.device,
+        )
+        self._num_timesteps = len(timesteps)
+
+        # Denoise loop
+        latents = self.diffuse(
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            latents=latents,
+            padding_mask=padding_mask,
+            timesteps=timesteps,
+            do_true_cfg=do_true_cfg,
+            true_cfg_scale=true_cfg_scale,
+        )
+
+        self._current_timestep = None
+        return [self.decode_latents(latents, output_type=output_type)]
+
+    @property
+    def guidance_scale(self) -> float:
+        return self._guidance_scale
+
+    @property
+    def num_timesteps(self) -> int:
+        return self._num_timesteps
+
+    @property
+    def current_timestep(self) -> torch.Tensor | None:
+        return self._current_timestep
+
+    @property
+    def interrupt(self) -> bool:
+        return self._interrupt
diff --git a/vllm_omni/diffusion/models/bagel/bagel_transformer.py b/vllm_omni/diffusion/models/bagel/bagel_transformer.py
index ddaa5693d..47ffda310 100644
--- a/vllm_omni/diffusion/models/bagel/bagel_transformer.py
+++ b/vllm_omni/diffusion/models/bagel/bagel_transformer.py
@@ -1,6 +1,7 @@
 # Copyright 2025 Bytedance Ltd. and/or its affiliates.
 # Copyright (c) 2024 The Qwen Team and The HuggingFace Inc. team.
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 #
 # This file has been modified by ByteDance Ltd. and/or its affiliates.
 #
@@ -48,10 +49,10 @@ from vllm_omni.diffusion.distributed.parallel_state import (
     get_sp_group,
 )
 from vllm_omni.diffusion.forward_context import get_forward_context, is_forward_context_available
-from vllm_omni.diffusion.layers.mot.mot_layernorm import MoTRMSNorm
-from vllm_omni.diffusion.layers.mot.mot_qkv_parallel_linear import MoTQKVParallelLinear
-from vllm_omni.diffusion.layers.mot.mot_row_parallel_linear import MoTRowParallelLinear
 from vllm_omni.diffusion.layers.rope import RotaryEmbedding
+from vllm_omni.diffusion.models.bagel.mot.mot_layernorm import MoTRMSNorm
+from vllm_omni.diffusion.models.bagel.mot.mot_qkv_parallel_linear import MoTQKVParallelLinear
+from vllm_omni.diffusion.models.bagel.mot.mot_row_parallel_linear import MoTRowParallelLinear
 from vllm_omni.diffusion.utils.kv_utils import left_pad_stack
 from vllm_omni.model_executor.layers.timestep_embedding import timestep_embedding
 
diff --git a/vllm_omni/diffusion/layers/mot/ops/__init__.py b/vllm_omni/diffusion/models/bagel/mot/__init__.py
similarity index 100%
rename from vllm_omni/diffusion/layers/mot/ops/__init__.py
rename to vllm_omni/diffusion/models/bagel/mot/__init__.py
diff --git a/vllm_omni/diffusion/layers/mot/mot_layernorm.py b/vllm_omni/diffusion/models/bagel/mot/mot_layernorm.py
similarity index 95%
rename from vllm_omni/diffusion/layers/mot/mot_layernorm.py
rename to vllm_omni/diffusion/models/bagel/mot/mot_layernorm.py
index 0ff67d7e3..802fa20a9 100644
--- a/vllm_omni/diffusion/layers/mot/mot_layernorm.py
+++ b/vllm_omni/diffusion/models/bagel/mot/mot_layernorm.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # ruff: noqa: N803, E741
 """Mixture-of-Tokens (MoT) RMS Normalization layer.
 
@@ -68,7 +71,7 @@ class MoTRMSNorm(CustomOp):
             return ir.ops.rms_norm(x, self.weight.data, self.variance_epsilon)
 
         # gen mode – fused MoT Triton kernel
-        from vllm_omni.diffusion.layers.mot.ops.mot_rms_norm import (
+        from vllm_omni.diffusion.models.bagel.mot.ops.mot_rms_norm import (
             mot_rms_norm,
         )
 
diff --git a/vllm_omni/diffusion/layers/mot/mot_qkv_parallel_linear.py b/vllm_omni/diffusion/models/bagel/mot/mot_qkv_parallel_linear.py
similarity index 99%
rename from vllm_omni/diffusion/layers/mot/mot_qkv_parallel_linear.py
rename to vllm_omni/diffusion/models/bagel/mot/mot_qkv_parallel_linear.py
index 235fc3342..b713d2826 100644
--- a/vllm_omni/diffusion/layers/mot/mot_qkv_parallel_linear.py
+++ b/vllm_omni/diffusion/models/bagel/mot/mot_qkv_parallel_linear.py
@@ -19,7 +19,7 @@ from vllm.model_executor.layers.quantization.base_config import (
 from vllm.model_executor.utils import set_weight_attrs
 from vllm.platforms import current_platform
 
-from vllm_omni.diffusion.layers.mot.ops.mot_gemm import invoke_mot_gemm
+from vllm_omni.diffusion.models.bagel.mot.ops.mot_gemm import invoke_mot_gemm
 
 logger = init_logger(__name__)
 
diff --git a/vllm_omni/diffusion/layers/mot/mot_row_parallel_linear.py b/vllm_omni/diffusion/models/bagel/mot/mot_row_parallel_linear.py
similarity index 99%
rename from vllm_omni/diffusion/layers/mot/mot_row_parallel_linear.py
rename to vllm_omni/diffusion/models/bagel/mot/mot_row_parallel_linear.py
index 6e846af47..3b6d040a9 100644
--- a/vllm_omni/diffusion/layers/mot/mot_row_parallel_linear.py
+++ b/vllm_omni/diffusion/models/bagel/mot/mot_row_parallel_linear.py
@@ -19,7 +19,7 @@ from vllm.model_executor.layers.quantization.base_config import (
 from vllm.model_executor.utils import set_weight_attrs
 from vllm.platforms import current_platform
 
-from vllm_omni.diffusion.layers.mot.ops.mot_gemm import invoke_mot_gemm
+from vllm_omni.diffusion.models.bagel.mot.ops.mot_gemm import invoke_mot_gemm
 
 
 class MoTRowParallelLinear(RowParallelLinear):
diff --git a/vllm_omni/diffusion/models/bagel/mot/ops/__init__.py b/vllm_omni/diffusion/models/bagel/mot/ops/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/vllm_omni/diffusion/layers/mot/ops/mot_gemm.py b/vllm_omni/diffusion/models/bagel/mot/ops/mot_gemm.py
similarity index 99%
rename from vllm_omni/diffusion/layers/mot/ops/mot_gemm.py
rename to vllm_omni/diffusion/models/bagel/mot/ops/mot_gemm.py
index f1bffbbac..10638a089 100644
--- a/vllm_omni/diffusion/layers/mot/ops/mot_gemm.py
+++ b/vllm_omni/diffusion/models/bagel/mot/ops/mot_gemm.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # ruff: noqa: N803, E741
 import functools
 import json
diff --git a/vllm_omni/diffusion/layers/mot/ops/mot_rms_norm.py b/vllm_omni/diffusion/models/bagel/mot/ops/mot_rms_norm.py
similarity index 98%
rename from vllm_omni/diffusion/layers/mot/ops/mot_rms_norm.py
rename to vllm_omni/diffusion/models/bagel/mot/ops/mot_rms_norm.py
index bbf979164..91e139f0a 100644
--- a/vllm_omni/diffusion/layers/mot/ops/mot_rms_norm.py
+++ b/vllm_omni/diffusion/models/bagel/mot/ops/mot_rms_norm.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # ruff: noqa: N803, E741
 import torch
 from vllm.triton_utils import tl, triton
diff --git a/vllm_omni/diffusion/models/bagel/pipeline_bagel.py b/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
index d805fd3b8..25f31679c 100644
--- a/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
+++ b/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
@@ -35,6 +35,7 @@ from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.errors import OmniClientError
 from vllm_omni.model_executor.model_loader.weight_utils import download_weights_from_hf_specific
 
 from .autoencoder import AutoEncoder, AutoEncoderParams, DistributedAutoEncoder
@@ -184,6 +185,45 @@ def _bagel_effective_image_size(
     return min(resized_height, max_image_size), min(resized_width, max_image_size)
 
 
+def _bagel_canvas_requested(sampling: OmniDiffusionSamplingParams) -> bool:
+    return (sampling.height is not None and not sampling.height_not_provided) or (
+        sampling.width is not None and not sampling.width_not_provided
+    )
+
+
+def _bagel_align_requested_canvas(
+    sampling: OmniDiffusionSamplingParams,
+    *,
+    latent_downsample: int,
+    max_latent_size: int,
+) -> None:
+    """Floor an explicitly requested canvas to the latent stride; reject sides over the checkpoint limit."""
+
+    max_image_size = int(max_latent_size * latent_downsample)
+    resized: list[str] = []
+    for name in ("width", "height"):
+        value = getattr(sampling, name)
+        if value is None or getattr(sampling, f"{name}_not_provided"):
+            continue
+        value = int(value)
+        if value > max_image_size:
+            raise OmniClientError(
+                f"Requested {name}={value} exceeds the BAGEL checkpoint limit of {max_image_size} "
+                f"(max_latent_size={max_latent_size}, latent_downsample={latent_downsample})."
+            )
+        aligned = max(latent_downsample, (value // latent_downsample) * latent_downsample)
+        if aligned != value:
+            setattr(sampling, name, aligned)
+            resized.append(f"{name} {value}->{aligned}")
+    if resized:
+        logger.warning(
+            "BAGEL: requested canvas is not a multiple of the latent stride %d and cannot be "
+            "generated as-is; resizing %s.",
+            latent_downsample,
+            ", ".join(resized),
+        )
+
+
 def get_bagel_pre_process_func(od_config: OmniDiffusionConfig):
     """Resolve BAGEL execution mode and step-batch compatibility."""
 
@@ -194,12 +234,23 @@ def get_bagel_pre_process_func(od_config: OmniDiffusionConfig):
         nonlocal image_geometry
 
         sampling = request.sampling_params
+        modalities = (request.prompt.get("modalities") or []) if isinstance(request.prompt, dict) else []
         kv_metadata = getattr(sampling, "kv_metadata", None) or {}
         image_shape = kv_metadata.get("image_shape")
-        if image_shape is not None:
+        if _bagel_canvas_requested(sampling) and "text" not in modalities:
+            if image_geometry is None:
+                image_geometry = _resolve_bagel_image_geometry(od_config)
+            latent_downsample, max_latent_size = image_geometry
+            _bagel_align_requested_canvas(
+                sampling,
+                latent_downsample=latent_downsample,
+                max_latent_size=max_latent_size,
+            )
+        elif image_shape is not None:
             sampling.height, sampling.width = (int(value) for value in image_shape)
+            sampling.height_not_provided = False
+            sampling.width_not_provided = False
         elif isinstance(request.prompt, dict):
-            modalities = request.prompt.get("modalities") or []
             multi_modal_data = request.prompt.get("multi_modal_data") or {}
             image_input = multi_modal_data.get("img2img")
             if image_input is None and "text" not in modalities:
@@ -220,6 +271,8 @@ def get_bagel_pre_process_func(od_config: OmniDiffusionConfig):
                     latent_downsample=latent_downsample,
                     max_latent_size=max_latent_size,
                 )
+                sampling.height_not_provided = True
+                sampling.width_not_provided = True
 
         extra_args = request.sampling_params.extra_args or {}
         cfg_interval = tuple(extra_args.get("cfg_interval", (0.4, 1.0)))
@@ -528,6 +581,7 @@ class BagelPipeline(nn.Module, SupportsComponentDiscovery, DiffusionPipelineProf
                 f"latent_downsample={self.bagel.latent_downsample})."
             )
         image_shape = (height, width)
+        image_shape_requested = _bagel_canvas_requested(sampling)
 
         extra_args = getattr(sampling, "extra_args", {}) or {}
         cfg_text_scale = extra_args.get("cfg_text_scale", 4.0)
@@ -568,7 +622,15 @@ class BagelPipeline(nn.Module, SupportsComponentDiscovery, DiffusionPipelineProf
                 gen_context["ropes"] = [seq_len]
 
             if sampling.kv_metadata and "image_shape" in sampling.kv_metadata:
-                image_shape = tuple(sampling.kv_metadata["image_shape"])
+                if not image_shape_requested:
+                    image_shape = tuple(sampling.kv_metadata["image_shape"])
+                elif tuple(sampling.kv_metadata["image_shape"]) != image_shape:
+                    logger.info(
+                        "Generating at requested %dx%d instead of KV image shape %s",
+                        image_shape[1],
+                        image_shape[0],
+                        sampling.kv_metadata["image_shape"],
+                    )
 
             branch_kvs = getattr(sampling, "cfg_branch_past_key_values", None) or {}
             branch_metadata = getattr(sampling, "cfg_branch_kv_metadata", None) or {}
@@ -673,8 +735,15 @@ class BagelPipeline(nn.Module, SupportsComponentDiscovery, DiffusionPipelineProf
                     image_input = [_resize_to_stride(img) for img in image_input]
 
                     resized_w, resized_h = image_input[0].size
-                    image_shape = (resized_h, resized_w)
-                    logger.info(f"img2img: resized image to {resized_w}x{resized_h}")
+                    if not image_shape_requested:
+                        image_shape = (resized_h, resized_w)
+                    logger.info(
+                        "img2img: resized source to %dx%d, generating at %dx%d",
+                        resized_w,
+                        resized_h,
+                        image_shape[1],
+                        image_shape[0],
+                    )
 
                     def vae_transforms(img):
                         if img.mode != "RGB":
diff --git a/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py b/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py
index c82e6ad7b..b4cd930b2 100644
--- a/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py
+++ b/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py
@@ -34,9 +34,13 @@ from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
 from diffusers.utils.torch_utils import randn_tensor
 from torch import nn
 from torch.nn.attention import SDPBackend, sdpa_kernel
-from transformers import Qwen3VLForConditionalGeneration, Qwen3VLProcessor
+from transformers import AutoModel, Qwen3VLConfig, Qwen3VLForConditionalGeneration, Qwen3VLModel, Qwen3VLProcessor
+from vllm.config.quantization import QuantizationConfigArgs
 from vllm.logger import init_logger
-from vllm.model_executor.models.utils import AutoWeightsLoader
+from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
+from vllm.model_executor.layers.quantization.fp8 import Fp8Config
+from vllm.model_executor.layers.quantization.online.base import OnlineQuantizationConfig
+from vllm.model_executor.models.utils import AutoWeightsLoader, WeightsMapper
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
@@ -54,6 +58,7 @@ from vllm_omni.diffusion.models.boogu_image.scheduling_flow_match_euler_discrete
 )
 from vllm_omni.diffusion.models.interface import SupportImageInput, SupportsComponentDiscovery
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
+from vllm_omni.diffusion.models.utils import create_transformers_model_with_vllm_linears
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
 from vllm_omni.model_executor.model_loader.weight_utils import download_weights_from_hf_specific
@@ -243,6 +248,7 @@ class BooguImagePipeline(CFGParallelMixin, nn.Module, ProgressBarMixin, Supports
         self.od_config = od_config
         self._raise_unsupported_features()
         transformer_quant_config = resolve_component_quant_config(od_config.quantization_config, "transformer")
+        mllm_quant_config = resolve_component_quant_config(od_config.quantization_config, "mllm")
         self.weights_sources = [
             DiffusersPipelineLoader.ComponentSource(
                 model_or_path=od_config.model,
@@ -273,22 +279,7 @@ class BooguImagePipeline(CFGParallelMixin, nn.Module, ProgressBarMixin, Supports
             local_files_only=local_files_only,
             revision=od_config.revision,
         )
-
-        mllm = from_pretrained_with_prefetch(
-            Qwen3VLForConditionalGeneration.from_pretrained,
-            model,
-            subfolder="mllm",
-            prefetch_list=boogu_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=od_config.dtype,
-            revision=od_config.revision,
-        )
-        # Upstream reuses the full VLM as an optional instruction rewriter and
-        # encodes with its inner model (no ``lm_head``); the rewriter is not
-        # ported, so keep only the inner ``Qwen3VLModel`` as the encoder.
-        if hasattr(mllm, "lm_head"):
-            mllm = mllm.model
-        self.mllm = mllm.to(self._execution_device)
+        self.mllm = self._load_mllm(model, local_files_only, mllm_quant_config, boogu_subfolders)
 
         self.processor = Qwen3VLProcessor.from_pretrained(
             model,
@@ -323,6 +314,68 @@ class BooguImagePipeline(CFGParallelMixin, nn.Module, ProgressBarMixin, Supports
         self.SYSTEM_PROMPT_4_TI2I = SYSTEM_PROMPT_4_TI2I_UNIFIED
         self.SYSTEM_PROMPT_4_I2I = SYSTEM_PROMPT_4_TI2I_UNIFIED
 
+    def _load_mllm(
+        self,
+        model_path: str,
+        local_files_only: bool,
+        quant_config: QuantizationConfig | None,
+        prefetch_list: list[str],
+    ) -> Qwen3VLModel:
+        """Load MLLM through HF, or prepare it for deferred online FP8 loading."""
+        config = None
+        if quant_config is not None:
+            if not isinstance(quant_config, Fp8Config):
+                raise ValueError(
+                    "Boogu MLLM only supports FP8 quantization. Set mllm to null to disable online quantization."
+                )
+            config = Qwen3VLConfig.from_pretrained(
+                model_path, subfolder="mllm", local_files_only=local_files_only, revision=self.od_config.revision
+            )
+
+        # With no MLLM quantization override, or with checkpoint quantization
+        # metadata, preserve HF model initialization and weight loading.
+        if config is None or getattr(config, "quantization_config", None):
+            mllm = from_pretrained_with_prefetch(
+                Qwen3VLForConditionalGeneration.from_pretrained,
+                model_path,
+                subfolder="mllm",
+                prefetch_list=prefetch_list,
+                local_files_only=local_files_only,
+                torch_dtype=self.od_config.dtype,
+                revision=self.od_config.revision,
+            )
+            # Upstream reuses the full VLM as an optional instruction rewriter and
+            # encodes with its inner model (no ``lm_head``); the rewriter is not
+            # ported, so keep only the inner ``Qwen3VLModel`` as the encoder.
+            if hasattr(mllm, "lm_head"):
+                mllm = mllm.model
+            return mllm.to(self._execution_device)
+
+        online_quant_config = OnlineQuantizationConfig(
+            QuantizationConfigArgs(linear="fp8_per_block", ignore=quant_config.ignored_layers)
+        )
+
+        mllm = create_transformers_model_with_vllm_linears(
+            AutoModel,
+            config,
+            online_quant_config,
+            dtype=self.od_config.dtype,
+            device=self._execution_device,
+            prefix="mllm",
+            skip_modules=("mllm.visual",),
+        )
+
+        self.weights_sources.append(
+            DiffusersPipelineLoader.ComponentSource(
+                model_or_path=model_path,
+                subfolder="mllm",
+                revision=self.od_config.revision,
+                prefix="mllm.",
+            )
+        )
+
+        return mllm.requires_grad_(False).eval()
+
     def _raise_unsupported_features(self) -> None:
         """Reject execution modes that do not have Boogu-specific support."""
         parallel_config = self.od_config.parallel_config
@@ -339,7 +392,8 @@ class BooguImagePipeline(CFGParallelMixin, nn.Module, ProgressBarMixin, Supports
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
         loader = AutoWeightsLoader(self)
-        return loader.load_weights(weights)
+        mapper = WeightsMapper(orig_to_new_prefix={"mllm.lm_head.": None, "mllm.model.": "mllm."})
+        return loader.load_weights(weights, mapper=mapper)
 
     # ------------------------------------------------------------------
     # Prompt encoding (upstream ``encode_instruction``, t2i path)
diff --git a/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py b/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
index 939544a9f..3ebda6b6e 100644
--- a/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
+++ b/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
@@ -720,7 +720,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
 
     def warmup_compile(self) -> None:
         """Warm up compiled text/image/VAE paths before timed inference."""
-        if not torch.cuda.is_available():
+        if not torch.accelerator.is_available():
             return
 
         state = self.state
@@ -801,12 +801,12 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         latents: tuple[torch.Tensor, torch.Tensor],
         do_true_cfg: bool,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        """Post-step sync: .contiguous() + cuda.synchronize()"""
+        """Post-step sync: .contiguous() + accelerator stream synchronize"""
         latents = tuple(t.contiguous() for t in latents)
         if do_true_cfg and get_classifier_free_guidance_world_size() > 1:
-            device = next((t.device for t in latents if t.is_cuda), None)
+            device = next((t.device for t in latents if t.device.type != "cpu"), None)
             if device is not None:
-                torch.cuda.current_stream(device).synchronize()
+                torch.accelerator.current_stream(device).synchronize()
         return latents
 
     # -----------------------------------------------------------------------
diff --git a/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py b/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
index bd96630e8..eb26e5389 100644
--- a/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
+++ b/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
@@ -28,6 +28,9 @@ from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
     SequenceParallelOutput,
 )
+from vllm_omni.diffusion.models.ernie_image.fused_rope import (
+    try_fused_qk_rotary_emb,
+)
 
 logger = init_logger(__name__)
 
@@ -101,6 +104,26 @@ def _apply_rotary_emb(
     return torch.cat((x_rot * cos_ + x_rotated * sin_, x[..., rot_dim:]), dim=-1)
 
 
+def _apply_qk_rotary_emb(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    freqs_cos: torch.Tensor,
+    freqs_sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    fused = try_fused_qk_rotary_emb(
+        query,
+        key,
+        freqs_cos,
+        freqs_sin,
+    )
+    if fused is not None:
+        return fused
+    return (
+        _apply_rotary_emb(query, freqs_cos, freqs_sin),
+        _apply_rotary_emb(key, freqs_cos, freqs_sin),
+    )
+
+
 class ErnieImageEmbedND3(nn.Module):
     def __init__(self, dim: int, theta: int, axes_dim: tuple[int, int, int]):
         super().__init__()
@@ -340,8 +363,7 @@ class ErnieImageAttention(nn.Module):
 
         if image_rotary_emb is not None:
             freqs_cos, freqs_sin = image_rotary_emb
-            query = _apply_rotary_emb(query, freqs_cos, freqs_sin)
-            key = _apply_rotary_emb(key, freqs_cos, freqs_sin)
+            query, key = _apply_qk_rotary_emb(query, key, freqs_cos, freqs_sin)
 
         attn_metadata = None
         if attention_mask is not None:
diff --git a/vllm_omni/diffusion/models/ernie_image/fused_rope.py b/vllm_omni/diffusion/models/ernie_image/fused_rope.py
new file mode 100644
index 000000000..5bdb61165
--- /dev/null
+++ b/vllm_omni/diffusion/models/ernie_image/fused_rope.py
@@ -0,0 +1,211 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Lossless eager Q/K RoPE fusion for ERNIE-Image."""
+
+from __future__ import annotations
+
+import logging
+from collections import OrderedDict
+
+import torch
+from vllm.triton_utils import HAS_TRITON, tl, triton
+
+from vllm_omni.platforms import current_omni_platform
+
+logger = logging.getLogger(__name__)
+
+_FAILED_KEYS_MAX_SIZE = 128
+_FAILED_KEYS: OrderedDict[tuple[object, ...], None] = OrderedDict()
+
+
+if HAS_TRITON:
+
+    @triton.jit
+    def _round_bf16_to_fp32(value):
+        """RNE-round FP32 to BF16 precision in an FP32 register."""
+
+        bits = value.to(tl.int32, bitcast=True)
+        rounding_bias = 0x7FFF + ((bits >> 16) & 1)
+        rounded_bits = (bits + rounding_bias) & -65536
+        return rounded_bits.to(tl.float32, bitcast=True)
+
+    @triton.jit
+    def _qk_rope_kernel(
+        out_q_ptr,
+        out_k_ptr,
+        q_ptr,
+        k_ptr,
+        cos_ptr,
+        sin_ptr,
+        heads,
+        head_dim: tl.constexpr,
+        rotary_dim: tl.constexpr,
+        rotary_half: tl.constexpr,
+        heads_block: tl.constexpr,
+        half_block: tl.constexpr,
+        tail_block: tl.constexpr,
+    ):
+        row = tl.program_id(0).to(tl.int64)
+        is_key = tl.program_id(1)
+        base = row * heads * head_dim
+        head_offsets = tl.arange(0, heads_block)[:, None]
+        head_mask = head_offsets < heads
+        columns = tl.arange(0, half_block)[None, :]
+        column_mask = columns < rotary_half
+        mask = head_mask & column_mask
+
+        if is_key == 0:
+            input_ptr = q_ptr
+            output_ptr = out_q_ptr
+        else:
+            input_ptr = k_ptr
+            output_ptr = out_k_ptr
+
+        first_offsets = base + head_offsets * head_dim + columns
+        second_offsets = first_offsets + rotary_half
+        first = tl.load(input_ptr + first_offsets, mask=mask, other=0.0).to(tl.float32)
+        second = tl.load(input_ptr + second_offsets, mask=mask, other=0.0).to(tl.float32)
+
+        # The eager path casts FP32 frequencies to BF16, duplicates adjacent
+        # values, rounds both BF16 multiplies, and finally rounds the add.
+        first_freq = columns // 2
+        second_freq = (rotary_half + columns) // 2
+        cos_first = _round_bf16_to_fp32(tl.load(cos_ptr + row * rotary_half + first_freq, mask=column_mask))
+        cos_second = _round_bf16_to_fp32(tl.load(cos_ptr + row * rotary_half + second_freq, mask=column_mask))
+        sin_first = _round_bf16_to_fp32(tl.load(sin_ptr + row * rotary_half + first_freq, mask=column_mask))
+        sin_second = _round_bf16_to_fp32(tl.load(sin_ptr + row * rotary_half + second_freq, mask=column_mask))
+
+        out_first = _round_bf16_to_fp32(first * cos_first) + _round_bf16_to_fp32(-second * sin_first)
+        out_second = _round_bf16_to_fp32(second * cos_second) + _round_bf16_to_fp32(first * sin_second)
+        tl.store(output_ptr + first_offsets, out_first, mask=mask)
+        tl.store(output_ptr + second_offsets, out_second, mask=mask)
+
+        if head_dim > rotary_dim:
+            tail_columns = rotary_dim + tl.arange(0, tail_block)[None, :]
+            tail_mask = head_mask & (tail_columns < head_dim)
+            tail_offsets = base + head_offsets * head_dim + tail_columns
+            tail = tl.load(input_ptr + tail_offsets, mask=tail_mask, other=0.0)
+            tl.store(output_ptr + tail_offsets, tail, mask=tail_mask)
+
+
+def _runtime_key(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    freqs_cos: torch.Tensor,
+) -> tuple[object, ...]:
+    return (
+        query.device.index,
+        tuple(query.shape),
+        tuple(key.shape),
+        tuple(freqs_cos.shape),
+        query.dtype,
+        freqs_cos.dtype,
+    )
+
+
+def _is_failed_runtime_key(runtime_key: tuple[object, ...]) -> bool:
+    if runtime_key not in _FAILED_KEYS:
+        return False
+    _FAILED_KEYS.move_to_end(runtime_key)
+    return True
+
+
+def _record_failed_runtime_key(runtime_key: tuple[object, ...]) -> None:
+    _FAILED_KEYS[runtime_key] = None
+    _FAILED_KEYS.move_to_end(runtime_key)
+    while len(_FAILED_KEYS) > _FAILED_KEYS_MAX_SIZE:
+        _FAILED_KEYS.popitem(last=False)
+
+
+def _supported_inputs(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    freqs_cos: torch.Tensor,
+    freqs_sin: torch.Tensor,
+) -> bool:
+    if torch.compiler.is_compiling():
+        return False
+    if any(tensor.requires_grad for tensor in (query, key, freqs_cos, freqs_sin)):
+        return False
+    if not HAS_TRITON or not current_omni_platform.is_cuda():
+        return False
+    if query.dtype is not torch.bfloat16 or not query.is_cuda:
+        return False
+    if query.ndim != 4 or key.shape != query.shape or key.dtype is not query.dtype or key.device != query.device:
+        return False
+    if not query.is_contiguous() or not key.is_contiguous():
+        return False
+    if freqs_cos.dtype is not torch.float32 or freqs_sin.dtype is not torch.float32:
+        return False
+    if not freqs_cos.is_cuda or freqs_cos.device != query.device:
+        return False
+    if freqs_sin.device != query.device or freqs_sin.shape != freqs_cos.shape:
+        return False
+    if not freqs_cos.is_contiguous() or not freqs_sin.is_contiguous():
+        return False
+    batch, sequence, _, head_dim = query.shape
+    rotary_half = freqs_cos.shape[-1] if freqs_cos.ndim == 3 else 0
+    return (
+        query.numel() > 0
+        and freqs_cos.shape == (batch, sequence, rotary_half)
+        and rotary_half > 0
+        and rotary_half * 2 <= head_dim
+    )
+
+
+def _launch_fused_qk_rotary_emb(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    freqs_cos: torch.Tensor,
+    freqs_sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    batch, sequence, heads, head_dim = query.shape
+    rotary_half = freqs_cos.shape[-1]
+    rotary_dim = rotary_half * 2
+    tail = head_dim - rotary_dim
+    output_query = torch.empty_like(query)
+    output_key = torch.empty_like(key)
+    with torch.accelerator.device_index(query.device.index):
+        _qk_rope_kernel[(batch * sequence, 2)](
+            output_query,
+            output_key,
+            query,
+            key,
+            freqs_cos,
+            freqs_sin,
+            heads,
+            head_dim=head_dim,
+            rotary_dim=rotary_dim,
+            rotary_half=rotary_half,
+            heads_block=triton.next_power_of_2(heads),
+            half_block=triton.next_power_of_2(rotary_half),
+            tail_block=triton.next_power_of_2(max(tail, 1)),
+        )
+    return output_query, output_key
+
+
+def try_fused_qk_rotary_emb(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    freqs_cos: torch.Tensor,
+    freqs_sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor] | None:
+    """Return fused Q/K outputs, or ``None`` to request the eager fallback."""
+
+    if not _supported_inputs(query, key, freqs_cos, freqs_sin):
+        return None
+
+    runtime_key = _runtime_key(query, key, freqs_cos)
+    if _is_failed_runtime_key(runtime_key):
+        return None
+
+    try:
+        return _launch_fused_qk_rotary_emb(query, key, freqs_cos, freqs_sin)
+    except Exception:
+        _record_failed_runtime_key(runtime_key)
+        logger.exception("ERNIE-Image fused Q/K RoPE failed; using the eager fallback")
+        return None
+
+
+__all__ = ["try_fused_qk_rotary_emb"]
diff --git a/vllm_omni/diffusion/models/helios/pipeline_helios.py b/vllm_omni/diffusion/models/helios/pipeline_helios.py
index 610fb2b8f..ebea371a4 100644
--- a/vllm_omni/diffusion/models/helios/pipeline_helios.py
+++ b/vllm_omni/diffusion/models/helios/pipeline_helios.py
@@ -535,19 +535,23 @@ class HeliosPipeline(
                 "zero_steps": int(extra.get("zero_steps", 1)),
             }
         )
-        self.prepare_next_chunk(state)
         return state
 
     def peek_chunk_media(self, state: StepRequestState) -> ChunkMediaSpec:
         """Expose this chunk's decoded media extent for interaction timelines."""
-        num_frames = int(state.extra["window_num_frames"])
+        num_media_frames = int(state.extra["window_num_frames"])
+        num_latent_frames = int(state.extra["num_latent_frames_per_chunk"])
         fps = state.sampling.fps
         if fps is None or float(fps) <= 0:
             raise ValueError(
                 "sampling.fps is required and must be > 0 for interaction modalities that use the "
                 f"chunk media timeline, got {fps!r} (request_id={state.request_id!r})"
             )
-        return ChunkMediaSpec(num_frames=num_frames, fps=float(fps))
+        return ChunkMediaSpec(
+            num_media_frames=num_media_frames,
+            fps=float(fps),
+            num_latent_frames=num_latent_frames,
+        )
 
     @override
     def prepare_next_chunk(self, state: StepRequestState) -> None:
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py b/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py
index d58a43498..743b8af91 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py
@@ -75,7 +75,11 @@ from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelOutput,
 )
 from vllm_omni.diffusion.distributed.utils import get_local_device
-from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
+from vllm_omni.diffusion.forward_context import (
+    get_paged_kv_computed_tokens,
+    paged_kv_prefill,
+    set_forward_context_denoise_step_idx,
+)
 from vllm_omni.diffusion.layers.fused_moe import FusedMoE
 from vllm_omni.diffusion.layers.norm import RMSNorm
 from vllm_omni.diffusion.layers.rope import RotaryEmbedding
@@ -1097,8 +1101,6 @@ class ImageKVCacheManager(nn.Module):
         layer resolves the actual CUDA or Ascend paged kernel.
         """
 
-        if uncond_cfg_prefill:
-            raise RuntimeError("Hunyuan negative-CFG prefill must run before paged row activation")
         if self._injected_ar_kv is not None:
             raise NotImplementedError("Hunyuan Scheduler-paged KV does not support imported AR KV")
         if not query_lens or len(seq_lens) != len(query_lens):
@@ -1109,7 +1111,6 @@ class ImageKVCacheManager(nn.Module):
         self.clear_legacy_prompt_kv_cache()
         bs = len(query_lens)
         q_len = query_lens[0]
-        seq_len = seq_lens[0]
         assert query.shape[0] == bs * q_len, f"{query.shape[0]} != {bs * q_len}"
 
         head_num_per_rank = query.shape[1]
@@ -1121,22 +1122,19 @@ class ImageKVCacheManager(nn.Module):
         value = value.reshape(bs, q_len, kv_head_num_per_rank, head_dim)
 
         joint_text_query = joint_text_key = joint_text_value = None
-        if self.sp_size > 1 and first_step:
+        if self.sp_size > 1 and uncond_cfg_prefill:
+            joint_text_query, joint_text_key, joint_text_value = query, key, value
+            query, key, value = query[:, :0], key[:, :0], value[:, :0]
+        elif self.sp_size > 1 and first_step:
             if shard_image_size is None or shard_image_size <= 0:
                 raise ValueError("Hunyuan paged Ulysses requires a positive local image shard size")
-            local_prompt_len = seq_len - shard_image_size
             joint_query_len = query.shape[1] - shard_image_size
-            if local_prompt_len != joint_query_len:
-                raise ValueError(
-                    "Hunyuan paged Ulysses prompt layout mismatch: "
-                    f"key_prompt={local_prompt_len}, query_prompt={joint_query_len}"
-                )
             joint_text_query = query[:, :joint_query_len]
-            joint_text_key = key[:, :local_prompt_len]
-            joint_text_value = value[:, :local_prompt_len]
+            joint_text_key = key[:, :joint_query_len]
+            joint_text_value = value[:, :joint_query_len]
             query = query[:, joint_query_len:]
-            key = key[:, local_prompt_len:]
-            value = value[:, local_prompt_len:]
+            key = key[:, joint_query_len:]
+            value = value[:, joint_query_len:]
 
         if joint_text_query is None:
             attn_metadata = AttentionMetadata(full_attn_spans=full_attn_spans)
@@ -1254,6 +1252,8 @@ class ImageKVCacheManager(nn.Module):
     ) -> torch.Tensor:
         self.image_token_len = kwargs.get("num_image_tokens")
         if self.attn.is_paged_kv_active():
+            # A native connector fills the same Scheduler-owned pages as
+            # local prefill. Imported prefixes need no dense reconstruction.
             full_attn_spans = kwargs.get("full_attn_spans")
             if full_attn_spans is None:
                 raise ValueError("Hunyuan Scheduler-paged KV requires full_attn_spans metadata")
@@ -1837,7 +1837,9 @@ class HunYuanAttention(nn.Module):
             num_kv_heads=self.num_kv_heads,
             scaling=self.scaling,
             image_token_len=4097,
-            prefix=f"{prefix}.image_attn",
+            # Native Mooncake pairs this canonical KV layer name with the AR
+            # HunYuanAttention: model.layers.N.self_attn.attn. Keep both in sync.
+            prefix=f"model.{prefix}",
         )
         self.image_rope2d_emb = HunYuanRotary2DEmbedder(
             num_heads=self.num_heads,
@@ -2964,7 +2966,10 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
             seq_lens=[prefill_seq_len],
             num_image_tokens=0,
             ar_kv_reuse_len=negative_reuse_len,
-            full_attn_spans=model_kwargs["full_attn_spans"][batch_slice]
+            full_attn_spans=[
+                [(start, min(end, prefill_seq_len)) for start, end in spans if start < prefill_seq_len]
+                for spans in model_kwargs["full_attn_spans"][batch_slice]
+            ]
             if model_kwargs.get("full_attn_spans")
             else None,
         )
@@ -3019,6 +3024,28 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
         device,
     ):
         ar_kv_data = model_kwargs.pop("ar_kv_data", None)
+        computed_tokens = get_paged_kv_computed_tokens()
+        if computed_tokens and computed_tokens[0] > 0:
+            positive_reuse_len = computed_tokens[0]
+            if (
+                len(computed_tokens) > 1
+                and computed_tokens[1] < positive_reuse_len
+                and (not cfg_parallel_ready or cfg_rank == 1)
+            ):
+                prefill_inputs = self._build_negative_cfg_prefill_inputs(
+                    input_ids,
+                    model_kwargs,
+                    batch_size,
+                    computed_tokens[1],
+                    positive_reuse_len,
+                    cfg_parallel_ready,
+                )
+                with (
+                    paged_kv_prefill(1, positive_reuse_len),
+                    torch.autocast(device_type=device.type, dtype=torch.bfloat16),
+                ):
+                    self.model.forward_call(**prefill_inputs)
+            return self._truncate_reused_prefix(input_ids, model_kwargs, positive_reuse_len), positive_reuse_len
         if ar_kv_data is None:
             logger.debug(
                 "[AR KV Reuse] cfg_rank=%s: no AR KV received, fallback to full recompute (reuse_len=0)",
@@ -3040,7 +3067,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
 
         # 3. negative cfg prefill
         # For CFG distilled models, skip negative CFG prefill (cfg_factor=1, no negative prompt)
-        if self.do_classifier_free_guidance and not self.model.config.cfg_distilled:
+        if self.do_classifier_free_guidance and not getattr(self.model.config, "cfg_distilled", False):
             self._maybe_run_negative_cfg_prefill(
                 input_ids=input_ids,
                 model_kwargs=model_kwargs,
@@ -3151,7 +3178,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
         # For CFG distilled models, skip CFG parallel (cfg_factor=1, no negative branch)
         cfg_parallel_ready = (
             self.do_classifier_free_guidance
-            and not self.model.config.cfg_distilled
+            and not getattr(self.model.config, "cfg_distilled", False)
             and get_classifier_free_guidance_world_size() == 2
         )
 
@@ -3207,7 +3234,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
             self._split_model_kwargs_for_cfg_parallel(model_kwargs, batch_size, cfg_rank)
         else:
             # For CFG distilled models, cfg_factor is always 1 (CFG embedded in model)
-            if self.model.config.cfg_distilled:
+            if getattr(self.model.config, "cfg_distilled", False):
                 cfg_factor = 1
             else:
                 cfg_factor = 1 + self.do_classifier_free_guidance
@@ -3252,7 +3279,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
                     # Sequential CFG: double the batch
                     latent_model_input = torch.cat([latents] * cfg_factor)
 
-                if self.model.config.use_meanflow:
+                if getattr(self.model.config, "use_meanflow", False):
                     r = self.scheduler.get_timestep_r(t)
                     r_expand = r.repeat(latent_model_input.shape[0])
                 else:
@@ -3281,7 +3308,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
 
                 if should_compute:
                     # Handle guidance for CFG distilled models
-                    if self.model.config.cfg_distilled:
+                    if getattr(self.model.config, "cfg_distilled", False):
                         model_kwargs["guidance"] = torch.tensor(
                             [1000.0 * self._guidance_scale],
                             device=self.device,
@@ -3308,7 +3335,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
                 # Perform guidance
                 # For CFG distilled models, guidance is already embedded in the model,
                 # so we skip the explicit CFG computation
-                if self.model.config.cfg_distilled:
+                if getattr(self.model.config, "cfg_distilled", False):
                     # CFG distilled: guidance is handled internally via guidance_emb
                     pass
                 elif cfg_parallel_ready:
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py b/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py
index fcfd48b4f..4856fac75 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py
@@ -338,6 +338,9 @@ class HunyuanImage3Pipeline(
     supports_step_execution: ClassVar[bool] = True
     supports_request_batch = False
     support_image_input = True
+    # The warmup request's blank image routes this AR+diffusion model down its
+    # image-edit path, where the token block cannot match the latent patch grid.
+    dummy_run_num_frames: ClassVar[int] = 0
     _dit_modules: ClassVar[list[str]] = ["model"]
     _encoder_modules: ClassVar[list[str]] = ["vision_model"]
     _vae_modules: ClassVar[list[str]] = ["vae"]
@@ -364,6 +367,8 @@ class HunyuanImage3Pipeline(
 
     def __init__(self, od_config: OmniDiffusionConfig) -> None:
         self.hf_config = get_config(od_config.model, trust_remote_code=True)
+        self.hf_config.cfg_distilled = _config_flag(self.hf_config, "cfg_distilled")
+        self.hf_config.use_meanflow = _config_flag(self.hf_config, "use_meanflow")
         super().__init__(self.hf_config)
         # update diffusion config
         self.generation_config = GenerationConfig.from_pretrained(od_config.model)
@@ -1279,7 +1284,9 @@ class HunyuanImage3Pipeline(
 
         # 4. Encode conditional images
         # Skip encoding if AR KV reuse is enabled
-        has_ar_kv = kwargs.get("ar_kv_data")
+        has_ar_kv = kwargs.get("ar_kv_data") or request_layout_utils.native_kv_covers_cond_images(
+            output, kwargs.get("kv_computed_tokens", ())
+        )
         if batch_cond_image_info is not None and len(batch_cond_image_info[0]) > 0 and not has_ar_kv:
             cond_vae_images, cond_timestep, cond_vit_images = self._encode_cond_image(
                 batch_cond_image_info, cfg_factor[mode], generator=generator
@@ -1891,6 +1898,7 @@ class HunyuanImage3Pipeline(
         pipe._guidance_scale = guidance_scale
         pipe._guidance_rescale = getattr(sampling, "guidance_rescale", 0.0)
 
+        ar_kv_kwargs = self._extract_ar_kv_from_sampling(sampling)
         model_kwargs = self.prepare_model_inputs(
             prompt=prompt,
             cot_text=cot_text,
@@ -1903,8 +1911,10 @@ class HunyuanImage3Pipeline(
             batch_cond_image_info=batch_cond_image_info,
             bot_task=tokenizer_bot_task,
             prepared_layout=request_layout_utils.get_hunyuan_prepared_layout(state),
+            kv_computed_tokens=state.extra.get("kv_computed_tokens", ()),
+            **ar_kv_kwargs,
         )
-        model_kwargs.update(self._extract_ar_kv_from_sampling(sampling))
+        model_kwargs.update(ar_kv_kwargs)
         model_kwargs["use_cache"] = False
 
         input_ids = model_kwargs.pop("input_ids")
@@ -2334,6 +2344,7 @@ class HunyuanImage3Pipeline(
             batch_cond_image_info=batch_cond_image_info,
             bot_task=tokenizer_bot_task,
             prepared_layout=request_layout_utils.get_hunyuan_prepared_layout(req.requests[0]),
+            kv_computed_tokens=getattr(req.requests[0], "kv_computed_tokens", ()),
             **ar_kv_kwargs,
         )
 
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/request_layout.py b/vllm_omni/diffusion/models/hunyuan_image3/request_layout.py
index 32353ed62..6eb873219 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/request_layout.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/request_layout.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from __future__ import annotations
 
@@ -373,7 +373,32 @@ def build_hunyuan_diffusion_kv_requests(
     real_pos = tokenizer_output.real_pos
     assert prefix_positions is not None and real_pos is not None
 
+    def boundary_rows(field_name: str) -> list[int | None]:
+        positions = getattr(tokenizer_output, field_name)
+        if positions is None:
+            return [None] * cfg_factor
+        if not isinstance(positions, list) or not positions:
+            raise ValueError(f"Hunyuan {field_name} must be a non-empty boundary list")
+        # Batched tokenizer output contains a separate boundary for each CFG
+        # row. Never broadcast a conditional boundary into a negative row.
+        if cfg_factor == 1 and len(positions) == 1 and (positions[0] is None or type(positions[0]) is int):
+            return positions
+        if len(positions) == cfg_factor and all(
+            isinstance(row, list) and len(row) == 1 and (row[0] is None or type(row[0]) is int) for row in positions
+        ):
+            return [row[0] for row in positions]
+        raise ValueError(f"Hunyuan {field_name} must contain one boundary per CFG row")
+
+    think_boundaries = boundary_rows("think_recaption_end_pos")
+    uncond_boundaries = boundary_rows("uncond_cfg_start_pos")
+
     target_len = hunyuan_num_image_tokens(prepared_layout.generated_image_info)
+    reusable_lens = [0] * cfg_factor
+    if think_boundaries[0] is not None:
+        reusable_lens[0] = think_boundaries[0] or 0
+    if any(boundary is not None for boundary in uncond_boundaries):
+        for sequence_id in range(1, cfg_factor):
+            reusable_lens[sequence_id] = min(reusable_lens[0], uncond_boundaries[sequence_id] or 0)
     return tuple(
         DiffusionKVRequest(
             f"{request.request_id}/diffusion-kv/{sequence_id}",
@@ -383,6 +408,7 @@ def build_hunyuan_diffusion_kv_requests(
             prefix_len=int(prefix_row[-1].item()),
             target_len=target_len,
             seq_len=int(valid_row[-1].item()),
+            prompt_token_ids=tokenizer_output.tokens[sequence_id, : reusable_lens[sequence_id]].tolist(),
             # Prompt and reference-image tokens are already embedded in this
             # row's primary self-attention sequence. Hunyuan therefore has no
             # independently projected cross/joint-attention KV context.
@@ -401,3 +427,14 @@ def get_hunyuan_prepared_layout(source: Any) -> HunyuanPreparedLayout | None:
             f"HunyuanImage3 expected prepared_layout to be HunyuanPreparedLayout, got {type(prepared_layout).__name__}"
         )
     return prepared_layout
+
+
+def native_kv_covers_cond_images(output: TokenizerEncodeOutput, computed_tokens: tuple[int, ...]) -> bool:
+    """Skip image encoding only when every CFG row already contains its image KV."""
+    image_slices = output.joint_image_slices
+    if not image_slices or len(image_slices) != len(computed_tokens):
+        return False
+    return all(
+        slices and all(image_slice.stop <= computed for image_slice in slices)
+        for slices, computed in zip(image_slices, computed_tokens, strict=True)
+    )
diff --git a/vllm_omni/diffusion/models/interface.py b/vllm_omni/diffusion/models/interface.py
index 92216d19e..c33d021f3 100644
--- a/vllm_omni/diffusion/models/interface.py
+++ b/vllm_omni/diffusion/models/interface.py
@@ -92,6 +92,13 @@ class SupportsStepExecution(Protocol):
     ``prepare_encode()`` (one-time request setup), ``denoise_step()``
     (one denoise forward), ``step_scheduler()`` (one scheduler update),
     and ``post_decode()`` (final decode).
+
+    A pipeline may additionally set the optional class attribute
+    ``supports_chunk_step_grouping = True`` to declare that its request state
+    may advance through every denoise step of its current chunk without a
+    serving-scheduler cycle in between (a capability, not a policy: the runner
+    that owns the scheduling decision chooses whether to group steps). It is
+    optional so it does not become part of the runtime protocol check.
     """
 
     supports_step_execution: ClassVar[bool] = True
@@ -151,10 +158,10 @@ class SupportsInteractionApply(Protocol):
     """Optional protocol for pipelines with unified mid-generation, chunk-boundary hooks."""
 
     def peek_chunk_media(self, state: StepRequestState) -> ChunkMediaSpec:
-        """Return the media timeline represented by the upcoming/current chunk.
+        """Return the media timeline and latent frame count for the upcoming/current chunk.
 
         Useful when interaction handler needs interpolation/integration on a frame-by-frame basis,
-        or for backpressure/pacing.
+        and/or for backpressure/pacing.
         """
         ...
 
diff --git a/vllm_omni/diffusion/models/lingbot_world/actions.py b/vllm_omni/diffusion/models/lingbot_world/actions.py
index 4720b041e..057341c84 100644
--- a/vllm_omni/diffusion/models/lingbot_world/actions.py
+++ b/vllm_omni/diffusion/models/lingbot_world/actions.py
@@ -25,6 +25,7 @@ from vllm_omni.experimental.ar_diffusion.tick_protocol import (
 
 LINGBOT_CAMERA_ACTION_SCHEMA = "lingbot.camera_actions.v1"
 LINGBOT_CAMERA_TRAJECTORY_SCHEMA = "lingbot.camera_trajectory.v1"
+LINGBOT_CONTROLLER_TRANSLATION_UNIT = 0.05
 _ACTION_ORDER = ("w", "a", "s", "d", "i", "j", "k", "l")
 _VALID_ACTIONS = frozenset(_ACTION_ORDER)
 _REFERENCE_HEIGHT = 480
@@ -282,7 +283,7 @@ def integrate_lingbot_camera_actions(
     """Convert latent-frame WASD/IJKL controls to cumulative C2W poses.
 
     Calibration and motion constants intentionally match SGLang's LingBot
-    adapter: movement 0.05, pitch 4 degrees, yaw 6 degrees, pitch clamp 85
+    adapter: movement 0.05 (LINGBOT_CONTROLLER_TRANSLATION_UNIT), pitch 4 degrees, yaw 6 degrees, pitch clamp 85
     degrees, and target-resolution focal lengths of 500 pixels.
     """
 
@@ -325,13 +326,31 @@ def integrate_lingbot_camera_actions(
             right /= right_norm + 1e-6
 
         movement = np.zeros(3, dtype=np.float64)
-        movement += forward * 0.05 * (("w" in actions) - ("s" in actions))
-        movement += right * 0.05 * (("d" in actions) - ("a" in actions))
+        movement += forward * LINGBOT_CONTROLLER_TRANSLATION_UNIT * (("w" in actions) - ("s" in actions))
+        movement += right * LINGBOT_CONTROLLER_TRANSLATION_UNIT * (("d" in actions) - ("a" in actions))
+        # Keep the cumulative controller pose in FP64 between chunks, matching
+        # SGLang's NumPy integration and avoiding long-session drift.
         current_pose = np.eye(4, dtype=np.float64)
         current_pose[:3, :3] = new_rotation
         current_pose[:3, 3] = translation + movement
         poses.append(current_pose)
 
+    trajectory = camera_trajectory_from_absolute_pose(torch.from_numpy(np.stack(poses)), width=width, height=height)
+    return trajectory, current_pitch
+
+
+def camera_trajectory_from_absolute_pose(
+    poses: torch.Tensor,
+    *,
+    width: int,
+    height: int,
+) -> CameraTrajectory:
+    if width <= 0 or height <= 0:
+        raise ValueError("camera action resolution must be positive.")
+    if poses.ndim != 3 or poses.shape[-2:] != (4, 4):
+        raise ValueError(f"absolute camera poses must have shape [frames, 4, 4], got {tuple(poses.shape)}.")
+    if poses.shape[0] == 0:
+        raise ValueError("absolute camera poses must not be empty.")
     # build_plucker_embedding expects intrinsics in the 832x480 reference
     # coordinate system. These values become SGLang's [500, 500, W/2, H/2]
     # after that function scales them to the requested resolution.
@@ -342,9 +361,7 @@ def integrate_lingbot_camera_actions(
         _REFERENCE_HEIGHT / 2,
     )
     trajectory = CameraTrajectory(
-        # Keep the cumulative controller pose in FP64 between chunks, matching
-        # SGLang's NumPy integration and avoiding long-session drift.
-        poses=torch.from_numpy(np.stack(poses)),
+        poses=poses,
         intrinsics=torch.tensor(reference_intrinsics, dtype=torch.float32).repeat(len(poses), 1),
     )
-    return trajectory, current_pitch
+    return trajectory
diff --git a/vllm_omni/diffusion/models/lingbot_world/camera.py b/vllm_omni/diffusion/models/lingbot_world/camera.py
index 504d850c7..45e3add44 100644
--- a/vllm_omni/diffusion/models/lingbot_world/camera.py
+++ b/vllm_omni/diffusion/models/lingbot_world/camera.py
@@ -389,7 +389,11 @@ def _invert_camera_poses(poses: torch.Tensor) -> torch.Tensor:
     return inverse
 
 
-def _prepare_framewise_poses(raw_poses: torch.Tensor) -> torch.Tensor:
+def _prepare_framewise_poses(
+    raw_poses: torch.Tensor,
+    *,
+    translation_scale: float | None = None,
+) -> torch.Tensor:
     """Convert raw C2W poses to normalized first-relative framewise deltas."""
 
     # Remove global placement, then convert the sequence to framewise deltas.
@@ -402,12 +406,19 @@ def _prepare_framewise_poses(raw_poses: torch.Tensor) -> torch.Tensor:
             relative_poses[1:],
         )
 
-    # Only relative direction/magnitude matters to the checkpoint; normalizing
-    # by the largest step removes the trajectory's arbitrary translation scale.
+    # Normalizing the control's scale. Different between scripted and realtime input.
     translations = relative_poses[:, :3, 3]
-    max_translation_norm = torch.linalg.vector_norm(translations, dim=-1).max()
-    if max_translation_norm > 0:
-        relative_poses[:, :3, 3] = translations / max_translation_norm
+    if translation_scale is None:
+        # Scripted action_path input: divide by the largest step so an arbitrary recording scale becomes 1.
+        scale = torch.linalg.vector_norm(translations, dim=-1).max()
+    else:
+        # Realtime interaction input: use the controller translation unit (one WASD step = full speed).
+        # It cannot see future motion or normalize globally.
+        if translation_scale <= 0:
+            raise ValueError(f"translation_scale must be > 0, got {translation_scale}")
+        scale = translation_scale
+    if float(scale) > 0:
+        relative_poses[:, :3, 3] = translations / scale
     return relative_poses
 
 
@@ -420,6 +431,7 @@ def build_plucker_embedding(
     target_width: int,
     device: torch.device,
     dtype: torch.dtype,
+    translation_scale: float | None = None,
 ) -> torch.Tensor:
     """Build checkpoint-ordered ``(ray origin, ray direction)`` channels."""
 
@@ -438,7 +450,10 @@ def build_plucker_embedding(
 
     # Compute geometry in at least FP32, then cast at the model boundary.
     compute_dtype = torch.float32 if dtype in (torch.float16, torch.bfloat16) else dtype
-    poses = _prepare_framewise_poses(trajectory.poses.to(device=device, dtype=compute_dtype))
+    poses = _prepare_framewise_poses(
+        trajectory.poses.to(device=device, dtype=compute_dtype),
+        translation_scale=translation_scale,
+    )
     intrinsics = trajectory.intrinsics.to(device=device, dtype=compute_dtype).clone()
     intrinsics[:, (0, 2)] *= width / _REFERENCE_WIDTH
     intrinsics[:, (1, 3)] *= height / _REFERENCE_HEIGHT
diff --git a/vllm_omni/diffusion/models/lingbot_world/dmd_block.py b/vllm_omni/diffusion/models/lingbot_world/dmd_block.py
index eace73a41..27da62149 100644
--- a/vllm_omni/diffusion/models/lingbot_world/dmd_block.py
+++ b/vllm_omni/diffusion/models/lingbot_world/dmd_block.py
@@ -7,9 +7,10 @@ over every block, stepwise execution calls ``probe_step`` / ``apply_transition``
 one denoise step at a time and ``commit_block_kv`` from ``post_decode`` -- so the
 math lives here once and cannot drift between the two modes.
 
-A block is four probes that must not touch KV, then one clean-x0 commit that
-does. Whether a call sees paged (session-bound) or request-local KV is decided
-by the ``ar`` argument, so this class never reaches back into the pipeline.
+By default a block is four probes followed by one clean-x0 KV commit.
+The experimental last-step reuse mode instead commits the fourth noisy probe.
+Whether a call sees paged (session-bound) or request-local KV is decided by
+the ``ar`` argument, so this class never reaches back into the pipeline.
 """
 
 from __future__ import annotations
@@ -19,9 +20,11 @@ from typing import TYPE_CHECKING, Any, cast
 
 import torch
 from diffusers.utils.torch_utils import randn_tensor
+from vllm.logger import init_logger
 
 from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
 from vllm_omni.diffusion.models.lingbot_world.transformer import (
+    CameraModulationCache,
     LingBotAttentionCache,
     LingBotTransformerCache,
 )
@@ -32,6 +35,9 @@ if TYPE_CHECKING:
     from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
 
 
+logger = init_logger(__name__)
+
+
 @dataclass(frozen=True)
 class ARBlockContext:
     """The bound AR-Diffusion session one block runs against.
@@ -54,10 +60,14 @@ class LingBotDMDBlockRunner:
         *,
         device: torch.device,
         enforce_eager: bool,
+        reuse_last_step_kv: bool = False,
     ) -> None:
         self.transformer = transformer
         self.device = device
         self.enforce_eager = enforce_eager
+        # Experimental approximation: cache x_t/t_last features instead of x0/t=0.
+        self.reuse_last_step_kv = reuse_last_step_kv
+        logger.info("LingBot experimental last-step KV reuse: %s", self.reuse_last_step_kv)
 
     # ── cache selection ──────────────────────────────────────────────────
 
@@ -109,11 +119,16 @@ class LingBotDMDBlockRunner:
         start_frame: int,
         timestep_value: float,
         step_index: int,
+        camera_cache: CameraModulationCache | None = None,
     ) -> torch.Tensor:
         """Predict flow for one denoise step.
 
-        A probe never writes KV: only the clean x0 of a finished block may
-        enter the cache, which is ``commit_block_kv``'s job.
+        Normally only clean x0 enters KV. The experimental reuse mode commits
+        the final noisy probe instead; the fixed DMD schedule has four probes.
+
+        ``camera_cache`` is the block's camera-modulation cache when the caller
+        holds it across separate calls (the stepwise path); ``generate_block``
+        opens the window itself instead.
         """
         if not self.enforce_eager:
             torch.compiler.cudagraph_mark_step_begin()
@@ -122,14 +137,16 @@ class LingBotDMDBlockRunner:
         # Checkpoint channel contract:
         # [noise/x_t(16), temporal_mask(4), image_latent(16)] -> 36.
         model_input = torch.cat((current_latents.to(dtype=condition.dtype), condition), dim=1)
+        commit_probe = self.reuse_last_step_kv and step_index == 3
         flow_prediction = self.transformer(
             hidden_states=model_input,
             timestep=timestep,
             encoder_hidden_states=prompt_embeds,
             camera_hidden_states=camera,
-            cache=self._block_cache(condition=condition, cache=cache, ar=ar, commit_current=False),
+            cache=self._block_cache(condition=condition, cache=cache, ar=ar, commit_current=commit_probe),
             start_frame=start_frame,
-            update_cache=False,
+            update_cache=commit_probe,
+            camera_modulation_cache=camera_cache,
         )
         if flow_prediction.shape != current_latents.shape:
             raise RuntimeError(
@@ -172,12 +189,19 @@ class LingBotDMDBlockRunner:
         cache: LingBotTransformerCache | None,
         ar: ARBlockContext | None,
         start_frame: int,
+        camera_cache: CameraModulationCache | None = None,
     ) -> None:
         """Write the finished block's clean x0 into KV and commit its pages.
 
-        The fifth transformer call of a block, deliberately not a denoise step:
-        on the stepwise path it belongs to ``post_decode()``.
+        By default this is the fifth transformer call, at t=0. Experimental
+        reuse only finalizes the pages written by the fourth probe. On the
+        stepwise path both modes finalize from ``post_decode()``.
+        ``camera_cache`` is as in ``probe_step``.
         """
+        if self.reuse_last_step_kv:
+            if ar is not None:
+                ar.state.commit_paged_context(ar.branch)
+            return
         # Commit K/V only for the final clean block, never for noisy probes.
         cache_input = torch.cat((latents.to(dtype=condition.dtype), condition), dim=1)
         if not self.enforce_eager:
@@ -190,6 +214,7 @@ class LingBotDMDBlockRunner:
             cache=self._block_cache(condition=condition, cache=cache, ar=ar, commit_current=True),
             start_frame=start_frame,
             update_cache=True,
+            camera_modulation_cache=camera_cache,
         )
         if ar is not None:
             ar.state.commit_paged_context(ar.branch)
@@ -210,6 +235,10 @@ class LingBotDMDBlockRunner:
         """Request mode: all probes of one block, then its commit."""
         block_shape = (1, self.transformer.config.out_channels, *condition.shape[2:5])
         current_latents = randn_tensor(block_shape, generator=generator, device=self.device, dtype=torch.float32)
+        # Every forward below -- each probe and the commit -- reads the same camera trajectory, so the camera
+        # injector is built once per block: one cache for the whole loop, exactly as the stepwise path holds
+        # one per block across its separate calls.
+        camera_cache = CameraModulationCache()
         for step_index, (timestep_value, sigma) in enumerate(schedule):
             flow_prediction = self.probe_step(
                 current_latents=current_latents,
@@ -221,6 +250,7 @@ class LingBotDMDBlockRunner:
                 start_frame=start_frame,
                 timestep_value=timestep_value,
                 step_index=step_index,
+                camera_cache=camera_cache,
             )
             next_sigma = schedule[step_index + 1][1] if step_index + 1 < len(schedule) else None
             current_latents = self.apply_transition(
@@ -235,5 +265,6 @@ class LingBotDMDBlockRunner:
             cache=cache,
             ar=ar,
             start_frame=start_frame,
+            camera_cache=camera_cache,
         )
         return current_latents
diff --git a/vllm_omni/diffusion/models/lingbot_world/pipeline.py b/vllm_omni/diffusion/models/lingbot_world/pipeline.py
index 8e8d5dea4..ae24c0138 100644
--- a/vllm_omni/diffusion/models/lingbot_world/pipeline.py
+++ b/vllm_omni/diffusion/models/lingbot_world/pipeline.py
@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import functools
 import math
 import os
 from collections import OrderedDict
@@ -26,16 +27,21 @@ from vllm.model_executor.models.utils import AutoWeightsLoader
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan import DistributedAutoencoderKLWan
 from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.interaction.mixin import InteractionMixin
+from vllm_omni.diffusion.interaction.modality_handlers.camera import CameraSession
+from vllm_omni.diffusion.interaction.types import ChunkMediaSpec
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
 from vllm_omni.diffusion.models.interface import SupportImageInput, SupportsComponentDiscovery, SupportsStepExecution
 from vllm_omni.diffusion.models.lingbot_world.actions import (
     LINGBOT_CAMERA_ACTION_SCHEMA,
     LINGBOT_CAMERA_TRAJECTORY_SCHEMA,
+    LINGBOT_CONTROLLER_TRANSLATION_UNIT,
     LingBotCameraActionFrames,
     LingBotCameraActionScript,
     as_camera_action_frames,
     as_camera_action_script,
+    camera_trajectory_from_absolute_pose,
     integrate_lingbot_camera_actions,
     parse_lingbot_camera_action_frames,
     parse_lingbot_camera_action_script,
@@ -49,6 +55,7 @@ from vllm_omni.diffusion.models.lingbot_world.camera import (
 )
 from vllm_omni.diffusion.models.lingbot_world.dmd_block import ARBlockContext, LingBotDMDBlockRunner
 from vllm_omni.diffusion.models.lingbot_world.transformer import (
+    CameraModulationCache,
     CausalLingBotWorldTransformer3DModel,
     LingBotAttentionCache,
     LingBotTransformerCache,
@@ -86,7 +93,6 @@ logger = init_logger(__name__)
 _STREAMING_DECODE_BYTES_PER_PIXEL_FP32 = 37832 * 1024 / (64 * 64)
 
 if TYPE_CHECKING:
-    from diffusers.video_processor import VideoProcessor
     from tqdm.std import tqdm as TqdmProgressBar
 
     from vllm_omni.diffusion.worker.input_batch import InputBatch
@@ -147,6 +153,9 @@ class _LingBotRequestInputs:
     width: int
     num_frames: int
     num_latent_frames: int
+    # Request mode returns pixels through VideoProcessor in this type. Step execution (realtime sessions)
+    # returns every pixel type as ``(F, H, W, 3)`` uint8 frames, the layout the streaming endpoint muxes; only
+    # ``"latent"`` differs there. See ``_decode_chunk_to_pixels``.
     output_type: str
     max_sequence_length: int
     flow_shift: float
@@ -158,10 +167,20 @@ class _LingBotARSessionState:
     """Model-owned state; attention tensors remain runner-owned."""
 
     next_chunk_index: int = 0
-    prompt: str | None = None
+    # The umT5 embedding itself is reused by ``encode_prompt``'s own cache.
+    # ``text_cache_key`` does the same job for the runner-owned cross-attention
+    # K/V built from that embedding: it holds the (prompt, max_sequence_length,
+    # dtype) the K/V was built from and is only published after a successful
+    # build; ``text_cache_dirty`` is raised for the duration of a build, so a
+    # build that fails forces the next tick to invalidate whatever its prompt is.
+    text_cache_key: tuple[str, int, str] | None = None
+    text_cache_dirty: bool = False
     generator_state: torch.Tensor | None = None
     encoder_cache: list[torch.Tensor | None] | None = None
     pending_encoder_cache: list[torch.Tensor | None] | None = None
+    # The condition the encoder settles on once its history has stopped
+    # changing; see ``_next_condition_chunk``.
+    condition_fixed_point: torch.Tensor | None = None
     camera_tail: CameraTrajectory | None = None
     camera_pitch: float = 0.0
 
@@ -279,7 +298,70 @@ def _decode_source_image(image: PIL.Image.Image) -> PIL.Image.Image:
         raise ValueError(_SOURCE_IMAGE_ERROR) from None
 
 
+def _source_image_fingerprint(path: str | os.PathLike[str]) -> tuple[str, int, int, int, int, int]:
+    """Identify the bytes behind ``path``: the resolved path plus the stat fields that change when it is rewritten."""
+    resolved = os.path.realpath(os.fspath(path))
+    stat = os.stat(resolved)
+    return resolved, stat.st_dev, stat.st_ino, stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns
+
+
+def _encoder_caches_identical(
+    before: list[torch.Tensor | None] | None, after: list[torch.Tensor | None] | None
+) -> bool:
+    """Whether two encoder histories hold the same tensors bit for bit, slot by slot."""
+    if before is None or after is None or len(before) != len(after):
+        return False
+    for x, y in zip(before, after, strict=True):
+        if x is None or y is None:
+            if x is not y:
+                return False
+        elif x.shape != y.shape or x.dtype != y.dtype or not torch.equal(x, y):
+            return False
+    return True
+
+
+def _uint8_frames(video: torch.Tensor) -> np.ndarray:
+    """Turn one decoded block ``(1, 3, F, H, W)`` in ``[-1, 1]`` into ``(F, H, W, 3)`` uint8 on the host.
+
+    This is the arithmetic ``VideoProcessor.postprocess_video`` applies for
+    ``"np"`` and ``"pil"`` -- denormalise, widen to float32, scale by 255 and
+    round -- done on the device before the copy instead of on the host after
+    it. The bytes are identical to the PIL path; what changes is that the
+    frames cross to the host once, already in the layout and dtype the
+    streaming endpoint muxes, instead of as a float32 copy that is then
+    converted per frame while the next block waits.
+    """
+    # Same order of operations as VideoProcessor: denormalise and clamp in
+    # the decoder dtype, then widen, scale and round.
+    frames = (video[0] / 2 + 0.5).clamp(0, 1).permute(1, 2, 3, 0)
+    frames = frames.float().mul_(255).round_().to(torch.uint8)
+    return np.ascontiguousarray(frames.cpu().numpy())
+
+
+@functools.lru_cache(maxsize=1)
+def _decode_source_image_fingerprinted(fingerprint: tuple[str, int, int, int, int, int]) -> PIL.Image.Image:
+    """The decoded image behind ``fingerprint`` (resolved path plus the stat fields that change on rewrite).
+
+    One entry: a request-mode caller that replays the same source path decodes it once. The realtime tick
+    carries its image inline and never comes through here.
+    """
+    return _decode_source_image_file(fingerprint[0])
+
+
 def _load_source_image(path: str | os.PathLike[str]) -> PIL.Image.Image:
+    """Decode the source image at ``path``, reusing the last decode while the file is unchanged.
+
+    Every caller gets its own copy, so a request that mutates its image cannot reach the next one. A path
+    that cannot be stat'ed goes straight to the uncached decode, which owns the validation error contract.
+    """
+    try:
+        fingerprint = _source_image_fingerprint(path)
+    except (OSError, TypeError, ValueError):
+        return _decode_source_image_file(path)
+    return _decode_source_image_fingerprinted(fingerprint).copy()
+
+
+def _decode_source_image_file(path: str | os.PathLike[str]) -> PIL.Image.Image:
     try:
         source_image = PIL.Image.open(path)
     except (OSError, SyntaxError, ValueError, PIL.Image.DecompressionBombError):
@@ -385,25 +467,36 @@ def get_lingbot_world_pre_process_func(
             camera_actions = None
         else:
             action_path = extra_args.get("action_path")
-            if not isinstance(action_path, (str, os.PathLike)) or not str(action_path):
-                raise ValueError("action_path is required in sampling_params.extra_args.action_path.")
-            if not configured_action_root:
-                raise ValueError(
-                    "sampling_params.extra_args.action_path requires a trusted action root configured by "
-                    f"model_config.lingbot_action_root or {_ACTION_ROOT_ENV}."
+            if action_path is None or action_path == "":
+                # Stepwise / streaming sessions may omit a request-scoped camera
+                # script and instead drive motion via mid-generation camera
+                # interaction (idle hold until the first camera event).
+                if getattr(od_config, "step_execution", False) or getattr(od_config, "streaming_output", False):
+                    trajectory = None
+                    camera_actions = None
+                    camera_action_script = None
+                else:
+                    raise ValueError("action_path is required in sampling_params.extra_args.action_path.")
+            else:
+                if not isinstance(action_path, (str, os.PathLike)) or not str(action_path):
+                    raise ValueError("action_path is required in sampling_params.extra_args.action_path.")
+                if not configured_action_root:
+                    raise ValueError(
+                        "sampling_params.extra_args.action_path requires a trusted action root configured by "
+                        f"model_config.lingbot_action_root or {_ACTION_ROOT_ENV}."
+                    )
+                action_directory = resolve_trusted_action_directory(
+                    action_path,
+                    configured_action_root,
                 )
-            action_directory = resolve_trusted_action_directory(
-                action_path,
-                configured_action_root,
-            )
-            try:
-                trajectory = load_camera_trajectory(action_directory)
-            except OSError:
-                raise ValueError(
-                    "Unable to load camera trajectory from action_path; expected poses.npy and intrinsics.npy."
-                ) from None
-            camera_actions = None
-            camera_action_script = None
+                try:
+                    trajectory = load_camera_trajectory(action_directory)
+                except OSError:
+                    raise ValueError(
+                        "Unable to load camera trajectory from action_path; expected poses.npy and intrinsics.npy."
+                    ) from None
+                camera_actions = None
+                camera_action_script = None
 
         updated_prompt = dict(prompt)
         updated_multi_modal_data = dict(multi_modal_data)
@@ -460,12 +553,16 @@ class LingBotWorldCausalDMDPipeline(
     SupportImageInput,
     SupportsComponentDiscovery,
     SupportsStepExecution,
+    InteractionMixin,
     ProgressBarMixin,
     DiffusionPipelineProfilerMixin,
 ):
     """LingBot-World v2 I2V generation with a request-local causal cache."""
 
     supports_step_execution: ClassVar[bool] = True
+    # A realtime block is four probes and a commit over one prepared chunk
+    # state; nothing between those steps needs the serving scheduler.
+    supports_chunk_step_grouping: ClassVar[bool] = True
     _dit_modules: ClassVar[list[str]] = ["transformer"]
     _encoder_modules: ClassVar[list[str]] = ["text_encoder"]
     _vae_modules: ClassVar[list[str]] = ["vae"]
@@ -484,6 +581,11 @@ class LingBotWorldCausalDMDPipeline(
         del prefix
         _validate_parallel_config(od_config)
         self.od_config = od_config
+        model_config = getattr(od_config, "model_config", None) or {}
+        reuse_last_step_kv = model_config.get("lingbot_reuse_last_step_kv", False)
+        if not isinstance(reuse_last_step_kv, bool):
+            raise ValueError("model_config.lingbot_reuse_last_step_kv must be a bool.")
+        self._reuse_last_step_kv = reuse_last_step_kv
         self.device = get_local_device()
         dtype = getattr(od_config, "dtype", torch.bfloat16)
         model = od_config.model
@@ -569,7 +671,6 @@ class LingBotWorldCausalDMDPipeline(
 
         self.vae_scale_factor_temporal = int(getattr(self.vae.config, "scale_factor_temporal", 4))
         self.vae_scale_factor_spatial = int(getattr(self.vae.config, "scale_factor_spatial", 8))
-        model_config = getattr(od_config, "model_config", None) or {}
         self._ar_height = int(model_config.get("ar_diffusion_height", 480))
         self._ar_width = int(model_config.get("ar_diffusion_width", 832))
         self._ar_diffusion_kv_state: ARDiffusionKVState | None = None
@@ -620,12 +721,21 @@ class LingBotWorldCausalDMDPipeline(
             raise ValueError("LingBot AR-Diffusion cache needs a positive recent window after reserving sink frames.")
         condition_latent_frames = int(self.transformer.config.num_frames_per_block)
         condition_channels = self.vae_scale_factor_temporal + int(self.transformer.config.out_channels)
+        element_size = torch.empty((), dtype=self.transformer.dtype).element_size()
         condition_bytes_per_session = (
-            condition_channels
-            * condition_latent_frames
-            * latent_height
-            * latent_width
-            * torch.empty((), dtype=self.transformer.dtype).element_size()
+            condition_channels * condition_latent_frames * latent_height * latent_width * element_size
+        )
+        # Each layer retains scale and shift for the rank-local camera tokens
+        # across all forwards of a block, including between scheduler calls.
+        camera_tokens = tokens_per_frame * condition_latent_frames
+        sp_size = int(self.od_config.parallel_config.ulysses_degree)
+        camera_bytes_per_session = (
+            2
+            * int(self.transformer.config.num_layers)
+            * ((camera_tokens + sp_size - 1) // sp_size)
+            * int(self.transformer.config.num_attention_heads)
+            * int(self.transformer.config.attention_head_dim)
+            * element_size
         )
         return ARDiffusionKVCacheSpec(
             num_layers=int(self.transformer.config.num_layers),
@@ -641,10 +751,14 @@ class LingBotWorldCausalDMDPipeline(
                 ARDiffusionCrossAttentionKVSpec(
                     self._AR_TEXT_CACHE,
                     _MAX_SEQUENCE_LENGTH,
+                    # Cross-attention keeps every local head on every rank rather than sharding heads across
+                    # the Ulysses group, so the text pool holds that many heads, not the self-attention share.
+                    num_kv_heads=int(self.transformer.blocks[0].cross_attn.num_local_heads),
                 ),
             ),
             model_owned_state_bytes_per_session=(
                 condition_bytes_per_session
+                + camera_bytes_per_session
                 + 2 * self._condition_encoder_cache_bytes()  # Committed and in-flight histories.
                 + self._streaming_decode_bytes_per_session()
             ),
@@ -716,6 +830,7 @@ class LingBotWorldCausalDMDPipeline(
         if state is not None:
             state.encoder_cache = None
             state.pending_encoder_cache = None
+            state.condition_fixed_point = None
 
     def reset_ar_diffusion_session(self, session_id: str) -> None:
         self._release_condition_encoder_state(session_id)
@@ -779,8 +894,10 @@ class LingBotWorldCausalDMDPipeline(
         camera_sources = (
             int(camera_trajectory is not None) + int(camera_actions is not None) + int(camera_action_script is not None)
         )
-        if camera_sources != 1:
-            raise ValueError("LingBot pre-processing must materialize exactly one camera input.")
+        if camera_sources > 1:
+            raise ValueError("LingBot pre-processing must materialize at most one camera input.")
+        # Zero camera sources are allowed for stepwise camera-interaction sessions;
+        # request-mode ``forward`` still requires an explicit trajectory or actions.
 
         request_flow_shift = (
             extra_args["flow_shift"] if "flow_shift" in extra_args else getattr(self.scheduler.config, "shift", 5.0)
@@ -969,6 +1086,50 @@ class LingBotWorldCausalDMDPipeline(
             )
         return condition
 
+    def _next_condition_chunk(
+        self,
+        inputs: _LingBotRequestInputs,
+        *,
+        start_frame: int,
+        session_state: _LingBotARSessionState,
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, list[torch.Tensor | None]]:
+        """The session's condition for the block at ``start_frame``, encoding only while it still changes.
+
+        After a session's opening block the encoder is fed the same all-zero
+        pixel frames on every block, so the only thing that can make one
+        block's condition differ from the last is the encoder's own history.
+        The history is a causal cache with finite temporal reach, and once the
+        zero frames have flushed the source image out of it the encoder is at
+        a fixed point: identical input and identical state produce the same
+        output and the same state on every later block. That fixed point is
+        detected, not assumed after some number of blocks: a block whose
+        returned history is bit-identical to the history it was given is the
+        proof, and from then on the stored condition is returned and the
+        encoder is not run. Measured at 480x832 the encode is 178 ms of a
+        block and the fixed point arrives by the eleventh; the served
+        rollouts this was measured on (40 blocks) are then byte-identical.
+
+        The opening block resets the fixed point, so a session that restarts
+        from a new source image encodes again until it settles.
+        """
+        if start_frame == 0:
+            session_state.condition_fixed_point = None
+        elif session_state.condition_fixed_point is not None:
+            assert session_state.encoder_cache is not None
+            # The history is unchanged by construction; the pending copy is
+            # what post_decode commits, exactly as an encoded block's would be.
+            return session_state.condition_fixed_point.clone(), list(session_state.encoder_cache)
+        condition, pending_cache = self._prepare_condition_chunk(
+            inputs,
+            start_frame=start_frame,
+            encoder_cache=session_state.encoder_cache,
+            dtype=dtype,
+        )
+        if start_frame > 0 and _encoder_caches_identical(session_state.encoder_cache, pending_cache):
+            session_state.condition_fixed_point = condition.clone()
+        return condition, pending_cache
+
     @torch.no_grad()
     def _prepare_condition_chunk(
         self,
@@ -1047,7 +1208,7 @@ class LingBotWorldCausalDMDPipeline(
         *,
         dtype: torch.dtype,
         previous: CameraTrajectory | None = None,
-        latent_aligned: bool = False,
+        latent_aligned: bool = False,  # iff using realtime interaction inputs
     ) -> tuple[torch.Tensor, CameraTrajectory]:
         """Convert raw camera frames to a latent-aligned ray tensor."""
 
@@ -1083,10 +1244,10 @@ class LingBotWorldCausalDMDPipeline(
                 ),
             )
             drop_anchor = True
-        elif inputs.camera_actions is not None:
-            # The action integrator returns post-action poses. Keep the first
-            # action visible to framewise-delta conditioning by prepending its
-            # known pre-action state (identity for a new realtime session).
+        elif inputs.camera_actions is not None or latent_aligned:
+            # Action/interaction integrators return post-action poses. Prepend the
+            # known pre-action state (identity for a new session) so the first
+            # pose still contributes a framewise delta.
             identity = torch.eye(
                 4,
                 device=trajectory.poses.device,
@@ -1100,6 +1261,8 @@ class LingBotWorldCausalDMDPipeline(
                 ),
             )
             drop_anchor = True
+        # Realtime interaction cannot see future steps; use the controller translation unit to normalize speed.
+        # Full action_path keeps max-norm.
         camera_embedding = build_plucker_embedding(
             embedding_trajectory,
             height=inputs.height,
@@ -1108,6 +1271,7 @@ class LingBotWorldCausalDMDPipeline(
             target_width=inputs.width,
             device=self.device,
             dtype=dtype,
+            translation_scale=LINGBOT_CONTROLLER_TRANSLATION_UNIT if latent_aligned else None,
         )
         if drop_anchor:
             camera_embedding = camera_embedding[1:]
@@ -1138,10 +1302,8 @@ class LingBotWorldCausalDMDPipeline(
                 for block in self.transformer.blocks:
                     cross_attention = block.cross_attn
                     shape = (cross_attention.num_local_heads, cross_attention.head_dim)
-                    key = cross_attention.shard_kv_heads(
-                        cross_attention.norm_k(cross_attention.k(projected_text)).unflatten(2, shape)
-                    )
-                    value = cross_attention.shard_kv_heads(cross_attention.v(projected_text).unflatten(2, shape))
+                    key = cross_attention.norm_k(cross_attention.k(projected_text)).unflatten(2, shape)
+                    value = cross_attention.v(projected_text).unflatten(2, shape)
                     yield key, value
 
             state.populate_cross_attention(
@@ -1179,6 +1341,7 @@ class LingBotWorldCausalDMDPipeline(
                 self.transformer,
                 device=self.device,
                 enforce_eager=bool(self.od_config.enforce_eager),
+                reuse_last_step_kv=self._reuse_last_step_kv,
             )
             self._dmd_block_runner = runner
         return runner
@@ -1221,6 +1384,34 @@ class LingBotWorldCausalDMDPipeline(
             progress_bar=progress_bar,
         )
 
+    def _session_text_caches(
+        self,
+        prompt_embeds: torch.Tensor,
+        *,
+        prompt: str,
+        max_sequence_length: int,
+        session_state: _LingBotARSessionState,
+    ) -> list[LingBotAttentionCache]:
+        """Runner-owned cross-attention K/V for this tick, rebuilt when its inputs change.
+
+        The K/V is keyed by everything that defines the prompt embedding
+        (text, sequence length, dtype). The first build of a session needs no
+        invalidation (the runner state is empty); a key change does. The dirty
+        flag is raised for the duration of the build and cleared only after
+        ``_ar_text_caches`` returns, so a build that fails after invalidating
+        or partially writing the caches makes the next tick, whatever its
+        prompt, invalidate again instead of consuming partial K/V.
+        """
+        text_key = (prompt, int(max_sequence_length), str(prompt_embeds.dtype))
+        previous = session_state.text_cache_key
+        invalidate = session_state.text_cache_dirty or (previous is not None and previous != text_key)
+        session_state.text_cache_dirty = True
+        session_state.text_cache_key = None
+        caches = self._ar_text_caches(prompt_embeds, invalidate=invalidate)
+        session_state.text_cache_key = text_key
+        session_state.text_cache_dirty = False
+        return caches
+
     def encode_prompt(
         self,
         prompt: str,
@@ -1277,6 +1468,11 @@ class LingBotWorldCausalDMDPipeline(
                 "request mode takes one three-frame camera_actions control per "
                 "block, or a camera_trajectory for the request."
             )
+        if inputs.camera_trajectory is None and inputs.camera_actions is None:
+            raise ValueError(
+                "LingBot request mode requires camera_trajectory or camera_actions; "
+                "omit them only for stepwise camera-interaction sessions."
+            )
         tick = ARDiffusionTickRequest.from_extra_args(req.sampling_params.extra_args)
         if tick is not None and self._ar_diffusion_kv_state is None:
             raise RuntimeError("LingBot typed ticks require ARDiffusionEngine session binding.")
@@ -1318,6 +1514,9 @@ class LingBotWorldCausalDMDPipeline(
         )
         dtype = self.transformer.dtype
         # Phase 1: turn all three user inputs into DiT-ready conditions.
+        # ``encode_prompt`` reuses an already-encoded prompt itself; the
+        # runner-owned cross-attention K/V is keyed the same way in
+        # ``_session_text_caches`` below.
         prompt_embeds = self.encode_prompt(
             inputs.prompt,
             max_sequence_length=inputs.max_sequence_length,
@@ -1327,10 +1526,10 @@ class LingBotWorldCausalDMDPipeline(
             condition = self._prepare_condition(inputs, dtype=dtype)
         else:
             assert session_state is not None
-            condition, pending_encoder_cache = self._prepare_condition_chunk(
+            condition, pending_encoder_cache = self._next_condition_chunk(
                 inputs,
                 start_frame=tick.chunk_index * block_frames,
-                encoder_cache=session_state.encoder_cache,
+                session_state=session_state,
                 dtype=dtype,
             )
         camera_pitch: float | None = None
@@ -1369,12 +1568,13 @@ class LingBotWorldCausalDMDPipeline(
             )
         else:
             assert session_state is not None
-            prompt_changed = session_state.prompt is not None and session_state.prompt != inputs.prompt
             if session_state.generator_state is not None:
                 inputs.generator.set_state(session_state.generator_state)
-            ar_cross_attention = self._ar_text_caches(
+            ar_cross_attention = self._session_text_caches(
                 prompt_embeds,
-                invalidate=prompt_changed,
+                prompt=inputs.prompt,
+                max_sequence_length=inputs.max_sequence_length,
+                session_state=session_state,
             )
         generated_blocks: list[torch.Tensor] = []
         total_steps = (inputs.num_latent_frames // block_frames) * len(LINGBOT_DMD_TIMESTEPS)
@@ -1410,7 +1610,6 @@ class LingBotWorldCausalDMDPipeline(
         cache = None
         if tick is not None:
             assert session_state is not None
-            session_state.prompt = inputs.prompt
             session_state.generator_state = inputs.generator.get_state()
             session_state.encoder_cache = pending_encoder_cache
             session_state.camera_tail = camera_tail
@@ -1509,11 +1708,15 @@ class LingBotWorldCausalDMDPipeline(
         if state is not None:
             state.release()
 
-    def _decode_chunk_to_pixels(
-        self, latents: torch.Tensor, *, output_type: str, session_id: str | None = None
-    ) -> torch.Tensor | np.ndarray | list[list[PIL.Image.Image]]:
+    def _decode_chunk_to_pixels(self, latents: torch.Tensor, *, session_id: str | None = None) -> np.ndarray:
         """Decode one AR block so streaming consumers receive pixels, not latents.
 
+        The block comes back as ``(F, H, W, 3)`` uint8 whatever pixel output
+        type the request named: the realtime endpoint muxes uint8 frames, so
+        ``"pil"`` and ``"np"`` only ever differed in how much work stood
+        between the decoder and those bytes. Only ``"latent"`` means
+        something else, and the caller keeps latents before reaching here.
+
         With a ``session_id`` the block is decoded through that session's own
         temporal cache, so chunk *N + 1* continues chunk *N*: the causal decoder
         expands the session's opening latent frame to one raw frame and every
@@ -1539,7 +1742,7 @@ class LingBotWorldCausalDMDPipeline(
             video = self.vae.decode(vae_latents, return_dict=False)[0]
         else:
             video = self._streaming_decode_chunk(decoder, vae_latents, cast(str, session_id))
-        return self._video_processor().postprocess_video(video, output_type=output_type)
+        return _uint8_frames(video)
 
     def _streaming_decode_chunk(
         self, decoder: WanStreamingDecoder, vae_latents: torch.Tensor, session_id: str
@@ -1560,15 +1763,6 @@ class LingBotWorldCausalDMDPipeline(
             self._release_streaming_decode_state(session_id)
             raise
 
-    def _video_processor(self) -> VideoProcessor:
-        processor = getattr(self, "_cached_video_processor", None)
-        if processor is None:
-            from diffusers.video_processor import VideoProcessor
-
-            processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
-            self._cached_video_processor = processor
-        return processor
-
     def _require_bound_ar_state(self) -> None:
         if self._ar_diffusion_kv_state is None:
             raise RuntimeError("LingBot step execution requires AR-Diffusion session binding.")
@@ -1645,11 +1839,6 @@ class LingBotWorldCausalDMDPipeline(
         }
         self._ar_text_caches(prompt_embeds, invalidate=False)
         self._ar_sessions[state.request_id] = _LingBotARSessionState()
-        try:
-            self._prepare_next_chunk(state)
-        except Exception:
-            self._release_condition_encoder_state(state.request_id)
-            raise
         return state
 
     def _prepare_next_chunk(self, state: StepRequestState) -> None:
@@ -1661,14 +1850,21 @@ class LingBotWorldCausalDMDPipeline(
         session_state = self._ar_sessions[state.request_id]
         if session_state.next_chunk_index != state.chunk_index:
             raise ValueError("LingBot condition chunks must be contiguous within the session.")
-        condition, pending_encoder_cache = self._prepare_condition_chunk(
+        condition, pending_encoder_cache = self._next_condition_chunk(
             inputs,
             start_frame=start_frame,
-            encoder_cache=session_state.encoder_cache,
+            session_state=session_state,
             dtype=extra["dtype"],
         )
         previous = extra.get("camera_tail")
+
         if extra.get("camera_action_script") is not None:
+            if (
+                (camera_session := state.interaction_sessions.get("camera"))
+                and isinstance(camera_session, CameraSession)
+                and camera_session.has_received_input
+            ):
+                raise ValueError("Cannot use mid-generation camera interaction together with camera_action_script; ")
             chunk_actions = extra["camera_action_script"][state.chunk_index]
             action_trajectory, camera_pitch = integrate_lingbot_camera_actions(
                 chunk_actions,
@@ -1678,11 +1874,12 @@ class LingBotWorldCausalDMDPipeline(
                 initial_pitch=float(extra.get("camera_pitch", 0.0)),
             )
             extra["camera_pitch"] = camera_pitch
+            media_frames = self._chunk_media_frame_count(state, block_frames=block_frames)
             chunk_inputs = replace(
                 inputs,
                 camera_trajectory=action_trajectory,
                 camera_actions=chunk_actions,
-                num_frames=(block_frames - 1) * self.vae_scale_factor_temporal + 1,
+                num_frames=media_frames,
                 num_latent_frames=block_frames,
             )
             camera, camera_tail = self._prepare_camera(
@@ -1691,14 +1888,53 @@ class LingBotWorldCausalDMDPipeline(
                 previous=previous,
             )
         elif extra.get("camera_embedding_cache") is not None:
-            # Same slice request mode takes from its one full-trajectory
-            # embedding, so both paths condition a block identically.
+            if (
+                (camera_session := state.interaction_sessions.get("camera"))
+                and isinstance(camera_session, CameraSession)
+                and camera_session.has_received_input
+            ):
+                raise ValueError("Cannot use mid-generation camera interaction together with camera_embedding_cache; ")
             trajectory = extra["camera_trajectory_cache"]
             camera = extra["camera_embedding_cache"][:, :, start_frame:stop_frame]
             camera_tail = CameraTrajectory(
                 poses=trajectory.poses[stop_frame - 1 : stop_frame].clone(),
                 intrinsics=trajectory.intrinsics[stop_frame - 1 : stop_frame].clone(),
             )
+        elif self._interaction_coordinator is not None and self._interaction_coordinator.has_modality("camera"):
+            # Poses come from the latest boundary apply: ``prepare_encode`` for
+            # chunk 0, the diffusion runner for later chunks. This method only
+            # digests them — it does not apply interactions itself.
+            camera_session = state.interaction_sessions.get("camera")
+            if not isinstance(camera_session, CameraSession) or camera_session.last_absolute_poses is None:
+                raise RuntimeError(
+                    "LingBot camera interaction requires apply_interaction_at_chunk_boundary before prepare_next_chunk."
+                )
+            absolute_poses = camera_session.last_absolute_poses
+            media_frames = self._chunk_media_frame_count(state, block_frames=block_frames)
+            num_latent_frames = block_frames
+            if int(absolute_poses.shape[0]) != num_latent_frames:
+                raise ValueError(
+                    "camera interaction must produce exactly one pose per latent frame; "
+                    f"got {int(absolute_poses.shape[0])}, expected {num_latent_frames}."
+                )
+            action_trajectory = camera_trajectory_from_absolute_pose(
+                absolute_poses,
+                width=inputs.width,
+                height=inputs.height,
+            )
+            chunk_inputs = replace(
+                inputs,
+                camera_trajectory=action_trajectory,
+                camera_actions=None,
+                num_frames=media_frames,
+                num_latent_frames=num_latent_frames,
+            )
+            camera, camera_tail = self._prepare_camera(
+                chunk_inputs,
+                dtype=extra["dtype"],
+                previous=previous,
+                latent_aligned=True,
+            )
         else:
             raise RuntimeError("LingBot step execution is missing a camera trajectory or action script.")
         if camera.shape[2:] != condition.shape[2:]:
@@ -1711,6 +1947,12 @@ class LingBotWorldCausalDMDPipeline(
             raise ValueError("LingBot World requires the runner-provided torch.Generator.")
         extra["condition"] = condition
         extra["camera"] = camera
+        # One camera-modulation cache per block: the four probes and the
+        # commit below are separate scheduler steps, so the block runner
+        # cannot open the reuse window around them the way generate_block
+        # does around its own loop. Holding the cache here makes the window
+        # span exactly this block, per request.
+        extra["camera_cache"] = CameraModulationCache()
         extra["camera_tail"] = camera_tail
         extra["start_frame"] = start_frame
         extra["ar_cross_attention"] = self._ar_text_caches(
@@ -1769,6 +2011,7 @@ class LingBotWorldCausalDMDPipeline(
             start_frame=int(extra["start_frame"]),
             timestep_value=float(schedule[step_in_chunk][0]),
             step_index=step_in_chunk,
+            camera_cache=extra["camera_cache"],
         )
 
     def step_scheduler(self, state: StepRequestState, noise_pred: torch.Tensor, **kwargs: Any) -> None:
@@ -1811,6 +2054,7 @@ class LingBotWorldCausalDMDPipeline(
             cache=None,
             ar=self._ar_block_context(extra["ar_cross_attention"]),
             start_frame=int(extra["start_frame"]),
+            camera_cache=extra.pop("camera_cache"),
         )
         completed_chunk_index = state.chunk_index
         inputs: _LingBotRequestInputs = extra["inputs"]
@@ -1820,13 +2064,7 @@ class LingBotWorldCausalDMDPipeline(
         if inputs.output_type == "latent":
             payload: dict[str, Any] = {"latents": latents}
         else:
-            payload = {
-                "video": self._decode_chunk_to_pixels(
-                    latents,
-                    output_type=inputs.output_type,
-                    session_id=state.request_id,
-                )
-            }
+            payload = {"video": self._decode_chunk_to_pixels(latents, session_id=state.request_id)}
         output = {
             "payload": payload,
             "metadata": {
@@ -1842,19 +2080,48 @@ class LingBotWorldCausalDMDPipeline(
         session_state.pending_encoder_cache = None
         session_state.next_chunk_index += 1
         state.chunk_index += 1
-        finished = state.request_denoise_completed
-        if not finished:
-            self._prepare_next_chunk(state)
-        else:
-            self._release_condition_encoder_state(state.request_id)
         return DiffusionOutput(
             output=output,
             stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
             chunk_index=completed_chunk_index,
             total_chunks=state.total_chunks,
-            finished=finished,
+            finished=state.request_denoise_completed,
         )
 
+    def _chunk_media_frame_count(self, state: StepRequestState, *, block_frames: int) -> int:
+        """Pixel frames this chunk will emit when decoded.
+
+        Independent (non-streaming) decode restarts causal expansion every block,
+        so each chunk is ``(block_frames - 1) * temporal + 1`` frames.
+        Streaming decode expands only the session's opening latent to one frame and every later latent to the full
+        temporal factor, so chunk 0 matches the independent count and later chunks are ``block_frames * temporal``.
+        """
+        decode_state = self._streaming_decode_states.get(state.request_id)
+        if decode_state is not None and decode_state.started:
+            return block_frames * self.vae_scale_factor_temporal
+        return (block_frames - 1) * self.vae_scale_factor_temporal + 1
+
+    def peek_chunk_media(self, state: StepRequestState) -> ChunkMediaSpec:
+        """Expose this chunk's decoded media extent and latent step count."""
+        num_latent_frames = int(state.extra.get("block_frames") or self.transformer.config.num_frames_per_block)
+        num_media_frames = self._chunk_media_frame_count(state, block_frames=num_latent_frames)
+        fps = state.sampling.fps
+        if fps is None or float(fps) <= 0:
+            # Media-frame camera controls are not wall-clock paced; a unit fps keeps
+            # resolve_event_frame_offset well-defined when the client omits sampling.fps.
+            fps = float(num_media_frames)
+        return ChunkMediaSpec(
+            num_media_frames=num_media_frames,
+            fps=fps,
+            num_latent_frames=num_latent_frames,
+        )
+
+    def prepare_next_chunk(self, state: StepRequestState) -> None:
+        """Prepare the next AR block after chunk-boundary interaction apply."""
+        if state.request_denoise_completed:
+            return
+        self._prepare_next_chunk(state)
+
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
         loader = AutoWeightsLoader(self)
         return cast(set[str], loader.load_weights(weights))
diff --git a/vllm_omni/diffusion/models/lingbot_world/transformer.py b/vllm_omni/diffusion/models/lingbot_world/transformer.py
index c7033cee8..9a270e611 100644
--- a/vllm_omni/diffusion/models/lingbot_world/transformer.py
+++ b/vllm_omni/diffusion/models/lingbot_world/transformer.py
@@ -24,7 +24,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 from vllm.model_executor.utils import set_weight_attrs
 
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.distributed.comm import SeqAllToAll4D
+from vllm_omni.diffusion.distributed.comm import SeqAllToAll4D, all_to_all_5D
 from vllm_omni.diffusion.distributed.parallel_state import get_sp_group
 from vllm_omni.diffusion.distributed.sp_plan import SequenceParallelInput, SequenceParallelOutput
 from vllm_omni.diffusion.layers.norm import LayerNorm
@@ -329,9 +329,18 @@ class LingBotSelfAttention(nn.Module):
             key = self.rotary_embedding(key, cos, sin)
 
         if self.ulysses_world_size > 1:
-            query = SeqAllToAll4D.apply(self.ulysses_group, query, 2, 1, False)
-            key = SeqAllToAll4D.apply(self.ulysses_group, key, 2, 1, False)
-            value = SeqAllToAll4D.apply(self.ulysses_group, value, 2, 1, False)
+            # One fused sequence->head all-to-all for q/k/v instead of three:
+            # (B, S/N, 3, H, D) -> (B, S, 3, H/N, D). Same head-group assignment
+            # as the per-tensor 4D exchange (rank r receives head group r), so
+            # the result is a pure permutation of the three-call version, with a
+            # 3x larger message and one third of the latency-bound collectives.
+            qkv = all_to_all_5D(
+                torch.stack((query, key, value), dim=2),
+                scatter_idx=3,
+                gather_idx=1,
+                group=self.ulysses_group,
+            )
+            query, key, value = qkv.unbind(2)
 
         if isinstance(cache, ARDiffusionPagedLayerInputs):
             if query.shape[0] != 1:
@@ -421,13 +430,11 @@ class LingBotCrossAttention(nn.Module):
         self.num_heads = num_heads
         self.head_dim = dim // num_heads
         self.num_local_heads = num_heads // tp_size
-        self.ulysses_world_size, self.ulysses_rank, self.ulysses_group = _ulysses_state()
-        if self.num_local_heads % self.ulysses_world_size:
-            raise ValueError(
-                "LingBot local cross-attention heads must be divisible by the Ulysses degree: "
-                f"heads={self.num_local_heads}, ulysses={self.ulysses_world_size}."
-            )
-        self.num_sp_heads = self.num_local_heads // self.ulysses_world_size
+        # Cross-attention keeps every local head on every Ulysses rank and attends the rank's own sequence
+        # shard. Each query token attends the whole text sequence independently of the others, so there is
+        # nothing to exchange: the sequence split Ulysses already gives us is the only split needed, and both
+        # all-to-all collectives -- one for the query, one for the output -- disappear. The cost is that the text K/V is
+        # replicated per rank instead of head-sharded; ar_diffusion_kv_cache_spec sizes the pool for it.
         self.tp_inner_dim = self.num_local_heads * self.head_dim
 
         self.q = ColumnParallelLinear(
@@ -465,9 +472,9 @@ class LingBotCrossAttention(nn.Module):
         self.norm_q = _LingBotRMSNorm(self.tp_inner_dim, eps)
         self.norm_k = _LingBotRMSNorm(self.tp_inner_dim, eps)
         self.attn = Attention(
-            num_heads=self.num_sp_heads,
+            num_heads=self.num_local_heads,
             head_size=self.head_dim,
-            num_kv_heads=self.num_sp_heads,
+            num_kv_heads=self.num_local_heads,
             softmax_scale=self.head_dim**-0.5,
             causal=False,
             role="cross",
@@ -477,14 +484,6 @@ class LingBotCrossAttention(nn.Module):
             disable_kv_quant=True,
         )
 
-    def shard_kv_heads(self, value: torch.Tensor) -> torch.Tensor:
-        """Select this Ulysses rank's projected K/V heads."""
-
-        if self.ulysses_world_size == 1:
-            return value
-        start = self.ulysses_rank * self.num_sp_heads
-        return value[:, :, start : start + self.num_sp_heads].clone(memory_format=torch.contiguous_format)
-
     def forward(
         self,
         hidden_states: torch.Tensor,
@@ -494,8 +493,6 @@ class LingBotCrossAttention(nn.Module):
     ) -> tuple[torch.Tensor, LingBotAttentionCache]:
         query = self.norm_q(self.q(hidden_states))
         query = query.unflatten(2, (self.num_local_heads, self.head_dim))
-        if self.ulysses_world_size > 1:
-            query = SeqAllToAll4D.apply(self.ulysses_group, query, 2, 1, False)
 
         # Text K/V is constant within a request and is projected once per layer.
         if cache is None:
@@ -503,8 +500,8 @@ class LingBotCrossAttention(nn.Module):
                 raise ValueError("encoder_hidden_states are required when the cross-attention cache is empty.")
             key = self.norm_k(self.k(encoder_hidden_states))
             value = self.v(encoder_hidden_states)
-            key = self.shard_kv_heads(key.unflatten(2, (self.num_local_heads, self.head_dim)))
-            value = self.shard_kv_heads(value.unflatten(2, (self.num_local_heads, self.head_dim)))
+            key = key.unflatten(2, (self.num_local_heads, self.head_dim))
+            value = value.unflatten(2, (self.num_local_heads, self.head_dim))
             cache = LingBotAttentionCache(
                 key=key,
                 value=value,
@@ -517,8 +514,6 @@ class LingBotCrossAttention(nn.Module):
             value = cache.value[:, : cache.end]
 
         output = self.attn(query, key, value)
-        if self.ulysses_world_size > 1:
-            output = SeqAllToAll4D.apply(self.ulysses_group, output, 1, 2, False)
         return self.o(output.flatten(2, 3)), cache
 
 
@@ -592,6 +587,16 @@ class LingBotAttentionBlock(nn.Module):
         self.cam_scale_layer = nn.Linear(dim, dim)
         self.cam_shift_layer = nn.Linear(dim, dim)
 
+    def camera_modulation(self, camera_hidden_states: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """Build this block's camera scale and shift from the patchified camera tokens.
+
+        Depends only on ``camera_hidden_states``, so a caller holding the camera trajectory fixed -- every
+        denoise forward of one AR chunk does -- can build this once and pass it back through ``forward``.
+        """
+        camera_features = self.cam_injector_layer2(F.silu(self.cam_injector_layer1(camera_hidden_states)))
+        camera_features = camera_features + camera_hidden_states
+        return self.cam_scale_layer(camera_features), self.cam_shift_layer(camera_features)
+
     def forward(
         self,
         hidden_states: torch.Tensor,
@@ -605,6 +610,7 @@ class LingBotAttentionBlock(nn.Module):
         sink_tokens: int,
         update_cache: bool,
         rotary_emb: tuple[torch.Tensor, torch.Tensor],
+        camera_modulation: tuple[torch.Tensor, torch.Tensor] | None = None,
     ) -> tuple[torch.Tensor, LingBotAttentionCache]:
         batch_size, token_count, dim = hidden_states.shape
         if (
@@ -638,10 +644,9 @@ class LingBotAttentionBlock(nn.Module):
         hidden_grid = hidden_grid + attention_output.unflatten(1, (num_frames, tokens_per_frame)) * gate_msa
         hidden_states = hidden_grid.flatten(1, 2).to(hidden_states.dtype)
 
-        camera_features = self.cam_injector_layer2(F.silu(self.cam_injector_layer1(camera_hidden_states)))
-        camera_features = camera_features + camera_hidden_states
-        camera_scale = self.cam_scale_layer(camera_features)
-        camera_shift = self.cam_shift_layer(camera_features)
+        camera_scale, camera_shift = (
+            self.camera_modulation(camera_hidden_states) if camera_modulation is None else camera_modulation
+        )
         hidden_states = ((1 + camera_scale) * hidden_states + camera_shift).to(hidden_states.dtype)
 
         attention_output, cross_cache = self.cross_attn(
@@ -763,6 +768,22 @@ def _rope_axis(max_seq_len: int, dim: int, *, start: int = 0) -> tuple[torch.Ten
     return phase.cos().float(), phase.sin().float()
 
 
+class CameraModulationCache:
+    """Per-block camera scale and shift, held by the caller across the forwards of one AR block.
+
+    The camera injector is four projections and a SiLU per block and reads only the camera tokens, which do
+    not change between the denoise steps and the clean commit of one block. The caller that owns that
+    invariant creates one of these per block and passes it to every forward of the block; ``forward`` fills a
+    block's entry on first use and reads it after. Its lifetime is the caller's: the AR runner keeps one per
+    block, ``generate_block`` one per loop, and nothing here checks the camera tensor for change.
+    """
+
+    __slots__ = ("entries",)
+
+    def __init__(self) -> None:
+        self.entries: dict[int, tuple[torch.Tensor, torch.Tensor]] = {}
+
+
 class CausalLingBotWorldTransformer3DModel(nn.Module):
     """Checkpoint-compatible causal LingBot World video transformer."""
 
@@ -922,6 +943,27 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
             cosine, sine = _rope_axis(rope_max_seq_len, axis_dim)
             self.register_buffer(f"_rope_{axis}_cosine", cosine, persistent=False)
             self.register_buffer(f"_rope_{axis}_sine", sine, persistent=False)
+        # One static-address buffer per shape for the per-token timestep
+        # projection; see _stage_timestep_projection.
+        self._timestep_projection_buffers: dict[tuple[tuple[int, ...], torch.dtype, torch.device], torch.Tensor] = {}
+
+    def _stage_timestep_projection(self, projection: torch.Tensor) -> torch.Tensor:
+        """Hand the blocks the timestep projection from a buffer whose address never changes.
+
+        Every regional block graph takes the projection as an input. Under CUDA-graph replay an input that
+        arrives in a fresh tensor each forward is copied into the graph's placeholder on every replay: at
+        480x832 with four Ulysses ranks that is a 72 MB copy per block, forty times per forward, two hundred
+        times per AR chunk. Copying the projection once per forward into a buffer marked static lets every
+        replay read it in place. The values the blocks see are the same; only where they live changes.
+        """
+        key = (tuple(projection.shape), projection.dtype, projection.device)
+        buffer = self._timestep_projection_buffers.get(key)
+        if buffer is None:
+            buffer = torch.empty(projection.shape, dtype=projection.dtype, device=projection.device)
+            torch._dynamo.mark_static_address(buffer)
+            self._timestep_projection_buffers[key] = buffer
+        buffer.copy_(projection)
+        return buffer
 
     @property
     def dtype(self) -> torch.dtype:
@@ -1178,6 +1220,7 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
         cache: LingBotTransformerCache,
         start_frame: int,
         update_cache: bool,
+        camera_modulation_cache: CameraModulationCache | None = None,
     ) -> torch.Tensor:
         if not isinstance(update_cache, bool):
             raise ValueError("update_cache must be a boolean.")
@@ -1272,16 +1315,25 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
                     "LingBot SP input hooks did not shard all conditioning tensors consistently; "
                     f"expected {local_tokens} tokens per rank. Check SP hook registration and input dimensions."
                 )
+        timestep_projection = self._stage_timestep_projection(timestep_projection)
         rotary_emb = (cosine, sine)
         # Phase 3: each layer receives its own cache entry. Text K/V is passed
         # only when absent; the returned cache is stored for subsequent DMD
-        # steps and causal blocks in this request.
+        # steps and causal blocks in this request. A caller-held camera cache
+        # gives every block its modulation once per AR block.
         for index, block in enumerate(self.blocks):
+            camera_modulation = None
+            if camera_modulation_cache is not None:
+                camera_modulation = camera_modulation_cache.entries.get(index)
+                if camera_modulation is None:
+                    camera_modulation = block.camera_modulation(camera_hidden_states)
+                    camera_modulation_cache.entries[index] = camera_modulation
             hidden_states, cross_cache = block(
                 hidden_states,
                 projected_text if cache.cross_attention[index] is None else None,
                 timestep_projection,
                 camera_hidden_states,
+                camera_modulation=camera_modulation,
                 self_cache=cache.self_attention[index],
                 cross_cache=cache.cross_attention[index],
                 current_start=current_start,
diff --git a/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py b/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py
index 3cde2a868..a93d14704 100644
--- a/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py
+++ b/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+from collections import OrderedDict
 from collections.abc import Iterable
 from typing import Any
 
@@ -16,6 +17,8 @@ from vllm.model_executor.layers.activation import get_act_fn
 from vllm.model_executor.layers.layernorm import RMSNorm
 from vllm.model_executor.layers.linear import ColumnParallelLinear, QKVParallelLinear, RowParallelLinear
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+from vllm.platforms import current_platform
+from vllm.triton_utils import HAS_TRITON
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
@@ -26,10 +29,150 @@ from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelOutput,
 )
 from vllm_omni.diffusion.forward_context import get_forward_context
+from vllm_omni.diffusion.layers.fused_qk_norm_rope import fused_qk_norm_rope_min_tokens
+from vllm_omni.diffusion.layers.fused_qk_rope import fused_qk_rope, fused_qk_rope_supported
 from vllm_omni.platforms import current_omni_platform
 
 logger = init_logger(__name__)
 
+RotaryEmbedding = tuple[torch.Tensor, torch.Tensor] | tuple[torch.Tensor, torch.Tensor, int]
+
+# All LongCat production attention spans contain at least 512 tokens.  Reuse
+# the shared Q/K fusion threshold override so deployments can retain a
+# hardware-specific crossover without adding another environment variable.
+_FUSED_MIN_TOKENS = 512
+_FUSED_QK_ROPE = HAS_TRITON and current_platform.is_cuda()
+_FAILED_QK_ROPE_SIGNATURES_MAX_SIZE = 128
+_FAILED_QK_ROPE_SIGNATURES: OrderedDict[tuple[object, ...], None] = OrderedDict()
+
+
+def _fusion_enabled(sequence_parallel_size: int | None, *, enforce_eager: bool) -> bool:
+    return (
+        _FUSED_QK_ROPE
+        and enforce_eager
+        and not torch.compiler.is_compiling()
+        and not torch.is_grad_enabled()
+        and not (sequence_parallel_size is not None and sequence_parallel_size > 1)
+    )
+
+
+def _prepare_rotary_emb(
+    txt_cos: torch.Tensor,
+    txt_sin: torch.Tensor,
+    img_cos: torch.Tensor,
+    img_sin: torch.Tensor,
+    *,
+    enable_fusion: bool,
+) -> RotaryEmbedding:
+    """Join text/image tables and resolve the shared token gate once."""
+
+    joint = torch.cat((txt_cos, img_cos), dim=0), torch.cat((txt_sin, img_sin), dim=0)
+    if not enable_fusion:
+        return joint
+    return joint[0], joint[1], fused_qk_norm_rope_min_tokens(_FUSED_MIN_TOKENS)
+
+
+def _apply_qk_rope_reference(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    rotary_emb: tuple[torch.Tensor, torch.Tensor],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    return (
+        apply_rotary_emb(query, rotary_emb, sequence_dim=1),
+        apply_rotary_emb(key, rotary_emb, sequence_dim=1),
+    )
+
+
+def _qk_rope_signature(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> tuple[object, ...]:
+    """Identify a runtime layout for failure-cache fallback."""
+
+    return (
+        query.device.type,
+        query.device.index,
+        query.dtype,
+        tuple(query.shape),
+        tuple(query.stride()),
+        tuple(key.shape),
+        tuple(key.stride()),
+        cos.dtype,
+        tuple(cos.shape),
+        tuple(cos.stride()),
+        tuple(sin.stride()),
+    )
+
+
+def _is_failed_qk_rope_signature(signature: tuple[object, ...]) -> bool:
+    if signature not in _FAILED_QK_ROPE_SIGNATURES:
+        return False
+    _FAILED_QK_ROPE_SIGNATURES.move_to_end(signature)
+    return True
+
+
+def _record_failed_qk_rope_signature(signature: tuple[object, ...]) -> None:
+    _FAILED_QK_ROPE_SIGNATURES[signature] = None
+    _FAILED_QK_ROPE_SIGNATURES.move_to_end(signature)
+    while len(_FAILED_QK_ROPE_SIGNATURES) > _FAILED_QK_ROPE_SIGNATURES_MAX_SIZE:
+        _FAILED_QK_ROPE_SIGNATURES.popitem(last=False)
+
+
+def _can_use_fused_qk_rope(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    sequence_parallel_size: int | None,
+    min_tokens: int | None,
+) -> bool:
+    """Keep compile, autograd, capture, SP, and unsupported inputs native."""
+
+    if (
+        torch.compiler.is_compiling()
+        or torch.is_grad_enabled()
+        or (sequence_parallel_size is not None and sequence_parallel_size > 1)
+        or min_tokens is None
+        or not fused_qk_rope_supported(query, key, cos, sin)
+        or torch.cuda.is_current_stream_capturing()
+    ):
+        return False
+    return query.shape[0] * query.shape[1] >= min_tokens
+
+
+def _apply_qk_rope(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    rotary_emb: RotaryEmbedding | None,
+    sequence_parallel_size: int | None,
+    min_tokens: int | None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Apply one paired RoPE launch, falling back after launch failures."""
+
+    if rotary_emb is None:
+        return query, key
+    rotary_pair = rotary_emb[:2]
+    cos, sin = rotary_pair
+    if not _can_use_fused_qk_rope(query, key, cos, sin, sequence_parallel_size, min_tokens):
+        return _apply_qk_rope_reference(query, key, rotary_pair)
+
+    signature = _qk_rope_signature(query, key, cos, sin)
+    if _is_failed_qk_rope_signature(signature):
+        return _apply_qk_rope_reference(query, key, rotary_pair)
+
+    try:
+        return fused_qk_rope(query, key, cos, sin)
+    except Exception as exc:  # noqa: BLE001 - optimized-path failures must fall back
+        _record_failed_qk_rope_signature(signature)
+        logger.warning(
+            "Disabling LongCat paired Q/K RoPE fusion for signature %s after failure: %s",
+            signature,
+            exc,
+        )
+        return _apply_qk_rope_reference(query, key, rotary_pair)
+
 
 class FeedForward(nn.Module):
     def __init__(self, dim: int, dim_out: int | None = None, mult: int = 4, bias: bool = True):
@@ -121,7 +264,7 @@ class LongCatImageAttention(nn.Module):
         text_key: torch.Tensor,
         text_value: torch.Tensor,
         text_seq_len: int,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None,
+        image_rotary_emb: RotaryEmbedding | None,
     ) -> torch.Tensor:
         """
         Apply RoPE separately to text and image Q/K, then run SP attention with joint tensors.
@@ -139,7 +282,7 @@ class LongCatImageAttention(nn.Module):
             Attention output with shape (B, txt_len + img_len/SP, H, D)
         """
         if image_rotary_emb is not None:
-            freqs_cos, freqs_sin = image_rotary_emb
+            freqs_cos, freqs_sin = image_rotary_emb[:2]
             txt_rotary_emb = (freqs_cos[:text_seq_len], freqs_sin[:text_seq_len])
             img_rotary_emb_split = (freqs_cos[text_seq_len:], freqs_sin[text_seq_len:])
             # Apply RoPE to image Q/K
@@ -165,7 +308,7 @@ class LongCatImageAttention(nn.Module):
         self,
         hidden_states: torch.Tensor,
         encoder_hidden_states: torch.Tensor | None = None,
-        image_rotary_emb: torch.Tensor | None = None,
+        image_rotary_emb: RotaryEmbedding | None = None,
         **kwargs,
     ) -> torch.Tensor:
         """
@@ -196,6 +339,8 @@ class LongCatImageAttention(nn.Module):
 
         query = self.norm_q(query)
         key = self.norm_k(key)
+        rotary_pair = image_rotary_emb[:2] if image_rotary_emb is not None else None
+        min_tokens = image_rotary_emb[2] if image_rotary_emb is not None and len(image_rotary_emb) > 2 else None
 
         if self.added_kv_proj_dim is not None:
             encoder_qkv, _ = self.add_kv_proj(encoder_hidden_states)
@@ -222,7 +367,7 @@ class LongCatImageAttention(nn.Module):
                     text_key=encoder_key,
                     text_value=encoder_value,
                     text_seq_len=encoder_query.shape[1],
-                    image_rotary_emb=image_rotary_emb,
+                    image_rotary_emb=rotary_pair,
                 )
             else:
                 # Non-SP Mode: Concat first, then apply RoPE to full sequence
@@ -230,10 +375,15 @@ class LongCatImageAttention(nn.Module):
                 joint_key = torch.cat([encoder_key, key], dim=1)
                 joint_value = torch.cat([encoder_value, value], dim=1)
 
-                if image_rotary_emb is not None:
-                    # Apply RoPE to full (text + image) sequence
-                    joint_query = apply_rotary_emb(joint_query, image_rotary_emb, sequence_dim=1)
-                    joint_key = apply_rotary_emb(joint_key, image_rotary_emb, sequence_dim=1)
+                # Keep the native RMSNorm and text-then-image concatenation
+                # order, then combine only the two independent RoPE calls.
+                joint_query, joint_key = _apply_qk_rope(
+                    joint_query,
+                    joint_key,
+                    rotary_pair,
+                    sp_size,
+                    min_tokens,
+                )
 
                 hidden_states = self.attn(
                     joint_query,
@@ -272,13 +422,17 @@ class LongCatImageAttention(nn.Module):
                     text_key=key[:, :text_seq_len],
                     text_value=value[:, :text_seq_len],
                     text_seq_len=text_seq_len,
-                    image_rotary_emb=image_rotary_emb,
+                    image_rotary_emb=rotary_pair,
                 )
             else:
                 # Non-SP Mode: standard path
-                if image_rotary_emb is not None:
-                    query = apply_rotary_emb(query, image_rotary_emb, sequence_dim=1)
-                    key = apply_rotary_emb(key, image_rotary_emb, sequence_dim=1)
+                query, key = _apply_qk_rope(
+                    query,
+                    key,
+                    rotary_pair,
+                    sp_size,
+                    min_tokens,
+                )
 
                 hidden_states = self.attn(
                     query,
@@ -345,7 +499,7 @@ class LongCatImageTransformerBlock(nn.Module):
         hidden_states: torch.Tensor,
         encoder_hidden_states: torch.Tensor,
         temb: torch.Tensor,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        image_rotary_emb: RotaryEmbedding | None = None,
         joint_attention_kwargs: dict[str, Any] | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1(hidden_states, emb=temb)
@@ -536,7 +690,7 @@ class LongCatImageSingleTransformerBlock(nn.Module):
         hidden_states: torch.Tensor,
         encoder_hidden_states: torch.Tensor,
         temb: torch.Tensor,
-        image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        image_rotary_emb: RotaryEmbedding | None = None,
         joint_attention_kwargs: dict[str, Any] | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         """
@@ -632,6 +786,7 @@ class LongCatImageTransformer2DModel(nn.Module):
 
         # Store parallel config for SP support
         self.parallel_config = od_config.parallel_config
+        self.enforce_eager = bool(getattr(od_config, "enforce_eager", False))
 
         self.pos_embed = LongCatImagePosEmbed(theta=10000, axes_dim=axes_dims_rope)
         self.rope_preparer = RoPEPreparer(self.pos_embed)
@@ -701,11 +856,15 @@ class LongCatImageTransformer2DModel(nn.Module):
         # txt_cos/txt_sin (outputs 0, 1) remain replicated for dual-stream attention
         txt_cos, txt_sin, img_cos, img_sin = self.rope_preparer(txt_ids, img_ids)
 
-        # Reconstruct image_rotary_emb with chunked values
-        # Final shape: (txt_seq_len + img_seq_len // SP, head_dim)
-        image_rotary_emb = (
-            torch.cat([txt_cos, img_cos], dim=0),
-            torch.cat([txt_sin, img_sin], dim=0),
+        # Preserve the ordinary full-width tables.  A third scalar only marks
+        # the eligible eager SP=1 route and resolves the shared threshold once
+        # for all attention blocks in this transformer call.
+        image_rotary_emb = _prepare_rotary_emb(
+            txt_cos,
+            txt_sin,
+            img_cos,
+            img_sin,
+            enable_fusion=_fusion_enabled(sp_size, enforce_eager=self.enforce_eager),
         )
 
         for block in self.transformer_blocks:
diff --git a/vllm_omni/diffusion/models/magi2/modeling_magi2.py b/vllm_omni/diffusion/models/magi2/modeling_magi2.py
index 44e282aa0..0009a2ecc 100644
--- a/vllm_omni/diffusion/models/magi2/modeling_magi2.py
+++ b/vllm_omni/diffusion/models/magi2/modeling_magi2.py
@@ -670,11 +670,9 @@ def _is_magi2_transformer_layer(_name: str, module: nn.Module) -> bool:
 class Magi2PreviewTransformer(nn.Module):
     """Native preview DiT with the released checkpoint hierarchy."""
 
-    # ``block`` must remain the registered child name because it is part of the
-    # released checkpoint hierarchy.  The ``layers`` property below exposes its
-    # ModuleList through the standard layerwise-offload contract without
-    # changing the registered module names.
-    _layerwise_offload_blocks_attrs = ["layers"]
+    # ``block`` is the registered child module containing the repeated
+    # layers, exposed as the streamable blocks container for layerwise offload.
+    _layerwise_offload_blocks_attrs = ["block"]
     _hsdp_shard_conditions = [_is_magi2_transformer_layer]
     _hsdp_preserve_parameter_dtypes = True
     _EP_SHARDED_SUFFIXES = (
@@ -704,7 +702,7 @@ class Magi2PreviewTransformer(nn.Module):
 
     @property
     def layers(self) -> nn.ModuleList:
-        """Expose Preview layers to the shared offload block discovery API."""
+        """Expose Preview layers for direct access and compatibility."""
 
         return self.block.layers
 
diff --git a/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py b/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
index c96e5548c..21977f488 100644
--- a/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
+++ b/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
@@ -3,19 +3,23 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from typing import Any, ClassVar
+from dataclasses import dataclass
+from typing import ClassVar
 
 import torch
+from diffusers.image_processor import VaeImageProcessor
 from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
 from diffusers.utils.torch_utils import randn_tensor
 from torch import nn
 from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
-from vllm.config import VllmConfig
 from vllm.logger import init_logger
 from vllm.model_executor.models.utils import AutoWeightsLoader, WeightsMapper
 
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
-from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 from vllm_omni.transformers_utils.configs.mammoth_moda2 import Mammothmoda2Config
 
 from .mammothmoda2_dit_model import SimpleQFormerImageRefiner, Transformer2DModel
@@ -25,6 +29,59 @@ from .schedulers import FlowMatchEulerDiscreteScheduler
 logger = init_logger(__name__)
 
 
+def _first_request_value(value: object) -> object:
+    if isinstance(value, (list, tuple)):
+        return value[0] if value else None
+    return value
+
+
+def get_mammoth_moda2_post_process_func(
+    _od_config: OmniDiffusionConfig,
+):
+    image_processor = VaeImageProcessor()
+
+    def post_process_func(images: torch.Tensor):
+        return image_processor.postprocess(images)
+
+    return post_process_func
+
+
+def _build_mammoth_config(od_config: OmniDiffusionConfig) -> Mammothmoda2Config:
+    raw_config = od_config.tf_model_config.to_dict()
+    if not raw_config:
+        raise ValueError("MammothModa2 diffusion stage requires the root checkpoint config")
+    return Mammothmoda2Config(**raw_config)
+
+
+def _root_weight_source(
+    od_config: OmniDiffusionConfig,
+) -> DiffusersPipelineLoader.ComponentSource:
+    if not od_config.model:
+        raise ValueError("MammothModa2 diffusion stage requires a model path")
+    return DiffusersPipelineLoader.ComponentSource(
+        model_or_path=od_config.model,
+        subfolder=None,
+        revision=od_config.revision,
+        prefix="",
+        fall_back_to_pt=True,
+    )
+
+
+@dataclass(frozen=True)
+class _MammothRequest:
+    request_id: str
+    full_hidden_states: torch.Tensor
+    full_token_ids: list[int]
+    answer_start_index: int
+    height: int
+    width: int
+    text_guidance_scale: float
+    cfg_range: tuple[float, float]
+    num_inference_steps: int
+    seed: int | None
+    generator: torch.Generator | list[torch.Generator] | None
+
+
 class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
     """
     MammothModa2 DiT + VAE generation stage (non-autoregressive).
@@ -38,7 +95,8 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
     _encoder_modules: ClassVar[list[str]] = ["gen_image_condition_refiner"]
     _vae_modules: ClassVar[list[str]] = ["gen_vae"]
 
-    have_multimodal_outputs = True
+    supports_request_batch = False
+    supports_step_execution = False
 
     # Load only gen_* weights; ignore llm_model.* to prevent loading the entire LLM backbone in the DiT stage.
     hf_to_vllm_mapper = WeightsMapper(
@@ -48,15 +106,13 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
         }
     )
 
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
         super().__init__()
         del prefix
-
-        hf_config = vllm_config.model_config.hf_config
-        if not isinstance(hf_config, Mammothmoda2Config):
-            raise TypeError(f"Expected Mammothmoda2Config, got {type(hf_config)}")
-
-        self.config = hf_config
+        self.od_config = od_config
+        self.device = get_local_device()
+        self.config = _build_mammoth_config(od_config)
+        self.weights_sources = [_root_weight_source(od_config)]
 
         # --- Build DiT / VAE modules (names must match checkpoint keys) ---
         if self.config.gen_vae_config is None or self.config.gen_dit_config is None:
@@ -111,9 +167,6 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
             theta=10000,
         )
 
-        # vLLM PP interface compatibility
-        self.make_empty_intermediate_tensors = lambda: None
-
         self._llm_hidden_size = llm_hidden_size
 
     def _reinit_caption_embedder(self, in_features: int) -> None:
@@ -125,39 +178,118 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
             nn.Linear(in_features, out_features, bias=True),
         )
 
-    def get_dummy_runtime_additional_information(self, num_reqs: int) -> list[dict[str, object]]:
-        if num_reqs <= 0:
-            raise ValueError(f"num_reqs must be positive, got {num_reqs}")
-        if num_reqs > 1:
-            raise NotImplementedError(
-                f"get_dummy_runtime_additional_information does not support num_reqs > 1, got {num_reqs}"
-            )
-        text_prompt_embeds = torch.zeros((1, self._llm_hidden_size), dtype=torch.float32)
-        image_prompt_embeds = torch.zeros((1, self._llm_hidden_size), dtype=torch.float32)
-        negative_prompt_embeds = torch.zeros((0, self._llm_hidden_size), dtype=torch.float32)
-        info = {
-            "text_prompt_embeds": text_prompt_embeds,
-            "image_prompt_embeds": image_prompt_embeds,
-            "negative_prompt_embeds": negative_prompt_embeds,
-            "negative_prompt_attention_mask": [],
-            "image_height": [512],
-            "image_width": [512],
-            "text_guidance_scale": [1.0],
-            "cfg_range": [0.0, 1.0],
-            "num_inference_steps": [1],
-        }
-        return [info for _ in range(num_reqs)]
+    def _parse_request(self, req: DiffusionRequestBatch) -> _MammothRequest:
+        if req.num_reqs != 1:
+            raise ValueError("MammothModa2 diffusion requires exactly one request")
+        request_id = req.request_id
+        sampling = req.sampling_params
+        if sampling.num_outputs_per_prompt != 1:
+            raise ValueError(f"MammothModa2 requires num_outputs_per_prompt=1 for request {request_id}")
 
-    def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
-        # DiT stage does not consume token embeddings; return a dummy tensor.
+        prompt = req.prompts[0]
+        prompt = prompt if isinstance(prompt, dict) else {}
+        info = prompt.get("additional_information")
+        if req.is_dummy_run():
+            full_hidden_states = torch.zeros((2, self._llm_hidden_size), dtype=torch.float32, device="cpu")
+            full_token_ids = [0, int(self.config.llm_config.gen_vocab_start_index)]
+            answer_start_index = 1
+        else:
+            if not isinstance(info, dict):
+                raise ValueError(f"Missing additional_information AR conditions for request {request_id}")
+            full_hidden_states = info.get("full_hidden_states")
+            full_token_ids = info.get("full_token_ids")
+            if not isinstance(full_hidden_states, torch.Tensor) or not isinstance(full_token_ids, list):
+                raise ValueError(f"Expected full_hidden_states tensor and full_token_ids list for request {request_id}")
+            try:
+                answer_start_index = int(info.get("answer_start_index"))
+            except (TypeError, ValueError, OverflowError) as exc:
+                raise ValueError(f"Invalid answer_start_index for request {request_id}") from exc
+            if full_hidden_states.ndim != 2:
+                raise ValueError(f"Expected 2D full_hidden_states for request {request_id}")
+            if full_hidden_states.shape[0] != len(full_token_ids):
+                raise ValueError(f"AR hidden-state/token-count mismatch for request {request_id}")
+            if not 0 <= answer_start_index <= len(full_token_ids):
+                raise ValueError(f"answer_start_index outside token range for request {request_id}")
+            try:
+                full_token_ids = [int(token_id) for token_id in full_token_ids]
+            except (TypeError, ValueError, OverflowError) as exc:
+                raise ValueError(f"Invalid full_token_ids for request {request_id}") from exc
+
+        dimensions = []
+        for name in ("height", "width"):
+            value = DiffusionRequestBatch.get_prompt_field(prompt, name)
+            if value is None:
+                value = getattr(sampling, name)
+            if value is None:
+                value = 1024
+            try:
+                dimensions.append(int(value))
+            except (TypeError, ValueError, OverflowError) as exc:
+                raise ValueError(f"Invalid image size {name}={value!r} for request {request_id}") from exc
+        height, width = dimensions
+        if height <= 0 or width <= 0:
+            raise ValueError(f"Invalid image size: {height}x{width} for request {request_id}")
+        if height % 16 != 0 or width % 16 != 0:
+            raise ValueError(f"Image size must be multiples of 16, got {height}x{width} for request {request_id}")
+
+        request_info = info if isinstance(info, dict) else {}
+        extra_args = sampling.extra_args or {}
+        guidance = extra_args.get("text_guidance_scale")
+        if guidance is None:
+            guidance = sampling.guidance_scale if sampling.guidance_scale_provided else None
+        if guidance is None:
+            guidance = _first_request_value(request_info.get("text_guidance_scale"))
+        if guidance is None:
+            guidance = 9.0
         try:
-            dtype = next(self.parameters()).dtype
-        except StopIteration:
-            dtype = torch.float32
-        return torch.zeros(
-            (input_ids.numel(), self._llm_hidden_size),
-            device=input_ids.device,
-            dtype=dtype,
+            text_guidance_scale = float(guidance)
+        except (TypeError, ValueError, OverflowError) as exc:
+            raise ValueError(f"Invalid text_guidance_scale for request {request_id}") from exc
+        raw_num_inference_steps = extra_args.get("num_inference_steps")
+        if raw_num_inference_steps is None:
+            raw_num_inference_steps = sampling.num_inference_steps
+        if raw_num_inference_steps is None:
+            raw_num_inference_steps = _first_request_value(request_info.get("num_inference_steps"))
+        if raw_num_inference_steps is None:
+            raw_num_inference_steps = 50
+        try:
+            num_inference_steps = int(raw_num_inference_steps)
+        except (TypeError, ValueError, OverflowError) as exc:
+            raise ValueError(f"Invalid num_inference_steps for request {request_id}") from exc
+        if num_inference_steps <= 0:
+            raise ValueError(f"num_inference_steps must be positive for request {request_id}")
+        cfg_range = extra_args.get("cfg_range")
+        if cfg_range is None:
+            cfg_range = request_info.get("cfg_range")
+        if cfg_range is None:
+            cfg_range = [0.0, 1.0]
+        if not isinstance(cfg_range, (list, tuple)) or len(cfg_range) != 2:
+            raise ValueError(f"cfg_range requires two values for request {request_id}")
+        try:
+            cfg_start, cfg_end = float(cfg_range[0]), float(cfg_range[1])
+        except (TypeError, ValueError, OverflowError) as exc:
+            raise ValueError(f"cfg_range requires two values convertible to floats for request {request_id}") from exc
+        if not 0 <= cfg_start <= cfg_end <= 1:
+            raise ValueError(f"cfg_range must satisfy 0 <= start <= end <= 1 for request {request_id}")
+
+        generator = sampling.generator
+        if isinstance(generator, list) and len(generator) != 1:
+            raise ValueError(
+                f"MammothModa2 single-output request mode requires exactly one generator for request {request_id}"
+            )
+
+        return _MammothRequest(
+            request_id=request_id,
+            full_hidden_states=full_hidden_states,
+            full_token_ids=full_token_ids,
+            answer_start_index=answer_start_index,
+            height=height,
+            width=width,
+            text_guidance_scale=text_guidance_scale,
+            cfg_range=(cfg_start, cfg_end),
+            num_inference_steps=num_inference_steps,
+            seed=sampling.seed,
+            generator=generator,
         )
 
     def _split_ar_conditions(
@@ -202,42 +334,19 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
         return text_cond, image_cond
 
     @torch.inference_mode()
-    def forward(
-        self,
-        *,
-        inputs_embeds: torch.Tensor | None = None,
-        **kwargs: Any,  # noqa: ARG002
-    ) -> OmniOutput:
-        runtime_addi = kwargs.get("runtime_additional_information", None)
-        info = runtime_addi[0]
-
-        # Sampling knobs are declared in vllm_omni/model_extras/mammothmodal2_preview.py
-        # and routed via extra_body -> sampling_params.extra_args (surfaced here as
-        # ``sampling_extra_args``). Fall back to runtime_additional_information for the
-        # legacy bespoke-example path during the transition.
-        extra_args_list = kwargs.get("sampling_extra_args") or []
-        extra_args = extra_args_list[0] if extra_args_list else {}
-        text_guidance_scale = float(extra_args.get("text_guidance_scale", info["text_guidance_scale"][0]))
-        cfg_range_val = extra_args.get("cfg_range", info["cfg_range"])
-        cfg_range = float(cfg_range_val[0]), float(cfg_range_val[1])
-        num_inference_steps = int(extra_args.get("num_inference_steps", info["num_inference_steps"][0]))
-
-        negative_cond = info.get("negative_prompt_embeds")
-        negative_attention_mask = info.get("negative_prompt_attention_mask")
-        image_hw = info["image_height"][0], info["image_width"][0]
-
-        # Split the AR hidden states into text / image conditions. The token ids that
-        # drive the split are sourced from the model config (see _split_ar_conditions),
-        # formerly supplied by the bespoke example via additional_information. Legacy
-        # fallback: ar2dit may have already produced the split conditions.
-        if "text_prompt_embeds" in info:
-            text_cond = info["text_prompt_embeds"]
-            image_cond = info["image_prompt_embeds"]
-        else:
-            text_cond, image_cond = self._split_ar_conditions(
-                full_hidden_states=info["full_hidden_states"],
-                full_token_ids=info["full_token_ids"],
-                answer_start_index=int(info["answer_start_index"][0]),
+    def forward(self, req: DiffusionRequestBatch) -> DiffusionOutput:
+        request = self._parse_request(req)
+        text_cond, image_cond = self._split_ar_conditions(
+            full_hidden_states=request.full_hidden_states,
+            full_token_ids=request.full_token_ids,
+            answer_start_index=request.answer_start_index,
+        )
+        if image_cond.shape[0] == 0:
+            answer_token_ids = request.full_token_ids[request.answer_start_index :]
+            raise ValueError(
+                "MammothModa2 AR stage produced no visual-token hidden states for "
+                f"request {request.request_id}; the DiT stage requires at least one generated visual token. "
+                f"Generated token ids: {answer_token_ids[:32]}"
             )
 
         # Move to model device/dtype.
@@ -247,22 +356,6 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
         else:
             target_dtype = next(self.gen_transformer.parameters()).dtype
 
-        def _ensure_2d(x: torch.Tensor, name: str) -> torch.Tensor:
-            if x.ndim == 3 and x.shape[0] == 1:
-                x = x[0]
-            if x.ndim != 2:
-                raise ValueError(f"Expected {name} to be 2D [T,H], got shape={tuple(x.shape)}")
-            return x
-
-        text_cond = _ensure_2d(text_cond, "text_prompt_embeds")
-        image_cond = _ensure_2d(image_cond, "image_prompt_embeds")
-        if image_cond.shape[0] == 0:
-            answer_token_ids = info.get("full_token_ids", [])[int(info.get("answer_start_index", [0])[0]) :]
-            raise ValueError(
-                "MammothModa2 AR stage produced no visual-token hidden states; "
-                "the DiT stage requires at least one generated visual token. "
-                f"Generated token ids: {answer_token_ids[:32]}"
-            )
         text_cond = text_cond.to(device=model_device, dtype=target_dtype, non_blocking=True).contiguous()
         image_cond = image_cond.to(device=model_device, dtype=target_dtype, non_blocking=True).contiguous()
 
@@ -301,63 +394,38 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
             ar_image_embeds = image_embeds
             ar_image_attention_mask = image_attention_mask
 
-        # Prepare negative prompt (for CFG). If none provided, fall back to unconditional.
+        # Empty unconditional prompt for classifier-free guidance.
         negative_prompt_embeds = None
         negative_prompt_attention_mask = None
-        if text_guidance_scale > 1.0:
-            if negative_cond is not None:
-                negative_cond = _ensure_2d(negative_cond, "negative_prompt_embeds")
-                negative_prompt_embeds = (
-                    negative_cond.to(device=model_device, dtype=target_dtype, non_blocking=True)
-                    .contiguous()
-                    .unsqueeze(0)
-                )
-                if isinstance(negative_attention_mask, torch.Tensor):
-                    neg_mask = negative_attention_mask
-                elif isinstance(negative_attention_mask, list):
-                    neg_mask = torch.tensor(negative_attention_mask, dtype=torch.bool)
-                else:
-                    neg_mask = None
-                if neg_mask is None:
-                    negative_prompt_attention_mask = torch.ones(
-                        (1, negative_prompt_embeds.shape[1]),
-                        dtype=torch.bool,
-                        device=negative_prompt_embeds.device,
-                    )
-                else:
-                    neg_mask = neg_mask.to(device=negative_prompt_embeds.device, dtype=torch.bool)
-                    if neg_mask.ndim == 1:
-                        neg_mask = neg_mask.unsqueeze(0)
-                    negative_prompt_attention_mask = neg_mask
-            else:
-                hidden_size = int(prompt_embeds.shape[-1])
-                negative_prompt_embeds = torch.zeros(
-                    (1, 0, hidden_size),
-                    dtype=target_dtype,
-                    device=prompt_embeds.device,
-                )
-                negative_prompt_attention_mask = torch.zeros(
-                    (1, 0),
-                    dtype=torch.bool,
-                    device=prompt_embeds.device,
-                )
+        if request.text_guidance_scale > 1.0:
+            hidden_size = int(prompt_embeds.shape[-1])
+            negative_prompt_embeds = torch.zeros(
+                (1, 0, hidden_size),
+                dtype=target_dtype,
+                device=prompt_embeds.device,
+            )
+            negative_prompt_attention_mask = torch.zeros(
+                (1, 0),
+                dtype=torch.bool,
+                device=prompt_embeds.device,
+            )
+
+        generator = request.generator
+        if generator is None and request.seed is not None:
+            generator = torch.Generator(device=model_device).manual_seed(request.seed)
 
         # Output image size (px), passed from stage input processor.
-        height, width = image_hw
-        if height <= 0 or width <= 0:
-            raise ValueError(f"Invalid image size: {height}x{width}")
-        if height % 16 != 0 or width % 16 != 0:
-            raise ValueError(f"Image size must be multiples of 16, got {height}x{width}")
+        height, width = request.height, request.width
         vae_scale_factor = 16
 
         latent_channels = int(self.gen_transformer.config.in_channels)
         shape = (1, latent_channels, 2 * height // vae_scale_factor, 2 * width // vae_scale_factor)
-        latents = randn_tensor(shape, device=prompt_embeds.device, dtype=prompt_embeds.dtype)
+        latents = randn_tensor(shape, generator=generator, device=prompt_embeds.device, dtype=prompt_embeds.dtype)
 
         scheduler = FlowMatchEulerDiscreteScheduler()
 
         scheduler.set_timesteps(
-            num_inference_steps=num_inference_steps,
+            num_inference_steps=request.num_inference_steps,
             device=prompt_embeds.device,
             num_tokens=latents.shape[-2] * latents.shape[-1],
         )
@@ -376,7 +444,9 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
                 ar_image_attention_mask=ar_image_attention_mask,
                 freqs_cis=self.gen_freqs_cis,
             )
-            guidance_scale = text_guidance_scale if cfg_range[0] <= i / total_steps <= cfg_range[1] else 1.0
+            guidance_scale = (
+                request.text_guidance_scale if request.cfg_range[0] <= i / total_steps <= request.cfg_range[1] else 1.0
+            )
             if guidance_scale > 1.0 and negative_prompt_embeds is not None:
                 model_pred_uncond = self.gen_transformer(
                     hidden_states=latents,
@@ -397,14 +467,7 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
             latents = latents + self.gen_vae.config.shift_factor
         image = self.gen_vae.decode(latents, return_dict=False)[0]
 
-        return OmniOutput(
-            text_hidden_states=inputs_embeds,  # placeholder, not used by runner
-            multimodal_outputs=image,
-            intermediate_tensors=None,
-        )
-
-    def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor | None:  # noqa: ARG002
-        return None
+        return DiffusionOutput(output=image)
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
         loader = AutoWeightsLoader(self)
diff --git a/vllm_omni/diffusion/models/minimax_h3/batched_packing.py b/vllm_omni/diffusion/models/minimax_h3/batched_packing.py
index 4d41bde61..a9bf7cbba 100644
--- a/vllm_omni/diffusion/models/minimax_h3/batched_packing.py
+++ b/vllm_omni/diffusion/models/minimax_h3/batched_packing.py
@@ -38,6 +38,8 @@ def minimax_h3_batched_forward_kwargs(
     t_audio: Sequence[float],
     imgvid_cond_timesteps: Sequence[float],
     audio_ref_cond_timesteps: Sequence[float],
+    video_target_timesteps: Sequence[torch.Tensor | None] | None = None,
+    audio_target_timesteps: Sequence[torch.Tensor | None] | None = None,
 ) -> dict[str, Any]:
     """Build one DiT forward kwargs dict covering every request in the batch.
 
@@ -46,6 +48,16 @@ def minimax_h3_batched_forward_kwargs(
     happen to agree -- which also keeps ``video_token_layout`` (the sparse-
     attention hint) on the single-request step path.
     """
+    request_count = len(branches)
+    if video_target_timesteps is None:
+        video_target_timesteps = [None] * request_count
+    elif len(video_target_timesteps) != request_count:
+        raise ValueError(f"video_target_timesteps has {len(video_target_timesteps)} requests, expected {request_count}")
+    if audio_target_timesteps is None:
+        audio_target_timesteps = [None] * request_count
+    elif len(audio_target_timesteps) != request_count:
+        raise ValueError(f"audio_target_timesteps has {len(audio_target_timesteps)} requests, expected {request_count}")
+
     if len(branches) == 1:
         return branches[0].forward_kwargs(
             video_rows=video_rows[0],
@@ -54,6 +66,8 @@ def minimax_h3_batched_forward_kwargs(
             t_audio=t_audio[0],
             imgvid_cond_timestep=imgvid_cond_timesteps[0],
             audio_ref_cond_timestep=audio_ref_cond_timesteps[0],
+            video_target_timesteps=video_target_timesteps[0],
+            audio_target_timesteps=audio_target_timesteps[0],
         )
 
     device = branches[0].device
@@ -88,11 +102,15 @@ def minimax_h3_batched_forward_kwargs(
         position_id_parts.append(branch.img_position_ids_dev)
         text_embed_parts.append(branch.text_embeddings_dev)
 
-        timesteps[seq_offset : seq_offset + branch.seq_len] = float(t_video[index])
-        timesteps[img_pos[branch.update_mask_dev]] = float(t_video[index])
-        timesteps[img_pos[~branch.update_mask_dev]] = float(imgvid_cond_timesteps[index])
-        timesteps[audio_pos[branch.audio_update_mask_dev]] = float(t_audio[index])
-        timesteps[audio_pos[~branch.audio_update_mask_dev]] = float(audio_ref_cond_timesteps[index])
+        branch.fill_timesteps(
+            timesteps[seq_offset : seq_offset + branch.seq_len],
+            t_video=t_video[index],
+            t_audio=t_audio[index],
+            imgvid_cond_timestep=imgvid_cond_timesteps[index],
+            audio_ref_cond_timestep=audio_ref_cond_timesteps[index],
+            video_target_timesteps=video_target_timesteps[index],
+            audio_target_timesteps=audio_target_timesteps[index],
+        )
 
         # Empty documents are omitted because not every varlen kernel accepts
         # repeated interior boundaries.
diff --git a/vllm_omni/diffusion/models/minimax_h3/continuation.py b/vllm_omni/diffusion/models/minimax_h3/continuation.py
new file mode 100644
index 000000000..f8d9d661c
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/continuation.py
@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Bounded H3 windows with synchronized latent-tail guides and global AV RoPE positions.
+
+The guide/discard/append algorithm follows ComfyUI-Minimax-H3-Continuation:
+https://github.com/ttulttul/ComfyUI-Minimax-H3-Continuation
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.errors import OmniClientError
+from vllm_omni.model_executor.models.minimax_h3.long_video import resolve_long_video_mode
+
+from .packed_tokens import minimax_h3_pack_audio_latent, minimax_h3_patchify_video_latent
+
+logger = init_logger(__name__)
+
+
+def _video_t(frames: int) -> int:
+    return (frames - 5) // 17 * 5 + 2
+
+
+def _audio_t(frame_boundary: int) -> int:
+    return round(frame_boundary * 5 / 3)
+
+
+@dataclass(frozen=True)
+class ContinuationWindow:
+    start: int
+    end: int
+    overlap: int
+
+    @property
+    def audio_start(self) -> int:
+        return _audio_t(self.start)
+
+    @property
+    def audio_end(self) -> int:
+        return _audio_t(self.end)
+
+    @property
+    def overlap_audio_t(self) -> int:
+        return _audio_t(self.start + self.overlap) - self.audio_start
+
+
+def resolve_continuation(extra: Mapping[str, Any], *, task: str, step_execution: bool) -> tuple[int, int] | None:
+    mode = resolve_long_video_mode(extra, task)
+    if mode == "full":
+        return None
+    if task != "ref2va" or step_execution:
+        raise OmniClientError("MiniMax H3 continuation requires Ref2VA request execution (not step execution)")
+    window = extra.get("continuation_window_frames", 277)
+    overlap = extra.get("continuation_overlap_frames", 22)
+    for name, value in (("window", window), ("overlap", overlap)):
+        if isinstance(value, bool) or not isinstance(value, int) or value < 5 or value % 17 != 5:
+            raise OmniClientError(f"MiniMax H3 continuation {name} must be an integer on the 17n+5 frame grid")
+    if not 107 <= window <= 345 or overlap >= window:
+        raise OmniClientError("MiniMax H3 continuation window must be 107..345 frames and exceed its overlap")
+    return window, overlap
+
+
+def plan_continuation_windows(total_frames: int, window_frames: int, overlap_frames: int) -> list[ContinuationWindow]:
+    if total_frames < 5 or total_frames % 17 != 5:
+        raise ValueError("total_frames must satisfy 17n+5")
+    if not 5 <= overlap_frames < window_frames or window_frames % 17 != 5 or overlap_frames % 17 != 5:
+        raise ValueError("window and overlap must satisfy 17n+5, with 5 <= overlap < window")
+    end = min(total_frames, window_frames)
+    windows = [ContinuationWindow(0, end, 0)]
+    while end < total_frames:
+        start = end - overlap_frames
+        end = min(total_frames, start + window_frames)
+        windows.append(ContinuationWindow(start, end, overlap_frames))
+    return windows
+
+
+def diffuse_continuation(
+    diffuse: Callable[..., tuple[torch.Tensor, torch.Tensor]],
+    kwargs: dict[str, Any],
+    *,
+    window_frames: int,
+    overlap_frames: int,
+    text_conditioning: Sequence[tuple[torch.Tensor, torch.Tensor]] | None = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Denoise fresh windows; retain old latents and append only new suffixes.
+
+    Guides are extra condition rows sharing the new target's temporal origin,
+    not a masked target prefix. Audio boundaries refer to the cumulative frame
+    timeline, preventing per-window rounding from accumulating A/V drift.
+    Each window shifts temporal media positions onto that same global timeline
+    before RoPE is evaluated; text and static image references remain fixed.
+    """
+    windows = plan_continuation_windows(kwargs["num_frames"], window_frames, overlap_frames)
+    if text_conditioning is not None and len(text_conditioning) != len(windows):
+        raise OmniClientError("MiniMax H3 requires one text conditioning per continuation window")
+    # Different prompts have different prefix lengths. Keep the media clock
+    # anchored after the longest prefix so text length cannot shift AV time.
+    media_time_origin = max(item[0].shape[0] for item in text_conditioning) if text_conditioning else None
+    source_rows = kwargs.get("locked_audio_rows")
+    source = None if source_rows is None else source_rows.reshape(2, kwargs["audio_t"], 32)
+    video = audio = None
+    for index, window in enumerate(windows):
+        frames = window.end - window.start
+        args = {
+            **kwargs,
+            "num_frames": frames,
+            "latent_t": _video_t(frames),
+            "audio_t": window.audio_end - window.audio_start,
+            # Keep fractional RoPE units; audio slice indices alone are rounded.
+            "temporal_offset": window.start * (40.0 / 24.0),
+        }
+        if text_conditioning is not None:
+            args["text_embeddings"], args["text_tags"] = text_conditioning[index]
+            args["media_time_origin"] = media_time_origin
+        if source is not None:
+            args["locked_audio_rows"] = source[:, window.audio_start : window.audio_end].reshape(-1, 32)
+        overlap_v = _video_t(window.overlap) if window.overlap else 0
+        if video is not None and audio is not None:
+            guide_video = minimax_h3_patchify_video_latent(video[:, :, -overlap_v:], patch_size=(1, 2, 2))
+            guide_audio = minimax_h3_pack_audio_latent(audio[..., -window.overlap_audio_t :])
+            for name, guide in (("visual_condition", guide_video), ("audio_condition", guide_audio)):
+                existing = kwargs.get(name)
+                args[name] = guide if existing is None else torch.cat((existing, guide), dim=0)
+            args["visual_condition_shapes"] = [
+                *(kwargs.get("visual_condition_shapes") or []),
+                (overlap_v, kwargs["latent_h"], kwargs["latent_w"]),
+            ]
+            args["audio_condition_lengths"] = [*(kwargs.get("audio_condition_lengths") or []), window.overlap_audio_t]
+            args["ref_blocks"] = [
+                *(kwargs.get("ref_blocks") or []),
+                {
+                    "kind": "latent_guide",
+                    "latent_t": overlap_v,
+                    "latent_h": kwargs["latent_h"],
+                    "latent_w": kwargs["latent_w"],
+                    "ref_audio_t": window.overlap_audio_t,
+                },
+            ]
+        logger.info(
+            "MiniMax H3 continuation window %d/%d: frames [%d, %d), hidden overlap %d, temporal offset %.6f",
+            index + 1,
+            len(windows),
+            window.start,
+            window.end,
+            window.overlap,
+            args["temporal_offset"],
+        )
+        sampled_video, sampled_audio = diffuse(**args)
+        video = sampled_video if video is None else torch.cat((video, sampled_video[:, :, overlap_v:]), dim=2)
+        audio = (
+            sampled_audio if audio is None else torch.cat((audio, sampled_audio[..., window.overlap_audio_t :]), dim=-1)
+        )
+    assert video is not None and audio is not None
+    if video.shape[2] != kwargs["latent_t"] or audio.shape[-1] != kwargs["audio_t"]:
+        raise RuntimeError("MiniMax H3 continuation produced inconsistent cumulative AV lengths")
+    return video, audio
diff --git a/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py b/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py
index 5f7579d07..1bd429b4d 100644
--- a/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py
+++ b/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py
@@ -23,6 +23,7 @@ from vllm_omni.diffusion.forward_context import (
 )
 from vllm_omni.platforms import current_omni_platform
 
+from .latent_mask import MiniMaxH3LatentEdit, minimax_h3_prepare_edit_rows
 from .scheduling_minimax_h3_euler_ancestral import (
     minimax_h3_euler_eta0_step,
     minimax_h3_rf_v_to_x0,
@@ -86,6 +87,7 @@ class MiniMaxH3DenoiseBranch:
             raise ValueError(f"token_tags length {int(token_tags.view(-1).shape[0])} != seq_len {seq_len}")
         cu = packed["cu_seqlens"].to(torch.int32)
         self.device = device
+        self.locked_audio_rows: torch.Tensor | None = None
         # ``used_len`` is the real (non-padding) document length; step-mode
         # batching concatenates layouts and needs both bounds as Python ints so
         # it can rebuild ``cu_seqlens`` without a device sync per step.
@@ -185,25 +187,23 @@ class MiniMaxH3DenoiseBranch:
         t_audio: float,
         imgvid_cond_timestep: float,
         audio_ref_cond_timestep: float,
+        video_target_timesteps: torch.Tensor | None = None,
+        audio_target_timesteps: torch.Tensor | None = None,
     ) -> dict[str, Any]:
         x = self.x_base.clone()
         x[0].index_copy_(0, self.img_pos_dev, video_rows)
         audio_x = self.audio_x_base.clone()
         audio_x[0].index_copy_(0, self.audio_pos_dev, audio_rows)
-        # Packed-sequence timestep semantics: non-media rows (text and
-        # padding) inherit the current video timestep. Later steps must reuse
-        # the previous step's updated rows; re-initializing from zeros is only
-        # valid at step 0.
-        timesteps = torch.full(
-            (self.seq_len,),
-            float(t_video),
-            dtype=torch.float32,
-            device=x.device,
+        timesteps = torch.empty(self.seq_len, dtype=torch.float32, device=self.device)
+        self.fill_timesteps(
+            timesteps,
+            t_video=t_video,
+            t_audio=t_audio,
+            imgvid_cond_timestep=imgvid_cond_timestep,
+            audio_ref_cond_timestep=audio_ref_cond_timestep,
+            video_target_timesteps=video_target_timesteps,
+            audio_target_timesteps=audio_target_timesteps,
         )
-        timesteps[self.img_pos_dev[self.update_mask_dev]] = t_video
-        timesteps[self.img_pos_dev[~self.update_mask_dev]] = imgvid_cond_timestep
-        timesteps[self.audio_pos_dev[self.audio_update_mask_dev]] = t_audio
-        timesteps[self.audio_pos_dev[~self.audio_update_mask_dev]] = audio_ref_cond_timestep
         unique_timesteps, inverse_indices = torch.unique(timesteps, sorted=True, return_inverse=True)
         return {
             **self.static_kwargs,
@@ -213,6 +213,56 @@ class MiniMaxH3DenoiseBranch:
             "inverse_indices": inverse_indices,
         }
 
+    def fill_timesteps(
+        self,
+        timesteps: torch.Tensor,
+        *,
+        t_video: float,
+        t_audio: float,
+        imgvid_cond_timestep: float,
+        audio_ref_cond_timestep: float,
+        video_target_timesteps: torch.Tensor | None = None,
+        audio_target_timesteps: torch.Tensor | None = None,
+    ) -> None:
+        """Fill one request's packed row timesteps in an existing tensor."""
+        if timesteps.shape != (self.seq_len,):
+            raise ValueError(f"timesteps must have shape ({self.seq_len},)")
+        # Packed-sequence timestep semantics: non-media rows (text and
+        # padding) inherit the current video timestep. Later steps must reuse
+        # the previous step's updated rows; re-initializing from zeros is only
+        # valid at step 0.
+        timesteps.fill_(float(t_video))
+        timestep_groups = (
+            (
+                "video_target_timesteps",
+                self.img_pos_dev,
+                self.update_mask_dev,
+                video_target_timesteps,
+                t_video,
+                imgvid_cond_timestep,
+            ),
+            (
+                "audio_target_timesteps",
+                self.audio_pos_dev,
+                self.audio_update_mask_dev,
+                audio_target_timesteps,
+                t_audio if self.locked_audio_rows is None else 1.0,
+                audio_ref_cond_timestep,
+            ),
+        )
+        for name, positions, update_mask, target_timesteps, current_timestep, condition_timestep in timestep_groups:
+            target_positions = positions[update_mask]
+            if target_timesteps is None:
+                timesteps[target_positions] = current_timestep
+            else:
+                target_timesteps = target_timesteps.to(device=self.device, dtype=torch.float32).reshape(-1)
+                if target_timesteps.shape[0] != target_positions.shape[0]:
+                    raise ValueError(
+                        f"{name} rows {target_timesteps.shape[0]} != target rows {target_positions.shape[0]}"
+                    )
+                timesteps[target_positions] = target_timesteps
+            timesteps[positions[~update_mask]] = condition_timestep
+
 
 def minimax_h3_prepare_denoise_rows(
     *,
@@ -273,6 +323,8 @@ def minimax_h3_denoise_loop(
     initial_audio_rows: torch.Tensor,
     keyframe_cond_rows: torch.Tensor | None,
     audio_ref_rows: torch.Tensor | None = None,
+    video_edit: MiniMaxH3LatentEdit | None = None,
+    audio_edit: MiniMaxH3LatentEdit | None = None,
     sigmas_video: list[float],
     sigmas_audio: list[float],
     device: torch.device,
@@ -307,6 +359,10 @@ def minimax_h3_denoise_loop(
     )
     update = positive.update_mask_dev
     audio_update = positive.audio_update_mask_dev
+    if video_edit is not None:
+        video_edit = video_edit.to(device=device, dtype=torch.float32)
+    if audio_edit is not None:
+        audio_edit = audio_edit.to(device=device, dtype=torch.float32)
 
     num_steps = len(sigmas_video) - 1
     for step in range(num_steps):
@@ -323,40 +379,73 @@ def minimax_h3_denoise_loop(
             imgvid_cond_t = max(t_v, float(imgvid_cond_noise_aug_for_inference))
             audio_ref_cond_t = max(t_a, float(audio_cond_noise_aug_for_inference))
 
+            model_video_rows, video_target_timesteps = minimax_h3_prepare_edit_rows(
+                video_rows,
+                update,
+                video_edit,
+                t_v,
+                imgvid_cond_t,
+                sigma=s_v,
+            )
+            model_audio_rows, audio_target_timesteps = minimax_h3_prepare_edit_rows(
+                audio_rows,
+                audio_update,
+                audio_edit,
+                t_a,
+                audio_ref_cond_t,
+                sigma=s_a,
+            )
+
             fk = positive.forward_kwargs(
-                video_rows=video_rows,
-                audio_rows=audio_rows,
+                video_rows=model_video_rows,
+                audio_rows=model_audio_rows,
                 t_video=t_v,
                 t_audio=t_a,
                 imgvid_cond_timestep=imgvid_cond_t,
                 audio_ref_cond_timestep=audio_ref_cond_t,
+                video_target_timesteps=video_target_timesteps,
+                audio_target_timesteps=audio_target_timesteps,
             )
             with torch.inference_mode():
                 v_video, v_audio = model(**fk)
             mv_video_t = v_video.float()[update]
             mv_audio_t = v_audio.float()[audio_update]
 
-            x0_video = minimax_h3_rf_v_to_x0(
-                video_rows[update],
-                mv_video_t,
-                torch.tensor(t_v, dtype=torch.float32, device=device),
-            )
+            if video_edit is None:
+                x0_video = minimax_h3_rf_v_to_x0(
+                    video_rows[update],
+                    mv_video_t,
+                    torch.tensor(t_v, dtype=torch.float32, device=device),
+                )
+            else:
+                x0_video = video_edit.x0(
+                    model_video_rows[update],
+                    mv_video_t,
+                    t_v,
+                )
             new_target = minimax_h3_euler_eta0_step(video_rows[update], x0_video, sigma_curr=s_v, sigma_next=s_v_next)
             video_rows = video_rows.clone()
             video_rows[update] = new_target
             if cond_anchor is not None:
                 video_rows[~update] = cond_anchor  # per-step imgvid cond reset
 
-            x0_audio = minimax_h3_rf_v_to_x0(
-                audio_rows[audio_update],
-                mv_audio_t,
-                torch.tensor(t_a, dtype=torch.float32, device=device),
-            )
+            if audio_edit is None:
+                x0_audio = minimax_h3_rf_v_to_x0(
+                    audio_rows[audio_update],
+                    mv_audio_t,
+                    torch.tensor(t_a, dtype=torch.float32, device=device),
+                )
+            else:
+                x0_audio = audio_edit.x0(
+                    model_audio_rows[audio_update],
+                    mv_audio_t,
+                    t_a,
+                )
             new_audio = minimax_h3_euler_eta0_step(
                 audio_rows[audio_update], x0_audio, sigma_curr=s_a, sigma_next=s_a_next
             )
             audio_rows = audio_rows.clone()
-            audio_rows[audio_update] = new_audio
+            audio_rows[audio_update] = new_audio if positive.locked_audio_rows is None else positive.locked_audio_rows
             if audio_anchor is not None:
                 audio_rows[~audio_update] = audio_anchor  # per-step audio ref reset
             if on_step is not None:
diff --git a/vllm_omni/diffusion/models/minimax_h3/fasth3.py b/vllm_omni/diffusion/models/minimax_h3/fasth3.py
index c4860c57e..dcc513028 100644
--- a/vllm_omni/diffusion/models/minimax_h3/fasth3.py
+++ b/vllm_omni/diffusion/models/minimax_h3/fasth3.py
@@ -102,6 +102,7 @@ _MODEL_LEVEL_TARGETS = {
     "time_embedder.linear_2": "time_embedder.proj_out",
     "norm_out.linear": "final_layer.adaln_proj.linear",
     "norm_out.norm": "final_layer.norm",
+    "token_refiner.final_norm": "token_refiner.final_norm",
 }
 
 # Per-block adapter suffix -> (native suffix, how a delta enters the native
@@ -115,6 +116,8 @@ _BLOCK_TARGETS = {
     "attn.to_v": ("attn.qkv_proj", _QKV_V),
     "attn.to_out.0": ("attn.out_proj", _PLAIN),
     "attn.to_gate_compress": ("attn.to_gate_compress", _PLAIN),
+    "attn.norm_q": ("attn.q_norm", _PLAIN),
+    "attn.norm_k": ("attn.k_norm", _PLAIN),
     "ff.net.0.proj": ("mlp.fc1", _SWAP_HALVES),
     "ff.net.2": ("mlp.fc2", _PLAIN),
     "adaln_proj.linear": ("adaln_proj.linear", _PLAIN),
diff --git a/vllm_omni/diffusion/models/minimax_h3/fasth3_checkpoint.py b/vllm_omni/diffusion/models/minimax_h3/fasth3_checkpoint.py
new file mode 100644
index 000000000..0382e9220
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/fasth3_checkpoint.py
@@ -0,0 +1,131 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Sampling contract for FastVideo FastH3 full checkpoints."""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from vllm_omni.diffusion.sched.sigma_schedule import DMD2SigmaSchedule
+from vllm_omni.errors import OmniClientError
+from vllm_omni.model_executor.model_loader.weight_utils import download_weights_from_hf_specific
+
+from .fasth3 import FASTH3_BASE_MODEL, _resolve_dit_attention_backend
+
+if TYPE_CHECKING:
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+FASTH3_V2_MODEL_ID = "FastVideo/FastVideo-FastH3-8-Step-V2"
+FASTH3_V2_BASE_SCHEDULE = DMD2SigmaSchedule.from_positions((0.999, 0.874, 0.749, 0.624, 0.5, 0.375, 0.25, 0.125, 0.0))
+
+
+@dataclass(frozen=True)
+class FastH3CheckpointSpec:
+    """The full V2 release has its own schedule and trained attention policy.
+
+    This is independent of ``FastH3WeightFusion``: the released weights already
+    contain the entire student, including its learned compression gates.
+    """
+
+    vsa_sparsity: float = 0.8
+
+    @classmethod
+    def from_metadata(cls, metadata: Mapping[str, object]) -> FastH3CheckpointSpec:
+        """Validate the release's own fastvideo_inference.json."""
+        required = {
+            "model_id": FASTH3_V2_MODEL_ID,
+            "schema_version": "fasth3-inference-contract-v1",
+            "dmd_denoising_steps": [999, 874, 749, 624, 500, 375, 250, 125],
+            "transformer_forwards": 8,
+            "video_scheduler_shift": 10.0,
+            "audio_scheduler_shift": 3.0,
+            "guidance_scale": 1.0,
+            "attention_backend": "VIDEO_SPARSE_ATTN_H3",
+            "vsa_sparsity": 0.8,
+            "vsa_tile_size": 64,
+            "task": "t2av",
+        }
+        for key, expected in required.items():
+            if metadata.get(key) != expected:
+                raise ValueError(f"unsupported FastH3 contract: {key}={metadata.get(key)!r}, expected {expected!r}")
+        return cls()
+
+    def release_metadata(self) -> dict[str, Any]:
+        """Express the sampling policy in the existing H3 pipeline schema."""
+        return {
+            "partition": "fl2va",
+            "tasks": ["t2va"],
+            "sigma_shift_scales": {"video": 10.0, "audio": 3.0},
+            "base_schedule": list(FASTH3_V2_BASE_SCHEDULE.base_schedule),
+        }
+
+    def resolve_native_vaes(self, model_root: Path) -> Path:
+        """Reuse the frozen base VAEs with Omni's native tiled/parallel runtime.
+
+        Only VAE components are fetched; the student and text encoder come
+        directly from the FastVideo release. The release pins the base revision.
+        """
+        provenance = json.loads((model_root / "provenance.json").read_text(encoding="utf-8"))
+        base = provenance.get("base_model", "")
+        prefix = f"hf://{FASTH3_BASE_MODEL}@"
+        if not isinstance(base, str) or not base.startswith(prefix) or not base[len(prefix) :]:
+            raise ValueError("FastH3 V2 provenance must pin a MiniMaxAI/MiniMax-H3 base revision")
+        return (
+            Path(
+                download_weights_from_hf_specific(
+                    model_name_or_path=FASTH3_BASE_MODEL,
+                    cache_dir=None,
+                    allow_patterns=["FL2VA/video_vae/**", "FL2VA/audio_vae/**"],
+                    revision=base[len(prefix) :],
+                    require_all=True,
+                )
+            )
+            / "FL2VA"
+        )
+
+    def check_serving_contract(self, *, partition: str, od_config: OmniDiffusionConfig) -> None:
+        if partition != "fl2va":
+            raise ValueError("FastH3 V2 requires --task-type fl2va (T2VA requests only)")
+        if getattr(od_config, "lora_path", None):
+            raise ValueError("FastH3 V2 is a full checkpoint; additional LoRA adapters are unsupported")
+        if _resolve_dit_attention_backend(od_config) != "FASTVIDEO_VSA":
+            raise ValueError("FastH3 V2 requires --diffusion-attention-backend FASTVIDEO_VSA")
+        attention_config = getattr(od_config, "diffusion_attention_config", None)
+        per_role = getattr(attention_config, "per_role", None) or {}
+        spec = per_role.get("self") or getattr(attention_config, "default", None)
+        if getattr(spec, "fastvideo_vsa_topk", None) is not None:
+            raise ValueError("FastH3 V2 pins VSA sparsity=0.8; remove the fixed fastvideo_vsa_topk override")
+        parallel = getattr(od_config, "parallel_config", None)
+        if any(int(getattr(parallel, key, 1) or 1) != 1 for key in ("ring_degree", "allgather_degree")):
+            raise ValueError("FastH3 V2 supports local attention or pure Ulysses sequence parallelism")
+
+    def check_request(self, sampling: OmniDiffusionSamplingParams, *, step_execution: bool = False) -> None:
+        if step_execution:
+            # StepScheduler admits requests before the pipeline hook runs and
+            # derives its lifetime from these fields.  The pinned schedule must
+            # therefore be explicit and cannot be overridden by custom arrays.
+            if sampling.num_inference_steps != FASTH3_V2_BASE_SCHEDULE.num_inference_steps:
+                raise OmniClientError("FastH3 V2 step execution requires num_inference_steps=8")
+            if sampling.timesteps is not None or sampling.sigmas is not None:
+                raise OmniClientError("FastH3 V2 step execution does not support custom timesteps or sigmas")
+        if sampling.lora_request is not None:
+            raise OmniClientError("FastH3 V2 does not support per-request LoRA adapters")
+        steps = sampling.num_inference_steps
+        if steps is not None and steps != FASTH3_V2_BASE_SCHEDULE.num_inference_steps:
+            raise OmniClientError("FastH3 V2 requires num_inference_steps=8 (nine sigma points), or omitted")
+        extra = sampling.extra_args or {}
+        for key, expected in (("flow_shift", 10.0), ("audio_flow_shift", 3.0)):
+            try:
+                value = float(extra.get(key, expected))
+            except (TypeError, ValueError) as exc:
+                raise OmniClientError(f"FastH3 V2 requires {key}={expected:g}") from exc
+            if not math.isclose(value, expected):
+                raise OmniClientError(f"FastH3 V2 requires {key}={expected:g}, got {value:g}")
+        if sampling.guidance_scale is not None and sampling.guidance_scale != 1.0:
+            raise OmniClientError("FastH3 V2 requires guidance_scale=1")
diff --git a/vllm_omni/diffusion/models/minimax_h3/latent_mask.py b/vllm_omni/diffusion/models/minimax_h3/latent_mask.py
new file mode 100644
index 000000000..cd740284c
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/latent_mask.py
@@ -0,0 +1,183 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""MiniMax H3 latent-edit mask parsing and sampler math."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import torch
+
+from .scheduling_minimax_h3_euler_ancestral import minimax_h3_rf_v_to_x0
+
+_MASK_LEVELS = 256.0
+
+
+def _quantize(mask: torch.Tensor) -> torch.Tensor:
+    """Match ComfyUI's token-grid mask used by H3's timestep embedding."""
+    return (torch.ceil(mask * _MASK_LEVELS) / _MASK_LEVELS).clamp_(0, 1)
+
+
+@dataclass(frozen=True)
+class MiniMaxH3ParsedMask:
+    """Token mask for the model and raw mask for the final x0 restore."""
+
+    model_mask_rows: torch.Tensor
+    restore_mask_rows: torch.Tensor
+
+
+def minimax_h3_video_edit_masks(
+    mask: torch.Tensor,
+    *,
+    latent_t: int,
+    latent_h: int,
+    latent_w: int,
+) -> MiniMaxH3ParsedMask:
+    """Map the canonical full-grid video mask to model and restore rows.
+
+    Full-grid masks are max-pooled over each 2x2 DiT token. Their raw four
+    cells are repeated in the packed 24-channel feature order for restoration.
+    """
+    latent_t, latent_h, latent_w = int(latent_t), int(latent_h), int(latent_w)
+    if latent_t <= 0 or latent_h <= 0 or latent_w <= 0 or latent_h % 2 or latent_w % 2:
+        raise ValueError("video latent dimensions must be positive and spatially even")
+
+    token_shape = (latent_t, latent_h // 2, latent_w // 2)
+    full_shape = (latent_t, latent_h, latent_w)
+    row_count = math.prod(token_shape)
+    if mask.dtype != torch.float32 or tuple(mask.shape) != full_shape or not mask.is_contiguous():
+        raise ValueError(f"canonical video mask must be contiguous FP32 with shape {full_shape}")
+    cells = mask.reshape(latent_t, latent_h // 2, 2, latent_w // 2, 2).permute(0, 1, 3, 2, 4).contiguous()
+    model = _quantize(cells.amax(dim=(3, 4)).reshape(-1))
+    restore = cells.unsqueeze(3).expand(*cells.shape[:3], 24, 2, 2).reshape(row_count, 96).clone()
+    return MiniMaxH3ParsedMask(model, restore)
+
+
+def minimax_h3_audio_edit_masks(mask: torch.Tensor, *, audio_t: int) -> MiniMaxH3ParsedMask:
+    """Flatten the canonical channel-major audio mask to H3 row order."""
+    audio_t = int(audio_t)
+    if audio_t <= 0:
+        raise ValueError("audio_t must be positive")
+    expected_shape = (2, audio_t)
+    if mask.dtype != torch.float32 or tuple(mask.shape) != expected_shape or not mask.is_contiguous():
+        raise ValueError(f"canonical audio mask must be contiguous FP32 with shape {expected_shape}")
+    rows = mask.reshape(-1).clone()
+    return MiniMaxH3ParsedMask(_quantize(rows), rows)
+
+
+@dataclass(frozen=True)
+class MiniMaxH3LatentEdit:
+    """Clean source, model anchor, and masks for one packed latent stream."""
+
+    clean_rows: torch.Tensor
+    anchor_rows: torch.Tensor
+    mask_rows: torch.Tensor
+    restore_mask_rows: torch.Tensor
+
+    @classmethod
+    def from_rows(
+        cls,
+        clean_rows: torch.Tensor,
+        anchor_rows: torch.Tensor,
+        mask_rows: torch.Tensor,
+        restore_mask_rows: torch.Tensor,
+    ) -> MiniMaxH3LatentEdit:
+        """Create an edit from already-validated encoder outputs.
+
+        Value validation and all-generate elision belong at the encoder input
+        boundary. This constructor only normalizes devices/dtypes and checks
+        the cheap row-shape invariants needed by the sampler math.
+        """
+        if clean_rows.ndim != 2 or anchor_rows.shape != clean_rows.shape:
+            raise ValueError("clean_rows and anchor_rows must have matching [rows, width] shape")
+        raw_mask = torch.as_tensor(mask_rows, dtype=torch.float32, device=clean_rows.device)
+        if raw_mask.ndim != 1 or raw_mask.numel() != clean_rows.shape[0]:
+            raise ValueError(f"mask_rows must have shape ({clean_rows.shape[0]},)")
+        restore = torch.as_tensor(restore_mask_rows, dtype=torch.float32, device=clean_rows.device)
+        valid_restore = restore.ndim == 1 and restore.shape == raw_mask.shape
+        valid_restore |= restore.ndim == 2 and tuple(restore.shape) in {
+            (clean_rows.shape[0], 1),
+            tuple(clean_rows.shape),
+        }
+        if not valid_restore:
+            raise ValueError("restore_mask_rows must have one scalar or one feature row per clean row")
+        return cls(clean_rows, anchor_rows, raw_mask, restore)
+
+    def to(self, *, device: torch.device, dtype: torch.dtype = torch.float32) -> MiniMaxH3LatentEdit:
+        return MiniMaxH3LatentEdit(
+            self.clean_rows.to(device=device, dtype=dtype),
+            self.anchor_rows.to(device=device, dtype=dtype),
+            self.mask_rows.to(device=device),
+            self.restore_mask_rows.to(device=device),
+        )
+
+    def model_rows(self, state_rows: torch.Tensor) -> torch.Tensor:
+        return torch.lerp(self.anchor_rows, state_rows, self.mask_rows.to(state_rows.dtype).unsqueeze(-1))
+
+    def target_timesteps(
+        self,
+        timestep: float,
+        condition_timestep: float,
+        *,
+        sigma: float | None = None,
+    ) -> torch.Tensor:
+        sigma = 1.0 - timestep if sigma is None else float(sigma)
+        return torch.clamp(1.0 - self.mask_rows * sigma, max=condition_timestep)
+
+    def prepare(
+        self,
+        state_rows: torch.Tensor,
+        timestep: float,
+        condition_timestep: float,
+        *,
+        sigma: float,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Prepare the model rows and per-row timesteps for one denoise step."""
+        return (
+            self.model_rows(state_rows),
+            self.target_timesteps(timestep, condition_timestep, sigma=sigma),
+        )
+
+    def x0(self, model_rows: torch.Tensor, velocity: torch.Tensor, timestep: float) -> torch.Tensor:
+        weight = self.mask_rows.to(model_rows.dtype).unsqueeze(-1)
+        predicted = minimax_h3_rf_v_to_x0(
+            model_rows,
+            velocity.to(model_rows.dtype) * weight,
+            torch.tensor(float(timestep), dtype=model_rows.dtype, device=model_rows.device),
+        )
+        restore = self.restore_mask_rows.to(model_rows.dtype)
+        if restore.ndim == 1:
+            restore = restore.unsqueeze(-1)
+        return torch.lerp(self.clean_rows, predicted, restore)
+
+
+def minimax_h3_prepare_edit_rows(
+    rows: torch.Tensor,
+    update_mask: torch.Tensor,
+    edit: MiniMaxH3LatentEdit | None,
+    timestep: float,
+    condition_timestep: float,
+    *,
+    sigma: float,
+) -> tuple[torch.Tensor, torch.Tensor | None]:
+    """Build one model input view without mutating the persistent sampler rows."""
+    if edit is None:
+        return rows, None
+    model_rows = rows.clone()
+    model_rows[update_mask], target_timesteps = edit.prepare(
+        rows[update_mask],
+        timestep,
+        condition_timestep,
+        sigma=sigma,
+    )
+    return model_rows, target_timesteps
+
+
+__all__ = [
+    "MiniMaxH3LatentEdit",
+    "MiniMaxH3ParsedMask",
+    "minimax_h3_audio_edit_masks",
+    "minimax_h3_prepare_edit_rows",
+    "minimax_h3_video_edit_masks",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py b/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
index e26493931..5662a9641 100644
--- a/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
+++ b/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
@@ -55,6 +55,8 @@ from vllm_omni.diffusion.layers.rope import RotaryEmbedding
 from vllm_omni.diffusion.models.host_weight_contract import FinalLayoutModelContract
 from vllm_omni.platforms import current_omni_platform
 
+from .fasth3 import _resolve_native_target
+
 if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization.base_config import (
         QuantizationConfig,
@@ -118,6 +120,18 @@ class MiniMaxH3DiTArchConfig:
 
     @classmethod
     def from_mapping(cls, config: Mapping[str, Any]) -> MiniMaxH3DiTArchConfig:
+        # The modular Diffusers checkpoint uses these spellings for the same
+        # architecture. Normalize before constructing the existing native DiT.
+        aliases = {
+            "num_refiner_layers": "token_refiner_num_layers",
+            "ffn_dim": "ffn_hidden_size",
+            "in_channels": "latents_dim",
+            "audio_in_channels": "audio_latents_dim",
+            "freq_dim": "timestep_input_dim",
+            "time_embed_hidden_dim": "time_embed_hidden_size",
+            "rope_freq_dim": "rope_inv_freq_len",
+        }
+        config = {aliases.get(name, name): value for name, value in config.items()}
         fields = cls.__dataclass_fields__
         values = {name: config[name] for name in fields if name in config}
         if "patch_size" in values:
@@ -394,6 +408,9 @@ def _sdpa_varlen_attention(
 
 
 class MiniMaxH3Attention(nn.Module):
+    # Full sparse checkpoints pin a ratio; legacy adapters use backend top-k.
+    vsa_sparsity: float | None = None
+
     def __init__(
         self,
         arch: MiniMaxH3DiTArchConfig,
@@ -588,6 +605,7 @@ class MiniMaxH3Attention(nn.Module):
                 # (see MINIMAX_H3_LASER_INPUT_SCALE). Ignored by every other
                 # backend/path.
                 "laser_input_scale": MINIMAX_H3_LASER_INPUT_SCALE,
+                **({"vsa_h3_sparsity": self.vsa_sparsity} if self.vsa_sparsity is not None else {}),
                 # Present only for a VSA artifact; the VSA backend reads it as
                 # the learned compression gate and every other backend ignores it.
                 **({"gate_compress": gate_compress.unsqueeze(0)} if gate_compress is not None else {}),
@@ -1127,10 +1145,23 @@ class MiniMaxH3DiTModel(nn.Module):
         self,
         od_config: OmniDiffusionConfig,
         quant_config: QuantizationConfig | None = None,
+        *,
+        diffusers_weights: bool | None = None,
     ) -> None:
         super().__init__()
         tf_config = od_config.tf_model_config
         config_mapping = tf_config.to_dict() if hasattr(tf_config, "to_dict") else dict(tf_config)
+        # The native MiniMax-H3 Hub snapshot advertises the Diffusers
+        # transformer class in its root config, while its FL2VA/Ref2VA
+        # components still contain native weights.  The pipeline has already
+        # resolved the actual source format, so let it override the
+        # class-name heuristic.  Keep the heuristic for standalone callers.
+        self._diffusers_weights = (
+            config_mapping.get("_class_name") == "MiniMaxH3Transformer3DModel"
+            if diffusers_weights is None
+            else diffusers_weights
+        )
+        self._rope_theta = float(config_mapping.get("rope_theta", 10000.0))
         arch = MiniMaxH3DiTArchConfig.from_mapping(config_mapping)
         self.arch = arch
         self.od_config = od_config
@@ -1211,7 +1242,7 @@ class MiniMaxH3DiTModel(nn.Module):
         )
         self._mark_missing_params_required()
 
-    def enable_vsa_gates(self) -> None:
+    def enable_vsa_gates(self, *, sparsity: float | None = None) -> None:
         """Give every DiT block's attention a VSA compression gate.
 
         A FastH3 VSA artifact assigns these projections rather than adding to
@@ -1223,6 +1254,9 @@ class MiniMaxH3DiTModel(nn.Module):
             return
         for block in self.blocks:
             block.attn.enable_vsa_gate()
+            block.attn.vsa_sparsity = sparsity
+            if sparsity is not None:
+                block.attn.to_gate_compress.weight.missing_param_init = "error"
         self.vsa_gates_enabled = True
 
     def _mark_missing_params_required(self) -> None:
@@ -1293,17 +1327,37 @@ class MiniMaxH3DiTModel(nn.Module):
         self,
         weights: Iterable[tuple[str, torch.Tensor]],
     ) -> set[str]:
-        """Load exact H3 checkpoint names with logical TP-aware loaders."""
+        """Load native or Diffusers H3 weights with the existing TP-aware loaders."""
         params = dict(self.named_parameters())
         params.update(dict(self.named_buffers()))
         loaded: set[str] = set()
+        diffusers_weights = getattr(self, "_diffusers_weights", False)
+        qkv_parts: dict[str, set[str]] = {}
+        source_names: set[str] = set()
         for name, loaded_weight in weights:
+            layout = "plain"
+            if diffusers_weights:
+                if name in source_names:
+                    raise ValueError(f"duplicate Diffusers H3 weight: {name}")
+                source_names.add(name)
+                module, _, kind = name.rpartition(".")
+                target = _resolve_native_target(module)
+                if target is None or kind not in {"weight", "bias"}:
+                    raise ValueError(f"unsupported Diffusers H3 weight: {name}")
+                name, layout = f"{target[0]}.{kind}", target[1]
             param = params.get(name)
             if param is None:
+                if diffusers_weights:
+                    raise ValueError(f"Diffusers H3 weight has no model parameter: {name}")
                 logger.warning("Skipping MiniMax H3 weight not present in model: %s", name)
                 continue
             weight_loader = getattr(param, "weight_loader", default_weight_loader)
-            if name.endswith(".attn.qkv_proj.weight"):
+            if layout in {"q", "k", "v"}:
+                # vLLM can load each projection directly into its packed QKV
+                # parameter, including TP slicing and online quantization.
+                weight_loader(param, loaded_weight, layout)
+                qkv_parts.setdefault(name, set()).add(layout)
+            elif name.endswith(".attn.qkv_proj.weight"):
                 # Transform checkpoint layout before entering vLLM's loader so
                 # online FP8 can keep ``online_process_loader`` outermost.
                 loaded_weight = _reorder_grouped_qkv_to_qkv(
@@ -1319,12 +1373,26 @@ class MiniMaxH3DiTModel(nn.Module):
                         "MiniMax H3 fc1 checkpoint rows must split evenly into "
                         f"gate/up matrices, got {tuple(loaded_weight.shape)}"
                     )
-                gate, up = loaded_weight.chunk(2, dim=0)
+                first, second = loaded_weight.chunk(2, dim=0)
+                gate, up = (second, first) if layout == "swap_halves" else (first, second)
                 weight_loader(param, gate, 0)
                 weight_loader(param, up, 1)
             else:
                 weight_loader(param, loaded_weight)
             loaded.add(name)
+        if diffusers_weights:
+            for name, parts in qkv_parts.items():
+                if parts != {"q", "k", "v"}:
+                    raise ValueError(f"incomplete Diffusers H3 QKV group {name}: {sorted(parts)}")
+            # Diffusers reconstructs RoPE from config instead of storing this
+            # native checkpoint buffer. Compute on CPU for identical values.
+            freq_dim = self.arch.rope_inv_freq_len
+            rope = 1.0 / (
+                self._rope_theta
+                ** (torch.arange(0, 2 * freq_dim, 2, dtype=torch.float32, device="cpu") / (2 * freq_dim))
+            )
+            default_weight_loader(params["rope.inv_freq"], rope)
+            loaded.add("rope.inv_freq")
         return loaded
 
     @staticmethod
diff --git a/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py b/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
index ecf797a9c..49ad496b4 100644
--- a/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
+++ b/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
@@ -14,6 +14,7 @@ Builder rules:
 
 from __future__ import annotations
 
+import math
 from collections.abc import Mapping, Sequence
 
 import numpy as np
@@ -345,6 +346,8 @@ def minimax_h3_packed_sequence_ref2va_blocks(
     ref_blocks: Sequence[Mapping[str, object]],
     audio_channel: int = 2,
     seq_len: int | None = None,
+    temporal_offset: float = 0.0,
+    media_time_origin: int | None = None,
 ) -> dict[str, object]:
     """General ref2va-family packed layout.
 
@@ -353,12 +356,22 @@ def minimax_h3_packed_sequence_ref2va_blocks(
     - ``{"kind": "audio", "ref_audio_t": T}``
     - ``{"kind": "video"|"video_audio", "ref_audio_t": T,
        "latent_t": RT, "latent_h": RH, "latent_w": RW}``
+    - Internal ``latent_guide``: a final AV condition block on the target's
+      spatial grid and temporal origin, without advancing the reference clock.
 
     Video-bearing blocks pack their audio rows immediately before their video
     rows; both share the same temporal origin and advance by the longer of the
     audio and video spans. Standalone audio advances the target origin by its
     own T, and image blocks advance it by one integer slot.
+
+    ``temporal_offset`` is the window origin in 40-Hz RoPE units. It shifts
+    target AV, reference AV and latent guides together, leaving text, static
+    images, padding and all spatial coordinates unchanged.
     """
+    if not math.isfinite(temporal_offset) or temporal_offset < 0:
+        raise ValueError("temporal_offset must be finite and non-negative")
+    if media_time_origin is not None and media_time_origin < text_len:
+        raise ValueError("media_time_origin must follow the text prefix")
     if not isinstance(ref_blocks, Sequence) or isinstance(ref_blocks, (str, bytes)):
         raise ValueError("ref_blocks must be a sequence")
 
@@ -383,11 +396,15 @@ def minimax_h3_packed_sequence_ref2va_blocks(
             rows = rt * audio_channel
             item = {"kind": kind, "ref_audio_t": rt, "audio_rows": rows}
             ref_audio_rows += rows
-        elif kind in ("video", "video_audio"):
+        elif kind in ("video", "video_audio", "latent_guide"):
             rt = _positive_int(raw, "ref_audio_t", path, allow_zero=True)
             vt = _positive_int(raw, "latent_t", path)
             vh = _positive_int(raw, "latent_h", path)
             vw = _positive_int(raw, "latent_w", path)
+            if kind == "latent_guide" and (
+                index != len(ref_blocks) - 1 or (vh, vw) != (latent_h, latent_w) or vt > latent_t or rt > audio_t
+            ):
+                raise ValueError("latent_guide must be last, match the target canvas, and fit its AV lengths")
             frame_rows = (vh // _PATCH_H) * (vw // _PATCH_W)
             audio_rows = rt * audio_channel
             video_rows = vt * frame_rows
@@ -447,7 +464,7 @@ def minimax_h3_packed_sequence_ref2va_blocks(
     # device-to-host synchronization.
     video_spans: list[dict[str, object]] = []
     for item in block_slices:
-        if item["kind"] in ("video", "video_audio"):
+        if item["kind"] in ("video", "video_audio", "latent_guide"):
             visual_sl = item["visual_sl"]
             assert isinstance(visual_sl, slice)
             video_spans.append(
@@ -485,7 +502,7 @@ def minimax_h3_packed_sequence_ref2va_blocks(
     hh, ww = torch.meshgrid(h_grid, w_grid, indexing="ij")
     target_frame = torch.stack([hh.reshape(-1), ww.reshape(-1)], dim=-1)
 
-    t_cursor = float(text_len)
+    t_cursor = float(text_len if media_time_origin is None else media_time_origin)
     for item in block_slices:
         kind = str(item["kind"])
         if kind == "image":
@@ -567,7 +584,8 @@ def minimax_h3_packed_sequence_ref2va_blocks(
             rv_g[:, :, 0] = _video_t_grid(vt, t_cursor)[:, None]
             rv_g[:, :, 1:] = rv_frame[None]
             g[visual_sl] = rv_g.reshape(-1, 3)
-            t_cursor += max(float(ref_t), _video_t_span(vt))
+            if kind != "latent_guide":
+                t_cursor += max(float(ref_t), _video_t_span(vt))
 
     input_ids[audio_sl] = MINIMAX_H3_AUDIO_ID
     input_ids[audio_sl.start] = MINIMAX_H3_AUDIO_FIRST_ID
@@ -591,6 +609,13 @@ def minimax_h3_packed_sequence_ref2va_blocks(
     video_g[:, :, 1:] = target_frame[None]
     g[video_sl] = video_g.reshape(-1, 3)
 
+    if temporal_offset:
+        g[audio_mask, 0] += temporal_offset
+        g[video_sl, 0] += temporal_offset
+        for item in block_slices:
+            if item["kind"] in ("video", "video_audio", "latent_guide"):
+                g[item["visual_sl"], 0] += temporal_offset
+
     target_img_pos = _range_for_slice(video_sl)
     target_audio_pos = _range_for_slice(audio_sl)
     img_pos = _cat_ranges(ref_img_pos_parts + [target_img_pos])
diff --git a/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
index 1b8bd7fea..8fc1514ef 100644
--- a/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
+++ b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
@@ -8,7 +8,7 @@ import json
 import math
 import os
 from collections.abc import Iterable, Mapping, Sequence
-from contextlib import contextmanager
+from contextlib import contextmanager, nullcontext
 from dataclasses import fields, replace
 from itertools import groupby
 from pathlib import Path
@@ -67,6 +67,7 @@ from vllm_omni.model_executor.model_loader.weight_utils import (
     download_weights_from_hf_specific,
 )
 from vllm_omni.model_executor.models.minimax_h3.checkpoint import (
+    is_minimax_h3_modular,
     resolve_minimax_h3_partition,
 )
 from vllm_omni.model_executor.models.minimax_h3.conditioning import (
@@ -80,6 +81,7 @@ from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
     encode_media,
     prepare_encoder_inputs,
 )
+from vllm_omni.model_executor.models.minimax_h3.long_video import validate_encoded_frame_limit
 from vllm_omni.model_executor.models.minimax_h3.preprocessing import build_minimax_h3_presentation
 from vllm_omni.model_executor.models.minimax_h3.reference_video import (
     MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY,
@@ -98,6 +100,7 @@ from .condition_noise import (
     minimax_h3_audio_cond_noise_aug_rows,
     minimax_h3_imgvid_cond_noise_aug_rows,
 )
+from .continuation import diffuse_continuation, plan_continuation_windows, resolve_continuation
 from .denoise_loop import (
     MiniMaxH3DenoiseBranch,
     minimax_h3_denoise_loop,
@@ -106,6 +109,13 @@ from .denoise_loop import (
 )
 from .encoder import MiniMaxH3Qwen3VLEncoder
 from .fasth3 import FastH3WeightFusion, resolve_fasth3_fusion
+from .fasth3_checkpoint import FastH3CheckpointSpec
+from .latent_mask import (
+    MiniMaxH3LatentEdit,
+    minimax_h3_audio_edit_masks,
+    minimax_h3_prepare_edit_rows,
+    minimax_h3_video_edit_masks,
+)
 from .lora import TurboSpec, load_minimax_h3_turbo_lora
 from .minimax_h3_transformer import (
     MiniMaxH3Attention,
@@ -136,9 +146,11 @@ from .time_request import (
     MINIMAX_H3_SHAPE_PLANNER,
     minimax_h3_time_shift_sigmas,
 )
-from .vae import MiniMaxH3AudioVAE, MiniMaxH3VideoVAE
+from .vae import MiniMaxH3AudioVAE, MiniMaxH3VideoVAE, _VideoVAEPartProxy
 
 if TYPE_CHECKING:
+    from PIL import Image
+
     from vllm_omni.diffusion.worker.input_batch import InputBatch
     from vllm_omni.diffusion.worker.utils import StepRequestState
 
@@ -213,7 +225,11 @@ def _resolve_minimax_h3_model_root(
         if path.name in {"FL2VA", "Ref2VA"}:
             return path.parent
         return path
-    if load_text_encoder:
+    if is_minimax_h3_modular(model, revision):
+        allow_patterns = ["modular_model_index.json", "fastvideo_inference.json", "provenance.json", "transformer/**"]
+        if load_text_encoder:
+            allow_patterns += ["text_encoder/**", "tokenizer/**", "processor/**"]
+    elif load_text_encoder:
         allow_patterns = (
             MINIMAX_H3_DOWNLOAD_PATTERNS if partition == "combined" else MINIMAX_H3_TASK_DOWNLOAD_PATTERNS[partition]
         )
@@ -253,6 +269,13 @@ _MINIMAX_H3_DENOISE_INPUT_KEYS = (
     "audio_condition_lengths",
     "keyframe_frame_indices",
     "pad_seq_len",
+    "locked_audio_rows",
+    "video_edit_clean_rows",
+    "video_edit_mask_rows",
+    "video_edit_restore_mask_rows",
+    "audio_edit_clean_rows",
+    "audio_edit_mask_rows",
+    "audio_edit_restore_mask_rows",
 )
 
 # ``StepRequestState.extra`` keys owned by the step-execution path.
@@ -265,6 +288,8 @@ _STEP_COND_ANCHOR = "minimax_h3_cond_anchor"
 _STEP_AUDIO_ANCHOR = "minimax_h3_audio_anchor"
 _STEP_SHAPE = "minimax_h3_shape"
 _STEP_TRANSFORMER = "minimax_h3_transformer"
+_STEP_VIDEO_EDIT = "minimax_h3_video_edit"
+_STEP_AUDIO_EDIT = "minimax_h3_audio_edit"
 
 
 def _minimax_h3_step_schedule(state: StepRequestState) -> dict[str, float]:
@@ -314,6 +339,8 @@ def resolve_minimax_h3_diffusion_model_path(
         partition,
         load_text_encoder=False,
     )
+    if is_minimax_h3_modular(str(model_root), revision):
+        return str(model_root)
     if partition == "combined":
         return str(model_root)
     subdir = "Ref2VA" if partition == "ref2va" else "FL2VA"
@@ -368,12 +395,20 @@ def _minimax_h3_post_process(output, output_type: str = "np"):
 
 def _prepare_minimax_h3_video_output(video: torch.Tensor) -> torch.Tensor:
     """Quantize decoded frames in place before worker-to-engine transfer."""
-    video = video.detach().float()
+    video = video.detach()
+    if video.dtype == torch.uint8:
+        # Streaming decode already quantized and clamped; only the transfer
+        # layout remains.
+        return video.permute(0, 2, 3, 4, 1).contiguous()
+    video = video.float()
     video.clamp_(0, 1).mul_(255).round_()
-    return video.permute(0, 2, 3, 4, 1).to(
-        dtype=torch.uint8,
-        memory_format=torch.contiguous_format,
-    )
+    permuted = video.permute(0, 2, 3, 4, 1)
+    out = torch.empty(permuted.shape, dtype=torch.uint8, device=video.device)
+    # copy_ fuses the layout change and the cast into one kernel;
+    # ``.to(dtype=uint8, memory_format=contiguous_format)`` materializes a
+    # contiguous FP32 intermediate first (~4.2GB for a 15s clip).
+    out.copy_(permuted)
+    return out
 
 
 def _register_dlo_component_cache(cache: BoundedAllocatorCache, *components: Any) -> None:
@@ -389,6 +424,27 @@ def get_minimax_h3_post_process_func(
     return _minimax_h3_post_process
 
 
+def _expose_padded_audio_tail(
+    source_audio_t: int,
+    *,
+    target_audio_t: int,
+    mask_rows: torch.Tensor,
+    restore_mask_rows: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Mark the encoder-padded audio tail for generation."""
+    if not 0 < source_audio_t <= target_audio_t:
+        raise ValueError(f"source_audio_t must be in [1, {target_audio_t}]")
+    expected_shape = (2 * target_audio_t,)
+    if tuple(mask_rows.shape) != expected_shape or tuple(restore_mask_rows.shape) != expected_shape:
+        raise ValueError(f"audio edit masks must have shape {expected_shape}")
+    model_mask = mask_rows.reshape(2, target_audio_t).clone()
+    restore_mask = restore_mask_rows.reshape(2, target_audio_t).clone()
+    if source_audio_t < target_audio_t:
+        model_mask[:, source_audio_t:] = 1.0
+        restore_mask[:, source_audio_t:] = 1.0
+    return model_mask.reshape(-1), restore_mask.reshape(-1)
+
+
 def _resolve_minimax_h3_num_outputs(value: Any) -> int:
     if value is None:
         return 1
@@ -575,6 +631,7 @@ class MiniMaxH3Pipeline(
     _base_schedule_by_partition: ClassVar[Mapping[str, DMD2SigmaSchedule | None]] = {}
     # Set from --lora-path during construction; absent means no FastH3 adapter.
     _fasth3: FastH3WeightFusion | None = None
+    _fasth3_checkpoint: FastH3CheckpointSpec | None = None
 
     def _load_diffusion_lora_adapter(
         self,
@@ -800,10 +857,13 @@ class MiniMaxH3Pipeline(
             self._PROFILER_TARGETS.remove("encode_prompt")
         if not self.load_vae_encoder:
             self._PROFILER_TARGETS.remove("_encode_local_media")
+        modular = is_minimax_h3_modular(str(od_config.model), od_config.revision)
         self.partition = _minimax_h3_partition_for_task(
             getattr(od_config, "task_type", None),
             str(od_config.model),
         )
+        if modular and str(od_config.task_type or "auto").lower() == "auto":
+            self.partition = "fl2va"
         self._turbo_lora_specs: dict[int, TurboSpec] = {}
         self._native_lora_adapter_ids: set[int] = set()
         self._lora_sigma_schedules: dict[int, DMD2SigmaSchedule] = {}
@@ -813,9 +873,19 @@ class MiniMaxH3Pipeline(
             self.partition,
             load_text_encoder=self.load_text_encoder,
         )
-        model_path = model_root / ("Ref2VA" if self.partition == "ref2va" else "FL2VA")
-        model_index = json.loads((model_path / "model_index.json").read_text(encoding="utf-8"))
-        release = model_index.get("_minimax_h3") or {}
+        if modular:
+            model_path = model_root
+            self._fasth3_checkpoint = FastH3CheckpointSpec.from_metadata(
+                json.loads((model_root / "fastvideo_inference.json").read_text(encoding="utf-8"))
+            )
+            self._fasth3_checkpoint.check_serving_contract(partition=self.partition, od_config=od_config)
+            release = self._fasth3_checkpoint.release_metadata()
+            vae_model_path = self._fasth3_checkpoint.resolve_native_vaes(model_root)
+        else:
+            model_path = model_root / ("Ref2VA" if self.partition == "ref2va" else "FL2VA")
+            model_index = json.loads((model_path / "model_index.json").read_text(encoding="utf-8"))
+            release = model_index.get("_minimax_h3") or {}
+            vae_model_path = model_path
         partition = str(release.get("partition", "")).lower()
         expected_partition = "ref2va" if self.partition == "ref2va" else "fl2va"
         if partition != expected_partition:
@@ -876,11 +946,18 @@ class MiniMaxH3Pipeline(
         self.transformer = MiniMaxH3DiTModel(
             od_config,
             quant_config=transformer_quant_config,
+            diffusers_weights=modular,
         )
+        if self._fasth3_checkpoint is not None:
+            self.transformer.enable_vsa_gates(sparsity=self._fasth3_checkpoint.vsa_sparsity)
+            logger.info(
+                "FastH3 V2 full checkpoint: 8 transformer forwards, video/audio shifts 10/3, VSA sparsity=0.8 tile=64"
+            )
         if ref2va_model_path is not None:
             self.transformers_ref = MiniMaxH3DiTModel(
                 od_config,
                 quant_config=transformer_quant_config,
+                diffusers_weights=modular,
             )
 
         self._fasth3 = resolve_fasth3_fusion(od_config, self.transformer)
@@ -963,14 +1040,14 @@ class MiniMaxH3Pipeline(
         # so VAEs stay resident for new configurations.
         component_load_device = torch.device("cpu") if legacy_manual_components else self.device
         self.video_vae = MiniMaxH3VideoVAE(
-            os.path.join(model_path, "video_vae"),
+            os.path.join(vae_model_path, "video_vae"),
             device=self.device,
             load_device=component_load_device,
             decode_only=not self.load_vae_encoder,
             trust_remote_code=od_config.trust_remote_code,
         )
         self.audio_vae = MiniMaxH3AudioVAE(
-            os.path.join(model_path, "audio_vae"),
+            os.path.join(vae_model_path, "audio_vae"),
             device=self.device,
             load_device=component_load_device,
             decode_only=not self.load_vae_encoder,
@@ -1046,6 +1123,12 @@ class MiniMaxH3Pipeline(
             # load_weights only warns on a parameter the model does not have, so
             # close the adapter against what the DiT actually consumed.
             self._fasth3.validate_fully_applied(transformer_loaded)
+        if self._fasth3_checkpoint is not None:
+            required_gates = {
+                f"blocks.{i}.attn.to_gate_compress.weight" for i in range(self.transformer.arch.num_layers)
+            }
+            if missing_gates := required_gates - transformer_loaded:
+                raise ValueError(f"FastH3 V2 checkpoint is missing compression gates: {sorted(missing_gates)}")
         return loaded_with_prefix
 
     @property
@@ -1097,6 +1180,7 @@ class MiniMaxH3Pipeline(
         requested: str | None,
         multi_modal_data: dict[str, Any] | None = None,
         *,
+        audio_mode: str = "native",
         turbo_spec: TurboSpec | None = None,
         has_native_lora: bool = False,
     ) -> str:
@@ -1106,7 +1190,9 @@ class MiniMaxH3Pipeline(
             # historical implicit default even for image-only references.
             if self.partition == "ref2va":
                 requested = "ref2va"
-            elif multi_modal_data.get("video") is not None or multi_modal_data.get("audio") is not None:
+            elif multi_modal_data.get("video") is not None or (
+                multi_modal_data.get("audio") is not None and audio_mode != "lock_source"
+            ):
                 requested = "ref2va"
             elif multi_modal_data.get("image") is not None:
                 requested = "fl2va"
@@ -1307,6 +1393,15 @@ class MiniMaxH3Pipeline(
     @contextmanager
     def _component_on_device(self, component: nn.Module):
         if getattr(self, "_model_cpu_offload_modules", None):
+            # Sequential offload hooks whole modules (enable_omni_model_cpu_offload
+            # registers them on the discovered components, e.g. the real
+            # video_vae). Split-residency proxies carry no hook, so unwrap to the
+            # hooked module before entering the context — whole-module movement
+            # has no half-residency benefit anyway. The check is a type check, not
+            # getattr: Mock components auto-create any attribute, which would
+            # unwrap them to a child mock and break scope tracking.
+            if isinstance(component, _VideoVAEPartProxy):
+                component = component.sequential_offload_target
             with sequential_offload_component(component):
                 yield
             return
@@ -1346,6 +1441,50 @@ class MiniMaxH3Pipeline(
         """Whether this rank's output is returned by the diffusion executor."""
         return not dist.is_available() or not dist.is_initialized() or dist.get_rank() == 0
 
+    def _encode_visual_conditions(
+        self,
+        images: list[Image.Image],
+        prepared_videos: list[dict[str, Any]] | None,
+        *,
+        video_count: int,
+    ) -> tuple[torch.Tensor | None, list[tuple[int, int, int]]]:
+        rows: list[torch.Tensor] = []
+        shapes: list[tuple[int, int, int]] = []
+        _, rank, _ = _dit_rank_world()
+        # Keep image and video references in one residency window when both
+        # appear in a request; otherwise the video branch would reload the VAE.
+        # Encoding touches only the CNN encoder half, so the 9GB ViT decoder
+        # stays off the device for the whole window.
+        needs_video_vae = video_count > 0 or (rank == 0 and bool(images))
+        video_vae_context = (
+            self._component_on_device(self.video_vae.encoder_component) if needs_video_vae else nullcontext()
+        )
+        with video_vae_context:
+            if images:
+                image_rows = None
+                if rank == 0:
+                    image_rows = torch.cat([self.video_vae.encode_image(image) for image in images])
+                rows.append(
+                    _broadcast_tensor(
+                        image_rows,
+                        dtype=torch.float32,
+                        device=self.device,
+                    )
+                )
+                shapes.extend((1, image.height // 16, image.width // 16) for image in images)
+            if video_count:
+                video_rows, video_shapes = self._encode_video_conditions_resident(
+                    prepared_videos,
+                    count=video_count,
+                )
+                rows.append(video_rows)
+                shapes.extend(video_shapes)
+        # The latents are extracted; the encode's input/staging pages are idle
+        # and must not stay mapped through the denoise and decode peaks.
+        if needs_video_vae:
+            self._release_stage_cache()
+        return (torch.cat(rows) if rows else None), shapes
+
     def _offload_model_cpu_stage_output(self, tensor: torch.Tensor) -> torch.Tensor:
         """Release a decoded output's storage before a later seed reloads the DiT.
 
@@ -1434,6 +1573,15 @@ class MiniMaxH3Pipeline(
         audio_condition_lengths: list[int] | None = None,
         keyframe_frame_indices: list[int] | None = None,
         pad_seq_len: int | None = None,
+        locked_audio_rows: torch.Tensor | None = None,
+        temporal_offset: float = 0.0,
+        media_time_origin: int | None = None,
+        video_edit_clean_rows: torch.Tensor | None = None,
+        video_edit_mask_rows: torch.Tensor | None = None,
+        video_edit_restore_mask_rows: torch.Tensor | None = None,
+        audio_edit_clean_rows: torch.Tensor | None = None,
+        audio_edit_mask_rows: torch.Tensor | None = None,
+        audio_edit_restore_mask_rows: torch.Tensor | None = None,
     ) -> dict[str, Any]:
         """Build the packed layout, initial rows, anchors, and sigma schedules.
 
@@ -1464,6 +1612,8 @@ class MiniMaxH3Pipeline(
                 audio_t=audio_t,
                 ref_blocks=ref_blocks,
                 seq_len=pad_seq_len,
+                temporal_offset=temporal_offset,
+                media_time_origin=media_time_origin,
             )
         else:
             packed = minimax_h3_packed_sequence(
@@ -1521,6 +1671,13 @@ class MiniMaxH3Pipeline(
             full_video[branch.update_mask] = initial_video
             initial_video = full_video
 
+        if locked_audio_rows is not None:
+            expected = (2 * audio_t, 32)
+            if tuple(locked_audio_rows.shape) != expected:
+                raise OmniClientError(f"MiniMax H3 driving audio rows must have shape {expected}")
+            branch.locked_audio_rows = locked_audio_rows.to(device=self.device, dtype=torch.float32)
+            initial_audio = branch.locked_audio_rows.cpu().clone()
+
         audio_anchor = audio_condition
         if audio_anchor is not None:
             condition_audio_t = audio_condition_lengths
@@ -1542,6 +1699,41 @@ class MiniMaxH3Pipeline(
             full_audio[branch.audio_update_mask] = initial_audio
             initial_audio = full_audio
 
+        video_edit = None
+        video_edit_values = (video_edit_clean_rows, video_edit_mask_rows, video_edit_restore_mask_rows)
+        if any(value is None for value in video_edit_values) and any(value is not None for value in video_edit_values):
+            raise ValueError("video edit clean, model-mask, and restore-mask rows must be provided together")
+        if (
+            video_edit_clean_rows is not None
+            and video_edit_mask_rows is not None
+            and video_edit_restore_mask_rows is not None
+        ):
+            target_noise = initial_video[branch.update_mask].to(device=self.device, dtype=torch.float32)
+            clean = video_edit_clean_rows.to(device=self.device, dtype=torch.float32)
+            video_edit = MiniMaxH3LatentEdit.from_rows(
+                clean,
+                MINIMAX_H3_IMGVID_COND_TIMESTEP * clean + (1.0 - MINIMAX_H3_IMGVID_COND_TIMESTEP) * target_noise,
+                video_edit_mask_rows,
+                video_edit_restore_mask_rows,
+            )
+
+        audio_edit = None
+        audio_edit_values = (audio_edit_clean_rows, audio_edit_mask_rows, audio_edit_restore_mask_rows)
+        if any(value is None for value in audio_edit_values) and any(value is not None for value in audio_edit_values):
+            raise ValueError("audio edit clean, model-mask, and restore-mask rows must be provided together")
+        if (
+            audio_edit_clean_rows is not None
+            and audio_edit_mask_rows is not None
+            and audio_edit_restore_mask_rows is not None
+        ):
+            clean = audio_edit_clean_rows.to(device=self.device, dtype=torch.float32)
+            audio_edit = MiniMaxH3LatentEdit.from_rows(
+                clean,
+                clean,
+                audio_edit_mask_rows,
+                audio_edit_restore_mask_rows,
+            )
+
         video_sigmas = minimax_h3_time_shift_sigmas(
             num_steps=num_steps,
             shift_scale=video_shift,
@@ -1566,6 +1758,8 @@ class MiniMaxH3Pipeline(
             ),
             "sigmas_video": video_sigmas,
             "sigmas_audio": audio_sigmas,
+            "video_edit": video_edit,
+            "audio_edit": audio_edit,
         }
 
     def _unpack_denoised_rows(
@@ -1624,6 +1818,15 @@ class MiniMaxH3Pipeline(
         audio_condition_lengths: list[int] | None = None,
         keyframe_frame_indices: list[int] | None = None,
         pad_seq_len: int | None = None,
+        locked_audio_rows: torch.Tensor | None = None,
+        temporal_offset: float = 0.0,
+        media_time_origin: int | None = None,
+        video_edit_clean_rows: torch.Tensor | None = None,
+        video_edit_mask_rows: torch.Tensor | None = None,
+        video_edit_restore_mask_rows: torch.Tensor | None = None,
+        audio_edit_clean_rows: torch.Tensor | None = None,
+        audio_edit_mask_rows: torch.Tensor | None = None,
+        audio_edit_restore_mask_rows: torch.Tensor | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         inputs = self._build_denoise_inputs(
             task=task,
@@ -1648,6 +1851,15 @@ class MiniMaxH3Pipeline(
             audio_condition_lengths=audio_condition_lengths,
             keyframe_frame_indices=keyframe_frame_indices,
             pad_seq_len=pad_seq_len,
+            locked_audio_rows=locked_audio_rows,
+            temporal_offset=temporal_offset,
+            media_time_origin=media_time_origin,
+            video_edit_clean_rows=video_edit_clean_rows,
+            video_edit_mask_rows=video_edit_mask_rows,
+            video_edit_restore_mask_rows=video_edit_restore_mask_rows,
+            audio_edit_clean_rows=audio_edit_clean_rows,
+            audio_edit_mask_rows=audio_edit_mask_rows,
+            audio_edit_restore_mask_rows=audio_edit_restore_mask_rows,
         )
         branch = inputs["branch"]
         transformer = self._transformer_for_task(task)
@@ -1665,6 +1877,8 @@ class MiniMaxH3Pipeline(
                     device=self.device,
                     imgvid_cond_noise_aug_for_inference=(MINIMAX_H3_IMGVID_COND_TIMESTEP),
                     audio_cond_noise_aug_for_inference=(MINIMAX_H3_AUDIO_REF_COND_TIMESTEP),
+                    video_edit=inputs["video_edit"],
+                    audio_edit=inputs["audio_edit"],
                     on_step=lambda step, video, audio: progress.update(),
                 )
 
@@ -1691,66 +1905,67 @@ class MiniMaxH3Pipeline(
     ) -> bytes:
         """Decode and encode one output on the worker without full-video materialization.
 
-        Audio is decoded first so the incremental mux session can attach its audio
-        stream before temporal video chunks arrive. The callback receives committed
-        float32 ``BCTHW`` frames, performs the requested-size crop and uint8
-        conversion in the worker, then applies bounded backpressure to the encoder.
-        """
-        from vllm_omni.diffusion.utils.media_utils import ChunkedMP4Encoder
+        Audio is decoded first so the incremental mux session can attach its
+        audio stream before temporal video chunks arrive. Everything after a
+        chunk is committed -- crop, quantization, transfer, encoding -- is the
+        shared consumer's job; this method only supplies what is specific to
+        H3: the audio waveform, the requested-size crop, and the fixed rate.
 
-        if batch_frames <= 0:
-            raise ValueError("batch_frames must be positive")
+        Every rank of a distributed VAE group drives the temporal collectives,
+        but only the output owner receives chunks, so a peer rank returns empty
+        bytes -- the pre-encoded counterpart of the empty tensor the full
+        decode leaves there.
+        """
+        from vllm_omni.diffusion.utils.chunked_video import decode_to_mp4 as decode_chunks_to_mp4
 
         with self._component_on_device(self.audio_vae):
             audio = self.audio_vae.decode_latent(audio_latent)
         audio_np = audio.detach().float().cpu().numpy()
         if audio_np.ndim == 3 and audio_np.shape[0] == 1:
             audio_np = audio_np[0]
-        encoder = ChunkedMP4Encoder(
-            width=width,
-            height=height,
-            fps=MINIMAX_H3_FPS,
-            audio_waveform=audio_np,
-            audio_sample_rate=MINIMAX_H3_AUDIO_SAMPLE_RATE,
-            max_pending=max_pending,
-            video_codec_options=video_codec_options,
-        )
 
-        pending_chunks: list[torch.Tensor] = []
-        pending_frames = 0
+        with self._component_on_device(self.video_vae):
+            with current_omni_platform.create_autocast_context(
+                device_type=self.device.type,
+                dtype=torch.float16,
+                enabled=True,
+            ):
+                videos = decode_chunks_to_mp4(
+                    self.video_vae,
+                    video_latent,
+                    fps=MINIMAX_H3_FPS,
+                    audio_waveforms=[audio_np],
+                    audio_sample_rate=MINIMAX_H3_AUDIO_SAMPLE_RATE,
+                    batch_frames=batch_frames,
+                    max_pending=max_pending,
+                    video_codec_options=video_codec_options,
+                    crop=(height, width),
+                )
+        if not videos:
+            return b""
+        if len(videos) != 1:
+            raise ValueError("MiniMax H3 chunked MP4 encoding currently expects one output per decoder")
+        return videos[0]
 
-        def flush_pending() -> None:
-            nonlocal pending_frames
-            if not pending_chunks:
-                return
-            batched = torch.cat(pending_chunks, dim=1)
-            encoder.push(batched[0].cpu().numpy())
-            pending_chunks.clear()
-            pending_frames = 0
+    def _release_stage_cache(self) -> None:
+        """Return idle allocator pages to the device at stage boundaries.
 
-        def on_chunk(frames: torch.Tensor) -> None:
-            nonlocal pending_frames
-            prepared = _prepare_minimax_h3_video_output(frames[..., :height, :width])
-            if prepared.shape[0] != 1:
-                raise ValueError("MiniMax H3 chunked MP4 encoding currently expects one output per decoder")
-            pending_chunks.append(prepared)
-            pending_frames += int(prepared.shape[1])
-            if pending_frames >= batch_frames:
-                flush_pending()
-
-        try:
-            with self._component_on_device(self.video_vae):
-                with current_omni_platform.create_autocast_context(
-                    device_type=self.device.type,
-                    dtype=torch.float16,
-                    enabled=True,
-                ):
-                    self.video_vae.decode_with_chunks(video_latent, on_chunk=on_chunk)
-            flush_pending()
-            return encoder.finish()
-        except BaseException:
-            encoder.abort()
-            raise
+        The bounded component cache releases only past its idle-cache bound
+        (>25% of device capacity), which on large devices lets a finished
+        stage's freed activations -- the DiT's denoise buffers, an encode
+        input, a decoded frame tensor -- stay physically mapped across the
+        next stage's peak. Forcing the release at a boundary is exact (only
+        free pages are returned; live tensors are untouched) and costs one
+        remap per later allocation.
+        """
+        cache = getattr(self, "_dlo_component_cache", None)
+        if cache is not None:
+            try:
+                cache.release_if_needed(force=True)
+            except BaseException:
+                logger.exception("Failed to release retained allocator cache at stage boundary")
+            return
+        current_omni_platform.empty_cache()
 
     def decode(
         self,
@@ -1760,7 +1975,11 @@ class MiniMaxH3Pipeline(
         height: int,
         width: int,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        with self._component_on_device(self.video_vae):
+        # Denoise just ended: its freed activation pages must not stay mapped
+        # through the VAE decode peak. Decoding needs only the ViT decoder
+        # half of the VAE, so the CNN encoder stays off the device.
+        self._release_stage_cache()
+        with self._component_on_device(self.video_vae.decoder_component):
             with current_omni_platform.create_autocast_context(
                 device_type=self.device.type,
                 dtype=torch.float16,
@@ -1894,7 +2113,14 @@ class MiniMaxH3Pipeline(
         if world_size == 1:
             assert conditioning is not None
             return conditioning
-        tensor_names = ("visual_condition", "audio_condition")
+        tensor_names = (
+            "visual_condition",
+            "audio_condition",
+            "video_edit_clean_rows",
+            "video_edit_mask",
+            "audio_edit_clean_rows",
+            "audio_edit_mask",
+        )
         header = [None]
         if rank == 0:
             assert conditioning is not None
@@ -1958,8 +2184,14 @@ class MiniMaxH3Pipeline(
         sampling: Any,
         *,
         require_external_text: bool = False,
-    ) -> MiniMaxH3EncoderConditioning:
+    ) -> tuple[MiniMaxH3EncoderConditioning, list[tuple[torch.Tensor, torch.Tensor]] | None]:
+        """Prepare media once and encode either shared text or each window's text.
+
+        Returns initial conditioning and optional request-owned window embeddings.
+        Invalid continuation prompts are broadcast before any encoder collective.
+        """
         group, rank, world_size = _dit_rank_world()
+        prompts = (sampling.extra_args or {}).get("continuation_prompts")
         prepared = text_conditioning = None
         error = None
         if rank == 0:
@@ -1970,6 +2202,7 @@ class MiniMaxH3Pipeline(
                 task = self._resolve_task(
                     (sampling.extra_args or {}).get("task"),
                     multi_modal_data,
+                    audio_mode=(sampling.extra_args or {}).get("audio_mode", "native"),
                     turbo_spec=turbo_spec,
                     has_native_lora=has_native_lora,
                 )
@@ -1988,6 +2221,27 @@ class MiniMaxH3Pipeline(
                     task=task,
                     prepared_reference_videos=self._extract_prepared_reference_videos(raw_prompt),
                 )
+                if prompts is not None:
+                    continuation = resolve_continuation(
+                        sampling.extra_args or {},
+                        task=task,
+                        step_execution=bool(getattr(self.od_config, "step_execution", False)),
+                    )
+                    if continuation is None or not self.load_text_encoder:
+                        raise OmniClientError(
+                            "continuation_prompts requires continuation mode with a local text encoder"
+                        )
+                    window, overlap = continuation
+                    count = len(plan_continuation_windows(prepared.media.num_frames, window, overlap))
+                    if (
+                        not isinstance(prompts, list)
+                        or len(prompts) != count
+                        or any(not isinstance(prompt, str) or not prompt.strip() for prompt in prompts)
+                    ):
+                        raise OmniClientError(f"continuation_prompts must contain exactly {count} non-empty strings")
+                    prepared = replace(prepared, prompt=prompts[0])
+                    # External text belongs to the main prompt, not the first window.
+                    text_conditioning = None
             except Exception as exc:
                 error = exc
         _broadcast_rank0_exception(error)
@@ -2005,21 +2259,33 @@ class MiniMaxH3Pipeline(
             )
         else:
             hidden, tags = self.encode_prompt(prepared)
+        window_text = None
+        if prompts is not None:
+            window_text = [(hidden, tags)]
+            for index, prompt in enumerate(prompts[1:], start=2):
+                logger.info("MiniMax H3 encoding continuation prompt %d/%d", index, len(prompts))
+                window_text.append(self.encode_prompt(replace(prepared, prompt=prompt) if rank == 0 else None))
         media = self._encode_local_media(prepared.media if prepared is not None else None)
-        return MiniMaxH3EncoderConditioning.from_components(MiniMaxH3TextConditioning(hidden, tags), media)
+        return MiniMaxH3EncoderConditioning.from_components(MiniMaxH3TextConditioning(hidden, tags), media), window_text
 
     def _prepare_request_inputs(self, raw_prompt: Any, sampling: Any) -> dict[str, Any]:
-        if self.load_text_encoder:
-            conditioning = self._prepare_local_conditioning(raw_prompt, sampling)
-        elif self.load_vae_encoder:
-            conditioning = self._prepare_local_conditioning(
+        if (getattr(sampling, "extra_args", None) or {}).get(
+            "continuation_prompts"
+        ) is not None and not self.load_text_encoder:
+            raise OmniClientError("continuation_prompts requires continuation mode with a local text encoder")
+        window_text = None
+        if self.load_text_encoder or self.load_vae_encoder:
+            conditioning, window_text = self._prepare_local_conditioning(
                 raw_prompt,
                 sampling,
-                require_external_text=True,
+                require_external_text=not self.load_text_encoder,
             )
         else:
             conditioning = self._extract_encoder_conditioning(raw_prompt)
-        return self._prepare_encoder_conditioning_inputs(conditioning, sampling)
+        context = self._prepare_encoder_conditioning_inputs(conditioning, sampling)
+        if window_text is not None:
+            context["continuation_text_conditioning"] = window_text
+        return context
 
     @staticmethod
     def _extract_encoder_conditioning(prompt: Any) -> MiniMaxH3EncoderConditioning:
@@ -2040,6 +2306,18 @@ class MiniMaxH3Pipeline(
         sampling: Any,
     ) -> dict[str, Any]:
         extra = sampling.extra_args or {}
+        continuation = resolve_continuation(
+            extra, task=conditioning.task, step_execution=bool(getattr(self.od_config, "step_execution", False))
+        )
+        validate_encoded_frame_limit(extra, conditioning.task, conditioning.num_frames)
+        if continuation is not None and (
+            conditioning.video_edit_clean_rows is not None or conditioning.audio_edit_clean_rows is not None
+        ):
+            raise OmniClientError(
+                "MiniMax H3 continuation does not support latent-mask editing; use long_video_mode=full"
+            )
+        if extra.get("audio_mode") == "lock_source" and conditioning.audio_edit_clean_rows is not None:
+            raise OmniClientError("MiniMax H3 audio_mode=lock_source cannot be combined with audio latent-mask editing")
         requested_task = extra.get("task")
         if requested_task is not None and str(requested_task).lower() != conditioning.task:
             raise OmniClientError(
@@ -2056,6 +2334,11 @@ class MiniMaxH3Pipeline(
             self._validate_turbo_sampling(sampling, turbo_spec)
         if has_native_lora:
             self._validate_native_sampling(sampling, task=task)
+        if self._fasth3_checkpoint is not None:
+            self._fasth3_checkpoint.check_request(
+                sampling,
+                step_execution=bool(getattr(self.od_config, "step_execution", False)),
+            )
         if self._fasth3 is not None:
             self._fasth3.check_request(
                 sampling,
@@ -2078,6 +2361,66 @@ class MiniMaxH3Pipeline(
 
         visual_shapes = list(conditioning.visual_condition_shapes) or None
         audio_lengths = list(conditioning.audio_condition_lengths) or None
+        audio_condition = conditioning.audio_condition
+        locked_audio_rows = None
+        if extra.get("audio_mode", "native") == "lock_source":
+            if audio_condition is None or not audio_lengths:
+                raise OmniClientError("MiniMax H3 lock_source requires encoded driving audio")
+            drive_t = audio_lengths[-1]
+            drive = audio_condition[-2 * drive_t :].reshape(2, drive_t, 32)
+            # Pad/crop each stereo channel independently; flattening first would
+            # shift the right channel when the source and target lengths differ.
+            fitted = drive.new_zeros((2, conditioning.audio_t, 32))
+            count = min(drive_t, conditioning.audio_t)
+            fitted[:, :count] = drive[:, :count]
+            locked_audio_rows = fitted.reshape(-1, 32).to(device=self.device)
+            audio_condition = audio_condition[: -2 * drive_t]
+            audio_condition = audio_condition if audio_condition.numel() else None
+            audio_lengths = audio_lengths[:-1] or None
+
+        latent_edit: dict[str, torch.Tensor | None] = {
+            "video_edit_clean_rows": None,
+            "video_edit_mask_rows": None,
+            "video_edit_restore_mask_rows": None,
+            "audio_edit_clean_rows": None,
+            "audio_edit_mask_rows": None,
+            "audio_edit_restore_mask_rows": None,
+        }
+        try:
+            if conditioning.video_edit_clean_rows is not None:
+                if conditioning.video_edit_mask is None:
+                    raise ValueError("MiniMax H3 video edit rows require a mask")
+                video_mask = minimax_h3_video_edit_masks(
+                    conditioning.video_edit_mask,
+                    latent_t=conditioning.latent_t,
+                    latent_h=conditioning.height // 16,
+                    latent_w=conditioning.width // 16,
+                )
+                latent_edit.update(
+                    video_edit_clean_rows=conditioning.video_edit_clean_rows,
+                    video_edit_mask_rows=video_mask.model_mask_rows,
+                    video_edit_restore_mask_rows=video_mask.restore_mask_rows,
+                )
+            if conditioning.audio_edit_clean_rows is not None:
+                if conditioning.audio_edit_mask is None:
+                    raise ValueError("MiniMax H3 audio edit rows require a mask")
+                audio_mask = minimax_h3_audio_edit_masks(
+                    conditioning.audio_edit_mask,
+                    audio_t=conditioning.audio_t,
+                )
+                model_mask, restore_mask = _expose_padded_audio_tail(
+                    conditioning.audio_edit_source_t,
+                    target_audio_t=conditioning.audio_t,
+                    mask_rows=audio_mask.model_mask_rows,
+                    restore_mask_rows=audio_mask.restore_mask_rows,
+                )
+                latent_edit.update(
+                    audio_edit_clean_rows=conditioning.audio_edit_clean_rows,
+                    audio_edit_mask_rows=model_mask,
+                    audio_edit_restore_mask_rows=restore_mask,
+                )
+        except ValueError as exc:
+            raise OmniClientError(str(exc)) from exc
 
         base_schedule, num_steps = self._resolve_sigma_positions(task, sampling)
         quality_plan = self._quality_policy.resolve(
@@ -2085,8 +2428,11 @@ class MiniMaxH3Pipeline(
             num_inference_steps=num_steps,
             extra_args=extra,
         )
+        if continuation is not None and quality_plan.cache_dit is not None:
+            raise OmniClientError("MiniMax H3 continuation requires uncached denoising; set quality=lossless")
         self._cache_dit_runtime.prepare(quality_plan.cache_dit)
         return {
+            "continuation": continuation,
             "task": task,
             "height": conditioning.height,
             "width": conditioning.width,
@@ -2103,15 +2449,12 @@ class MiniMaxH3Pipeline(
                 else None
             ),
             "visual_condition_shape": visual_shapes[0] if visual_shapes and len(visual_shapes) == 1 else None,
-            "audio_condition": (
-                conditioning.audio_condition.to(device=self.device)
-                if conditioning.audio_condition is not None
-                else None
-            ),
+            "audio_condition": (audio_condition.to(device=self.device) if audio_condition is not None else None),
             "ref_audio_t": audio_lengths[0] if audio_lengths and len(audio_lengths) == 1 else None,
             "ref_blocks": list(conditioning.ref_blocks) or None,
             "visual_condition_shapes": visual_shapes,
             "audio_condition_lengths": audio_lengths,
+            "locked_audio_rows": locked_audio_rows,
             "keyframe_frame_indices": list(conditioning.keyframe_frame_indices) or None,
             "pad_seq_len": _resolve_pad_seq_len(extra.get("pad_seq_len")),
             "seed": int(sampling.seed if sampling.seed is not None else 42),
@@ -2131,6 +2474,7 @@ class MiniMaxH3Pipeline(
                 if extra.get("preencode_mp4", False)
                 else None
             ),
+            **latent_edit,
         }
 
     @staticmethod
@@ -2151,7 +2495,18 @@ class MiniMaxH3Pipeline(
         videos = []
         audios = []
         for output_seed in _minimax_h3_output_seeds(context["seed"], num_outputs):
-            video_latent, audio_latent = self.diffuse(**{**denoise_kwargs, "seed": output_seed})
+            output_kwargs = {**denoise_kwargs, "seed": output_seed}
+            if context.get("continuation") is None:
+                video_latent, audio_latent = self.diffuse(**output_kwargs)
+            else:
+                window_frames, overlap_frames = context["continuation"]
+                video_latent, audio_latent = diffuse_continuation(
+                    self.diffuse,
+                    output_kwargs,
+                    window_frames=window_frames,
+                    overlap_frames=overlap_frames,
+                    text_conditioning=context.get("continuation_text_conditioning"),
+                )
             if context["preencode_mp4"]:
                 videos.append(
                     self.decode_to_mp4(
@@ -2178,6 +2533,11 @@ class MiniMaxH3Pipeline(
                 # loop rebinds it. post_decode() rebinds for the same reason.
                 video = self._offload_model_cpu_stage_output(_prepare_minimax_h3_video_output(video))
                 videos.append(video)
+                # The FP32 decoded frames are quantized into the appended uint8
+                # tensor; drop the reference and return the idle pages instead of
+                # holding them through the next output's denoise/decode.
+                del video
+                self._release_stage_cache()
                 audios.append(audio)
         if videos and isinstance(videos[0], bytes):
             video = videos[0] if len(videos) == 1 else videos
@@ -2298,6 +2658,8 @@ class MiniMaxH3Pipeline(
                 _STEP_AUDIO_ANCHOR: audio_anchor,
                 _STEP_SIGMAS_VIDEO: sigmas_video,
                 _STEP_SIGMAS_AUDIO: sigmas_audio,
+                _STEP_VIDEO_EDIT: inputs.get("video_edit"),
+                _STEP_AUDIO_EDIT: inputs.get("audio_edit"),
                 _STEP_SHAPE: {
                     "height": context["height"],
                     "width": context["width"],
@@ -2331,12 +2693,40 @@ class MiniMaxH3Pipeline(
         batch_states = list(states if states is not None else input_batch.states)
 
         branches = [state.extra[_STEP_BRANCH] for state in batch_states]
-        video_rows = [state.latents for state in batch_states]
-        audio_rows = [state.extra[_STEP_AUDIO_ROWS] for state in batch_states]
         schedules = [_minimax_h3_step_schedule(state) for state in batch_states]
         transformers = [state.extra[_STEP_TRANSFORMER] for state in batch_states]
         mixed_transformers = len({id(transformer) for transformer in transformers}) > 1
 
+        video_rows: list[torch.Tensor] = []
+        audio_rows: list[torch.Tensor] = []
+        video_target_timesteps: list[torch.Tensor | None] = []
+        audio_target_timesteps: list[torch.Tensor | None] = []
+        for state, branch, schedule in zip(batch_states, branches, schedules, strict=True):
+            video_edit = state.extra.get(_STEP_VIDEO_EDIT)
+            request_video, request_video_timesteps = minimax_h3_prepare_edit_rows(
+                state.latents,
+                branch.update_mask_dev,
+                video_edit,
+                schedule["t_video"],
+                schedule["imgvid_cond_timestep"],
+                sigma=schedule["sigma_video"],
+            )
+            video_target_timesteps.append(request_video_timesteps)
+            video_rows.append(request_video)
+
+            state_audio = state.extra[_STEP_AUDIO_ROWS]
+            audio_edit = state.extra.get(_STEP_AUDIO_EDIT)
+            request_audio, request_audio_timesteps = minimax_h3_prepare_edit_rows(
+                state_audio,
+                branch.audio_update_mask_dev,
+                audio_edit,
+                schedule["t_audio"],
+                schedule["audio_ref_cond_timestep"],
+                sigma=schedule["sigma_audio"],
+            )
+            audio_target_timesteps.append(request_audio_timesteps)
+            audio_rows.append(request_audio)
+
         # Both execution modes must publish denoise progress for step-gated
         # attention features. Requests can differ in both step index and sigma
         # schedule, so a batch that is not at one single point has nothing to
@@ -2382,6 +2772,8 @@ class MiniMaxH3Pipeline(
                     t_audio=schedules[index]["t_audio"],
                     imgvid_cond_timestep=schedules[index]["imgvid_cond_timestep"],
                     audio_ref_cond_timestep=schedules[index]["audio_ref_cond_timestep"],
+                    video_target_timesteps=video_target_timesteps[index],
+                    audio_target_timesteps=audio_target_timesteps[index],
                 )
                 request_video, request_audio = transformers[index](**forward_kwargs)
                 video_parts.append(request_video)
@@ -2397,6 +2789,8 @@ class MiniMaxH3Pipeline(
                 t_audio=[schedule["t_audio"] for schedule in schedules],
                 imgvid_cond_timesteps=[schedule["imgvid_cond_timestep"] for schedule in schedules],
                 audio_ref_cond_timesteps=[schedule["audio_ref_cond_timestep"] for schedule in schedules],
+                video_target_timesteps=video_target_timesteps,
+                audio_target_timesteps=audio_target_timesteps,
             )
             logger.debug(
                 "MiniMax H3 denoise step: %d request(s) packed into %d rows",
@@ -2430,11 +2824,19 @@ class MiniMaxH3Pipeline(
         audio_anchor = state.extra[_STEP_AUDIO_ANCHOR]
         device = video_rows.device
 
-        x0_video = minimax_h3_rf_v_to_x0(
-            video_rows[update],
-            noise_pred.float()[update],
-            torch.tensor(schedule["t_video"], dtype=torch.float32, device=device),
-        )
+        video_edit = state.extra.get(_STEP_VIDEO_EDIT)
+        if video_edit is None:
+            x0_video = minimax_h3_rf_v_to_x0(
+                video_rows[update],
+                noise_pred.float()[update],
+                torch.tensor(schedule["t_video"], dtype=torch.float32, device=device),
+            )
+        else:
+            x0_video = video_edit.x0(
+                video_edit.model_rows(video_rows[update]),
+                noise_pred.float()[update],
+                schedule["t_video"],
+            )
         new_video = minimax_h3_euler_eta0_step(
             video_rows[update],
             x0_video,
@@ -2446,11 +2848,19 @@ class MiniMaxH3Pipeline(
         if cond_anchor is not None:
             video_rows[~update] = cond_anchor  # per-step imgvid cond reset
 
-        x0_audio = minimax_h3_rf_v_to_x0(
-            audio_rows[audio_update],
-            audio_noise_pred.float()[audio_update],
-            torch.tensor(schedule["t_audio"], dtype=torch.float32, device=device),
-        )
+        audio_edit = state.extra.get(_STEP_AUDIO_EDIT)
+        if audio_edit is None:
+            x0_audio = minimax_h3_rf_v_to_x0(
+                audio_rows[audio_update],
+                audio_noise_pred.float()[audio_update],
+                torch.tensor(schedule["t_audio"], dtype=torch.float32, device=device),
+            )
+        else:
+            x0_audio = audio_edit.x0(
+                audio_edit.model_rows(audio_rows[audio_update]),
+                audio_noise_pred.float()[audio_update],
+                schedule["t_audio"],
+            )
         new_audio = minimax_h3_euler_eta0_step(
             audio_rows[audio_update],
             x0_audio,
@@ -2458,7 +2868,7 @@ class MiniMaxH3Pipeline(
             sigma_next=schedule["sigma_audio_next"],
         )
         audio_rows = audio_rows.clone()
-        audio_rows[audio_update] = new_audio
+        audio_rows[audio_update] = new_audio if branch.locked_audio_rows is None else branch.locked_audio_rows
         if audio_anchor is not None:
             audio_rows[~audio_update] = audio_anchor  # per-step audio ref reset
 
@@ -2497,6 +2907,7 @@ class MiniMaxH3Pipeline(
                 width=shape["width"],
             )
             video = self._offload_model_cpu_stage_output(_prepare_minimax_h3_video_output(video))
+            self._release_stage_cache()
         return DiffusionOutput(
             output=(video, audio),
             post_process_func=get_minimax_h3_post_process_func(self.od_config),
diff --git a/vllm_omni/diffusion/models/minimax_h3/vae.py b/vllm_omni/diffusion/models/minimax_h3/vae.py
index d02649229..c614ea0f2 100644
--- a/vllm_omni/diffusion/models/minimax_h3/vae.py
+++ b/vllm_omni/diffusion/models/minimax_h3/vae.py
@@ -6,11 +6,13 @@ from __future__ import annotations
 
 import importlib
 import json
+import os
 from collections.abc import Iterator
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from pathlib import Path
 from typing import Any, ClassVar
 
+import numpy as np
 import torch
 import torch.distributed as dist
 import torch.nn as nn
@@ -29,15 +31,20 @@ from vllm_omni.diffusion.offloader.module_residency import (
     BoundedAllocatorCache,
     PinnedModuleStager,
 )
+from vllm_omni.platforms import current_omni_platform
 
 from .chunked_decode import decode_h3_chunks
 from .ops import install_h3_vae_optimizations
 from .packed_tokens import minimax_h3_patchify_video_latent
+from .vae_temporal import install_temporal_stream_patches
 
 MINIMAX_H3_KEYFRAME_ENCODE_SEED = 42
 MINIMAX_H3_AUDIO_SAMPLE_RATE = 32000
 MINIMAX_H3_AUDIO_CHANNELS = 2
 
+# Escape hatch back to the checkpoint's whole-video numpy preparation path.
+_VAE_ENCODE_LEGACY_PREP_ENV = "VLLM_OMNI_VAE_ENCODE_LEGACY_PREP"
+
 
 logger = init_logger(__name__)
 
@@ -50,19 +57,28 @@ def _minimax_h3_keyframe_encode_context(
         yield
         return
 
-    # The official keyframe latent uses cuDNN's TF32 convolution path. The
-    # default non-deterministic algorithm can select numerically different
-    # reductions on H100s, and the difference is amplified by the denoiser.
-    # Pin both the algorithm and math mode for this sensitive encode only.
+    # Deterministic cuDNN algorithms can still use reduced-precision TF32.
+    # On Hopper, TF32 can shift the keyframe latent enough to push I2VA below
+    # the reference accuracy thresholds. Use FP32 convolutions for this
+    # sensitive encode only; preserve the existing math mode elsewhere.
+    allow_tf32 = True
+    if current_omni_platform.is_cuda():
+        capability = current_omni_platform.get_device_capability(device.index or 0)
+        allow_tf32 = capability is None or capability.major != 9
     with torch.backends.cudnn.flags(
         enabled=True,
         benchmark=False,
         deterministic=True,
-        allow_tf32=True,
+        allow_tf32=allow_tf32,
     ):
         yield
 
 
+def _legacy_encode_prep_enabled() -> bool:
+    value = os.environ.get(_VAE_ENCODE_LEGACY_PREP_ENV, "0")
+    return value.strip().lower() not in ("", "0", "false", "off")
+
+
 def _load_component_config(component_path: str) -> dict[str, Any]:
     config_path = Path(component_path) / "config.json"
     config = json.loads(config_path.read_text(encoding="utf-8"))
@@ -264,6 +280,49 @@ class _AudioVAEDeterminismContext(AbstractContextManager):
         return False
 
 
+class _VideoVAEPartProxy(nn.Module):
+    """Residency proxy for one half of the split video VAE.
+
+    The pipeline's ``_component_on_device`` drives whatever object it is
+    given through ``load_to_device``/``offload_to_cpu``. The checkpoint's
+    ViT decoder holds ~9GB of FP32 weights while the CNN encoder holds
+    ~0.7GB, and each is used by exactly one direction, so routing those
+    calls per half keeps the decoder off the device while reference videos
+    encode and the encoder off while latents decode. ``object.__setattr__``
+    keeps the back-reference out of the module registry (registering the
+    adapter as a submodule would recurse through ``parameters()``).
+    """
+
+    def __init__(self, vae: MiniMaxH3VideoVAE, part: str) -> None:
+        super().__init__()
+        object.__setattr__(self, "_vae", vae)
+        object.__setattr__(self, "_part", part)
+
+    def load_to_device(self) -> None:
+        self._vae._load_part_to_device(self._part)
+
+    def offload_to_cpu(self) -> None:
+        self._vae._offload_part_to_cpu(self._part)
+
+    def set_omni_component_cache(self, cache: BoundedAllocatorCache | None) -> None:
+        self._vae.set_omni_component_cache(cache)
+
+    @property
+    def sequential_offload_target(self) -> MiniMaxH3VideoVAE:
+        """The module model-level CPU offload actually hooks.
+
+        ``enable_omni_model_cpu_offload`` registers the sequential hook on the
+        real ``video_vae``, and the hook moves the whole module through
+        ``parameters()`` — entering the sequential context through this proxy
+        would find no ``_hook_registry`` and raise, and whole-module movement
+        has no half-residency benefit anyway. ``_component_on_device`` unwraps
+        through this property before entering its sequential-offload branch;
+        the manual per-half staging above stays proxy-driven, where split
+        residency is the whole point.
+        """
+        return self._vae
+
+
 class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
     """Adapter around the checkpoint's native parallel-tiled video VAE."""
 
@@ -303,14 +362,15 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
                 decoder,
                 device=device,
             )
-        self._stager = None
-        if initial_device.type == "cpu" and device.type not in ("cpu", "meta"):
-            self._stager = PinnedModuleStager(
-                self.remote,
-                device,
-                pin_memory=True,
-            )
+        install_temporal_stream_patches(self.remote.model)
         self.model = self.remote.model
+        self._stager = None
+        self._encoder_stager = None
+        self._decoder_stager = None
+        if initial_device.type == "cpu" and device.type not in ("cpu", "meta"):
+            self._build_residency_stagers(device)
+        self.encoder_component = _VideoVAEPartProxy(self, "encoder")
+        self.decoder_component = _VideoVAEPartProxy(self, "decoder")
         self.use_tiling = True
         self.use_slicing = False
         self.parallel_size = 1
@@ -321,27 +381,97 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
         if self._tile_gather_reuse_enabled():
             self._install_persistent_tile_gather()
 
-    def load_to_device(self) -> None:
+    def _build_residency_stagers(self, device: torch.device) -> None:
+        """Stage the encode and decode halves of the remote separately.
+
+        The encode path touches only ``encoder`` + ``quant_conv`` and the
+        decode path only ``post_quant_conv`` + ``decoder`` (verified against
+        the checkpoint's ``AutoencoderKLLegacy``: the one cross reference,
+        ``tiled_decode``'s ``getattr(self.encoder, "mask_enabled")``, is
+        short-circuited by ``self.training`` at inference). No storage is
+        shared across the two groups, so independent staging is exact. When
+        the checkpoint's structure is not discoverable, fall back to
+        whole-module staging (the previous single-stager behavior).
+        """
+        part_names = ("encoder", "quant_conv", "post_quant_conv", "decoder")
+        if all(isinstance(getattr(self.model, name, None), nn.Module) for name in part_names):
+            self._encoder_stager = PinnedModuleStager(
+                [self.model.encoder, self.model.quant_conv],
+                device,
+                pin_memory=True,
+            )
+            self._decoder_stager = PinnedModuleStager(
+                [self.model.post_quant_conv, self.model.decoder],
+                device,
+                pin_memory=True,
+            )
+            return
+        self._stager = PinnedModuleStager(
+            self.remote,
+            device,
+            pin_memory=True,
+        )
+
+    def _part_stager(self, part: str) -> PinnedModuleStager | None:
+        if part == "encoder":
+            return self._encoder_stager
+        if part == "decoder":
+            return self._decoder_stager
+        raise ValueError(f"unknown video VAE part {part!r}")
+
+    def _load_part_to_device(self, part: str) -> None:
+        stager = self._part_stager(part)
+        if stager is not None:
+            stager.load()
+        elif self._stager is not None:
+            self._stager.load()
+        else:
+            # No staged residency (the component lives on the device already
+            # or is fully CPU-resident): fall back to whole-module placement.
+            self.remote.to(self._device_target)
+
+    def _offload_part_to_cpu(self, part: str) -> None:
+        stager = self._part_stager(part)
+        if stager is not None:
+            stager.offload()
+            return
         if self._stager is not None:
+            self._stager.offload()
+            return
+        self.remote.to("cpu")
+        self._release_component_cache()
+
+    def _release_component_cache(self) -> None:
+        cache = getattr(self, "_omni_component_cache", None)
+        if cache is None:
+            torch.accelerator.empty_cache()
+        else:
+            cache.release_if_needed()
+
+    def load_to_device(self) -> None:
+        if self._encoder_stager is not None:
+            self._encoder_stager.load()
+            self._decoder_stager.load()
+        elif self._stager is not None:
             self._stager.load()
         else:
             self.remote.to(self._device_target)
 
     def set_omni_component_cache(self, cache: BoundedAllocatorCache | None) -> None:
         self._omni_component_cache = cache
-        if self._stager is not None:
-            self._stager.set_cache_retention(cache)
+        for stager in (self._encoder_stager, self._decoder_stager, self._stager):
+            if stager is not None:
+                stager.set_cache_retention(cache)
 
     def offload_to_cpu(self) -> None:
-        if self._stager is not None:
+        if self._encoder_stager is not None:
+            self._encoder_stager.offload()
+            self._decoder_stager.offload()
+        elif self._stager is not None:
             self._stager.offload()
         else:
             self.remote.to("cpu")
-            cache = getattr(self, "_omni_component_cache", None)
-            if cache is None:
-                torch.accelerator.empty_cache()
-            else:
-                cache.release_if_needed()
+            self._release_component_cache()
 
     def set_parallel_size(
         self,
@@ -650,6 +780,91 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
             patch_size=(1, 2, 2),
         ).float()
 
+    def _stream_prepare_video_tensor(
+        self,
+        frames: np.ndarray,
+        device: torch.device,
+    ) -> torch.Tensor | None:
+        """Upload a uint8 ``(T, H, W, 3)`` video as one normalized FP32 tensor.
+
+        The checkpoint's numpy path uploads the whole video as FP32, then
+        ``transform_tensor`` materializes a second normalized copy, then
+        ``encode_temporal`` pads through a full-video ``torch.cat``: three
+        resident pixel-scale copies on the device. Here the padding is
+        replicated on the host, a single preallocated ``(3, T', H, W)`` tensor
+        receives clip-by-clip uploads, and the ``÷255 → (x-mean)/std`` chain
+        runs in place on each clip's staging buffer in the same op order as
+        ``convert_numpy_to_tensor`` → ``transform_tensor``, so peak device
+        memory is the output tensor plus one clip instead of three copies.
+
+        Returns ``None`` whenever the checkpoint contract this mirrors (uint8
+        frames, ``clip_length`` alignment, processor ``transform`` constants)
+        is not discoverable; callers fall back to the legacy path.
+        """
+        if frames.dtype != np.uint8 or frames.ndim != 4 or frames.shape[-1] != 3:
+            return None
+        if int(frames.shape[0]) == 0:
+            return None
+        model = self.model
+        clip_length = getattr(model, "clip_length", None)
+        transform = getattr(getattr(model, "processor", None), "transform", None)
+        mean = getattr(transform, "mean", None)
+        std = getattr(transform, "std", None)
+        if not isinstance(clip_length, int) or clip_length <= 0:
+            return None
+        if mean is None or std is None or len(mean) != 3 or len(std) != 3:
+            return None
+        # Mirror the checkpoint's temporal alignment so the device-side
+        # ``get_suitable_video_length`` trim is a no-op and the
+        # ``encode_temporal`` padding ``torch.cat`` never triggers. A
+        # trim-stable length is ``k * clip_length + tail`` (tail = frame
+        # overlap plus the isolated last frame); it also satisfies
+        # encode_temporal only when ``tail % clip_length == offset_frame``.
+        # With an asymmetric checkpoint (isolated last frame but no isolated
+        # first frame) no trim-stable length can satisfy encode_temporal, so
+        # the remote re-pads through a whole-video cat regardless and any
+        # host-side pad would be trimmed away before that -- keep the legacy
+        # frame count there instead of uploading dead frames.
+        isolated_first_frame = bool(getattr(model, "isolated_first_frame", False))
+        frame_pre_padding = int(getattr(model, "frame_pre_padding", 0) or 0)
+        offset = 1 if isolated_first_frame and frame_pre_padding == 0 else 0
+        processor = getattr(model, "processor", None)
+        tail = int(getattr(processor, "frame_overlap", 0) or 0)
+        if bool(getattr(processor, "isolated_last_frame", False)):
+            tail += 1
+        num_frames = int(frames.shape[0])
+        pad = 0
+        if tail % clip_length == offset:
+            align = getattr(processor, "align_video_length", None)
+            if callable(align):
+                pad = max(0, int(align(num_frames, mode="pad", granularity="chunk")))
+            else:
+                chunks = -(-(num_frames - tail) // clip_length)
+                pad = max(max(chunks, 1) * clip_length + tail - num_frames, 0)
+        if pad:
+            frames = np.concatenate([frames, np.repeat(frames[-1:], pad, axis=0)])
+            num_frames += pad
+        mean_t = torch.as_tensor(mean, dtype=torch.float32, device=device).view(3, 1, 1, 1)
+        std_t = torch.as_tensor(std, dtype=torch.float32, device=device).view(3, 1, 1, 1)
+        height, width = int(frames.shape[1]), int(frames.shape[2])
+        out = torch.empty(
+            (3, num_frames, height, width),
+            dtype=torch.float32,
+            device=device,
+        )
+        for start in range(0, num_frames, clip_length):
+            end = min(start + clip_length, num_frames)
+            # Frame slices of a C-contiguous (T, H, W, 3) array stay
+            # contiguous, so each clip uploads at uint8 width (4x less host
+            # traffic than the legacy FP32 upload) before the in-place
+            # normalization chain. permute lands on the checkpoint's
+            # (3, T, H, W) layout directly.
+            chunk = torch.from_numpy(frames[start:end]).to(device=device)
+            chunk = chunk.permute(3, 0, 1, 2).to(torch.float32).div_(255.0)
+            chunk = chunk.sub_(mean_t).div_(std_t)
+            out[:, start:end].copy_(chunk)
+        return out
+
     @torch.inference_mode()
     def encode_video(
         self,
@@ -679,6 +894,14 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
                 for device in devices:
                     with self.device_module.device(device):
                         self.device_module.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
+                prepared = None
+                if isinstance(frames, np.ndarray) and not _legacy_encode_prep_enabled():
+                    prepared = self._stream_prepare_video_tensor(frames, parameter.device)
+                if prepared is not None:
+                    # Tensor inputs already carry the checkpoint's expected
+                    # (3, T, H, W) normalized-FP32 contract, so encode_videos
+                    # skips its own convert/transform/pad whole-video copies.
+                    frames = [prepared]
                 latent = self.model.encode_videos(
                     frames,
                     use_fp16_latent=True,
@@ -738,7 +961,12 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
             raise RuntimeError("MiniMax H3 encode-only video VAE cannot decode latents")
         with self._decode_tiling_context(latent):
             decoded = self.model.decode_base(self._denormalize_latent(latent))
-        return self._normalize_decoded_frames(self.model.processor.revert_tensor(decoded))
+        if decoded.dtype == torch.uint8:
+            # The streaming uint8 write-back already ran the revert and the
+            # output quantizer inside write_part; nothing remains but the
+            # shape contract.
+            return self._normalize_decoded_frames(decoded)
+        return self._normalize_decoded_frames(self._revert_decoded_inplace(decoded))
 
     def _denormalize_latent(self, latent: torch.Tensor) -> torch.Tensor:
         channels = int(self.config_dict["latent_channels"])
@@ -755,7 +983,7 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
             frames = frames.unsqueeze(0).transpose(1, 2)
         if frames.ndim != 5:
             raise ValueError(f"unexpected decoded video shape {tuple(frames.shape)}")
-        return frames.float()
+        return frames if frames.dtype == torch.uint8 else frames.float()
 
     # Chunks are reverted through the checkpoint's processor, which
     # denormalizes and clamps into the unit interval.
@@ -791,6 +1019,33 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
         with self._decode_tiling_context(z):
             decode_h3_chunks(self, z, on_chunk, group=group)
 
+    def _revert_decoded_inplace(self, decoded: torch.Tensor) -> torch.Tensor:
+        """In-place counterpart of the processor's ``revert_tensor``.
+
+        The checkpoint version materializes a denormalized copy, a clamped
+        copy, and a contiguous copy of the whole decoded video -- three
+        pixel-scale tensors resident at the decode peak. Decoding owns the
+        tensor here, so the same op order (torchvision ``Normalize`` is
+        ``(x - mean) / std``, then ``clamp(0, 1)``) runs in place on the
+        original ``(B, C, T, H, W)`` layout, which is bit-identical
+        elementwise to normalizing the ``(b t) c h w`` rearrangement and
+        returns with zero whole-video copies.
+
+        Falls back to ``processor.revert_tensor`` when the checkpoint's
+        denormalization constants are not discoverable.
+        """
+        processor = getattr(self.model, "processor", None)
+        transform_rev = getattr(processor, "transform_rev", None)
+        mean = getattr(transform_rev, "mean", None)
+        std = getattr(transform_rev, "std", None)
+        if mean is None or std is None or len(mean) != 3 or len(std) != 3:
+            return processor.revert_tensor(decoded)
+        if bool(getattr(processor, "use_3d_conv", True)) and decoded.ndim == 4:
+            decoded = decoded.unsqueeze(2)
+        mean_t = torch.as_tensor(mean, dtype=decoded.dtype, device=decoded.device).view(1, 3, 1, 1, 1)
+        std_t = torch.as_tensor(std, dtype=decoded.dtype, device=decoded.device).view(1, 3, 1, 1, 1)
+        return decoded.sub_(mean_t).div_(std_t).clamp_(0.0, 1.0)
+
 
 class MiniMaxH3AudioVAE(nn.Module):
     def __init__(
diff --git a/vllm_omni/diffusion/models/minimax_h3/vae_temporal.py b/vllm_omni/diffusion/models/minimax_h3/vae_temporal.py
new file mode 100644
index 000000000..6606ee5ef
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/vae_temporal.py
@@ -0,0 +1,271 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Memory-optimized forks of the checkpoint's temporal VAE loops.
+
+Two method replacements installed on the checkpoint's ``AutoencoderKLLegacy``
+at adapter construction:
+
+* ``encode_temporal`` pads misaligned frame counts by concatenating repeated
+  last frames onto the *whole* video before the chunk loop (~4GB copy for a
+  15s clip). The fork pads inside the tail chunk instead: the chunks see
+  bit-identical frames while the copy shrinks to a single clip.
+
+* ``_decode_temporal_streaming`` accumulates the whole decoded video in a
+  floating-point buffer that is denormalized, clamped, and quantized to
+  uint8 only after the final chunk lands. The fork fuses the adapter's
+  in-place revert and the output quantizer into ``write_part`` and
+  accumulates directly into a uint8 buffer -- the same per-element op order
+  (``(x - mean) / std -> clamp(0, 1) -> *255 -> round -> uint8``), so the
+  delivered video is bit-identical while the resident decode buffer shrinks
+  4x.
+
+Set ``VLLM_OMNI_VAE_LEGACY_TEMPORAL=1`` to keep the checkpoint's methods.
+"""
+
+from __future__ import annotations
+
+import os
+from types import MethodType
+
+import torch
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+_LEGACY_TEMPORAL_ENV = "VLLM_OMNI_VAE_LEGACY_TEMPORAL"
+
+
+def _legacy_temporal_enabled() -> bool:
+    value = os.environ.get(_LEGACY_TEMPORAL_ENV, "0")
+    return value.strip().lower() not in ("", "0", "false", "off")
+
+
+def _encode_temporal_tail_pad(self, x):
+    """Drop-in fork of the checkpoint's ``encode_temporal``.
+
+    Frame handling is identical to the original; only the padding site
+    moves from a whole-video ``torch.cat`` into the tail chunk.
+    """
+    offset_frame = 1 if self.isolated_first_frame and self.frame_pre_padding == 0 else 0
+
+    orig_frames = int(x.shape[2])
+    pad_size = (offset_frame - orig_frames) % self.clip_length
+    padded_frames = orig_frames + pad_size
+    num_chunks = (padded_frames - offset_frame) // self.clip_length
+
+    z_list = []
+    for i in range(num_chunks):
+        start_idx = i * self.clip_length + offset_frame
+        end_idx = (i + 1) * self.clip_length + offset_frame
+        clip_x = x[:, :, start_idx : min(end_idx, orig_frames), :, :]
+        if end_idx > orig_frames:
+            # The original pads the whole video up front by repeating the
+            # last frame; repeating it inside the tail chunk feeds the
+            # identical frames to the identical encodes.
+            clip_x = torch.cat(
+                [clip_x, clip_x[:, :, -1:].repeat(1, 1, end_idx - orig_frames, 1, 1)],
+                dim=2,
+            )
+
+        if self.isolated_key_frame:
+            key_frame = clip_x[:, :, :1, :, :]
+            z_key = self._adaptive_encode(key_frame)
+
+            if clip_x.shape[2] > 1:
+                video_frames = clip_x[:, :, 1:, :, :]
+                z_video = self._adaptive_encode(video_frames)
+                z = torch.cat([z_key, z_video], dim=2)
+            else:
+                z = z_key
+        else:
+            z = self._adaptive_encode(clip_x)
+
+        z_list.append(z)
+
+    z = torch.cat(z_list, dim=2)
+    if self.token_drop > 0:
+        z = z[:, :, : -self.token_drop]
+
+    if self.isolated_first_frame:
+        input_first_frame = x[:, :, :1, :, :]
+        z_first_frame = self._adaptive_encode(input_first_frame)
+
+        if self.frame_pre_padding == 0:
+            z = torch.cat([z_first_frame, z], dim=2)
+        else:
+            z = torch.cat([z_first_frame, z[:, :, 1:, :, :]], dim=2)
+
+    if self.isolated_last_frame:
+        # The original indexes into the padded video: pad frames replicate
+        # the last real frame, out-of-range indexes produce an empty slice
+        # (a no-op), and negative indexes wrap. Reproduce that mapping
+        # against the unpadded tensor instead of materializing the pad.
+        last_frame_idx = padded_frames - self.frame_drop + offset_frame
+        if last_frame_idx < 0:
+            last_frame_idx += padded_frames
+        if 0 <= last_frame_idx < padded_frames:
+            src_idx = min(last_frame_idx, orig_frames - 1)
+            input_last_frame = x[:, :, src_idx : src_idx + 1, :, :]
+            z_last_frame = self._adaptive_encode(input_last_frame)
+            z = torch.cat([z, z_last_frame], dim=2)
+
+    return z
+
+
+def _decode_temporal_streaming_uint8(self, z, z_head, z_tail, num_chunks, pad_tokens, temporal_cat_dtype):
+    """Drop-in fork of the checkpoint's ``_decode_temporal_streaming``.
+
+    The chunk loop, overlap blending, frame plan, and assertions are
+    identical to the original. ``write_part`` additionally runs the
+    denormalize -> clamp -> quantize chain in place (the same op order the
+    pipeline applies after decode) and accumulates into a uint8 buffer.
+    """
+    total_frames, pad_frames, output_frames = self._decode_temporal_output_frame_plan(
+        z, z_head, z_tail, num_chunks, pad_tokens
+    )
+    if output_frames <= 0:
+        raise ValueError(
+            f"decode_temporal streaming planned non-positive output_frames={output_frames} "
+            f"total_frames={total_frames} pad_frames={pad_frames}"
+        )
+
+    chunk_dec = self.tokens_chunk_size * self.vae_ratio_t
+    split_count = int(self.token_drop > 0) + 1
+    dec = None
+    dec_overlap = None
+    norm = None
+    write_pos = 0
+    logical_frames = 0
+    dropped_frames = 0
+    decoded_count = 0
+
+    def write_part(part):
+        nonlocal dec, dec_overlap, norm, write_pos, logical_frames, dropped_frames
+        part_frames = int(part.shape[2])
+        if part_frames <= 0:
+            return
+        logical_frames += part_frames
+        if dec is None:
+            out_shape = list(part.shape)
+            out_shape[2] = output_frames
+            dec = torch.empty(out_shape, dtype=torch.uint8, device=part.device)
+            transform_rev = self.processor.transform_rev
+            mean = torch.as_tensor(transform_rev.mean, dtype=part.dtype, device=part.device).view(1, 3, 1, 1, 1)
+            std = torch.as_tensor(transform_rev.std, dtype=part.dtype, device=part.device).view(1, 3, 1, 1, 1)
+            norm = (mean, std)
+        # revert_tensor ((x - mean) / std, clamp) followed by the output
+        # quantizer (*255, round, uint8), in place on the part: the blended
+        # raw values are consumed before this point, and every write into
+        # ``dec`` goes through here, so the final buffer matches the legacy
+        # post-decode chain element for element. Denormalization and clamping
+        # run in the decoded dtype exactly like the legacy adapter; the
+        # quantizer then runs in FP32 because the legacy adapter returned
+        # ``frames.float()`` before the pipeline multiplied and rounded —
+        # rounding fp16/bf16 directly flips borderline pixels by one.
+        mean_t, std_t = norm
+        part.sub_(mean_t).div_(std_t).clamp_(0.0, 1.0)
+        part = part.float()
+        part.mul_(255.0).round_()
+
+        remaining = int(dec.shape[2]) - write_pos
+        copy_frames = min(part_frames, max(0, remaining))
+        if copy_frames > 0:
+            dec[:, :, write_pos : write_pos + copy_frames, :, :].copy_(part[:, :, :copy_frames, :, :])
+            write_pos += copy_frames
+        dropped_frames += part_frames - copy_frames
+
+    for i in range(num_chunks):
+        t_start_idx = i * self.tokens_chunk_size
+        t_end_idx = t_start_idx + self.tokens_chunk_size + self.token_overlap
+        clip_z = z[:, :, t_start_idx:t_end_idx, :, :]
+
+        if i == 0 and z_head is not None:
+            clip_z = torch.cat([z_head, clip_z], dim=2)
+
+        if i == num_chunks - 1 and z_tail is not None:
+            clip_z = torch.cat([clip_z, z_tail], dim=2)
+
+        clip_dec = self._adaptive_decode(clip_z)
+        decoded_count += 1
+        if temporal_cat_dtype is not None and clip_dec.dtype != temporal_cat_dtype:
+            clip_dec = clip_dec.to(temporal_cat_dtype)
+        if clip_dec.device != z.device:
+            clip_dec = clip_dec.to(z.device)
+
+        dec_tail = None
+        if i == 0 and z_head is not None:
+            write_part(clip_dec[:, :, self.vae_ratio_t - 1 : self.vae_ratio_t, :, :])
+            clip_dec = clip_dec[:, :, self.vae_ratio_t :, :, :]
+
+        if i == num_chunks - 1 and z_tail is not None:
+            dec_tail = clip_dec[:, :, -1:, :, :]
+            clip_dec = clip_dec[:, :, : -self.vae_ratio_t, :, :]
+
+        for j in range(split_count):
+            f_start_idx = j * chunk_dec
+            f_end_idx = min(f_start_idx + chunk_dec, clip_dec.shape[2])
+            clip_dec_chunk = clip_dec[:, :, f_start_idx:f_end_idx, :, :]
+            clip_dec_chunk = clip_dec_chunk[:, :, self.frame_pre_padding :, :, :]
+
+            if j == 0:
+                if dec_overlap is not None:
+                    clip_dec_chunk = self.blend(dec_overlap, clip_dec_chunk, self.frame_overlap, dim=-3)
+                    dec_overlap = None
+                write_part(clip_dec_chunk)
+            else:
+                # Break the view's reference to the full decoded clip so earlier
+                # temporal chunks can be released before the final output exists.
+                dec_overlap = clip_dec_chunk.contiguous()
+
+        if i == num_chunks - 1:
+            if dec_overlap is not None:
+                write_part(dec_overlap)
+                dec_overlap = None
+            if dec_tail is not None:
+                write_part(dec_tail)
+
+        del clip_dec, clip_z
+
+    if dec is None:
+        raise RuntimeError("decode_temporal streaming produced no output tensor")
+    if logical_frames != total_frames or dropped_frames != pad_frames or write_pos != output_frames:
+        raise RuntimeError(
+            "decode_temporal streaming frame plan mismatch: "
+            f"logical_frames={logical_frames} total_frames={total_frames} "
+            f"dropped_frames={dropped_frames} pad_frames={pad_frames} "
+            f"write_pos={write_pos} output_frames={output_frames}"
+        )
+
+    return dec
+
+
+def _processor_denorm_available(model) -> bool:
+    transform_rev = getattr(getattr(model, "processor", None), "transform_rev", None)
+    mean = getattr(transform_rev, "mean", None)
+    std = getattr(transform_rev, "std", None)
+    return mean is not None and std is not None and len(mean) == 3 and len(std) == 3
+
+
+def install_temporal_stream_patches(model) -> None:
+    """Install the memory-optimized temporal forks on the checkpoint model.
+
+    Each fork is installed only when the checkpoint contract it mirrors is
+    discoverable; otherwise the checkpoint's own method keeps running (the
+    adapter's post-decode revert already covers that path).
+    """
+    if _legacy_temporal_enabled():
+        logger.info("MiniMax-H3 VAE temporal stream patches disabled by %s", _LEGACY_TEMPORAL_ENV)
+        return
+    if callable(getattr(model, "encode_temporal", None)) and hasattr(model, "clip_length"):
+        model.encode_temporal = MethodType(_encode_temporal_tail_pad, model)
+        logger.info("MiniMax-H3 VAE encode_temporal tail-padding patch installed")
+    else:
+        logger.warning("MiniMax-H3 VAE encode_temporal contract not found; keeping checkpoint method")
+    if callable(getattr(model, "_decode_temporal_streaming", None)) and _processor_denorm_available(model):
+        model._decode_temporal_streaming = MethodType(_decode_temporal_streaming_uint8, model)
+        logger.info("MiniMax-H3 VAE streaming uint8 decode patch installed")
+    else:
+        logger.warning("MiniMax-H3 VAE streaming decode contract not found; keeping checkpoint method")
+
+
+__all__ = ["install_temporal_stream_patches"]
diff --git a/vllm_omni/diffusion/models/pi05/__init__.py b/vllm_omni/diffusion/models/pi05/__init__.py
new file mode 100644
index 000000000..ccd19acde
--- /dev/null
+++ b/vllm_omni/diffusion/models/pi05/__init__.py
@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""π0.5 VLA model for vllm-omni.
+
+PaliGemma (SigLIP vision + Gemma-2B LM) + Gemma-300M action expert with AdaRMS
+timestep conditioning + a flow-matching action head. Outputs a continuous action
+chunk ``[horizon, action_dim]`` rather than tokens.
+
+Differs from π0 in five places: AdaRMS timestep conditioning (``time_mlp_*``
+instead of ``action_time_mlp_*``), AdaRMS norms throughout the action expert, a
+200-token tokenizer budget, a discretized state carried in the prompt (no
+``state_proj``), and relative-action support.
+"""
+
+from vllm_omni.diffusion.models.pi05.config import (
+    Pi05Config,
+    UnsupportedCheckpointCapabilityError,
+    resolve_excluded_action_indices,
+)
+from vllm_omni.diffusion.models.pi05.modeling_pi05 import (
+    GemmaVariantConfig,
+    PaliGemmaWithActionExpertPi05,
+    Pi05AdaRMSNorm,
+    Pi05ForActionPrediction,
+    create_sinusoidal_pos_embedding,
+    get_gemma_config,
+    make_att_2d_masks,
+    prepare_attention_masks_4d,
+)
+from vllm_omni.diffusion.models.pi05.pipeline_pi05 import (
+    Pi05Pipeline,
+    get_pi05_post_process_func,
+)
+from vllm_omni.diffusion.models.pi05.processor_pi05 import (
+    Pi05ImageProcessor,
+    Pi05Processor,
+    Pi05RelativeActions,
+    apply_norm,
+    build_norm_stats,
+    build_pi05_prompt,
+    discretize_state,
+    pil_image_to_tensor,
+    resize_with_pad,
+    tokenize_prompt,
+)
+
+__all__ = [
+    "Pi05Config",
+    "UnsupportedCheckpointCapabilityError",
+    "resolve_excluded_action_indices",
+    "Pi05ForActionPrediction",
+    "PaliGemmaWithActionExpertPi05",
+    "Pi05AdaRMSNorm",
+    "GemmaVariantConfig",
+    "get_gemma_config",
+    "create_sinusoidal_pos_embedding",
+    "make_att_2d_masks",
+    "prepare_attention_masks_4d",
+    "Pi05ImageProcessor",
+    "Pi05Processor",
+    "Pi05RelativeActions",
+    "build_pi05_prompt",
+    "discretize_state",
+    "apply_norm",
+    "build_norm_stats",
+    "pil_image_to_tensor",
+    "resize_with_pad",
+    "tokenize_prompt",
+    "Pi05Pipeline",
+    "get_pi05_post_process_func",
+]
diff --git a/vllm_omni/diffusion/models/pi05/config.py b/vllm_omni/diffusion/models/pi05/config.py
new file mode 100644
index 000000000..e86ddbae9
--- /dev/null
+++ b/vllm_omni/diffusion/models/pi05/config.py
@@ -0,0 +1,471 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Config surface for the π0.5 VLA model in vllm-omni.
+
+Deliberately shaped exactly like ``pi0/config.py``: a small dataclass that
+consumes the raw LeRobot ``config.json`` (the field surface of
+``lerobot.policies.pi05.PI05Config``) and keeps only the runtime-relevant
+fields. Transformer dimensions are derived from ``paligemma_variant`` /
+``action_expert_variant`` inside the model via ``get_gemma_config``.
+
+What π0.5 adds on top of the π0 config surface:
+
+* ``tokenizer_max_length = 200`` (π0 uses 48).
+* ``state_num_bins`` — state is discretized into language tokens instead of
+  going through a ``state_proj`` layer.
+* ``use_relative_actions`` / ``relative_exclude_joints`` /
+  ``action_feature_names`` — the relative-action contract. See
+  ``processor_pi05.Pi05RelativeActions``.
+* Quantile normalization stats. LeRobot's π0.5 defaults ``STATE`` and
+  ``ACTION`` to ``NormalizationMode.QUANTILES`` where π0 uses ``MEAN_STD``.
+
+**Checkpoint boundary rule.** A capability that the checkpoint *declares* but
+this implementation does not *consume* must raise, not be silently dropped.
+π0.5 checkpoints can declare MEM (short-horizon observation memory) and RTC
+(real-time chunking); neither is supported here, and serving such a checkpoint
+anyway would produce plausible-looking wrong actions. See
+``_reject_unsupported_capabilities``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from dataclasses import fields as dataclass_fields
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Serving dtypes, by name. Kept in sync with ``Pi05Pipeline.SUPPORTED_DTYPES``,
+# which guards the path that performs the actual cast. Defined here rather than
+# imported to keep config.py free of a pipeline import cycle.
+SUPPORTED_DTYPE_NAMES = frozenset({"float32", "bfloat16"})
+
+# LeRobot / OpenPI observation key conventions.
+ACTION = "action"
+OBS_STR = "observation"
+OBS_STATE = OBS_STR + ".state"
+OBS_IMAGES = OBS_STR + ".images"
+
+
+class UnsupportedCheckpointCapabilityError(ValueError):
+    """A checkpoint declares a capability this implementation does not consume.
+
+    Raised at load time rather than silently ignored: every one of these
+    capabilities changes what a *correct* action chunk looks like, and none of
+    them is visible in the weights alone.
+    """
+
+
+def resolve_excluded_action_indices(
+    exclude_joints: list[str] | None,
+    action_names: list[str] | None,
+) -> list[int]:
+    """Map ``relative_exclude_joints`` names onto action-vector indices.
+
+    Matching is exact name first, then substring (a checkpoint may name the
+    gripper dimension ``gripper_position`` while the config just says
+    ``gripper``). Single source of truth for both the config-time validation
+    and the runtime mask in ``processor_pi05.Pi05RelativeActions``.
+
+    Returns an empty list when there is nothing to exclude. Raises when a name
+    cannot be resolved — an unresolvable exclusion would otherwise silently
+    become "make this dimension relative too".
+    """
+    if not [name for name in (exclude_joints or []) if name]:
+        return []
+    if not action_names:
+        raise UnsupportedCheckpointCapabilityError(
+            f"Cannot resolve relative_exclude_joints={exclude_joints!r} without action_feature_names."
+        )
+
+    # LeRobot walks the action names and excludes each one any token equals or is
+    # contained in, both lowercased. Walking the tokens instead and stopping at the
+    # first exact hit misses a second name the token is a substring of.
+    tokens = [str(name).lower() for name in exclude_joints if name]
+    lowered = [str(name).lower() for name in action_names]
+    indices = [i for i, name in enumerate(lowered) if any(t == name or t in name for t in tokens)]
+    unresolved = [t for t in tokens if not any(t == name or t in name for name in lowered)]
+
+    if unresolved:
+        raise UnsupportedCheckpointCapabilityError(
+            f"relative_exclude_joints entries {unresolved!r} match no entry in action_feature_names={action_names!r}."
+        )
+    return sorted(set(indices))
+
+
+@dataclass
+class Pi05Config:
+    """π0.5 VLA config (dataclass, not an HF ``PretrainedConfig``)."""
+
+    # Backbone variants — mapped to Gemma dimensions by ``get_gemma_config``.
+    paligemma_variant: str = "gemma_2b"
+    action_expert_variant: str = "gemma_300m"
+
+    # Action chunk shape.
+    chunk_size: int = 50
+    # The stateless OpenPI endpoint returns one complete predicted chunk.
+    n_action_steps: int = 50
+    max_action_dim: int = 32
+    max_state_dim: int = 32
+
+    # Flow-matching denoising schedule.
+    num_inference_steps: int = 10
+    # Sinusoidal timestep embedding periods (must match OpenPI/LeRobot).
+    min_period: float = 4e-3
+    max_period: float = 4.0
+
+    # Image preprocessing. π0.5/SigLIP only support square inputs.
+    image_resolution: tuple[int, int] = (224, 224)
+    # π0.5 pads text to 200 tokens (π0 uses 48). The prompt now also carries the
+    # serialized state, which is why it is so much longer.
+    tokenizer_max_length: int = 200
+    # Number of camera slots the model attends to (real + padded).
+    max_cameras: int = 3
+
+    # Bins the normalized state is discretized into before it enters the prompt.
+    # Ref: openpi PaliGemmaTokenizer.tokenize().
+    state_num_bins: int = 256
+
+    # Weight dtype the checkpoint was saved in.
+    dtype: str = "float32"
+
+    # ── Relative actions ──────────────────────────────────────────────
+    # True when the checkpoint was trained on actions relative to the current
+    # state. Its ``norm_stats`` are then in relative space, so serving it without
+    # the transform silently yields wrong actions — the weights look identical
+    # either way.
+    use_relative_actions: bool = False
+    # Joint names kept absolute (gripper open/close is an absolute quantity).
+    relative_exclude_joints: list[str] = field(default_factory=lambda: ["gripper"])
+    # Needed to resolve ``relative_exclude_joints``; there is no dataset to
+    # fall back on at serving time.
+    action_feature_names: list[str] | None = None
+
+    # Per-dataset normalization stats (schema matches LeRobot's
+    # ``NormalizerProcessorStep``). ``None`` means identity / pass-through.
+    # π0.5 defaults to quantile mode; see ``processor_pi05.build_norm_stats``.
+    norm_stats: dict | None = None
+
+    # Ordered camera-slot identities. Missing keys retain their slot and are
+    # represented by an empty image with a false mask during preprocessing.
+    image_feature_keys: list[str] | None = None
+    # Optional map from raw OpenPI obs keys → ``image_feature_keys`` entries.
+    image_key_map: dict[str, str] = field(default_factory=dict)
+
+    # Checkpoint feature schemas. The input schema determines camera order and
+    # the state width serialized into the prompt; the output schema determines
+    # the unpadded action width returned on the wire.
+    input_features: dict[str, Any] = field(default_factory=dict)
+    output_features: dict[str, Any] = field(default_factory=dict)
+    # OpenPI handshake metadata from the deploy config. Construction validates
+    # it against the resolved checkpoint contract.
+    policy_server_config: dict[str, Any] = field(default_factory=dict)
+
+    # Derived from output_features[ACTION].shape; never accepted as a second
+    # source of truth in config.json.
+    action_dim: int = field(init=False)
+    # Derived from input_features[OBS_STATE].shape — the number of values the
+    # prompt serializes, not a padding target. See processor_pi05.as_state_vector.
+    state_dim: int = field(init=False)
+
+    def __post_init__(self) -> None:
+        # Coerce list → tuple (JSON has no tuples). Squareness is a real
+        # constraint: SigLIP only takes square inputs.
+        res = self.image_resolution
+        if not isinstance(res, (tuple, list)) or len(res) != 2 or res[0] != res[1]:
+            raise ValueError(f"π0.5 expects a square image_resolution (H == W); got {res!r}.")
+        self.image_resolution = (int(res[0]), int(res[1]))
+
+        if self.n_action_steps != self.chunk_size:
+            raise UnsupportedCheckpointCapabilityError(
+                "The stateless OpenPI serving path returns one complete action chunk and "
+                f"does not support n_action_steps={self.n_action_steps} with "
+                f"chunk_size={self.chunk_size}."
+            )
+        # Mirrors Pi05Pipeline.SUPPORTED_DTYPES. This field records what the
+        # *checkpoint* declares; the dtype the weights are actually cast to comes
+        # from the top-level OmniDiffusionConfig and is validated there.
+        if self.dtype not in SUPPORTED_DTYPE_NAMES:
+            raise ValueError(f"dtype must be one of {sorted(SUPPORTED_DTYPE_NAMES)}, got {self.dtype!r}.")
+
+        # Derive the camera order from input_features if not given explicitly.
+        if self.image_feature_keys is None and self.input_features:
+            self.image_feature_keys = [key for key in self.input_features if key.startswith(OBS_IMAGES + ".")]
+
+        if self.max_cameras < 1:
+            raise ValueError(f"max_cameras must be at least 1, got {self.max_cameras!r}.")
+        if self.num_inference_steps < 1:
+            # ``dt = -1 / num_steps`` in the Euler loop.
+            raise ValueError(f"num_inference_steps must be at least 1, got {self.num_inference_steps!r}.")
+
+        self._derive_widths()
+        self._validate_norm_stats()
+        self._validate_policy_server_config()
+        self._validate_relative_actions()
+
+    def _validate_norm_stats(self) -> None:
+        """Statistics have to cover the widths the checkpoint declares."""
+        for key, width in (("state", self.state_dim), ("action", self.action_dim)):
+            for name, value in (self.norm_stats or {}).get(key, {}).items():
+                if name != "mode" and len(value) != width:
+                    raise ValueError(f"norm_stats[{key}][{name}] has {len(value)} entries, expected {width}.")
+
+    # ------------------------------------------------------------------
+    # Validation
+    # ------------------------------------------------------------------
+    def _derive_widths(self) -> None:
+        """Read the real state and action widths off the checkpoint schema.
+
+        π0.5 serializes the state into the prompt at its real width, so a 7-joint
+        checkpoint must not be padded out to ``max_state_dim``. The action chunk
+        is cropped to ``action_dim`` on the way out.
+        """
+        state = self.input_features.get(OBS_STATE) or {}
+        action = self.output_features.get(ACTION) or {}
+        if state.get("type", "STATE").upper() != "STATE":
+            raise ValueError(f"input_features[{OBS_STATE!r}].type must be STATE, got {state['type']!r}.")
+        if action.get("type", "ACTION").upper() != "ACTION":
+            raise ValueError(f"output_features[{ACTION!r}].type must be ACTION, got {action['type']!r}.")
+        self.state_dim = int(state["shape"][0]) if state else self.max_state_dim
+        self.action_dim = int(action["shape"][0]) if action else self.max_action_dim
+        if self.state_dim > self.max_state_dim or self.action_dim > self.max_action_dim:
+            raise ValueError(
+                f"Checkpoint declares state_dim={self.state_dim} / action_dim={self.action_dim}, "
+                f"over max_state_dim={self.max_state_dim} / max_action_dim={self.max_action_dim}."
+            )
+
+    def _validate_policy_server_config(self) -> None:
+        """The OpenPI handshake has to advertise the resolved contract."""
+        expected = {
+            "action_horizon": self.chunk_size,
+            "action_dim": self.action_dim,
+            "max_action_dim": self.max_action_dim,
+            "max_cameras": self.max_cameras,
+            "image_resolution": list(self.image_resolution),
+        }
+        for key, value in expected.items():
+            declared = (self.policy_server_config or {}).get(key)
+            if declared is None:
+                continue
+            if key == "image_resolution":
+                declared = list(declared)
+            if declared != value:
+                raise ValueError(
+                    f"policy_server_config.{key}={declared!r} does not match the resolved value {value!r}."
+                )
+
+    def _validate_relative_actions(self) -> None:
+        """Resolve the excluded joints at load, so a bad name fails before serving."""
+        if not self.use_relative_actions or not self.relative_exclude_joints:
+            return
+        if not self.action_feature_names:
+            raise UnsupportedCheckpointCapabilityError(
+                f"relative_exclude_joints={self.relative_exclude_joints!r} needs action_feature_names, "
+                "which the checkpoint does not carry."
+            )
+        resolve_excluded_action_indices(self.relative_exclude_joints, self.action_feature_names)
+
+    # ------------------------------------------------------------------
+    # Constructors
+    # ------------------------------------------------------------------
+    @classmethod
+    def from_pretrained(cls, checkpoint_dir: str | Path) -> Pi05Config:
+        """Build from a checkpoint directory's ``config.json``.
+
+        Normalization stats are *not* in ``config.json``. LeRobot keeps them in
+        the processor sidecar, so they are loaded separately and backfilled
+        here — see :func:`load_lerobot_norm_stats`.
+        """
+        checkpoint_dir = Path(checkpoint_dir)
+        config_path = checkpoint_dir / "config.json"
+        if not config_path.exists():
+            raise FileNotFoundError(f"π0.5 checkpoint is missing required config: {config_path}.")
+        with open(config_path, encoding="utf-8") as f:
+            raw = json.load(f)
+        config = cls.from_model_config(raw)
+
+        if config.norm_stats is None:
+            stats = load_lerobot_norm_stats(checkpoint_dir)
+            if stats:
+                config.norm_stats = stats
+                config._validate_norm_stats()
+        return config
+
+    @classmethod
+    def from_model_config(cls, model_config: dict[str, Any] | None) -> Pi05Config:
+        """Build from a config dict (LeRobot ``config.json`` or deploy yaml)."""
+        if not model_config:
+            return cls()
+
+        raw = dict(model_config)
+        _reject_unsupported_capabilities(raw)
+
+        model_type = raw.pop("type", "pi05")
+        if model_type != "pi05":
+            raise ValueError(f"Expected a π0.5 checkpoint (type='pi05'), got type={model_type!r}.")
+
+        if "image_resolution" in raw:
+            raw["image_resolution"] = tuple(raw["image_resolution"])
+
+        # A config.json carries the whole training recipe; none of it reaches
+        # inference. Capabilities we cannot serve are rejected above instead.
+        allowed = {item.name for item in dataclass_fields(cls) if item.init}
+        filtered = {key: value for key, value in raw.items() if key in allowed}
+        dropped = sorted(set(raw) - allowed)
+        if dropped:
+            logger.debug("π0.5 config: ignoring %d non-runtime key(s): %s", len(dropped), dropped)
+        return cls(**filtered)
+
+
+# ----------------------------------------------------------------------
+# LeRobot normalization-stats sidecar
+# ----------------------------------------------------------------------
+# Stats live beside config.json: ``policy_preprocessor.json`` names a
+# safetensors file per stateful step, keyed ``"<feature_name>.<stat_name>"``.
+_PREPROCESSOR_JSON = "policy_preprocessor.json"
+
+# The mode must come from ``norm_map``: a state_dict carries all of
+# mean/std/min/max/q01/q99 regardless, so guessing from the present keys would
+# read a QUANTILES checkpoint as mean_std and apply a wrong affine map.
+_NORM_MODE_FROM_LEROBOT: dict[str, tuple[str, str, str] | None] = {
+    "IDENTITY": None,
+    "MEAN_STD": ("mean_std", "mean", "std"),
+    "MIN_MAX": ("min_max", "min", "max"),
+    "QUANTILES": ("quantile", "q01", "q99"),
+}
+# Renaming happens in an earlier processor step, so these names are canonical
+# here. VISUAL is absent by design: images are normalized in the processor.
+_NORM_STATS_FEATURES = {OBS_STATE: ("STATE", "state"), ACTION: ("ACTION", "action")}
+
+
+def load_lerobot_norm_stats(checkpoint_dir: str | Path) -> dict[str, dict[str, Any]] | None:
+    """Load normalization stats from a LeRobot checkpoint's processor sidecar.
+
+    Returns a ``norm_stats``-shaped dict (``{"state": {...}, "action": {...}}``)
+    carrying an **explicit** ``mode``, or ``None`` when the checkpoint ships no
+    stats. ``lerobot/pi05_base`` is the latter case: its normalizer step has no
+    ``state_file``, i.e. normalization is identity and the client is expected to
+    send an already-normalized state.
+
+    Raises on a mode we cannot reproduce rather than serving the checkpoint with
+    the wrong transform, which fails silently — a wrongly normalized state still
+    yields a plausible-looking action chunk.
+    """
+    checkpoint_dir = Path(checkpoint_dir)
+    preprocessor_path = checkpoint_dir / _PREPROCESSOR_JSON
+    if not preprocessor_path.exists():
+        return None
+    with open(preprocessor_path, encoding="utf-8") as f:
+        steps = json.load(f).get("steps", [])
+
+    step = next((s for s in steps if s.get("registry_name") == "normalizer_processor"), {})
+    state_file = step.get("state_file")
+    if not state_file:
+        logger.info(
+            "π0.5 config: %s declares no normalizer state file; the state passes through.",
+            _PREPROCESSOR_JSON,
+        )
+        return None
+    state_path = checkpoint_dir / state_file
+    if not state_path.exists():
+        raise FileNotFoundError(f"{preprocessor_path} declares normalizer state {state_file!r}, which is missing.")
+
+    norm_map = {str(k).upper(): str(v).upper() for k, v in ((step.get("config") or {}).get("norm_map") or {}).items()}
+
+    import safetensors.torch
+
+    flat = safetensors.torch.load_file(str(state_path))
+
+    stats: dict[str, dict[str, Any]] = {}
+    for feature_name, (feature_type, stats_key) in _NORM_STATS_FEATURES.items():
+        lerobot_mode = norm_map.get(feature_type, "IDENTITY")
+        if lerobot_mode not in _NORM_MODE_FROM_LEROBOT:
+            raise ValueError(
+                f"π0.5 cannot reproduce normalization mode {lerobot_mode!r} for {feature_type}. "
+                f"Expected one of {sorted(_NORM_MODE_FROM_LEROBOT)}."
+            )
+        selected = _NORM_MODE_FROM_LEROBOT[lerobot_mode]
+        if selected is None:
+            continue
+
+        mode, *stat_names = selected
+        missing = [name for name in stat_names if f"{feature_name}.{name}" not in flat]
+        if missing:
+            raise ValueError(
+                f"{feature_type} declares {lerobot_mode} normalization but the state file is missing {missing}."
+            )
+        stats[stats_key] = {"mode": mode} | {name: flat[f"{feature_name}.{name}"].tolist() for name in stat_names}
+
+    if not stats:
+        return None
+    logger.info(
+        "π0.5 config: loaded normalization stats from %s — %s.",
+        state_file,
+        ", ".join(f"{key}={value['mode']}" for key, value in sorted(stats.items())),
+    )
+    return stats
+
+
+# ----------------------------------------------------------------------
+# Checkpoint-boundary rule
+# ----------------------------------------------------------------------
+# Each entry: config key → (is this value *enabled*?, why we cannot serve it).
+# Every capability here changes what a *correct* action chunk looks like, and
+# none is visible in the weights, so a checkpoint that enables one is refused
+# rather than served plausibly wrong. See recipes/lerobot/Pi05.md for the
+# longer explanations.
+#
+# The predicate is per key because these are not all flags: ``n_obs_steps`` is
+# a count whose supported value is 1, and an empty ``rtc_config`` still selects
+# RTC — LeRobot's ``RTCConfig`` defaults ``enabled=True``.
+_UNSUPPORTED: dict[str, tuple[Callable[[Any], bool], str]] = {
+    "use_peft": (bool, "adapter-aware loading; this loader takes a merged checkpoint only"),
+    "empty_cameras": (bool, "mutates the input schema; declare camera features explicitly instead"),
+    "use_visual_memory": (bool, "MEM needs a per-session observation history, which this path does not keep"),
+    "use_proprioceptive_memory": (
+        bool,
+        "MEM sends the state as a projected token, not the discretized prompt built here",
+    ),
+    "rtc_config": (
+        lambda value: value is not None,
+        "RTC needs prefix guidance in the denoising loop and per-request chunk carry-over",
+    ),
+    "n_obs_steps": (
+        lambda value: bool(value) and value > 1,
+        "an observation history; this path is first-order Markov",
+    ),
+}
+
+
+def _reject_unsupported_capabilities(raw: dict[str, Any]) -> None:
+    """Raise if the checkpoint enables something we do not consume.
+
+    Scope note: this validates that we correctly consume *the checkpoint we were
+    handed*. Choosing which checkpoint to load belongs to the caller.
+    """
+    problems = [
+        f"  - {key}={raw[key]!r}: {why}"
+        for key, (is_enabled, why) in _UNSUPPORTED.items()
+        if key in raw and is_enabled(raw[key])
+    ]
+    if problems:
+        raise UnsupportedCheckpointCapabilityError(
+            "This checkpoint declares capabilities the vllm-omni π0.5 implementation "
+            "does not support:\n" + "\n".join(problems) + "\nServing it anyway would "
+            "produce plausible-looking but wrong actions."
+        )
+
+    # Not an error: it records that the checkpoint was trained with clean action
+    # prefixes sampled in, which is a property of training rather than a request
+    # to run RTC. Such a checkpoint is still correct to serve without RTC.
+    delay = raw.get("rtc_training_max_delay")
+    if delay:
+        logger.info(
+            "π0.5 config: checkpoint was trained with rtc_training_max_delay=%s. "
+            "Real-Time Chunking is not implemented here; serving proceeds without it.",
+            delay,
+        )
diff --git a/vllm_omni/diffusion/models/pi05/modeling_pi05.py b/vllm_omni/diffusion/models/pi05/modeling_pi05.py
new file mode 100644
index 000000000..a792ae0ef
--- /dev/null
+++ b/vllm_omni/diffusion/models/pi05/modeling_pi05.py
@@ -0,0 +1,898 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Inference-only π0.5 VLA math kernel for vllm-omni.
+
+Only the math that turns a robot observation into an action chunk; no serving or
+request glue. Deliberately shaped like ``models/pi0/modeling_pi0.py`` so the two
+can later be factored into a shared Pi-family module (RFC step 2) on a
+"behaviour unchanged" review.
+
+π0.5 = PaliGemma (SigLIP vision + Gemma 2B LM) prefix + Gemma 300M action expert
+suffix + flow-matching head. Where π0 projects the robot state through
+``state_proj``, π0.5 discretizes it into prompt tokens — so there is no
+``state_proj`` layer, ``sample_actions`` takes no ``state`` argument, and the
+suffix is action tokens only, which drops π0's leading state-token boundary from
+the suffix attention mask and leaves ``[1] + [0] * (horizon - 1)``.
+
+π0.5 is nonetheless the *larger* model: the 37 AdaRMS ``dense`` projections add
+~116M parameters against the ~8K that ``state_proj`` saves. (LeRobot's README
+says otherwise; the checkpoint disagrees.)
+
+Reference implementations:
+   - OpenPI: openpi/src/openpi/models_pytorch/pi0_pytorch.py, gemma_pytorch.py
+   - LeRobot: lerobot/src/lerobot/policies/pi05/modeling_pi05.py
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from collections.abc import Iterable
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers.models.auto import CONFIG_MAPPING
+from transformers.models.gemma.modeling_gemma import (
+    GemmaForCausalLM,
+    apply_rotary_pos_emb,
+)
+from transformers.models.paligemma.modeling_paligemma import (
+    PaliGemmaForConditionalGeneration,
+)
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+logger = logging.getLogger(__name__)
+
+# ──────────────────────────────────────────────────────────────────────
+# Constants
+# ──────────────────────────────────────────────────────────────────────
+DEFAULT_ACTION_DIM = 32
+DEFAULT_ACTION_HORIZON = 50
+DEFAULT_MAX_TOKEN_LEN = 200  # π0 uses 48
+DEFAULT_NUM_INFERENCE_STEPS = 10
+DEFAULT_IMAGE_RESOLUTION = (224, 224)  # openpi/models/model.py IMAGE_RESOLUTION
+DEFAULT_STATE_NUM_BINS = 256  # openpi PaliGemmaTokenizer.tokenize()
+
+# Large negative value to fill masked-out positions in a float attention mask.
+# Matches OpenPI's constant exactly so that numerics line up during parity.
+# Ref: openpi/src/openpi/models/gemma.py
+OPENPI_ATTENTION_MASK_VALUE = -2.3819763e38
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Gemma variant configs (matches openpi/models/gemma.py get_config)
+# ──────────────────────────────────────────────────────────────────────
+class GemmaVariantConfig:
+    def __init__(self, width, depth, mlp_dim, num_heads, num_kv_heads, head_dim):
+        self.width = width
+        self.depth = depth
+        self.mlp_dim = mlp_dim
+        self.num_heads = num_heads
+        self.num_kv_heads = num_kv_heads
+        self.head_dim = head_dim
+
+
+def get_gemma_config(variant: str) -> GemmaVariantConfig:
+    if variant == "gemma_2b":
+        return GemmaVariantConfig(2048, 18, 16384, 8, 1, 256)
+    elif variant == "gemma_300m":
+        return GemmaVariantConfig(1024, 18, 4096, 8, 1, 256)
+    else:
+        raise ValueError(f"Unknown variant: {variant}")
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Utility functions (match openpi/models_pytorch/pi0_pytorch.py)
+# ──────────────────────────────────────────────────────────────────────
+def create_sinusoidal_pos_embedding(
+    time: torch.Tensor,
+    dimension: int,
+    min_period: float = 4e-3,
+    max_period: float = 4.0,
+    device: torch.device = None,
+) -> torch.Tensor:
+    """Compute a sine/cosine positional embedding for scalar timesteps.
+
+    Ref: openpi/models_pytorch/pi0_pytorch.py create_sinusoidal_pos_embedding
+    """
+    if dimension % 2 != 0:
+        raise ValueError(f"dimension ({dimension}) must be divisible by 2")
+    if time.ndim != 1:
+        raise ValueError("time tensor must be 1-D (batch_size,)")
+    if device is None:
+        device = time.device
+
+    # Use float64 for the log-linear sweep and for the inner products, to
+    # match the reference implementation's numerical behaviour exactly.
+    dtype = torch.float64
+    fraction = torch.linspace(0.0, 1.0, dimension // 2, dtype=dtype, device=device)
+    period = min_period * (max_period / min_period) ** fraction
+    scaling_factor = 1.0 / period * 2 * math.pi
+    sin_input = scaling_factor[None, :] * time[:, None].to(dtype)
+    return torch.cat([torch.sin(sin_input), torch.cos(sin_input)], dim=1)
+
+
+def make_att_2d_masks(pad_masks: torch.Tensor, att_masks: torch.Tensor) -> torch.Tensor:
+    """Build a 2D attention mask from a padding mask and an autoregressive mask.
+
+    Ref: openpi/models_pytorch/pi0_pytorch.py make_att_2d_masks
+    """
+    if att_masks.ndim != 2:
+        raise ValueError(f"att_masks must be 2-D, got {att_masks.ndim}-D")
+    if pad_masks.ndim != 2:
+        raise ValueError(f"pad_masks must be 2-D, got {pad_masks.ndim}-D")
+
+    cumsum = torch.cumsum(att_masks, dim=1)
+    att_2d_masks = cumsum[:, None, :] <= cumsum[:, :, None]
+    pad_2d_masks = pad_masks[:, None, :] * pad_masks[:, :, None]
+    return att_2d_masks & pad_2d_masks
+
+
+def prepare_attention_masks_4d(att_2d_masks: torch.Tensor) -> torch.Tensor:
+    """Convert ``(B, S, S)`` bool masks to ``(B, 1, S, S)`` float masks.
+
+    ``True`` → 0.0 (attend), ``False`` → ``OPENPI_ATTENTION_MASK_VALUE``.
+    """
+    att_2d_masks_4d = att_2d_masks[:, None, :, :]
+    return torch.where(att_2d_masks_4d, 0.0, OPENPI_ATTENTION_MASK_VALUE)
+
+
+class Pi05AdaRMSNorm(nn.Module):
+    """Adaptive RMSNorm conditioned on the flow-matching timestep.
+
+    π0 conditions on time by *concatenating* a time embedding onto each action
+    embedding. π0.5 instead feeds the time embedding into every action-expert
+    norm, which produces a per-layer ``(scale, shift, gate)`` triple::
+
+        y    = norm(x) * (1 + scale) + shift
+        out  = residual + gate * sublayer(y)
+
+    ``dense`` is zero-initialized, so an untrained model starts as the identity
+    modulation with a closed gate — matching OpenPI's parameterization.
+
+    Note the shape of the unconditioned branch: ``normed * (1 + weight)`` with
+    ``weight`` zero-initialized, which is exactly ``transformers``'
+    ``GemmaRMSNorm``. That equivalence is why only the *expert* norms need
+    replacing here and the PaliGemma prefix can keep stock Gemma layers.
+    """
+
+    def __init__(self, dim: int, eps: float = 1e-6, cond_dim: int | None = None):
+        super().__init__()
+        self.eps = eps
+        self.dim = dim
+        self.cond_dim = cond_dim
+        if cond_dim is not None:
+            self.dense = nn.Linear(cond_dim, dim * 3, bias=True)
+            nn.init.zeros_(self.dense.weight)
+            nn.init.zeros_(self.dense.bias)
+            self.weight = None
+        else:
+            self.weight = nn.Parameter(torch.zeros(dim))
+            self.dense = None
+
+    def _norm(self, x: torch.Tensor) -> torch.Tensor:
+        var = torch.mean(torch.square(x.float()), dim=-1, keepdim=True)
+        return x.float() * torch.rsqrt(var + self.eps)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        cond: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Return ``(normed, gate)``; ``gate`` is ``None`` in the unconditioned case."""
+        dtype = x.dtype
+        normed = self._norm(x)
+        if self.dense is None:
+            normed = normed * (1.0 + self.weight.float())
+            return normed.to(dtype), None
+
+        if cond is None:
+            # A conditioned norm silently falling back to an unconditioned one
+            # would drop the entire timestep signal and still return a
+            # well-shaped, finite tensor.
+            raise ValueError(
+                "Pi05AdaRMSNorm was built with cond_dim="
+                f"{self.cond_dim} but called without an AdaRMS conditioning vector."
+            )
+
+        if cond.shape[-1] != self.cond_dim:
+            raise ValueError(f"Expected AdaRMS cond dim {self.cond_dim}, got {cond.shape[-1]}")
+
+        modulation = self.dense(cond.to(self.dense.weight.dtype))
+        if x.ndim == 3:
+            # (B, 3*dim) → (B, 1, 3*dim), broadcast across the token axis: the
+            # timestep is a per-sample scalar, identical for every action token.
+            modulation = modulation.unsqueeze(1)
+        scale, shift, gate = modulation.chunk(3, dim=-1)
+        normed = normed * (1.0 + scale.float()) + shift.float()
+        return normed.to(dtype), gate.to(dtype)
+
+
+def _gated_residual(residual: torch.Tensor, out: torch.Tensor, gate: torch.Tensor | None) -> torch.Tensor:
+    if gate is None:
+        return residual + out
+    return residual + gate * out
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Dual-backbone: PaliGemma + AdaRMS action expert
+# ──────────────────────────────────────────────────────────────────────
+def _repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+    """Repeat KV heads for grouped-query attention.
+
+    ``(B, num_kv_heads, S, D) → (B, num_kv_heads * n_rep, S, D)``.
+    """
+    if n_rep == 1:
+        return hidden_states
+    b, nh, s, d = hidden_states.shape
+    hidden_states = hidden_states[:, :, None, :, :].expand(b, nh, n_rep, s, d)
+    return hidden_states.reshape(b, nh * n_rep, s, d)
+
+
+def _attend(query_states, key_states, value_states, attention_mask, num_kv_groups, scaling):
+    """Manual eager attention: ``softmax(Q Kᵀ · scale + mask) · V``.
+
+    The mask is sliced to ``key_states.shape[-2]`` so the same
+    ``(B, 1, Q, prefix+suffix)`` mask works in both the prefix pass (K length =
+    prefix) and the suffix pass (K length = prefix + suffix).
+    """
+    k = _repeat_kv(key_states, num_kv_groups)
+    v = _repeat_kv(value_states, num_kv_groups)
+    attn_weights = torch.matmul(query_states, k.transpose(2, 3)) * scaling
+    if attention_mask is not None:
+        attn_weights = attn_weights + attention_mask[:, :, :, : k.shape[-2]]
+    attn_weights = F.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+    return torch.matmul(attn_weights, v)
+
+
+def _match(tensor: torch.Tensor, module: nn.Module) -> torch.Tensor:
+    """Cast ``tensor`` to the dtype ``module``'s weight expects."""
+    return tensor.to(module.weight.dtype) if tensor.dtype != module.weight.dtype else tensor
+
+
+def _compute_layer_prefix_only(layer_idx, hidden_states, attention_mask, position_ids, paligemma):
+    """Run one PaliGemma LM layer on the prefix, returning the layer output and
+    the post-RoPE ``(k, v)`` for the suffix pass.
+
+    Identical to π0: the prefix backbone is unchanged in π0.5 (no AdaRMS —
+    there is no timestep in the prefix).
+    """
+    model = paligemma.model.language_model
+    layer = model.layers[layer_idx]
+    residual = hidden_states
+    x = _match(layer.input_layernorm(hidden_states), layer.self_attn.q_proj)
+
+    hidden_shape = (*x.shape[:-1], -1, layer.self_attn.head_dim)
+    q = layer.self_attn.q_proj(x).view(hidden_shape).transpose(1, 2)
+    k = layer.self_attn.k_proj(x).view(hidden_shape).transpose(1, 2)
+    v = layer.self_attn.v_proj(x).view(hidden_shape).transpose(1, 2)
+
+    cos, sin = model.rotary_emb(v, position_ids)
+    q, k = apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1)
+
+    att = _attend(
+        q,
+        k,
+        v,
+        attention_mask,
+        num_kv_groups=layer.self_attn.num_key_value_groups,
+        scaling=1.0 / math.sqrt(layer.self_attn.head_dim),
+    )
+    att = att.transpose(1, 2).reshape(q.shape[0], -1, q.shape[1] * layer.self_attn.head_dim)
+
+    out = layer.self_attn.o_proj(_match(att, layer.self_attn.o_proj)) + residual
+    after_resid = out
+    normed = layer.post_attention_layernorm(out)
+    out = layer.mlp(_match(normed, layer.mlp.up_proj)) + after_resid
+    return out, (k, v)
+
+
+def _compute_layer_suffix_only(
+    layer_idx,
+    hidden_states,
+    prefix_kv,
+    attention_mask,
+    position_ids,
+    gemma_expert,
+    adarms_cond,
+):
+    """Run one action-expert layer on the suffix with AdaRMS conditioning.
+
+    This is where π0.5 diverges from π0. Both norms are
+    :class:`Pi05AdaRMSNorm` and each returns a gate that scales its sublayer's
+    contribution to the residual stream.
+    """
+    layer = gemma_expert.model.layers[layer_idx]
+
+    residual = hidden_states
+    x, gate = layer.input_layernorm(hidden_states, adarms_cond)
+    x = _match(x, layer.self_attn.q_proj)
+
+    hidden_shape = (*x.shape[:-1], -1, layer.self_attn.head_dim)
+    q = layer.self_attn.q_proj(x).view(hidden_shape).transpose(1, 2)
+    k_suf = layer.self_attn.k_proj(x).view(hidden_shape).transpose(1, 2)
+    v_suf = layer.self_attn.v_proj(x).view(hidden_shape).transpose(1, 2)
+
+    # RoPE frequencies are shared between PaliGemma and the expert.
+    cos, sin = gemma_expert.model.rotary_emb(v_suf, position_ids)
+    q, k_suf = apply_rotary_pos_emb(q, k_suf, cos, sin, unsqueeze_dim=1)
+
+    # Concatenate cached prefix K/V (possibly different dtype) with suffix K/V.
+    k_prefix, v_prefix = prefix_kv
+    k = torch.cat([k_prefix.to(k_suf.dtype), k_suf], dim=2)
+    v = torch.cat([v_prefix.to(v_suf.dtype), v_suf], dim=2)
+
+    att = _attend(
+        q,
+        k,
+        v,
+        attention_mask,
+        num_kv_groups=layer.self_attn.num_key_value_groups,
+        scaling=1.0 / math.sqrt(layer.self_attn.head_dim),
+    )
+    att = att.transpose(1, 2).reshape(q.shape[0], -1, q.shape[1] * layer.self_attn.head_dim)
+
+    hidden_states = _gated_residual(residual, layer.self_attn.o_proj(_match(att, layer.self_attn.o_proj)), gate)
+
+    residual = hidden_states
+    x, gate = layer.post_attention_layernorm(hidden_states, adarms_cond)
+    return _gated_residual(residual, layer.mlp(_match(x, layer.mlp.up_proj)), gate)
+
+
+class PaliGemmaWithActionExpertPi05(nn.Module):
+    """Dual-backbone transformer: PaliGemma (Gemma 2B) + AdaRMS expert (300M).
+
+    Same two-mode dispatch as π0 (``prefix_only`` / ``suffix_only``), with one
+    structural change: after building a stock ``GemmaForCausalLM`` expert, every
+    norm in it is swapped for a :class:`Pi05AdaRMSNorm` carrying a ``dense``
+    conditioning projection.
+
+    Swapping in place — rather than subclassing ``GemmaModel`` as #4419 does —
+    keeps the module tree, and therefore the checkpoint key layout, identical to
+    the expert's stock layout apart from the norms themselves.
+    """
+
+    def __init__(self, vlm_config, action_expert_config):
+        super().__init__()
+
+        # PaliGemma prefix: identical to π0. It sees no timestep, so no AdaRMS.
+        vlm_config_hf = CONFIG_MAPPING["paligemma"]()
+        vlm_config_hf._vocab_size = 257152
+        vlm_config_hf.image_token_index = 257152
+        vlm_config_hf.text_config.hidden_size = vlm_config.width
+        vlm_config_hf.text_config.intermediate_size = vlm_config.mlp_dim
+        vlm_config_hf.text_config.num_attention_heads = vlm_config.num_heads
+        vlm_config_hf.text_config.head_dim = vlm_config.head_dim
+        vlm_config_hf.text_config.num_hidden_layers = vlm_config.depth
+        vlm_config_hf.text_config.num_key_value_heads = vlm_config.num_kv_heads
+        vlm_config_hf.text_config.hidden_activation = "gelu_pytorch_tanh"
+        vlm_config_hf.text_config.dtype = "float32"
+        vlm_config_hf.text_config.vocab_size = 257152
+        vlm_config_hf.vision_config.intermediate_size = 4304
+        vlm_config_hf.vision_config.projection_dim = 2048
+        vlm_config_hf.vision_config.projector_hidden_act = "gelu_fast"
+        vlm_config_hf.vision_config.dtype = "float32"
+
+        action_expert_config_hf = CONFIG_MAPPING["gemma"](
+            head_dim=action_expert_config.head_dim,
+            hidden_size=action_expert_config.width,
+            intermediate_size=action_expert_config.mlp_dim,
+            num_attention_heads=action_expert_config.num_heads,
+            num_hidden_layers=action_expert_config.depth,
+            num_key_value_heads=action_expert_config.num_kv_heads,
+            vocab_size=257152,
+            hidden_activation="gelu_pytorch_tanh",
+            dtype="float32",
+        )
+
+        self.paligemma = PaliGemmaForConditionalGeneration(config=vlm_config_hf)
+        self.gemma_expert = GemmaForCausalLM(config=action_expert_config_hf)
+        # The action expert doesn't embed tokens — it only consumes the
+        # suffix action embeddings we feed in.
+        self.gemma_expert.model.embed_tokens = None
+
+        self.adarms_cond_dim = action_expert_config.width
+        self._install_adarms_norms(action_expert_config)
+
+    def _install_adarms_norms(self, action_expert_config) -> None:
+        """Replace every action-expert RMSNorm with a conditioned AdaRMS norm."""
+        expert = self.gemma_expert.model
+        eps = getattr(self.gemma_expert.config, "rms_norm_eps", 1e-6)
+        width = action_expert_config.width
+        for layer in expert.layers:
+            layer.input_layernorm = Pi05AdaRMSNorm(width, eps=eps, cond_dim=self.adarms_cond_dim)
+            layer.post_attention_layernorm = Pi05AdaRMSNorm(width, eps=eps, cond_dim=self.adarms_cond_dim)
+        expert.norm = Pi05AdaRMSNorm(width, eps=eps, cond_dim=self.adarms_cond_dim)
+
+    def embed_image(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        """Encode images with SigLIP vision tower + PaliGemma projector.
+
+        The two steps are run explicitly rather than via
+        ``PaliGemmaModel.get_image_features`` because that helper divides the
+        projector output by ``sqrt(text_hidden_size)``. Being explicit keeps the
+        scale unambiguous and matches π0 exactly (SigLIP is unchanged in π0.5).
+        """
+        # Shapes: pixel_values (B, 3, 224, 224) → SigLIP (B, 256, 1152)
+        #                                      → projector (B, 256, 2048)
+        vision_outputs = self.paligemma.model.vision_tower(pixel_values)
+        image_features = vision_outputs.last_hidden_state
+        return self.paligemma.model.multi_modal_projector(image_features)
+
+    def embed_language_tokens(self, tokens: torch.Tensor) -> torch.Tensor:
+        """Embed language tokens, returning the ``* sqrt(hidden)``-scaled embedding.
+
+        The scaling location moved across transformers releases: at ≤5.3 the
+        normalizer lives inside ``GemmaModel.forward`` (which we bypass), and at
+        ≥5.4 ``GemmaTextScaledWordEmbedding`` self-applies it. Detect and avoid
+        double-scaling.
+        """
+        embed_tokens = self.paligemma.model.language_model.embed_tokens
+        lang_emb = embed_tokens(tokens)
+        if getattr(embed_tokens, "embed_scale", None) is None:
+            lang_emb = lang_emb * math.sqrt(lang_emb.shape[-1])
+        return lang_emb
+
+    def forward(
+        self,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values=None,
+        inputs_embeds: list[torch.Tensor | None] | None = None,
+        use_cache: bool = False,
+        adarms_cond: torch.Tensor | None = None,
+    ):
+        """Dispatch to prefix_only / suffix_only and return
+        ``([prefix_out, suffix_out], past_key_values_or_None)``.
+        """
+        num_layers = self.paligemma.config.text_config.num_hidden_layers
+        pali_lm = self.paligemma.model.language_model
+        expert_lm = self.gemma_expert.model
+
+        if inputs_embeds[1] is None:
+            hidden_states = inputs_embeds[0]
+            kv_list: list[tuple[torch.Tensor, torch.Tensor]] = []
+            for layer_idx in range(num_layers):
+                hidden_states, kv = _compute_layer_prefix_only(
+                    layer_idx,
+                    hidden_states,
+                    attention_mask,
+                    position_ids,
+                    paligemma=self.paligemma,
+                )
+                kv_list.append(kv)
+            hidden_states = pali_lm.norm(hidden_states)
+            return [hidden_states, None], (kv_list if use_cache else None)
+
+        if inputs_embeds[0] is not None:
+            raise ValueError(
+                "PaliGemmaWithActionExpertPi05.forward only supports prefix-only "
+                "or suffix-only dispatch; got both inputs_embeds populated."
+            )
+        if not isinstance(past_key_values, list):
+            raise TypeError(
+                "suffix_only forward expects past_key_values to be the "
+                "list[(k, v)] produced by a previous prefix_only forward; "
+                f"got {type(past_key_values)}"
+            )
+        hidden_states = inputs_embeds[1]
+        for layer_idx in range(num_layers):
+            hidden_states = _compute_layer_suffix_only(
+                layer_idx,
+                hidden_states,
+                past_key_values[layer_idx],
+                attention_mask,
+                position_ids,
+                gemma_expert=self.gemma_expert,
+                adarms_cond=adarms_cond,
+            )
+        hidden_states, _ = expert_lm.norm(hidden_states, adarms_cond)
+        return [None, hidden_states], None
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Main π0.5 Model
+# ──────────────────────────────────────────────────────────────────────
+class Pi05ForActionPrediction(nn.Module):
+    """π0.5 VLA model for robot action prediction via flow matching.
+
+    Inference flow:
+      1. Embed prefix (images + language, where the language already carries the
+         discretized state) → prefix tokens.
+      2. Forward prefix through PaliGemma → layer-wise KV cache.
+      3. For each denoising step ``t = 1.0, 1-dt, ..., 0``:
+         a. Embed the timestep → an AdaRMS conditioning vector.
+         b. Embed the suffix (action tokens only).
+         c. Forward the suffix through the AdaRMS action expert.
+         d. ``x_t = x_t + dt * v_t`` (Euler integration).
+      4. Return ``x_0`` as the predicted action chunk.
+    """
+
+    def __init__(self, config, quant_config=None, prefix: str = ""):
+        super().__init__()
+        # ``quant_config`` is accepted for interface compatibility but unused —
+        # quant_config is not plumbed through; the weight dtype comes from the pipeline.
+        del quant_config
+        self.config = config
+
+        self.action_dim = getattr(config, "max_action_dim", DEFAULT_ACTION_DIM)
+        self.max_state_dim = getattr(config, "max_state_dim", self.action_dim)
+        self.action_horizon = getattr(config, "chunk_size", DEFAULT_ACTION_HORIZON)
+        self.num_inference_steps = getattr(config, "num_inference_steps", DEFAULT_NUM_INFERENCE_STEPS)
+
+        paligemma_variant = getattr(config, "paligemma_variant", "gemma_2b")
+        action_expert_variant = getattr(config, "action_expert_variant", "gemma_300m")
+        vlm_config = get_gemma_config(paligemma_variant)
+        expert_config = get_gemma_config(action_expert_variant)
+        self.vlm_width = vlm_config.width
+        self.expert_width = expert_config.width
+
+        # Dual backbone
+        self.paligemma_with_expert = PaliGemmaWithActionExpertPi05(vlm_config, expert_config)
+
+        # Action chunk projections.
+        self.action_in_proj = nn.Linear(self.action_dim, self.expert_width)
+        self.action_out_proj = nn.Linear(self.expert_width, self.action_dim)
+
+        # π0.5 timestep MLP: (W → W → W) with SiLU, feeding AdaRMS.
+        # π0 instead has action_time_mlp_{in,out} of shape (2W → W → W) because
+        # it concatenates the time embedding onto the action embedding.
+        # NOTE: there is deliberately **no** ``state_proj`` here — that is the
+        # π0-only continuous-state path.
+        self.time_mlp_in = nn.Linear(self.expert_width, self.expert_width)
+        self.time_mlp_out = nn.Linear(self.expert_width, self.expert_width)
+
+    # ── Prefix embedding ─────────────────────────────────────────────
+    def embed_prefix(
+        self,
+        images: list[torch.Tensor],
+        image_masks: list[torch.Tensor],
+        lang_tokens: torch.Tensor,
+        lang_masks: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Build prefix embeddings, per-token padding mask, and AR mask.
+
+        Prefix tokens form ``[img_cam_0..., ..., lang_tokens...]`` with fully
+        bidirectional attention (all-zero ``att_masks``). Identical to π0 — the
+        state is inside ``lang_tokens``, so nothing here changes shape-wise.
+
+        Cameras are embedded one at a time; each call is ``(B, 3, 224, 224)``.
+        The number of slots is fixed by ``config.max_cameras`` for the deployed
+        model; missing cameras occupy their slot with a false image mask.
+        """
+        num_views = len(images)
+        if len(image_masks) != num_views:
+            raise ValueError(
+                f"images and image_masks must contain the same number of views, got {num_views} and {len(image_masks)}."
+            )
+        max_cameras = int(self.config.max_cameras)
+        if num_views != max_cameras:
+            raise ValueError(f"Expected exactly max_cameras={max_cameras} image views, got {num_views}.")
+
+        embs: list[torch.Tensor] = []
+        pad_masks: list[torch.Tensor] = []
+        att_masks: list[int] = []
+
+        for img, img_mask in zip(images, image_masks):
+            img_emb = self.paligemma_with_expert.embed_image(img)
+            bsize, num_img_embs = img_emb.shape[:2]
+            embs.append(img_emb)
+            pad_masks.append(img_mask[:, None].expand(bsize, num_img_embs))
+            att_masks += [0] * num_img_embs
+
+        lang_emb = self.paligemma_with_expert.embed_language_tokens(lang_tokens)
+        embs.append(lang_emb)
+        pad_masks.append(lang_masks)
+        att_masks += [0] * lang_emb.shape[1]
+
+        embs = torch.cat(embs, dim=1)
+        pad_masks = torch.cat(pad_masks, dim=1)
+        att_masks = torch.tensor(att_masks, dtype=torch.bool, device=embs.device)
+        att_masks = att_masks[None, :].expand(pad_masks.shape[0], -1)
+
+        return embs, pad_masks, att_masks
+
+    # ── Timestep + suffix embedding ──────────────────────────────────
+    def embed_timestep(self, timestep: torch.Tensor) -> torch.Tensor:
+        """Timestep → AdaRMS conditioning vector ``(B, expert_width)``.
+
+        ``silu(time_mlp_out(silu(time_mlp_in(sinusoid(t)))))``. The trailing
+        SiLU is part of the reference implementation — dropping it is a silent
+        numerical error, not a crash.
+        """
+        model_dtype = self.action_in_proj.weight.dtype
+        time_emb = create_sinusoidal_pos_embedding(
+            timestep,
+            self.action_in_proj.out_features,
+            min_period=getattr(self.config, "min_period", 4e-3),
+            max_period=getattr(self.config, "max_period", 4.0),
+            device=timestep.device,
+        ).to(dtype=model_dtype)
+        time_cond = self.time_mlp_in(time_emb)
+        time_cond = F.silu(time_cond)
+        time_cond = self.time_mlp_out(time_cond)
+        return F.silu(time_cond)
+
+    def embed_suffix(
+        self,
+        noisy_actions: torch.Tensor,
+        timestep: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Build the suffix: **action tokens only**, plus the AdaRMS condition.
+
+        π0's suffix is ``[state_token, action_tokens×H]`` with an AR mask of
+        ``[1, 1, 0...]``. π0.5 has no state token, so the suffix is
+        ``[action_tokens×H]`` and the mask is ``[1] + [0]*(H-1)``: the first
+        action token opens a causal block and the rest attend bidirectionally
+        within it.
+        """
+        model_dtype = self.action_in_proj.weight.dtype
+        noisy_actions = noisy_actions.to(dtype=model_dtype)
+
+        time_cond = self.embed_timestep(timestep)
+        action_emb = self.action_in_proj(noisy_actions)  # (B, H, W)
+
+        bsize, action_len = action_emb.shape[:2]
+        pad_masks = torch.ones(bsize, action_len, dtype=torch.bool, device=action_emb.device)
+        att_masks = torch.tensor(
+            [1] + [0] * (self.action_horizon - 1),
+            dtype=action_emb.dtype,
+            device=action_emb.device,
+        )[None, :].expand(bsize, -1)
+        return action_emb, pad_masks, att_masks, time_cond
+
+    # ── Denoising step ───────────────────────────────────────────────
+    def denoise_step(
+        self,
+        prefix_pad_masks: torch.Tensor,
+        past_key_values,
+        x_t: torch.Tensor,
+        timestep: torch.Tensor,
+    ) -> torch.Tensor:
+        """Apply one flow-matching denoising step: predict ``v_t`` from ``x_t``.
+
+        Signature differs from π0's by exactly one argument: no ``state``.
+        """
+        suffix_embs, suffix_pad_masks, suffix_att_masks, time_cond = self.embed_suffix(x_t, timestep)
+
+        batch_size = prefix_pad_masks.shape[0]
+        suffix_len = suffix_pad_masks.shape[1]
+        prefix_len = prefix_pad_masks.shape[1]
+
+        prefix_pad_2d_masks = prefix_pad_masks[:, None, :].expand(batch_size, suffix_len, prefix_len)
+        suffix_att_2d_masks = make_att_2d_masks(suffix_pad_masks, suffix_att_masks)
+        full_att_2d_masks = torch.cat([prefix_pad_2d_masks, suffix_att_2d_masks], dim=2)
+
+        # Position IDs continue from where the prefix's last valid token left off.
+        prefix_offsets = torch.sum(prefix_pad_masks, dim=-1)[:, None]
+        position_ids = prefix_offsets + torch.cumsum(suffix_pad_masks, dim=1) - 1
+
+        full_att_2d_masks_4d = prepare_attention_masks_4d(full_att_2d_masks)
+
+        outputs_embeds, _ = self.paligemma_with_expert.forward(
+            attention_mask=full_att_2d_masks_4d,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=[None, suffix_embs],
+            use_cache=False,
+            adarms_cond=time_cond,
+        )
+
+        # Every suffix token is an action token in π0.5 (no state token to drop).
+        suffix_out = outputs_embeds[1][:, -self.action_horizon :]
+        suffix_out = suffix_out.to(dtype=self.action_out_proj.weight.dtype)
+        return self.action_out_proj(suffix_out)
+
+    # ── Full action generation ───────────────────────────────────────
+    @torch.no_grad()
+    def sample_actions(
+        self,
+        images: list[torch.Tensor],
+        image_masks: list[torch.Tensor],
+        lang_tokens: torch.Tensor,
+        lang_masks: torch.Tensor,
+        noise: torch.Tensor | None = None,
+        num_steps: int | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+    ) -> torch.Tensor:
+        """Generate an action chunk via iterative flow-matching denoising.
+
+        Convention: ``t=1`` is noise, ``t=0`` is the target — opposite of the
+        published π0 paper but matching both OpenPI and LeRobot.
+
+        Takes no ``state``: π0.5's state rides inside ``lang_tokens``.
+        """
+        if num_steps is None:
+            num_steps = self.num_inference_steps
+
+        bsize = lang_tokens.shape[0]
+        device = lang_tokens.device
+        if noise is None:
+            noise_shape = (self.action_horizon, self.action_dim)
+            if isinstance(generator, list):
+                if len(generator) != bsize:
+                    raise ValueError(f"Expected {bsize} generators, got {len(generator)}.")
+                noise = torch.stack(
+                    [torch.randn(noise_shape, dtype=torch.float32, device=device, generator=item) for item in generator]
+                )
+            else:
+                noise = torch.randn(
+                    bsize,
+                    *noise_shape,
+                    dtype=torch.float32,
+                    device=device,
+                    generator=generator,
+                )
+
+        # 1. Prefix embeddings + mask building.
+        prefix_embs, prefix_pad_masks, prefix_att_masks = self.embed_prefix(
+            images, image_masks, lang_tokens, lang_masks
+        )
+        prefix_att_2d_masks = make_att_2d_masks(prefix_pad_masks, prefix_att_masks)
+        prefix_position_ids = torch.cumsum(prefix_pad_masks, dim=1) - 1
+        prefix_att_2d_masks_4d = prepare_attention_masks_4d(prefix_att_2d_masks)
+
+        # 2. Forward prefix through PaliGemma LM, producing a list[(k, v)] cache.
+        _, past_key_values = self.paligemma_with_expert.forward(
+            attention_mask=prefix_att_2d_masks_4d,
+            position_ids=prefix_position_ids,
+            past_key_values=None,
+            inputs_embeds=[prefix_embs, None],
+            use_cache=True,
+        )
+
+        # 3. Euler-integrated denoising from t=1 down to t=0.
+        dt = -1.0 / num_steps
+        x_t = noise
+        for step in range(num_steps):
+            t = 1.0 + step * dt
+            time_tensor = torch.full((bsize,), t, dtype=torch.float32, device=device)
+            v_t = self.denoise_step(
+                prefix_pad_masks=prefix_pad_masks,
+                past_key_values=past_key_values,
+                x_t=x_t,
+                timestep=time_tensor,
+            )
+            x_t = x_t + dt * v_t
+        return x_t
+
+    # ── Weight loading ───────────────────────────────────────────────
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]],
+        *,
+        strict: bool = True,
+    ):
+        """Load and audit a LeRobot π0.5 safetensors checkpoint.
+
+        Same remap rules as π0 (strip the ``model.`` prefix, flatten→nested
+        PaliGemma submodules, tied ``lm_head`` → ``embed_tokens``, version-robust
+        SigLIP nesting), plus two π0.5-specific ones:
+
+          * ``action_time_mlp_{in,out}`` → ``time_mlp_{in,out}``: some
+            checkpoints were exported under the π0 parameter names.
+          * ``state_proj.*`` is reported, not silently dropped. A π0.5
+            checkpoint should not contain it; its presence usually means a π0
+            checkpoint was pointed at the π0.5 model class, which would
+            otherwise run happily with a randomly-initialized action expert.
+
+        The action-expert norms are AdaRMS here, so they expose ``dense.weight``
+        / ``dense.bias`` and no plain ``weight``. A checkpoint that carries a
+        plain expert-norm ``weight`` is a π0-shaped checkpoint; that too is
+        rejected rather than skipped. ``strict=False`` exists only for focused
+        remapping unit tests that intentionally provide a partial state dict;
+        the serving path always uses the strict default.
+        """
+        params_dict = dict(self.named_parameters())
+        buffers_dict = dict(self.named_buffers())
+
+        _PALIGEMMA_SUBMODULES = ("vision_tower", "multi_modal_projector", "language_model")
+        _EXPERT_PREFIX = "paligemma_with_expert.gemma_expert.model."
+
+        def _remap(name: str) -> str:
+            # Strip the leading "model." that LeRobot's PI05Policy wrapper adds.
+            if name.startswith("model."):
+                name = name[len("model.") :]
+
+            # π0-style timestep MLP names → π0.5 names.
+            if name.startswith("action_time_mlp_in."):
+                name = "time_mlp_in." + name[len("action_time_mlp_in.") :]
+            elif name.startswith("action_time_mlp_out."):
+                name = "time_mlp_out." + name[len("action_time_mlp_out.") :]
+
+            # Nested PaliGemma layout.
+            for sub in _PALIGEMMA_SUBMODULES:
+                flat = f"paligemma_with_expert.paligemma.{sub}."
+                nested = f"paligemma_with_expert.paligemma.model.{sub}."
+                if name.startswith(flat) and not name.startswith(nested):
+                    return nested + name[len(flat) :]
+
+            if name == "paligemma_with_expert.paligemma.lm_head.weight":
+                return "paligemma_with_expert.paligemma.model.language_model.embed_tokens.weight"
+
+            return name
+
+        def _fix_vision_tower(name: str) -> str:
+            """Reconcile SigLIP nesting across transformers versions (≤5.3 wraps
+            the encoder in ``vision_tower.vision_model.*``; ≥5.4 flattens it)."""
+            vt = "paligemma_with_expert.paligemma.model.vision_tower."
+            if not name.startswith(vt):
+                return name
+            rest = name[len(vt) :]
+            if name in params_dict or name in buffers_dict:
+                return name
+            if rest.startswith("vision_model."):
+                candidate = vt + rest[len("vision_model.") :]
+            else:
+                candidate = vt + "vision_model." + rest
+            return candidate if (candidate in params_dict or candidate in buffers_dict) else name
+
+        loaded = 0
+        skipped: list[str] = []
+        pi0_shaped: list[str] = []
+        filled_params: set = set()
+
+        for name, loaded_weight in weights:
+            mapped = _fix_vision_tower(_remap(name))
+
+            # Diagnose π0-shaped keys instead of dropping them quietly.
+            is_expert_norm_weight = mapped.startswith(_EXPERT_PREFIX) and (
+                mapped.endswith("input_layernorm.weight")
+                or mapped.endswith("post_attention_layernorm.weight")
+                or mapped == _EXPERT_PREFIX + "norm.weight"
+            )
+            if mapped.startswith("state_proj.") or is_expert_norm_weight:
+                pi0_shaped.append(mapped)
+                continue
+
+            if mapped in params_dict:
+                param = params_dict[mapped]
+                weight_loader = getattr(param, "weight_loader", default_weight_loader)
+                weight_loader(param, loaded_weight)
+                loaded += 1
+                filled_params.add(mapped)
+            elif mapped in buffers_dict:
+                buffers_dict[mapped].copy_(loaded_weight)
+                loaded += 1
+                filled_params.add(mapped)
+            else:
+                skipped.append(mapped)
+
+        # LeRobot stores PaliGemma's tied text embedding as lm_head.weight; keep
+        # lm_head filled so the tied-weight state stays consistent.
+        embed_key = "paligemma_with_expert.paligemma.model.language_model.embed_tokens.weight"
+        lm_head_key = "paligemma_with_expert.paligemma.lm_head.weight"
+        if embed_key in filled_params and lm_head_key in params_dict and lm_head_key not in filled_params:
+            params_dict[lm_head_key].data.copy_(params_dict[embed_key].data)
+            filled_params.add(lm_head_key)
+
+        # Reverse audit: any model param that got no checkpoint tensor at all
+        # would be running with random init.
+        missing_params: list[str] = []
+        for pname in params_dict:
+            if pname in filled_params:
+                continue
+            if "rotary_emb" in pname or pname.endswith(".inv_freq"):
+                continue
+            missing_params.append(pname)
+
+        parts: list[str] = []
+        if pi0_shaped:
+            parts.append(
+                f"{len(pi0_shaped)} checkpoint key(s) are π0-shaped, not π0.5-shaped (first 5: {pi0_shaped[:5]})"
+            )
+        if skipped:
+            parts.append(f"{len(skipped)} checkpoint key(s) had no model target (first 5: {skipped[:5]})")
+        if missing_params:
+            parts.append(f"{len(missing_params)} model param(s) received no weight (first 5: {missing_params[:5]})")
+
+        if parts and strict:
+            raise RuntimeError("Incomplete or incompatible π0.5 checkpoint: " + "; ".join(parts))
+        if parts:
+            logger.debug("π0.5 partial test load: %d tensors loaded — %s.", loaded, "; ".join(parts))
+        else:
+            logger.info("π0.5 load_weights: %d tensors loaded, 0 skipped, 0 missing.", loaded)
+        return filled_params
+
+
+EntryClass = Pi05ForActionPrediction
diff --git a/vllm_omni/diffusion/models/pi05/pipeline_pi05.py b/vllm_omni/diffusion/models/pi05/pipeline_pi05.py
new file mode 100644
index 000000000..a4d32ed81
--- /dev/null
+++ b/vllm_omni/diffusion/models/pi05/pipeline_pi05.py
@@ -0,0 +1,311 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""π0.5 VLA pipeline for vllm-omni.
+
+Entry point for ``DiffusionEngine.step() → pipeline.forward(req)``. Mirrors the
+DreamZero contract and the π0 pipeline: the pipeline owns ALL preprocessing. It
+reads the raw robot observation from
+``req.sampling_params.extra_args["robot_obs"]`` (delivered by the OpenPI
+realtime serving layer), builds model inputs, runs flow-matching denoising, and
+returns ``DiffusionOutput(output={"actions": ndarray})``.
+
+π0.5 is stateless across calls (no KV reuse, first-order Markov), so
+``session_id`` / ``reset`` from the OpenPI protocol are accepted but ignored.
+
+The post-processing order is load-bearing and matches LeRobot::
+
+    unnormalize → absolute actions → to_cpu
+
+``AbsoluteActionsProcessorStep`` must run *after* unnormalization, because a
+relative-action checkpoint's ``norm_stats`` are computed in relative space.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import fields as dataclass_fields
+
+import numpy as np
+import torch
+from torch import nn
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.models.pi05.config import SUPPORTED_DTYPE_NAMES, Pi05Config
+from vllm_omni.diffusion.models.pi05.modeling_pi05 import Pi05ForActionPrediction
+from vllm_omni.diffusion.models.pi05.processor_pi05 import Pi05Processor
+from vllm_omni.diffusion.models.pi05_pipeline_config import PI05_PIPELINE as PI05_PIPELINE
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+
+logger = init_logger(__name__)
+
+# π0.5 pins the PaliGemma tokenizer (LeRobot hardcodes it too).
+DEFAULT_PI05_TOKENIZER = "google/paligemma-3b-pt-224"
+
+# float16 is absent deliberately, not by oversight: nothing here has been
+# validated against it. The float32/bfloat16 trade-off is in the deploy config
+# and recipes/lerobot/Pi05.md.
+SUPPORTED_DTYPES = (torch.float32, torch.bfloat16)
+
+# The two lists guard different entry points — what the checkpoint declares
+# versus the dtype actually cast to — so they must not drift apart.
+assert {str(dtype).split(".")[-1] for dtype in SUPPORTED_DTYPES} == set(SUPPORTED_DTYPE_NAMES)
+
+
+def _checkpoint_declared_keys(model_dir: str) -> set[str]:
+    """The keys the checkpoint's config.json actually carries."""
+    path = os.path.join(model_dir, "config.json")
+    if not os.path.exists(path):
+        return set()
+    with open(path, encoding="utf-8") as f:
+        return set(json.load(f))
+
+
+def _comparable(value):
+    """Compare yaml and checkpoint values without tripping on list/tuple."""
+    return list(value) if isinstance(value, (list, tuple)) else value
+
+
+def _pi05_post_process(x):
+    """Module-level identity post-process (picklable across the orchestrator's
+    multiprocess boundary — a local closure is not)."""
+    return x
+
+
+def get_pi05_post_process_func(od_config: OmniDiffusionConfig):
+    """π0.5 returns actions directly; post-processing is identity."""
+    del od_config
+    return _pi05_post_process
+
+
+_LEROBOT_FLOAT32_IN_BFLOAT16 = (
+    "vision_tower",
+    "multi_modal_projector",
+    "input_layernorm",
+    "post_attention_layernorm",
+    "model.norm",
+)
+
+
+def _to_bfloat16_for_inference(model: Pi05ForActionPrediction) -> None:
+    """Apply LeRobot's mixed-precision inference layout explicitly."""
+    inner_model = model.paligemma_with_expert
+    for name, param in inner_model.named_parameters():
+        target_dtype = (
+            torch.float32 if any(selector in name for selector in _LEROBOT_FLOAT32_IN_BFLOAT16) else torch.bfloat16
+        )
+        param.data = param.data.to(dtype=target_dtype)
+    for buffer in inner_model.buffers():
+        if buffer.is_floating_point():
+            buffer.data = buffer.data.to(dtype=torch.bfloat16)
+
+    for name, param in model.named_parameters():
+        if not name.startswith("paligemma_with_expert."):
+            param.data = param.data.to(dtype=torch.float32)
+    for name, buffer in model.named_buffers():
+        if not name.startswith("paligemma_with_expert.") and buffer.is_floating_point():
+            buffer.data = buffer.data.to(dtype=torch.float32)
+
+
+def _set_inference_dtype(model: Pi05ForActionPrediction, dtype: torch.dtype) -> None:
+    if dtype == torch.float32:
+        model.to(dtype=torch.float32)
+    elif dtype == torch.bfloat16:
+        _to_bfloat16_for_inference(model)
+    else:
+        raise ValueError(f"Unsupported π0.5 inference dtype: {dtype!r}.")
+
+
+class Pi05Pipeline(nn.Module):
+    """π0.5 VLA pipeline: raw robot obs → continuous action chunk.
+
+    Registered as ``"Pi05Pipeline"`` in the diffusion registry.
+    """
+
+    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
+        super().__init__()
+        self.od_config = od_config
+        self.prefix = prefix
+        self.model_dir = self._resolve_model_dir(od_config.model)
+        self.config = self._build_config(od_config)
+
+        custom_args = od_config.custom_pipeline_args or {}
+        self.tokenizer_source = str(custom_args.get("tokenizer", self._resolve_tokenizer_source()))
+
+        self._torch_dtype = self._resolve_dtype(od_config)
+        self._device = self._resolve_device(od_config)
+
+        self.tokenizer = self._load_tokenizer()
+        self.model = self._initialize_model()
+
+        self.processor = Pi05Processor(self.config, self.tokenizer, self._device)
+
+    # ------------------------------------------------------------------
+    # Construction helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _resolve_model_dir(model: str | None) -> str | None:
+        """Return a local directory for ``model``; download an HF repo id if needed."""
+        if not model:
+            return None
+        if os.path.isdir(model):
+            return model
+        # Via repo_utils' shared HfApi rather than huggingface_hub directly, so
+        # the download carries vLLM-Omni's user agent like every other repo access.
+        from vllm_omni.transformers_utils.repo_utils import hf_api
+
+        return hf_api().snapshot_download(
+            repo_id=model,
+            allow_patterns=["*.json", "*.safetensors", "*.model", "tokenizer*"],
+        )
+
+    def _build_config(self, od_config: OmniDiffusionConfig) -> Pi05Config:
+        """Read the config from the checkpoint, then let the deploy yaml override it."""
+        checkpoint_config = Pi05Config.from_pretrained(self.model_dir) if self.model_dir else None
+        if checkpoint_config is None:
+            return Pi05Config.from_model_config(od_config.model_config)
+        if not od_config.model_config:
+            return checkpoint_config
+
+        resolved = {
+            item.name: getattr(checkpoint_config, item.name) for item in dataclass_fields(Pi05Config) if item.init
+        }
+        # Only a key the checkpoint actually declares can disagree with the yaml.
+        # Comparing against the dataclass default instead would report every
+        # serving-only field, such as policy_server_config, on every start.
+        declared_keys = _checkpoint_declared_keys(self.model_dir)
+        for key, value in od_config.model_config.items():
+            if key in resolved and key in declared_keys and _comparable(value) != _comparable(resolved[key]):
+                logger.warning(
+                    "Pi05Pipeline: the deploy config sets %s=%r, overriding %r from the checkpoint.",
+                    key,
+                    value,
+                    resolved[key],
+                )
+        resolved.update(od_config.model_config)
+        return Pi05Config.from_model_config(resolved)
+
+    def _resolve_tokenizer_source(self) -> str:
+        """Prefer the checkpoint dir if it ships tokenizer files; else PaliGemma."""
+        if self.model_dir and os.path.isdir(self.model_dir):
+            if os.path.exists(os.path.join(self.model_dir, "tokenizer_config.json")):
+                return self.model_dir
+        return DEFAULT_PI05_TOKENIZER
+
+    @staticmethod
+    def _resolve_dtype(od_config: OmniDiffusionConfig) -> torch.dtype:
+        """Resolve the dtype the weights are actually cast to.
+
+        This is the load-bearing check, not ``Pi05Config.dtype``: the cast in
+        :meth:`_initialize_model` reads the *top-level* ``OmniDiffusionConfig``
+        field, so a guard on the model config alone would let an unsupported
+        dtype through. See :data:`SUPPORTED_DTYPES` for why float16 is excluded.
+        """
+        dt = od_config.dtype
+        resolved = dt if isinstance(dt, torch.dtype) else getattr(torch, str(dt).split(".")[-1], None)
+        if resolved not in SUPPORTED_DTYPES:
+            raise ValueError(
+                f"Unsupported π0.5 dtype: {dt!r}. Supported: "
+                f"{', '.join(sorted(str(d).split('.')[-1] for d in SUPPORTED_DTYPES))}."
+            )
+        return resolved
+
+    @staticmethod
+    def _resolve_device(od_config: OmniDiffusionConfig) -> torch.device:
+        from vllm_omni.diffusion.distributed.utils import get_local_device
+
+        try:
+            return get_local_device()
+        except Exception:  # noqa: BLE001
+            return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def _load_tokenizer(self):
+        from transformers import AutoTokenizer
+
+        # padding_side="right" is part of the π0.5 spec: the prefix is a fixed
+        # 200-token block whose live tokens must start at index 0.
+        return AutoTokenizer.from_pretrained(self.tokenizer_source, padding_side="right")
+
+    def has_real_checkpoint(self) -> bool:
+        return bool(self.model_dir) and os.path.exists(os.path.join(self.model_dir, "model.safetensors"))
+
+    def _initialize_model(self) -> Pi05ForActionPrediction:
+        if not self.has_real_checkpoint():
+            expected = os.path.join(self.model_dir or "<missing-model-dir>", "model.safetensors")
+            raise FileNotFoundError(f"π0.5 serving requires checkpoint weights at {expected}.")
+        model = Pi05ForActionPrediction(self.config)
+        _set_inference_dtype(model, self._torch_dtype)
+        model.to(device=self._device)
+        self._load_checkpoint(model)
+        model.eval()
+        return model
+
+    def _load_checkpoint(self, model: Pi05ForActionPrediction) -> None:
+        import safetensors.torch
+
+        path = os.path.join(self.model_dir, "model.safetensors")
+        logger.info("Pi05Pipeline: loading π0.5 weights from %s", path)
+        try:
+            state = safetensors.torch.load_file(path)
+            model.load_weights(state.items())
+        except Exception as exc:
+            raise RuntimeError(f"Failed to load complete π0.5 checkpoint {path}: {exc}") from exc
+
+    # ------------------------------------------------------------------
+    # Framework weight-loading hook
+    # ------------------------------------------------------------------
+    def load_weights(self, weights=()):  # noqa: D401
+        """No-op for the diffusion loader: π0.5 self-loads its checkpoint."""
+        for _ in weights:
+            pass
+        return None
+
+    # ------------------------------------------------------------------
+    # Inference
+    # ------------------------------------------------------------------
+    @torch.inference_mode()
+    def forward(self, req: OmniDiffusionRequest, **kwargs) -> DiffusionOutput:
+        extra_args = getattr(req.sampling_params, "extra_args", None) or {}
+        robot_obs = extra_args.get("robot_obs")
+
+        if robot_obs is None:
+            # Dummy warmup path (no obs): return zeros so engine warmup/capture
+            # doesn't crash. Mirrors DreamZero's dummy-run handling.
+            first_prompt = req.prompts[0] if req.prompts else ""
+            prompt = first_prompt if isinstance(first_prompt, str) else (first_prompt.get("prompt") or "")
+            num_steps = getattr(req.sampling_params, "num_inference_steps", None)
+            if prompt == "dummy run" or num_steps == 1:
+                logger.info("Pi05Pipeline: dummy warmup request without robot_obs — returning zeros.")
+                return DiffusionOutput(
+                    output={
+                        "actions": np.zeros(
+                            (self.config.chunk_size, self.config.action_dim),
+                            dtype=np.float32,
+                        )
+                    },
+                )
+            return DiffusionOutput(
+                error="Pi05Pipeline.forward requires sampling_params.extra_args['robot_obs'].",
+            )
+
+        images, image_masks, lang_tokens, lang_masks = self.processor.build_model_inputs(robot_obs)
+
+        num_steps = getattr(req.sampling_params, "num_inference_steps", None)
+        if num_steps is not None and (
+            isinstance(num_steps, bool) or not isinstance(num_steps, (int, np.integer)) or int(num_steps) < 1
+        ):
+            raise ValueError(f"num_inference_steps must be a positive integer, got {num_steps!r}.")
+        if num_steps is not None:
+            num_steps = int(num_steps)
+
+        actions = self.model.sample_actions(
+            images=images,
+            image_masks=image_masks,
+            lang_tokens=lang_tokens,
+            lang_masks=lang_masks,
+            num_steps=num_steps,
+            generator=req.sampling_params.generator,
+        )
+
+        return DiffusionOutput(output={"actions": self.processor.build_model_outputs(actions, robot_obs)})
diff --git a/vllm_omni/diffusion/models/pi05/processor_pi05.py b/vllm_omni/diffusion/models/pi05/processor_pi05.py
new file mode 100644
index 000000000..11ebad2db
--- /dev/null
+++ b/vllm_omni/diffusion/models/pi05/processor_pi05.py
@@ -0,0 +1,568 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+r"""Preprocessing for the π0.5 VLA model.
+
+Converts a raw robot observation (multi-camera images + language instruction +
+proprioceptive state) into the tensors ``Pi05ForActionPrediction.sample_actions``
+consumes.
+
+**The defining π0.5 difference:** the state is not projected by a ``state_proj``
+layer. It is normalized to ``[-1, 1]``, discretized into ``state_num_bins`` bins,
+and serialized into the language prompt::
+
+    "Task: <instruction>, State: <b0> <b1> ... <bN>;\nAction: "
+
+so ``sample_actions`` receives no state tensor at all.
+
+**Normalization must precede discretization.** The discretizer bins over
+``[-1, 1]`` and assumes the state is already in that range. Reversed, every bin
+index is wrong and nothing raises.
+
+Reference:
+  - OpenPI: openpi/src/openpi/shared/image_tools.py (resize_with_pad)
+  - OpenPI: openpi/src/openpi/models/pi0_config.py (PaliGemmaTokenizer.tokenize)
+  - LeRobot: lerobot/src/lerobot/policies/pi05/processor_pi05.py
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.models.pi05.config import resolve_excluded_action_indices
+from vllm_omni.diffusion.models.pi05.modeling_pi05 import (
+    DEFAULT_IMAGE_RESOLUTION,
+    DEFAULT_MAX_TOKEN_LEN,
+    DEFAULT_STATE_NUM_BINS,
+)
+
+logger = init_logger(__name__)
+
+# LeRobot NormalizerProcessorStep.eps.
+NORM_EPS = 1e-8
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Image preprocessing (identical to π0 — SigLIP is unchanged in π0.5)
+# ──────────────────────────────────────────────────────────────────────
+def resize_with_pad(
+    images: torch.Tensor,
+    target_height: int,
+    target_width: int,
+    mode: str = "bilinear",
+) -> torch.Tensor:
+    """Resize ``(B, C, H, W)`` images to the target shape, preserving aspect
+    ratio with -1 padding on the short side.
+
+    Matches openpi ``image_tools.resize_with_pad_torch`` — the clamp to
+    [-1, 1] is what lets the padded region blend with SigLIP-normalized
+    pixels without adding signal at the boundary.
+    """
+    if images.ndim != 4:
+        raise ValueError(f"Expected 4-D (B,C,H,W), got {images.ndim}-D")
+    _, _, cur_h, cur_w = images.shape
+    ratio = max(cur_w / target_width, cur_h / target_height)
+    rh, rw = int(cur_h / ratio), int(cur_w / ratio)
+    align_corners = False if mode == "bilinear" else None
+    resized = F.interpolate(images, size=(rh, rw), mode=mode, align_corners=align_corners)
+    resized = resized.clamp(-1.0, 1.0)
+    ph, rem_h = divmod(target_height - rh, 2)
+    pw, rem_w = divmod(target_width - rw, 2)
+    return F.pad(resized, (pw, pw + rem_w, ph, ph + rem_h), value=-1.0)
+
+
+def pil_image_to_tensor(image: Image.Image) -> torch.Tensor:
+    """PIL → ``(1, C, H, W)`` float32 in ``[-1, 1]`` (SigLIP normalization)."""
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+    arr = np.array(image, dtype=np.float32) / 255.0 * 2.0 - 1.0
+    return torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0)
+
+
+class Pi05ImageProcessor:
+    """Minimal image preprocessor: image → normalized + padded ``[-1,1]`` tensor."""
+
+    def __init__(self, image_size: int = DEFAULT_IMAGE_RESOLUTION[0]):
+        self.image_size = image_size
+
+    def preprocess_single(self, image: Any) -> torch.Tensor:
+        """Convert one LeRobot-domain image to a normalized model tensor.
+
+        PIL and uint8 inputs have domain ``[0, 255]``. Floating ndarray/tensor
+        inputs must be finite and in ``[0, 1]``. Values are converted
+        deterministically to ``[-1, 1]``; the pixel content is never used to
+        guess its input domain.
+        """
+        t = self._to_tensor(image)
+        if t.shape[2] != self.image_size or t.shape[3] != self.image_size:
+            t = resize_with_pad(t, self.image_size, self.image_size)
+        return t
+
+    def _to_tensor(self, image: Any) -> torch.Tensor:
+        if isinstance(image, Image.Image):
+            return pil_image_to_tensor(image)
+        if isinstance(image, np.ndarray):
+            if image.ndim != 3 or image.shape[-1] != 3:
+                raise ValueError(f"Expected an HWC ndarray with 3 channels, got shape {image.shape}.")
+            t = torch.from_numpy(np.ascontiguousarray(image)).permute(2, 0, 1).unsqueeze(0)
+        elif isinstance(image, torch.Tensor):
+            t = image.unsqueeze(0) if image.ndim == 3 else image
+            if t.ndim != 4 or t.shape[0] != 1 or t.shape[1] != 3:
+                raise ValueError(f"Expected a CHW tensor (optionally batched once), got shape {tuple(t.shape)}.")
+        else:
+            raise TypeError(f"Unsupported image type for π0.5 preprocessing: {type(image)}")
+
+        if t.dtype == torch.uint8:
+            return t.to(dtype=torch.float32) / 255.0 * 2.0 - 1.0
+        if not t.is_floating_point():
+            raise TypeError(f"π0.5 images must use uint8 or floating dtype, got {t.dtype}.")
+        if not torch.isfinite(t).all():
+            raise ValueError("Floating π0.5 image contains NaN or Inf.")
+        low, high = float(t.amin()), float(t.amax())
+        if low < 0.0 or high > 1.0:
+            raise ValueError(f"Floating π0.5 images must be in [0, 1]; observed min={low}, max={high}.")
+        return t.to(dtype=torch.float32) * 2.0 - 1.0
+
+    def make_empty_image(self) -> torch.Tensor:
+        """Fill tensor for an unused camera slot — pure -1, matches OpenPI/LeRobot."""
+        return torch.full((1, 3, self.image_size, self.image_size), -1.0)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Normalization (LeRobot NormalizerProcessorStep)
+# ──────────────────────────────────────────────────────────────────────
+@dataclass(frozen=True)
+class NormStats:
+    """The affine map a checkpoint's statistics define.
+
+    ``mean_std`` carries mean and std; the two range modes carry the lower and
+    upper bound (``min``/``max``, or the ``q01``/``q99`` quantiles π0.5 ships).
+    """
+
+    mode: str
+    lower: torch.Tensor
+    upper: torch.Tensor
+
+
+def build_norm_stats(norm_stats: dict | None, key: str) -> NormStats | None:
+    """Read ``norm_stats[key]`` into tensors, or ``None`` when it carries none.
+
+    The mode comes from the entry. A LeRobot state_dict ships mean, std, min,
+    max, q01 and q99 at once, so the statistic names present cannot select it.
+    Missing modes default to quantile, which is what LeRobot defaults π0.5's
+    STATE and ACTION to (π0 defaults to mean_std).
+    """
+    entry = (norm_stats or {}).get(key)
+    if not entry:
+        return None
+
+    mode = str(entry.get("mode", "quantile")).lower()
+    if mode == "mean_std":
+        names = ("mean", "std")
+    elif mode == "min_max":
+        names = ("min", "max")
+    elif mode == "quantile":
+        mode, names = "min_max", ("q01", "q99")
+    else:
+        raise ValueError(f"Unsupported normalization mode for {key!r}: {mode!r}.")
+
+    bounds = [entry.get(name) for name in names]
+    if any(bound is None for bound in bounds):
+        raise ValueError(f"Normalization mode {mode!r} for {key!r} requires {names[0]!r} and {names[1]!r}.")
+    lower, upper = (torch.as_tensor(bound, dtype=torch.float32) for bound in bounds)
+    return NormStats(mode=mode, lower=lower, upper=upper)
+
+
+def apply_norm(x: torch.Tensor, stats: NormStats | None, *, inverse: bool = False) -> torch.Tensor:
+    """Map raw units to the model's normalized space, or back with ``inverse``.
+
+    Actions are padded to ``max_action_dim`` while the statistics cover only the
+    real width, so the tail passes through untouched. The eps rules are
+    LeRobot's: ``mean_std`` always divides by ``std + eps``, and the range modes
+    substitute ``eps`` only for an exactly zero range.
+    """
+    if stats is None:
+        return x
+    lower = stats.lower.to(device=x.device, dtype=x.dtype)
+    upper = stats.upper.to(device=x.device, dtype=x.dtype)
+    valid = lower.shape[0]
+    head = x[..., :valid]
+
+    if stats.mode == "mean_std":
+        head = head * upper + lower if inverse else (head - lower) / (upper + NORM_EPS)
+    else:
+        span = upper - lower
+        span = torch.where(span == 0, NORM_EPS, span)
+        head = (head + 1.0) * 0.5 * span + lower if inverse else 2.0 * (head - lower) / span - 1.0
+
+    if valid == x.shape[-1]:
+        return head
+    return torch.cat([head, x[..., valid:]], dim=-1)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# State: normalize → discretize → prompt  (π0.5's defining path)
+# ──────────────────────────────────────────────────────────────────────
+def _pad_or_truncate(raw_state: Any, width: int) -> np.ndarray:
+    """Zero-pad / truncate a vector to ``(width,)`` float32."""
+    if raw_state is None:
+        return np.zeros((width,), dtype=np.float32)
+    if isinstance(raw_state, torch.Tensor):
+        raw_state = raw_state.detach().cpu().numpy()
+    state = np.asarray(raw_state, dtype=np.float32).reshape(-1)
+    if state.shape[0] < width:
+        state = np.pad(state, (0, width - state.shape[0]))
+    elif state.shape[0] > width:
+        state = state[:width]
+    return state.astype(np.float32)
+
+
+def as_state_vector(raw_state: Any, state_dim: int) -> np.ndarray:
+    """Coerce a request's raw state to ``(state_dim,)`` float32, or raise.
+
+    LeRobot's ``Pi05PrepareStateTokenizerProcessorStep`` discretizes whatever
+    width it is handed and never pads to ``max_state_dim``, so zero-filling a
+    7-dim state up to 32 would append 25 state tokens the checkpoint never saw
+    in training.
+    """
+    if raw_state is None:
+        raise ValueError("π0.5 requires a state; there is no default to fall back on.")
+    if isinstance(raw_state, torch.Tensor):
+        raw_state = raw_state.detach().cpu().numpy()
+    state = np.asarray(raw_state, dtype=np.float32)
+    if state.ndim == 2 and state.shape[0] == 1:
+        state = state[0]
+    if state.ndim != 1:
+        raise ValueError(f"π0.5 state must be shaped (D,) or (1, D); got {tuple(state.shape)}.")
+    if not np.isfinite(state).all():
+        raise ValueError("π0.5 state contains NaN or Inf.")
+    if state.shape[0] != state_dim:
+        raise ValueError(
+            f"π0.5 state has {state.shape[0]} dimension(s), but the checkpoint declares "
+            f"{state_dim}. The state is serialized into the prompt at its real width, so "
+            "padding or truncating it would change the tokens the model sees."
+        )
+    return state
+
+
+def discretize_state(state: np.ndarray, *, num_bins: int = DEFAULT_STATE_NUM_BINS) -> np.ndarray:
+    """Discretize a ``[-1, 1]`` state into ``num_bins`` integer bins.
+
+    Byte-for-byte LeRobot's ``processor_pi05.py``::
+
+        np.digitize(state_np, bins=np.linspace(-1, 1, 256 + 1)[:-1]) - 1
+
+    A state below ``-1`` lands in bin ``-1``, and that negative bin is part of
+    the contract: the checkpoint was trained with ``" -1"`` in the state prompt
+    for those dimensions. Clipping it to ``0`` changes the tokens the model
+    sees, so this must not clip.
+
+    ``bins`` stays float64, matching LeRobot's default ``linspace`` dtype, so
+    boundary values fall on the same side.
+
+    **Assumes the state is already normalized** — see the module docstring.
+    """
+    bins = np.linspace(-1.0, 1.0, num_bins + 1)[:-1]
+    return (np.digitize(np.asarray(state, dtype=np.float32), bins=bins) - 1).astype(np.int64)
+
+
+def build_pi05_prompt(
+    *,
+    task: str,
+    normalized_state: np.ndarray,
+    state_num_bins: int = DEFAULT_STATE_NUM_BINS,
+) -> str:
+    """Build the π0.5 prompt: instruction + serialized discretized state.
+
+    Matches LeRobot's ``Pi05PrepareStateTokenizerProcessorStep``, including the
+    task cleanup (``strip``, ``_`` → space, newline → space), the exact template
+    and the state values it serializes. The template already ends in a newline,
+    so — unlike π0 — there is no separate newline-appending step.
+
+    ``normalized_state`` comes from ``Pi05ForActionPrediction._normalize_state``.
+    """
+    cleaned_task = (task or "").strip().replace("_", " ").replace("\n", " ")
+    bins = discretize_state(normalized_state, num_bins=state_num_bins)
+    state_str = " ".join(str(int(x)) for x in bins.tolist())
+    return f"Task: {cleaned_task}, State: {state_str};\nAction: "
+
+
+def tokenize_prompt(tokenizer, text: str, max_token_len: int = DEFAULT_MAX_TOKEN_LEN):
+    """Return ``(input_ids, attention_mask)`` lists, length exactly ``max_token_len``.
+
+    ``padding="max_length"`` is what makes the prefix a constant shape: the text
+    segment is always ``max_token_len`` tokens regardless of the instruction, so
+    only ``attention_mask.sum()`` varies per request.
+    """
+    enc = tokenizer(
+        text,
+        padding="max_length",
+        max_length=max_token_len,
+        truncation=True,
+        add_special_tokens=True,
+        return_tensors=None,
+    )
+    return list(enc["input_ids"]), list(enc["attention_mask"])
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Relative actions
+# ──────────────────────────────────────────────────────────────────────
+class Pi05RelativeActions:
+    """The relative/absolute action transform, as a single paired object.
+
+    LeRobot builds one ``RelativeActionsProcessorStep`` and hands *the same
+    instance* to ``AbsoluteActionsProcessorStep``; the two directions must
+    agree on ``enabled`` and on which dimensions are excluded, so they are one
+    object here too.
+
+    **Deviation from LeRobot, on purpose.** LeRobot's step keeps the reference
+    state on ``self`` between the pre- and post-pass. That is safe for a
+    single-threaded training loop and unsafe for a server: two in-flight
+    requests would share one reference state and silently corrupt each other's
+    actions. Here the state is passed explicitly to :meth:`to_absolute`, so the
+    object stays immutable after construction and is safe to share across
+    requests.
+
+    Transform (LeRobot / OpenPI): ``relative = action - state`` on the way in,
+    ``absolute = relative + state`` on the way out, applied only to the
+    dimensions *not* named in ``exclude_joints``. Gripper open/close is an
+    absolute command, which is why it is excluded by default.
+    """
+
+    def __init__(
+        self,
+        *,
+        enabled: bool,
+        exclude_joints: list[str] | None = None,
+        action_names: list[str] | None = None,
+        max_action_dim: int = 32,
+    ):
+        self.enabled = bool(enabled)
+        self.exclude_joints = list(exclude_joints or [])
+        self.action_names = list(action_names) if action_names else None
+        self.max_action_dim = int(max_action_dim)
+
+        # Boolean mask over action dims: True = this dim is relative to state.
+        mask = np.ones((self.max_action_dim,), dtype=bool)
+        if self.enabled:
+            for idx in resolve_excluded_action_indices(self.exclude_joints, self.action_names):
+                if 0 <= idx < self.max_action_dim:
+                    mask[idx] = False
+            # Padding beyond the real action dimensions carries no signal;
+            # leaving it "relative" would add state noise into dead channels.
+            if self.action_names:
+                mask[len(self.action_names) :] = False
+        else:
+            mask[:] = False
+        self.relative_mask = mask
+
+    @property
+    def num_relative_dims(self) -> int:
+        return int(self.relative_mask.sum())
+
+    def _state_row(self, state: Any, device, dtype) -> torch.Tensor:
+        """Raw state → ``(B, max_action_dim)`` aligned with the action dims.
+
+        Accepts one state for the whole batch (``(D,)``, the serving path,
+        where the pipeline runs B=1) or one state per sample (``(B, D)``).
+        LeRobot caches the batched state and shifts each sample by its own row,
+        so the per-sample form has to be honoured: ``_pad_or_truncate``
+        flattens, which would silently reduce ``(B, D)`` to sample 0's state and
+        apply it to every sample — wrong answers, no error.
+        """
+        if isinstance(state, torch.Tensor):
+            state = state.detach().cpu().numpy()
+        arr = np.asarray(0.0 if state is None else state, dtype=np.float32)
+        if arr.ndim > 2:
+            raise ValueError(f"Expected state shaped (D,) or (B, D), got {tuple(arr.shape)}")
+        rows = arr if arr.ndim == 2 else arr[None, :]
+        padded = np.stack([_pad_or_truncate(row, self.max_action_dim) for row in rows])
+        return torch.as_tensor(padded, device=device, dtype=dtype)
+
+    def to_relative(self, actions: torch.Tensor, state: Any) -> torch.Tensor:
+        """``absolute → relative``. Input side (step 3).
+
+        Not used on the inference path — there are no input actions to convert
+        at serving time — but it is what the transform *means*, and the parity
+        test exercises it as the inverse of :meth:`to_absolute`.
+        """
+        if not self.enabled:
+            return actions
+        return self._shift(actions, state, sign=-1.0)
+
+    def to_absolute(self, actions: torch.Tensor, state: Any) -> torch.Tensor:
+        """``relative → absolute``. Output side (step 2 of the post-pipeline).
+
+        ``state`` must be the **raw** state — the same one the model was given
+        before normalization — because relative actions live in raw action space.
+        """
+        if not self.enabled:
+            return actions
+        return self._shift(actions, state, sign=+1.0)
+
+    def _shift(self, actions: torch.Tensor, state: Any, *, sign: float) -> torch.Tensor:
+        if actions.ndim != 3:
+            raise ValueError(f"Expected actions shaped (B, horizon, action_dim), got {tuple(actions.shape)}")
+        action_dim = actions.shape[-1]
+        if action_dim != self.max_action_dim:
+            raise ValueError(
+                f"Action dim {action_dim} does not match max_action_dim={self.max_action_dim}; "
+                "the relative mask would be misaligned."
+            )
+        state_row = self._state_row(state, actions.device, actions.dtype)  # (1, D)
+        mask = torch.as_tensor(self.relative_mask, device=actions.device)
+        delta = torch.where(mask, state_row, torch.zeros_like(state_row))
+        # Broadcast over the action horizon: every step of the chunk is
+        # expressed relative to the same current state.
+        return actions + sign * delta[:, None, :]
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Model input assembly
+# ──────────────────────────────────────────────────────────────────────
+def _extract_images(robot_obs: dict, config) -> dict[str, Any]:
+    """Pull a ``{feature_key: image}`` map out of a raw robot obs.
+
+    This is functional step 1 (``rename_observations``): keys are translated
+    through ``config.image_key_map`` so serving wire names map onto the
+    checkpoint's ``input_features`` identities.
+    """
+    images = robot_obs.get("images")
+    if not isinstance(images, dict):
+        images = {k: v for k, v in robot_obs.items() if _is_image_like(v)}
+    key_map = config.image_key_map or {}
+    return {key_map.get(k, k): v for k, v in images.items() if _is_image_like(v)}
+
+
+def _is_image_like(value: Any) -> bool:
+    if isinstance(value, (Image.Image, torch.Tensor)):
+        return True
+    if isinstance(value, np.ndarray):
+        return value.ndim >= 3
+    if isinstance(value, (list, tuple)):
+        try:
+            return np.asarray(value).ndim >= 3
+        except Exception:  # noqa: BLE001
+            return False
+    return False
+
+
+def _assemble_model_inputs(robot_obs: dict, config, tokenizer, device: torch.device, state_norm: NormStats | None):
+    """Convert a raw robot observation into ``sample_actions`` inputs.
+
+    Returns ``(images, image_masks, lang_tokens, lang_masks)`` — note there is
+    **no state tensor**: π0.5 carries the state inside ``lang_tokens``.
+
+    Camera slots follow ``config.image_feature_keys`` order. A missing key keeps
+    its semantic slot and receives an empty image with a false mask. The output
+    always contains exactly ``max_cameras`` slots for the deployed model.
+    """
+    image_size = int(config.image_resolution[0])
+    img_proc = Pi05ImageProcessor(image_size=image_size)
+    max_cameras = config.max_cameras
+
+    feature_keys = config.image_feature_keys or []
+    obs_images = _extract_images(robot_obs, config)
+    if not feature_keys:
+        # No declared camera order — fall back to whatever the obs provides,
+        # preserving insertion order.
+        feature_keys = list(obs_images.keys())[:max_cameras]
+
+    camera_keys = feature_keys[:max_cameras]
+    if all(obs_images.get(key) is None for key in camera_keys):
+        raise ValueError("π0.5 observation must provide at least one configured camera image.")
+    if not config.image_feature_keys and len(obs_images) > max_cameras:
+        raise ValueError(
+            f"π0.5 observation provides {len(obs_images)} cameras, which exceeds max_cameras={max_cameras}."
+        )
+
+    images: list[torch.Tensor] = []
+    image_masks: list[torch.Tensor] = []
+    for key in camera_keys:
+        image = obs_images.get(key)
+        if image is None:
+            tensor = img_proc.make_empty_image().to(device=device)
+            mask = False
+        else:
+            tensor = img_proc.preprocess_single(image).to(device=device)
+            mask = True
+        images.append(tensor)
+        image_masks.append(torch.tensor([mask], dtype=torch.bool, device=device))
+
+    # A checkpoint may declare fewer named slots than the serving graph.
+    while len(images) < max_cameras:
+        images.append(img_proc.make_empty_image().to(device=device))
+        image_masks.append(torch.tensor([False], dtype=torch.bool, device=device))
+
+    # Normalize and serialize the state into the tokenized prompt.
+    raw_state = as_state_vector(robot_obs.get("state"), config.state_dim)
+    normalized_state = apply_norm(torch.from_numpy(raw_state), state_norm).numpy()
+    prompt = build_pi05_prompt(
+        task=robot_obs.get("prompt", "") or "",
+        normalized_state=normalized_state,
+        state_num_bins=config.state_num_bins,
+    )
+    ids, attn = tokenize_prompt(tokenizer, prompt, config.tokenizer_max_length)
+    lang_tokens = torch.tensor([ids], dtype=torch.long, device=device)
+    lang_masks = torch.tensor([attn], dtype=torch.bool, device=device)
+
+    return images, image_masks, lang_tokens, lang_masks
+
+
+# ──────────────────────────────────────────────────────────────────────
+# The interface the pipeline uses
+# ──────────────────────────────────────────────────────────────────────
+class Pi05Processor:
+    """Everything between the OpenPI wire and the model.
+
+    Owns the normalization statistics and the relative-action transform, so the
+    pipeline holds no preprocessing state of its own.
+    """
+
+    def __init__(self, config, tokenizer, device: torch.device):
+        self.config = config
+        self.tokenizer = tokenizer
+        self.device = device
+        self._state_norm = build_norm_stats(config.norm_stats, "state")
+        self._action_norm = build_norm_stats(config.norm_stats, "action")
+        self.relative_actions = Pi05RelativeActions(
+            enabled=config.use_relative_actions,
+            exclude_joints=config.relative_exclude_joints,
+            action_names=config.action_feature_names,
+            max_action_dim=config.max_action_dim,
+        )
+        if self._action_norm is None:
+            logger.info("π0.5: no action normalization stats; returned actions stay in normalized space.")
+        if self.relative_actions.enabled:
+            logger.info(
+                "π0.5: relative actions enabled — %d of %d action dims are state-relative (excluded joints: %s).",
+                self.relative_actions.num_relative_dims,
+                config.max_action_dim,
+                config.relative_exclude_joints,
+            )
+
+    def build_model_inputs(self, robot_obs: dict):
+        """Raw observation → ``sample_actions`` inputs.
+
+        No state tensor comes back: π0.5 carries the state inside ``lang_tokens``.
+        """
+        return _assemble_model_inputs(robot_obs, self.config, self.tokenizer, self.device, self._state_norm)
+
+    def build_model_outputs(self, actions: torch.Tensor, robot_obs: dict) -> np.ndarray:
+        """Model output → the action chunk the robot receives.
+
+        ``AbsoluteActionsProcessorStep`` runs after unnormalization, because a
+        relative-action checkpoint's statistics are computed in relative space.
+        The raw state is the one the prompt encoded, before normalization.
+        """
+        actions = apply_norm(actions, self._action_norm, inverse=True)
+        if self.relative_actions.enabled:
+            actions = self.relative_actions.to_absolute(actions, robot_obs.get("state"))
+        return actions.squeeze(0)[..., : self.config.action_dim].float().cpu().numpy()
diff --git a/vllm_omni/diffusion/models/pi05_pipeline_config.py b/vllm_omni/diffusion/models/pi05_pipeline_config.py
new file mode 100644
index 000000000..27035d509
--- /dev/null
+++ b/vllm_omni/diffusion/models/pi05_pipeline_config.py
@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Lightweight pipeline topology for π0.5."""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+# π0.5 is one diffusion stage (robot observation -> action chunk via flow
+# matching). It is registered in ``OMNI_PIPELINES`` because π0.5 is online-served
+# via ``vllm serve --deploy-config pi05.yaml``. Keep this topology outside the
+# ``pi05`` package: importing a package submodule executes ``pi05.__init__``,
+# which imports the runtime pipeline and ``diffusion.data``.
+PI05_PIPELINE = PipelineConfig(
+    model_type="pi05",
+    model_arch="Pi05Pipeline",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="diffusion",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(),
+            final_output=True,
+            final_output_type="action",
+            model_arch="Pi05Pipeline",
+        ),
+    ),
+)
diff --git a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py
index 0aa00abd9..5e262ff1e 100644
--- a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py
+++ b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py
@@ -337,14 +337,20 @@ class QwenImagePipeline(
             del visual_owner.visual
         else:
             logger.warning("Qwen-Image: vision tower not found on text encoder; skipping drop")
-        self.text_encoder = self.text_encoder.to(self.device)
+        # Under model-level CPU offload, keep the BF16 encoder/VAE on CPU so they
+        # do not share VRAM with DiT construction (#7555). The DiT follows the
+        # loader's default-device context (CUDA for online / AutoRound INT under
+        # offload, CPU for layerwise / unquantized HSDP defer).
+        cpu_offload = bool(getattr(self.od_config, "enable_cpu_offload", False))
+        enc_vae_device = torch.device("cpu") if cpu_offload else self.device
+        self.text_encoder = self.text_encoder.to(enc_vae_device)
         self.vae = from_pretrained_with_prefetch(
             DistributedAutoencoderKLQwenImage.from_pretrained,
             model,
             subfolder="vae",
             prefetch_list=qwen_subfolders,
             local_files_only=local_files_only,
-        ).to(self.device)
+        ).to(enc_vae_device)
         transformer_kwargs = get_transformer_config_kwargs(od_config.tf_model_config, QwenImageTransformer2DModel)
         self.transformer = QwenImageTransformer2DModel(
             od_config=od_config,
diff --git a/vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py b/vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py
index 11568f62c..cb1adbb61 100644
--- a/vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py
+++ b/vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py
@@ -60,17 +60,6 @@ from vllm_omni.diffusion.layers.rope import RotaryEmbedding
 logger = init_logger(__name__)
 
 
-def _apply_qwen_image_rotary_emb(x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
-    """Rotate interleaved pairs before rounding back to the activation dtype.
-
-    Qwen-Image's reference uses complex FP32 multiplication. Rounding the
-    frequencies to BF16 before rotation loses positional precision; those
-    errors accumulate across the denoising steps.
-    """
-    paired = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2))
-    return torch.view_as_real(paired * freqs.unsqueeze(1)).flatten(3).to(x.dtype)
-
-
 def _qwen_image_qk_norm_rope(
     q: torch.Tensor,
     k: torch.Tensor,
@@ -103,16 +92,11 @@ def _qwen_image_qk_norm_rope(
             fused_k.reshape(batch, seq_len, num_kv_heads, head_dim),
         )
 
+    # Eager path: BF16/activation-dtype RotaryEmbedding on every device.
+    # CUDA used to call FP32 complex multiply here; that matches the Diffusers
+    # helper in unit tests but drops Omni vs Diffusers pipeline PSNR (#7494).
     q = norm_q(q)
     k = norm_k(k)
-    if q.device.type == "cuda":
-        return (
-            _apply_qwen_image_rotary_emb(q, freqs),
-            _apply_qwen_image_rotary_emb(k, freqs),
-        )
-
-    # Retain the platform-specific kernels on other accelerators, which may
-    # not support complex tensors.
     cos = torch.real(freqs).to(q.dtype)
     sin = torch.imag(freqs).to(q.dtype)
     return rope(q, cos, sin), rope(k, cos, sin)
diff --git a/vllm_omni/diffusion/models/utils.py b/vllm_omni/diffusion/models/utils.py
index 429c34b9d..f55996a76 100644
--- a/vllm_omni/diffusion/models/utils.py
+++ b/vllm_omni/diffusion/models/utils.py
@@ -5,12 +5,14 @@ from __future__ import annotations
 
 import json
 import os
+from collections.abc import Sequence
 from typing import TYPE_CHECKING, Literal
 
 import torch
 import torch.nn as nn
 from vllm.model_executor.layers.linear import (
     ColumnParallelLinear,
+    LinearBase,
     ReplicatedLinear,
     RowParallelLinear,
 )
@@ -124,6 +126,28 @@ def recursive_replace_linear(model: nn.Module, od_config: OmniDiffusionConfig):
     _recursive_replace(model, prefix="")
 
 
+def recursive_replace_linear_with_quantization_config(
+    model: nn.Module,
+    quant_config: QuantizationConfig | None,
+    prefix: str = "",
+    skip_modules: Sequence[str] = (),
+) -> None:
+    for child_name, child_module in model.named_children():
+        qual_name = maybe_prefix(prefix, child_name)
+        if any(qual_name == path or qual_name.startswith(path + ".") for path in skip_modules):
+            continue
+        if isinstance(child_module, nn.Linear):
+            setattr(
+                model,
+                child_name,
+                replace_linear_class(child_module, quant_config=quant_config, prefix=qual_name),
+            )
+        else:
+            recursive_replace_linear_with_quantization_config(
+                child_module, quant_config, prefix=qual_name, skip_modules=skip_modules
+            )
+
+
 def init_parameters(
     module: nn.Module,
     dtype: torch.dtype | None,
@@ -144,6 +168,24 @@ def init_parameters(
         init_parameters(child, dtype, device)
 
 
+def init_parameters_preserving_vllm_linear(
+    module: nn.Module,
+    dtype: torch.dtype | None,
+    device: torch.device | None = None,
+) -> None:
+    if isinstance(module, LinearBase):
+        return
+    for name, param in module.named_parameters(recurse=False):
+        if param.is_meta:
+            setattr(
+                module,
+                name,
+                nn.Parameter(torch.empty_like(param, dtype=dtype, device=device), requires_grad=param.requires_grad),
+            )
+    for child in module.children():
+        init_parameters_preserving_vllm_linear(child, dtype, device)
+
+
 def create_transformers_model(
     auto_cls: _BaseAutoModelClass,
     od_config: OmniDiffusionConfig,
@@ -161,6 +203,23 @@ def create_transformers_model(
     return model
 
 
+def create_transformers_model_with_vllm_linears(
+    auto_cls: _BaseAutoModelClass,
+    hf_config: PretrainedConfig,
+    quant_config: QuantizationConfig | None,
+    dtype: torch.dtype,
+    device: torch.device,
+    prefix: str = "",
+    skip_modules: Sequence[str] = (),
+) -> PreTrainedModel:
+    """Build a Transformers model with vLLM linears."""
+    with init_on_device_without_buffers("meta"):
+        model = auto_cls.from_config(hf_config, dtype=dtype)
+    recursive_replace_linear_with_quantization_config(model, quant_config, prefix=prefix, skip_modules=skip_modules)
+    init_parameters_preserving_vllm_linear(model, dtype=dtype, device=device)
+    return model
+
+
 def _load_json(model_path: str, filename: str, local_files_only: bool = True) -> dict:
     """Load a JSON config file from a local path or HuggingFace Hub repo."""
     if local_files_only:
diff --git a/vllm_omni/diffusion/models/wan2_2/chunked_mp4.py b/vllm_omni/diffusion/models/wan2_2/chunked_mp4.py
new file mode 100644
index 000000000..5b16a7a13
--- /dev/null
+++ b/vllm_omni/diffusion/models/wan2_2/chunked_mp4.py
@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Worker-side MP4 encoding for Wan VAE temporal chunks."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from vllm_omni.diffusion.utils.media_utils import normalize_preencode_batch_frames, normalize_video_codec_options
+
+# Matches the fallback the video serving layer applies when a request omits fps,
+# so the bytes the worker encodes carry the rate the response advertises.
+WAN_DEFAULT_OUTPUT_FPS = 24
+
+# Keep worker-side encoding consistent with the one-shot serving encoder when
+# a request does not choose codec options explicitly.
+WAN_DEFAULT_VIDEO_CODEC_OPTIONS = {"preset": "ultrafast", "threads": "0"}
+
+# Wan publishes one latent frame group per callback, which is far finer than one
+# host transfer is worth. 17 frames matches MiniMax-H3's native clip size.
+WAN_DEFAULT_BATCH_FRAMES = 17
+
+
+def wan_preencoded_mp4_payload(video: Any) -> dict[str, Any] | None:
+    """Return a post-process payload when the worker already encoded the MP4.
+
+    Returns ``None`` for the ordinary frame-tensor output so callers fall
+    through to their existing post-processing.
+
+    No fps is reported here: :func:`resolve_wan_output_fps` mirrors the fallback
+    the serving layer applies, so the rate the response advertises already
+    matches the rate these bytes were encoded at.
+    """
+    if isinstance(video, (bytes, bytearray, memoryview)):
+        video = [video]
+    if not isinstance(video, list) or not all(isinstance(item, (bytes, bytearray, memoryview)) for item in video):
+        return None
+    return {"payload": {"video": [bytes(item) for item in video]}, "metadata": {}}
+
+
+def resolve_wan_preencode_mp4(sampling_params: Any, *, output_type: str) -> bool:
+    """Return whether this request wants the worker to pre-encode the MP4.
+
+    Reject rather than silently downgrade the combinations the pre-encoded path
+    cannot serve: it emits MP4 bytes, so nothing downstream can interpolate
+    frames or hand back an array.
+    """
+    extra_args = getattr(sampling_params, "extra_args", None) or {}
+    if not extra_args.get("preencode_mp4", False):
+        return False
+    if getattr(sampling_params, "enable_frame_interpolation", False):
+        raise ValueError(
+            "preencode_mp4 cannot be combined with enable_frame_interpolation: interpolation "
+            "needs the decoded frames that the pre-encoded path no longer materializes"
+        )
+    if output_type != "np":
+        raise ValueError(f"preencode_mp4 returns MP4 bytes and cannot serve output_type={output_type!r}")
+    return True
+
+
+def resolve_wan_preencode_batch_frames(sampling_params: Any, *, default: int = WAN_DEFAULT_BATCH_FRAMES) -> int:
+    """Read the MP4 batching threshold before starting expensive generation."""
+    extra_args = getattr(sampling_params, "extra_args", None) or {}
+    return normalize_preencode_batch_frames(extra_args.get("preencode_batch_frames", default))
+
+
+def resolve_wan_video_codec_options(sampling_params: Any) -> dict[str, str] | None:
+    """Read the request's encoder options, preserving serving defaults.
+
+    An absent key inherits the one-shot serving encoder's defaults. Explicit
+    ``None`` and an empty mapping remain distinct caller choices.
+    """
+    extra_args = getattr(sampling_params, "extra_args", None) or {}
+    return normalize_video_codec_options(extra_args.get("video_codec_options", WAN_DEFAULT_VIDEO_CODEC_OPTIONS))
+
+
+def resolve_wan_output_fps(sampling_params: Any) -> int:
+    """Resolve the fps the worker encodes with.
+
+    The serving layer resolves output fps from the request's ``fps`` field, not
+    from ``frame_rate``, so pre-encoding has to read the same field or the bytes
+    would carry a rate the response does not advertise.
+    """
+    fps = getattr(sampling_params, "fps", None)
+    if isinstance(fps, list):
+        fps = fps[0] if fps else None
+    return int(fps) if fps else WAN_DEFAULT_OUTPUT_FPS
diff --git a/vllm_omni/diffusion/models/wan2_2/norm.py b/vllm_omni/diffusion/models/wan2_2/norm.py
new file mode 100644
index 000000000..e432ebd36
--- /dev/null
+++ b/vllm_omni/diffusion/models/wan2_2/norm.py
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Normalization layer used by the Wan VAE patch."""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from vllm_omni.diffusion.layers.custom_op import CustomOp
+
+
+class RMSNormVAE(CustomOp):
+    """Root Mean Square Layer Normalization for Channel-First or Last"""
+
+    def __init__(
+        self,
+        dim: int,
+        channel_first: bool = True,
+        images: bool = True,
+        bias: bool = False,
+        epsilon: float = 1e-6,
+    ) -> None:
+        super().__init__()
+        broadcastable_dims = (1, 1, 1) if not images else (1, 1)
+        shape = (dim, *broadcastable_dims) if channel_first else (dim,)
+
+        self.channel_first = channel_first
+        self.scale = dim**0.5
+        self.gamma = nn.Parameter(torch.ones(shape))
+        self.bias = nn.Parameter(torch.zeros(shape)) if bias else None
+        self.epsilon = epsilon
+
+        self.gamma_rmsnorm = None
+
+    def forward_cuda(
+        self,
+        x: torch.Tensor,
+    ) -> torch.Tensor:
+        return self.forward_native(x)
+
+    def forward_hip(
+        self,
+        x: torch.Tensor,
+    ) -> torch.Tensor:
+        return self.forward_native(x)
+
+    def forward_npu(
+        self,
+        x: torch.Tensor,
+    ) -> torch.Tensor:
+        import torch_npu
+
+        if self.gamma_rmsnorm is None:
+            self.gamma_rmsnorm = self.gamma.reshape(-1)
+
+        if self.channel_first:
+            x = x.transpose(1, -1)
+            out = torch_npu.npu_rms_norm(x, self.gamma_rmsnorm, epsilon=self.epsilon)[0].transpose(1, -1)
+        else:
+            out = torch_npu.npu_rms_norm(x, self.gamma_rmsnorm, epsilon=self.epsilon)[0]
+
+        if self.bias is not None:
+            out = out + self.bias
+        return out
+
+    def forward_native(
+        self,
+        x: torch.Tensor,
+    ) -> torch.Tensor:
+        out = (
+            F.normalize(
+                x,
+                dim=(1 if self.channel_first else -1),
+                eps=self.epsilon,
+            )
+            * self.scale
+            * self.gamma
+        )
+        if self.bias is not None:
+            out = out + self.bias
+        return out
diff --git a/vllm_omni/diffusion/models/wan2_2/patch_diffusers.py b/vllm_omni/diffusion/models/wan2_2/patch_diffusers.py
index a3247f683..33f713862 100644
--- a/vllm_omni/diffusion/models/wan2_2/patch_diffusers.py
+++ b/vllm_omni/diffusion/models/wan2_2/patch_diffusers.py
@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import sys
 
-from vllm_omni.diffusion.layers.norm import RMSNormVAE
+from vllm_omni.diffusion.models.wan2_2.norm import RMSNormVAE
 
 
 def patch_wan_rms_norm():
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
index 15b036864..a971806b0 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
@@ -40,12 +40,20 @@ from vllm_omni.diffusion.models.dmd2 import DMD2PipelineMixin
 from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin, _is_rank_zero
 from vllm_omni.diffusion.models.schedulers import FlowUniPCMultistepScheduler
+from vllm_omni.diffusion.models.wan2_2.chunked_mp4 import (
+    resolve_wan_output_fps,
+    resolve_wan_preencode_batch_frames,
+    resolve_wan_preencode_mp4,
+    resolve_wan_video_codec_options,
+    wan_preencoded_mp4_payload,
+)
 from vllm_omni.diffusion.models.wan2_2.scheduling_wan_euler import WanEulerScheduler
 from vllm_omni.diffusion.models.wan2_2.wan2_2_transformer import WanSelfAttention, WanTransformer3DModel
 from vllm_omni.diffusion.offloader import OffloadPlan
 from vllm_omni.diffusion.postprocess import interpolate_video_tensor
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.utils.chunked_video import decode_to_mp4
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
 from vllm_omni.platforms import current_omni_platform
@@ -179,8 +187,36 @@ def load_transformer_config(model_path: str, subfolder: str = "transformer", loc
     return {}
 
 
+def resolve_wan_transformer_quant_config(
+    config: dict, quant_config: QuantizationConfig | None, component: str
+) -> QuantizationConfig | None:
+    """Resolve the expert before applying its checkpoint's storage contract."""
+    from vllm_omni.quantization.component_config import ComponentQuantizationConfig
+    from vllm_omni.quantization.factory import resolve_quant_config_from_disk
+
+    # Wan experts are siblings: "transformer_2" must not inherit "transformer"
+    # through the generic layer-prefix resolver. Select the whole expert name.
+    component_quant_config = (
+        quant_config.component_configs.get(component, quant_config.default_config)
+        if isinstance(quant_config, ComponentQuantizationConfig)
+        else quant_config
+    )
+    quantization_disabled = isinstance(quant_config, ComponentQuantizationConfig) and component_quant_config is None
+    resolved_quant_config = resolve_quant_config_from_disk(component_quant_config, config.get("quantization_config"))
+    if quantization_disabled and resolved_quant_config is not None:
+        raise ValueError(
+            f"Quantization is disabled for component {component!r}, but its checkpoint declares quantization. "
+            "Use a BF16 checkpoint for this component or enable its matching quantization method."
+        )
+    return resolved_quant_config
+
+
 def create_transformer_from_config(
-    config: dict, quant_config: QuantizationConfig | None = None, prefix: str = ""
+    config: dict,
+    quant_config: QuantizationConfig | None = None,
+    prefix: str = "",
+    *,
+    component: str = "transformer",
 ) -> WanTransformer3DModel:
     """Create WanTransformer3DModel from config dict."""
     kwargs: dict = {}
@@ -216,11 +252,7 @@ def create_transformer_from_config(
     if "pos_embed_seq_len" in config:
         kwargs["pos_embed_seq_len"] = config["pos_embed_seq_len"]
 
-    if "quantization_config" in config:
-        from vllm_omni.quantization.factory import resolve_quant_config_from_disk
-
-        quant_config = resolve_quant_config_from_disk(quant_config, config["quantization_config"])
-
+    quant_config = resolve_wan_transformer_quant_config(config, quant_config, component)
     if quant_config is not None:
         kwargs["quant_config"] = quant_config
     if prefix:
@@ -245,6 +277,9 @@ def get_wan22_post_process_func(
             output_type = sampling_params.output_type
         if output_type == "latent":
             return video
+        encoded = wan_preencoded_mp4_payload(video)
+        if encoded is not None:
+            return encoded
         video_metadata = {}
         if sampling_params is not None and getattr(sampling_params, "enable_frame_interpolation", False):
             video, multiplier = interpolate_video_tensor(
@@ -460,13 +495,13 @@ class Wan22Pipeline(
         # Initialize transformers with correct config (weights loaded via load_weights)
         if load_transformer:
             transformer_config = load_transformer_config(model, "transformer", local_files_only)
-            self.transformer = self._create_transformer(transformer_config)
+            self.transformer = self._create_transformer(transformer_config, component="transformer")
         else:
             self.transformer = None
 
         if load_transformer_2:
             transformer_2_config = load_transformer_config(model, "transformer_2", local_files_only)
-            self.transformer_2 = self._create_transformer(transformer_2_config)
+            self.transformer_2 = self._create_transformer(transformer_2_config, component="transformer_2")
         else:
             self.transformer_2 = None
 
@@ -504,10 +539,17 @@ class Wan22Pipeline(
             enable_diffusion_pipeline_profiler=self.od_config.enable_diffusion_pipeline_profiler
         )
 
-    def _create_transformer(self, config: dict) -> WanTransformer3DModel:
+    def _create_transformer(self, config: dict, component: str = "transformer") -> WanTransformer3DModel:
         """Create a transformer from a config dict. Respects od_config.quantization_config."""
         quant_config = getattr(self.od_config, "quantization_config", None)
-        return create_transformer_from_config(config, quant_config=quant_config)
+        # Startup metadata describes the first expert, not a user policy for both.
+        if getattr(self.od_config, "quantization_config_is_auto_detected", False):
+            quant_config = None
+        return create_transformer_from_config(
+            config,
+            quant_config=quant_config,
+            component=component,
+        )
 
     @property
     def guidance_scale(self):
@@ -680,6 +722,8 @@ class Wan22Pipeline(
             num_steps = 40 if common.num_inference_steps is None else common.num_inference_steps
 
         output_type = common.output_type or "np"
+        preencode_mp4 = resolve_wan_preencode_mp4(common, output_type=output_type)
+        preencode_batch_frames = resolve_wan_preencode_batch_frames(common) if preencode_mp4 else 17
         num_outputs_per_prompt = common.num_outputs_per_prompt or 1
         attention_kwargs: dict | None = None
 
@@ -934,27 +978,36 @@ class Wan22Pipeline(
                 latents.device, latents.dtype
             )
             latents = latents / latents_std + latents_mean
-            decoded = self.vae.decode(latents, return_dict=False)[0]
-            # Distributed VAE decode uses broadcast_result=False, so only the
-            # output-owning rank receives the full [B, C, T, H, W] video; other
-            # ranks get an empty placeholder. Emit typed media only from the
-            # owning rank and keep the placeholder on the legacy output field, so
-            # the media batch-dimension check in split_diffusion_output_by_request
-            # does not trip on every non-owner rank.
-            if decoded.dim() == 5:
-                output = None
-                media = DiffusionMediaOutput(
-                    video=VideoMediaOutput(
-                        tensor=decoded,
-                        spec=VideoTensorSpec(
-                            layout=VideoTensorLayout.BCTHW,
-                            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
-                            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
-                        ),
-                    )
+            if preencode_mp4:
+                output = decode_to_mp4(
+                    self.vae,
+                    latents,
+                    fps=resolve_wan_output_fps(common),
+                    batch_frames=preencode_batch_frames,
+                    video_codec_options=resolve_wan_video_codec_options(common),
                 )
             else:
-                output = decoded
+                decoded = self.vae.decode(latents, return_dict=False)[0]
+                # Distributed VAE decode uses broadcast_result=False, so only the
+                # output-owning rank receives the full [B, C, T, H, W] video; other
+                # ranks get an empty placeholder. Emit typed media only from the
+                # owning rank and keep the placeholder on the legacy output field, so
+                # the media batch-dimension check in split_diffusion_output_by_request
+                # does not trip on every non-owner rank.
+                if decoded.dim() == 5:
+                    output = None
+                    media = DiffusionMediaOutput(
+                        video=VideoMediaOutput(
+                            tensor=decoded,
+                            spec=VideoTensorSpec(
+                                layout=VideoTensorLayout.BCTHW,
+                                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+                            ),
+                        )
+                    )
+                else:
+                    output = decoded
 
         if DEBUG_PERF:
             current_omni_platform.synchronize()
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py
index 01bd53bb8..9f03f5853 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py
@@ -31,6 +31,13 @@ from vllm_omni.diffusion.models.dmd2 import DMD2PipelineMixin
 from vllm_omni.diffusion.models.interface import SupportImageInput, SupportsComponentDiscovery
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin, _is_rank_zero
 from vllm_omni.diffusion.models.utils import _load_json
+from vllm_omni.diffusion.models.wan2_2.chunked_mp4 import (
+    resolve_wan_output_fps,
+    resolve_wan_preencode_batch_frames,
+    resolve_wan_preencode_mp4,
+    resolve_wan_video_codec_options,
+    wan_preencoded_mp4_payload,
+)
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
     _WAN_TEXT_ENCODER_OFFLOAD_PLAN,
     build_wan_scheduler,
@@ -46,6 +53,7 @@ from vllm_omni.diffusion.models.wan2_2.wan2_2_transformer import WanTransformer3
 from vllm_omni.diffusion.postprocess import interpolate_video_tensor
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.utils.chunked_video import decode_to_mp4
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
 from vllm_omni.inputs.data import OmniTextPrompt
 from vllm_omni.platforms import current_omni_platform
@@ -70,6 +78,9 @@ def get_wan22_i2v_post_process_func(
             output_type = sampling_params.output_type
         if output_type == "latent":
             return video
+        encoded = wan_preencoded_mp4_payload(video)
+        if encoded is not None:
+            return encoded
         video_metadata = {}
         if sampling_params is not None and getattr(sampling_params, "enable_frame_interpolation", False):
             video, multiplier = interpolate_video_tensor(
@@ -304,25 +315,10 @@ class Wan22I2VPipeline(
         # Transformers (weights loaded via load_weights)
         # Load config from model directory or HF Hub to get correct in_channels for I2V models
         transformer_config = load_transformer_config(model, "transformer", local_files_only)
-        self.transformer = create_transformer_from_config(
-            transformer_config,
-            quant_config=od_config.quantization_config,
-        )
+        self.transformer = self._create_transformer(transformer_config, component="transformer")
         if self.has_transformer_2:
             transformer_2_config = load_transformer_config(model, "transformer_2", local_files_only)
-            t2_quant = transformer_2_config.get("quantization_config")
-            if isinstance(t2_quant, dict) and "quant_method" in t2_quant:
-                from vllm_omni.quantization.factory import build_quant_config
-
-                method = t2_quant["quant_method"]
-                kwargs = {k: v for k, v in t2_quant.items() if k != "quant_method"}
-                t2_quant = build_quant_config(method, **kwargs)
-            else:
-                t2_quant = None
-            self.transformer_2 = create_transformer_from_config(
-                transformer_2_config,
-                quant_config=t2_quant,
-            )
+            self.transformer_2 = self._create_transformer(transformer_2_config, component="transformer_2")
         else:
             self.transformer_2 = None
 
@@ -462,10 +458,13 @@ class Wan22I2VPipeline(
         image_embeds = self.image_encoder(pixel_values, output_hidden_states=True)
         return image_embeds.hidden_states[-2]
 
-    def _create_transformer(self, config: dict) -> WanTransformer3DModel:
+    def _create_transformer(self, config: dict, component: str = "transformer") -> WanTransformer3DModel:
         """Create a transformer from a config dict. Respects od_config.quantization_config."""
         quant_config = getattr(self.od_config, "quantization_config", None)
-        return create_transformer_from_config(config, quant_config=quant_config)
+        # Startup metadata describes the first expert, not a user policy for both.
+        if getattr(self.od_config, "quantization_config_is_auto_detected", False):
+            quant_config = None
+        return create_transformer_from_config(config, quant_config=quant_config, component=component)
 
     def forward(self, req: DiffusionRequestBatch) -> list[DiffusionOutput]:
         sampling_params_list = req.sampling_params_list
@@ -519,6 +518,8 @@ class Wan22I2VPipeline(
         num_steps = 40 if common.num_inference_steps is None else common.num_inference_steps
 
         output_type = common.output_type or "np"
+        preencode_mp4 = resolve_wan_preencode_mp4(common, output_type=output_type)
+        preencode_batch_frames = resolve_wan_preencode_batch_frames(common) if preencode_mp4 else 17
         num_outputs_per_prompt = common.num_outputs_per_prompt or 1
         attention_kwargs: dict | None = None
 
@@ -748,7 +749,16 @@ class Wan22I2VPipeline(
                 latents.device, latents.dtype
             )
             latents = latents / latents_std + latents_mean
-            output = self.vae.decode(latents, return_dict=False)[0]
+            if preencode_mp4:
+                output = decode_to_mp4(
+                    self.vae,
+                    latents,
+                    fps=resolve_wan_output_fps(common),
+                    batch_frames=preencode_batch_frames,
+                    video_codec_options=resolve_wan_video_codec_options(common),
+                )
+            else:
+                output = self.vae.decode(latents, return_dict=False)[0]
 
         if DEBUG_PERF:
             current_omni_platform.synchronize()
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py
index 1d28b425d..3cbd727a7 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py
@@ -33,6 +33,11 @@ from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineL
 from vllm_omni.diffusion.models.interface import SupportAudioInput, SupportImageInput
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
 from vllm_omni.diffusion.models.schedulers import FlowUniPCMultistepScheduler
+from vllm_omni.diffusion.models.wan2_2.chunked_mp4 import (
+    resolve_wan_preencode_batch_frames,
+    resolve_wan_preencode_mp4,
+    resolve_wan_video_codec_options,
+)
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
     load_transformer_config,
     load_wan_weights_with_optional_gate,
@@ -44,6 +49,7 @@ from vllm_omni.diffusion.models.wan2_2.wan2_2_s2v_transformer import (
 from vllm_omni.diffusion.offloader.config import DIT_COMPONENT, selected_offload_components
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.utils.chunked_video import ChunkedVideoMP4Session
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
 from vllm_omni.inputs.data import OmniTextPrompt
 from vllm_omni.platforms import current_omni_platform
@@ -63,6 +69,10 @@ _S2V_DEFAULT_NEG_PROMPT = (
 
 _AUDIO_VIDEO_RATE = 30
 
+# S2V generates at a fixed rate; the worker-side encoder and the post-process
+# payload must report the same one.
+S2V_OUTPUT_FPS = 16
+
 
 def _s2v_audio_condition_key(audio: str | np.ndarray | None) -> tuple[Any, ...]:
     if isinstance(audio, str):
@@ -280,6 +290,10 @@ def get_wan22_s2v_post_process_func(
         if output_type == "latent":
             return video
 
+        if isinstance(video, list) and all(isinstance(item, (bytes, bytearray, memoryview)) for item in video):
+            # The worker already muxed the audio into these bytes.
+            return {"video": [bytes(item) for item in video], "audio": None, "fps": S2V_OUTPUT_FPS}
+
         processed_video = video_processor.postprocess_video(video, output_type=output_type)
 
         if audio_waveform is not None:
@@ -287,7 +301,7 @@ def get_wan22_s2v_post_process_func(
                 "video": processed_video,
                 "audio": audio_waveform,
                 "audio_sample_rate": audio_sr,
-                "fps": 16,
+                "fps": S2V_OUTPUT_FPS,
             }
         return processed_video
 
@@ -1177,6 +1191,13 @@ class Wan22S2VPipeline(
         )
         num_steps = common.num_inference_steps or num_inference_steps
         num_outputs_per_prompt = common.num_outputs_per_prompt or 1
+        # The request's output_type is what serving honours downstream; the keyword
+        # argument only carries a default for direct callers. Reading it here is what
+        # lets pre-encoding reject pil, pt, and latent instead of returning MP4 bytes
+        # to a caller that asked for frames.
+        output_type = common.output_type or output_type or "np"
+        preencode_mp4 = resolve_wan_preencode_mp4(common, output_type=output_type)
+        preencode_batch_frames = resolve_wan_preencode_batch_frames(common, default=1) if preencode_mp4 else 1
 
         if common.guidance_scale_provided:
             guidance_scale = common.guidance_scale
@@ -1315,170 +1336,207 @@ class Wan22S2VPipeline(
 
         # ---- 6. Multi-clip autoregressive denoising ----
         clips: list[torch.Tensor] = []
+        # Encode each finished clip while the next one denoises, instead of
+        # concatenating the whole video first.
+        mp4_session = (
+            ChunkedVideoMP4Session(
+                value_range=self.vae.chunk_value_range,
+                audio_waveforms=[raw_audio_waveforms[index // num_outputs_per_prompt] for index in range(batch_size)],
+                audio_sample_rate=raw_audio_sr,
+                fps=S2V_OUTPUT_FPS,
+                batch_frames=preencode_batch_frames,
+                video_codec_options=resolve_wan_video_codec_options(common),
+            )
+            if preencode_mp4
+            else None
+        )
         # Keep a pixel-space buffer of the trailing motion_frames for the
         # autoregressive connection between clips.
         videos_last_frames = torch.zeros([batch_size, 3, motion_frames, height, width], dtype=dtype, device=device)
 
-        for r in range(num_repeat):
-            clip_generators = _make_clip_generators(seeds, generators, r, device)
-            # -- Noise --
-            if r == 0 and request_latents is not None:
-                latents = request_latents.to(device=device, dtype=dtype)
-            else:
-                latents = torch.stack(
-                    [
-                        self.prepare_latents(
-                            infer_frames=infer_frames,
-                            height=height,
-                            width=width,
-                            motion_frames=motion_frames,
-                            lat_motion_frames=lat_motion_frames,
-                            dtype=dtype,
-                            device=device,
-                            generator=clip_generator,
-                        )
-                        for clip_generator in clip_generators
-                    ]
+        try:
+            for r in range(num_repeat):
+                clip_generators = _make_clip_generators(seeds, generators, r, device)
+                # -- Noise --
+                if r == 0 and request_latents is not None:
+                    latents = request_latents.to(device=device, dtype=dtype)
+                else:
+                    latents = torch.stack(
+                        [
+                            self.prepare_latents(
+                                infer_frames=infer_frames,
+                                height=height,
+                                width=width,
+                                motion_frames=motion_frames,
+                                lat_motion_frames=lat_motion_frames,
+                                dtype=dtype,
+                                device=device,
+                                generator=clip_generator,
+                            )
+                            for clip_generator in clip_generators
+                        ]
+                    )
+
+                # -- Scheduler --
+                self.scheduler.set_timesteps(num_steps, device=device, shift=self._flow_shift)
+                timesteps = self.scheduler.timesteps
+                self._num_timesteps = len(timesteps)
+
+                # -- Slice audio for this clip --
+                left_idx = r * infer_frames
+                right_idx = left_idx + infer_frames
+                audio_input = audio_emb[..., left_idx:right_idx]
+
+                # -- Pose condition for this clip --
+                # Default: zero condition (no pose driving)
+                # Shape: [B, C=16, T, H, W]
+                lat_h = height // self.vae_scale_factor_spatial
+                lat_w = width // self.vae_scale_factor_spatial
+                lat_target_frames = (infer_frames + 3 + motion_frames) // 4 - lat_motion_frames
+                cond_latents = torch.zeros(
+                    [batch_size, 16, lat_target_frames, lat_h, lat_w], dtype=dtype, device=device
                 )
 
-            # -- Scheduler --
-            self.scheduler.set_timesteps(num_steps, device=device, shift=self._flow_shift)
-            timesteps = self.scheduler.timesteps
-            self._num_timesteps = len(timesteps)
+                # -- Clone motion latents for this clip --
+                input_motion_latents = motion_latents.clone()
 
-            # -- Slice audio for this clip --
-            left_idx = r * infer_frames
-            right_idx = left_idx + infer_frames
-            audio_input = audio_emb[..., left_idx:right_idx]
+                # Max sequence length for the transformer
+                max_seq_len = int(np.prod([lat_target_frames, lat_h, lat_w]) // 4)
 
-            # -- Pose condition for this clip --
-            # Default: zero condition (no pose driving)
-            # Shape: [B, C=16, T, H, W]
-            lat_h = height // self.vae_scale_factor_spatial
-            lat_w = width // self.vae_scale_factor_spatial
-            lat_target_frames = (infer_frames + 3 + motion_frames) // 4 - lat_motion_frames
-            cond_latents = torch.zeros([batch_size, 16, lat_target_frames, lat_h, lat_w], dtype=dtype, device=device)
-
-            # -- Clone motion latents for this clip --
-            input_motion_latents = motion_latents.clone()
-
-            # Max sequence length for the transformer
-            max_seq_len = int(np.prod([lat_target_frames, lat_h, lat_w]) // 4)
-
-            # -- Precompute audio embeddings once per clip --
-            mf = [motion_frames, lat_motion_frames]
-            # When CPU offload is active the transformer lives on CPU until
-            # its __call__ hook fires.  encode_audio() bypasses __call__,
-            # so move the audio sub-module to GPU explicitly.
-            _audio_enc = getattr(self.transformer, "casual_audio_encoder", None)
-            _audio_on_cpu = _audio_enc is not None and next(_audio_enc.parameters()).device.type == "cpu"
-            if _audio_on_cpu:
-                _audio_enc.to(device)
-            param_dtype = next(self.transformer.parameters()).dtype
-            with torch.amp.autocast(device.type, dtype=param_dtype):
-                positive_audio_emb = self.transformer.encode_audio(audio_input, mf)
-            do_true_cfg = self.do_classifier_free_guidance and negative_prompt_embeds is not None
-            if do_true_cfg:
+                # -- Precompute audio embeddings once per clip --
+                mf = [motion_frames, lat_motion_frames]
+                # When CPU offload is active the transformer lives on CPU until
+                # its __call__ hook fires.  encode_audio() bypasses __call__,
+                # so move the audio sub-module to GPU explicitly.
+                _audio_enc = getattr(self.transformer, "casual_audio_encoder", None)
+                _audio_on_cpu = _audio_enc is not None and next(_audio_enc.parameters()).device.type == "cpu"
+                if _audio_on_cpu:
+                    _audio_enc.to(device)
+                param_dtype = next(self.transformer.parameters()).dtype
                 with torch.amp.autocast(device.type, dtype=param_dtype):
-                    negative_audio_emb = self.transformer.encode_audio(0.0 * audio_input, mf)
-            else:
-                negative_audio_emb = None
-            if _audio_on_cpu:
-                _audio_enc.to("cpu")
+                    positive_audio_emb = self.transformer.encode_audio(audio_input, mf)
+                do_true_cfg = self.do_classifier_free_guidance and negative_prompt_embeds is not None
+                if do_true_cfg:
+                    with torch.amp.autocast(device.type, dtype=param_dtype):
+                        negative_audio_emb = self.transformer.encode_audio(0.0 * audio_input, mf)
+                else:
+                    negative_audio_emb = None
+                if _audio_on_cpu:
+                    _audio_enc.to("cpu")
 
-            # -- Denoising loop --
-            latents = self.diffuse(
-                latents=latents,
-                timesteps=timesteps,
-                prompt_embeds=prompt_embeds,
-                negative_prompt_embeds=negative_prompt_embeds,
-                guidance_scale=guidance_scale,
-                clip_generator=clip_generators,
-                dtype=dtype,
-                device=device,
-                max_seq_len=max_seq_len,
-                cond_latents=cond_latents,
-                input_motion_latents=input_motion_latents,
-                ref_latents=ref_latents,
-                motion_frames=mf,
-                drop_first_motion=drop_first_motion and r == 0,
-                positive_audio_emb=positive_audio_emb,
-                negative_audio_emb=negative_audio_emb,
-            )
-
-            # ---- Decode this clip ----
-            if self._should_release_dit_before_decode():
-                self.transformer.to("cpu")
-                current_omni_platform.empty_cache()
-
-            if not (drop_first_motion and r == 0):
-                decode_latents = torch.cat([motion_latents, latents], dim=2)
-            else:
-                decode_latents = torch.cat([ref_latents, latents], dim=2)
-
-            decode_latents = self._denormalize_latents(decode_latents)
-            decode_latents = decode_latents.to(self.vae.dtype)
-            clip_video = self.vae.decode(decode_latents, return_dict=False)[0]  # [1, C, T, H, W]
-
-            # Handle VAE patch parallel: only rank 0 gets result, broadcast to all ranks
-            # This is needed for S2V's autoregressive loop where all ranks need the decoded frames
-            if clip_video.numel() == 0:
-                # Non-rank0 received empty tensor from patch parallel decode
-                # Use the same broadcast mechanism as the VAE patch parallel code
-                import torch.distributed as dist
-
-                total_frames = decode_latents.shape[2]
-
-                # Create buffer for broadcast
-                clip_video = torch.empty(
-                    (batch_size, 3, total_frames, height, width),
-                    device=decode_latents.device,
-                    dtype=decode_latents.dtype,
+                # -- Denoising loop --
+                latents = self.diffuse(
+                    latents=latents,
+                    timesteps=timesteps,
+                    prompt_embeds=prompt_embeds,
+                    negative_prompt_embeds=negative_prompt_embeds,
+                    guidance_scale=guidance_scale,
+                    clip_generator=clip_generators,
+                    dtype=dtype,
+                    device=device,
+                    max_seq_len=max_seq_len,
+                    cond_latents=cond_latents,
+                    input_motion_latents=input_motion_latents,
+                    ref_latents=ref_latents,
+                    motion_frames=mf,
+                    drop_first_motion=drop_first_motion and r == 0,
+                    positive_audio_emb=positive_audio_emb,
+                    negative_audio_emb=negative_audio_emb,
                 )
 
-                # Get the VAE's patch parallel group (same one used in decode)
-                vae_pp_group = getattr(self.vae, "_vae_pp_group", None)
-                if vae_pp_group is not None:
-                    # Broadcast using the same group as VAE patch parallel
-                    dist.broadcast(clip_video, src=0, group=vae_pp_group)
+                # ---- Decode this clip ----
+                if self._should_release_dit_before_decode():
+                    self.transformer.to("cpu")
+                    current_omni_platform.empty_cache()
 
-            # Trim to the infer_frames of interest
-            clip_video = clip_video[:, :, -infer_frames:]
-            if drop_first_motion and r == 0:
-                # Drop the first 3 frames (artifact from ref_latents prepend)
-                clip_video = clip_video[:, :, 3:]
+                if not (drop_first_motion and r == 0):
+                    decode_latents = torch.cat([motion_latents, latents], dim=2)
+                else:
+                    decode_latents = torch.cat([ref_latents, latents], dim=2)
 
-            # ---- Update motion for next clip (autoregressive) ----
-            overlap_frames_num = min(motion_frames, clip_video.shape[2])
-            videos_last_frames = torch.cat(
-                [videos_last_frames[:, :, overlap_frames_num:], clip_video[:, :, -overlap_frames_num:]],
-                dim=2,
+                decode_latents = self._denormalize_latents(decode_latents)
+                decode_latents = decode_latents.to(self.vae.dtype)
+                clip_video = self.vae.decode(decode_latents, return_dict=False)[0]  # [1, C, T, H, W]
+                # Under VAE patch parallelism only the output-owning rank decodes a
+                # real clip; peers get an empty placeholder filled by the broadcast.
+                owns_output = clip_video.numel() > 0
+
+                # Handle VAE patch parallel: only rank 0 gets result, broadcast to all ranks
+                # This is needed for S2V's autoregressive loop where all ranks need the decoded frames
+                if clip_video.numel() == 0:
+                    # Non-rank0 received empty tensor from patch parallel decode
+                    # Use the same broadcast mechanism as the VAE patch parallel code
+                    import torch.distributed as dist
+
+                    total_frames = decode_latents.shape[2]
+
+                    # Create buffer for broadcast
+                    clip_video = torch.empty(
+                        (batch_size, 3, total_frames, height, width),
+                        device=decode_latents.device,
+                        dtype=decode_latents.dtype,
+                    )
+
+                    # Get the VAE's patch parallel group (same one used in decode)
+                    vae_pp_group = getattr(self.vae, "_vae_pp_group", None)
+                    if vae_pp_group is not None:
+                        # Broadcast using the same group as VAE patch parallel
+                        dist.broadcast(clip_video, src=0, group=vae_pp_group)
+
+                # Trim to the infer_frames of interest
+                clip_video = clip_video[:, :, -infer_frames:]
+                if drop_first_motion and r == 0:
+                    # Drop the first 3 frames (artifact from ref_latents prepend)
+                    clip_video = clip_video[:, :, 3:]
+
+                # ---- Update motion for next clip (autoregressive) ----
+                overlap_frames_num = min(motion_frames, clip_video.shape[2])
+                videos_last_frames = torch.cat(
+                    [videos_last_frames[:, :, overlap_frames_num:], clip_video[:, :, -overlap_frames_num:]],
+                    dim=2,
+                )
+                videos_last_frames = videos_last_frames.to(dtype=dtype, device=device)
+                # Only prepare motion latents if there's another clip coming
+                if r < num_repeat - 1:
+                    motion_latents = self.prepare_motion_latents(videos_last_frames, device=device).to(dtype=dtype)
+
+                if mp4_session is not None:
+                    # Every rank needs the frames for the motion loop above, but the
+                    # executor keeps only the owner's response, so a peer skips the
+                    # encode and finishes with no containers, like T2V's non-owners.
+                    if owns_output:
+                        mp4_session.push(clip_video)
+                else:
+                    clips.append(clip_video.cpu())
+
+                # Free VRAM between clips
+                if current_omni_platform.is_available():
+                    current_omni_platform.empty_cache()
+
+            # ---- Assemble the output ----
+            if mp4_session is not None:
+                output = mp4_session.finish()  # one progressive MP4 per batch entry
+            else:
+                output = torch.cat(clips, dim=2)  # [B, C, T_total, H, W]
+
+            outputs = split_diffusion_output_by_request(
+                DiffusionOutput(
+                    output=output,
+                    stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
+                ),
+                req,
+                num_outputs_per_prompt=num_outputs_per_prompt,
             )
-            videos_last_frames = videos_last_frames.to(dtype=dtype, device=device)
-            # Only prepare motion latents if there's another clip coming
-            if r < num_repeat - 1:
-                motion_latents = self.prepare_motion_latents(videos_last_frames, device=device).to(dtype=dtype)
-
-            clips.append(clip_video.cpu())
-
-            # Free VRAM between clips
-            if current_omni_platform.is_available():
-                current_omni_platform.empty_cache()
-
-        # ---- Concatenate all clips ----
-        output = torch.cat(clips, dim=2)  # [B, C, T_total, H, W]
-
-        outputs = split_diffusion_output_by_request(
-            DiffusionOutput(
-                output=output,
-                stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
-            ),
-            req,
-            num_outputs_per_prompt=num_outputs_per_prompt,
-        )
-        for request_output, raw_audio_waveform in zip(outputs, raw_audio_waveforms):
-            request_output.output = (request_output.output, raw_audio_waveform, raw_audio_sr)
-        return outputs
+            if mp4_session is not None:
+                # The waveform is already muxed into each container.
+                return outputs
+            for request_output, raw_audio_waveform in zip(outputs, raw_audio_waveforms):
+                request_output.output = (request_output.output, raw_audio_waveform, raw_audio_sr)
+            return outputs
+        except BaseException:
+            if mp4_session is not None:
+                mp4_session.abort()
+            raise
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
         return load_wan_weights_with_optional_gate(self, weights)
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py
index aeecff608..0d5f3cd67 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py
@@ -28,6 +28,7 @@ from vllm_omni.diffusion.models.interface import SupportImageInput
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
     Wan22Pipeline,
     load_wan_weights_with_optional_gate,
+    resolve_wan_transformer_quant_config,
     retrieve_latents,
 )
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
@@ -60,6 +61,8 @@ def create_vace_transformer_from_config(
     config: dict,
     quant_config: QuantizationConfig | None = None,
     prefix: str = "",
+    *,
+    component: str = "transformer",
 ) -> WanVACETransformer3DModel:
     """Create WanVACETransformer3DModel from config dict."""
     kwargs = {}
@@ -97,6 +100,7 @@ def create_vace_transformer_from_config(
         kwargs["vace_layers"] = config["vace_layers"]
     if "vace_in_channels" in config:
         kwargs["vace_in_channels"] = config["vace_in_channels"]
+    quant_config = resolve_wan_transformer_quant_config(config, quant_config, component)
     if quant_config is not None:
         kwargs["quant_config"] = quant_config
     if prefix:
@@ -205,10 +209,13 @@ class Wan22VACEPipeline(Wan22Pipeline, SupportImageInput):
 
         super().__init__(od_config=od_config, prefix=prefix)
 
-    def _create_transformer(self, config: dict) -> WanVACETransformer3DModel:
+    def _create_transformer(self, config: dict, component: str = "transformer") -> WanVACETransformer3DModel:
         """Build VACE transformer. Respects od_config.quantization_config."""
         quant_config = getattr(self.od_config, "quantization_config", None)
-        return create_vace_transformer_from_config(config, quant_config=quant_config)
+        # Startup metadata describes the first expert, not a user policy for both.
+        if getattr(self.od_config, "quantization_config_is_auto_detected", False):
+            quant_config = None
+        return create_vace_transformer_from_config(config, quant_config=quant_config, component=component)
 
     def diffuse(
         self,
diff --git a/vllm_omni/diffusion/models/wan2_2/rope.py b/vllm_omni/diffusion/models/wan2_2/rope.py
new file mode 100644
index 000000000..2867da005
--- /dev/null
+++ b/vllm_omni/diffusion/models/wan2_2/rope.py
@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Wan S2V rotary positional embedding layers."""
+
+import torch
+
+from vllm_omni.diffusion.layers.rope import RotaryEmbeddingWan
+from vllm_omni.platforms import current_omni_platform
+
+
+class WanS2VRotaryPosEmbed(torch.nn.Module):
+    """Precompute complex-valued RoPE embeddings for S2V multi-grid positions.
+
+    Owns the base frequency buffer and provides forward() to compute position
+    embeddings given hidden_states (for shape) and grid_sizes.
+    """
+
+    def __init__(self, num_heads: int, head_dim: int, max_seq_len: int = 1024):
+        super().__init__()
+        self.num_heads = num_heads
+        self.head_dim = head_dim
+        d = head_dim
+        freqs = torch.cat(
+            [
+                self._rope_params(max_seq_len, d - 4 * (d // 6)),
+                self._rope_params(max_seq_len, 2 * (d // 6)),
+                self._rope_params(max_seq_len, 2 * (d // 6)),
+            ],
+            dim=1,
+        )
+        self.register_buffer("freqs", freqs.to(torch.complex64), persistent=False)
+
+    @staticmethod
+    @torch.amp.autocast(current_omni_platform.device_type, enabled=False)
+    def _rope_params(max_seq_len, dim, theta=10000):
+        if dim % 2 != 0:
+            raise ValueError(f"dim ({dim}) must be even")
+        freqs = torch.outer(
+            torch.arange(max_seq_len), 1.0 / torch.pow(theta, torch.arange(0, dim, 2).to(torch.float64).div(dim))
+        )
+        return torch.polar(torch.ones_like(freqs), freqs)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        grid_sizes: list,
+        trainable_freqs: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Precompute RoPE embeddings for the given grid layout.
+
+        Args:
+            hidden_states: Tensor [B, S, ...] (used for batch/seq shape and device)
+            grid_sizes: Grid specification (list of [offsets, sizes, totals])
+            trainable_freqs: Optional trainable frequency overrides for t_f < 0
+
+        Returns:
+            Complex tensor [B, S, 1, head_dim//2] of precomputed position embeddings
+        """
+        b, s = hidden_states.shape[0], hidden_states.shape[1]
+        c = self.head_dim // 2
+        device = hidden_states.device
+
+        freqs = self.freqs.to(device)
+        if trainable_freqs is not None:
+            freqs_input = [freqs, trainable_freqs]
+        else:
+            freqs_input = freqs
+
+        if isinstance(freqs_input, list):
+            trainable_f = freqs_input[1]
+            freqs_split = freqs_input[0]
+        else:
+            trainable_f = None
+            freqs_split = freqs_input
+        freqs_split = freqs_split.split([c - 2 * (c // 3), c // 3, c // 3], dim=1)
+
+        output = torch.empty((b, s, 1, c), device=device, dtype=torch.complex64)
+        seq_bucket = [0]
+        if not isinstance(grid_sizes, list):
+            grid_sizes = [grid_sizes]
+        for g in grid_sizes:
+            if not isinstance(g, list):
+                g = [torch.zeros_like(g), g]
+            batch_size = g[0].shape[0]
+            for i in range(batch_size):
+                f_o, h_o, w_o = g[0][i]
+                f, h, w = g[1][i]
+                t_f, t_h, t_w = g[2][i]
+                seq_f, seq_h, seq_w = f - f_o, h - h_o, w - w_o
+                seq_len = int(seq_f * seq_h * seq_w)
+                if seq_len > 0:
+                    if t_f > 0:
+                        assert f_o * f >= 0 and h_o * h >= 0 and w_o * w >= 0
+                        seq_f_int = int(seq_f)
+                        seq_h_int = int(seq_h)
+                        seq_w_int = int(seq_w)
+
+                        if f_o >= 0:
+                            f_sam = torch.linspace(int(f_o), int(t_f + f_o) - 1, seq_f_int, device=device).long()
+                        else:
+                            f_sam = torch.linspace(int(-f_o), int(-t_f - f_o) + 1, seq_f_int, device=device).long()
+                        h_sam = torch.linspace(int(h_o), int(t_h + h_o) - 1, seq_h_int, device=device).long()
+                        w_sam = torch.linspace(int(w_o), int(t_w + w_o) - 1, seq_w_int, device=device).long()
+
+                        freqs_0 = torch.index_select(freqs_split[0] if f_o >= 0 else freqs_split[0].conj(), 0, f_sam)
+                        freqs_0 = freqs_0.view(seq_f_int, 1, 1, -1)
+
+                        freqs_i = torch.cat(
+                            [
+                                freqs_0.expand(seq_f_int, seq_h_int, seq_w_int, -1),
+                                torch.index_select(freqs_split[1], 0, h_sam)
+                                .view(1, seq_h_int, 1, -1)
+                                .expand(seq_f_int, seq_h_int, seq_w_int, -1),
+                                torch.index_select(freqs_split[2], 0, w_sam)
+                                .view(1, 1, seq_w_int, -1)
+                                .expand(seq_f_int, seq_h_int, seq_w_int, -1),
+                            ],
+                            dim=-1,
+                        ).reshape(seq_len, 1, -1)
+                    elif t_f < 0:
+                        freqs_i = trainable_f.unsqueeze(1)
+                    output[i, seq_bucket[-1] : seq_bucket[-1] + seq_len] = freqs_i
+            seq_bucket.append(seq_bucket[-1] + seq_len)
+        return output
+
+
+class RotaryEmbeddingWanS2V(RotaryEmbeddingWan):
+    """Apply RoPE using precomputed complex freqs for Wan S2V main transformer.
+
+    Converts complex freqs (from WanS2VRotaryPosEmbed) to cos/sin and delegates
+    to RotaryEmbeddingWan for platform-optimized application (float32 kernel).
+    Under TP, freqs has 1 head — broadcasts automatically via cos/sin.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(is_neox_style=False, half_head_dim=True)
+
+    def forward(self, x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
+        freqs_sliced = freqs[:, : x.size(1)]
+        cos = freqs_sliced.real.to(x.dtype)
+        sin = freqs_sliced.imag.to(x.dtype)
+        return super().forward(x, cos, sin)
diff --git a/vllm_omni/diffusion/models/wan2_2/wan2_2_s2v_transformer.py b/vllm_omni/diffusion/models/wan2_2/wan2_2_s2v_transformer.py
index cce5e43be..56ec4faf2 100644
--- a/vllm_omni/diffusion/models/wan2_2/wan2_2_s2v_transformer.py
+++ b/vllm_omni/diffusion/models/wan2_2/wan2_2_s2v_transformer.py
@@ -32,7 +32,8 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.layer import Attention
 from vllm_omni.diffusion.distributed.sp_plan import SequenceParallelInput, SequenceParallelOutput
-from vllm_omni.diffusion.layers.rope import RotaryEmbeddingS2VGrid, RotaryEmbeddingWanS2V, WanS2VRotaryPosEmbed
+from vllm_omni.diffusion.layers.rope import RotaryEmbeddingS2VGrid
+from vllm_omni.diffusion.models.wan2_2.rope import RotaryEmbeddingWanS2V, WanS2VRotaryPosEmbed
 from vllm_omni.platforms import current_omni_platform
 
 from .wan2_2_transformer import DistributedRMSNorm, WanFeedForward
diff --git a/vllm_omni/diffusion/models/wan2_2/wan2_2_transformer.py b/vllm_omni/diffusion/models/wan2_2/wan2_2_transformer.py
index dbc555604..91b482ebd 100644
--- a/vllm_omni/diffusion/models/wan2_2/wan2_2_transformer.py
+++ b/vllm_omni/diffusion/models/wan2_2/wan2_2_transformer.py
@@ -18,7 +18,7 @@ from vllm.distributed import (
 )
 from vllm.logger import init_logger
 from vllm.model_executor.layers.conv import Conv3dLayer
-from vllm.model_executor.layers.linear import ColumnParallelLinear, QKVParallelLinear, RowParallelLinear
+from vllm.model_executor.layers.linear import ColumnParallelLinear, LinearBase, QKVParallelLinear, RowParallelLinear
 from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 from vllm.model_executor.models.utils import (
@@ -29,7 +29,7 @@ from vllm.model_executor.models.utils import (
 )
 from vllm.sequence import IntermediateTensors
 
-from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata, VideoTokenLayout
 from vllm_omni.diffusion.attention.layer import Attention
 from vllm_omni.diffusion.distributed.parallel_state import (
     get_pipeline_parallel_world_size,
@@ -45,6 +45,7 @@ from vllm_omni.diffusion.layers.adalayernorm import AdaLayerNorm
 from vllm_omni.diffusion.layers.norm import LayerNorm, RMSNorm
 from vllm_omni.diffusion.layers.rope import RotaryEmbeddingWan
 from vllm_omni.platforms import current_omni_platform
+from vllm_omni.quantization.mxfp4_config import NPUMxfp4LinearMethod
 
 logger = init_logger(__name__)
 
@@ -416,6 +417,7 @@ class WanSelfAttention(nn.Module):
             softmax_scale=1.0 / (head_dim**0.5),
             causal=False,
             role="self",
+            qkv_layout="BSND",
             prefix=prefix,
         )
 
@@ -608,8 +610,8 @@ class WanCrossAttention(nn.Module):
             qkv_layout="BSND",
             prefix=prefix,
             skip_sequence_parallel=True,
-            # Wan2.2 cross-attn operates on short text-encoder sequences; per-block
-            # FP8 quant offers no perf win and degrades quality. Opt out until a
+            # Wan2.2 cross-attn operates on short text-encoder sequences; runtime
+            # Q/K/V quantization offers no perf win and degrades quality. Opt out until a
             # dedicated quant backend handles this case.
             disable_kv_quant=True,
         )
@@ -763,7 +765,15 @@ class WanTransformerBlock(nn.Module):
             self_attn_extra["vsa_dit_seq_shape"] = vsa_dit_seq_shape
         if preserve_vsa_all_blocks:
             self_attn_extra["preserve_vsa_all_blocks"] = True
-        self_attn_metadata = AttentionMetadata(attn_mask=hidden_states_mask, extra=self_attn_extra)
+        video_layout = None
+        if vsa_dit_seq_shape is not None:
+            grid = tuple(int(dim) for dim in vsa_dit_seq_shape)
+            # Publish geometry independently of backend selection. Do not add
+            # partial cu_seqlens/max_seqlen metadata to dense CUDA attention.
+            video_layout = VideoTokenLayout(prefix_len=0, latent_grid=grid, used_len=math.prod(grid))
+        self_attn_metadata = AttentionMetadata(
+            attn_mask=hidden_states_mask, extra=self_attn_extra, video_layout=video_layout
+        )
         attn_output = self.attn1(norm_hidden_states, rotary_emb, self_attn_metadata)
         hidden_states = (hidden_states + attn_output * gate_msa).type_as(hidden_states)
 
@@ -985,6 +995,68 @@ class WanTransformer3DModel(nn.Module):
         # ROPE helper
         self._cached_rope_emb = None
         self._cached_rope_resolution = None
+        self._validate_w4a8_fallback_layers(quant_config)
+
+    def _validate_w4a8_fallback_layers(self, quant_config: QuantizationConfig | None) -> None:
+        """Reject checkpoint aliases/typos before loading weights or running inference."""
+        requested = tuple(getattr(quant_config, "w4a8_fallback_layers", []))
+        self._w4a8_fallback_layers = requested
+        self._local_w4a8_fallback_layers: tuple[str, ...] = ()
+        if not requested:
+            return
+        modules = dict(self.named_modules())
+        missing_pp_prefixes = [name for name, module in modules.items() if isinstance(module, PPMissingLayer)]
+        local_layers = [
+            name for name in requested if not any(name.startswith(prefix + ".") for prefix in missing_pp_prefixes)
+        ]
+        self._local_w4a8_fallback_layers = tuple(local_layers)
+        invalid = [name for name in local_layers if not isinstance(modules.get(name), LinearBase)]
+        if invalid:
+            raise ValueError(
+                "w4a8_fallback_layers requires exact runtime Linear paths relative to each Wan transformer; "
+                f"unknown/non-Linear paths: {invalid}. Use attn1.to_qkv for fused self-attention, "
+                "not checkpoint attn1.to_q/to_k/to_v names."
+            )
+
+    def _log_w4a8_fallback_load_summary(self, component_name: str) -> None:
+        """Log post-load transforms/cache readiness, not numerical acceptance."""
+        requested = self._w4a8_fallback_layers
+        if not requested:
+            return
+        modules = dict(self.named_modules())
+        local_layers = self._local_w4a8_fallback_layers
+        selected_layers = [
+            name for name in local_layers if getattr(modules[name].quant_method, "is_w4a8_fallback_layer", False)
+        ]
+        bf16_overrides = [name for name in local_layers if name not in selected_layers]
+        processed = [
+            name
+            for name in selected_layers
+            if getattr(modules[name], "_already_called_process_weights_after_loading", False)
+        ]
+        if not selected_layers:
+            processing_state = "not-required"
+        elif len(processed) == len(selected_layers):
+            processing_state = "ready"
+        else:
+            processing_state = "not-ready"
+
+        def qualified(names: Iterable[str]) -> list[str]:
+            return [f"{component_name}.{name}" for name in names]
+
+        logger.info(
+            "Wan W4A8 post-load summary: component=%s; selected=%d %s; BF16 overrides=%d %s; "
+            "weight/A8 processing state=%s (%d/%d selected layers processed); other PP ranks=%d",
+            component_name,
+            len(selected_layers),
+            qualified(selected_layers),
+            len(bf16_overrides),
+            qualified(bf16_overrides),
+            processing_state,
+            len(processed),
+            len(selected_layers),
+            len(requested) - len(local_layers),
+        )
 
     @property
     def dtype(self) -> torch.dtype:
@@ -1155,7 +1227,22 @@ class WanTransformer3DModel(nn.Module):
         }
 
         params_dict = dict(self.named_parameters())
+        single_scale_prefixes = {
+            name
+            for name, module in self.named_modules()
+            if isinstance(getattr(module, "quant_method", None), NPUMxfp4LinearMethod)
+        }
+
+        def reject_dualscale_tensor(name: str) -> None:
+            if name.endswith(".weight_dual_scale") and name.rsplit(".", 1)[0] in single_scale_prefixes:
+                raise ValueError(
+                    f"Single-scale mxfp4 cannot load DualScale tensor {name}; "
+                    "changing quant_method does not convert a checkpoint."
+                )
+
         loaded_params: set[str] = set()
+        loaded_qkv_shards: dict[str, set[str]] = {}
+        qkv_smooth_scales: dict[str, torch.Tensor] = {}
 
         for name, loaded_weight in weights:
             name = weight_name_remapping.get(name, name)
@@ -1166,15 +1253,32 @@ class WanTransformer3DModel(nn.Module):
             # Pre-fused to_qkv tensors (from offline MXFP8 merged checkpoint) fall
             # through to the else branch and are loaded directly.
             for param_name, weight_name, shard_id in stacked_params_mapping:
-                if weight_name not in original_name:
+                if f"{weight_name}." not in original_name:
                     continue
-                lookup_name = original_name.replace(weight_name, param_name)
+                lookup_name = original_name.replace(f"{weight_name}.", f"{param_name}.", 1)
+                reject_dualscale_tensor(lookup_name)
                 # Skip weights that belong to PP stages other than this one
                 if is_pp_missing_parameter(lookup_name, self) or lookup_name not in params_dict:
                     break
                 param = params_dict[lookup_name]
+                if lookup_name.endswith(".mul_scale"):
+                    previous_scale = qkv_smooth_scales.get(lookup_name)
+                    if previous_scale is not None and not torch.equal(previous_scale, loaded_weight):
+                        raise ValueError(f"Fused Q/K/V must share the same Smooth tensor: {lookup_name}")
+                    if previous_scale is None:
+                        qkv_smooth_scales[lookup_name] = loaded_weight.clone()
                 weight_loader = param.weight_loader
                 weight_loader(param, loaded_weight, shard_id)
+                loaded_params.add(original_name)
+                if getattr(param, "output_dim", None) is None and not getattr(param, "needs_scalar_to_array", False):
+                    # Shared input-channel Smooth is a complete tensor even
+                    # when supplied under a single Q/K/V source name.
+                    loaded_params.add(lookup_name)
+                else:
+                    shards = loaded_qkv_shards.setdefault(lookup_name, set())
+                    shards.add(shard_id)
+                    if shards == {"q", "k", "v"}:
+                        loaded_params.add(lookup_name)
                 break
             else:
                 # diffusers: ffn.net.0.proj.weight -> our: ffn.net_0.proj.weight
@@ -1198,6 +1302,7 @@ class WanTransformer3DModel(nn.Module):
                 if is_pp_missing_parameter(lookup_name, self):
                     continue
 
+                reject_dualscale_tensor(lookup_name)
                 if lookup_name not in params_dict:
                     logger.warning(f"Skipping weight {original_name} -> {lookup_name}")
                     continue
@@ -1222,8 +1327,6 @@ class WanTransformer3DModel(nn.Module):
 
                 weight_loader = getattr(param, "weight_loader", default_weight_loader)
                 weight_loader(param, loaded_weight)
-
-            loaded_params.add(original_name)
-            loaded_params.add(lookup_name)
+                loaded_params.update((original_name, lookup_name))
 
         return loaded_params
diff --git a/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py b/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py
index 299ec3d3a..e79d1f197 100644
--- a/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py
+++ b/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py
@@ -53,8 +53,7 @@ from .host_registration import (
     HostRegistrationError,
     register_host_mappings,
 )
-from .offload_plan import OffloadPlan
-from .plan_resolver import ResolvedComponent, resolve_offload_plan
+from .plan_resolver import BlockStack, ResolvedComponent, resolve_offload_plan
 from .tensor_utils import (
     clear_block_storage,
     clear_tensor_storage,
@@ -111,7 +110,6 @@ def _forget_active_hwr_registration(
 # use layerwise offload (streaming hooks) or be moved to GPU as a resident
 # module.  Submodules larger than this are offloaded to save HBM; smaller
 # ones stay resident for lower latency.
-_ON_DEMAND_THRESHOLD_MB = 1024
 
 
 class DistributedLayerwiseOffloadHook(ModelHook):
@@ -1182,7 +1180,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
     def _load_weights_via_mmap(
         self,
         pipeline: nn.Module,
-        modules,
+        dits: tuple[ResolvedComponent, ...],
         plan: HostWeightPlan,
     ) -> None:
         """Load DiT checkpoint tensors as file-backed safetensors views.
@@ -1226,7 +1224,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
         # converts the child's buffers too.  So we must save ALL buffers
         # from ALL DiT modules BEFORE any to_empty call.
         saved_buffers: dict[int, dict[str, torch.Tensor]] = {}
-        for dit_module in modules.dits:
+        for dit_module in (component.module for component in dits):
             bufs: dict[str, torch.Tensor] = {}
             for name, buf in dit_module.named_buffers():
                 # Check if this buffer is non-persistent on its OWNING module
@@ -1246,7 +1244,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
         # Skip modules that are already meta (happens when a parent DiT
         # module contains a child DiT module — to_empty on the parent
         # already converted the child).
-        for dit_module in modules.dits:
+        for dit_module in (component.module for component in dits):
             if any(p.is_meta for p in dit_module.parameters()):
                 logger.info(
                     "%s already on meta device (skipping to_empty, %d buffers saved)",
@@ -1307,7 +1305,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
         # assigning checkpoint tensors. The mmap path bypasses that loader, so
         # preserve the same lifecycle for transforms such as Cosmos3's fp32
         # timestep embedder.
-        for dit_name, dit_module in zip(modules.dit_names, modules.dits):
+        for dit_name, dit_module in ((component.path, component.module) for component in dits):
             # Restore non-persistent buffers before post-load hooks and strict
             # validation. They are constructor-derived and intentionally have
             # no checkpoint binding.
@@ -1352,7 +1350,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
             self._mmap_transforms_by_tensor_id[id(target)] = binding.transform
 
         remaining_meta: list[str] = []
-        for dit_name, dit_module in zip(modules.dit_names, modules.dits):
+        for dit_name, dit_module in ((component.path, component.module) for component in dits):
             remaining_meta.extend(
                 f"{dit_name}.{name}" for name, tensor in dit_module.named_parameters() if tensor.is_meta
             )
@@ -1517,73 +1515,26 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
         )
         return True
 
-    def _try_layerwise_offload_submodule(self, module: nn.Module, name: str, plan: OffloadPlan | None = None) -> bool:
-        """Try to apply layerwise offload to a large submodule's blocks.
-        Resolution order:
-        1. OffloadPlan.offload_submodules (declarative, if plan is provided)
-        2. Heuristic search for common block-list attributes
-
-        Returns True if layerwise offload was applied, False otherwise.
-        """
-        from operator import attrgetter
-
-        blocks = None
-        blocks_attr = None
-
-        # 1. Check OffloadPlan first (declarative — no guessing)
-        if plan is not None and name in plan.offload_submodules:
-            attr_name = plan.offload_submodules[name]
-            try:
-                candidate = attrgetter(attr_name)(module)
-                if isinstance(candidate, nn.ModuleList) and len(candidate) > 1:
-                    blocks = candidate
-                    blocks_attr = attr_name
-            except AttributeError:
-                logger.warning(
-                    "OffloadPlan declared block attr '%s' for submodule '%s' "
-                    "but attribute not found — falling back to heuristic",
-                    attr_name,
-                    name,
-                )
-
-        # 2. Fallback: heuristic search
-        if blocks is None:
-            for attr_name in ("layers", "blocks", "h", "model.layers"):
-                try:
-                    candidate = attrgetter(attr_name)(module)
-                except AttributeError:
-                    continue
-                if isinstance(candidate, nn.ModuleList) and len(candidate) > 1:
-                    blocks = candidate
-                    blocks_attr = attr_name
-                    break
-
-        if blocks is None:
-            return False
-
+    def _offload_nested_submodule(self, component: ResolvedComponent) -> None:
+        """Stream one resolved DiT submodule through its own hook ring."""
+        stack = component.stacks[0]
         logger.info(
             "Distributed layerwise offload for submodule '%s.%s' (%d blocks, %.0f MB total, group_size=%d)",
-            name,
-            blocks_attr,
-            len(blocks),
-            sum(p.nelement() * p.element_size() for p in module.parameters()) / 1048576,
+            component.path,
+            stack.attrs[0],
+            len(stack.blocks),
+            sum(p.nelement() * p.element_size() for p in component.module.parameters()) / 1048576,
             self._component_transport(DIT_COMPONENT)[1],
         )
-
-        # Move non-block parts of the submodule to GPU (small: embeddings, norms)
-        for child_name, child in module.named_children():
-            if child_name != blocks_attr:
-                child.to(self.device)
-
-        self._install_hook_group(blocks, DIT_COMPONENT, use_dit_mmap=True)
-        return True
+        # Keep the submodule's own non-block state resident by block identity,
+        # so an attribute aliasing a streamed block is not placed with it.
+        move_non_block_state_to_device(component.module, (stack.blocks,), self.device)
+        self._install_hook_group(stack.blocks, DIT_COMPONENT, use_dit_mmap=True)
 
     def _prepare_dit_non_block_modules(
         self,
-        dit_module: nn.Module,
-        blocks_attr_names: list[str],
-        all_dit_modules: set[int],
-        plan: OffloadPlan | None,
+        component: ResolvedComponent,
+        stack: BlockStack,
     ) -> None:
         """Place or hook the DiT parts that are outside its repeated blocks.
 
@@ -1591,28 +1542,23 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
         an all-resident stage skips placement for modules such as H3's token
         refiner and enters the forward pass with CPU or meta tensors.
         """
+        dit_module = component.module
+        nested = {child.path.rsplit(".", 1)[-1]: child for child in component.children}
         for name, module in dit_module.named_children():
-            if name in blocks_attr_names:
+            if name in stack.attrs:
                 logger.debug("Skipped blocks module %s", name)
                 continue
 
-            module_mb = (
-                sum(
-                    param.nelement() * param.element_size() if not getattr(param, "is_meta", False) else 0
-                    for param in module.parameters()
-                )
-                / 1048576
-            )
-            explicitly_planned = plan is not None and name in plan.offload_submodules
-            if explicitly_planned or module_mb > _ON_DEMAND_THRESHOLD_MB:
-                if id(module) in all_dit_modules:
+            child = nested.get(name)
+            if child is not None:
+                if not child.selected:
                     logger.info("Submodule '%s' is already a DiT module, skipping layerwise offload", name)
-                elif self._try_layerwise_offload_submodule(module, name, plan):
-                    pass
+                elif child.stacks:
+                    self._offload_nested_submodule(child)
                 else:
                     prepare_component(
-                        module,
-                        name,
+                        child.module,
+                        child.path,
                         device=self.device,
                         stage_on_demand=True,
                         blockwise=False,
@@ -1715,7 +1661,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
             elif host_weight_plan.backing_kind == "checkpoint_mmap":
                 self._load_weights_via_mmap(
                     pipeline,
-                    resolved.modules,
+                    resolved.dits,
                     host_weight_plan,
                 )
             else:
@@ -1750,16 +1696,12 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
             enable_encoder_blocks=self._try_layerwise_offload_encoder,
         )
 
-        if self.config.offloads(DIT_COMPONENT):
+        if any(component.selected for component in resolved.dits):
             logger.info(
                 "Applying distributed layer-wise offloading on %s",
                 [component.path for component in resolved.dits],
             )
 
-        # Collect all DiT module objects to detect submodules that are
-        # already handled as a separate DiT module (avoids duplicate hooks).
-        all_dit_modules = set(id(component.module) for component in resolved.dits)
-
         # Apply hooks for each DiT module
         for component, stack in iter_streamable_dits(resolved, self.device):
             streaming = list(stack.streaming)
@@ -1772,12 +1714,7 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
                     len(streaming),
                 )
 
-            self._prepare_dit_non_block_modules(
-                component.module,
-                list(stack.attrs),
-                all_dit_modules,
-                resolved.declaration,
-            )
+            self._prepare_dit_non_block_modules(component, stack)
 
             if not streaming:
                 logger.info("All blocks for %s are resident; no streaming hooks required", component.path)
@@ -1804,11 +1741,6 @@ class DistributedLayerwiseOffloadBackend(OffloadBackend):
             self.enabled = bool(self._resident_blocks or self._encoder_modules or self._staged_components)
             if self._using_mmap and not self.enabled:
                 self._release_mmap_handles()
-            if not self.enabled and not self.config.offloads(DIT_COMPONENT):
-                raise ValueError(
-                    "None of the selected distributed layerwise offload components have "
-                    "a model-declared streamable or on-demand plan"
-                )
             return
 
         # Unified allocation: 2 shared output buffers + 2 shared shard buffers
diff --git a/vllm_omni/diffusion/offloader/plan_resolver.py b/vllm_omni/diffusion/offloader/plan_resolver.py
index 08527318f..ca32f6d3f 100644
--- a/vllm_omni/diffusion/offloader/plan_resolver.py
+++ b/vllm_omni/diffusion/offloader/plan_resolver.py
@@ -17,6 +17,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import cache
+from operator import attrgetter
 from typing import TYPE_CHECKING
 
 from torch import nn
@@ -27,7 +28,7 @@ from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
 from .block_discovery import get_blocks_from_dit
 from .component_utils import get_encoder_block_groups, validate_on_demand_component
 from .config import DIT_COMPONENT, TEXT_ENCODER_COMPONENT, OffloadStrategy
-from .module_collector import ModuleDiscovery, PipelineModules
+from .module_collector import ModuleDiscovery
 from .offload_plan import OffloadPlan, get_offload_plan
 
 if TYPE_CHECKING:
@@ -76,6 +77,9 @@ class ResolvedComponent:
     selected: bool
     stacks: tuple[BlockStack, ...] = ()
     on_demand: bool = False
+    # Submodules of a DiT that are large enough to own their residency instead
+    # of staying resident with the rest of its non-block state.
+    children: tuple[ResolvedComponent, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -86,11 +90,6 @@ class ResolvedOffloadPlan:
     encoders: tuple[ResolvedComponent, ...]
     vaes: tuple[ResolvedComponent, ...]
     residents: tuple[ResolvedComponent, ...]
-    # Raw discovery output and the model declaration remain reachable for the
-    # loader-owned mmap path and for DLO's nested-submodule staging, which
-    # still interpret topology themselves.
-    modules: PipelineModules
-    declaration: OffloadPlan | None = None
     # Ordinary layerwise offload turns a legacy selection it cannot serve into
     # a complete no-op, placement included. Distributed layerwise offload warns
     # and keeps preparing its other components instead, so this stays scoped to
@@ -102,6 +101,22 @@ class ResolvedOffloadPlan:
         return self.dits + self.encoders + self.vaes + self.residents
 
 
+# A DiT submodule this large owns its residency even when no plan declares it.
+_NESTED_OFFLOAD_THRESHOLD_MB = 1024
+_NESTED_BLOCK_ATTRS = ("layers", "blocks", "h", "model.layers")
+
+
+@cache
+def _warn_nested_block_scan(module_class: str, attr: str) -> None:
+    """Warn once per class that a nested block list was found by guessing."""
+    logger.warning(
+        "%s block list was discovered as %r by scanning well-known attribute names. "
+        "Declare it in OffloadPlan.offload_submodules; the attribute scan is deprecated.",
+        module_class,
+        attr,
+    )
+
+
 @cache
 def _warn_legacy_discovery(pipeline_class: str) -> None:
     """Warn once per pipeline class that component discovery guessed.
@@ -117,6 +132,77 @@ def _warn_legacy_discovery(pipeline_class: str) -> None:
     )
 
 
+def _nested_block_stack(module: nn.Module, declared_attr: str | None) -> BlockStack | None:
+    """Resolve one DiT submodule's own block ring, if it has one."""
+    candidates = (declared_attr,) if declared_attr is not None else _NESTED_BLOCK_ATTRS
+    for attr in candidates:
+        try:
+            blocks = attrgetter(attr)(module)
+        except AttributeError:
+            continue
+        if isinstance(blocks, nn.ModuleList) and len(blocks) > 1:
+            if declared_attr is None:
+                _warn_nested_block_scan(type(module).__name__, attr)
+            return BlockStack(attrs=(attr,), blocks=tuple(blocks))
+    if declared_attr is not None:
+        logger.warning(
+            "OffloadPlan declared block attr %r for submodule %s but it is not a streamable block list",
+            declared_attr,
+            type(module).__name__,
+        )
+    return None
+
+
+def _resolve_dit_children(
+    dit_module: nn.Module,
+    dit_path: str,
+    stack: BlockStack,
+    declaration: OffloadPlan | None,
+    dit_module_ids: set[int],
+) -> tuple[ResolvedComponent, ...]:
+    """Resolve the DiT submodules that own their residency.
+
+    A submodule qualifies when the model declares it or when it is large enough
+    that keeping it resident would defeat streaming. Submodules that are
+    themselves discovered DiTs are left to their own component.
+    """
+    children: list[ResolvedComponent] = []
+    for name, module in dit_module.named_children():
+        if name in stack.attrs:
+            continue
+        declared_attr = None if declaration is None else declaration.offload_submodules.get(name)
+        if declared_attr is None and _module_size_mb(module) <= _NESTED_OFFLOAD_THRESHOLD_MB:
+            continue
+        path = f"{dit_path}.{name}"
+        if id(module) in dit_module_ids:
+            # Its own component owns this submodule; the parent must not place it.
+            children.append(ResolvedComponent(path=path, module=module, selected=False))
+            continue
+        nested_stack = _nested_block_stack(module, declared_attr)
+        if nested_stack is None:
+            # Without its own ring the submodule needs the pipeline lifecycle.
+            validate_on_demand_component(module, path)
+        children.append(
+            ResolvedComponent(
+                path=path,
+                module=module,
+                selected=True,
+                stacks=() if nested_stack is None else (nested_stack,),
+                on_demand=nested_stack is None,
+            )
+        )
+    return tuple(children)
+
+
+def _module_size_mb(module: nn.Module) -> float:
+    """Expected parameter bytes in MiB, including not-yet-loaded meta tensors.
+
+    Resolution precedes mmap materialization, so residency must depend on the
+    tensor metadata rather than whether the loader has allocated storage yet.
+    """
+    return sum(parameter.nelement() * parameter.element_size() for parameter in module.parameters()) / 1048576
+
+
 def _resolve_dit_stacks(
     module: nn.Module,
     path: str,
@@ -253,11 +339,25 @@ def resolve_offload_plan(pipeline: nn.Module, config: OffloadConfig) -> Resolved
     vaes: list[ResolvedComponent] = []
     residents: list[ResolvedComponent] = []
 
+    dit_module_ids = {id(module) for module in modules.dits}
     for path, module in zip(modules.dit_names, modules.dits):
         stacks: tuple[BlockStack, ...] = ()
+        children: tuple[ResolvedComponent, ...] = ()
         if dit_selected and layerwise:
             stacks = _resolve_dit_stacks(module, path, declaration, config, explicit=explicit)
-        dits.append(ResolvedComponent(path=path, module=module, selected=dit_selected, stacks=stacks))
+            # Only distributed layerwise offload streams or stages submodules;
+            # the ordinary backend keeps all non-block state resident.
+            if stacks and config.strategy is OffloadStrategy.DISTRIBUTED_LAYER_WISE:
+                children = _resolve_dit_children(module, path, stacks[0], declaration, dit_module_ids)
+        dits.append(
+            ResolvedComponent(
+                path=path,
+                module=module,
+                selected=dit_selected,
+                stacks=stacks,
+                children=children,
+            )
+        )
 
     for path, module in zip(modules.encoder_names, modules.encoders):
         selected = config.should_offload_encoder(path, declaration)
@@ -307,8 +407,6 @@ def resolve_offload_plan(pipeline: nn.Module, config: OffloadConfig) -> Resolved
         encoders=tuple(encoders),
         vaes=tuple(vaes),
         residents=tuple(residents),
-        modules=modules,
-        declaration=declaration,
         skip_reason=(
             "No DiT/transformer modules found for selected DiT layerwise offload"
             if config.strategy is OffloadStrategy.LAYER_WISE and dit_selected and not dits
@@ -322,7 +420,10 @@ def resolve_offload_plan(pipeline: nn.Module, config: OffloadConfig) -> Resolved
 def _validate_unique_ownership(resolved: ResolvedOffloadPlan) -> None:
     """Reject topologies where two components would hook the same blocks."""
     owner_by_block: dict[int, str] = {}
-    for component in resolved.components:
+    pending = list(reversed(resolved.components))
+    while pending:
+        component = pending.pop()
+        pending.extend(reversed(component.children))
         for block in (block for stack in component.stacks for block in stack.blocks):
             owner = owner_by_block.setdefault(id(block), component.path)
             if owner != component.path:
diff --git a/vllm_omni/diffusion/registry.py b/vllm_omni/diffusion/registry.py
index 26b052a3a..17d8216db 100644
--- a/vllm_omni/diffusion/registry.py
+++ b/vllm_omni/diffusion/registry.py
@@ -19,6 +19,19 @@ from vllm_omni.platforms import current_omni_platform
 
 logger = init_logger(__name__)
 
+_NATIVE_SINGLE_FILE_MODELS = {
+    "AnimaPipeline": ("AnimaModularPipeline",),
+}
+
+
+def resolve_native_single_file(model_class_name: str | None) -> str | None:
+    """Return the canonical native pipeline for a single-file model class."""
+    for canonical, aliases in _NATIVE_SINGLE_FILE_MODELS.items():
+        if model_class_name == canonical or model_class_name in aliases:
+            return canonical
+    return None
+
+
 _DIFFUSION_MODELS = {
     # arch:(mod_folder, mod_relname, cls_name)
     "QwenImagePipeline": (
@@ -56,6 +69,11 @@ _DIFFUSION_MODELS = {
         "pipeline_ovis_image",
         "OvisImagePipeline",
     ),
+    "MammothModa2DiTPipeline": (
+        "mammoth_moda2",
+        "pipeline_mammothmoda2_dit",
+        "MammothModa2DiTPipeline",
+    ),
     "WanPipeline": (
         "wan2_2",
         "pipeline_wan2_2",
@@ -206,6 +224,11 @@ _DIFFUSION_MODELS = {
         "pipeline_pi0",
         "Pi0Pipeline",
     ),
+    "Pi05Pipeline": (
+        "pi05",
+        "pipeline_pi05",
+        "Pi05Pipeline",
+    ),
     "LongCatImageEditPipeline": (
         "longcat_image",
         "pipeline_longcat_image_edit",
@@ -351,6 +374,11 @@ _DIFFUSION_MODELS = {
         "pipeline_dreamzero",
         "DreamZeroPipeline",
     ),
+    "AnimaPipeline": (
+        "anima",
+        "pipeline_anima",
+        "AnimaPipeline",
+    ),
     "StableDiffusionXLPipeline": (
         "sdxl",
         "pipeline_sdxl",
@@ -377,11 +405,13 @@ DiffusionModelRegistry = _ModelRegistry(
 _NO_CACHE_ACCELERATION = {
     # Pipelines that do not support cache acceleration (cache_dit / tea_cache).
     "NextStep11Pipeline",
+    "AnimaPipeline",
     # π0 is a flow-matching VLA with a self-contained sample_actions loop and no
     # DiT-style ``.transformer`` block list, so cache_dit / tea_cache cannot apply
     # to it; list it here so a stray cache_backend override disables gracefully
     # instead of erroring.
     "Pi0Pipeline",
+    "Pi05Pipeline",
     "LingBotWorldCausalDMDPipeline",
 }
 
@@ -553,11 +583,13 @@ _DIFFUSION_POST_PROCESS_FUNCS = {
     # `post_process_func` function must be placed in {mod_folder}/{mod_relname}.py,
     # where mod_folder and mod_relname are  defined and mapped using `_DIFFUSION_MODELS` via the `arch` key
     "QwenImagePipeline": "get_qwen_image_post_process_func",
+    "AnimaPipeline": "get_anima_post_process_func",
     "QwenImageEditPipeline": "get_qwen_image_edit_post_process_func",
     "QwenImageEditPlusPipeline": "get_qwen_image_edit_plus_post_process_func",
     "GlmImagePipeline": "get_glm_image_post_process_func",
     "ZImagePipeline": "get_post_process_func",
     "OvisImagePipeline": "get_ovis_image_post_process_func",
+    "MammothModa2DiTPipeline": "get_mammoth_moda2_post_process_func",
     "BooguImagePipeline": "get_boogu_image_post_process_func",
     "BooguImageTurboPipeline": "get_boogu_image_post_process_func",
     "WanPipeline": "get_wan22_post_process_func",
@@ -586,6 +618,7 @@ _DIFFUSION_POST_PROCESS_FUNCS = {
     "MingImagePipeline": "get_ming_image_post_process_func",
     "InternVLAA1Pipeline": "get_internvla_a1_post_process_func",
     "Pi0Pipeline": "get_pi0_post_process_func",
+    "Pi05Pipeline": "get_pi05_post_process_func",
     "LongCatImageEditPipeline": "get_longcat_image_post_process_func",
     "StableDiffusion3Pipeline": "get_sd3_image_post_process_func",
     "FluxKontextPipeline": "get_flux_kontext_post_process_func",
diff --git a/vllm_omni/diffusion/request.py b/vllm_omni/diffusion/request.py
index 9e9a4bfbb..b5be82567 100644
--- a/vllm_omni/diffusion/request.py
+++ b/vllm_omni/diffusion/request.py
@@ -70,6 +70,8 @@ class OmniDiffusionRequest:
     # Opaque native vLLM connector parameters. The Orchestrator and Scheduler
     # transport this bag without interpreting local pages or block IDs.
     kv_transfer_params: dict[str, Any] | None = None
+    # Worker-populated scheduler reuse boundaries, available before encoding.
+    kv_computed_tokens: tuple[int, ...] = ()
     # A model preprocessor may keep selected requests on the legacy full-forward
     # path even when the engine is globally configured for step execution.
     use_step_execution: bool = True
diff --git a/vllm_omni/diffusion/sched/base_scheduler.py b/vllm_omni/diffusion/sched/base_scheduler.py
index d9bb78ea4..4fd695dc5 100644
--- a/vllm_omni/diffusion/sched/base_scheduler.py
+++ b/vllm_omni/diffusion/sched/base_scheduler.py
@@ -11,10 +11,17 @@ from dataclasses import fields
 from vllm.config import VllmConfig
 from vllm.logger import init_logger
 from vllm.v1.kv_cache_interface import KVCacheConfig
+from vllm.v1.outputs import KVConnectorOutput
+from vllm.v1.request import RequestStatus
 
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.diffusion_kv.config import DiffusionKVCacheMode
-from vllm_omni.diffusion.diffusion_kv.manager import DiffusionKVAdmissionError, DiffusionKVCacheManager
+from vllm_omni.diffusion.diffusion_kv.kv_connector import (
+    KVTransferRegistrationError,
+    commit_kv_load,
+    prepare_kv_requests,
+)
+from vllm_omni.diffusion.diffusion_kv.manager import DiffusionKVCacheManager
 from vllm_omni.diffusion.diffusion_kv.metadata import DiffusionKVMetadata
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched.interface import (
@@ -58,6 +65,12 @@ class BaseScheduler(ABC):
         self._prefetch_enabled: bool = False
         self._diffusion_kv_manager: DiffusionKVCacheManager | None = None
         self._kv_connector = None
+        self._kv_transfer_request_ids: set[str] = set()
+        self._kv_finished_request_ids: set[str] = set()
+        self._kv_loading_request_ids: set[str] = set()
+        self._kv_request_generations: dict[str, int] = {}
+        self._kv_draining_requests: dict[str, SchedulerRequestState] = {}
+        self._kv_received_request_ids: set[str] = set()
 
     def initialize(
         self,
@@ -75,6 +88,7 @@ class BaseScheduler(ABC):
         self._running.clear()
         self._running_sampling_params_key = None
         self._finished_req_ids.clear()
+        self._reset_kv_transfer_state()
         max_num_seqs = getattr(od_config, "max_num_seqs", 1)
         try:
             self.max_num_running_reqs = max(1, int(max_num_seqs))
@@ -114,7 +128,7 @@ class BaseScheduler(ABC):
             self._diffusion_kv_manager = None
         from vllm_omni.diffusion.diffusion_kv.kv_connector import create_scheduler_kv_connector
 
-        self._kv_connector = create_scheduler_kv_connector(od_config)
+        self._kv_connector = create_scheduler_kv_connector(od_config, kv_cache_config, kv_vllm_config)
         self._reset_scheduler_state()
 
     @property
@@ -127,7 +141,7 @@ class BaseScheduler(ABC):
         return self._add_request_with_request_id(request.request_id, request)
 
     def _add_request_with_request_id(self, request_id: str, request: OmniDiffusionRequest) -> str:
-        if request_id in self._request_states:
+        if request_id in self._request_states or request_id in self._kv_draining_requests:
             raise ValueError(f"request_id {request_id!r} is already active.")
         state = self._make_request_state(request_id, request)
         state.queued_at = time.perf_counter()
@@ -147,7 +161,10 @@ class BaseScheduler(ABC):
                 scheduled_cached_request_ids.append(request_id)
 
         # Second, schedule WAITING requests while capacity remains.
-        while self._waiting and len(self._running) < self.max_num_running_reqs:
+        deferred: list[str] = []
+        waiting_budget = len(self._waiting)
+        while self._waiting and waiting_budget and len(self._running) < self.max_num_running_reqs:
+            waiting_budget -= 1
             request_id = self._waiting[0]
             state = self._request_states.get(request_id)
             if state is None:
@@ -161,21 +178,24 @@ class BaseScheduler(ABC):
                 if self._diffusion_kv_manager.has_request(request_id):
                     diffusion_kv_metadata = self._diffusion_kv_manager.get_metadata(request_id)
                 else:
+                    matched_tokens: list[int] = []
+                    if self._kv_connector is not None:
+                        for request in state.diffusion_kv_requests:
+                            num_tokens, _ = self._kv_connector.get_num_new_matched_tokens(request, 0)
+                            if num_tokens is None:
+                                break
+                            matched_tokens.append(num_tokens)
+                        if len(matched_tokens) != len(state.diffusion_kv_requests):
+                            deferred.append(self._waiting.popleft())
+                            continue
                     try:
                         allocation = self._diffusion_kv_manager.reserve_request(
                             request_id,
                             state.diffusion_kv_requests,
                         )
                     except Exception as exc:
-                        # schedule() runs outside the Engine execution-error
-                        # wrapper. Convert both expected admission failures and
-                        # unexpected native allocator failures into a terminal
-                        # request error so the busy loop can wake its stream.
-                        if not isinstance(exc, DiffusionKVAdmissionError):
-                            logger.exception(
-                                "Unexpected Diffusion KV allocation failure for request %s",
-                                request_id,
-                            )
+                        # Reservation rolls back on failure and has not yet
+                        # handed any destination pages to the connector.
                         self._finish_requests(
                             {request_id: DiffusionRequestStatus.FINISHED_ERROR},
                             {request_id: str(exc)},
@@ -184,6 +204,27 @@ class BaseScheduler(ABC):
                     if allocation is None:
                         break
                     diffusion_kv_metadata = allocation
+                    self._kv_request_generations[request_id] = allocation.allocation_generation
+                    if self._kv_connector is not None:
+                        try:
+                            transfer_ids = commit_kv_load(
+                                self._kv_connector,
+                                self._diffusion_kv_manager.native_manager,
+                                state.diffusion_kv_requests,
+                                matched_tokens,
+                            )
+                        except KVTransferRegistrationError as exc:
+                            self._finish_requests(
+                                {request_id: DiffusionRequestStatus.FINISHED_ERROR}, {request_id: str(exc)}
+                            )
+                            continue
+                        # Other exceptions have no proven rollback. Keep pages
+                        # allocated until the Engine shuts down the Workers.
+                        self._kv_transfer_request_ids.update(transfer_ids)
+                        if transfer_ids:
+                            self._kv_loading_request_ids.add(request_id)
+                        for sequence, request in zip(allocation.sequences, state.diffusion_kv_requests, strict=True):
+                            sequence.num_computed_tokens = request.num_computed_tokens
 
             self._waiting.popleft()
             was_new_request = state.status == DiffusionRequestStatus.WAITING
@@ -202,6 +243,8 @@ class BaseScheduler(ABC):
             else:
                 scheduled_cached_request_ids.append(request_id)
 
+        self._waiting.extendleft(reversed(deferred))
+
         # Expose the next waiting request (serial mode) so the runner can
         # prefetch its KV during this forward.  Skip a request without
         # kv_sender_info (would target the wrong sender under multi-replica) or
@@ -226,11 +269,19 @@ class BaseScheduler(ABC):
             num_running_reqs=len(self._running),
             num_waiting_reqs=len(self._waiting),
             kv_prefetch_job=kv_prefetch_job,
+            kv_finished_request_ids=set(self._kv_finished_request_ids),
         )
+        if self._kv_connector is not None and (
+            self._kv_transfer_request_ids or self._kv_finished_request_ids or self._kv_draining_requests
+        ):
+            scheduler_output.kv_connector_metadata = self._kv_connector.build_connector_meta(scheduler_output)
+            scheduler_output.kv_transfer_request_ids = self._kv_transfer_request_ids
+            self._kv_transfer_request_ids = set()
 
         # update after schedule
         self._step_id += 1
         self._finished_req_ids.clear()
+        self._kv_finished_request_ids.clear()
         return scheduler_output
 
     @abstractmethod
@@ -238,7 +289,53 @@ class BaseScheduler(ABC):
         pass
 
     def has_requests(self) -> bool:
-        return bool(self._waiting or self._running)
+        return bool(
+            self._waiting
+            or self._running
+            or self._kv_transfer_request_ids
+            or self._kv_finished_request_ids
+            or self._kv_draining_requests
+        )
+
+    def update_kv_connector_output(self, output: KVConnectorOutput | None) -> None:
+        if output is None:
+            return
+        assert self._kv_connector is not None
+        self._kv_connector.update_connector_output(output)
+        finished_ids = output.finished_recving or set()
+        if not finished_ids:
+            return
+        for request_id in tuple(self._kv_loading_request_ids):
+            state = self._request_states.get(request_id) or self._kv_draining_requests.get(request_id)
+            if state is None:
+                continue
+            internal_ids = {request.request_id for request in state.diffusion_kv_requests}
+            self._kv_received_request_ids.update(internal_ids.intersection(finished_ids))
+            if internal_ids and internal_ids.issubset(self._kv_received_request_ids):
+                self._kv_loading_request_ids.discard(request_id)
+                self._kv_received_request_ids.difference_update(internal_ids)
+
+    def fail_incomplete_kv_loads(self, transfer_ids: set[str]) -> set[str]:
+        statuses = {}
+        for request_id in self._kv_loading_request_ids:
+            state = self._request_states.get(request_id)
+            if state is not None and any(req.request_id in transfer_ids for req in state.diffusion_kv_requests):
+                statuses[request_id] = DiffusionRequestStatus.FINISHED_ERROR
+        return self._finish_requests(statuses, {rid: "Timed out receiving diffusion KV" for rid in statuses})
+
+    def completed_kv_drains(self) -> set[str]:
+        return self._kv_draining_requests.keys() - self._kv_loading_request_ids
+
+    def release_kv_drains(self, request_ids: set[str]) -> None:
+        """Called only after all ranks completed and Worker row cleanup succeeded."""
+        for request_id in request_ids:
+            if request_id in self._kv_loading_request_ids:
+                raise RuntimeError("Cannot release diffusion pages before KV receive completes")
+            state = self._kv_draining_requests[request_id]
+            self._release_request_kv(state, state.status)
+            del self._kv_draining_requests[request_id]
+            if request_id not in self._request_states:
+                self._kv_request_generations.pop(request_id, None)
 
     def num_waiting_requests(self) -> int:
         return len(self._waiting)
@@ -270,13 +367,27 @@ class BaseScheduler(ABC):
     def get_request_state(self, request_id: str) -> SchedulerRequestState | None:
         return self._request_states.get(request_id)
 
+    def get_diffusion_kv_cleanup_targets(self, request_ids: list[str]) -> list[str | tuple[str, int]]:
+        targets: list[str | tuple[str, int]] = []
+        for request_id in request_ids:
+            if request_id in self._kv_loading_request_ids:
+                continue
+            generation = self._kv_request_generations.get(request_id)
+            if generation is not None:
+                targets.append((request_id, generation))
+            else:
+                targets.append(request_id)
+        return targets
+
     def pop_request_state(self, request_id: str) -> SchedulerRequestState | None:
-        if self._diffusion_kv_manager is not None:
-            self._diffusion_kv_manager.free_request(request_id)
         self._pop_extra_request_state(request_id)
+        if request_id not in self._kv_draining_requests:
+            self._kv_request_generations.pop(request_id, None)
         return self._request_states.pop(request_id, None)
 
     def preempt_request(self, request_id: str) -> bool:
+        if request_id in self._kv_loading_request_ids:
+            return False
         if request_id not in self._request_states:
             return False
         if request_id in self._running:
@@ -295,13 +406,7 @@ class BaseScheduler(ABC):
         self._finish_requests({request_id: status for request_id in request_ids})
 
     def close(self) -> None:
-        if self._diffusion_kv_manager is not None:
-            self._diffusion_kv_manager.close()
-            self._diffusion_kv_manager = None
-        from vllm_omni.diffusion.diffusion_kv.kv_connector import shutdown_kv_connector
-
-        shutdown_kv_connector(scheduler_connector=self._kv_connector)
-        self._kv_connector = None
+        self._shutdown_diffusion_kv()
         self._request_states.clear()
         self._waiting.clear()
         self._running.clear()
@@ -309,6 +414,26 @@ class BaseScheduler(ABC):
         self._finished_req_ids.clear()
         self._reset_scheduler_state()
 
+    def _reset_kv_transfer_state(self) -> None:
+        """Clear request bookkeeping for native KV transfers."""
+        self._kv_transfer_request_ids.clear()
+        self._kv_finished_request_ids.clear()
+        self._kv_loading_request_ids.clear()
+        self._kv_draining_requests.clear()
+        self._kv_received_request_ids.clear()
+        self._kv_request_generations.clear()
+
+    def _shutdown_diffusion_kv(self) -> None:
+        """Stop transfers before releasing their cache and request state."""
+        from vllm_omni.diffusion.diffusion_kv.kv_connector import shutdown_kv_connector
+
+        shutdown_kv_connector(scheduler_connector=self._kv_connector)
+        self._kv_connector = None
+        if self._diffusion_kv_manager is not None:
+            self._diffusion_kv_manager.close()
+            self._diffusion_kv_manager = None
+        self._reset_kv_transfer_state()
+
     def _finish_requests(
         self,
         statuses: dict[str, DiffusionRequestStatus],
@@ -326,7 +451,6 @@ class BaseScheduler(ABC):
             state = self._request_states.get(request_id)
             if state is None or state.is_finished():
                 continue
-
             finished_req_ids.add(request_id)
             if request_id in self._running:
                 running_to_remove.add(request_id)
@@ -341,10 +465,12 @@ class BaseScheduler(ABC):
             self._waiting = deque(request_id for request_id in self._waiting if request_id not in waiting_to_remove)
 
         for request_id in finished_req_ids:
-            if self._diffusion_kv_manager is not None:
-                self._diffusion_kv_manager.free_request(request_id)
             state = self._request_states[request_id]
             status = statuses[request_id]
+            if request_id in self._kv_loading_request_ids:
+                self._kv_draining_requests[request_id] = state
+            else:
+                self._release_request_kv(state, status)
             state.status = status
             if status == DiffusionRequestStatus.FINISHED_ERROR:
                 state.error = None if errors is None else errors.get(request_id)
@@ -354,6 +480,27 @@ class BaseScheduler(ABC):
         self._finished_req_ids |= finished_req_ids
         return finished_req_ids
 
+    def _release_request_kv(self, state: SchedulerRequestState, status: DiffusionRequestStatus) -> None:
+        request_id = state.request_id
+        if self._kv_connector is not None:
+            for request in state.diffusion_kv_requests:
+                request.status = (
+                    RequestStatus.FINISHED_ABORTED
+                    if status == DiffusionRequestStatus.FINISHED_ABORTED
+                    else RequestStatus.FINISHED_STOPPED
+                )
+                if request.kv_transfer_params:
+                    self._kv_finished_request_ids.add(request.request_id)
+                block_ids = []
+                if self._diffusion_kv_manager.has_request(request_id):
+                    blocks = self._diffusion_kv_manager.native_manager.get_blocks(request.request_id)
+                    block_ids = blocks.get_block_ids()[0]
+                delay_free, _ = self._kv_connector.request_finished(request, block_ids)
+                if delay_free:
+                    raise RuntimeError("Diffusion consumer cannot release pages while KV transfer is active")
+        if self._diffusion_kv_manager is not None:
+            self._diffusion_kv_manager.free_request(request_id)
+
     def _finalize_update_from_output(
         self,
         sched_output: DiffusionSchedulerOutput,
@@ -391,13 +538,9 @@ class BaseScheduler(ABC):
         elif kv_requests:
             raise ValueError("dense_legacy request unexpectedly contains Scheduler Diffusion KV requests")
 
-        # Keep the request-scoped native connector bag on each Scheduler-owned
-        # sequence without interpreting its contents or creating page state.
         kv_transfer_params = getattr(request, "kv_transfer_params", None)
         if kv_transfer_params is not None:
-            for kv_request in kv_requests:
-                if kv_request.kv_transfer_params is None:
-                    kv_request.kv_transfer_params = dict(kv_transfer_params)
+            prepare_kv_requests(kv_requests, kv_transfer_params)
 
         # DiffusionKVRequest objects are mutable Scheduler/native-KVCacheManager
         # state and must never ride the normal request payload to a Worker.
diff --git a/vllm_omni/diffusion/sched/interface.py b/vllm_omni/diffusion/sched/interface.py
index 122a97ec2..fd2b47c63 100644
--- a/vllm_omni/diffusion/sched/interface.py
+++ b/vllm_omni/diffusion/sched/interface.py
@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import enum
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, TypedDict
 
@@ -254,9 +254,10 @@ class DiffusionSchedulerOutput:
     num_waiting_reqs: int
     # next request to background-prefetch KV
     kv_prefetch_job: KVPrefetchJob | None = None
-    # Opaque metadata emitted by a future Scheduler-role connector. PR0 keeps
-    # the input port but does not build or consume it.
     kv_connector_metadata: KVConnectorMetadata | None = None
+    kv_transfer_request_ids: set[str] = field(default_factory=set)
+    # Connector lifecycle uses per-sequence IDs, not public request IDs.
+    kv_finished_request_ids: set[str] = field(default_factory=set)
 
     @cached_property
     def scheduled_request_ids(self) -> list[str]:
@@ -274,4 +275,4 @@ class DiffusionSchedulerOutput:
 
     @property
     def is_empty(self) -> bool:
-        return self.num_scheduled_reqs == 0
+        return self.num_scheduled_reqs == 0 and self.kv_connector_metadata is None
diff --git a/vllm_omni/diffusion/sched/request_scheduler.py b/vllm_omni/diffusion/sched/request_scheduler.py
index 4168ae974..826a63c67 100644
--- a/vllm_omni/diffusion/sched/request_scheduler.py
+++ b/vllm_omni/diffusion/sched/request_scheduler.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from __future__ import annotations
 
@@ -100,7 +100,7 @@ class RequestScheduler(BaseScheduler):
 
     def update_from_output(self, sched_output: DiffusionSchedulerOutput, output: RunnerOutput) -> set[str]:
         scheduled_request_ids = sched_output.scheduled_request_ids
-        if not scheduled_request_ids:
+        if not scheduled_request_ids and not sched_output.finished_req_ids:
             return set()
 
         terminal_statuses: dict[str, DiffusionRequestStatus] = {}
diff --git a/vllm_omni/diffusion/sched/step_scheduler.py b/vllm_omni/diffusion/sched/step_scheduler.py
index a5a7a04ae..636c71ba2 100644
--- a/vllm_omni/diffusion/sched/step_scheduler.py
+++ b/vllm_omni/diffusion/sched/step_scheduler.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from __future__ import annotations
 
@@ -64,7 +64,7 @@ class StepScheduler(BaseScheduler):
 
     def update_from_output(self, sched_output: DiffusionSchedulerOutput, output: RunnerOutput) -> set[str]:
         scheduled_request_ids = sched_output.scheduled_request_ids
-        if not scheduled_request_ids:
+        if not scheduled_request_ids and not sched_output.finished_req_ids:
             return set()
 
         terminal_statuses: dict[str, DiffusionRequestStatus] = {}
diff --git a/vllm_omni/diffusion/utils/chunked_video.py b/vllm_omni/diffusion/utils/chunked_video.py
new file mode 100644
index 000000000..57b6d2f82
--- /dev/null
+++ b/vllm_omni/diffusion/utils/chunked_video.py
@@ -0,0 +1,492 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Turn committed VAE chunks into MP4 bytes without materializing the video.
+
+The producer side is the model's business: a Wan VAE walks a causal
+frame-by-frame loop, a MiniMax-H3 VAE walks overlapping clips, and Wan S2V
+decodes one clip per autoregressive iteration. What happens to a chunk once it
+is final is not: every one of them quantizes to uint8, moves to the host once,
+and lands in a bounded encoder. That consumer lives here so a model only has to
+publish finished chunks -- :class:`SupportsChunkedVAEDecode` for producers that
+can be driven, :class:`ChunkedVideoMP4Session` for producers that drive
+themselves.
+
+The move to the host runs as its own scheduled stage. A chunk is quantized on
+the accelerator, copied without blocking into one of a fixed number of reusable
+pinned host slots on a dedicated stream, and only read once its copy-completion
+event has fired. The producer therefore returns to decoding while the copy is
+still in flight, and the slot count bounds how many chunks can be in flight at
+once.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.models.interface import supports_chunked_vae_decode
+from vllm_omni.diffusion.utils.media_utils import ChunkedMP4Encoder
+
+logger = init_logger(__name__)
+
+# Re-checked while waiting for a slot so an abort recorded without a notify
+# still wakes the producer.
+_SLOT_POLL_SECONDS = 0.05
+
+_COPY_STREAMS: dict[tuple[str, int], torch.Stream] = {}
+_COPY_STREAM_LOCK = threading.Lock()
+
+
+def _copy_stream(device: torch.device) -> torch.Stream:
+    """Return the process-wide chunk-copy stream for ``device``.
+
+    One stream per device rather than one per request: copies are issued in
+    order on it anyway, and a stream per request would churn accelerator
+    resources for no ordering benefit.
+    """
+    with _COPY_STREAM_LOCK:
+        key = (device.type, device.index or 0)
+        stream = _COPY_STREAMS.get(key)
+        if stream is None:
+            stream = torch.Stream(device=device)
+            _COPY_STREAMS[key] = stream
+        return stream
+
+
+def quantize_chunk(chunk: torch.Tensor, value_range: tuple[float, float]) -> torch.Tensor:
+    """Quantize a ``BCTHW`` chunk to contiguous ``BTHWC`` uint8 on its own device.
+
+    ``value_range`` is the interval the producer publishes, which differs per
+    checkpoint (see ``SupportsChunkedVAEDecode.chunk_value_range``). Quantizing
+    on the accelerator means the transfer that follows moves the final bytes
+    rather than float frames, and making the result contiguous there keeps the
+    copy a single flat move instead of a strided host-side gather.
+    """
+    low, high = float(value_range[0]), float(value_range[1])
+    if high <= low:
+        raise ValueError(f"value_range must be increasing, got {value_range!r}")
+    scale = 255.0 / (high - low)
+    frames = chunk.clamp(low, high).sub(low).mul(scale).round().to(torch.uint8)
+    return frames.permute(0, 2, 3, 4, 1).contiguous()
+
+
+def chunk_to_uint8_frames(chunk: torch.Tensor, value_range: tuple[float, float]) -> np.ndarray:
+    """Quantize a ``BCTHW`` chunk and block until it reaches the host.
+
+    The path a session takes when no pinned ring is available, and the one a
+    caller outside a session gets. A session on an accelerator uses
+    :class:`PinnedChunkRing` instead so the copy does not stall the producer.
+    """
+    return quantize_chunk(chunk, value_range).cpu().numpy()
+
+
+@dataclass
+class ChunkTransferStats:
+    """What the host transfer cost, for checking that it actually overlapped.
+
+    ``copy_wait_seconds`` staying near zero while ``transfers`` climbs is the
+    signal that copies completed behind the producer; it rising with them means
+    the producer is outrunning the copy stream. ``slot_wait_seconds`` rising
+    instead means the encoder is the bottleneck and backpressure has reached
+    the producer.
+    """
+
+    transfers: int = 0
+    slot_wait_seconds: float = 0.0
+    copy_wait_seconds: float = 0.0
+    peak_slots_in_use: int = 0
+    peak_pending_bytes: int = 0
+
+
+class _HostSlot:
+    """One reusable pinned host buffer.
+
+    The buffer is allocated on first use and never shrinks. ``batch_frames`` is
+    a flush threshold rather than a cap, so a later batch can be larger than
+    the first; the slot then keeps the larger buffer for the rest of the
+    request instead of reallocating per chunk.
+    """
+
+    def __init__(self, *, pinned: bool) -> None:
+        self._pinned = pinned
+        self._buffer: torch.Tensor | None = None
+        self.held_bytes = 0
+
+    def reserve(self, frames: torch.Tensor) -> torch.Tensor:
+        """Return a host view shaped like ``frames``, growing the buffer if needed."""
+        needed = frames.numel()
+        if self._buffer is None or self._buffer.numel() < needed:
+            try:
+                self._buffer = torch.empty(needed, dtype=frames.dtype, pin_memory=self._pinned)
+            except Exception:
+                # Pinning can be refused by the driver or unsupported on a
+                # platform. A pageable buffer still copies correctly, only
+                # synchronously, so degrade rather than fail the request.
+                logger.warning("Pinned host buffer unavailable; chunk copies fall back to pageable memory")
+                self._pinned = False
+                self._buffer = torch.empty(needed, dtype=frames.dtype)
+        self.held_bytes = needed * frames.element_size()
+        return self._buffer[:needed].view(frames.shape)
+
+
+class ChunkLease:
+    """One chunk in flight: a host slot, its copy event, and its readers.
+
+    The slot returns to the ring only after the last reader has finished with
+    it. Being handed to an encoder is not enough -- the encoder's queue holds a
+    view of this buffer until its muxing thread reads it -- so release is
+    driven by the encoder rather than by dequeuing.
+    """
+
+    def __init__(
+        self,
+        *,
+        ring: PinnedChunkRing,
+        slot: _HostSlot,
+        view: np.ndarray,
+        source: torch.Tensor,
+        landed: torch.Event | None,
+        readers: int,
+    ) -> None:
+        self._ring = ring
+        self._slot = slot
+        self._view = view
+        self._source: torch.Tensor | None = source
+        self._landed = landed
+        self._readers = readers
+        self._lock = threading.Lock()
+
+    def ready(self) -> bool:
+        """Whether the copy has landed, without blocking on it."""
+        return self._landed is None or self._landed.query()
+
+    def wait(self) -> np.ndarray:
+        """Block until the copy has landed, then hand over the host frames."""
+        if self._landed is not None:
+            started = time.perf_counter()
+            self._landed.synchronize()
+            self._ring.stats.copy_wait_seconds += time.perf_counter() - started
+            self._landed = None
+        # The source stays referenced until here so the allocator cannot hand
+        # its device memory to the next chunk while the copy is still reading.
+        self._source = None
+        return self._view
+
+    def release(self) -> None:
+        """Report one reader done; the last one returns the slot to the ring."""
+        with self._lock:
+            if self._readers <= 0:
+                return
+            self._readers -= 1
+            if self._readers > 0:
+                return
+        self._ring.reclaim(self._slot)
+
+    def discard(self) -> None:
+        """Drop an unread chunk during teardown, keeping the copy's memory alive.
+
+        The copy may still be writing into the slot and reading from the source
+        tensor, so this waits for it rather than letting either be reused
+        underneath an in-flight transfer.
+        """
+        if self._landed is not None:
+            self._landed.synchronize()
+            self._landed = None
+        self._source = None
+        with self._lock:
+            remaining, self._readers = self._readers, 0
+        if remaining > 0:
+            self._ring.reclaim(self._slot)
+
+
+class PinnedChunkRing:
+    """Fixed-depth pool of reusable host slots for chunk transfers.
+
+    A slot walks ``free -> copying -> ready -> encoding -> free`` and holds
+    exactly one chunk for that whole trip, so pending transfer bytes are
+    bounded by the depth times the largest chunk of the request. Waiting for a
+    free slot is where encoder backpressure reaches the producer.
+    """
+
+    def __init__(self, *, depth: int, device: torch.device) -> None:
+        if depth <= 0:
+            raise ValueError("transfer ring depth must be positive")
+        self.depth = depth
+        self.stats = ChunkTransferStats()
+        self._on_device = device.type != "cpu"
+        self._stream = _copy_stream(device) if self._on_device else None
+        self._lock = threading.Lock()
+        self._slot_freed = threading.Condition(self._lock)
+        self._free = [_HostSlot(pinned=self._on_device) for _ in range(depth)]
+        self._pending_bytes = 0
+        self._failure: BaseException | None = None
+
+    @property
+    def slots_in_use(self) -> int:
+        """Slots currently holding a chunk, whether copying, ready or encoding."""
+        with self._lock:
+            return self.depth - len(self._free)
+
+    def transfer(self, frames: torch.Tensor, *, readers: int) -> ChunkLease:
+        """Start one non-blocking copy of ``frames`` into a free slot."""
+        if readers <= 0:
+            raise ValueError("a transferred chunk needs at least one reader")
+        slot = self._acquire()
+        try:
+            host = slot.reserve(frames)
+            with self._lock:
+                self._pending_bytes += slot.held_bytes
+                self.stats.transfers += 1
+                self.stats.peak_pending_bytes = max(self.stats.peak_pending_bytes, self._pending_bytes)
+            landed = self._issue_copy(host, frames)
+        except BaseException:
+            self.reclaim(slot)
+            raise
+        return ChunkLease(ring=self, slot=slot, view=host.numpy(), source=frames, landed=landed, readers=readers)
+
+    def abort(self, error: BaseException | None = None) -> None:
+        """Fail every present and future wait for a slot."""
+        with self._slot_freed:
+            if self._failure is None:
+                self._failure = error or RuntimeError("chunk transfer ring aborted")
+            self._slot_freed.notify_all()
+
+    def reclaim(self, slot: _HostSlot) -> None:
+        """Return a slot whose last reader is done."""
+        with self._slot_freed:
+            self._pending_bytes -= slot.held_bytes
+            slot.held_bytes = 0
+            self._free.append(slot)
+            self._slot_freed.notify()
+
+    def _issue_copy(self, host: torch.Tensor, frames: torch.Tensor) -> torch.Event | None:
+        if self._stream is None:
+            host.copy_(frames)
+            return None
+        # The chunk was quantized on the compute stream, so the copy stream has
+        # to wait for that work before reading it.
+        source_ready = torch.Event()
+        source_ready.record()
+        self._stream.wait_event(source_ready)
+        with self._stream:
+            host.copy_(frames, non_blocking=True)
+            landed = torch.Event()
+            landed.record(self._stream)
+        return landed
+
+    def _acquire(self) -> _HostSlot:
+        started = time.perf_counter()
+        with self._slot_freed:
+            while not self._free and self._failure is None:
+                # ponytail: no request deadline yet, only an abort escape. A
+                # unified deadline across producer, slot, queue and encoder
+                # waits is RFC #6872 R4.
+                self._slot_freed.wait(timeout=_SLOT_POLL_SECONDS)
+            if self._failure is not None:
+                raise self._failure
+            slot = self._free.pop()
+            in_use = self.depth - len(self._free)
+            self.stats.peak_slots_in_use = max(self.stats.peak_slots_in_use, in_use)
+        self.stats.slot_wait_seconds += time.perf_counter() - started
+        return slot
+
+
+class ChunkedVideoMP4Session:
+    """Encode committed video chunks into one progressive MP4 per batch entry.
+
+    Push finished ``BCTHW`` chunks as the producer commits them; each batch
+    entry gets its own bounded encoder, so host transfer and H.264 encoding
+    overlap whatever the producer is still decoding.
+
+    ``audio_waveforms`` holds one waveform per batch entry (``None`` for a
+    silent entry), so a caller with several outputs per prompt repeats a
+    request's waveform across its entries. ``batch_frames`` coalesces transfers
+    for producers that publish finer than a transfer is worth; ``crop`` trims
+    the decoder's padding to the requested output size. ``transfer_slots`` sets
+    how many chunks may be in flight to the host at once.
+    """
+
+    def __init__(
+        self,
+        *,
+        value_range: tuple[float, float],
+        fps: float,
+        audio_waveforms: list[np.ndarray | None] | None = None,
+        audio_sample_rate: int | None = None,
+        batch_frames: int = 1,
+        max_pending: int = 2,
+        video_codec_options: dict[str, str] | None = None,
+        crop: tuple[int, int] | None = None,
+        transfer_slots: int = 2,
+    ) -> None:
+        if batch_frames <= 0:
+            raise ValueError("batch_frames must be positive")
+        self._value_range = value_range
+        self._fps = fps
+        self._audio_waveforms = audio_waveforms
+        self._audio_sample_rate = audio_sample_rate
+        self._batch_frames = batch_frames
+        self._max_pending = max_pending
+        self._video_codec_options = video_codec_options
+        self._crop = crop
+        self._transfer_slots = transfer_slots
+        self._encoders: list[ChunkedMP4Encoder] = []
+        self._pending: list[torch.Tensor] = []
+        self._pending_frames = 0
+        self._ring: PinnedChunkRing | None = None
+        self._ring_resolved = False
+        self._inflight: deque[ChunkLease] = deque()
+
+    def push(self, chunk: torch.Tensor) -> None:
+        """Queue one committed ``BCTHW`` chunk."""
+        if self._crop is not None:
+            height, width = self._crop
+            chunk = chunk[..., :height, :width]
+        self._pending.append(chunk)
+        self._pending_frames += int(chunk.shape[2])
+        if self._pending_frames >= self._batch_frames:
+            self._flush()
+
+    def finish(self) -> list[bytes]:
+        """Flush what is pending and return one MP4 per batch entry."""
+        self._flush()
+        while self._inflight:
+            self._feed_lease(self._inflight.popleft())
+        return [encoder.finish() for encoder in self._encoders]
+
+    def abort(self) -> None:
+        if self._ring is not None:
+            self._ring.abort()
+        while self._inflight:
+            self._inflight.popleft().discard()
+        for encoder in self._encoders:
+            encoder.abort()
+
+    def transfer_stats(self) -> ChunkTransferStats | None:
+        """Per-request transfer accounting, or ``None`` if no ring was used."""
+        return None if self._ring is None else self._ring.stats
+
+    @property
+    def ring(self) -> PinnedChunkRing | None:
+        """The transfer ring this session settled on, once a chunk has flushed."""
+        return self._ring
+
+    def _flush(self) -> None:
+        if not self._pending:
+            return
+        frames = quantize_chunk(torch.cat(self._pending, dim=2), self._value_range)
+        self._pending.clear()
+        self._pending_frames = 0
+        self._ensure_encoders(frames)
+        ring = self._resolve_ring(frames.device)
+        if ring is None:
+            self._feed(frames.cpu().numpy(), release=None)
+            return
+        # Free a slot before asking for one, so the ring's own wait is only
+        # ever for the encoder to catch up rather than for this loop.
+        while len(self._inflight) >= ring.depth:
+            self._feed_lease(self._inflight.popleft())
+        self._inflight.append(ring.transfer(frames, readers=len(self._encoders)))
+        while self._inflight and self._inflight[0].ready():
+            self._feed_lease(self._inflight.popleft())
+
+    def _feed_lease(self, lease: ChunkLease) -> None:
+        try:
+            self._feed(lease.wait(), release=lease.release)
+        except BaseException:
+            lease.discard()
+            raise
+
+    def _feed(self, frames: np.ndarray, *, release: Callable[[], None] | None) -> None:
+        for index, encoder in enumerate(self._encoders):
+            try:
+                encoder.push(frames[index], on_consumed=release)
+            except BaseException:
+                # push() owns the callback for the entry it was given, so only
+                # the encoders this chunk never reached still hold a reader.
+                for _ in range(len(self._encoders) - index - 1):
+                    if release is not None:
+                        release()
+                raise
+
+    def _ensure_encoders(self, frames: torch.Tensor) -> None:
+        if self._encoders:
+            return
+        self._encoders = [
+            ChunkedMP4Encoder(
+                width=int(frames.shape[3]),
+                height=int(frames.shape[2]),
+                fps=self._fps,
+                audio_waveform=self._waveform_for(index, int(frames.shape[0])),
+                audio_sample_rate=self._audio_sample_rate,
+                max_pending=self._max_pending,
+                video_codec_options=self._video_codec_options,
+            )
+            for index in range(int(frames.shape[0]))
+        ]
+
+    def _resolve_ring(self, device: torch.device) -> PinnedChunkRing | None:
+        if self._ring_resolved:
+            return self._ring
+        self._ring_resolved = True
+        if self._transfer_slots <= 0:
+            return None
+        try:
+            self._ring = PinnedChunkRing(depth=self._transfer_slots, device=device)
+        except Exception:
+            logger.warning(
+                "Pinned chunk transfers unavailable on %s; falling back to blocking copies",
+                device,
+                exc_info=True,
+            )
+        return self._ring
+
+    def _waveform_for(self, index: int, batch_size: int) -> np.ndarray | None:
+        if self._audio_waveforms is None:
+            return None
+        if len(self._audio_waveforms) != batch_size:
+            raise ValueError(
+                f"expected one audio waveform per batch entry, got "
+                f"{len(self._audio_waveforms)} for {batch_size} entries"
+            )
+        return self._audio_waveforms[index]
+
+
+def decode_to_mp4(vae: Any, z: torch.Tensor, **session_kwargs: Any) -> list[bytes]:
+    """Decode ``z`` straight into one progressive MP4 per batch entry.
+
+    Drives a VAE that declares :class:`SupportsChunkedVAEDecode`, so host
+    transfer and encoding overlap the remaining decode and the full video is
+    never materialized. Ranks that own no decode output receive no chunks and
+    get an empty list, matching the empty tensor the full-decode path returns
+    there.
+    """
+    if not supports_chunked_vae_decode(vae):
+        raise TypeError(f"{type(vae).__name__} does not expose the chunked VAE decode capability")
+
+    session = ChunkedVideoMP4Session(value_range=vae.chunk_value_range, **session_kwargs)
+    try:
+        vae.decode_with_chunks(z, on_chunk=session.push)
+        videos = session.finish()
+    except BaseException:
+        session.abort()
+        raise
+    stats = session.transfer_stats()
+    if stats is not None:
+        logger.debug(
+            "Chunked MP4 transfers=%d slot_wait=%.3fs copy_wait=%.3fs peak_slots=%d peak_bytes=%d",
+            stats.transfers,
+            stats.slot_wait_seconds,
+            stats.copy_wait_seconds,
+            stats.peak_slots_in_use,
+            stats.peak_pending_bytes,
+        )
+    return videos
diff --git a/vllm_omni/diffusion/utils/media_utils.py b/vllm_omni/diffusion/utils/media_utils.py
index 99d20a0af..a53359cc8 100644
--- a/vllm_omni/diffusion/utils/media_utils.py
+++ b/vllm_omni/diffusion/utils/media_utils.py
@@ -7,16 +7,36 @@ from __future__ import annotations
 import io
 import queue
 import threading
-from collections.abc import Iterable, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from fractions import Fraction
-from typing import Any, cast
+from typing import Any, NamedTuple, cast
 
 import av
 import numpy as np
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
 
 _CHUNKED_MP4_DONE = object()
 
 
+class _QueuedChunk(NamedTuple):
+    """One queued chunk plus the callback that returns its buffer to its owner."""
+
+    frames: np.ndarray
+    on_consumed: Callable[[], None] | None
+
+
+def _release_chunk(on_consumed: Callable[[], None] | None) -> None:
+    """Hand a chunk's buffer back, never letting the callback wedge the worker."""
+    if on_consumed is None:
+        return
+    try:
+        on_consumed()
+    except BaseException:  # noqa: BLE001
+        logger.exception("Chunked MP4 encoder failed to release a consumed chunk")
+
+
 def normalize_preencode_batch_frames(value: Any) -> int:
     """Validate the request's MP4 transfer/encoding batch threshold."""
     if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
@@ -51,8 +71,11 @@ def _validate_video_chunk(chunk: np.ndarray, *, width: int, height: int) -> None
 class ChunkedMP4Encoder:
     """Encode temporal video chunks while the producer is still decoding.
 
-    A bounded queue and one muxing worker provide ordered backpressure while
-    keeping host memory bounded by ``max_pending`` chunks. Chunks use the same
+    A bounded queue and one muxing worker provide ordered backpressure. What
+    that bounds is pending raw-frame memory: at most ``max_pending`` chunks wait
+    to be encoded, so the bound is in chunks rather than bytes and a taller
+    frame or a longer chunk raises it. The muxed container is not bounded -- it
+    accumulates in memory and grows with output duration. Chunks use the same
     ``(T, H, W, 3)`` uint8 contract as :func:`mux_video_audio_bytes`.
     """
 
@@ -85,9 +108,10 @@ class ChunkedMP4Encoder:
         self._state_lock = threading.Lock()
 
         def run() -> None:
+            frames = self._frames()
             try:
                 self._result = mux_av_video_audio_bytes(
-                    self._frames(),
+                    frames,
                     width=self.width,
                     height=self.height,
                     audio_waveform=audio_waveform,
@@ -100,6 +124,11 @@ class ChunkedMP4Encoder:
                 )
             except BaseException as exc:
                 self._error = exc
+                # Closing is what runs the generator's cleanup and releases the
+                # chunk it was mid-way through. Waiting for collection would
+                # never get there: the traceback just stored on this encoder
+                # keeps the abandoned generator alive for the process's life.
+                frames.close()
                 self._drain_until_done()
 
         self._thread = threading.Thread(target=run, name="chunked-mp4", daemon=True)
@@ -107,19 +136,29 @@ class ChunkedMP4Encoder:
 
     def _drain_until_done(self) -> None:
         # A flush/mux failure can occur after _frames consumed the sentinel.
-        if not self._input_done:
-            while self._queue.get() is not _CHUNKED_MP4_DONE:
-                pass
+        if self._input_done:
+            return
+        while True:
+            entry = self._queue.get()
+            if entry is _CHUNKED_MP4_DONE:
+                return
+            _release_chunk(cast(_QueuedChunk, entry).on_consumed)
 
     def _frames(self):
         while True:
-            chunk = self._queue.get()
-            if chunk is _CHUNKED_MP4_DONE:
+            entry = self._queue.get()
+            if entry is _CHUNKED_MP4_DONE:
                 self._input_done = True
                 return
-            assert isinstance(chunk, np.ndarray)
-            for frame_data in chunk:
-                yield av.VideoFrame.from_ndarray(frame_data, format="rgb24")
+            assert isinstance(entry, _QueuedChunk)
+            try:
+                for frame_data in entry.frames:
+                    yield av.VideoFrame.from_ndarray(frame_data, format="rgb24")
+            finally:
+                # Also runs when the muxer raises part-way through this chunk
+                # and abandons the generator, so a lent buffer is never
+                # stranded in the encoder.
+                _release_chunk(entry.on_consumed)
 
     def _validate_chunk(self, chunk: np.ndarray) -> None:
         _validate_video_chunk(chunk, width=self.width, height=self.height)
@@ -130,11 +169,22 @@ class ChunkedMP4Encoder:
         if self._closed:
             raise RuntimeError("ChunkedMP4Encoder is already closed")
 
-    def push(self, chunk: np.ndarray) -> None:
-        """Queue a chunk; asynchronous failures surface here or at finish()."""
-        self._validate_chunk(chunk)
-        self._raise_if_failed()
-        self._queue.put(chunk)
+    def push(self, chunk: np.ndarray, *, on_consumed: Callable[[], None] | None = None) -> None:
+        """Queue a chunk; asynchronous failures surface here or at finish().
+
+        ``on_consumed`` fires exactly once after this encoder has read
+        ``chunk``, including when the chunk is discarded by an abort or by a
+        failed encode. Ownership transfers on call: whether this returns or
+        raises, the callback is this encoder's responsibility, so a caller
+        lending a pooled host buffer never compensates on the error path.
+        """
+        try:
+            self._validate_chunk(chunk)
+            self._raise_if_failed()
+        except BaseException:
+            _release_chunk(on_consumed)
+            raise
+        self._queue.put(_QueuedChunk(chunk, on_consumed))
         self._raise_if_failed()
 
     def _send_done(self) -> None:
@@ -165,9 +215,11 @@ class ChunkedMP4Encoder:
                 self._aborted = True
                 while True:
                     try:
-                        self._queue.get_nowait()
+                        entry = self._queue.get_nowait()
                     except queue.Empty:
                         break
+                    if entry is not _CHUNKED_MP4_DONE:
+                        _release_chunk(cast(_QueuedChunk, entry).on_consumed)
                 self._send_done()
         self._thread.join()
 
diff --git a/vllm_omni/diffusion/vllm_config.py b/vllm_omni/diffusion/vllm_config.py
index c90671d60..12ae1bdb9 100644
--- a/vllm_omni/diffusion/vllm_config.py
+++ b/vllm_omni/diffusion/vllm_config.py
@@ -151,6 +151,9 @@ class _DiffusionVllmModelConfig:
     def get_head_size(self) -> int:
         return self._require_attention_geometry()[2]
 
+    def get_total_num_kv_heads(self) -> int:
+        return self.hf_text_config.num_key_value_heads
+
     @property
     def is_diffusion(self) -> bool:
         # This config is also installed as the current VllmConfig for the
@@ -224,7 +227,10 @@ def configure_diffusion_vllm_config(vllm_config: VllmConfig, od_config: OmniDiff
         vllm_config.cache_config.kv_cache_memory_bytes = getattr(od_config, "kv_cache_memory_bytes", None)
         # Prefix hashes/publication are intentionally deferred to the next PR.
         vllm_config.cache_config.enable_prefix_caching = False
-        vllm_config.scheduler_config.max_num_seqs = int(od_config.max_num_seqs)
+        max_rows_per_request = getattr(od_config, "diffusion_kv_max_rows_per_request", None)
+        if type(max_rows_per_request) is not int or max_rows_per_request <= 0:
+            raise ValueError("paged_scheduler requires a positive diffusion_kv_max_rows_per_request")
+        vllm_config.scheduler_config.max_num_seqs = int(od_config.max_num_seqs) * max_rows_per_request
         max_num_batched_tokens = getattr(od_config, "max_num_batched_tokens", None)
         if max_num_batched_tokens is not None:
             vllm_config.scheduler_config.max_num_batched_tokens = int(max_num_batched_tokens)
diff --git a/vllm_omni/diffusion/worker/diffusion_model_runner.py b/vllm_omni/diffusion/worker/diffusion_model_runner.py
index 5fb124a18..d4d457bdc 100644
--- a/vllm_omni/diffusion/worker/diffusion_model_runner.py
+++ b/vllm_omni/diffusion/worker/diffusion_model_runner.py
@@ -43,6 +43,7 @@ from vllm_omni.diffusion.diffusion_kv.paged_attention_adapter import (
 from vllm_omni.diffusion.distributed.parallel_state import get_classifier_free_guidance_rank
 from vllm_omni.diffusion.forward_context import set_forward_context
 from vllm_omni.diffusion.interaction.coordinator import InteractionCoordinator
+from vllm_omni.diffusion.interaction.types import InteractionPayload
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.models.interface import (
     SupportsInteractionApply,
@@ -193,14 +194,20 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         self.state_cache: dict[str, StepRequestState] = {}
 
         # Initialize KV cache manager for connector management.
-        self.kv_transfer_manager = OmniKVTransferManager.from_od_config(od_config)
+        self.kv_transfer_manager = (
+            OmniKVTransferManager.from_od_config(od_config)
+            if getattr(od_config, "kv_transfer_config", None) is None
+            else None
+        )
+        self._kv_connector = None
 
         # Prefetch covers TP / SP / CFG-Parallel / HSDP.  Disabled when a CFG
         # companion KV collector is set (that KV is not backgrounded).
         has_cfg_companion_kv = getattr(od_config, "cfg_kv_collect_func", None) is not None
 
         self._kv_prefetch_enabled = (
-            bool(self.kv_transfer_manager.config.enable_kv_async_prefetch)
+            self.kv_transfer_manager is not None
+            and bool(self.kv_transfer_manager.config.enable_kv_async_prefetch)
             and not has_cfg_companion_kv
             and self.kv_transfer_manager.config.need_recv_cache
         )
@@ -471,6 +478,16 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
 
         self.diffusion_kv_backend.initialize_kv_cache(kv_cache_config)
         self.kv_cache_config = self.diffusion_kv_backend.kv_cache_config
+        if getattr(self.od_config, "kv_transfer_config", None) is not None:
+            from vllm.v1.worker.gpu.kv_connector import ActiveKVConnector
+
+            self._kv_connector = ActiveKVConnector(self.vllm_config, self.diffusion_kv_backend.kv_caches_by_layer)
+
+    def prepare_kv_for_forward(self, scheduler_output: DiffusionSchedulerOutput):
+        from vllm_omni.diffusion.diffusion_kv.kv_connector import wait_for_kv_load
+
+        timeout = self.od_config.kv_transfer_config.kv_connector_extra_config.get("transfer_timeout", 60.0)
+        return wait_for_kv_load(self._kv_connector, scheduler_output, timeout)
 
     def install_diffusion_kv_metadata(self, metadata: DiffusionKVMetadata) -> bool:
         return self.diffusion_kv_backend.install_diffusion_kv_metadata(metadata)
@@ -483,7 +500,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
     ) -> int:
         return self.diffusion_kv_backend.get_diffusion_kv_row(request_id, sequence_id, context_id)
 
-    def remove_diffusion_kv_requests(self, request_ids: list[str]) -> int:
+    def remove_diffusion_kv_requests(self, request_ids: list[str | tuple[str, int]]) -> int:
         return self.diffusion_kv_backend.remove_diffusion_kv_requests(request_ids)
 
     def refresh_diffusion_kv_block_table_layout(self) -> None:
@@ -520,8 +537,9 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                     DiffusionPagedAttentionRow(
                         request_id=request_metadata.request_id,
                         sequence_id=sequence.sequence_id,
-                        query_len=sequence.seq_len,
+                        query_len=sequence.seq_len - sequence.num_computed_tokens,
                         seq_len=sequence.seq_len,
+                        kv_start_pos=sequence.num_computed_tokens,
                     )
                 )
                 denoise_rows.append(
@@ -606,6 +624,9 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         kv_prefetch_job: KVPrefetchJob | None = None,
         use_prefetch: bool = False,
     ) -> None:
+        if self.kv_transfer_manager is None:
+            self._initialize_generator(req.sampling_params)
+            return
         # Receive AR KV. Single-request execution can use the prefetch path:
         # consume prior-forward payload, sync-fallback on miss; request-batch
         # execution keeps the synchronous per-request receive path.
@@ -770,6 +791,8 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                         "Diffusion KV metadata count must match the request batch: "
                         f"metadata={len(diffusion_kv_metadata)}, requests={len(reqs)}"
                     )
+                for req, metadata in zip(reqs, diffusion_kv_metadata, strict=True):
+                    req.kv_computed_tokens = tuple(seq.num_computed_tokens for seq in metadata.sequences)
                 paged_metadata = self._build_paged_attention_metadata(diffusion_kv_metadata)
                 paged_kv_runtime, paged_kv_context = self.diffusion_kv_backend.activate_paged_attention_metadata(
                     paged_metadata
@@ -1018,13 +1041,18 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                     kv_sender_info=sched_new_req.req.kv_sender_info,
                     prepared_layout=getattr(sched_new_req.req, "prepared_layout", None),
                 )
+                if sched_new_req.diffusion_kv_metadata is not None:
+                    new_state.extra["kv_computed_tokens"] = tuple(
+                        seq.num_computed_tokens for seq in sched_new_req.diffusion_kv_metadata.sequences
+                    )
                 state_req = copy.copy(sched_new_req.req)
                 state_req.sampling_params = new_state.sampling
-                self.kv_transfer_manager.receive_multi_kv_cache_distributed(
-                    state_req,
-                    cfg_kv_collect_func=getattr(self.od_config, "cfg_kv_collect_func", None),
-                    target_device=self._target_device,
-                )
+                if self.kv_transfer_manager is not None:
+                    self.kv_transfer_manager.receive_multi_kv_cache_distributed(
+                        state_req,
+                        cfg_kv_collect_func=getattr(self.od_config, "cfg_kv_collect_func", None),
+                        target_device=self._target_device,
+                    )
                 self.state_cache[request_id] = new_state
                 resolved.append(new_state)
 
@@ -1053,30 +1081,13 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         error_outputs: list[RunnerOutput] = []
         for state in states:
             if state.request_id in new_request_ids:
-                # Everything that runs before ``_dit_any_rank_failed`` must be
-                # inside the try: an exception in ``_initialize_generator`` or
+                # Everything that requires rank-synchronization must be called
+                # inside a try, record the exception and handle with `_dit_any_rank_failed`.
+                # Reason (example): An exception in ``_initialize_generator`` or
                 # ``clear_pipeline_stage_durations`` on one rank would skip the
                 # all-reduce here while every peer proceeds into it, and the
                 # peers then hang on the NCCL collective until timeout.
-                per_req_exc: BaseException | None = None
-                try:
-                    self._initialize_generator(state.sampling)
-                    clear_pipeline_stage_durations(pipeline)
-                    # encode
-                    pipeline.prepare_encode(state)
-                    merge_stage_durations(
-                        state,
-                        consume_pipeline_stage_durations(pipeline),
-                    )
-                except Exception as exc:
-                    per_req_exc = exc
-                # Pipelines that do rank-0-only work (e.g. MiniMax H3
-                # reference-video prep) must broadcast per-request failures
-                # internally so downstream collectives stay in step; even so,
-                # cross-check that every DiT rank agrees so a rank-local error
-                # (or a future pipeline that omits the guard) does not leave
-                # the process group half-way through a new request.
-                if _dit_any_rank_failed(per_req_exc is not None):
+                def _abort_prep_failure(per_req_exc: BaseException | None) -> None:
                     self.state_cache.pop(state.request_id, None)
                     if per_req_exc is None:
                         per_req_exc = RuntimeError(
@@ -1096,6 +1107,41 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                             result=DiffusionOutput.from_exception(per_req_exc),
                         )
                     )
+
+                per_req_exc: BaseException | None = None
+                try:
+                    self._initialize_generator(state.sampling)
+                    clear_pipeline_stage_durations(pipeline)
+                    pipeline.prepare_encode(state)
+                except Exception as exc:
+                    per_req_exc = exc
+                # Pipelines that do rank-0-only work (e.g. MiniMax H3
+                # reference-video prep) must broadcast per-request failures
+                # internally so downstream collectives stay in step; even so,
+                # cross-check that every DiT rank agrees so a rank-local error
+                # (or a future pipeline that omits the guard) does not leave
+                # the process group half-way through a new request.
+                if _dit_any_rank_failed(per_req_exc is not None):
+                    _abort_prep_failure(per_req_exc)
+                    continue
+                # If the pipeline supports interaction, the interaction session initialization also needs to call
+                # synchronized_monotonic_time(). Wrap in another try-block to not block on prepare_encode failures.
+                try:
+                    if supports_interaction_apply(pipeline) and state.chunk_index == 0:
+                        pipe = cast(SupportsInteractionApply, pipeline)
+                        assert self._interaction_coordinator is not None, "Model not loaded. Call load_model() first."
+                        state.interaction_chunk_metadata = self._interaction_coordinator.maybe_prepare_initial_session(
+                            state, pipe
+                        )
+                        pipe.prepare_next_chunk(state)
+                    merge_stage_durations(
+                        state,
+                        consume_pipeline_stage_durations(pipeline),
+                    )
+                except Exception as exc:
+                    per_req_exc = exc
+                if _dit_any_rank_failed(per_req_exc is not None):
+                    _abort_prep_failure(per_req_exc)
                     continue
             prepared_states.append(state)
 
@@ -1404,47 +1450,33 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         interaction: OmniInteractionPrompt,
     ) -> None:
         """Route a midway interaction through the pipeline interaction coordinator."""
-        assert self.pipeline is not None, "Model not loaded. Call load_model() first."
+        assert self.pipeline is not None and self._interaction_coordinator is not None, (
+            "Model not loaded. Call load_model() first."
+        )
         if not self.od_config.streaming_output:
             raise ValueError("submit_interaction requires streaming_output=True")
         if not self._supports_step_mode():
             raise ValueError("submit_interaction requires step execution support")
 
-        coordinator = self._interaction_coordinator
-        if coordinator is None:
-            coordinator = InteractionCoordinator.build(self.pipeline, self.od_config)
-            self._interaction_coordinator = coordinator
-            if hasattr(self.pipeline, "_interaction_coordinator"):
-                self.pipeline._interaction_coordinator = coordinator
-
-        event = interaction.get("event")
-        has_mm = isinstance(event, dict) and "multi_modal_data" in event
-        has_prompt = isinstance(event, dict) and "prompt" in event and event.get("prompt") is not None
-
-        # Prompt-only interactions in this release; multi_modal_data lands with camera support.
-        if not isinstance(event, dict) or has_mm or not has_prompt:
-            raise NotImplementedError(
-                "Only text-only prompt update interactions with 'event.prompt' and optional "
-                "'transition_chunks' are supported in this release"
-            )
-        if not coordinator.has_modality("prompt"):
-            raise ValueError(f"prompt_update is not supported by pipeline {self.od_config.model_class_name!r}")
-
         state = self.state_cache.get(request_id)
         if state is None:
             raise ValueError(f"No active request state for interaction: {request_id!r}")
 
-        event_id = interaction.get("event_id")
-        if not isinstance(event_id, str) or not event_id:
-            raise ValueError("event_id must be non-empty")
-        prompt = event["prompt"]
-        if not isinstance(prompt, str) or not prompt:
-            raise ValueError("prompt must be non-empty")
-        coordinator.enqueue(
+        event = interaction["event"]
+        parts: list[tuple[str, InteractionPayload]] = []
+        prompt = event.get("prompt")
+        if prompt is not None:
+            parts.append(("prompt", {"prompt": prompt}))
+        multi_modal_data = event.get("multi_modal_data")
+        if multi_modal_data:
+            parts.extend(
+                (str(modality), cast(InteractionPayload, payload)) for modality, payload in multi_modal_data.items()
+            )
+
+        self._interaction_coordinator.enqueue_parts(
             state,
-            modality="prompt",
-            event_id=event_id,
+            parts=parts,
+            event_id=interaction["event_id"],
             received_at=time.monotonic(),
-            payload={"prompt": prompt},
             transition_chunks=interaction.get("transition_chunks"),
         )
diff --git a/vllm_omni/diffusion/worker/diffusion_worker.py b/vllm_omni/diffusion/worker/diffusion_worker.py
index b9506f102..4eadf33db 100644
--- a/vllm_omni/diffusion/worker/diffusion_worker.py
+++ b/vllm_omni/diffusion/worker/diffusion_worker.py
@@ -59,6 +59,7 @@ from vllm_omni.diffusion.distributed.parallel_state import (
     get_hsdp_replicate_group,
     get_pp_group,
     get_sp_group,
+    get_world_group,
     init_distributed_environment,
     initialize_model_parallel,
     model_parallel_is_initialized,
@@ -116,7 +117,11 @@ def _all_gather_rank_values(value: Any) -> list[Any]:
     if not dist.is_available() or not dist.is_initialized():
         return [value]
     values: list[Any] = [None] * dist.get_world_size()
-    dist.all_gather_object(values, value)
+    # Object collectives are control-plane traffic. Using the default NCCL
+    # group serializes them through temporary CUDA tensors, adding pointless
+    # H2D/DtoH copies to every rank-wide status check. Reuse the world
+    # coordinator's Gloo group, as vLLM does for CPU metadata collectives.
+    dist.all_gather_object(values, value, group=get_world_group().cpu_group)
     return values
 
 
@@ -446,15 +451,13 @@ class DiffusionWorker:
                 raise RuntimeError("Diffusion KV memory snapshot was not captured before model loading")
             override = self.vllm_config.cache_config.kv_cache_memory_bytes
             if override:
-                # Match native vLLM: an explicit cache budget skips automatic
-                # capacity derivation, but still runs the maximum-shape model
-                # request so lazy kernels and communication buffers initialize.
-                self.model_runner.profile_run(profile_requests)
+                # Post-allocation warmup avoids retaining a second activation arena.
                 logger.info(
                     "Worker %d: Initial free memory %s GiB, reserved %s GiB memory for "
                     "Diffusion KV Cache as specified by kv_cache_memory_bytes config and "
                     "skipped automatic memory profiling. This does not respect the "
-                    "gpu_memory_utilization config. A profile warmup was still executed.",
+                    "gpu_memory_utilization config. Model kernels will be initialized by "
+                    "the post-allocation startup warmup.",
                     self.rank,
                     format_gib(self.init_snapshot.free_memory),
                     format_gib(int(override)),
@@ -467,6 +470,8 @@ class DiffusionWorker:
             ) as profile_result:
                 self.model_runner.profile_run(profile_requests)
 
+            current_omni_platform.empty_cache()
+
             available_memory = self.requested_memory - profile_result.non_kv_cache_memory
             if available_memory <= 0:
                 raise RuntimeError(
@@ -534,12 +539,18 @@ class DiffusionWorker:
         with self._maybe_get_memory_pool_context("kv_cache"):
             self.model_runner.set_kv_cache_config(kv_cache_config)
 
-    def remove_diffusion_kv_requests(self, request_ids: list[str]) -> int:
+    def remove_diffusion_kv_requests(self, request_ids: list[str | tuple[str, int]]) -> int:
         """Clear Worker-local rows without freeing Scheduler-owned blocks."""
 
         assert self.model_runner is not None, "Model runner not initialized"
         return self.model_runner.remove_diffusion_kv_requests(request_ids)
 
+    def prepare_kv_for_forward(self, scheduler_output: DiffusionSchedulerOutput):
+        return _run_and_gather_rank_values(
+            "Diffusion KV receive",
+            lambda: self.model_runner.prepare_kv_for_forward(scheduler_output),
+        )
+
     def init_lora_manager(self) -> None:
         """Initialize the LoRA manager for this worker."""
         pipeline = self.model_runner.pipeline
@@ -790,6 +801,15 @@ class DiffusionWorker:
         Args:
             level: Sleep level. Level 1 offloads weights, level 2 also saves buffers.
         """
+        # The config validator rejects sleep for the native paged path. Keep
+        # this worker-side guard precise as well: test doubles and legacy
+        # configs may expose arbitrary attributes through Mock/getattr.
+        if (
+            getattr(self.od_config, "diffusion_kv_mode", DiffusionKVCacheMode.DENSE_LEGACY)
+            is DiffusionKVCacheMode.PAGED_SCHEDULER
+            and getattr(self.od_config, "kv_transfer_config", None) is not None
+        ):
+            raise ValueError("Cannot sleep while native KV connector memory is registered")
         CuMemAllocator = _get_cumem_allocator_class()
         allocator = CuMemAllocator.get_instance()
 
@@ -1254,7 +1274,11 @@ class WorkerProc:
 
         world_size = torch.distributed.get_world_size()
         statuses: list[dict[str, Any] | None] = [None] * world_size
-        torch.distributed.all_gather_object(statuses, status)
+        torch.distributed.all_gather_object(
+            statuses,
+            status,
+            group=get_world_group().cpu_group,
+        )
         missing_ranks = [rank for rank, rank_status in enumerate(statuses) if rank_status is None]
         if missing_ranks:
             logger.warning("RPC rank status gather returned missing entries for ranks: %s", missing_ranks)
@@ -1568,31 +1592,31 @@ class WorkerWrapperBase:
             gpu_id: GPU device ID
             od_config: OmniDiffusionConfig configuration
             worker_extension_cls: Optional qualified name of worker extension class
-            custom_pipeline_args: Optional arguments for custom pipeline initialization
+            custom_pipeline_args: Optional arguments passed to native pipelines.
+                A ``pipeline_class`` entry triggers custom pipeline initialization.
         """
         self.gpu_id = gpu_id
         self.od_config = od_config
         self.base_worker_class = base_worker_class
         self.worker_extension_cls = worker_extension_cls
         self.custom_pipeline_args = custom_pipeline_args
+        self.uses_custom_pipeline = bool(custom_pipeline_args and "pipeline_class" in custom_pipeline_args)
 
         # Prepare worker class with extension support
         worker_class = self._prepare_worker_class()
 
         # Create the actual worker instance
-        # When custom_pipeline_args is provided, skip initial model loading
-        # since re_init_pipeline will handle it. This avoids allocating memory
-        # through CuMemAllocator twice, which causes assertion failures in
-        # sleep mode.
+        # Only dynamic custom pipelines skip initial loading; native pipelines
+        # may also use custom_pipeline_args for model-specific component paths.
         self.worker = worker_class(
             local_rank=gpu_id,
             rank=gpu_id,
             od_config=od_config,
-            skip_load_model=(self.custom_pipeline_args is not None),
+            skip_load_model=self.uses_custom_pipeline,
         )
 
         # Re-initialize pipeline with custom pipeline if provided
-        if self.custom_pipeline_args is not None:
+        if self.uses_custom_pipeline:
             self.worker.re_init_pipeline(self.custom_pipeline_args)
 
     def _prepare_worker_class(self) -> type:
@@ -1605,8 +1629,8 @@ class WorkerWrapperBase:
         """
         worker_class = self.base_worker_class
 
-        # If custom_pipeline_args is provided, use CustomPipelineWorkerExtension
-        if self.custom_pipeline_args is not None:
+        # If custom pipeline initialization is requested, use CustomPipelineWorkerExtension.
+        if self.uses_custom_pipeline:
             # Set worker_extension_cls to CustomPipelineWorkerExtension if not already set
             if self.worker_extension_cls is None:
                 self.worker_extension_cls = CustomPipelineWorkerExtension
diff --git a/vllm_omni/diffusion/worker/input_batch.py b/vllm_omni/diffusion/worker/input_batch.py
index 0e9a2bde1..a536a4f58 100644
--- a/vllm_omni/diffusion/worker/input_batch.py
+++ b/vllm_omni/diffusion/worker/input_batch.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Diffusion input-batch structures following the MRV2-style vLLM layout.
 
 Request states remain the only persistent source of truth. Static tensors are
@@ -67,19 +67,26 @@ def _select_states(
         raise ValueError("Cannot build InputBatch from empty states.")
 
     if idx_mapping is None:
+        # The identity mapping is known on the host; build the device copy as
+        # a launch and the host copy from NumPy rather than reading the device
+        # tensor back. This runs on every step of every stepwise request, and
+        # a device-to-host read here would stall the host until the queued
+        # denoise work drained, so it must not be a synchronising operation.
         device = states[0].latents.device if states[0].latents is not None else None
         idx_mapping = torch.arange(len(states), dtype=torch.int32, device=device)
+        idx_mapping_np = np.arange(len(states), dtype=np.int32)
     else:
         if idx_mapping.ndim != 1:
             raise ValueError("idx_mapping must be a 1D tensor.")
         idx_mapping = idx_mapping.to(dtype=torch.int32)
+        idx_mapping_np = idx_mapping.detach().cpu().numpy()
 
     selected_states: list[StepRequestState] = []
-    for batch_idx, state_idx in enumerate(idx_mapping.tolist()):
+    for batch_idx, state_idx in enumerate(idx_mapping_np.tolist()):
         if state_idx < 0 or state_idx >= len(states):
             raise ValueError(f"idx_mapping[{batch_idx}]={state_idx} is out of range for states.")
         selected_states.append(states[state_idx])
-    return selected_states, idx_mapping, idx_mapping.detach().cpu().numpy()
+    return selected_states, idx_mapping, idx_mapping_np
 
 
 def _prepare_request_ids(states: Sequence[StepRequestState]) -> list[str]:
diff --git a/vllm_omni/distributed/omni_connectors/adapter.py b/vllm_omni/distributed/omni_connectors/adapter.py
index 79a1d7887..dc3be166f 100644
--- a/vllm_omni/distributed/omni_connectors/adapter.py
+++ b/vllm_omni/distributed/omni_connectors/adapter.py
@@ -10,6 +10,11 @@ from vllm_omni.metrics import OrchestratorAggregator
 
 from .utils.logging import get_connector_logger
 
+# Upper bound on a previous streaming chunk's generation reserve: a duplex
+# turn-end chunk may retain more codec ids than the steady-state per-unit
+# reserve (see MINICPMO45_DUPLEX_TURN_END_CODEC_TOKENS).
+_MAX_PREVIOUS_CHUNK_GENERATION_RESERVE = 26 * 4
+
 logger = get_connector_logger(__name__)
 
 
@@ -345,7 +350,9 @@ def construct_next_stage_streaming_input_prompt(
                 f"confirmed={confirmed_num_computed_tokens}, prompt={request.num_prompt_tokens}"
             )
         previous_codec_ids = list(request._all_token_ids[request.num_prompt_tokens : confirmed_num_computed_tokens])
-        max_confirmed_codec_tokens = generation_reserve - 1
+        # The previous chunk may have been a turn-end unit that ran to the
+        # Talker's EOS with a larger reserve than this chunk's.
+        max_confirmed_codec_tokens = max(generation_reserve, _MAX_PREVIOUS_CHUNK_GENERATION_RESERVE) - 1
         if len(previous_codec_ids) > max_confirmed_codec_tokens:
             raise ValueError(
                 "streaming prompt recompute retained too many codec tokens: "
diff --git a/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py b/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py
index 3a51795c4..f2c01da9c 100644
--- a/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py
+++ b/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import fcntl
 import os
diff --git a/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_payload_transport.py b/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_payload_transport.py
index 2343315b9..23c218c71 100644
--- a/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_payload_transport.py
+++ b/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_payload_transport.py
@@ -7,7 +7,8 @@ from __future__ import annotations
 import importlib
 import inspect
 from collections import deque
-from typing import TYPE_CHECKING, Any
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, cast
 
 import torch
 from vllm.distributed.parallel_state import get_tp_group
@@ -29,21 +30,23 @@ if TYPE_CHECKING:
 class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
     """Own payload caching, full/chunk transport, and connector I/O."""
 
+    _full_payload_replace_keys_cached: frozenset[str]
+
     # ------------------------------------------------------------------ #
     #  Local payload cache (RFC §2.4 – Model Runner ownership)
     # ------------------------------------------------------------------ #
 
     def put_local_stage_payload(self, req_id: str, payload: OmniPayload) -> None:
         """Store a full stage payload in the local cache."""
-        self._local_stage_payload_cache[req_id] = payload
+        self._local_stage_payload_cache[req_id] = cast(dict[str, Any], payload)
 
     def get_local_stage_payload(self, req_id: str) -> OmniPayload | None:
         """Read a stage payload without removing it."""
-        return self._local_stage_payload_cache.get(req_id)
+        return cast(OmniPayload | None, self._local_stage_payload_cache.get(req_id))
 
     def pop_local_stage_payload(self, req_id: str) -> OmniPayload | None:
         """Remove and return a stage payload (consume after use)."""
-        return self._local_stage_payload_cache.pop(req_id, None)
+        return cast(OmniPayload | None, self._local_stage_payload_cache.pop(req_id, None))
 
     def put_local_request_metadata(self, req_id: str, metadata: dict[str, Any]) -> None:
         """Store lightweight scheduling metadata for a request."""
@@ -58,19 +61,20 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
     # ------------------------------------------------------------------ #
 
     @classmethod
-    def _extract_scheduling_metadata(cls, payload: OmniPayload) -> dict[str, Any]:
+    def _extract_scheduling_metadata(cls, payload: dict[str, Any] | OmniPayload) -> dict[str, Any]:
         """Extract only the fields the scheduler needs from a full payload."""
         extracted: dict[str, Any] = {}
         meta = payload.get("meta") if isinstance(payload, dict) else None
         meta = meta if isinstance(meta, dict) else {}
-
         if "next_stage_prompt_len" in meta:
             extracted["next_stage_prompt_len"] = meta["next_stage_prompt_len"]
-        elif "next_stage_prompt_len" in payload:
-            logger.warning_once(
-                "legacy flat 'next_stage_prompt_len' key in payload; expected 'meta.next_stage_prompt_len'"
-            )
-            extracted["next_stage_prompt_len"] = payload["next_stage_prompt_len"]
+        else:
+            legacy_prompt_len = cast(dict[str, Any], payload).get("next_stage_prompt_len")
+            if legacy_prompt_len is not None:
+                logger.warning_once(
+                    "legacy flat 'next_stage_prompt_len' key in payload; expected 'meta.next_stage_prompt_len'"
+                )
+                extracted["next_stage_prompt_len"] = legacy_prompt_len
 
         audio_codes = cls._payload_audio_codes(payload)
         if audio_codes is not None:
@@ -81,6 +85,9 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         elif "left_context_size" in payload:
             logger.warning_once("legacy flat 'left_context_size' key in payload; expected 'meta.left_context_size'")
 
+        if cls._payload_finished(payload):
+            extracted["input_terminal"] = True
+
         return extracted
 
     _NON_CONSUMABLE_PAYLOAD_KEYS: set[tuple[str, str]] = {
@@ -129,7 +136,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         return None
 
     @classmethod
-    def _payload_is_consumable(cls, payload: OmniPayload | None) -> bool:
+    def _payload_is_consumable(cls, payload: dict[str, Any] | OmniPayload | None) -> bool:
         """Return True when an async payload can drive a real forward step.
 
         Metadata-only wake-ups should not transition WAITING_FOR_CHUNK requests
@@ -327,67 +334,11 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         """
         if not hasattr(self, "_lock"):
             return OmniConnectorOutput()
-
-        tp_group = self._get_local_tp_group()
-        if self._async_chunk and tp_group is not None and getattr(tp_group, "world_size", 1) > 1:
-            if self.is_data_transfer_rank():
-                with self._lock:
-                    fanout_packet = self._collect_async_chunk_fanout_packet_locked()
-            else:
-                fanout_packet = None
-            fanout_packet = self._broadcast_tp_payload_packet(fanout_packet)
-            if fanout_packet is None:
-                newly_finished = set()
-                chunk_finished = set()
-                request_metadata = {}
-            else:
-                if not self.is_data_transfer_rank():
-                    self._apply_async_chunk_fanout_packet(fanout_packet)
-                newly_finished = set(fanout_packet["newly_finished"])
-                chunk_finished = set(fanout_packet["chunk_finished"])
-                request_metadata = dict(fanout_packet["request_metadata"])
-        else:
-            with self._lock:
-                newly_finished = set(self._finished_load_reqs)
-                self._finished_load_reqs.clear()
-                chunk_finished = set(self._chunk_finished_req_ids)
-                self._chunk_finished_req_ids.clear()
-                request_metadata = dict(self._local_request_metadata)
-                self._local_request_metadata.clear()
-                # _send_side_request_payload is the async accumulation buffer for
-                # future recv chunks. Clearing it on every consumable wake-up drops
-                # intermediate
-                # thinker decode spans before the model side can consume them.
-                # Only terminal chunk_finished requests may release that buffer.
-                for req_id in chunk_finished:
-                    if req_id not in self._local_stage_payload_cache:
-                        continue
-                    ext_req_id = self._request_ids_mapping.get(req_id, req_id)
-                    self._send_side_request_payload.pop(ext_req_id, None)
-                    if ext_req_id != req_id:
-                        self._send_side_request_payload.pop(req_id, None)
-        self._chunk_ready_req_ids.update(newly_finished)
-
-        output = OmniConnectorOutput(
-            chunk_ready_req_ids=set(self._chunk_ready_req_ids),
-            chunk_finished_req_ids=chunk_finished,
-            request_metadata=request_metadata,
-            kv_sent_req_ids=list(self._kv_sent_req_ids),
-            stage_recv_req_ids=set(self._stage_recv_req_ids),
-            has_pending_kv_work=self.has_pending_kv_work(),
-        )
-        if output.stage_recv_req_ids or chunk_finished or newly_finished:
-            logger.debug(
-                "[Stage-%s] get_omni_connector_output: stage_recv=%s, chunk_finished=%s, chunk_ready=%s",
-                self._stage_id,
-                output.stage_recv_req_ids,
-                chunk_finished,
-                output.chunk_ready_req_ids,
-            )
-        self._chunk_ready_req_ids.clear()
-        self._kv_sent_req_ids.clear()
-        self._stage_recv_req_ids.clear()
-        return output
+        drain_lock = getattr(self, "_omni_connector_output_drain_lock", None)
+        if drain_lock is None:
+            return self._drain_omni_connector_output()
+        with drain_lock:
+            return self._drain_omni_connector_output()
 
     @staticmethod
     def _connector_output_has_signals(output: OmniConnectorOutput) -> bool:
@@ -502,8 +453,8 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             # Skip the per-step accumulator+build that would otherwise be
             # silently discarded.  Defends against a terminal stage whose
             # custom_process_input_func has a *_full_payload derivative in
-            # the same module (e.g. dynin stage 2 token2image_to_token2audio
-            # in pipelines that don't configure any connector at all).
+            # the same module, even in pipelines that don't configure any
+            # connector at all.
             #
             # Known limitation: a *terminal-consumer* stage that has a
             # connector configured for receiving upstream input is NOT
@@ -556,7 +507,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 output[k] = tensors[0] if len(tensors) == 1 else torch.cat(tensors, dim=0)
         return output, request
 
-    def _resolve_full_payload_replace_keys(self) -> frozenset:
+    def _resolve_full_payload_replace_keys(self) -> frozenset[str]:
         """Per-model REPLACE-key set for the full-payload accumulator.
 
         Looked up from the stage-input-processor module that ships the model's sync builder
@@ -584,7 +535,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             import sys as _sys
 
             mod = _sys.modules.get(module_name) or importlib.import_module(module_name)
-            keys = getattr(mod, "_FULL_PAYLOAD_REPLACE_KEYS", frozenset())
+            keys: Any = getattr(mod, "_FULL_PAYLOAD_REPLACE_KEYS", frozenset())
         except ImportError:
             logger.debug(
                 "Could not import stage input processor module %s while resolving "
@@ -748,7 +699,8 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                     code_len = len(audio_codes)
                 else:
                     code_len = None
-                meta = payload.get("meta") if isinstance(payload.get("meta"), dict) else {}
+                raw_meta = payload.get("meta")
+                meta = raw_meta if isinstance(raw_meta, dict) else {}
                 logger.debug(
                     "[Stage-%s] send_full_payload_outputs: req=%s payload_keys=%s code_len=%s left_context_size=%s",
                     self._stage_id,
@@ -849,6 +801,9 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         self,
         request: Any,
         pooling_output: Any | None = None,
+        *,
+        propagate_errors: bool = False,
+        wait_for_delivery: bool = False,
     ) -> bool:
         """Derive and enqueue one chunk for async sending.
 
@@ -863,6 +818,9 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         if not self.is_data_transfer_rank():
             return True
         raw_req_id = getattr(request, "request_id", None) or getattr(request, "req_id", None)
+        if not isinstance(raw_req_id, str):
+            logger.warning("[Stage-%s] send_chunk: missing request_id", self._stage_id)
+            return False
         request_id = self._resolve_external_req_id(request, raw_req_id)
         # Cache the internal→external mapping so that finish sentinels can
         # resolve the external ID even after the request is freed.
@@ -874,10 +832,11 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             request_id=request_id,
             request=request,
             pooling_output=pooling_output,
+            propagate_errors=propagate_errors,
         )
         if payload_data is None:
             if chunk_id == 0:
-                logger.warning(
+                logger.debug(
                     "[Stage-%s] send_chunk: payload is None for req=%s chunk=%s (process_func=%s)",
                     self._stage_id,
                     request_id,
@@ -886,31 +845,14 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 )
             return False
 
-        self._put_req_chunk[request_id] += 1
-        self._ramp_chunk_count[request_id] += 1
-        next_stage_id = self._next_stage_id
-        connector_put_key = f"{request_id}_{self._stage_id}_{chunk_id}"
-
-        if chunk_id == 0:
-            logger.debug(
-                "[Stage-%s] send_chunk: first chunk enqueued, req=%s key=%s",
-                self._stage_id,
-                request_id,
-                connector_put_key,
-            )
-
-        task = {
-            "stage_id": self._stage_id,
-            "next_stage_id": next_stage_id,
-            "put_key": connector_put_key,
-            "data": payload_data,
-            "request_id": request_id,
-        }
-        with self._lock:
-            self._pending_save_reqs.setdefault(request_id, deque()).append(task)
-            self._pending_save_counts[request_id] += 1
-        self._work_available.set()
-        return True
+        enqueued, completion = self._enqueue_chunk_payload(
+            request,
+            payload_data,
+            wait_for_delivery=wait_for_delivery,
+        )
+        if enqueued and completion is not None:
+            completion.wait()
+        return enqueued
 
     # ------------------------------------------------------------------ #
     #  Background I/O threads
@@ -938,14 +880,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                     _recv_poll_count,
                 )
 
-            made_progress = False
-            for req_id in pending_ids:
-                if self._stop_event.is_set():
-                    break
-                try:
-                    made_progress = self._poll_single_request(req_id) or made_progress
-                except Exception:
-                    logger.warning("Error receiving data for %s", req_id, exc_info=True)
+            made_progress = self._poll_pending_requests_once(pending_ids)
 
             if not made_progress and not self._stop_event.is_set():
                 self._work_available.wait(timeout=0.005)
@@ -969,25 +904,40 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
 
             if task is not None:
                 success = False
+                send_error: BaseException | None = None
                 try:
                     success = self._send_single_request(task)
-                except Exception:
+                except Exception as error:
+                    send_error = error
                     logger.error(
                         "Error saving data for %s",
                         task.get("request_id"),
                         exc_info=True,
                     )
                 if not success:
-                    self._requeue_or_drop_failed_send(task)
+                    self._requeue_or_drop_failed_send(task, error=send_error)
                 continue
 
             self._work_available.wait(timeout=0.01)
             self._work_available.clear()
 
-    def _requeue_or_drop_failed_send(self, task: dict) -> None:
+    def _requeue_or_drop_failed_send(
+        self,
+        task: dict,
+        *,
+        error: BaseException | None = None,
+    ) -> None:
         """Re-enqueue a failed send task or drop it after max retries."""
         retry_count = task.get("_retry_count", 0) + 1
         req_id = task.get("request_id")
+        if not isinstance(req_id, str):
+            logger.error(
+                "[Stage-%s] Failed send task is missing request_id; dropping it",
+                getattr(self, "_stage_id", "?"),
+            )
+            return
+        if error is not None:
+            task["_last_send_error"] = error
         if retry_count <= self._MAX_SEND_RETRIES:
             task["_retry_count"] = retry_count
             logger.warning(
@@ -1001,19 +951,36 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 dq = self._pending_save_reqs.setdefault(req_id, deque())
                 dq.appendleft(task)
         else:
+            cause = error or task.get("_last_send_error")
+            failure = RuntimeError(
+                "connector send failed permanently for "
+                f"request {req_id!r}, key {task.get('put_key')!r} "
+                f"after {self._MAX_SEND_RETRIES + 1} attempts"
+            )
+            if cause is not None:
+                failure.__cause__ = cause
             logger.error(
                 "[Stage-%s] Giving up on send for %s after %d retries",
                 getattr(self, "_stage_id", "?"),
                 req_id,
                 self._MAX_SEND_RETRIES,
             )
+            sink = getattr(self, "_connector_send_error_sink", None)
+            if sink is not None:
+                try:
+                    sink(failure)
+                except Exception:
+                    logger.exception("Connector send error sink failed for %s", req_id)
+            completion = task.get("completion")
+            if completion is not None:
+                completion.set_error(failure)
             self._decrement_pending_save_count(req_id)
 
     # ------------------------------------------------------------------ #
     #  Chunk-level poll / send  (ported from OmniChunkTransferAdapter)
     # ------------------------------------------------------------------ #
 
-    def _poll_single_request(self, req_id: str) -> bool:
+    def _poll_single_request(self, req_id: str, *, publish_ready: bool = True) -> bool:
         """Poll connector for one chunk of a request (non-blocking)."""
         connector = self._omni_connector
         if connector is None:
@@ -1085,16 +1052,20 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             is_finished = self._payload_finished(payload_data)
             incoming_payload_consumable = self._payload_is_consumable(payload_data)
 
-            if self._model_mode == "ar":
-                payload_data = self._accumulate_payload(external_req_id, payload_data)
-                payload_consumable = incoming_payload_consumable
-            else:
-                new_ids = self._payload_audio_codes(payload_data) or []
-                if not new_ids and not is_finished:
+            if self._model_mode != "ar":
+                new_ids = self._payload_audio_codes(payload_data)
+                if not self._payload_value_has_content(new_ids) and not is_finished:
                     return False
                 payload_consumable = self._payload_is_consumable(payload_data)
 
             with self._lock:
+                if self._model_mode == "ar":
+                    # Accumulation, staging, and model-side consume/ack share
+                    # this lock. Keeping the transition atomic prevents the
+                    # model thread from clearing a just-merged decode span
+                    # before the recv thread publishes it to the local cache.
+                    payload_data = self._accumulate_payload(external_req_id, payload_data)
+                    payload_consumable = incoming_payload_consumable
                 if is_finished:
                     self._chunk_finished_req_ids.add(req_id)
                     self._chunk_stream_completed.add(req_id)
@@ -1153,6 +1124,8 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 type(engine_inputs).__name__,
             )
 
+        if publish_ready and self._async_chunk and (payload_consumable or is_finished):
+            self.publish_omni_connector_output_to_sink()
         logger.debug("[Stage-%s] Received data for key %s", self._stage_id, connector_get_key)
         return True
 
@@ -1161,14 +1134,27 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         request_id: str | None,
         request: Any | None,
         pooling_output: Any | None,
+        *,
+        propagate_errors: bool = False,
     ) -> Any | None:
         """Run the custom process hook with a best-effort finished kwarg."""
         if self._custom_process_func is None:
             return None
 
+        payload_kwarg = getattr(self, "_custom_process_payload_kwarg", None)
+        if payload_kwarg is None:
+            payload_kwarg = self._connector_payload_kwarg(self._custom_process_func)
+            self._custom_process_payload_kwarg = payload_kwarg
+        if payload_kwarg is None:
+            message = f"custom process hook {self._custom_process_func} has no connector payload argument"
+            logger.error(message)
+            if propagate_errors:
+                raise RuntimeError(message)
+            return None
+
         kwargs = {
             "transfer_manager": self,
-            "pooling_output": pooling_output,
+            payload_kwarg: pooling_output,
             "request": request,
         }
         supports_is_finished = getattr(
@@ -1183,21 +1169,29 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                     kwargs["is_finished"] = bool(is_finished_fn())
             except Exception:
                 logger.debug("request.is_finished() failed for %s", request_id, exc_info=True)
+                if propagate_errors:
+                    raise
 
         try:
             return self._custom_process_func(**kwargs)
         except TypeError as exc:
             if "is_finished" not in kwargs or not self._is_unexpected_is_finished_kwarg_error(exc):
                 logger.exception("custom_process_stage_input_func failed for chunk %s", request_id)
+                if propagate_errors:
+                    raise
                 return None
             kwargs.pop("is_finished", None)
             try:
                 return self._custom_process_func(**kwargs)
             except Exception:
                 logger.exception("custom_process_stage_input_func failed for chunk %s", request_id)
+                if propagate_errors:
+                    raise
                 return None
         except Exception:
             logger.exception("custom_process_stage_input_func failed for chunk %s", request_id)
+            if propagate_errors:
+                raise
             return None
 
     def _custom_process_supports_is_finished_kwarg(self) -> bool | None:
@@ -1233,15 +1227,17 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
     def _send_single_request(self, task: dict) -> bool:
         """Send one queued task via connector.put().
 
-        Returns True on success.  On failure (put() raises or returns
-        ``success=False``), returns False **without** decrementing
-        ``_pending_save_counts`` so the caller can retry or clean up.
+        Returns True when the task is consumed, either by a successful send or
+        because its delivery completion was already terminal.  On transport
+        failure (put() raises or returns ``success=False``), returns False
+        **without** decrementing ``_pending_save_counts`` so the caller can
+        retry or clean up.
         """
         connector = self._omni_connector
         if connector is None:
             return True
 
-        request_id = task.get("request_id")
+        request_id = task["request_id"]
         payload_data = task.get("data")
         if payload_data is None and task.get("request") is not None:
             payload_data = self._build_custom_process_payload(
@@ -1250,6 +1246,15 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 pooling_output=task.get("pooling_output"),
             )
         put_key = task.get("put_key")
+        completion = task.get("completion")
+        if completion is not None and not completion.mark_in_flight():
+            logger.debug(
+                "[Stage-%s] Skipping terminal connector delivery: put_key=%s",
+                task["stage_id"],
+                put_key,
+            )
+            self._decrement_pending_save_count(request_id)
+            return True
 
         success, _size, _metadata = connector.put(
             from_stage=str(task["stage_id"]),
@@ -1269,6 +1274,8 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             return False
 
         self._decrement_pending_save_count(request_id)
+        if completion is not None:
+            completion.set_result()
         return True
 
     def _decrement_pending_save_count(self, request_id: str) -> None:
@@ -1287,6 +1294,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 self._put_req_chunk.pop(cleanup_req_id, None)
                 self._send_side_request_payload.pop(cleanup_req_id, None)
                 self._code_prompt_token_ids.pop(cleanup_req_id, None)
+                getattr(self, "_qwen3_tts_emitted_frames", {}).pop(cleanup_req_id, None)
                 self._cached_ic.pop(cleanup_req_id, None)
                 self._ramp_chunk_count.pop(cleanup_req_id, None)
                 self._adaptive_states.pop(cleanup_req_id, None)
@@ -1299,7 +1307,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         """Accumulate chunk payloads (concat tensors, extend lists)."""
         if req_id not in self._send_side_request_payload:
             self._send_side_request_payload[req_id] = dict(payload_data)
-            return dict(self._send_side_request_payload[req_id])
+            return cast(OmniPayload, dict(self._send_side_request_payload[req_id]))
 
         origin = self._send_side_request_payload[req_id]
         merged = dict(origin)
@@ -1338,4 +1346,239 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                     merged[key] = value
 
         self._send_side_request_payload[req_id] = merged
-        return dict(merged)
+        return cast(OmniPayload, dict(merged))
+
+    def _drain_omni_connector_output(self) -> OmniConnectorOutput:
+        tp_group = self._get_local_tp_group()
+        if self._async_chunk and tp_group is not None and getattr(tp_group, "world_size", 1) > 1:
+            if self.is_data_transfer_rank():
+                with self._lock:
+                    fanout_packet = self._collect_async_chunk_fanout_packet_locked()
+            else:
+                fanout_packet = None
+            fanout_packet = self._broadcast_tp_payload_packet(fanout_packet)
+            if fanout_packet is None:
+                newly_finished = set()
+                chunk_finished = set()
+                request_metadata = {}
+            else:
+                if not self.is_data_transfer_rank():
+                    self._apply_async_chunk_fanout_packet(fanout_packet)
+                newly_finished = set(fanout_packet["newly_finished"])
+                chunk_finished = set(fanout_packet["chunk_finished"])
+                request_metadata = dict(fanout_packet["request_metadata"])
+        else:
+            with self._lock:
+                newly_finished = set(self._finished_load_reqs)
+                self._finished_load_reqs.clear()
+                chunk_finished = set(self._chunk_finished_req_ids)
+                self._chunk_finished_req_ids.clear()
+                request_metadata = dict(self._local_request_metadata)
+                self._local_request_metadata.clear()
+                # _send_side_request_payload is the async accumulation buffer for
+                # future recv chunks. Clearing it on every consumable wake-up drops
+                # intermediate
+                # thinker decode spans before the model side can consume them.
+                # Only terminal chunk_finished requests may release that buffer.
+                for req_id in chunk_finished:
+                    if req_id not in self._local_stage_payload_cache:
+                        continue
+                    ext_req_id = self._request_ids_mapping.get(req_id, req_id)
+                    self._send_side_request_payload.pop(ext_req_id, None)
+                    if ext_req_id != req_id:
+                        self._send_side_request_payload.pop(req_id, None)
+        self._chunk_ready_req_ids.update(newly_finished)
+
+        output = OmniConnectorOutput(
+            chunk_ready_req_ids=set(self._chunk_ready_req_ids),
+            chunk_finished_req_ids=chunk_finished,
+            request_metadata=request_metadata,
+            kv_sent_req_ids=list(self._kv_sent_req_ids),
+            stage_recv_req_ids=set(self._stage_recv_req_ids),
+            has_pending_kv_work=self.has_pending_kv_work(),
+        )
+        if output.stage_recv_req_ids or chunk_finished or newly_finished:
+            logger.debug(
+                "[Stage-%s] get_omni_connector_output: stage_recv=%s, chunk_finished=%s, chunk_ready=%s",
+                self._stage_id,
+                output.stage_recv_req_ids,
+                chunk_finished,
+                output.chunk_ready_req_ids,
+            )
+        self._chunk_ready_req_ids.clear()
+        self._kv_sent_req_ids.clear()
+        self._stage_recv_req_ids.clear()
+        return output
+
+    def _enqueue_chunk_payload(
+        self,
+        request: Any,
+        payload_data: Any,
+        *,
+        wait_for_delivery: bool = False,
+    ) -> tuple[bool, Any | None]:
+        """Enqueue an already-built payload under its per-request chunk key."""
+        raw_req_id = getattr(request, "request_id", None) or getattr(request, "req_id", None)
+        request_id = self._resolve_external_req_id(request, raw_req_id)
+        if raw_req_id and raw_req_id != request_id:
+            self._request_ids_mapping.setdefault(raw_req_id, request_id)
+        chunk_id = self._put_req_chunk[request_id]
+        self._put_req_chunk[request_id] += 1
+        self._ramp_chunk_count[request_id] += 1
+        next_stage_id = self._next_stage_id
+        connector_put_key = f"{request_id}_{self._stage_id}_{chunk_id}"
+        completion = (
+            self._create_send_completion(
+                request_id=request_id,
+                put_key=connector_put_key,
+            )
+            if wait_for_delivery
+            else None
+        )
+
+        if chunk_id == 0:
+            logger.debug(
+                "[Stage-%s] send_chunk: first chunk enqueued, req=%s key=%s",
+                self._stage_id,
+                request_id,
+                connector_put_key,
+            )
+
+        task = {
+            "stage_id": self._stage_id,
+            "next_stage_id": next_stage_id,
+            "put_key": connector_put_key,
+            "data": payload_data,
+            "request_id": request_id,
+            "completion": completion,
+        }
+        with self._lock:
+            self._pending_save_reqs.setdefault(request_id, deque()).append(task)
+            self._pending_save_counts[request_id] += 1
+        self._work_available.set()
+        return True, completion
+
+    def _poll_pending_requests_once(self, pending_ids: list[str]) -> bool:
+        """Poll one receiver pass and publish its ready requests as a cohort."""
+        made_progress = False
+        for req_id in pending_ids:
+            if self._stop_event.is_set():
+                break
+            try:
+                made_progress = self._poll_single_request(req_id, publish_ready=False) or made_progress
+            except Exception:
+                logger.warning("Error receiving data for %s", req_id, exc_info=True)
+        if made_progress and self._async_chunk:
+            self.publish_omni_connector_output_to_sink()
+        return made_progress
+
+    def _publish_chunk_cohort(self, entries: list[tuple[Any, Any]], *, wait_for_delivery: bool) -> int:
+        entries = [(request, payload) for request, payload in entries if payload is not None]
+        if not entries:
+            return 0
+        emitted = 0
+        completions: list[Any] = []
+        for request, payload in entries:
+            enqueued, completion = self._enqueue_chunk_payload(request, payload, wait_for_delivery=wait_for_delivery)
+            if enqueued:
+                emitted += 1
+                if completion is not None:
+                    completions.append(completion)
+        for completion in completions:
+            completion.wait()
+        return emitted
+
+    def publish_omni_connector_output_to_sink(self) -> bool:
+        """Drain pending readiness into the same-process scheduler inbox."""
+        sink = getattr(self, "_omni_connector_output_sink", None)
+        if sink is None:
+            return False
+        output = self.get_omni_connector_output()
+        if not self._connector_output_has_signals(output):
+            return False
+        sink(output)
+        return True
+
+    def send_chunks(
+        self,
+        entries: list[tuple[Any, Any | None]],
+        *,
+        propagate_errors: bool = False,
+        wait_for_delivery: bool = False,
+    ) -> int:
+        """Build and enqueue all request payloads from one model step.
+
+        A model-specific batch builder may coalesce GPU post-processing and
+        D2H copies across requests. Models without one retain the scalar
+        builder contract.
+        """
+        if not entries or self._omni_connector is None:
+            return 0
+        if not self.is_data_transfer_rank():
+            return len(entries)
+
+        batch_func = getattr(self, "_custom_process_batch_func", None)
+        if batch_func is None:
+            payloads = []
+            for request, pooling_output in entries:
+                raw_req_id = getattr(request, "request_id", None) or getattr(request, "req_id", None)
+                request_id = self._resolve_external_req_id(request, raw_req_id)
+                payloads.append(
+                    self._build_custom_process_payload(
+                        request_id=request_id,
+                        request=request,
+                        pooling_output=pooling_output,
+                        propagate_errors=propagate_errors,
+                    )
+                )
+            return self._publish_chunk_cohort(
+                [(request, payload) for (request, _), payload in zip(entries, payloads, strict=True)],
+                wait_for_delivery=wait_for_delivery,
+            )
+
+        requests = [request for request, _ in entries]
+        pooling_outputs = [pooling_output for _, pooling_output in entries]
+        is_finished: list[bool] = []
+        for request in requests:
+            finished_fn = getattr(request, "is_finished", None)
+            is_finished.append(bool(finished_fn()) if callable(finished_fn) else False)
+
+        try:
+            payloads = batch_func(
+                transfer_manager=self,
+                pooling_outputs=pooling_outputs,
+                requests=requests,
+                is_finished=is_finished,
+            )
+        except Exception:
+            logger.exception(
+                "batch custom_process_stage_input_func failed for %s requests",
+                len(entries),
+            )
+            if propagate_errors:
+                raise
+            return 0
+        if not isinstance(payloads, list) or len(payloads) != len(entries):
+            message = (
+                "batch custom process hook "
+                f"{batch_func} returned "
+                f"{len(payloads) if isinstance(payloads, list) else type(payloads).__name__} "
+                f"payloads for {len(entries)} requests"
+            )
+            logger.error(
+                "batch custom process hook %s returned %s payloads for %s requests",
+                batch_func,
+                len(payloads) if isinstance(payloads, list) else type(payloads).__name__,
+                len(entries),
+            )
+            if propagate_errors:
+                raise RuntimeError(message)
+            return 0
+
+        return self._publish_chunk_cohort(list(zip(requests, payloads)), wait_for_delivery=wait_for_delivery)
+
+    def set_omni_connector_output_sink(
+        self,
+        sink: Callable[[OmniConnectorOutput], None] | None,
+    ) -> None:
+        self._omni_connector_output_sink = sink
diff --git a/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_runtime.py b/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_runtime.py
index 95a6cac22..2ed040703 100644
--- a/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_runtime.py
+++ b/vllm_omni/distributed/omni_connectors/model_runner/omni_connector_runtime.py
@@ -9,6 +9,7 @@ import inspect
 import os
 import threading
 from collections import defaultdict, deque
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 import torch
@@ -21,6 +22,7 @@ from vllm_omni.distributed.omni_connectors.utils.config import (
 )
 from vllm_omni.distributed.omni_connectors.utils.initialization import resolve_connector_spec
 from vllm_omni.distributed.omni_connectors.utils.kv_utils import get_local_tp_rank, get_omni_replica_id
+from vllm_omni.outputs import OmniConnectorOutput
 
 logger = init_logger("vllm_omni.worker.omni_connector_model_runner_mixin")
 
@@ -69,14 +71,35 @@ def should_accumulate_full_payload_output(model_config, custom_process_func) ->
         return False
     if getattr(model_config, "async_chunk", False):
         return False
-    if getattr(model_config, "final_output", False):
-        return False
     next_stage_func = getattr(model_config, "custom_process_next_stage_input_func", None)
     if not isinstance(next_stage_func, str) or not next_stage_func:
         return False
     return getattr(model_config, "model_stage", None) is not None
 
 
+class _SendCompletion:
+    """One connector task's delivery acknowledgement."""
+
+    def __init__(self) -> None:
+        self._event = threading.Event()
+        self._error: BaseException | None = None
+
+    def mark_in_flight(self) -> bool:
+        return True
+
+    def set_result(self) -> None:
+        self._event.set()
+
+    def set_error(self, error: BaseException) -> None:
+        self._error = error
+        self._event.set()
+
+    def wait(self) -> None:
+        self._event.wait()
+        if self._error is not None:
+            raise self._error
+
+
 class _OmniConnectorRuntimeMixin:
     """Own connector lifecycle, shared state, and KV transfer delegation."""
 
@@ -166,6 +189,8 @@ class _OmniConnectorRuntimeMixin:
         self._stage_id: int = stage_id if isinstance(stage_id, int) else 0
 
         self._custom_process_func_path, self._custom_process_func = self._load_custom_func(model_config)
+        self._custom_process_batch_func = self._load_custom_batch_func(self._custom_process_func)
+        self._custom_process_payload_kwarg = self._connector_payload_kwarg(self._custom_process_func)
         self._custom_process_supports_is_finished = self._custom_process_supports_is_finished_kwarg()
         logger.debug(
             "[Stage-%s] init_omni_connectors: async_chunk=%s, custom_process_func=%s, connector=%s, func_path=%s",
@@ -229,6 +254,7 @@ class _OmniConnectorRuntimeMixin:
         self._pending_save_reqs: dict[str, deque] = {}
         self._pending_save_counts: dict[str, int] = defaultdict(int)
         self._deferred_send_cleanup: set[str] = set()
+        self._connector_send_error_sink: Callable[[BaseException], None] | None = None
         # -- per-cycle output accumulator --
         self._chunk_ready_req_ids: set[str] = set()
         self._chunk_finished_req_ids: set[str] = set()
@@ -247,6 +273,9 @@ class _OmniConnectorRuntimeMixin:
         self._local_stage_payload_cache: dict[str, dict[str, Any]] = {}
         # Lightweight scheduling metadata pending delivery to the Scheduler.
         self._local_request_metadata: dict[str, dict[str, Any]] = {}
+        # Optional same-process control-plane fast path. Payload tensors remain
+        # runner-owned; only OmniConnectorOutput readiness is published.
+        self._omni_connector_output_sink: Callable[[OmniConnectorOutput], None] | None = None
 
         # -- persistent set of request IDs whose chunk stream is complete --
         # Prevents re-registration after the finish sentinel has been received.
@@ -270,6 +299,7 @@ class _OmniConnectorRuntimeMixin:
         self._kv_triggered_requests: set[str] = set()
 
         self._lock = threading.Lock()
+        self._omni_connector_output_drain_lock = threading.Lock()
         self._stop_event = threading.Event()
         self._work_available = threading.Event()
 
@@ -364,6 +394,7 @@ class _OmniConnectorRuntimeMixin:
                 self._put_req_chunk.pop(k, None)
                 self._send_side_request_payload.pop(k, None)
                 self._code_prompt_token_ids.pop(k, None)
+                getattr(self, "_qwen3_tts_emitted_frames", {}).pop(k, None)
                 self._cached_ic.pop(k, None)
                 self._ramp_chunk_count.pop(k, None)
                 self._adaptive_states.pop(k, None)
@@ -384,6 +415,10 @@ class _OmniConnectorRuntimeMixin:
         self._cleanup_recv_delivery_state(req_id)
 
     def _drop_send_side_payload_state(self, req_id: str, ext_id: str | None) -> None:
+        watermark = getattr(self, "_qwen3_tts_emitted_frames", {})
+        watermark.pop(req_id, None)
+        if ext_id is not None:
+            watermark.pop(ext_id, None)
         if ext_id is not None:
             self._send_side_request_payload.pop(ext_id, None)
             self._cached_ic.pop(ext_id, None)
@@ -594,31 +629,12 @@ class _OmniConnectorRuntimeMixin:
 
         return None, None
 
-    @staticmethod
-    def _is_connector_payload_builder(func: Any) -> bool:
+    @classmethod
+    def _is_connector_payload_builder(cls, func: Any) -> bool:
         """Whether *func* matches the mixin payload-builder contract."""
-        try:
-            signature = inspect.signature(func)
-        except (TypeError, ValueError):
-            return False
+        return cls._connector_payload_kwarg(func) is not None
 
-        params = signature.parameters
-        if any(param.kind == inspect.Parameter.VAR_KEYWORD for param in params.values()):
-            return True
-
-        required = {"transfer_manager", "pooling_output", "request"}
-        supported = {
-            name
-            for name, param in params.items()
-            if param.kind
-            in (
-                inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                inspect.Parameter.KEYWORD_ONLY,
-            )
-        }
-        return required.issubset(supported)
-
-    def _resolve_external_req_id(self, request: Any, fallback_req_id: str) -> str:
+    def _resolve_external_req_id(self, request: Any, fallback_req_id: str | None) -> str:
         """Resolve the external request ID consistently.
 
         Checks ``_request_ids_mapping`` first (populated by
@@ -626,7 +642,7 @@ class _OmniConnectorRuntimeMixin:
         ``external_req_id`` attribute, and finally to the given
         ``fallback_req_id``.
         """
-        mapped = self._request_ids_mapping.get(fallback_req_id)
+        mapped = self._request_ids_mapping.get(fallback_req_id) if fallback_req_id is not None else None
         if mapped is not None:
             return mapped
         if request is not None:
@@ -634,6 +650,8 @@ class _OmniConnectorRuntimeMixin:
             ext = getattr(request, "external_req_id", None)
             if ext is not None:
                 return ext
+        if fallback_req_id is None:
+            raise ValueError("Connector request has neither an external nor an internal request ID")
         return fallback_req_id
 
     def _resolve_next_stage_id(self, model_config: Any) -> int:
@@ -1073,3 +1091,67 @@ class _OmniConnectorRuntimeMixin:
     ) -> str:
         """Build connector key that includes rank info for KV transfers."""
         return f"{req_id}_{from_stage}_{chunk_id}_{from_rank}_{to_rank}"
+
+    @staticmethod
+    def _connector_payload_kwarg(func: Any) -> str | None:
+        """Resolve the model output argument used by a connector builder.
+
+        Full-payload builders historically name it ``pooling_output`` while
+        async-chunk builders name it ``multimodal_output``. Both represent the
+        runner-owned per-step inter-stage payload and share the same transport
+        contract.
+        """
+        if func is None:
+            return None
+        try:
+            signature = inspect.signature(func)
+        except (TypeError, ValueError):
+            return None
+
+        params = signature.parameters
+        if any(param.kind == inspect.Parameter.VAR_KEYWORD for param in params.values()):
+            return "pooling_output"
+
+        supported = {
+            name
+            for name, param in params.items()
+            if param.kind
+            in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+            )
+        }
+        if not {"transfer_manager", "request"}.issubset(supported):
+            return None
+        if "pooling_output" in supported:
+            return "pooling_output"
+        if "multimodal_output" in supported:
+            return "multimodal_output"
+        return None
+
+    @staticmethod
+    def _load_custom_batch_func(custom_process_func: Any | None) -> Any | None:
+        """Resolve an optional ``<scalar_builder>_batch`` peer."""
+        if custom_process_func is None:
+            return None
+        module_name = getattr(custom_process_func, "__module__", None)
+        func_name = getattr(custom_process_func, "__name__", None)
+        if not module_name or not func_name:
+            return None
+        try:
+            module = importlib.import_module(module_name)
+            batch_func = getattr(module, f"{func_name}_batch", None)
+        except ImportError:
+            logger.debug(
+                "Could not import batch connector payload builder for %s.%s",
+                module_name,
+                func_name,
+                exc_info=True,
+            )
+            return None
+        return batch_func if callable(batch_func) else None
+
+    def _create_send_completion(self, *, request_id: str, put_key: str) -> Any:
+        """Create a delivery completion; MRv2 overrides this with a ticket."""
+        del request_id, put_key
+        return _SendCompletion()
diff --git a/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py b/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py
index b801622f9..13d3dca3e 100644
--- a/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py
+++ b/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py
@@ -273,6 +273,8 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                 frozen_ids = token_ids.copy()
                 setattr(snapshot, private_name, frozen_ids)
                 setattr(snapshot, public_name, ConstantList(frozen_ids))
+                if public_name == "output_token_ids":
+                    snapshot.output_token_count = len(frozen_ids)
         return snapshot
 
     @staticmethod
@@ -878,6 +880,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
 
         if is_segment_finished:
             self.code_prompt_token_ids.pop(external_req_id, None)
+            getattr(self, "_qwen3_tts_emitted_frames", {}).pop(external_req_id, None)
             self.ramp_chunk_count.pop(external_req_id, None)
             self._adaptive_states.pop(external_req_id, None)
             cached_ic = getattr(self, "_cached_ic", None)
@@ -992,6 +995,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         self.put_req_chunk.pop(external_req_id, None)
         self.request_payload.pop(external_req_id, None)
         self.code_prompt_token_ids.pop(external_req_id, None)
+        getattr(self, "_qwen3_tts_emitted_frames", {}).pop(external_req_id, None)
         self.requests_num_chunks_sent.pop(external_req_id, None)
         self._segment_generation.pop(external_req_id, None)
         self.ramp_chunk_count.pop(external_req_id, None)
diff --git a/vllm_omni/distributed/omni_connectors/utils/config.py b/vllm_omni/distributed/omni_connectors/utils/config.py
index 176a8bf69..a646a3a30 100644
--- a/vllm_omni/distributed/omni_connectors/utils/config.py
+++ b/vllm_omni/distributed/omni_connectors/utils/config.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 from dataclasses import dataclass, field
 from typing import Any
@@ -33,7 +33,7 @@ def get_stage_connector_role(model_config: Any) -> str | None:
 
 def stage_receives_chunks(model_config: Any) -> bool:
     """Whether connector chunks, rather than the orchestrator, feed a stage."""
-    return get_stage_connector_role(model_config) != "sender"
+    return bool(getattr(model_config, "async_chunk", True)) and get_stage_connector_role(model_config) != "sender"
 
 
 def stage_sends_async_output(model_config: Any) -> bool:
diff --git a/vllm_omni/engine/__init__.py b/vllm_omni/engine/__init__.py
index a96c8027f..c36d6d986 100644
--- a/vllm_omni/engine/__init__.py
+++ b/vllm_omni/engine/__init__.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Engine components for vLLM-Omni.
 """
@@ -134,10 +137,19 @@ class OmniEngineCoreOutput(EngineCoreOutput):
     # pooling_output is inherited from EngineCoreOutput as torch.Tensor | None
     # and retains its original vLLM semantics for pooling/embedding tasks.
     multimodal_output: dict[str, torch.Tensor] | None = None
+    # Bytes-serialized carrier for a dict-shaped pooling_output (MR V2 cross-stage
+    # hidden/codec handoff). vLLM strictly decodes ``pooling_output`` as a
+    # ``torch.Tensor``, so a per-request dict payload cannot ride that field. The
+    # producer (OmniARScheduler) sets ``pooling_output=None`` and serializes the
+    # dict here; the consumer (StagePool._poll_stage_raw) rehydrates it back into
+    # ``pooling_output`` after decode. Tensor pooling outputs are unaffected.
+    pooling_output_payload: AdditionalInformationPayload | None = None
     # Finished flag for streaming input segment
     is_segment_finished: bool | None = False
     # Streaming update prompt length
     new_prompt_len_snapshot: int | None = None
+    # Authoritative segment count when the native plane suppresses token IPC.
+    num_generation_tokens: int | None = None
 
 
 class OmniEngineCoreOutputs(EngineCoreOutputs):
diff --git a/vllm_omni/engine/arg_utils.py b/vllm_omni/engine/arg_utils.py
index d1e53775a..8fb6c80e9 100644
--- a/vllm_omni/engine/arg_utils.py
+++ b/vllm_omni/engine/arg_utils.py
@@ -181,15 +181,16 @@ class OmniEngineArgs(EngineArgs):
             (e.g. ["text", "audio"]). If None, all modalities supported by
             the model are used.
         log_stats: Whether to log engine statistics. Defaults to False.
-        custom_pipeline_args: Dictionary of arguments for custom pipeline
-            initialization (e.g., ``{"pipeline_class": "my.Module"}``).
-            Passed through to the diffusion stage engine.
+        custom_pipeline_args: Dictionary of arguments passed through to the
+            diffusion pipeline. When it contains ``pipeline_class``, it triggers
+            custom pipeline initialization.
     """
 
     stage_id: int = 0
     model_stage: str = "thinker"
     model_arch: str | None = None
     engine_output_type: str | None = None
+    final_output: bool = False
     hf_config_name: str | None = None
     custom_process_next_stage_input_func: str | None = None
     requires_full_payload_input: bool = False
@@ -199,6 +200,8 @@ class OmniEngineArgs(EngineArgs):
     async_chunk: bool = False
     session_mode: str = "turn"
     retains_state_across_chunks: bool = False
+    use_v2_model_runner: bool = False
+    supports_native_mrv2_data_plane: bool = False
     # WS-A: Stage-1 active stream slots. 0 = legacy preempt-everything.
     # Must be declared here so engine_args dict propagation does not silently
     # drop the value when constructing OmniEngineArgs from kwargs.
@@ -220,6 +223,12 @@ class OmniEngineArgs(EngineArgs):
     # Diffusion request-mode batch admission (forwarded to OmniDiffusionConfig).
     request_batch_max_wait_ms: float = 0.0
     fa_deterministic: bool = False
+    # Tensor-parallel degree for the diffusion text encoder (forwarded to
+    # DiffusionParallelConfig via the generic diffusion fallback). Declared
+    # here so ``from_cli_args`` field filtering keeps ``--text-encoder-tp-size``
+    # for library callers (#7564); registered pipelines may consume it through
+    # their own stage_cli_aliases or deploy YAML.
+    text_encoder_tp_size: int | None = None
 
     @classmethod
     def _add_omni_specific_args(cls, parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
@@ -423,6 +432,8 @@ class OmniEngineArgs(EngineArgs):
             async_chunk=self.async_chunk,
             session_mode=self.session_mode,
             retains_state_across_chunks=self.retains_state_across_chunks,
+            use_v2_model_runner=self.use_v2_model_runner,
+            supports_native_mrv2_data_plane=self.supports_native_mrv2_data_plane,
             active_stream_window=self.active_stream_window,
             duplex_max_sessions=self.duplex_max_sessions,
             model_stage=self.model_stage,
@@ -430,6 +441,7 @@ class OmniEngineArgs(EngineArgs):
             worker_type=self.worker_type,
             pooling_output_decoder=self.pooling_output_decoder,
             engine_output_type=self.engine_output_type,
+            final_output=self.final_output,
             hf_config_name=self.hf_config_name,
             custom_process_next_stage_input_func=self.custom_process_next_stage_input_func,
             requires_full_payload_input=self.requires_full_payload_input,
diff --git a/vllm_omni/engine/duplex/audio.py b/vllm_omni/engine/duplex/audio.py
index 5f163826a..2d46e8edb 100644
--- a/vllm_omni/engine/duplex/audio.py
+++ b/vllm_omni/engine/duplex/audio.py
@@ -1,218 +1,44 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""Compatibility re-export: the Realtime audio codec moved out of the duplex engine.
+
+Decoding PCM / G.711 / WAV, resampling and re-encoding are wire-format work with
+no duplex session in them, so the implementation now lives in
+``vllm_omni.protocol.realtime.audio`` where a non-duplex Realtime surface can
+use it too. Duplex code reaches it through ``vllm_omni.protocol.duplex``, the
+one door the engine uses --- which is also where a duplex-specific conversion
+would be introduced. Import from there in new code.
+"""
+
 from __future__ import annotations
 
-import base64
-import binascii
-import io
-import math
-import wave
+from vllm_omni.protocol.duplex import (
+    MAX_INPUT_SAMPLE_RATE_HZ,
+    MIN_INPUT_SAMPLE_RATE_HZ,
+    convert_input_audio_with_rate,
+    convert_output_audio,
+    decode_g711_alaw,
+    decode_g711_ulaw,
+    encode_float32_mono_wav_base64,
+    encode_g711_alaw,
+    encode_g711_ulaw,
+    resample_pcm16_mono,
+    validate_input_sample_rate_hz,
+    wav_payload_to_pcm16,
+)
 
-import numpy as np
-
-from vllm_omni.utils.audio_resample import StreamingAudioResampler
-
-try:
-    from audioop import alaw2lin, lin2alaw, lin2ulaw, ulaw2lin
-except ImportError:  # pragma: no cover - audioop is removed in newer Python.
-    alaw2lin = lin2alaw = lin2ulaw = ulaw2lin = None
-
-
-MIN_INPUT_SAMPLE_RATE_HZ = 8_000
-MAX_INPUT_SAMPLE_RATE_HZ = 192_000
-
-
-def validate_input_sample_rate_hz(sample_rate_hz: object) -> int:
-    if (
-        isinstance(sample_rate_hz, bool)
-        or not isinstance(sample_rate_hz, int | float)
-        or (isinstance(sample_rate_hz, float) and not math.isfinite(sample_rate_hz))
-    ):
-        raise ValueError("sample_rate_hz must be a finite integer")
-    rate = int(sample_rate_hz)
-    if rate != sample_rate_hz:
-        raise ValueError("sample_rate_hz must be an integer")
-    if not MIN_INPUT_SAMPLE_RATE_HZ <= rate <= MAX_INPUT_SAMPLE_RATE_HZ:
-        raise ValueError(f"sample_rate_hz must be between {MIN_INPUT_SAMPLE_RATE_HZ} and {MAX_INPUT_SAMPLE_RATE_HZ}")
-    return rate
-
-
-def resample_pcm16_mono(raw: bytes, *, source_rate_hz: int, target_rate_hz: int) -> bytes:
-    if source_rate_hz <= 0 or target_rate_hz <= 0 or source_rate_hz == target_rate_hz:
-        return raw
-    samples = np.frombuffer(raw, dtype="<i2")
-    rate_gcd = math.gcd(source_rate_hz, target_rate_hz)
-    reduced_factor = max(source_rate_hz // rate_gcd, target_rate_hz // rate_gcd)
-    if reduced_factor > StreamingAudioResampler.max_polyphase_factor:
-        # The FIR size scales with the reduced ratio. Keep unusual client
-        # rates bounded while common audio rates use the high-quality path.
-        if samples.size <= 1:
-            return raw
-        target_size = max(1, int(round(samples.size * target_rate_hz / source_rate_hz)))
-        source_x = np.linspace(0.0, 1.0, num=samples.size, endpoint=True)
-        target_x = np.linspace(0.0, 1.0, num=target_size, endpoint=True)
-        resampled = np.interp(target_x, source_x, samples)
-        return np.clip(resampled, -32_768, 32_767).astype("<i2").tobytes()
-    resampler = StreamingAudioResampler(source_rate_hz, target_rate_hz)
-    normalized = samples.astype(np.float32) * np.float32(1.0 / 32768.0)
-    resampled = resampler.process(normalized, final=True)
-    return np.clip(np.rint(resampled * 32768.0), -32768, 32767).astype("<i2").tobytes()
-
-
-def decode_g711_ulaw(raw: bytes) -> bytes:
-    if ulaw2lin is not None:
-        return ulaw2lin(raw, 2)
-    data = np.frombuffer(raw, dtype=np.uint8)
-    value = np.bitwise_not(data).astype(np.int16)
-    sign = value & 0x80
-    exponent = (value >> 4) & 0x07
-    mantissa = value & 0x0F
-    sample = ((mantissa << 3) + 0x84) << exponent
-    return np.where(sign != 0, -(sample - 0x84), sample - 0x84).astype("<i2").tobytes()
-
-
-def decode_g711_alaw(raw: bytes) -> bytes:
-    if alaw2lin is not None:
-        return alaw2lin(raw, 2)
-    data = np.bitwise_xor(np.frombuffer(raw, dtype=np.uint8), 0x55).astype(np.int16)
-    sign = data & 0x80
-    exponent = (data >> 4) & 0x07
-    mantissa = data & 0x0F
-    sample = np.where(exponent == 0, (mantissa << 4) + 8, ((mantissa << 4) + 0x108) << (exponent - 1))
-    return np.where(sign != 0, sample, -sample).astype("<i2").tobytes()
-
-
-def encode_g711_ulaw(raw: bytes) -> bytes:
-    if lin2ulaw is not None:
-        return lin2ulaw(raw, 2)
-    pcm = np.clip(np.frombuffer(raw, dtype="<i2").astype(np.int32), -32635, 32635)
-    sign = np.where(pcm < 0, 0x80, 0)
-    magnitude = np.abs(pcm) + 0x84
-    exponent = np.zeros_like(magnitude)
-    for exp in range(7):
-        exponent = np.where(magnitude > (0xFF << exp), exp + 1, exponent)
-    mantissa = (magnitude >> (exponent + 3)) & 0x0F
-    return (np.bitwise_not(sign | (exponent << 4) | mantissa) & 0xFF).astype(np.uint8).tobytes()
-
-
-def encode_g711_alaw(raw: bytes) -> bytes:
-    if lin2alaw is not None:
-        return lin2alaw(raw, 2)
-    pcm = np.frombuffer(raw, dtype="<i2").astype(np.int32)
-    sign = np.where(pcm >= 0, 0x80, 0x00)
-    magnitude = np.abs(pcm)
-    exponent = np.zeros_like(magnitude)
-    for exp in range(1, 8):
-        exponent = np.where(magnitude >= (1 << (exp + 7)), exp, exponent)
-    mantissa = np.where(
-        exponent == 0,
-        (magnitude >> 4) & 0x0F,
-        (magnitude >> (exponent + 3)) & 0x0F,
-    )
-    return ((sign | (exponent << 4) | mantissa) ^ 0x55).astype(np.uint8).tobytes()
-
-
-def wav_payload_to_pcm16(raw: bytes) -> tuple[bytes | None, int | None]:
-    try:
-        with wave.open(io.BytesIO(raw), "rb") as wav_file:
-            channels = wav_file.getnchannels()
-            sample_width = wav_file.getsampwidth()
-            sample_rate_hz = wav_file.getframerate()
-            frames = wav_file.readframes(wav_file.getnframes())
-        if sample_width != 2:
-            return None, sample_rate_hz
-        if channels <= 1:
-            return frames, sample_rate_hz
-        pcm = np.frombuffer(frames, dtype="<i2").reshape(-1, channels)
-        mono = np.mean(pcm.astype(np.float32), axis=1)
-        return np.clip(mono, -32768, 32767).astype("<i2").tobytes(), sample_rate_hz
-    except (EOFError, ValueError, wave.Error):
-        return None, None
-
-
-def encode_float32_mono_wav_base64(
-    samples: np.ndarray,
-    *,
-    sample_rate_hz: int,
-) -> str:
-    """Package normalized mono float32 samples as a PCM16 WAV data payload."""
-    rate = validate_input_sample_rate_hz(sample_rate_hz)
-    normalized = np.ascontiguousarray(samples, dtype=np.float32).reshape(-1)
-    pcm16 = np.clip(np.rint(normalized * 32768.0), -32768, 32767).astype("<i2")
-    with io.BytesIO() as buffer:
-        with wave.open(buffer, "wb") as wav_file:
-            wav_file.setnchannels(1)
-            wav_file.setsampwidth(2)
-            wav_file.setframerate(rate)
-            wav_file.writeframes(pcm16.tobytes())
-        return base64.b64encode(buffer.getvalue()).decode("ascii")
-
-
-def convert_input_audio_with_rate(
-    audio: object,
-    fmt: object,
-    *,
-    sample_rate_hz: int | float | None = None,
-    target_sample_rate_hz: int = 16_000,
-) -> tuple[object, object, int | float | None]:
-    if not isinstance(audio, str) or not isinstance(fmt, str):
-        return audio, fmt, sample_rate_hz
-    normalized = fmt.lower()
-    if normalized not in {"pcm16", "pcm_s16le", "s16le", "g711_ulaw", "g711_alaw"}:
-        return audio, fmt, sample_rate_hz
-    if isinstance(sample_rate_hz, int | float):
-        sample_rate_hz = validate_input_sample_rate_hz(sample_rate_hz)
-    try:
-        raw = base64.b64decode(audio.strip(), validate=False)
-    except (binascii.Error, ValueError):
-        return audio, fmt, sample_rate_hz
-    if normalized == "g711_ulaw":
-        raw = decode_g711_ulaw(raw)
-        sample_rate_hz = sample_rate_hz if isinstance(sample_rate_hz, int | float) else 8_000
-    elif normalized == "g711_alaw":
-        raw = decode_g711_alaw(raw)
-        sample_rate_hz = sample_rate_hz if isinstance(sample_rate_hz, int | float) else 8_000
-    elif len(raw) % 2:
-        return audio, fmt, sample_rate_hz
-    if isinstance(sample_rate_hz, int | float) and int(sample_rate_hz) != target_sample_rate_hz:
-        raw = resample_pcm16_mono(
-            raw,
-            source_rate_hz=int(sample_rate_hz),
-            target_rate_hz=target_sample_rate_hz,
-        )
-        sample_rate_hz = target_sample_rate_hz
-    pcm = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
-    encoded = base64.b64encode(np.ascontiguousarray(pcm, dtype="<f4").tobytes()).decode("ascii")
-    return encoded, "pcm_f32le", sample_rate_hz
-
-
-def convert_output_audio(
-    audio: str,
-    *,
-    source_fmt: str,
-    target_fmt: str,
-    source_sample_rate_hz: int | None = None,
-    target_sample_rate_hz: int | None = None,
-) -> tuple[str, str, int | None]:
-    target = target_fmt.lower()
-    if target not in {"g711_ulaw", "g711_alaw"}:
-        return audio, source_fmt, source_sample_rate_hz
-    try:
-        raw = base64.b64decode(audio, validate=False)
-    except (binascii.Error, ValueError):
-        return audio, source_fmt, source_sample_rate_hz
-    source = source_fmt.lower()
-    if source == "wav":
-        pcm_raw, wav_rate = wav_payload_to_pcm16(raw)
-        if pcm_raw is None:
-            return audio, source_fmt, source_sample_rate_hz
-        raw = pcm_raw
-        source_sample_rate_hz = source_sample_rate_hz or wav_rate
-    elif source not in {"pcm", "pcm16", "pcm_s16le", "s16le"} or len(raw) % 2:
-        return audio, source_fmt, source_sample_rate_hz
-    target_rate = target_sample_rate_hz or 8_000
-    if source_sample_rate_hz is not None:
-        raw = resample_pcm16_mono(raw, source_rate_hz=source_sample_rate_hz, target_rate_hz=target_rate)
-    encoded = encode_g711_ulaw(raw) if target == "g711_ulaw" else encode_g711_alaw(raw)
-    return base64.b64encode(encoded).decode("ascii"), target, target_rate
+__all__ = [
+    "MAX_INPUT_SAMPLE_RATE_HZ",
+    "MIN_INPUT_SAMPLE_RATE_HZ",
+    "convert_input_audio_with_rate",
+    "convert_output_audio",
+    "decode_g711_alaw",
+    "decode_g711_ulaw",
+    "encode_float32_mono_wav_base64",
+    "encode_g711_alaw",
+    "encode_g711_ulaw",
+    "resample_pcm16_mono",
+    "validate_input_sample_rate_hz",
+    "wav_payload_to_pcm16",
+]
diff --git a/vllm_omni/engine/duplex/commands.py b/vllm_omni/engine/duplex/commands.py
index 90d48d050..19674948c 100644
--- a/vllm_omni/engine/duplex/commands.py
+++ b/vllm_omni/engine/duplex/commands.py
@@ -1,41 +1,62 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Typed commands accepted by a duplex session.
+"""The command vocabulary one duplex session accepts, plus its mailbox rendering.
 
 ``DuplexSessionHandle.submit()`` takes one of these; the websocket handler and
-``InlineDuplexClient`` build them with :func:`command_from_realtime` from the
-OpenAI Realtime client event vocabulary. Every command can also render the
-session-internal mailbox payload (``payload()``), which is the dictionary
-vocabulary the session runner bodies were written against.
+``InlineDuplexClient`` build them with :func:`command_from_realtime`.
+
+The *wire* half of each command --- which client event it decodes from and what
+fields survive decoding --- now lives in ``vllm_omni.protocol.duplex.commands``,
+which carries the whole vocabulary: the eight Tier 1 classes re-exported from
+``vllm_omni.protocol.realtime.commands``, the two Tier 2 ones and the seven
+Tier 3 ones. The engine imports that module and never the Tier 1 one directly,
+so a command that later grows a duplex extension changes one file
+(RFC #6592 P0a).
+
+The *engine* half stays here, because it is not wire contract at all:
+``payload()`` renders the session-internal mailbox dictionary the runner bodies
+were written against, and its ``type`` is the mailbox channel rather than the
+client event. Those two genuinely differ --- ``session.update`` and
+``conversation.item.create`` / ``.delete`` / ``.truncate`` all travel on the
+``turn.signal`` channel --- which is why the halves are separated instead of
+the classes being relocated wholesale.
 """
 
 from __future__ import annotations
 
 import base64
 from collections.abc import Mapping
-from dataclasses import dataclass, field, fields
+from dataclasses import dataclass, fields
 from typing import TYPE_CHECKING, ClassVar
 
+from vllm_omni.protocol.duplex import RealtimeProtocolError
+from vllm_omni.protocol.duplex import commands as _duplex_wire
+from vllm_omni.protocol.duplex.commands import RealtimeCommand
+
 if TYPE_CHECKING:
-    from vllm_omni.engine.duplex.realtime_commands import RealtimeInputDefaults
+    from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
 
-class DuplexCommandError(ValueError):
-    """A client payload could not be turned into a command."""
+class DuplexCommandError(RealtimeProtocolError):
+    """A client payload could not be turned into a duplex command.
 
-    def __init__(self, message: str, *, code: str = "bad_event", event_id: str | None = None) -> None:
-        super().__init__(message)
-        self.code = code
-        self.event_id = event_id
+    The duplex name for a Realtime protocol error: same ``code`` /
+    ``event_id`` contract, so the error envelope is rendered identically
+    whichever consumer raised it.
+    """
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class DuplexCommand:
+class DuplexCommand(RealtimeCommand):
+    """A Realtime command as the duplex engine handles it.
+
+    Adds the mailbox channel (``type``) and its rendering on top of the wire
+    command; every concrete class below pairs this with its protocol twin.
+    """
+
     #: Mailbox event type this command renders to (see ``payload()``).
     type: ClassVar[str] = ""
-    #: Client correlation id (OpenAI ``event_id``), echoed on error events.
-    event_id: str | None = None
 
     def payload(self) -> dict[str, object]:
         """Render the session-internal mailbox dictionary."""
@@ -56,19 +77,23 @@ class DuplexCommand:
         return data
 
 
+# ---- GA commands ----
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
-class AppendAudio(DuplexCommand):
+class UpdateSession(DuplexCommand, _duplex_wire.UpdateSession):
+    type: ClassVar[str] = "turn.signal"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        data["event"] = "session.update"
+        data["payload"] = dict(data.pop("patch", {}) or {})
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AppendAudio(DuplexCommand, _duplex_wire.AppendAudio):
     type: ClassVar[str] = "input_audio_buffer.append"
-    #: Raw audio bytes in ``format`` at ``sample_rate_hz`` (base64 only on the wire).
-    audio: bytes
-    format: str = "pcm16"
-    sample_rate_hz: int | None = None
-    is_speech: bool | None = None
-    video_frames: tuple[str, ...] = ()
-    duration_ms: int | None = None
-    audio_end_ms: int | None = None
-    #: Model-neutral hints carried through from the wire (rms, vad, transcript hints ...).
-    hints: Mapping[str, object] = field(default_factory=dict)
 
     def payload(self) -> dict[str, object]:
         data = DuplexCommand.payload(self)
@@ -90,21 +115,8 @@ class AppendAudio(DuplexCommand):
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class AppendText(DuplexCommand):
-    type: ClassVar[str] = "input.text.append"
-    text: str
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class Commit(DuplexCommand):
+class Commit(DuplexCommand, _duplex_wire.Commit):
     type: ClassVar[str] = "input_audio_buffer.commit"
-    final: bool = True
-    #: ``None`` means "no explicit request": the runner decides on commit (auto-response
-    #: sessions answer on their own); ``True`` / ``False`` force it.
-    create_response: bool | None = None
-    is_speech: bool | None = None
-    #: Realtime conversation item created for this commit (wire correlation only).
-    realtime_item_id: str | None = None
 
     def payload(self) -> dict[str, object]:
         data = DuplexCommand.payload(self)
@@ -114,10 +126,18 @@ class Commit(DuplexCommand):
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class CreateResponse(DuplexCommand):
+class ClearInput(DuplexCommand, _duplex_wire.ClearInput):
+    type: ClassVar[str] = "input_audio_buffer.clear"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ClearOutputAudio(DuplexCommand, _duplex_wire.ClearOutputAudio):
+    type: ClassVar[str] = "output_audio_buffer.clear"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateResponse(DuplexCommand, _duplex_wire.CreateResponse):
     type: ClassVar[str] = "response.create"
-    #: Raw Realtime ``response`` object (instructions, voice, modalities, ...).
-    options: Mapping[str, object] = field(default_factory=dict)
 
     def payload(self) -> dict[str, object]:
         data = DuplexCommand.payload(self)
@@ -128,84 +148,13 @@ class CreateResponse(DuplexCommand):
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class ClearInput(DuplexCommand):
-    type: ClassVar[str] = "input_audio_buffer.clear"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class CancelInput(DuplexCommand):
-    type: ClassVar[str] = "input.cancel"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class CancelResponse(DuplexCommand):
+class CancelResponse(DuplexCommand, _duplex_wire.CancelResponse):
     type: ClassVar[str] = "response.cancel"
-    response_id: str | None = None
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class BargeIn(DuplexCommand):
-    type: ClassVar[str] = "barge_in"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ClearOutputAudio(DuplexCommand):
-    type: ClassVar[str] = "output_audio_buffer.clear"
-    #: Explicit response to clear; ``None`` targets the active/last response.
-    response_id: str | None = None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SignalTurn(DuplexCommand):
-    """Generic ``turn.signal`` (local turn transitions such as ``user_started``)."""
-
+class CreateItem(DuplexCommand, _duplex_wire.CreateItem):
     type: ClassVar[str] = "turn.signal"
-    event: str
-    signal_payload: Mapping[str, object] = field(default_factory=dict)
-
-    def payload(self) -> dict[str, object]:
-        data = DuplexCommand.payload(self)
-        signal_payload = data.pop("signal_payload", None)
-        if isinstance(signal_payload, Mapping) and signal_payload:
-            data["payload"] = dict(signal_payload)
-        return data
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class UpdateSession(DuplexCommand):
-    """``session.update``: a Realtime ``session`` object patch."""
-
-    type: ClassVar[str] = "turn.signal"
-    patch: Mapping[str, object] = field(default_factory=dict)
-
-    def payload(self) -> dict[str, object]:
-        data = DuplexCommand.payload(self)
-        data["event"] = "session.update"
-        data["payload"] = dict(data.pop("patch", {}) or {})
-        return data
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class AckPlayback(DuplexCommand):
-    type: ClassVar[str] = "playback.ack"
-    played_ms: int
-    committed_ms: int | None = None
-    response_id: str | None = None
-    item_id: str | None = None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class Heartbeat(DuplexCommand):
-    type: ClassVar[str] = "session.heartbeat"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class CreateItem(DuplexCommand):
-    """``conversation.item.create`` (history injection or function-call output)."""
-
-    type: ClassVar[str] = "turn.signal"
-    item: Mapping[str, object]
-    previous_item_id: str | None = None
 
     def payload(self) -> dict[str, object]:
         data = DuplexCommand.payload(self)
@@ -219,9 +168,8 @@ class CreateItem(DuplexCommand):
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class DeleteItem(DuplexCommand):
+class DeleteItem(DuplexCommand, _duplex_wire.DeleteItem):
     type: ClassVar[str] = "turn.signal"
-    item_id: str
 
     def payload(self) -> dict[str, object]:
         data = DuplexCommand.payload(self)
@@ -231,11 +179,8 @@ class DeleteItem(DuplexCommand):
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
-class TruncateItem(DuplexCommand):
+class TruncateItem(DuplexCommand, _duplex_wire.TruncateItem):
     type: ClassVar[str] = "turn.signal"
-    item_id: str
-    audio_end_ms: int
-    content_index: int = 0
 
     def payload(self) -> dict[str, object]:
         data = DuplexCommand.payload(self)
@@ -248,15 +193,51 @@ class TruncateItem(DuplexCommand):
         return data
 
 
+# ---- duplex extension commands ----
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
-class CloseSession(DuplexCommand):
-    """Graceful close requested through the command stream (``session.close``)."""
+class AppendText(DuplexCommand, _duplex_wire.AppendText):
+    type: ClassVar[str] = "input.text.append"
 
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CancelInput(DuplexCommand, _duplex_wire.CancelInput):
+    type: ClassVar[str] = "input.cancel"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class BargeIn(DuplexCommand, _duplex_wire.BargeIn):
+    type: ClassVar[str] = "barge_in"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SignalTurn(DuplexCommand, _duplex_wire.SignalTurn):
+    type: ClassVar[str] = "turn.signal"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        signal_payload = data.pop("signal_payload", None)
+        if isinstance(signal_payload, Mapping) and signal_payload:
+            data["payload"] = dict(signal_payload)
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AckPlayback(DuplexCommand, _duplex_wire.AckPlayback):
+    type: ClassVar[str] = "playback.ack"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Heartbeat(DuplexCommand, _duplex_wire.Heartbeat):
+    type: ClassVar[str] = "session.heartbeat"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CloseSession(DuplexCommand, _duplex_wire.CloseSession):
     type: ClassVar[str] = "session.close"
-    reason: str = "client_close"
 
 
-#: Realtime client event types that map onto commands (wire vocabulary).
 REALTIME_COMMAND_TYPES: frozenset[str] = frozenset(
     {
         "input_audio_buffer.append",
@@ -300,7 +281,6 @@ def command_from_realtime(
 
 
 __all__ = [
-    "REALTIME_COMMAND_TYPES",
     "AckPlayback",
     "AppendAudio",
     "AppendText",
@@ -317,6 +297,8 @@ __all__ = [
     "DuplexCommand",
     "DuplexCommandError",
     "Heartbeat",
+    "REALTIME_COMMAND_TYPES",
+    "RealtimeCommand",
     "SignalTurn",
     "TruncateItem",
     "UpdateSession",
diff --git a/vllm_omni/engine/duplex/config.py b/vllm_omni/engine/duplex/config.py
index aab0fb1c5..f343a5233 100644
--- a/vllm_omni/engine/duplex/config.py
+++ b/vllm_omni/engine/duplex/config.py
@@ -111,6 +111,8 @@ class DuplexCapabilities:
     #: seeding a text prompt has no representation and the turn never
     #: completes. ``text_turn_priming_units`` is how many silence units such a
     #: seeded turn must be given to generate on -- it still speaks per unit.
+    supports_image_input: bool = False
+    supports_text_only_turn: bool = False
     supports_chat_completions: bool = False
     text_turn_priming_units: int = 0
     requires_model_runner_kv: bool = False
@@ -149,11 +151,13 @@ class DuplexCapabilities:
             "supports_session_resume": self.supports_session_resume,
             "session_admission_mode": self.session_admission_mode,
             "supports_audio_truncate": self.supports_audio_truncate,
+            "supports_image_input": self.supports_image_input,
+            "supports_text_only_turn": self.supports_text_only_turn,
             "requires_model_runner_kv": self.requires_model_runner_kv,
             "requires_native_stage_role": self.requires_native_stage_role,
-            # Every duplex model is model-native and appends audio chunks (§7 D4);
-            # kept on the wire as constants for clients that still read them.
-            "implementation_level": "model_native_duplex",
+            "implementation_level": (
+                "model_native_duplex" if self.supports_model_native_turn_policy else "turn_based_duplex"
+            ),
             "adapter_patterns": self.adapter_patterns,
             "input_modes": ["append_audio_chunk"],
             "signal_sources": self.signal_sources,
@@ -169,6 +173,8 @@ class DuplexPlaybackCursor:
     sent_ms: int = 0
     played_ms: int = 0
     committed_ms: int = 0
+    text_requires_complete_audio: bool = False
+    audio_complete: bool = False
 
     def acknowledge(self, played_ms: int, committed_ms: int | None = None) -> None:
         self.played_ms = max(self.played_ms, max(0, int(played_ms)))
@@ -188,7 +194,11 @@ class DuplexPlaybackCursor:
         }
 
     def snapshot(self) -> DuplexPlaybackView:
-        return DuplexPlaybackView(**self.as_dict())
+        return DuplexPlaybackView(
+            **self.as_dict(),
+            text_requires_complete_audio=self.text_requires_complete_audio,
+            audio_complete=self.audio_complete,
+        )
 
 
 @dataclass(frozen=True, slots=True)
@@ -197,6 +207,8 @@ class DuplexPlaybackView:
     sent_ms: int = 0
     played_ms: int = 0
     committed_ms: int = 0
+    text_requires_complete_audio: bool = False
+    audio_complete: bool = False
 
     def as_dict(self) -> dict[str, int]:
         return {
@@ -310,16 +322,21 @@ class DuplexSessionConfig:
         if isinstance(source.get("extra_body"), dict):
             config.extra_body = dict(source["extra_body"])
             extra = config.extra_body
-            if isinstance(extra.get("overlap_policy"), str):
-                config.overlap_policy = cls._normalize_overlap_policy(extra["overlap_policy"])
-            if isinstance(extra.get("overlap_short_ack_ms"), int | float):
-                config.overlap_short_ack_ms = max(0, int(extra["overlap_short_ack_ms"]))
-            if isinstance(extra.get("overlap_barge_in_ms"), int | float):
-                config.overlap_barge_in_ms = max(0, int(extra["overlap_barge_in_ms"]))
-            if isinstance(extra.get("overlap_silence_rms"), int | float):
-                config.overlap_silence_rms = max(0.0, float(extra["overlap_silence_rms"]))
-            if isinstance(extra.get("playback_commit_policy"), str):
-                config.playback_commit_policy = cls._normalize_playback_commit_policy(extra["playback_commit_policy"])
+            overlap_policy = extra.get("overlap_policy")
+            if isinstance(overlap_policy, str):
+                config.overlap_policy = cls._normalize_overlap_policy(overlap_policy)
+            short_ack_ms = extra.get("overlap_short_ack_ms")
+            if isinstance(short_ack_ms, int | float):
+                config.overlap_short_ack_ms = max(0, int(short_ack_ms))
+            barge_in_ms = extra.get("overlap_barge_in_ms")
+            if isinstance(barge_in_ms, int | float):
+                config.overlap_barge_in_ms = max(0, int(barge_in_ms))
+            silence_rms = extra.get("overlap_silence_rms")
+            if isinstance(silence_rms, int | float):
+                config.overlap_silence_rms = max(0.0, float(silence_rms))
+            playback_commit_policy = extra.get("playback_commit_policy")
+            if isinstance(playback_commit_policy, str):
+                config.playback_commit_policy = cls._normalize_playback_commit_policy(playback_commit_policy)
         return config
 
     @classmethod
@@ -339,26 +356,26 @@ class DuplexSessionConfig:
         ``_session_create_from_realtime``.
         """
         from vllm_omni.engine.duplex.realtime_commands import (
-            RealtimeInputDefaults,
+            DUPLEX_REALTIME_CAPABILITIES,
             duplex_response_format,
+        )
+        from vllm_omni.engine.duplex.turn_detection import normalize_turn_detection_session_payload
+        from vllm_omni.protocol.duplex import (
+            RealtimeInputDefaults,
             input_audio_transcription_config,
             json_safe_realtime_payload,
             realtime_max_output_tokens,
             realtime_overlap_fields,
-            validate_realtime_session_audio_formats,
-        )
-        from vllm_omni.engine.duplex.turn_detection import (
-            normalize_turn_detection_session_payload,
-            validate_realtime_turn_detection,
+            validate_session_payload,
         )
 
         payload: dict[str, object] = dict(session_payload)
-        format_error = validate_realtime_session_audio_formats(payload)
-        if format_error is not None:
-            raise DuplexConfigError(format_error, code="unsupported_audio_format")
-        turn_detection_error = validate_realtime_turn_detection(payload)
-        if turn_detection_error is not None:
-            raise DuplexConfigError(turn_detection_error, code="unsupported_turn_detection", param="turn_detection")
+        # One session check for every consumer (ENTRY-INV-002): the same
+        # capability object ``translate_realtime_command`` uses, so a session
+        # object is accepted or refused identically whichever door it came in.
+        rejection = validate_session_payload(payload, capabilities=DUPLEX_REALTIME_CAPABILITIES)
+        if rejection is not None:
+            raise DuplexConfigError(rejection.message, code=rejection.code, param=rejection.param)
         normalize_turn_detection_session_payload(payload)
         defaults = RealtimeInputDefaults().with_session_payload(payload)
         payload.update(realtime_overlap_fields(payload))
@@ -446,9 +463,9 @@ class DuplexSessionConfig:
         when the patch changes something a live session cannot change.
         ``audio_started`` is ``playback.generated_ms > 0 or playback.sent_ms > 0``.
         """
-        from vllm_omni.engine.duplex.realtime_commands import (
+        from vllm_omni.engine.duplex.realtime_commands import duplex_response_format
+        from vllm_omni.protocol.duplex import (
             REALTIME_OUTPUT_AUDIO_FORMATS,
-            duplex_response_format,
             input_audio_transcription_config,
             json_safe_realtime_payload,
             parse_realtime_audio_format,
@@ -629,11 +646,10 @@ class ResponseCreateOptions:
         for options a model-native duplex session cannot apply per response.
         Private runtime keys in ``extra_body`` are dropped.
         """
-        from vllm_omni.engine.duplex.realtime_commands import (
+        from vllm_omni.engine.duplex.realtime_commands import duplex_response_format
+        from vllm_omni.protocol.duplex import (
             REALTIME_OUTPUT_AUDIO_FORMATS,
-            duplex_response_format,
             parse_realtime_audio_format,
-            realtime_max_output_tokens,
         )
 
         payload: dict[str, object] = dict(response_payload)
@@ -665,11 +681,12 @@ class ResponseCreateOptions:
         response_format = payload.get("output_audio_format") or payload.get("response_format")
         if response_format is None and isinstance(audio_output, dict):
             response_format = audio_output.get("format")
-        response_format, _ = parse_realtime_audio_format(response_format)
-        if isinstance(response_format, str) and response_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
-            response_format = duplex_response_format(response_format)
+        parsed_format, _ = parse_realtime_audio_format(response_format)
+        output_audio_format: str | None
+        if isinstance(parsed_format, str) and parsed_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
+            output_audio_format = str(duplex_response_format(parsed_format))
         else:
-            response_format = None
+            output_audio_format = None
         temperature = (
             float(cast("int | float", payload["temperature"]))
             if isinstance(payload.get("temperature"), int | float)
@@ -687,9 +704,9 @@ class ResponseCreateOptions:
             else payload.get("max_tokens")
         )
         if "max_response_output_tokens" in payload or "max_output_tokens" in payload or "max_tokens" in payload:
-            max_tokens = realtime_max_output_tokens(max_tokens)
+            token_limit = realtime_max_output_tokens(max_tokens)
         else:
-            max_tokens = None
+            token_limit = None
         modalities = payload.get("modalities") or payload.get("output_modalities")
         if isinstance(modalities, list) and all(isinstance(item, str) for item in modalities):
             modalities = tuple(modalities)
@@ -717,9 +734,9 @@ class ResponseCreateOptions:
         return cls(
             instructions=instructions,
             voice=voice,
-            response_format=response_format,
+            response_format=output_audio_format,
             temperature=temperature,
-            max_tokens=max_tokens,
+            max_tokens=token_limit,
             speed=speed,
             modalities=modalities,
             extra_body=response_extra,
@@ -761,6 +778,8 @@ def realtime_item_to_history_message(item: object) -> dict[str, object] | None:
         part_type = part.get("type")
         if part_type in {"input_text", "text", "output_text"} and isinstance(part.get("text"), str):
             text_chunks.append(str(part["text"]))
+        elif part_type == "input_image" and isinstance(part.get("image_url"), str):
+            audio_chunks.append({"type": "image_url", "image_url": {"url": part["image_url"]}})
         elif part_type in {"input_audio", "audio"}:
             audio = part.get("audio") or part.get("data")
             fmt = part.get("format") if isinstance(part.get("format"), str) else "wav"
@@ -782,14 +801,14 @@ def realtime_item_to_history_message(item: object) -> dict[str, object] | None:
 
 def realtime_max_output_tokens(value: object) -> int | None:
     """Normalize Realtime max output tokens (``"inf"`` -> ``None``)."""
-    from vllm_omni.engine.duplex.realtime_commands import realtime_max_output_tokens as _impl
+    from vllm_omni.protocol.duplex import realtime_max_output_tokens as _impl
 
     return _impl(value)
 
 
 def input_audio_transcription_config(session_payload: Mapping[str, object]) -> dict[str, object] | None:
     """Return the ``input_audio_transcription`` object of a Realtime session payload."""
-    from vllm_omni.engine.duplex.realtime_commands import input_audio_transcription_config as _impl
+    from vllm_omni.protocol.duplex import input_audio_transcription_config as _impl
 
     return _impl(session_payload)
 
diff --git a/vllm_omni/engine/duplex/events.py b/vllm_omni/engine/duplex/events.py
index 9c131a893..197dec613 100644
--- a/vllm_omni/engine/duplex/events.py
+++ b/vllm_omni/engine/duplex/events.py
@@ -1,677 +1,79 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Typed events emitted by a duplex session.
+"""The event vocabulary one duplex session speaks, assembled from two layers.
 
-Every public event is a frozen dataclass with explicit fields. The Realtime
-wire JSON is *derived* from those fields by :meth:`DuplexEvent.to_realtime`,
-which is pure: it never consults session state. The stateful part (response /
-item ids, content-part bookkeeping) lives in
-``vllm_omni.engine.duplex.realtime_events`` on the session runner and is
-consumed when the events are *constructed*.
+The classes themselves no longer live here. ``vllm_omni.protocol.duplex.events``
+carries the whole vocabulary --- 22 Tier 1 classes re-exported from
+``vllm_omni.protocol.realtime.events``, 8 Tier 2 ones and 12 Tier 3 ones --- so
+a non-duplex Realtime consumer can take the Tier 1 half and its wire rendering
+without the duplex session control plane (RFC #6592 P0a). The engine imports
+the duplex module and never the Tier 1 one directly.
 
-``session_id`` / ``epoch`` are bound by
-``DuplexSessionManager.emit`` when an event leaves the runner; producers
-(projector, serving handshake helpers) build events with the defaults.
+What is genuinely engine-side stays: :data:`DOMAIN_TERMINAL_EVENTS` and
+:data:`MODEL_OUTPUT_EVENTS` are the session runner's epoch-filter policy, not
+wire contract --- they name *internal* event types, and which of them may never
+be dropped as stale is a runtime decision.
+
+``DuplexEvent`` is re-exported as the name the engine and the clients already
+use. It is an alias of
+:class:`~vllm_omni.protocol.realtime.events.RealtimeEvent`, not a subclass,
+because an event has no engine-internal half --- what the session emits is
+exactly what the socket sends. A *command* does have one (``payload()`` renders
+the runner's mailbox), which is why ``DuplexCommand`` is a real class.
 """
 
 from __future__ import annotations
 
-import base64
-from collections.abc import Mapping
-from dataclasses import dataclass, field, fields
-from typing import ClassVar, cast
-from uuid import uuid4
+from vllm_omni.protocol.duplex.errors import REALTIME_ERROR_TYPES_BY_CODE
+from vllm_omni.protocol.duplex.events import (
+    AudioDelta,
+    AudioDone,
+    ContentPartAdded,
+    ContentPartDone,
+    DuplexEvent,
+    DuplexRawEvent,
+    ErrorEvent,
+    FunctionCallArgumentsDelta,
+    FunctionCallArgumentsDone,
+    InputCleared,
+    InputCommitted,
+    InputTranscriptionCompleted,
+    ItemAdded,
+    ItemCreated,
+    ItemDeleted,
+    ItemDone,
+    ItemRetrieved,
+    ItemTruncated,
+    Listen,
+    OutputAudioCleared,
+    OutputItemAdded,
+    OutputItemDone,
+    OverlapDecision,
+    PlaybackAcknowledged,
+    RateLimitsUpdated,
+    ResponseCreated,
+    ResponseDone,
+    SessionClosed,
+    SessionCreated,
+    SessionExpired,
+    SessionHeartbeatAck,
+    SessionReplaced,
+    SessionResumed,
+    SessionResyncRequired,
+    SessionUpdated,
+    Speak,
+    SpeechStarted,
+    SpeechStopped,
+    TextDelta,
+    TextDone,
+    TranscriptDelta,
+    TranscriptDone,
+    TurnEvent,
+    error_event,
+    new_event_id,
+)
 
-
-def new_event_id() -> str:
-    return f"event_{uuid4().hex}"
-
-
-#: OpenAI Realtime ``error.type`` for each internal error code.
-REALTIME_ERROR_TYPES_BY_CODE: dict[str, str] = {
-    "bad_event": "invalid_request_error",
-    "bad_audio": "invalid_request_error",
-    "config_timeout": "invalid_request_error",
-    "invalid_json": "invalid_request_error",
-    "event_too_large": "invalid_request_error",
-    "unknown_event": "invalid_request_error",
-    "internal_error": "server_error",
-    "runtime_append_failed": "server_error",
-    "runtime_append_task_failed": "server_error",
-    "runtime_signal_failed": "server_error",
-    "runtime_abort_failed": "server_error",
-    "runtime_data_plane_stream_failed": "server_error",
-    "runtime_data_plane_text_without_audio": "server_error",
-    "resource_exhausted": "rate_limit_error",
-    "session_exists": "invalid_request_error",
-    "session_closed": "invalid_request_error",
-    "unknown_session": "invalid_request_error",
-    "invalid_duplex_runtime_config": "invalid_request_error",
-    "instructions_update_unsupported": "invalid_request_error",
-    "persona_update_unsupported": "invalid_request_error",
-    "voice_update_unsupported": "invalid_request_error",
-    "unsupported_nemotron_duplex_mode": "invalid_request_error",
-    "unsupported_native_response_options": "invalid_request_error",
-    "runtime_touch_failed": "server_error",
-    "engine_error": "server_error",
-    "input_backpressure": "rate_limit_error",
-    "response_already_active": "invalid_request_error",
-    "response_not_active": "invalid_request_error",
-    "response_create_without_input": "invalid_request_error",
-    "text_only_turn_unsupported": "invalid_request_error",
-    "commit_aborted": "server_error",
-    "input_audio_buffer_empty": "invalid_request_error",
-    "missing_item_id": "invalid_request_error",
-    "item_not_found": "invalid_request_error",
-    "playback_item_mismatch": "invalid_request_error",
-    "playback_item_not_found": "invalid_request_error",
-    "playback_ack_too_late": "invalid_request_error",
-    "unsupported_audio_format": "invalid_request_error",
-    "unsupported_turn_detection": "invalid_request_error",
-    "unsupported_ref_audio_path": "invalid_request_error",
-    "ref_audio_required": "invalid_request_error",
-    "model_update_unsupported": "invalid_request_error",
-    "voice_update_after_audio_unsupported": "invalid_request_error",
-    "ref_audio_update_unsupported": "invalid_request_error",
-    "native_text_append_unsupported": "invalid_request_error",
-    "invalid_video_frames": "invalid_request_error",
-    "invalid_function_call_output": "invalid_request_error",
-    "server_vad_unavailable": "server_error",
-}
-
-_IDENTITY_FIELDS = frozenset({"session_id", "epoch", "event_id"})
-
-
-def _wire_value(value: object) -> object:
-    if isinstance(value, Mapping):
-        return {str(k): _wire_value(v) for k, v in value.items()}
-    if isinstance(value, tuple | list):
-        return [_wire_value(v) for v in value]
-    return value
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class DuplexEvent:
-    """Base of every public session event."""
-
-    #: Realtime ``type`` this class renders to.
-    wire_type: ClassVar[str] = ""
-    #: Fields that are omitted from the wire object when ``None``.
-    optional_wire_fields: ClassVar[frozenset[str]] = frozenset()
-
-    session_id: str = ""
-    epoch: int | None = None
-    #: Server event id (OpenAI ``event_id``); generated at construction.
-    event_id: str = field(default_factory=new_event_id)
-
-    # ---- identity ----
-
-    @property
-    def type(self) -> str:
-        return self.wire_type
-
-    @property
-    def is_terminal(self) -> bool:
-        return False
-
-    # ---- generic accessors (None when the class has no such field) ----
-
-    @property
-    def response_id(self) -> str | None:
-        return None
-
-    @property
-    def item_id(self) -> str | None:
-        return None
-
-    @property
-    def text(self) -> str | None:
-        return None
-
-    @property
-    def audio(self) -> bytes | None:
-        return None
-
-    # ---- wire rendering (pure) ----
-
-    def _wire_fields(self) -> dict[str, object]:
-        data: dict[str, object] = {}
-        for f in fields(self):
-            if f.name in _IDENTITY_FIELDS:
-                continue
-            value = getattr(self, f.name)
-            if value is None and f.name in self.optional_wire_fields:
-                continue
-            data[f.name] = _wire_value(value)
-        return data
-
-    def to_realtime(self) -> dict[str, object]:
-        """The Realtime wire JSON object for this event (derived from the fields)."""
-        return {"type": self.wire_type, "event_id": self.event_id, **self._wire_fields()}
-
-    def __repr__(self) -> str:  # pragma: no cover - debugging aid
-        return f"{type(self).__name__}(type={self.wire_type!r}, session_id={self.session_id!r}, epoch={self.epoch!r})"
-
-
-# ---- session lifecycle ----
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionCreated(DuplexEvent):
-    wire_type = "session.created"
-    optional_wire_fields = frozenset({"attachment_generation", "resume_token"})
-
-    session: Mapping[str, object] = field(default_factory=dict)
-    #: Transport resume credentials (set by the websocket handler when resume is supported).
-    attachment_generation: int | None = None
-    resume_token: str | None = None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionUpdated(DuplexEvent):
-    wire_type = "session.updated"
-
-    session: Mapping[str, object] = field(default_factory=dict)
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionResumed(SessionCreated):
-    wire_type = "session.resumed"
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id, **DuplexEvent._wire_fields(self)}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionReplaced(DuplexEvent):
-    """A newer connection took the session over (sent to the replaced socket)."""
-
-    wire_type = "session.replaced"
-
-    attachment_generation: int = 0
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id, **DuplexEvent._wire_fields(self)}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionResyncRequired(DuplexEvent):
-    """The replay journal cannot bridge the gap; the client must start over."""
-
-    wire_type = "session.resync_required"
-
-    reason: str = "journal_gap"
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id, **DuplexEvent._wire_fields(self)}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionClosed(DuplexEvent):
-    wire_type = "session.closed"
-
-    reason: str = "closed"
-    #: The session-internal close event (kept for clients that inspect it).
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def is_terminal(self) -> bool:
-        return True
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id, "reason": self.reason, "event": _wire_value(self.details)}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionExpired(SessionClosed):
-    wire_type = "session.expired"
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id, "reason": self.reason}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SessionHeartbeatAck(DuplexEvent):
-    wire_type = "session.heartbeat_ack"
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class TurnEvent(DuplexEvent):
-    """Turn-state transition (``turn.event``)."""
-
-    wire_type = "turn.event"
-
-    event: str = ""
-    turn_state: str = ""
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"session_id": self.session_id, "event": self.event, "turn_state": self.turn_state, "epoch": self.epoch}
-
-
-# ---- response lifecycle ----
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class _ResponseEvent(DuplexEvent):
-    """Events addressed to one response (and usually one output item / content part)."""
-
-    response_id: str | None = None  # type: ignore[assignment]
-    item_id: str | None = None  # type: ignore[assignment]
-    output_index: int = 0
-    content_index: int = 0
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ResponseCreated(DuplexEvent):
-    wire_type = "response.created"
-
-    response_id: str | None = None  # type: ignore[assignment]
-    response: Mapping[str, object] = field(default_factory=dict)
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class Listen(DuplexEvent):
-    """The model decided to keep listening (no spoken response for this turn)."""
-
-    wire_type = "response.listen"
-    optional_wire_fields = frozenset({"response_id"})
-
-    response_id: str | None = None  # type: ignore[assignment]
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    def _wire_fields(self) -> dict[str, object]:
-        response: dict[str, object] = {
-            "object": "realtime.response",
-            "status": "listening",
-            "metadata": _wire_value(self.details),
-        }
-        data: dict[str, object] = {"session_id": self.session_id, "epoch": self.epoch, "response": response}
-        if self.response_id:
-            response["id"] = self.response_id
-            data["response_id"] = self.response_id
-        return data
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class Speak(_ResponseEvent):
-    wire_type = "response.speak"
-
-    metadata: Mapping[str, object] = field(default_factory=dict)
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class OverlapDecision(DuplexEvent):
-    wire_type = "overlap.decision"
-
-    policy: str | None = None
-    action: str | None = None
-    reason: str | None = None
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {
-            "session_id": self.session_id,
-            "epoch": self.epoch,
-            "policy": self.policy,
-            "action": self.action,
-            "reason": self.reason,
-            "metadata": _wire_value(self.details),
-        }
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class OutputItemAdded(DuplexEvent):
-    wire_type = "response.output_item.added"
-
-    response_id: str | None = None  # type: ignore[assignment]
-    output_index: int = 0
-    item: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def item_id(self) -> str | None:
-        value = self.item.get("id")
-        return value if isinstance(value, str) else None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class OutputItemDone(OutputItemAdded):
-    wire_type = "response.output_item.done"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ContentPartAdded(_ResponseEvent):
-    wire_type = "response.content_part.added"
-
-    part: Mapping[str, object] = field(default_factory=dict)
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ContentPartDone(ContentPartAdded):
-    wire_type = "response.content_part.done"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class AudioDelta(_ResponseEvent):
-    wire_type = "response.output_audio.delta"
-    optional_wire_fields = frozenset({"sample_rate_hz", "metadata"})
-
-    #: Base64 audio in ``format``.
-    delta: str = ""
-    format: str = "pcm16"
-    sample_rate_hz: int | None = None
-    metadata: Mapping[str, object] | None = None
-
-    @property
-    def audio(self) -> bytes | None:
-        try:
-            return base64.b64decode(self.delta)
-        except (ValueError, TypeError):
-            return None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class AudioDone(_ResponseEvent):
-    wire_type = "response.output_audio.done"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class TranscriptDelta(_ResponseEvent):
-    wire_type = "response.output_audio_transcript.delta"
-
-    delta: str = ""
-
-    @property
-    def text(self) -> str | None:
-        return self.delta
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class TranscriptDone(_ResponseEvent):
-    wire_type = "response.output_audio_transcript.done"
-
-    transcript: str = ""
-
-    @property
-    def text(self) -> str | None:
-        return self.transcript
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class TextDelta(_ResponseEvent):
-    wire_type = "response.output_text.delta"
-
-    delta: str = ""
-
-    @property
-    def text(self) -> str | None:
-        return self.delta
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class TextDone(_ResponseEvent):
-    wire_type = "response.output_text.done"
-
-    text: str = ""  # type: ignore[assignment]
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class FunctionCallArgumentsDelta(DuplexEvent):
-    wire_type = "response.function_call_arguments.delta"
-
-    response_id: str | None = None  # type: ignore[assignment]
-    item_id: str | None = None  # type: ignore[assignment]
-    output_index: int = 0
-    call_id: str = ""
-    delta: str = ""
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class FunctionCallArgumentsDone(DuplexEvent):
-    wire_type = "response.function_call_arguments.done"
-
-    response_id: str | None = None  # type: ignore[assignment]
-    item_id: str | None = None  # type: ignore[assignment]
-    output_index: int = 0
-    call_id: str = ""
-    arguments: str = ""
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ResponseDone(DuplexEvent):
-    wire_type = "response.done"
-
-    response_id: str | None = None  # type: ignore[assignment]
-    response: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def status(self) -> str | None:
-        value = self.response.get("status")
-        return value if isinstance(value, str) else None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class RateLimitsUpdated(DuplexEvent):
-    wire_type = "rate_limits.updated"
-
-    rate_limits: tuple[Mapping[str, object], ...] = ()
-
-
-# ---- input buffer / conversation ----
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class InputCommitted(DuplexEvent):
-    wire_type = "input_audio_buffer.committed"
-
-    previous_item_id: str | None = None
-    item_id: str | None = None  # type: ignore[assignment]
-    #: The session-internal ``input.committed`` event.
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {
-            "previous_item_id": self.previous_item_id,
-            "item_id": self.item_id,
-            "event": _wire_value(self.details),
-        }
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class InputCleared(DuplexEvent):
-    wire_type = "input_audio_buffer.cleared"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SpeechStarted(DuplexEvent):
-    wire_type = "input_audio_buffer.speech_started"
-
-    audio_start_ms: int = 0
-    item_id: str | None = None  # type: ignore[assignment]
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SpeechStopped(DuplexEvent):
-    wire_type = "input_audio_buffer.speech_stopped"
-
-    audio_end_ms: int = 0
-    item_id: str | None = None  # type: ignore[assignment]
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class _ItemEvent(DuplexEvent):
-    previous_item_id: str | None = None
-    item: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def item_id(self) -> str | None:
-        value = self.item.get("id")
-        return value if isinstance(value, str) else None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ItemAdded(_ItemEvent):
-    wire_type = "conversation.item.added"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ItemCreated(_ItemEvent):
-    wire_type = "conversation.item.created"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ItemDone(_ItemEvent):
-    wire_type = "conversation.item.done"
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ItemRetrieved(DuplexEvent):
-    wire_type = "conversation.item.retrieved"
-
-    item: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def item_id(self) -> str | None:
-        value = self.item.get("id")
-        return value if isinstance(value, str) else None
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ItemDeleted(DuplexEvent):
-    wire_type = "conversation.item.deleted"
-
-    item_id: str | None = None  # type: ignore[assignment]
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"item_id": self.item_id, "event": _wire_value(self.details)}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ItemTruncated(DuplexEvent):
-    wire_type = "conversation.item.truncated"
-
-    item_id: str | None = None  # type: ignore[assignment]
-    content_index: int = 0
-    audio_end_ms: int = 0
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {
-            "item_id": self.item_id,
-            "content_index": self.content_index,
-            "audio_end_ms": self.audio_end_ms,
-            "event": _wire_value(self.details),
-        }
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class InputTranscriptionCompleted(DuplexEvent):
-    wire_type = "conversation.item.input_audio_transcription.completed"
-
-    item_id: str | None = None  # type: ignore[assignment]
-    content_index: int = 0
-    transcript: str = ""
-
-    @property
-    def text(self) -> str | None:
-        return self.transcript
-
-
-# ---- playback / control ----
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class OutputAudioCleared(DuplexEvent):
-    wire_type = "output_audio_buffer.cleared"
-
-    response_id: str | None = None  # type: ignore[assignment]
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class PlaybackAcknowledged(DuplexEvent):
-    wire_type = "playback.acknowledged"
-
-    #: The session-internal ``playback.acknowledged`` event (cursor, committed_ms ...).
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"event": _wire_value(self.details)}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class ErrorEvent(DuplexEvent):
-    wire_type = "error"
-
-    code: str = "internal_error"
-    message: str = ""
-    #: Client ``event_id`` this error answers (OpenAI ``error.event_id``).
-    related_event_id: str | None = None
-    param: str | None = None
-    #: Extra keys merged into the wire ``error`` object (``retryable`` ...).
-    extra: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def error_type(self) -> str:
-        return REALTIME_ERROR_TYPES_BY_CODE.get(self.code, "invalid_request_error")
-
-    @property
-    def error(self) -> dict[str, object]:
-        error: dict[str, object] = {"type": self.error_type, "code": self.code, "message": self.message}
-        if self.related_event_id:
-            error["event_id"] = self.related_event_id
-        if self.param:
-            error["param"] = self.param
-        error.update(cast("Mapping[str, object]", _wire_value(self.extra)))
-        return error
-
-    @property
-    def text(self) -> str | None:
-        return self.message
-
-    def _wire_fields(self) -> dict[str, object]:
-        return {"error": self.error}
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class DuplexRawEvent(DuplexEvent):
-    """A session-internal event with no dedicated Realtime type (``duplex.<internal type>``)."""
-
-    wire_type = "duplex.raw"
-
-    internal_type: str = ""
-    details: Mapping[str, object] = field(default_factory=dict)
-
-    @property
-    def type(self) -> str:
-        return f"duplex.{self.internal_type}"
-
-    def to_realtime(self) -> dict[str, object]:
-        return {"type": self.type, "event_id": self.event_id, "event": _wire_value(self.details)}
-
-
-def error_event(
-    code: str,
-    message: str,
-    *,
-    event_id: object | None = None,
-    param: object | None = None,
-    extra: Mapping[str, object] | None = None,
-) -> ErrorEvent:
-    """Build the error event for an internal code; ``event_id`` is the *client* event id."""
-    return ErrorEvent(
-        code=code,
-        message=message,
-        related_event_id=event_id if isinstance(event_id, str) and event_id else None,
-        param=param if isinstance(param, str) and param else None,
-        extra=dict(extra or {}),
-    )
-
-
-#: Internal events that terminate a response/session and must never be dropped as stale.
 DOMAIN_TERMINAL_EVENTS = frozenset(
     {
         "response.done",
@@ -682,7 +84,6 @@ DOMAIN_TERMINAL_EVENTS = frozenset(
     }
 )
 
-#: Internal streaming model-output events subject to epoch/close stale filtering.
 MODEL_OUTPUT_EVENTS = frozenset(
     {
         "response.created",
@@ -705,13 +106,11 @@ MODEL_OUTPUT_EVENTS = frozenset(
 
 
 __all__ = [
-    "DOMAIN_TERMINAL_EVENTS",
-    "MODEL_OUTPUT_EVENTS",
-    "REALTIME_ERROR_TYPES_BY_CODE",
     "AudioDelta",
     "AudioDone",
     "ContentPartAdded",
     "ContentPartDone",
+    "DOMAIN_TERMINAL_EVENTS",
     "DuplexEvent",
     "DuplexRawEvent",
     "ErrorEvent",
@@ -727,11 +126,13 @@ __all__ = [
     "ItemRetrieved",
     "ItemTruncated",
     "Listen",
+    "MODEL_OUTPUT_EVENTS",
     "OutputAudioCleared",
     "OutputItemAdded",
     "OutputItemDone",
     "OverlapDecision",
     "PlaybackAcknowledged",
+    "REALTIME_ERROR_TYPES_BY_CODE",
     "RateLimitsUpdated",
     "ResponseCreated",
     "ResponseDone",
diff --git a/vllm_omni/engine/duplex/plugin.py b/vllm_omni/engine/duplex/plugin.py
index 130d5204d..1e2517ef6 100644
--- a/vllm_omni/engine/duplex/plugin.py
+++ b/vllm_omni/engine/duplex/plugin.py
@@ -123,6 +123,11 @@ class DuplexModelSessionState(ABC):
     continuation_units: int
     pending_silence_task: asyncio.Task[bool] | None
     pending_silence_owner_id: str | None
+    # Deadline-aligned silence continuation state: the monotonic submission
+    # time of the most recent native input unit and the next silence
+    # continuation deadline. A real (non-silence) input resets the chain.
+    last_native_submit_monotonic: float | None
+    silence_deadline_monotonic: float | None
 
     @abstractmethod
     def retain_committed_audio(
@@ -174,6 +179,7 @@ class DuplexModelPlugin(ABC):
     two halves is impossible by construction.
     """
 
+    projects_intermediate_outputs: bool = False
     plugin_id: str = ""
     private_runtime_config_keys: frozenset[str] = frozenset()
     #: Samples per silence unit the runner appends to keep a model turn going.
@@ -194,6 +200,16 @@ class DuplexModelPlugin(ABC):
         defaults: tuple[object, ...],
     ) -> tuple[object, ...]: ...
 
+    def prepare_prompt_config(
+        self, config: dict[str, object], *, state: DuplexModelSessionState, payload: dict[str, object]
+    ) -> dict[str, object]:
+        """Add model-owned context before planning an append on the session loop."""
+        return config
+
+    async def prepare_append_plan(self, **kwargs) -> DuplexAppendPlan:
+        """Prepare a plan; plugins may offload expensive work on owned snapshots."""
+        return self.plan_append(**kwargs)
+
     @abstractmethod
     def plan_append(
         self,
@@ -307,10 +323,16 @@ def payload_turn_id(payload: object) -> int | None:
 
 
 def coerce_int(value: object) -> int | None:
-    try:
-        return int(value) if value is not None else None
-    except (TypeError, ValueError):
-        return None
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float | str | bytes | bytearray):
+        try:
+            return int(value)
+        except (TypeError, ValueError, OverflowError):
+            return None
+    return None
 
 
 __all__ = [
diff --git a/vllm_omni/engine/duplex/realtime_commands.py b/vllm_omni/engine/duplex/realtime_commands.py
index 370364017..31b1c0949 100644
--- a/vllm_omni/engine/duplex/realtime_commands.py
+++ b/vllm_omni/engine/duplex/realtime_commands.py
@@ -3,26 +3,31 @@
 
 """OpenAI Realtime client events -> :class:`DuplexCommand` (stateless).
 
-This is the mapping half of the former ``entrypoints/duplex/realtime_input.py``
-translator. Everything that needed per-session state in the old translator
-(input-buffer emptiness for commits, response-id fallbacks for cancels,
-conversation-item lookups, VAD) is resolved by the session runner through the
-helpers on :class:`~vllm_omni.engine.duplex.realtime_events.RealtimeProjectionState`;
+This module is the *duplex binding* of the shared Realtime codec. Parsing,
+validating and decoding a client event is not duplex-specific and lives in
+``vllm_omni.protocol.realtime``, reached through ``vllm_omni.protocol.duplex``;
+what lives here is the part that is: which
+:class:`~vllm_omni.engine.duplex.commands.DuplexCommand` a decoded event
+becomes, what the duplex engine can serve
+(:data:`DUPLEX_REALTIME_CAPABILITIES`), and the mapping between a Realtime
+output format and the duplex ``response_format`` vocabulary.
+
+Everything that needs per-session state (input-buffer emptiness for commits,
+response-id fallbacks for cancels, conversation-item lookups, VAD) is resolved
+by the session runner through the helpers on
+:class:`~vllm_omni.engine.duplex.realtime_events.RealtimeProjectionState`;
 the commands produced here carry the raw client intent only.
+
+The shared names re-exported at the bottom are a compatibility surface for
+existing importers. The canonical definitions are in
+``vllm_omni.protocol.realtime`` and there is exactly one of each.
 """
 
 from __future__ import annotations
 
-import base64
-import binascii
 from collections.abc import Mapping
-from dataclasses import dataclass, replace
-from typing import Any, cast
-from uuid import uuid4
+from typing import cast
 
-import numpy as np
-
-from vllm_omni.engine.duplex.audio import convert_input_audio_with_rate
 from vllm_omni.engine.duplex.commands import (
     AckPlayback,
     AppendAudio,
@@ -44,93 +49,58 @@ from vllm_omni.engine.duplex.commands import (
     TruncateItem,
     UpdateSession,
 )
-
-REALTIME_INPUT_AUDIO_FORMATS = {
-    "pcm16",
-    "pcm_s16le",
-    "s16le",
-    "pcm_f32le",
-    "g711_ulaw",
-    "g711_alaw",
-}
-REALTIME_OUTPUT_AUDIO_FORMATS = {
-    "pcm16",
-    "pcm_s16le",
-    "s16le",
-    "wav",
-    "pcm",
-    "g711_ulaw",
-    "g711_alaw",
-}
-
-#: Wire hint keys copied verbatim from a client append onto the internal payload.
-REALTIME_INPUT_HINT_KEYS = (
-    "duration_ms",
-    "audio_duration_ms",
-    "audio_start_ms",
-    "audio_end_ms",
-    "is_speech",
-    "speech",
-    "speech_probability",
-    "vad",
-    "overlap_action",
-    "overlap",
-    "force_barge_in",
-    "force_listen",
-    "text",
-    "transcript",
+from vllm_omni.protocol.duplex import (
+    REALTIME_INPUT_AUDIO_FORMATS,
+    REALTIME_INPUT_HINT_KEYS,
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+    RealtimeInputDefaults,
+    RealtimeProtocolCapabilities,
+    RealtimeProtocolError,
+    apply_realtime_session_defaults,
+    copy_realtime_input_hints,
+    decode_audio_append,
+    input_audio_transcription_config,
+    input_explicitly_non_speech,
+    input_looks_like_speech,
+    input_transcript_from_item,
+    is_supported_realtime_input_format,
+    json_safe_realtime_payload,
+    normalize_conversation_item,
+    parse_realtime_audio_format,
+    realtime_audio_format_object,
+    realtime_max_output_tokens,
+    realtime_output_format,
+    realtime_overlap_fields,
+    text_chars_for_audio_ms_from_marks,
+    truncate_realtime_item_content,
+    validate_conversation_item_audio_formats,
+    validate_realtime_item_truncate,
+    validate_realtime_response_audio_formats,
+    validate_realtime_session_audio_formats,
+    validate_realtime_video_frames,
+    validate_session_payload,
 )
 
 
-@dataclass(frozen=True, slots=True)
-class RealtimeInputDefaults:
-    """Session-level wire defaults an append may omit (derived from the session object)."""
+def _validate_duplex_turn_detection(session_payload: Mapping[str, object]) -> str | None:
+    """The duplex engine's answer for ``turn_detection`` on a session object.
 
-    input_audio_format: str = "pcm16"
-    input_sample_rate_hz: int = 16000
-    output_audio_format: str = "pcm16"
-    output_sample_rate_hz: int | None = None
-    overlap_silence_rms: float = 0.003
+    Imported lazily: the validator lives with the Silero VAD backend, and a
+    connection that never sends a session object should not pay for loading it.
+    """
+    from vllm_omni.engine.duplex.turn_detection import validate_realtime_turn_detection
 
-    def with_session_payload(self, session_payload: Mapping[str, object]) -> RealtimeInputDefaults:
-        """Return defaults updated from a Realtime ``session`` object (session.update)."""
-        values = apply_realtime_session_defaults(self, session_payload)
-        return values
+    return validate_realtime_turn_detection(session_payload)
 
 
-# ---- audio format helpers ----
-
-
-def parse_realtime_audio_format(raw_format: object) -> tuple[object, int | None]:
-    def normalize_format(fmt: str) -> str:
-        normalized = fmt.lower()
-        if normalized in {"audio/pcm", "pcm"}:
-            return "pcm16"
-        if normalized in {"audio/wav", "wav"}:
-            return "wav"
-        if normalized in {"audio/pcm16", "pcm16", "pcm_s16le", "s16le"}:
-            return "pcm16"
-        if normalized in {"audio/pcm_f32le", "pcm_f32le", "f32le"}:
-            return "pcm_f32le"
-        if normalized in {"audio/g711_ulaw", "g711_ulaw", "g711-ulaw", "ulaw", "mulaw"}:
-            return "g711_ulaw"
-        if normalized in {"audio/g711_alaw", "g711_alaw", "g711-alaw", "alaw"}:
-            return "g711_alaw"
-        return fmt
-
-    if isinstance(raw_format, str):
-        return normalize_format(raw_format), None
-    if not isinstance(raw_format, dict):
-        return raw_format, None
-    rate = raw_format.get("rate") or raw_format.get("sample_rate_hz") or raw_format.get("sample_rate")
-    sample_rate_hz = int(rate) if isinstance(rate, int | float) and rate > 0 else None
-    fmt = raw_format.get("type") or raw_format.get("format")
-    if not isinstance(fmt, str):
-        return raw_format, sample_rate_hz
-    return normalize_format(fmt), sample_rate_hz
+#: What the duplex engine can serve, for the shared session-object validator.
+DUPLEX_REALTIME_CAPABILITIES = RealtimeProtocolCapabilities(
+    validate_turn_detection=_validate_duplex_turn_detection,
+)
 
 
 def duplex_response_format(realtime_format: str) -> str:
+    """A Realtime output format -> the duplex ``response_format`` vocabulary."""
     normalized = realtime_format.lower()
     if normalized in {"pcm16", "pcm_s16le", "s16le"}:
         return "pcm"
@@ -141,433 +111,6 @@ def duplex_response_format(realtime_format: str) -> str:
     return "wav"
 
 
-def realtime_output_format(duplex_format: object) -> str:
-    if isinstance(duplex_format, str) and duplex_format.lower() in {"g711_ulaw", "g711_alaw"}:
-        return duplex_format.lower()
-    if isinstance(duplex_format, str) and duplex_format.lower() == "pcm":
-        return "pcm16"
-    return str(duplex_format or "wav")
-
-
-def is_supported_realtime_input_format(fmt: object) -> bool:
-    return isinstance(fmt, str) and fmt.lower() in REALTIME_INPUT_AUDIO_FORMATS
-
-
-def realtime_audio_format_object(fmt: object, *, sample_rate_hz: int | None = None) -> dict[str, object]:
-    if isinstance(fmt, str) and fmt.lower() in {"pcm16", "pcm_s16le", "s16le", "pcm"}:
-        payload: dict[str, object] = {"type": "audio/pcm"}
-    elif isinstance(fmt, str) and fmt.lower() == "pcm_f32le":
-        payload = {"type": "audio/pcm_f32le"}
-    elif isinstance(fmt, str) and fmt.lower() == "g711_ulaw":
-        payload = {"type": "audio/g711_ulaw"}
-    elif isinstance(fmt, str) and fmt.lower() == "g711_alaw":
-        payload = {"type": "audio/g711_alaw"}
-    else:
-        payload = {"type": "audio/wav"}
-    if sample_rate_hz is not None:
-        payload["rate"] = int(sample_rate_hz)
-    return payload
-
-
-def validate_realtime_session_audio_formats(session_payload: Mapping[str, object]) -> str | None:
-    audio_config = session_payload.get("audio")
-    input_format: object = session_payload.get("input_audio_format")
-    if input_format is None and isinstance(audio_config, dict):
-        audio_input = audio_config.get("input")
-        if isinstance(audio_input, dict):
-            input_format = audio_input.get("format")
-    parsed_input, _ = parse_realtime_audio_format(input_format)
-    if input_format is not None and not (
-        isinstance(parsed_input, str) and parsed_input.lower() in REALTIME_INPUT_AUDIO_FORMATS
-    ):
-        return f"Unsupported input_audio_format: {input_format}"
-
-    output_format: object = session_payload.get("output_audio_format") or session_payload.get("response_format")
-    if output_format is None and isinstance(audio_config, dict):
-        audio_output = audio_config.get("output")
-        if isinstance(audio_output, dict):
-            output_format = audio_output.get("format")
-    parsed_output, _ = parse_realtime_audio_format(output_format)
-    if output_format is not None and not (
-        isinstance(parsed_output, str) and parsed_output.lower() in REALTIME_OUTPUT_AUDIO_FORMATS
-    ):
-        return f"Unsupported output_audio_format: {output_format}"
-    return None
-
-
-def validate_realtime_response_audio_formats(response_payload: Mapping[str, object]) -> str | None:
-    output_format: object = response_payload.get("output_audio_format") or response_payload.get("response_format")
-    audio_config = response_payload.get("audio")
-    if output_format is None and isinstance(audio_config, dict):
-        audio_output = audio_config.get("output")
-        if isinstance(audio_output, dict):
-            output_format = audio_output.get("format")
-    parsed_output, _ = parse_realtime_audio_format(output_format)
-    if output_format is not None and not (
-        isinstance(parsed_output, str) and parsed_output.lower() in REALTIME_OUTPUT_AUDIO_FORMATS
-    ):
-        return f"Unsupported output_audio_format: {output_format}"
-    return None
-
-
-def validate_conversation_item_audio_formats(item: object) -> str | None:
-    if not isinstance(item, dict):
-        return None
-    content = item.get("content")
-    if not isinstance(content, list):
-        return None
-    for part in content:
-        if not isinstance(part, dict):
-            continue
-        if part.get("type") not in {"input_audio", "audio"}:
-            continue
-        raw_format = part.get("format")
-        parsed_format, _ = parse_realtime_audio_format(raw_format)
-        if raw_format is not None and not (
-            isinstance(parsed_format, str) and parsed_format.lower() in REALTIME_INPUT_AUDIO_FORMATS
-        ):
-            return f"Unsupported input_audio format in conversation.item.create: {raw_format}"
-    return None
-
-
-def apply_realtime_session_defaults(
-    defaults: RealtimeInputDefaults,
-    session_payload: Mapping[str, object],
-) -> RealtimeInputDefaults:
-    """Derive the wire defaults a Realtime ``session`` object declares."""
-    input_format: object = session_payload.get("input_audio_format")
-    audio_config = session_payload.get("audio")
-    if input_format is None and isinstance(audio_config, dict):
-        audio_input = audio_config.get("input")
-        if isinstance(audio_input, dict):
-            input_format = audio_input.get("format")
-    input_format, input_rate = parse_realtime_audio_format(input_format)
-    # Any: heterogeneous field values splatted into ``dataclasses.replace`` below.
-    updates: dict[str, Any] = {}
-    if isinstance(input_format, str) and input_format.lower() in REALTIME_INPUT_AUDIO_FORMATS:
-        updates["input_audio_format"] = input_format
-    output_format: object = session_payload.get("output_audio_format") or session_payload.get("response_format")
-    output_rate_raw: object | None = None
-    if output_format is None and isinstance(audio_config, dict):
-        audio_output = audio_config.get("output")
-        if isinstance(audio_output, dict):
-            output_format = audio_output.get("format")
-            output_rate_raw = audio_output.get("sample_rate_hz") or audio_output.get("sample_rate")
-    output_format, output_rate = parse_realtime_audio_format(output_format)
-    if output_rate is None and isinstance(output_rate_raw, int | float) and output_rate_raw > 0:
-        output_rate = int(output_rate_raw)
-    if isinstance(output_format, str) and output_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
-        updates["output_audio_format"] = realtime_output_format(output_format)
-    sample_rate = session_payload.get("sample_rate_hz") or session_payload.get("sample_rate")
-    if sample_rate is None and isinstance(audio_config, dict):
-        audio_input = audio_config.get("input")
-        if isinstance(audio_input, dict):
-            sample_rate = audio_input.get("sample_rate_hz") or audio_input.get("sample_rate")
-    if sample_rate is None:
-        sample_rate = input_rate
-    if isinstance(sample_rate, int | float) and sample_rate > 0:
-        updates["input_sample_rate_hz"] = int(sample_rate)
-    if isinstance(output_rate, int | float) and output_rate > 0:
-        updates["output_sample_rate_hz"] = int(output_rate)
-    overlap_fields = realtime_overlap_fields(session_payload)
-    overlap_silence_rms = overlap_fields.get("overlap_silence_rms")
-    if isinstance(overlap_silence_rms, int | float):
-        updates["overlap_silence_rms"] = max(0.0, float(overlap_silence_rms))
-    return replace(defaults, **updates) if updates else defaults
-
-
-def realtime_overlap_fields(session_payload: Mapping[str, object]) -> dict[str, object]:
-    fields: dict[str, object] = {}
-    if isinstance(session_payload.get("overlap_policy"), str):
-        fields["overlap_policy"] = session_payload["overlap_policy"]
-    for key in ("overlap_short_ack_ms", "overlap_barge_in_ms", "overlap_silence_rms"):
-        value = session_payload.get(key)
-        if isinstance(value, int | float):
-            fields[key] = value
-    if isinstance(session_payload.get("playback_commit_policy"), str):
-        fields["playback_commit_policy"] = session_payload["playback_commit_policy"]
-    return fields
-
-
-def json_safe_realtime_payload(payload: Mapping[str, object]) -> dict[str, object]:
-    clean: dict[str, object] = {}
-    for key, value in payload.items():
-        if key == "extra_body":
-            continue
-        if isinstance(value, str | int | float | bool) or value is None:
-            clean[key] = value
-        elif isinstance(value, dict):
-            clean[key] = json_safe_realtime_payload(value)
-        elif isinstance(value, list):
-            clean[key] = [
-                (json_safe_realtime_payload(item) if isinstance(item, dict) else item)
-                for item in value
-                if isinstance(item, str | int | float | bool | dict) or item is None
-            ]
-    return clean
-
-
-def input_audio_transcription_config(session_payload: Mapping[str, object]) -> dict[str, object] | None:
-    transcription = session_payload.get("input_audio_transcription")
-    if isinstance(transcription, dict):
-        return transcription
-    audio_config = session_payload.get("audio")
-    if not isinstance(audio_config, dict):
-        return None
-    audio_input = audio_config.get("input")
-    if not isinstance(audio_input, dict):
-        return None
-    transcription = audio_input.get("transcription")
-    return transcription if isinstance(transcription, dict) else None
-
-
-def realtime_max_output_tokens(value: object) -> int | None:
-    """Normalize Realtime max output tokens (``"inf"`` -> ``None``)."""
-    if value is None:
-        return None
-    if isinstance(value, str) and value.strip().lower() in {"inf", "infinity", "unlimited"}:
-        return None
-    if isinstance(value, int) and value > 0:
-        return int(value)
-    return None
-
-
-# ---- speech hints ----
-
-
-def input_explicitly_non_speech(event: Mapping[str, object]) -> bool:
-    for key in ("is_speech", "speech"):
-        value = event.get(key)
-        if isinstance(value, bool):
-            return not value
-    vad = event.get("vad")
-    if isinstance(vad, dict):
-        value = vad.get("is_speech")
-        if isinstance(value, bool):
-            return not value
-        probability = vad.get("speech_probability", vad.get("probability"))
-        if isinstance(probability, int | float):
-            return float(probability) < 0.5
-    probability = event.get("speech_probability")
-    return isinstance(probability, int | float) and float(probability) < 0.5
-
-
-def input_looks_like_speech(
-    event: Mapping[str, object],
-    *,
-    audio: object,
-    fmt: object,
-    overlap_silence_rms: float,
-) -> bool:
-    if input_explicitly_non_speech(event):
-        return False
-    for key in ("is_speech", "speech"):
-        value = event.get(key)
-        if isinstance(value, bool):
-            return value
-    vad = event.get("vad")
-    if isinstance(vad, dict):
-        probability = vad.get("speech_probability", vad.get("probability"))
-        if isinstance(probability, int | float):
-            return float(probability) >= 0.5
-    probability = event.get("speech_probability")
-    if isinstance(probability, int | float):
-        return float(probability) >= 0.5
-    if fmt != "pcm_f32le":
-        return True
-    if isinstance(audio, bytes | bytearray):
-        raw = bytes(audio)
-    elif isinstance(audio, str):
-        try:
-            raw = base64.b64decode(audio, validate=True)
-        except (binascii.Error, ValueError):
-            return True
-    else:
-        return True
-    if len(raw) < 4 or len(raw) % 4 != 0:
-        return True
-    samples = np.frombuffer(raw, dtype=np.float32)
-    if samples.size == 0:
-        return False
-    rms = float(np.sqrt(np.mean(np.square(samples.astype(np.float32)))))
-    threshold = event.get("overlap_silence_rms")
-    if not isinstance(threshold, int | float):
-        vad = event.get("vad")
-        if isinstance(vad, dict):
-            threshold = vad.get("silence_rms")
-    silence_rms = float(threshold) if isinstance(threshold, int | float) else overlap_silence_rms
-    return rms >= max(0.0, silence_rms)
-
-
-def copy_realtime_input_hints(source: Mapping[str, object], target: dict[str, object]) -> None:
-    for key in REALTIME_INPUT_HINT_KEYS:
-        if key in source:
-            target[key] = source[key]
-
-
-def validate_realtime_video_frames(video_frames: object, max_slice_nums: object) -> str | None:
-    """Validate omni-duplex camera frames on input_audio_buffer.append.
-
-    Wire contract matches the official MiniCPM-o duplex loop: one base
-    base64 JPEG per ~1 s audio chunk, optionally followed by that unit's
-    stacked composite tiling the sub-frames captured inside it (at most 2
-    images either way). A caller-supplied ``max_slice_nums`` is rejected rather
-    than silently ignored: slicing is Stage 0's decision here, and Stage 0
-    already applies the official HD suggestion for a stacked unit
-    (``max_slice_nums=[2, 1]``). The wire simply does not let the client choose
-    it.
-    """
-    if max_slice_nums not in (None, 1):
-        return "max_slice_nums is not selectable on the wire; Stage0 slices stacked units itself"
-    if not isinstance(video_frames, list):
-        return "video_frames must be a list of base64-encoded images"
-    frames = [frame for frame in video_frames if frame is not None]
-    if len(frames) > 2:
-        return "video_frames carries more than 2 frames for one append; send ~1 frame per 1 s chunk"
-    for frame in frames:
-        if not isinstance(frame, str) or not frame:
-            return "video_frames entries must be non-empty base64 strings"
-        if len(frame) > 4_000_000:
-            return "video_frames entry exceeds 4MB base64; reduce capture resolution or JPEG quality"
-        try:
-            header = base64.b64decode(frame[:64] + "=" * (-len(frame[:64]) % 4))
-        except (binascii.Error, ValueError):
-            return "video_frames entries must be valid base64"
-        if not (header.startswith(b"\xff\xd8") or header.startswith(b"\x89PNG")):
-            return "video_frames entries must be JPEG or PNG images"
-    return None
-
-
-# ---- conversation items ----
-
-
-def normalize_conversation_item(item: Mapping[str, object]) -> dict[str, object]:
-    normalized = dict(item)
-    normalized.setdefault("id", f"item_{uuid4().hex}")
-    normalized.setdefault("object", "realtime.item")
-    normalized.setdefault("type", "message")
-    normalized.setdefault("status", "completed")
-    if "role" not in normalized and normalized.get("type") == "message":
-        normalized["role"] = "user"
-    if not isinstance(normalized.get("content"), list):
-        normalized["content"] = []
-    return normalized
-
-
-def text_chars_for_audio_ms_from_marks(
-    audio_end_ms: int,
-    text_len: int,
-    marks: list[object],
-    *,
-    final_ms: object | None = None,
-) -> int:
-    if text_len <= 0:
-        return 0
-    clean_marks: list[tuple[int, int]] = []
-    for mark in marks:
-        if not isinstance(mark, dict):
-            continue
-        raw_text_chars = mark.get("text_chars")
-        raw_audio_end_ms = mark.get("audio_end_ms", mark.get("audio_ms"))
-        if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
-            continue
-        clean_marks.append((max(0, int(raw_audio_end_ms)), min(text_len, max(0, int(raw_text_chars)))))
-    if not clean_marks:
-        return 0 if audio_end_ms <= 0 else text_len
-    clean_marks.sort(key=lambda item: item[0])
-    audio_end_ms = max(0, int(audio_end_ms))
-    if audio_end_ms <= 0:
-        return 0
-    previous_ms = 0
-    previous_chars = 0
-    for mark_ms, mark_chars in clean_marks:
-        mark_ms = max(previous_ms, mark_ms)
-        mark_chars = max(previous_chars, min(text_len, mark_chars))
-        if audio_end_ms <= mark_ms:
-            if mark_ms <= previous_ms:
-                return mark_chars
-            ratio = (audio_end_ms - previous_ms) / max(1, mark_ms - previous_ms)
-            return int(previous_chars + (mark_chars - previous_chars) * max(0.0, min(1.0, ratio)))
-        previous_ms = mark_ms
-        previous_chars = mark_chars
-    if isinstance(final_ms, int | float) and int(final_ms) > previous_ms:
-        if audio_end_ms >= int(final_ms):
-            return text_len
-        ratio = (audio_end_ms - previous_ms) / max(1, int(final_ms) - previous_ms)
-        return int(previous_chars + (text_len - previous_chars) * max(0.0, min(1.0, ratio)))
-    return text_len if audio_end_ms >= previous_ms else previous_chars
-
-
-def truncate_realtime_item_content(item: dict[str, object], *, content_index: int, audio_end_ms: int) -> None:
-    content = item.get("content")
-    if not isinstance(content, list) or not content:
-        return
-    index = max(0, int(content_index))
-    if index >= len(content):
-        return
-    part = content[index]
-    if not isinstance(part, dict):
-        return
-    transcript = part.get("transcript")
-    if not isinstance(transcript, str) or not transcript:
-        return
-    marks = part.get("audio_text_marks")
-    if isinstance(marks, list):
-        keep_chars = text_chars_for_audio_ms_from_marks(
-            audio_end_ms,
-            len(transcript),
-            marks,
-            final_ms=part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms"),
-        )
-        part["transcript"] = transcript[:keep_chars].rstrip()
-        return
-    duration_ms = part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms")
-    if isinstance(duration_ms, int | float) and duration_ms > 0:
-        keep_chars = int(len(transcript) * max(0.0, min(1.0, int(audio_end_ms) / float(duration_ms))))
-        part["transcript"] = transcript[:keep_chars].rstrip()
-    elif audio_end_ms <= 0:
-        part["transcript"] = ""
-
-
-def validate_realtime_item_truncate(item: Mapping[str, object], *, content_index: int, audio_end_ms: int) -> str | None:
-    if item.get("type") != "message" or item.get("role") != "assistant":
-        return "conversation.item.truncate only supports assistant message items"
-    if audio_end_ms < 0:
-        return "conversation.item.truncate requires non-negative audio_end_ms"
-    content = item.get("content")
-    if not isinstance(content, list) or not content:
-        return None
-    index = max(0, int(content_index))
-    if index >= len(content):
-        return f"conversation.item.truncate content_index out of range: {content_index}"
-    part = content[index]
-    if not isinstance(part, dict):
-        return "conversation.item.truncate target content part is invalid"
-    if part.get("type") not in {"audio", "output_audio"}:
-        return "conversation.item.truncate target content part must be audio"
-    duration_ms = part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms")
-    if isinstance(duration_ms, int | float) and int(duration_ms) >= 0 and audio_end_ms > int(duration_ms):
-        return "conversation.item.truncate audio_end_ms exceeds item audio duration"
-    return None
-
-
-def input_transcript_from_item(item: Mapping[str, object]) -> str:
-    content = item.get("content")
-    if not isinstance(content, list):
-        return ""
-    parts: list[str] = []
-    for part in content:
-        if not isinstance(part, dict):
-            continue
-        for key in ("transcript", "text"):
-            value = part.get(key)
-            if isinstance(value, str) and value:
-                if part.get("type") in {"input_audio", "audio", "audio_transcript", "transcript"}:
-                    parts.append(value)
-                    break
-    return "".join(parts).strip()
-
-
 # ---- append / item audio conversion ----
 
 
@@ -577,67 +120,21 @@ def build_append_audio(
     defaults: RealtimeInputDefaults,
     hints_source: Mapping[str, object] | None = None,
 ) -> AppendAudio:
-    """Validate, convert (to 16 kHz ``pcm_f32le`` base64) and pack one audio append.
-
-    Speech classification without VAD (``is_speech`` on the command) uses the
-    explicit wire hints and the RMS fallback exactly like the old translator.
-    """
-    event_id = cast("str", event.get("event_id")) if isinstance(event.get("event_id"), str) else None
-    audio = event.get("audio") or event.get("delta")
-    fmt, format_rate = parse_realtime_audio_format(
-        event.get("format") or event.get("input_audio_format") or defaults.input_audio_format
-    )
-    sample_rate_hz = (
-        event.get("sample_rate_hz") or event.get("sample_rate") or format_rate or defaults.input_sample_rate_hz
-    )
-    if not is_supported_realtime_input_format(fmt):
-        raise DuplexCommandError(
-            f"Unsupported input_audio_format: {fmt}",
-            code="unsupported_audio_format",
-            event_id=event_id,
-        )
+    """Decode one audio append (shared codec) and pack it as the duplex command."""
     try:
-        audio, fmt, sample_rate_hz = convert_input_audio_with_rate(
-            audio,
-            fmt,
-            sample_rate_hz=sample_rate_hz if isinstance(sample_rate_hz, int | float) else None,
-        )
-    except ValueError as exc:
-        raise DuplexCommandError(str(exc), code="bad_event", event_id=event_id) from exc
-    hints: dict[str, object] = {}
-    if hints_source is not None:
-        copy_realtime_input_hints(hints_source, hints)
-    copy_realtime_input_hints(event, hints)
-    looks_like_speech = input_looks_like_speech(
-        {**(hints_source or {}), **event},
-        audio=audio,
-        fmt=fmt,
-        overlap_silence_rms=defaults.overlap_silence_rms,
-    )
-    video_frames: tuple[str, ...] = ()
-    raw_frames = event.get("video_frames")
-    if raw_frames is not None:
-        frames_error = validate_realtime_video_frames(raw_frames, event.get("max_slice_nums"))
-        if frames_error is not None:
-            raise DuplexCommandError(frames_error, code="invalid_video_frames", event_id=event_id)
-        if isinstance(raw_frames, list):
-            video_frames = tuple(frame for frame in raw_frames if isinstance(frame, str) and frame)
-    duration_ms = hints.get("duration_ms", hints.get("audio_duration_ms"))
-    audio_end_ms = hints.get("audio_end_ms")
-    try:
-        audio_bytes = base64.b64decode(audio, validate=True) if isinstance(audio, str) and audio else b""
-    except (binascii.Error, ValueError) as exc:
-        raise DuplexCommandError("input audio is not valid base64", code="bad_audio", event_id=event_id) from exc
+        decoded = decode_audio_append(event, defaults=defaults, hints_source=hints_source)
+    except RealtimeProtocolError as exc:
+        raise DuplexCommandError(str(exc), code=exc.code, event_id=exc.event_id) from exc
     return AppendAudio(
-        event_id=event_id,
-        audio=audio_bytes,
-        format=str(fmt),
-        sample_rate_hz=int(sample_rate_hz) if isinstance(sample_rate_hz, int | float) else None,
-        is_speech=looks_like_speech,
-        video_frames=video_frames,
-        duration_ms=int(duration_ms) if isinstance(duration_ms, int | float) else None,
-        audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else None,
-        hints=hints,
+        event_id=decoded.event_id,
+        audio=decoded.audio,
+        format=decoded.format,
+        sample_rate_hz=decoded.sample_rate_hz,
+        is_speech=decoded.is_speech,
+        video_frames=decoded.video_frames,
+        duration_ms=decoded.duration_ms,
+        audio_end_ms=decoded.audio_end_ms,
+        hints=decoded.hints,
     )
 
 
@@ -664,14 +161,9 @@ def translate_realtime_command(
     if event_type == "session.update":
         session = payload.get("session")
         session_payload: Mapping[str, object] = session if isinstance(session, dict) else payload
-        format_error = validate_realtime_session_audio_formats(session_payload)
-        if format_error is not None:
-            raise DuplexCommandError(format_error, code="unsupported_audio_format", event_id=event_id)
-        from vllm_omni.engine.duplex.turn_detection import validate_realtime_turn_detection
-
-        turn_detection_error = validate_realtime_turn_detection(session_payload)
-        if turn_detection_error is not None:
-            raise DuplexCommandError(turn_detection_error, code="unsupported_turn_detection", event_id=event_id)
+        rejection = validate_session_payload(session_payload, capabilities=DUPLEX_REALTIME_CAPABILITIES)
+        if rejection is not None:
+            raise DuplexCommandError(rejection.message, code=rejection.code, event_id=event_id)
         return UpdateSession(event_id=event_id, patch=dict(session_payload))
 
     if event_type == "conversation.item.create":
@@ -855,7 +347,10 @@ def translate_realtime_command(
     raise DuplexCommandError(f"Unknown duplex event type: {event_type}", code="unknown_event", event_id=event_id)
 
 
+#: Names this module used to define, re-exported so existing importers keep
+#: working. The canonical definitions live in ``vllm_omni.protocol.realtime``.
 __all__ = [
+    "DUPLEX_REALTIME_CAPABILITIES",
     "REALTIME_INPUT_AUDIO_FORMATS",
     "REALTIME_INPUT_HINT_KEYS",
     "REALTIME_OUTPUT_AUDIO_FORMATS",
diff --git a/vllm_omni/engine/duplex/realtime_events.py b/vllm_omni/engine/duplex/realtime_events.py
index 91359f297..e6292b213 100644
--- a/vllm_omni/engine/duplex/realtime_events.py
+++ b/vllm_omni/engine/duplex/realtime_events.py
@@ -15,6 +15,12 @@ carries the input-side bookkeeping the old input translator kept (input buffer
 flags, conversation items, response-id fallbacks); the ``resolve_*`` /
 ``note_*`` helpers give the runner the same behaviour for the corresponding
 commands.
+
+What is *not* here is the model- and runtime-agnostic half of the codec ---
+audio format negotiation, conversation-item shape and truncation, transcript
+extraction, audio conversion. That lives in ``vllm_omni.protocol.realtime`` so
+a non-duplex Realtime surface can use it without the duplex session; this
+module is the duplex consumer of it (RFC #6592 P0a).
 """
 
 from __future__ import annotations
@@ -24,7 +30,6 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, cast
 from uuid import uuid4
 
-from vllm_omni.engine.duplex.audio import convert_output_audio
 from vllm_omni.engine.duplex.commands import (
     AppendAudio,
     CancelResponse,
@@ -74,10 +79,11 @@ from vllm_omni.engine.duplex.events import (
     TranscriptDone,
     error_event,
 )
-from vllm_omni.engine.duplex.realtime_commands import (
+from vllm_omni.engine.duplex.realtime_commands import build_append_audio
+from vllm_omni.protocol.duplex import (
     RealtimeInputDefaults,
     apply_realtime_session_defaults,
-    build_append_audio,
+    convert_output_audio,
     copy_realtime_input_hints,
     input_looks_like_speech,
     input_transcript_from_item,
@@ -321,7 +327,7 @@ def _response_done_output_item(
         )
     if text:
         content.append(_response_item_text_content_part(text=text))
-    item = {
+    item: dict[str, object] = {
         "id": item_id,
         "object": "realtime.item",
         "type": "message",
@@ -790,7 +796,7 @@ def _project(state: RealtimeProjectionState, event: dict[str, object]) -> list[D
         item_id = _response_item_id(state, response_id)
         modalities = event.get("modalities")
         has_audio_modality = not isinstance(modalities, list) or "audio" in modalities
-        item = {
+        item: dict[str, object] = {
             "id": item_id,
             "object": "realtime.item",
             "type": "message",
@@ -894,13 +900,13 @@ def _project(state: RealtimeProjectionState, event: dict[str, object]) -> list[D
         item_id = (
             event_item_id if isinstance(event_item_id, str) and event_item_id else _pop_pending_commit_item_id(state)
         )
-        item = state.conversation_items.get(item_id)
-        events = []
-        if item is None:
+        committed_item = state.conversation_items.get(item_id)
+        commit_events: list[DuplexEvent] = []
+        if committed_item is None:
             message = event.get("message")
             no_response = event.get("no_response") is True
             is_speech = event.get("is_speech")
-            item = {
+            created_commit_item: dict[str, object] = {
                 "id": item_id,
                 "object": "realtime.item",
                 "type": "message",
@@ -912,17 +918,18 @@ def _project(state: RealtimeProjectionState, event: dict[str, object]) -> list[D
                     else _user_item_content_from_duplex_message(message)
                 ),
             }
-            state.conversation_items[item_id] = item
-            events.extend(_conversation_item_added_events(state, item))
-        item["status"] = "completed"
-        events.append(
+            committed_item = created_commit_item
+            state.conversation_items[item_id] = committed_item
+            commit_events.extend(_conversation_item_added_events(state, committed_item))
+        committed_item["status"] = "completed"
+        commit_events.append(
             InputCommitted(previous_item_id=_previous_item_id(state, item_id), item_id=item_id, details=event)
         )
-        transcription_event = _input_audio_transcription_completed_event(item_id, item)
+        transcription_event = _input_audio_transcription_completed_event(item_id, committed_item)
         if transcription_event is not None:
-            events.append(transcription_event)
-        events.append(_conversation_item_done_event(state, item))
-        return events
+            commit_events.append(transcription_event)
+        commit_events.append(_conversation_item_done_event(state, committed_item))
+        return commit_events
     if event_type == "input.cancelled":
         return [InputCleared()]
     if event_type == "audio.cancelled":
@@ -939,15 +946,25 @@ def _project(state: RealtimeProjectionState, event: dict[str, object]) -> list[D
         if not isinstance(response_id, str) or not response_id:
             return events
         if response_is_done(state, response_id):
+            # Generation may finish long before the client drains its audio.
+            # A later barge-in still needs to stop that queued playback, but
+            # must not produce a second response.done for the completed turn.
+            playback = event.get("playback")
+            if (
+                not events
+                and isinstance(playback, Mapping)
+                and _int_or(playback.get("sent_ms")) > _int_or(playback.get("committed_ms"))
+            ):
+                events.append(OutputAudioCleared(response_id=response_id))
             return events
         committed_ms = event.get("committed_ms")
         if isinstance(committed_ms, int | float):
             item_id = _response_item_id(state, response_id)
             committed_audio_ms = max(0, int(committed_ms))
             state.item_truncation_cursors[item_id] = (0, committed_audio_ms)
-            item = state.conversation_items.get(item_id)
-            if item is not None:
-                truncate_realtime_item_content(item, content_index=0, audio_end_ms=committed_audio_ms)
+            cancelled_item = state.conversation_items.get(item_id)
+            if cancelled_item is not None:
+                truncate_realtime_item_content(cancelled_item, content_index=0, audio_end_ms=committed_audio_ms)
         events.extend(_realtime_audio_done_events(state, event, response_id))
         events.extend(
             _realtime_response_terminal_events(
@@ -962,48 +979,49 @@ def _project(state: RealtimeProjectionState, event: dict[str, object]) -> list[D
             state.active_response_id = None
         return events
     if event_type == "conversation.item.created":
-        item = event.get("item")
-        if isinstance(item, dict) and isinstance(item.get("id"), str):
-            item_id = str(item["id"])
-            already_known = item_id in state.conversation_items
-            state.conversation_items[item_id] = item
+        created_raw = event.get("item")
+        if isinstance(created_raw, dict) and isinstance(created_raw.get("id"), str):
+            created_item_id = str(created_raw["id"])
+            created_item = cast("dict[str, object]", created_raw)
+            already_known = created_item_id in state.conversation_items
+            state.conversation_items[created_item_id] = created_item
             if already_known:
-                if item.get("status") == "completed":
-                    return [_conversation_item_done_event(state, item)]
+                if created_item.get("status") == "completed":
+                    return [_conversation_item_done_event(state, created_item)]
                 return []
-            events = _conversation_item_added_events(state, item)
-            if item.get("status") == "completed":
-                events.append(_conversation_item_done_event(state, item))
-            return events
-        return [ItemCreated(item=item if isinstance(item, Mapping) else {})]
+            created_events = _conversation_item_added_events(state, created_item)
+            if created_item.get("status") == "completed":
+                created_events.append(_conversation_item_done_event(state, created_item))
+            return created_events
+        return [ItemCreated(item=created_raw if isinstance(created_raw, Mapping) else {})]
     if event_type == "conversation.item.deleted":
-        item_id = event.get("item_id")
-        if isinstance(item_id, str):
-            _remove_conversation_item(state, item_id)
-        return [ItemDeleted(item_id=_str_or_none(item_id), details=event)]
+        deleted_item_id = event.get("item_id")
+        if isinstance(deleted_item_id, str):
+            _remove_conversation_item(state, deleted_item_id)
+        return [ItemDeleted(item_id=_str_or_none(deleted_item_id), details=event)]
     if event_type == "conversation.item.truncated":
-        item_id = event.get("item_id")
+        truncated_item_id = event.get("item_id")
         audio_end_ms = event.get("audio_end_ms")
         content_index = event.get("content_index", 0)
-        if isinstance(item_id, str):
-            item = state.conversation_items.get(item_id)
-            if item is not None:
+        if isinstance(truncated_item_id, str):
+            truncated_item = state.conversation_items.get(truncated_item_id)
+            if truncated_item is not None:
                 truncate_realtime_item_content(
-                    item,
+                    truncated_item,
                     content_index=_int_or(content_index),
                     audio_end_ms=_int_or(audio_end_ms),
                 )
         return [
             ItemTruncated(
-                item_id=_str_or_none(item_id),
+                item_id=_str_or_none(truncated_item_id),
                 content_index=_int_or(content_index),
                 audio_end_ms=_int_or(audio_end_ms),
                 details=event,
             )
         ]
     if event_type == "conversation.item.retrieved":
-        item = event.get("item")
-        return [ItemRetrieved(item=item if isinstance(item, Mapping) else {})]
+        retrieved_item = event.get("item")
+        return [ItemRetrieved(item=retrieved_item if isinstance(retrieved_item, Mapping) else {})]
     if event_type == "response.output_item.done":
         response_id = event.get("response_id")
         return _realtime_response_terminal_events(
@@ -1038,7 +1056,7 @@ def _function_call_done_events(state: RealtimeProjectionState, event: dict[str,
         arguments = str(arguments)
     response_id = f"resp_{uuid4().hex}"
     item_id = f"item_{uuid4().hex}"
-    item = {
+    item: dict[str, object] = {
         "id": item_id,
         "object": "realtime.item",
         "type": "function_call",
@@ -1312,7 +1330,11 @@ def resolve_cancel_response(state: RealtimeProjectionState, command: CancelRespo
 def resolve_clear_output_audio(state: RealtimeProjectionState, command: ClearOutputAudio) -> ResolvedControl:
     payload: dict[str, object] = {"type": "output_audio_buffer.clear", "reason": "output_audio_buffer.clear"}
     response_id = command.response_id or state.active_response_id or state.last_response_id
-    if response_is_done(state, response_id):
+    # A completed response can still own queued playback. Clear the latest
+    # response in the engine, while keeping late clears away from newer turns.
+    if response_is_done(state, response_id) and (
+        state.active_response_id is not None or response_id != state.last_response_id
+    ):
         return ResolvedControl(payloads=[], events=[OutputAudioCleared(response_id=_str_or_none(response_id))])
     if isinstance(response_id, str) and response_id:
         payload["response_id"] = response_id
@@ -1354,7 +1376,6 @@ def resolve_truncate_item(state: RealtimeProjectionState, command: TruncateItem)
             payloads=[], events=[error_event("bad_event", truncate_error, event_id=command.event_id)]
         )
     state.item_truncation_cursors[command.item_id] = (command.content_index, command.audio_end_ms)
-    truncate_realtime_item_content(item, content_index=command.content_index, audio_end_ms=command.audio_end_ms)
     ack_payload: dict[str, object] = {
         "type": "playback.ack",
         "item_id": command.item_id,
@@ -1425,7 +1446,7 @@ def resolve_create_item(state: RealtimeProjectionState, command: CreateItem) ->
                 ],
             )
     ack_events = register_user_item(state, item) if item_type == "message" and role == "user" else []
-    signal_payload = {
+    signal_payload: dict[str, object] = {
         "type": "turn.signal",
         "event": "conversation.item.create",
         "payload": {"item": item},
@@ -1438,12 +1459,15 @@ def resolve_create_item(state: RealtimeProjectionState, command: CreateItem) ->
     if not isinstance(content, list):
         return ResolvedControl(payloads=[], events=ack_events)
     text_chunks: list[str] = []
+    image_parts: list[Mapping[str, object]] = []
     audio_payloads: list[dict[str, object]] = []
     for part in content:
         if not isinstance(part, dict):
             continue
         if part.get("type") in {"input_text", "text"} and isinstance(part.get("text"), str):
             text_chunks.append(str(part["text"]))
+        if part.get("type") == "input_image":
+            image_parts.append(part)
         if part.get("type") in {"input_audio", "audio"}:
             audio = part.get("audio") or part.get("data")
             if not isinstance(audio, str) or not audio:
@@ -1488,12 +1512,28 @@ def resolve_create_item(state: RealtimeProjectionState, command: CreateItem) ->
         }
         if transcript:
             commit_payload["transcript"] = transcript
-        return ResolvedControl(payloads=[*audio_payloads, commit_payload], events=ack_events)
-    if not text_chunks:
+        payloads: list[dict[str, object]] = []
+        if image_parts:
+            # The audio leaves as buffered appends that the commit seals, and
+            # that commit registers *this* item id against the spoken message.
+            # Images cannot ride it: the commit would overwrite them. So they
+            # travel as their own item, stored ahead of the audio describing
+            # them, under an id derived from the one the client named.
+            image_item = dict(item)
+            image_item["id"] = f"{item_id}_image"
+            image_item["status"] = "completed"
+            image_item["content"] = list(image_parts)
+            payloads.append({**signal_payload, "payload": {"item": image_item}})
+        payloads.extend([*audio_payloads, commit_payload])
+        return ResolvedControl(payloads=payloads, events=ack_events)
+    if not text_chunks and not image_parts:
         return ResolvedControl(payloads=[], events=ack_events)
-    text_item = dict(item)
-    text_item["status"] = "completed"
-    signal_payload["payload"] = {"item": text_item}
+    # An image is content in its own right, not a decoration on text. Dropping
+    # the payload here would still ack the item to the client, so the picture
+    # would be silently missing from every prompt that followed.
+    stored_item = dict(item)
+    stored_item["status"] = "completed"
+    signal_payload["payload"] = {"item": stored_item}
     return ResolvedControl(payloads=[signal_payload], events=ack_events)
 
 
diff --git a/vllm_omni/engine/duplex/session/append_task.py b/vllm_omni/engine/duplex/session/append_task.py
index 724dc7f82..6092f26cf 100644
--- a/vllm_omni/engine/duplex/session/append_task.py
+++ b/vllm_omni/engine/duplex/session/append_task.py
@@ -53,8 +53,11 @@ class AppendAttempt:
     retained_committed_payload: dict[str, object] | None
     #: Response reserved before submission, to be failed if submission does not happen.
     precreated_response_id: str | None
+    #: Commits timing state once the runtime accepts the append (before any
+    #: returned output event can clear the continuation chain).
+    on_append_accepted: Callable[[float], None] | None = None
     #: Last chance to call the append off, checked once the predecessor is done.
-    before_append: Callable[[], bool] | None
+    before_append: Callable[[], bool] | None = None
 
     # ------------------------------------------------------------------ #
     # Compensation                                                       #
@@ -107,8 +110,7 @@ class AppendAttempt:
             try:
                 predecessor_ok = await predecessor
             except asyncio.CancelledError:
-                current = asyncio.current_task()
-                if current is not None and current.cancelling():
+                if helpers.task_is_cancelling(asyncio.current_task()):
                     raise
                 predecessor_ok = False
             except Exception:
@@ -140,6 +142,7 @@ class AppendAttempt:
                 ),
                 final=self.final,
                 expected_epoch=self.epoch,
+                on_append_accepted=self.on_append_accepted,
             )
             if append_ok:
                 model_state.context_locked = True
@@ -155,8 +158,10 @@ class AppendAttempt:
                 self.ctx.run.runtime_closed = True
                 return False
             if not emitted_response and session.epoch == self.epoch:
-                if session.active_request_id == helpers.stage0_request_id(session, self.epoch):
-                    session.clear_request(self.request_id)
+                # Only if the session still points at this append's request:
+                # ``clear_request`` compares before it clears, and the id
+                # carries a turn suffix when the core request is not resumable.
+                session.clear_request(self.request_id)
                 if self.final:
                     self.out.emit_events([session.signal_turn(DuplexTurnEventType.USER_STARTED.value)])
             return append_ok
diff --git a/vllm_omni/engine/duplex/session/control.py b/vllm_omni/engine/duplex/session/control.py
index 2d46154fe..5de703acd 100644
--- a/vllm_omni/engine/duplex/session/control.py
+++ b/vllm_omni/engine/duplex/session/control.py
@@ -113,6 +113,19 @@ class SessionControl:
         except ValueError as exc:
             self._out.emit_error("bad_audio", str(exc))
             return None
+        if result.speech_started or result.speech_stopped:
+            logger.info(
+                "Duplex VAD session=%s started=%s stopped=%s active=%s probability=%.3f "
+                "start_ms=%s end_ms=%s commit=%s",
+                self._ctx.session.session_id,
+                result.speech_started,
+                result.speech_stopped,
+                result.speech_active,
+                result.speech_probability,
+                result.audio_start_ms,
+                result.audio_end_ms,
+                result.should_commit,
+            )
         apply_turn_detection_result(event, result)
         return result
 
@@ -310,6 +323,47 @@ class SessionControl:
                 name="duplex-continue",
             )
             return
+        item_payload = item if isinstance(item, dict) else None
+        raw_parts = item_payload.get("content", []) if item_payload is not None else []
+        parts: list[object] = [part for part in raw_parts] if isinstance(raw_parts, list) else []
+        images = [p for p in parts if isinstance(p, dict) and p.get("type") == "input_image"]
+        if images:
+            if item_payload is None or item_payload.get("role") != "user":
+                self._out.emit_error("invalid_image", "input_image is supported only in user messages")
+                return
+            if not session.capabilities.supports_image_input:
+                self._out.emit_error("unsupported", "This model does not support input_image conversation items")
+                return
+            from vllm_omni.engine.duplex.realtime_commands import validate_realtime_video_frames
+
+            urls: list[str] = []
+            for part in images:
+                url = part.get("image_url")
+                if not isinstance(url, str) or not url.startswith(
+                    ("data:image/jpeg;base64,", "data:image/png;base64,")
+                ):
+                    self._out.emit_error("invalid_image", "input_image requires a JPEG or PNG base64 data URL")
+                    return
+                error = validate_realtime_video_frames([url.split(",", 1)[1]], None)
+                if error:
+                    self._out.emit_error("invalid_image", error)
+                    return
+                urls.append(url)
+            existing: list[str] = []
+            for history_message in session.history:
+                content = history_message.get("content")
+                if not isinstance(content, list):
+                    continue
+                for part in content:
+                    if not isinstance(part, dict) or part.get("type") != "image_url":
+                        continue
+                    image_url = part.get("image_url")
+                    nested_url = image_url.get("url") if isinstance(image_url, dict) else None
+                    if isinstance(nested_url, str):
+                        existing.append(nested_url)
+            if len(existing) + len(urls) > 8 or sum(map(len, existing + urls)) > 4 * 1024 * 1024:
+                self._out.emit_error("input_backpressure", "Image context exceeds 8 images or 4 MiB; delete old items")
+                return
         message = realtime_item_to_history_message(item)
         item_id = item.get("id") if isinstance(item, dict) else None
         if message is not None:
diff --git a/vllm_omni/engine/duplex/session/engine_session.py b/vllm_omni/engine/duplex/session/engine_session.py
index bb5c38515..f181aaaea 100644
--- a/vllm_omni/engine/duplex/session/engine_session.py
+++ b/vllm_omni/engine/duplex/session/engine_session.py
@@ -20,7 +20,7 @@ import time
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from types import MappingProxyType
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 from vllm_omni.engine.duplex.config import (
@@ -53,6 +53,42 @@ def _default_lease() -> DuplexLeaseState:
     return DuplexLeaseState(config=DuplexLeaseConfig(), generation=0, last_activity=time.monotonic())
 
 
+def _object_dict(**fields: object) -> dict[str, object]:
+    return dict(fields)
+
+
+def _as_int(value: object, default: int = 0) -> int:
+    if isinstance(value, bool):
+        return default
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return int(value)
+    return default
+
+
+def _as_optional_int(value: object) -> int | None:
+    if value is None or isinstance(value, bool):
+        return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return int(value)
+    return None
+
+
+def _copy_mapping(value: object) -> dict[str, object] | None:
+    if not isinstance(value, dict):
+        return None
+    return {str(key): item for key, item in value.items()}
+
+
+def _copy_list(value: object) -> list[object] | None:
+    if not isinstance(value, list):
+        return None
+    return [item for item in value]
+
+
 @dataclass
 class InputBufferState:
     commit_seq: int = 0
@@ -624,7 +660,7 @@ class DuplexEngineSession:
             input_audio_part["transcript"] = transcript
         self._bind_active_response_to_input_commit(self._input.commit_seq + 1)
         self._input.commit_seq += 1
-        message = {"role": "user", "content": [input_audio_part]}
+        message = _object_dict(role="user", content=[input_audio_part])
         if transcript:
             message["transcript"] = transcript
         self._conversation.messages.append(message)
@@ -694,7 +730,7 @@ class DuplexEngineSession:
         self._response.stage_metric_tpot_weighted_ms.clear()
         self._response.stage_metric_tpot_weight.clear()
 
-    def stash_stage_metrics(self, stage_metrics: Mapping[object, object] | None) -> None:
+    def stash_stage_metrics(self, stage_metrics: Mapping[Any, Any] | None) -> None:
         """Hold a stage snapshot until a response exists to attribute it to.
 
         A stage that hands its output to the next stage instead of the client
@@ -706,9 +742,10 @@ class DuplexEngineSession:
         """
         if not isinstance(stage_metrics, Mapping):
             return
-        snapshot = {
-            str(stage_id): dict(values) for stage_id, values in stage_metrics.items() if isinstance(values, Mapping)
-        }
+        snapshot: dict[str, dict[str, object]] = {}
+        for stage_id, values in stage_metrics.items():
+            if isinstance(values, Mapping):
+                snapshot[str(stage_id)] = {str(key): value for key, value in values.items()}
         if not snapshot:
             return
         if self.active_response_id is not None:
@@ -718,7 +755,7 @@ class DuplexEngineSession:
 
     def accumulate_response_stage_metrics(
         self,
-        stage_metrics: Mapping[object, object] | None,
+        stage_metrics: Mapping[Any, Any] | None,
     ) -> dict[str, dict[str, object]]:
         if self.active_response_id is None:
             return copy.deepcopy(self._response.stage_metrics)
@@ -762,7 +799,9 @@ class DuplexEngineSession:
             for name in additive_fields:
                 value = raw_values.get(name)
                 if isinstance(value, int | float) and not isinstance(value, bool):
-                    current[name] = current.get(name, 0) + value
+                    previous = current.get(name, 0)
+                    addend = previous if isinstance(previous, int | float) and not isinstance(previous, bool) else 0
+                    current[name] = addend + value
             for name in first_positive_fields:
                 value = raw_values.get(name)
                 current_value = current.get(name)
@@ -776,7 +815,8 @@ class DuplexEngineSession:
             for list_name, mean_name in interval_fields:
                 values = raw_values.get(list_name)
                 if isinstance(values, list):
-                    combined = list(current.get(list_name, []))
+                    existing = current.get(list_name, [])
+                    combined = list(existing) if isinstance(existing, list) else []
                     combined.extend(
                         value for value in values if isinstance(value, int | float) and not isinstance(value, bool)
                     )
@@ -805,7 +845,7 @@ class DuplexEngineSession:
 
     def replace_response_stage_metric_snapshots(
         self,
-        stage_metrics: Mapping[object, object] | None,
+        stage_metrics: Mapping[Any, Any] | None,
     ) -> dict[str, dict[str, object]]:
         """Merge cumulative chat snapshots by replacing each stage's latest value."""
         if self.active_response_id is None or not isinstance(stage_metrics, Mapping):
@@ -839,8 +879,12 @@ class DuplexEngineSession:
         *,
         text_chars: int | None = None,
         audio_text_marks: list[dict[str, object]] | None = None,
+        text_requires_complete_audio: bool = False,
+        audio_complete: bool = False,
     ) -> None:
         playback = self._playback.current
+        playback.text_requires_complete_audio |= text_requires_complete_audio
+        playback.audio_complete |= audio_complete
         if duration_ms is not None:
             playback.generated_ms = max(playback.generated_ms, duration_ms)
             playback.sent_ms = max(playback.sent_ms, duration_ms)
@@ -925,9 +969,9 @@ class DuplexEngineSession:
             response_input_commit_seq = self.input_commit_seq
         response_history_is_late = self.input_commit_seq > response_input_commit_seq
         assistant_text = "".join(self._response.assistant_text_buffer).strip()
-        message = None
+        message: dict[str, object] | None = None
         if assistant_text:
-            self._conversation.last_assistant_full_message = {"role": "assistant", "content": assistant_text}
+            self._conversation.last_assistant_full_message = _object_dict(role="assistant", content=assistant_text)
             self._conversation.last_assistant_audio_text_marks = list(self._response.assistant_audio_text_marks)
             if response_id is not None:
                 self._conversation.assistant_response_snapshots[response_id] = (
@@ -943,7 +987,7 @@ class DuplexEngineSession:
         else:
             committed_text = ""
         if commit_text and committed_text:
-            message = {"role": "assistant", "content": committed_text}
+            message = _object_dict(role="assistant", content=committed_text)
             item_id = f"item_{response_id}" if response_id is not None else None
             if item_id is not None and item_id in self._conversation.history_item_placeholders:
                 self._store_history_item_message(item_id, message)
@@ -985,6 +1029,16 @@ class DuplexEngineSession:
             last_message, audio_text_marks, _ = response_snapshot
             self._conversation.pending_item_ids[item_id] = copy.deepcopy(last_message)
             self._conversation.pending_item_input_commit_seqs[item_id] = response_snapshot[2]
+            playback = self._playback_cursor_for_item_id(item_id)
+            if (
+                item_id in self._conversation.history_item_placeholders
+                and playback is not None
+                and playback.text_requires_complete_audio
+            ):
+                # Keep the assistant turn between its user inputs even when
+                # unaligned audio cannot establish any heard text. A later
+                # full playback ACK fills this same slot from the snapshot.
+                self._store_history_item_message(item_id, _object_dict(role="assistant", content=""))
             if audio_text_marks:
                 self._conversation.pending_item_audio_text_marks[item_id] = list(copy.deepcopy(audio_text_marks))
             pending_audio_ms = self._conversation.pending_truncations_ms.get(item_id)
@@ -1029,10 +1083,10 @@ class DuplexEngineSession:
             self._conversation.assistant_response_snapshots.pop(response_id, None)
         if message is None:
             return pending is not None or removed_placeholder
-        try:
-            self._conversation.messages.remove(message)
-        except ValueError:
-            pass
+        # Distinct response items can have identical (including empty) content.
+        self._conversation.messages = [
+            candidate for candidate in self._conversation.messages if candidate is not message
+        ]
         return True
 
     def truncate_history_item(
@@ -1078,8 +1132,8 @@ class DuplexEngineSession:
             self._conversation.pending_truncations_ms.pop(item_id, None)
             return True
 
-        message = self._conversation.item_ids.get(item_id)
-        if message is None:
+        stored_message = self._conversation.item_ids.get(item_id)
+        if stored_message is None:
             pending = self._conversation.pending_item_ids.get(item_id)
             if pending is None:
                 self._conversation.pending_truncations_ms[item_id] = max(0, int(audio_end_ms))
@@ -1113,6 +1167,7 @@ class DuplexEngineSession:
             if item_id.startswith("item_"):
                 self._conversation.assistant_response_snapshots.pop(item_id.removeprefix("item_"), None)
             return True
+        message = stored_message
         changed = self._truncate_message_to_audio_ms(
             message,
             audio_end_ms=audio_end_ms,
@@ -1122,10 +1177,9 @@ class DuplexEngineSession:
         if changed and self._message_text_len(message) <= 0:
             self._conversation.item_ids.pop(item_id, None)
             self._conversation.item_audio_text_marks.pop(item_id, None)
-            try:
-                self._conversation.messages.remove(message)
-            except ValueError:
-                pass
+            self._conversation.messages = [
+                candidate for candidate in self._conversation.messages if candidate is not message
+            ]
             if item_id.startswith("item_"):
                 self._conversation.assistant_response_snapshots.pop(item_id.removeprefix("item_"), None)
         elif changed and item_id.startswith("item_"):
@@ -1209,12 +1263,20 @@ class DuplexEngineSession:
         sent_ms = max(self.playback.sent_ms, self.playback.generated_ms)
         committed_ms = self.playback.committed_ms
         policy = playback_commit_policy or self.config.playback_commit_policy
+        commit_all = policy == DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
+        if self.playback.text_requires_complete_audio:
+            # Unaligned text has no spoken prefix to cut at, so history gets
+            # the whole answer or none of it. Under commit_all_on_done that
+            # choice is the whole answer --- which is also the only thing a
+            # client that never acks playback can be credited with.
+            if commit_all:
+                return assistant_text
+            keep_chars = self._text_chars_for_audio_ms(committed_ms, len(assistant_text))
+            return assistant_text[:keep_chars].rstrip()
         if sent_ms <= 0 or committed_ms >= sent_ms:
             return assistant_text
         if committed_ms <= 0:
-            if policy == DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value:
-                return assistant_text
-            return ""
+            return assistant_text if commit_all else ""
         keep_chars = self._text_chars_for_audio_ms(committed_ms, len(assistant_text))
         if keep_chars <= 0:
             return ""
@@ -1233,6 +1295,11 @@ class DuplexEngineSession:
         audio_end_ms = max(0, int(audio_end_ms))
         marks = marks if marks is not None else self._response.assistant_audio_text_marks
         playback = playback or self._playback.current
+        if playback.text_requires_complete_audio:
+            # Unaligned streams cannot establish a spoken prefix. A terminal
+            # boundary plus its playback ACK can establish the whole answer.
+            total_ms = max(playback.sent_ms, playback.generated_ms)
+            return text_len if playback.audio_complete and total_ms > 0 and audio_end_ms >= total_ms else 0
         if not marks:
             sent_ms = max(1, playback.sent_ms, playback.generated_ms)
             return int(text_len * max(0.0, min(1.0, audio_end_ms / sent_ms)))
@@ -1307,11 +1374,9 @@ class DuplexEngineSession:
         elif event_type == DuplexTurnEventType.ASSISTANT_DONE.value:
             self.transition_turn(DuplexTurnState.IDLE)
         elif event_type == DuplexTurnEventType.PLAYBACK_ACK.value:
-            played_ms = int(payload.get("played_ms", 0) or 0)
-            committed_ms = payload.get("committed_ms")
             self.acknowledge_playback(
-                played_ms,
-                int(committed_ms) if isinstance(committed_ms, int | float) else None,
+                _as_int(payload.get("played_ms", 0)),
+                _as_optional_int(payload.get("committed_ms")),
             )
         elif event_type == DuplexTurnEventType.BARGE_IN.value:
             self.transition_turn(DuplexTurnState.BARGE_IN)
@@ -1346,29 +1411,45 @@ class DuplexEngineSession:
             "playback": self.playback.as_dict(),
             "capabilities": self.capabilities.as_dict(),
         }
-        if isinstance(self.config.extra_body.get("realtime_tools"), list):
-            payload["tools"] = self.config.extra_body["realtime_tools"]
-        if isinstance(self.config.extra_body.get("realtime_tool_choice"), str | dict):
-            payload["tool_choice"] = self.config.extra_body["realtime_tool_choice"]
-        if isinstance(self.config.extra_body.get("realtime_metadata"), dict):
-            payload["metadata"] = dict(self.config.extra_body["realtime_metadata"])
-        if isinstance(self.config.extra_body.get("realtime_include"), list):
-            payload["include"] = list(self.config.extra_body["realtime_include"])
-        if isinstance(self.config.extra_body.get("realtime_prompt"), dict):
-            payload["prompt"] = dict(self.config.extra_body["realtime_prompt"])
-        if isinstance(self.config.extra_body.get("realtime_input_audio_transcription"), dict):
-            payload["input_audio_transcription"] = dict(self.config.extra_body["realtime_input_audio_transcription"])
-        if isinstance(self.config.extra_body.get("realtime_input_audio_noise_reduction"), dict):
-            payload["input_audio_noise_reduction"] = dict(
-                self.config.extra_body["realtime_input_audio_noise_reduction"]
-            )
-        if isinstance(self.config.extra_body.get("realtime_audio"), dict):
-            payload["audio"] = dict(self.config.extra_body["realtime_audio"])
-        if isinstance(self.config.extra_body.get("realtime_tracing"), str | dict):
-            payload["tracing"] = self.config.extra_body["realtime_tracing"]
-        raw_realtime_session = self.config.extra_body.get("realtime_session_payload")
-        if isinstance(raw_realtime_session, dict):
-            for key, value in raw_realtime_session.items():
+        extra_body = self.config.extra_body
+        realtime_tools = _copy_list(extra_body.get("realtime_tools"))
+        if realtime_tools is not None:
+            payload["tools"] = realtime_tools
+        realtime_tool_choice = extra_body.get("realtime_tool_choice")
+        if isinstance(realtime_tool_choice, str):
+            payload["tool_choice"] = realtime_tool_choice
+        else:
+            copied_tool_choice = _copy_mapping(realtime_tool_choice)
+            if copied_tool_choice is not None:
+                payload["tool_choice"] = copied_tool_choice
+        realtime_metadata = _copy_mapping(extra_body.get("realtime_metadata"))
+        if realtime_metadata is not None:
+            payload["metadata"] = realtime_metadata
+        realtime_include = _copy_list(extra_body.get("realtime_include"))
+        if realtime_include is not None:
+            payload["include"] = realtime_include
+        realtime_prompt = _copy_mapping(extra_body.get("realtime_prompt"))
+        if realtime_prompt is not None:
+            payload["prompt"] = realtime_prompt
+        realtime_transcription = _copy_mapping(extra_body.get("realtime_input_audio_transcription"))
+        if realtime_transcription is not None:
+            payload["input_audio_transcription"] = realtime_transcription
+        realtime_noise_reduction = _copy_mapping(extra_body.get("realtime_input_audio_noise_reduction"))
+        if realtime_noise_reduction is not None:
+            payload["input_audio_noise_reduction"] = realtime_noise_reduction
+        realtime_audio = _copy_mapping(extra_body.get("realtime_audio"))
+        if realtime_audio is not None:
+            payload["audio"] = realtime_audio
+        realtime_tracing = extra_body.get("realtime_tracing")
+        if isinstance(realtime_tracing, str):
+            payload["tracing"] = realtime_tracing
+        else:
+            copied_tracing = _copy_mapping(realtime_tracing)
+            if copied_tracing is not None:
+                payload["tracing"] = copied_tracing
+        copied_session = _copy_mapping(extra_body.get("realtime_session_payload"))
+        if copied_session is not None:
+            for key, value in copied_session.items():
                 if key not in payload and key != "extra_body":
                     payload[key] = value
         return payload
diff --git a/vllm_omni/engine/duplex/session/helpers.py b/vllm_omni/engine/duplex/session/helpers.py
index f8b705e6d..02ae1b7ca 100644
--- a/vllm_omni/engine/duplex/session/helpers.py
+++ b/vllm_omni/engine/duplex/session/helpers.py
@@ -13,14 +13,16 @@ Functions, not a component, because there is nothing here to own.
 
 from __future__ import annotations
 
+import asyncio
 import binascii
 from typing import TYPE_CHECKING
 
 import pybase64 as base64
 
 from vllm_omni.engine.duplex.config import DuplexPlaybackCommitPolicy
-from vllm_omni.engine.duplex.contracts import DuplexFence, duplex_resource_request_id
+from vllm_omni.engine.duplex.contracts import DuplexFence
 from vllm_omni.engine.duplex.events import ErrorEvent, OverlapDecision, error_event
+from vllm_omni.engine.duplex.plugin import payload_turn_id
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -29,13 +31,38 @@ if TYPE_CHECKING:
     from vllm_omni.engine.duplex.session.engine_session import DuplexCommittedInput, DuplexEngineSession
 
 
+def task_is_cancelling(task: asyncio.Task[object] | None) -> bool:
+    """True when *task* has a pending cancellation (Python 3.11+ ``Task.cancelling``)."""
+    if task is None:
+        return False
+    cancelling = getattr(task, "cancelling", None)
+    return bool(cancelling()) if callable(cancelling) else False
+
+
 # --------------------------------------------------------------------------- #
 # Questions about the session                                                 #
 # --------------------------------------------------------------------------- #
 
 
-def stage0_request_id(session: DuplexEngineSession, epoch: int) -> str:
-    return duplex_resource_request_id(DuplexFence(session.session_id, epoch=epoch), "stage0")
+def append_fence(session: DuplexEngineSession, payload: object, *, epoch: int | None = None) -> DuplexFence:
+    """The fence one append is submitted under.
+
+    A model without a resumable core request gets one stage request per turn,
+    so the turn this resolves to is part of the request id. The runner names
+    that id when it queues the append and the model channel names it again
+    when it submits, and the two must not disagree --- otherwise the session
+    binds a request id it never submitted.
+    """
+    turn_id = payload_turn_id(payload)
+    if turn_id is None:
+        turn_id = session.active_response_turn_id
+    if turn_id is None:
+        turn_id = session.turn_id
+    return DuplexFence(
+        session.session_id,
+        epoch=session.epoch if epoch is None else epoch,
+        turn_id=turn_id,
+    )
 
 
 def response_in_progress(session: DuplexEngineSession, tasks: DuplexSessionTasks) -> bool:
diff --git a/vllm_omni/engine/duplex/session/manager.py b/vllm_omni/engine/duplex/session/manager.py
index 0b7a7a07e..e09881abe 100644
--- a/vllm_omni/engine/duplex/session/manager.py
+++ b/vllm_omni/engine/duplex/session/manager.py
@@ -408,8 +408,11 @@ class DuplexSessionManager:
         return configured
 
     @staticmethod
-    def stage_request_id(fence: DuplexFence, *, stage_id: int) -> str:
-        return duplex_resource_request_id(fence, f"stage{stage_id}")
+    def stage_request_id(fence: DuplexFence, *, stage_id: int, resumable: bool = True) -> str:
+        role = f"stage{stage_id}"
+        if not resumable:
+            role += f"-turn{fence.turn_id}"
+        return duplex_resource_request_id(fence, role)
 
     def ensure_stage_request(
         self,
@@ -422,7 +425,9 @@ class DuplexSessionManager:
         if stage_id >= self.stage_port.stage_count:
             return None
         effective_fence = fence or session.fence
-        request_id = self.stage_request_id(effective_fence, stage_id=stage_id)
+        request_id = self.stage_request_id(
+            effective_fence, stage_id=stage_id, resumable=session.capabilities.supports_core_resumable_request
+        )
         session.reserve_stage_request(stage_id, request_id, fence=effective_fence)
         context = DuplexStageRequestContext(
             request_id=request_id,
diff --git a/vllm_omni/engine/duplex/session/model_channel.py b/vllm_omni/engine/duplex/session/model_channel.py
index 322db7ede..f244a6859 100644
--- a/vllm_omni/engine/duplex/session/model_channel.py
+++ b/vllm_omni/engine/duplex/session/model_channel.py
@@ -22,6 +22,8 @@ tracked task, and aborting a stage request in the background.
 from __future__ import annotations
 
 import asyncio
+import copy
+import time
 import uuid
 from collections.abc import Awaitable, Callable, Mapping
 from dataclasses import replace
@@ -42,8 +44,8 @@ from vllm_omni.engine.duplex.contracts import (
 from vllm_omni.engine.duplex.plugin import (
     DuplexRuntimeConfigError,
     coerce_int,
-    payload_turn_id,
 )
+from vllm_omni.engine.duplex.session import helpers
 from vllm_omni.engine.duplex.session.context import DuplexSessionContext, StageOutput
 from vllm_omni.engine.duplex.session.emitter import SessionEmitter
 from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession, DuplexFenceMismatchError
@@ -113,6 +115,13 @@ class ModelChannel:
     ) -> dict[str, object]:
         session = self._ctx.session
         response_config = session.response_config
+        if not session.capabilities.supports_core_resumable_request and self.should_commit_response_to_history(
+            session, response_id
+        ):
+            # Committed-turn models can receive the next utterance before the
+            # speaker drains. Reserve the response's chronological slot now;
+            # an ACK fills it later without moving it past newer user input.
+            session.reserve_history_item(f"item_{response_id}")
         payload: dict[str, object] = {
             "type": "response.created",
             "session_id": session.session_id,
@@ -146,12 +155,16 @@ class ModelChannel:
         operation_id: str | None = None,
         final: bool,
         expected_epoch: int | None = None,
+        on_append_accepted: Callable[[float], None] | None = None,
     ) -> tuple[bool, bool]:
         session = self._ctx.session
         if not session.capabilities.supports_input_append:
             return True, False
         if expected_epoch is not None and session.epoch != expected_epoch:
             return True, False
+        # Anchor the submission time before the RPC; the acceptance callback
+        # commits timing state only if the append actually submitted.
+        submit_time = time.monotonic()
         try:
             result = await self._append_via_data_plane(
                 payload,
@@ -169,6 +182,10 @@ class ModelChannel:
             return True, False
         if expected_epoch is not None and session.epoch != expected_epoch:
             return True, False
+        # Commit timing state before returned output events can clear the
+        # silence-continuation chain (e.g. a terminal turn-end).
+        if on_append_accepted is not None:
+            on_append_accepted(submit_time)
         request_id, _ = duplex_data_plane_request_info(result)
         if request_id is not None:
             self._ctx.plugin.data_plane.begin_request(request_id)
@@ -193,22 +210,13 @@ class ModelChannel:
         session = self._ctx.session
         if self._ctx.stage_port.stage_count == 0:
             raise RuntimeError("duplex_data_plane_has_no_stage")
-        payload_turn = payload_turn_id(payload)
-        fence = DuplexFence(
-            session.session_id,
-            epoch=session.epoch,
-            turn_id=(
-                payload_turn
-                if payload_turn is not None
-                else (
-                    session.active_response_turn_id if session.active_response_turn_id is not None else session.turn_id
-                )
-            ),
-        )
+        fence = helpers.append_fence(session, payload)
         lease_operation_id = f"append:{operation_id or uuid.uuid4().hex}"
         operation_started = False
         stage_id = 0
-        request_id = self._ctx.manager.stage_request_id(fence, stage_id=stage_id)
+        request_id = self._ctx.manager.stage_request_id(
+            fence, stage_id=stage_id, resumable=session.capabilities.supports_core_resumable_request
+        )
         try:
             session.begin_lease_operation(fence, lease_operation_id)
             operation_started = True
@@ -217,10 +225,17 @@ class ModelChannel:
             request_context = self._ctx.manager.ensure_stage_request(session, stage_id=stage_id, fence=fence)
             if request_context is None:
                 raise RuntimeError("duplex_data_plane_has_no_stage")
-            append_plan = self._ctx.plugin.plan_append(
+            prompt_payload: dict[str, object] = (
+                {str(key): value for key, value in payload.items()} if isinstance(payload, Mapping) else {}
+            )
+            append_plan = await self._ctx.plugin.prepare_append_plan(
                 request_id=request_id,
                 fence=fence,
-                session_config=dict(request_context.session_config),
+                session_config=self._ctx.plugin.prepare_prompt_config(
+                    {**request_context.session_config, "conversation": list(session.history)},
+                    state=self._ctx.model_state,
+                    payload=prompt_payload,
+                ),
                 runtime_config=dict(request_context.runtime_config),
                 seq=reservation.update.seq,
                 turn_seq=reservation.update.turn_seq,
@@ -228,6 +243,10 @@ class ModelChannel:
                 final=final,
                 sampling_params=request_context.stage_sampling_params,
             )
+            # Preparation may yield while cancellation or session teardown runs.
+            # Never submit the worker's stale result to the model.
+            if session.epoch != fence.epoch or session.state != DuplexSessionState.OPEN:
+                raise DuplexFenceMismatchError(session.fence, fence)
             if not isinstance(append_plan, DuplexAppendPlan):
                 raise TypeError("duplex plugin plan_append() must return DuplexAppendPlan")
             submission = DuplexStageSubmission(
@@ -270,7 +289,7 @@ class ModelChannel:
                             "seq": update.seq,
                             "turn_id": update.turn_id,
                             "turn_seq": update.turn_seq,
-                            "resumable": True,
+                            "resumable": session.capabilities.supports_core_resumable_request,
                         },
                     }
                 ],
@@ -404,7 +423,7 @@ class ModelChannel:
             engine_output.finished = True
             engine_output = attach_duplex_output_decision(engine_output, item.decision)
         elif isinstance(output, OmniRequestOutput):
-            engine_output = output
+            engine_output = copy.copy(output)
             if finished:
                 engine_output.finished = True
         else:
@@ -416,6 +435,9 @@ class ModelChannel:
                 stage_id=item.stage_id,
                 final_output_type=final_output_type if isinstance(final_output_type, str) else "audio",
             )
+        engine_output.stage_id = item.stage_id
+        if self._ctx.plugin.projects_intermediate_outputs and item.stage_id < item.context.final_stage_id:
+            engine_output.finished = False
         snapshot = self.stage_metrics_snapshot(item.stage_id, item.metrics, output)
         if snapshot is not None:
             existing = engine_output.metrics if isinstance(engine_output.metrics, dict) else {}
@@ -452,6 +474,11 @@ class ModelChannel:
             await self._close_from_runtime(close_reason)
             return
         finished = self._data_plane_outputs_finished(drain_result)
+        if finished and not session.capabilities.supports_core_resumable_request:
+            if self._ctx.run.stream_request_id == item.request_id:
+                self._ctx.run.stream_request_id = None
+            await self._ctx.stage_port.cleanup([item.request_id])
+            return
         if finished and emitted_response and not self._out.auto_responds():
             # A finished, emitted response releases the per-request projector
             # cursor on its way out and offers the model another
@@ -750,8 +777,9 @@ class ModelChannel:
             response_id = session.begin_response(turn_id=model_turn_id)
             response_created = True
             self._out.emit(self.response_created_payload(response_id, epoch=session.epoch))
+        stage_metrics = model_result.get("stage_metrics")
         response_stage_metrics = session.accumulate_response_stage_metrics(
-            model_result.get("stage_metrics") if isinstance(model_result.get("stage_metrics"), Mapping) else None
+            stage_metrics if isinstance(stage_metrics, Mapping) else None
         )
         if response_created:
             speak_payload = {
@@ -796,6 +824,8 @@ class ModelChannel:
             mark_duration_ms,
             text_chars=mark_text_chars if mark_duration_ms is not None else None,
             audio_text_marks=audio_text_marks,
+            text_requires_complete_audio=model_result.get("text_requires_complete_audio") is True,
+            audio_complete=model_result.get("audio_complete") is True,
         )
         payload = {
             "type": "response.output_audio.delta",
@@ -895,10 +925,10 @@ class ModelChannel:
         *,
         audio_offset_ms: int,
         text_offset_chars: int,
-    ) -> list[dict[str, int]] | None:
+    ) -> list[dict[str, object]] | None:
         if not audio_text_marks:
             return None
-        normalized: list[dict[str, int]] = []
+        normalized: list[dict[str, object]] = []
         for raw_mark in audio_text_marks:
             if not isinstance(raw_mark, dict):
                 continue
diff --git a/vllm_omni/engine/duplex/session/runner.py b/vllm_omni/engine/duplex/session/runner.py
index 7915500b7..1ca248fef 100644
--- a/vllm_omni/engine/duplex/session/runner.py
+++ b/vllm_omni/engine/duplex/session/runner.py
@@ -21,6 +21,7 @@ orchestrator loop (the session is never touched from another thread):
 from __future__ import annotations
 
 import asyncio
+import time
 import uuid
 from collections.abc import Awaitable, Callable, Mapping
 from dataclasses import dataclass, field
@@ -28,7 +29,6 @@ from typing import TYPE_CHECKING, TypeVar
 
 from vllm.logger import init_logger
 
-from vllm_omni.engine.duplex.audio import convert_input_audio_with_rate
 from vllm_omni.engine.duplex.commands import (
     AckPlayback,
     AppendAudio,
@@ -71,7 +71,6 @@ from vllm_omni.engine.duplex.plugin import (
     DuplexModelPlugin,
     DuplexModelSessionState,
     PcmAppendReservation,
-    payload_turn_id,
 )
 from vllm_omni.engine.duplex.realtime_events import (
     RealtimeProjectionState,
@@ -103,6 +102,7 @@ from vllm_omni.engine.duplex.turn_detection import (
     TurnDetectionResult,
 )
 from vllm_omni.metrics.stats import StageRequestStats
+from vllm_omni.protocol.duplex import convert_input_audio_with_rate
 
 if TYPE_CHECKING:
     from vllm.config import ModelConfig
@@ -126,6 +126,38 @@ class _Internal:
 _CANCEL_EVENTS = frozenset({"input.cancel", "response.cancel", "barge_in", "output_audio_buffer.clear"})
 
 
+def compute_silence_continuation_deadline(
+    *,
+    chunk_period_s: float,
+    now: float,
+    last_submit: float | None,
+    current_deadline: float | None,
+) -> tuple[float, float]:
+    """Return the silence continuation schedule ``(delay_s, next_silence_deadline)``.
+
+    The first continuation anchors to the latest accepted append's submission
+    time (``last_submit + chunk_period_s``), falling back to ``now`` when no
+    submission exists. Later continuations advance from the current deadline
+    instead of from ``now``, so pipeline processing time does not accumulate
+    as timer drift. When the schedule is more than one period overdue it is
+    stale: one continuation submits immediately and the schedule restarts
+    from ``now`` (``next_silence_deadline = now + chunk_period_s``) instead of
+    firing a burst of catch-ups.
+
+    ``delay_s`` is the wait before this continuation and
+    ``next_silence_deadline`` the deadline for the following one.
+    """
+    if current_deadline is None:
+        base = last_submit if last_submit is not None else now
+        deadline = base + chunk_period_s
+    else:
+        deadline = current_deadline
+    if now - deadline > chunk_period_s:
+        deadline = now
+    delay_s = max(0.0, deadline - now)
+    return delay_s, deadline + chunk_period_s
+
+
 class DuplexSessionRunner:
     """Owns one ``DuplexEngineSession`` on the orchestrator loop (see module docstring)."""
 
@@ -218,7 +250,8 @@ class DuplexSessionRunner:
         if stage_id < context.final_stage_id:
             decision = self.model.decide_output(stage_id, output, context)
         consume = decision is not None or stage_id >= context.final_stage_id
-        if not consume:
+        project_intermediate = self.plugin.projects_intermediate_outputs and stage_id == 0
+        if not consume and not project_intermediate:
             # Stage0 text without a direct decision feeds the TTS stage as before.
             # Its metrics still have to reach the client: before sessions moved
             # into the engine the orchestrator published them as a standalone
@@ -241,7 +274,7 @@ class DuplexSessionRunner:
                 decision=decision,
             )
         )
-        return True
+        return consume
 
     def on_stage_failure(self, stage_id: int, exc: BaseException) -> None:
         """A stage rejected this session's request: fail the active response now.
@@ -401,12 +434,11 @@ class DuplexSessionRunner:
             worker.cancel()
             await asyncio.gather(worker, return_exceptions=True)
 
-    def spawn(self, coro: Awaitable[None], *, name: str) -> asyncio.Task[None]:
+    def spawn(self, coro: Awaitable[None], *, name: str) -> None:
         task = asyncio.ensure_future(coro)
         task.set_name(name)
         self._background_tasks.add(task)
         task.add_done_callback(self._background_tasks.discard)
-        return task
 
     async def offload(self, fn: Callable[..., _OffloadT], *args: object, **kwargs: object) -> _OffloadT:
         loop = self._loop or asyncio.get_running_loop()
@@ -506,14 +538,14 @@ class DuplexSessionRunner:
         elif isinstance(command, ClearInput):
             self._on_clear_input()
         elif isinstance(command, CancelResponse):
-            resolved = resolve_cancel_response(projector, command)
-            self._emit_events(resolved.events)
-            for payload in resolved.payloads:
+            control = resolve_cancel_response(projector, command)
+            self._emit_events(control.events)
+            for payload in control.payloads:
                 await self._on_cancel(payload)
         elif isinstance(command, ClearOutputAudio):
-            resolved = resolve_clear_output_audio(projector, command)
-            self._emit_events(resolved.events)
-            for payload in resolved.payloads:
+            control = resolve_clear_output_audio(projector, command)
+            self._emit_events(control.events)
+            for payload in control.payloads:
                 await self._on_cancel(payload)
         elif isinstance(command, CancelInput | BargeIn):
             await self._on_cancel(command.payload())
@@ -531,7 +563,8 @@ class DuplexSessionRunner:
                 return
             payload = command.payload()
             if command.event in _CANCEL_EVENTS:
-                normalized = dict(payload.get("payload") or {})
+                inner = payload.get("payload")
+                normalized: dict[str, object] = dict(inner) if isinstance(inner, Mapping) else {}
                 normalized.update(payload)
                 normalized["type"] = command.event
                 await self._on_cancel(normalized)
@@ -544,19 +577,19 @@ class DuplexSessionRunner:
         elif isinstance(command, Heartbeat):
             self._on_heartbeat(command)
         elif isinstance(command, CreateItem):
-            resolved = resolve_create_item(projector, command)
-            self._emit_events(resolved.events)
-            for payload in resolved.payloads:
+            control = resolve_create_item(projector, command)
+            self._emit_events(control.events)
+            for payload in control.payloads:
                 await self._run_internal_payload(payload)
         elif isinstance(command, DeleteItem):
-            resolved = resolve_delete_item(projector, command)
-            self._emit_events(resolved.events)
-            for payload in resolved.payloads:
+            control = resolve_delete_item(projector, command)
+            self._emit_events(control.events)
+            for payload in control.payloads:
                 await self.control.on_turn_signal(payload)
         elif isinstance(command, TruncateItem):
-            resolved = resolve_truncate_item(projector, command)
-            self._emit_events(resolved.events)
-            for payload in resolved.payloads:
+            control = resolve_truncate_item(projector, command)
+            self._emit_events(control.events)
+            for payload in control.payloads:
                 await self._run_internal_payload(payload)
         elif isinstance(command, CloseSession):
             await self._on_close_command(command.reason)
@@ -743,7 +776,7 @@ class DuplexSessionRunner:
         sr_raw = event.get("sample_rate_hz") or event.get("sample_rate")
         sample_rate_hz = sr_raw if isinstance(sr_raw, int | float) else 16000
         try:
-            audio, fmt, sample_rate_hz = await self.offload(
+            converted: tuple[object, object, int | float | None] = await self.offload(
                 convert_input_audio_with_rate,
                 audio,
                 fmt,
@@ -752,13 +785,25 @@ class DuplexSessionRunner:
         except ValueError as exc:
             self._emit_error("bad_event", str(exc))
             return
+        audio, fmt, converted_rate = converted
+        if converted_rate is not None:
+            sample_rate_hz = converted_rate
         if isinstance(fmt, str) and fmt.lower() in {"pcm16", "pcm_s16le", "s16le"}:
             self._emit_error("bad_audio", "input_audio_buffer.append pcm16 audio could not be decoded")
             return
         event["audio"] = audio
         event["format"] = fmt
         event["sample_rate_hz"] = sample_rate_hz
+        client_force_listen = bool(event.get("force_listen", False))
         vad_result = await self.control.run_turn_detection(event)
+        if (
+            vad_result is not None
+            and not session.capabilities.supports_core_resumable_request
+            and not client_force_listen
+        ):
+            # VAD's force_listen hint controls native model decoding. Committed
+            # turn models already buffer speech; it must not suppress barge-in.
+            event.pop("force_listen", None)
         projector = self._require_projector()
         self._emit_events(note_input_append(projector, event, vad_result=vad_result))
         if self.run.closing or session.state != DuplexSessionState.OPEN:
@@ -863,8 +908,11 @@ class DuplexSessionRunner:
             return
         if pcm_reservation.byte_count == 0:
             session.release_input_bytes(raw_audio_bytes)
-        payload = pcm_reservation.payload
-        await self._start_append(payload, final=False, pcm_reservation=pcm_reservation)
+        append_payload = pcm_reservation.payload
+        if append_payload is None:
+            self._maybe_schedule_vad_commit(vad_result)
+            return
+        await self._start_append(append_payload, final=False, pcm_reservation=pcm_reservation)
         self._maybe_schedule_vad_commit(vad_result)
 
     def _maybe_schedule_vad_commit(self, vad_result: TurnDetectionResult | None) -> None:
@@ -918,17 +966,30 @@ class DuplexSessionRunner:
         operation_id: str | None = None,
         retained_committed_payload: dict[str, object] | None = None,
         silence_continuation: bool = False,
+        on_append_accepted: Callable[[float], None] | None = None,
         before_append: Callable[[], bool] | None = None,
     ) -> asyncio.Task[bool]:
         session = self.session
         model_state = self.model_state
         if not silence_continuation:
             self._mark_pending_silence_superseded()
+            if on_append_accepted is None:
+                # A real (non-silence) input re-anchors the silence pacing
+                # chain: its submission becomes the anchor and the stored
+                # deadline is cleared until the next continuation sets one.
+                def _reanchor_chain(submit_time: float) -> None:
+                    model_state.last_native_submit_monotonic = submit_time
+                    model_state.silence_deadline_monotonic = None
+
+                on_append_accepted = _reanchor_chain
         append_epoch = session.epoch
-        append_turn_id = payload_turn_id(payload)
-        if append_turn_id is None:
-            append_turn_id = session.turn_id
-        request_id = helpers.stage0_request_id(self.session, append_epoch)
+        append_fence = helpers.append_fence(session, payload, epoch=append_epoch)
+        append_turn_id = append_fence.turn_id
+        request_id = self.ctx.manager.stage_request_id(
+            append_fence,
+            stage_id=0,
+            resumable=session.capabilities.supports_core_resumable_request,
+        )
         if final or precreate_response:
             session.bind_request(request_id)
         if precreate_response:
@@ -936,6 +997,14 @@ class DuplexSessionRunner:
         if precreate_response and session.active_response_id is None:
             response_id = session.begin_response(turn_id=append_turn_id)
             self.emit(self.model.response_created_payload(response_id, epoch=append_epoch))
+        if final and not session.capabilities.supports_core_resumable_request:
+            logger.info(
+                "Duplex committed turn session=%s request=%s response=%s audio_bytes=%s",
+                session.session_id,
+                request_id,
+                session.active_response_id,
+                helpers.audio_payload_size_bytes(payload),
+            )
         attempt = AppendAttempt(
             ctx=self.ctx,
             out=self.out,
@@ -949,6 +1018,7 @@ class DuplexSessionRunner:
             operation_id=operation_id,
             retained_committed_payload=retained_committed_payload,
             precreated_response_id=session.active_response_id if precreate_response else None,
+            on_append_accepted=on_append_accepted,
             before_append=before_append,
         )
 
@@ -990,8 +1060,7 @@ class DuplexSessionRunner:
         try:
             return await predecessor
         except asyncio.CancelledError:
-            current = asyncio.current_task()
-            if current is not None and current.cancelling():
+            if helpers.task_is_cancelling(asyncio.current_task()):
                 raise
             return False
         except Exception:
@@ -1019,8 +1088,7 @@ class DuplexSessionRunner:
                 if not await pending_silence:
                     return False
             except asyncio.CancelledError:
-                current = asyncio.current_task()
-                if current is not None and current.cancelling():
+                if helpers.task_is_cancelling(asyncio.current_task()):
                     raise
                 return False
             except Exception:
@@ -1032,29 +1100,60 @@ class DuplexSessionRunner:
         append_tail = self.tasks.append_tail
         if (append_tail is None or append_tail.done()) and self._real_input_waiting():
             return False
-        continuation_delay_s = max(0.0, float(session.capabilities.chunk_period_ms or 1000) / 1000.0)
-        if continuation_delay_s > 0:
-            await asyncio.sleep(continuation_delay_s)
-            if (
-                self.tasks.append_tail is not append_tail
-                or ((append_tail is None or append_tail.done()) and self._real_input_waiting())
-                or self.model.silence_continuation_is_stale(
+        chunk_period_s = max(0.0, float(session.capabilities.chunk_period_ms or 1000) / 1000.0)
+        # Snapshot the anchor after any wait for pending silence. A real append
+        # accepted between the snapshot and this continuation's submission
+        # re-anchors the chain; _still_valid() then skips the stale unit.
+        anchor = model_state.last_native_submit_monotonic
+        # Align the next silence unit to submission_time_N + chunk_period and
+        # sleep only the remaining budget. The deadline is stored by the
+        # acceptance callback when the append actually submits, so skipped or
+        # stale continuations never advance the clock.
+        delay_s, next_silence_deadline = compute_silence_continuation_deadline(
+            chunk_period_s=chunk_period_s,
+            now=time.monotonic(),
+            last_submit=anchor,
+            current_deadline=model_state.silence_deadline_monotonic,
+        )
+        if delay_s > 0:
+            await asyncio.sleep(delay_s)
+        if (
+            self.tasks.append_tail is not append_tail
+            or ((append_tail is None or append_tail.done()) and self._real_input_waiting())
+            or self.model.silence_continuation_is_stale(
+                request_id=request_id,
+                response_id=response_id,
+                response_owned=response_owned,
+                expected_epoch=expected_epoch,
+                expected_model_turn_id=expected_model_turn_id,
+            )
+        ):
+            return False
+
+        def _still_valid() -> bool:
+            return (
+                # The anchor changed (a real append was accepted) after this
+                # continuation was planned; the unit is outdated.
+                model_state.last_native_submit_monotonic == anchor
+                and not self._real_input_waiting()
+                and not self.model.silence_continuation_is_stale(
                     request_id=request_id,
                     response_id=response_id,
                     response_owned=response_owned,
                     expected_epoch=expected_epoch,
                     expected_model_turn_id=expected_model_turn_id,
                 )
-            ):
-                return False
+            )
 
-        def _still_valid() -> bool:
-            return not self._real_input_waiting() and not self.model.silence_continuation_is_stale(
-                request_id=request_id,
-                response_id=response_id,
-                response_owned=response_owned,
-                expected_epoch=expected_epoch,
-                expected_model_turn_id=expected_model_turn_id,
+        def _on_append_accepted(submit_time: float) -> None:
+            # Commit timing state once the runtime accepts the append. If the
+            # submission is more than one chunk period past the planned
+            # deadline, the schedule is stale: restart from the actual
+            # submission. Small delays keep the planned cadence so ordinary
+            # jitter does not accumulate as drift.
+            model_state.last_native_submit_monotonic = submit_time
+            model_state.silence_deadline_monotonic = (
+                submit_time + chunk_period_s if submit_time > next_silence_deadline else next_silence_deadline
             )
 
         model_state.pending_silence_owner_id = owner_id
@@ -1062,6 +1161,7 @@ class DuplexSessionRunner:
             dict(payload) if isinstance(payload, dict) else {},
             final=False,
             silence_continuation=True,
+            on_append_accepted=_on_append_accepted,
             before_append=_still_valid,
         )
         return task is not None
@@ -1213,7 +1313,7 @@ class DuplexSessionRunner:
                 {
                     "type": "audio.cancelled",
                     "session_id": session.session_id,
-                    "response_id": session.active_response_id,
+                    "response_id": event.get("response_id") or session.active_response_id,
                     "reason": cancel_reason,
                     "cancelled_epoch": session.epoch,
                     "epoch": session.epoch,
@@ -1447,6 +1547,10 @@ class DuplexSessionRunner:
                 retained_committed_payload=committed_payload,
             )
             return
+        if session.unanswered_user_items() and session.capabilities.supports_text_only_turn:
+            session.reset_unanswered_user_items()
+            await self._start_append({"type": "conversation"}, final=True, precreate_response=True)
+            return
         if session.unanswered_user_items():
             # Conversation items are context, not a turn. A model-native model
             # decides to speak from the audio it hears, and there is no audio
@@ -1525,13 +1629,16 @@ class DuplexSessionRunner:
         if deferred_payload is None:
             commit_reservation.commit()
             return False
+        retained_payload: dict[str, object]
         if model_state.committed_audio_payload is not None:
-            deferred_payload = overlap_policy.merge_audio_payloads(
+            retained_payload = overlap_policy.merge_audio_payloads(
                 model_state.committed_audio_payload,
                 deferred_payload,
             )
+        else:
+            retained_payload = deferred_payload
         model_state.retain_committed_audio(
-            deferred_payload,
+            retained_payload,
             operation_id=commit_reservation.operation_id,
             reserved_bytes=commit_reservation.byte_count,
         )
diff --git a/vllm_omni/engine/duplex/vad.py b/vllm_omni/engine/duplex/vad.py
index ad3c26820..9c19c4355 100644
--- a/vllm_omni/engine/duplex/vad.py
+++ b/vllm_omni/engine/duplex/vad.py
@@ -428,11 +428,17 @@ class SileroStreamingVAD:
 
             if self._speech_active:
                 contained_speech = True
+                if probability >= self.config.threshold:
+                    # Confirmed speech cancels a pending endpoint. Otherwise a
+                    # brief pause can age through resumed speech and split the
+                    # utterance at the next low-probability frame.
+                    self._silence_samples = 0
+                    continue
                 below_negative_threshold = probability < negative_threshold
                 if not below_negative_threshold and self._silence_samples == 0:
                     continue
-                # A silence candidate is running: louder frames keep its clock
-                # moving but cannot themselves close the turn.
+                # Scores inside the hysteresis band keep the pending timer,
+                # but cannot themselves close the turn.
                 self._silence_samples += self._WINDOW_SAMPLES
                 if not below_negative_threshold or self._silence_samples < min_silence_samples:
                     continue
diff --git a/vllm_omni/engine/duplex_orchestrator.py b/vllm_omni/engine/duplex_orchestrator.py
index 09a767fb1..9814927d1 100644
--- a/vllm_omni/engine/duplex_orchestrator.py
+++ b/vllm_omni/engine/duplex_orchestrator.py
@@ -12,6 +12,8 @@ and applies the session-owned policy.
 
 from __future__ import annotations
 
+import asyncio
+import threading
 import time as _time
 from collections.abc import Coroutine
 from dataclasses import dataclass, field
@@ -20,6 +22,7 @@ from typing import TYPE_CHECKING, Any
 from vllm.logger import init_logger
 
 from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine import OmniEngineCoreRequest
 from vllm_omni.engine.duplex.contracts import (
     DuplexFence,
     DuplexOutputContext,
@@ -77,6 +80,7 @@ class DuplexOrchestrator(Orchestrator, DuplexStagePort):
         **kwargs: Any,
     ) -> None:
         super().__init__(*args, **kwargs)
+        self._prompt_processing_lock = threading.Lock()
         self.plugin = plugin
         self.duplex_session_config = duplex_session_config
         self.session_manager = DuplexSessionManager(
@@ -288,7 +292,9 @@ class DuplexOrchestrator(Orchestrator, DuplexStagePort):
                 fence=context.fence,
                 config_generation=context.config_generation,
             )
-            request_state.streaming.enabled = True
+            request_state.streaming.enabled = self.plugin.capabilities(
+                max_sessions=self.duplex_session_config.max_sessions
+            ).supports_core_resumable_request
             self.request_states[context.request_id] = request_state
         elif isinstance(request_state, DuplexOrchestratorRequestState):
             if request_state.config_generation != context.config_generation:
@@ -301,18 +307,49 @@ class DuplexOrchestrator(Orchestrator, DuplexStagePort):
         self._sync_bridge_state(request_state, context)
         self.session_manager.register_request(context.request_id, context.session_id)
 
+    def _upgrade_processed_stage_request(self, request, raw_prompt):
+        request = super()._upgrade_processed_stage_request(request, raw_prompt)
+        if not self.plugin.capabilities(
+            max_sessions=self.duplex_session_config.max_sessions
+        ).supports_core_resumable_request and not isinstance(request, OmniEngineCoreRequest):
+            request = OmniEngineCoreRequest.from_request(request)
+        return request
+
+    def _process_turn_prompt(self, *args, **kwargs):
+        # Input processors own mutable caches. Hold a thread lock even if the
+        # awaiting session is cancelled while its preprocessing is still running.
+        with self._prompt_processing_lock:
+            return self._build_next_stage_request(*args, **kwargs)
+
     async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
         context = submission.context
         request_state = self.request_states.get(context.request_id)
         if not isinstance(request_state, DuplexOrchestratorRequestState):
             raise RuntimeError(f"duplex request was not preregistered: {context.request_id}")
-        request = build_engine_core_request_from_tokens(
-            request_id=context.request_id,
-            prompt=dict(submission.prompt),
-            params=context.stage_sampling_params,
-            model_config=self.stage_pools[context.stage_id].stage_vllm_config.model_config,
-            resumable=True,
-        )
+        if self.plugin.capabilities(
+            max_sessions=self.duplex_session_config.max_sessions
+        ).supports_core_resumable_request:
+            request = build_engine_core_request_from_tokens(
+                request_id=context.request_id,
+                prompt=dict(submission.prompt),
+                params=context.stage_sampling_params,
+                model_config=self.stage_pools[context.stage_id].stage_vllm_config.model_config,
+                resumable=True,
+            )
+        else:
+            # Use the ordinary multimodal input processor for turn-model plugins.
+            # Its CPU preprocessing runs off the session/orchestrator event loop.
+            request = await asyncio.to_thread(
+                self._process_turn_prompt,
+                context.request_id,
+                context.stage_id,
+                dict(submission.prompt),
+                context.stage_sampling_params,
+                resumable=False,
+            )
+            if self.request_states.get(context.request_id) is not request_state:
+                raise RuntimeError("duplex request cancelled during input preprocessing")
+            request_state.prompt = dict(submission.prompt)
         request.external_req_id = request.request_id
         pool = self.stage_pools[context.stage_id]
         if submission.already_submitted:
diff --git a/vllm_omni/engine/errors.py b/vllm_omni/engine/errors.py
new file mode 100644
index 000000000..0128176d6
--- /dev/null
+++ b/vllm_omni/engine/errors.py
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Engine runtime error types."""
+
+
+class NativeKVHandoffError(RuntimeError):
+    """One request lost its producer binding or transfer metadata."""
diff --git a/vllm_omni/engine/omni_engine_base.py b/vllm_omni/engine/omni_engine_base.py
index e49804f7c..0a89f4141 100644
--- a/vllm_omni/engine/omni_engine_base.py
+++ b/vllm_omni/engine/omni_engine_base.py
@@ -61,11 +61,12 @@ from vllm_omni.engine.stage_client import StageClient
 from vllm_omni.engine.stage_init_utils import build_stage0_input_processor
 from vllm_omni.engine.stage_pool import StagePool
 from vllm_omni.engine.stage_runtime import (
+    OmniClientConfig,
     StageRuntimeInfo,
     create_stage_runtime,
 )
 from vllm_omni.entrypoints.pd_utils import PDDisaggregationMixin
-from vllm_omni.entrypoints.utils import parse_stage_overrides
+from vllm_omni.entrypoints.utils import prepare_stage_config_inputs
 from vllm_omni.inputs.data import OmniSamplingParams
 from vllm_omni.metrics.prometheus import OmniRequestCounter
 
@@ -122,6 +123,7 @@ class OmniEngineBase:
     _transfer_emitter: Any = None
     _prom_metrics: Any = None
     _enable_orch_monitor: bool = False
+    _client_config: OmniClientConfig | None = None
     # Lazily created by get_output_blocking_async().
     _output_drain_executor: concurrent.futures.ThreadPoolExecutor | None = None
 
@@ -136,6 +138,7 @@ class OmniEngineBase:
         log_stats: bool = False,
         tokenizer: str | None = None,
         trust_remote_code: bool | None = None,
+        client_config: OmniClientConfig | None = None,
         **kwargs: Any,
     ) -> None:
         self.model = model
@@ -155,6 +158,7 @@ class OmniEngineBase:
         # --log-stats CLI flag set by the user via OmniBase.
         self._log_stats = log_stats
         self._enable_orch_monitor = bool(kwargs.pop("enable_orch_monitor", False))
+        self._client_config = client_config
 
         logger.info(f"[OmniEngine] Initializing with model {model}")
 
@@ -166,6 +170,8 @@ class OmniEngineBase:
         _stage_id_kwarg = kwargs.get("stage_id")
         if isinstance(_stage_id_kwarg, int) and not single_stage_mode:
             single_stage_mode = True
+        if client_config is not None and int(client_config.get("client_count", 1)) > 1 and single_stage_mode:
+            raise ValueError("Multiple API servers cannot be combined with single-stage distributed mode")
 
         self.single_stage_mode: bool = single_stage_mode
         self._single_stage_id_filter: int | None = (
@@ -271,8 +277,16 @@ class OmniEngineBase:
             )
 
         self.num_stages = len(self.stage_configs)
-        stage0_args = getattr(self.stage_configs[0], "engine_args", None) if self.num_stages > 0 else None
-        self.async_chunk = bool(getattr(stage0_args, "async_chunk", False))
+        self.async_chunk = any(
+            bool(
+                getattr(
+                    getattr(stage, "connector_config", None),
+                    "async_chunk",
+                    getattr(getattr(stage, "engine_args", None), "async_chunk", False),
+                )
+            )
+            for stage in self.stage_configs
+        )
         self.stage_pools: list[StagePool] = []
         self.stage_clients: list[StageClient] = []  # logical-stage view for external readers
         self.input_processor: InputProcessor | None = None
@@ -370,6 +384,7 @@ class OmniEngineBase:
             omni_lb_policy=self._omni_lb_policy,
             request_queue=self.request_queue,
             log_stats=self._log_stats,
+            client_config=self._client_config,
         )
         self._runtime.initialize()
 
@@ -888,24 +903,15 @@ class OmniEngineBase:
     ) -> tuple[str, list[Any]]:
         """Resolve stage configs and inject defaults shared by orchestrator/headless."""
 
-        for legacy_arg in ("stage_configs_path", "stage_configs"):
-            if legacy_arg in kwargs:
-                raise ValueError(f"`{legacy_arg}` is no longer supported; use `deploy_config` instead.")
-
-        # log_stats is captured by __init__; its CLI-only negative alias must
-        # not cross into per-stage structured config ownership validation.
-        kwargs.pop("disable_log_stats", None)
-        deploy_config_path = kwargs.pop("deploy_config", None)
-        strategy_config_path = kwargs.pop("strategy_config", None)
-        # CLI callers arrive pre-parsed; offline Python callers may use the
-        # JSON-string form documented in recipes.
-        stage_overrides = parse_stage_overrides(kwargs.pop("stage_overrides", None))
-
-        # ``diffusion_streaming_output`` is the public AsyncOmni/serve kwarg;
-        # stage configs know the field as ``streaming_output``. Mirror only a
-        # truthy value so the CLI's False default does not override deploy YAML.
-        if kwargs.get("diffusion_streaming_output") and kwargs.get("streaming_output") is None:
-            kwargs["streaming_output"] = True
+        config_inputs = prepare_stage_config_inputs(
+            model,
+            kwargs,
+            trust_remote_code=trust_remote_code,
+        )
+        kwargs = config_inputs.kwargs
+        deploy_config_path = config_inputs.deploy_config_path
+        strategy_config_path = config_inputs.strategy_config_path
+        stage_overrides = config_inputs.stage_overrides
 
         resolution = cast(
             _ConfigResolutionResult,
diff --git a/vllm_omni/engine/orchestrator.py b/vllm_omni/engine/orchestrator.py
index c8c8963f9..bb360a831 100644
--- a/vllm_omni/engine/orchestrator.py
+++ b/vllm_omni/engine/orchestrator.py
@@ -38,6 +38,7 @@ from vllm_omni.diffusion.data import is_diffusion_request_started_output
 from vllm_omni.distributed.omni_connectors.utils.config import stage_receives_chunks
 from vllm_omni.engine import OmniEngineCoreRequest
 from vllm_omni.engine.cfg_companion_tracker import CfgCompanionTracker
+from vllm_omni.engine.errors import NativeKVHandoffError
 from vllm_omni.engine.membership_controller import MembershipController
 from vllm_omni.engine.messages import (
     AbortRequestMessage,
@@ -199,6 +200,8 @@ class OrchestratorRequestState:
     final_stage_id: int = -1
     final_output_stage_ids: set[int] = field(default_factory=set)
     finished_final_output_stage_ids: set[int] = field(default_factory=set)
+    finished_stage_ids: set[int] = field(default_factory=set)
+    pending_final_output: OutputMessage | None = None
 
     # Wall-clock timestamp when the client-facing engine request was accepted.
     request_timestamp: float = 0.0
@@ -219,6 +222,7 @@ class OrchestratorRequestState:
     session_owned: bool = False
     running_counter_registered: bool = False
     request_artifact_dirs: set[str] = field(default_factory=set)
+    native_kv_transfer_id: str | None = None
 
 
 @dataclass
@@ -770,20 +774,21 @@ class OrchestratorBase:
                     float(kv_wait_s),
                 )
             req_state = self.request_states.get(getattr(eco, "request_id", None))
-            if req_state is None or not req_state.streaming.enabled:
+            if req_state is None:
                 continue
-            segment_finished = bool(getattr(eco, "is_segment_finished", False))
-            raw_mm = self._completion_multimodal_output(eco, None)
-            req_state.streaming.segments[stage_id] = StreamingSegmentState(
-                finished=segment_finished,
-                token_ids=(self._coerce_int_list(getattr(eco, "new_token_ids", None)) if segment_finished else []),
-                output_metadata=(dict(raw_mm) if segment_finished and isinstance(raw_mm, dict) else {}),
-            )
-            req_state.streaming.new_prompt_len_snapshot = getattr(
-                eco,
-                "new_prompt_len_snapshot",
-                None,
-            )
+            if req_state.streaming.enabled:
+                segment_finished = bool(getattr(eco, "is_segment_finished", False))
+                raw_mm = self._completion_multimodal_output(eco, None)
+                req_state.streaming.segments[stage_id] = StreamingSegmentState(
+                    finished=segment_finished,
+                    token_ids=(self._coerce_int_list(getattr(eco, "new_token_ids", None)) if segment_finished else []),
+                    output_metadata=(dict(raw_mm) if segment_finished and isinstance(raw_mm, dict) else {}),
+                )
+                req_state.streaming.new_prompt_len_snapshot = getattr(
+                    eco,
+                    "new_prompt_len_snapshot",
+                    None,
+                )
             if await self._apply_raw_terminal_stage_finish(stage_id, eco, req_state):
                 raw_terminal_request_ids.add(req_state.request_id)
             await self._report_duplex_session_request_error(stage_id, replica_id, eco, req_state)
@@ -794,6 +799,11 @@ class OrchestratorBase:
             iteration_stats=iteration_stats,
         )
         if self._stat_logger is not None and (raw_outputs.scheduler_stats is not None or iteration_stats is not None):
+            key = (stage_id, replica_id)
+            if key not in self._stage_replica_to_engine_idx:
+                engine_idx = len(self._stage_replica_to_engine_idx)
+                self._stat_logger.register_replica(engine_idx, str(stage_id), str(replica_id))
+                self._stage_replica_to_engine_idx[key] = engine_idx
             self._stat_logger.record(
                 raw_outputs.scheduler_stats,
                 iteration_stats,
@@ -1373,6 +1383,16 @@ class OrchestratorBase:
         try:
             await dispatch()
             return True
+        except NativeKVHandoffError as e:
+            await self._fail_request_client_error(
+                req_id,
+                stage_id,
+                str(e),
+                status_code=HTTPStatus.BAD_GATEWAY.value,
+                error_type="NativeKVHandoffError",
+                release_owners=True,
+            )
+            return False
         except StageUnavailableError as e:
             # No specific replica to evict: the stage already has no live
             # replica or the chosen slot was evicted. Fail just this request.
@@ -1504,18 +1524,19 @@ class OrchestratorBase:
         ``is_segment_finished=False``, but vLLM's output processor may remove the
         request state before that EngineCoreOutput is processed.
 
-        Only update ``finished_final_output_stage_ids`` here. Request cleanup stays
-        in ``_route_output`` so downstream async-chunk stages can still deliver
-        outputs after stage-0 session end.
+        Record raw stage completion here. Client completion is
+        resolved after this raw batch passes through the output processor, so a
+        real processed output wins over the swallowed-terminal fallback.
         """
         if getattr(eco, "finish_reason", None) is None:
             return False
         if getattr(eco, "is_segment_finished", False):
             return False
 
+        req_state.finished_stage_ids.add(stage_id)
         final_output_stage_ids = req_state.final_output_stage_ids or {req_state.final_stage_id}
         if stage_id not in final_output_stage_ids:
-            return False
+            return True
         req_state.finished_final_output_stage_ids.add(stage_id)
         return True
 
@@ -1568,16 +1589,23 @@ class OrchestratorBase:
         replica_id: int,
         request_ids: set[str],
     ) -> None:
-        """Finish streaming requests whose raw terminal had no processed output."""
+        """Finish requests whose raw terminal had no processed output."""
         pool = self.stage_pools[stage_id]
-        if not pool.final_output:
-            return
-
         for request_id in request_ids:
             req_state = self.request_states.get(request_id)
             if req_state is None or req_state.session_owned:
                 continue
-
+            pending = req_state.pending_final_output
+            if pending is not None:
+                if set(req_state.stage_submit_ts).issubset(req_state.finished_stage_ids):
+                    req_state.pending_final_output = None
+                    await self.output_async_queue.put(pending)
+                    await self._cleanup_request_ids([request_id, *self._cfg_tracker.cleanup_parent(request_id)])
+                # A real terminal output is pending; do not replace it with
+                # the swallowed-output fallback before upstream completion.
+                continue
+            if not pool.final_output:
+                continue
             final_output_stage_ids = req_state.final_output_stage_ids or {req_state.final_stage_id}
             if not final_output_stage_ids.issubset(req_state.finished_final_output_stage_ids):
                 continue
@@ -1651,27 +1679,41 @@ class OrchestratorBase:
             await self._cleanup_request_ids([req_id])
             return
 
+        if finished and not segment_finished:
+            req_state.finished_stage_ids.add(stage_id)
+
         request_finished = False
         if finished and self.stage_pools[stage_id].final_output and not segment_finished:
             req_state.finished_final_output_stage_ids.add(stage_id)
             final_output_stage_ids = req_state.final_output_stage_ids or {req_state.final_stage_id}
             request_finished = final_output_stage_ids.issubset(req_state.finished_final_output_stage_ids)
         if req_state.session_owned:
-            # Session-owned outputs are delivered to their session through
-            # ``_intercept_stage_output`` below, never to a request queue.
+            # Session-owned outputs are delivered through the session interceptor.
             pass
         elif self.stage_pools[stage_id].final_output:
-            await self.output_async_queue.put(
-                OutputMessage(
-                    request_id=req_id,
-                    stage_id=stage_id,
-                    replica_id=replica_id,
-                    engine_outputs=output,
-                    metrics=stage_metrics,
-                    finished=request_finished,
-                    stage_submit_ts=submit_ts,
-                )
+            message = OutputMessage(
+                request_id=req_id,
+                stage_id=stage_id,
+                replica_id=replica_id,
+                engine_outputs=output,
+                metrics=stage_metrics,
+                finished=request_finished,
+                stage_submit_ts=submit_ts,
             )
+            if (
+                request_finished
+                and self.async_chunk
+                and not req_state.streaming.enabled
+                and not set(req_state.stage_submit_ts).issubset(req_state.finished_stage_ids)
+            ):
+                # Direct chunk delivery can finish the decoder before the
+                # upstream engine's terminal output/metrics reaches this loop.
+                # Keep request state until those messages are routed, otherwise
+                # the frontend publishes incomplete usage and loses stop reasons.
+                req_state.pending_final_output = message
+                request_finished = False
+            else:
+                await self.output_async_queue.put(message)
         elif stage_metrics is not None:
             await self.output_async_queue.put(
                 StageMetricsMessage(
@@ -1739,6 +1781,12 @@ class OrchestratorBase:
                         is_final_update=True,
                     )
 
+        pending = req_state.pending_final_output
+        if pending is not None and set(req_state.stage_submit_ts).issubset(req_state.finished_stage_ids):
+            req_state.pending_final_output = None
+            await self.output_async_queue.put(pending)
+            request_finished = True
+
         if request_finished and not req_state.session_owned:
             await self._cleanup_request_ids([req_id, *self._cfg_tracker.cleanup_parent(req_id)])
 
@@ -2203,12 +2251,13 @@ class OrchestratorBase:
                     req_id,
                     req_state,
                     diffusion_prompt,
-                    submit_kwargs={
-                        "kv_sender_info": self._build_kv_sender_info(
-                            list(getattr(next_client, "engine_input_source", None) or [src_stage_id]),
-                            request_id=req_id,
-                        )
-                    },
+                    submit_kwargs=self._diffusion_submit_kwargs(
+                        req_id,
+                        src_stage_id,
+                        next_client,
+                        req_state,
+                        output,
+                    ),
                     params_override=self._maybe_clone_diffusion_params_for_cfg(req_id, params),
                 )
             self._on_stage_submitted(
@@ -2462,12 +2511,12 @@ class OrchestratorBase:
             _t_submit_start = _time.perf_counter()
 
             if next_pool.stage_type == "diffusion":
-                submit_kwargs = {
-                    "kv_sender_info": self._build_kv_sender_info(
-                        list(getattr(next_pool.stage_client, "engine_input_source", None) or [next_stage_id - 1]),
-                        request_id=request_id,
-                    )
-                }
+                submit_kwargs = self._diffusion_submit_kwargs(
+                    request_id,
+                    next_stage_id - 1,
+                    next_pool.stage_client,
+                    req_state,
+                )
                 submitted = await self._dispatch_or_fail_request(
                     lambda: next_pool.submit_initial(
                         request_id,
@@ -2480,8 +2529,6 @@ class OrchestratorBase:
                     operation="async-chunk prewarm",
                 )
             else:
-                import copy
-
                 from vllm_omni.distributed.omni_connectors.adapter import compute_talker_prompt_ids_length
 
                 try:
@@ -2504,7 +2551,9 @@ class OrchestratorBase:
 
                 original_prompt = req_state.prompt
                 if isinstance(original_prompt, dict):
-                    base_input = copy.deepcopy(original_prompt)
+                    from vllm_omni.engine.request_snapshot import copy_request_snapshot
+
+                    base_input = copy_request_snapshot(original_prompt)
                 else:
                     base_input = {}
 
@@ -2564,6 +2613,67 @@ class OrchestratorBase:
 
         return True
 
+    def _maybe_attach_native_kv_transfer_params(
+        self,
+        req_state: OrchestratorRequestState,
+        prompt: Any,
+    ) -> None:
+        source_stage_id = 0
+        if source_stage_id + 1 > req_state.final_stage_id:
+            return
+        config = getattr(self.stage_pools[source_stage_id].stage_vllm_config, "kv_transfer_config", None)
+        if getattr(config, "kv_role", None) != "kv_producer":
+            return
+        if self.stage_pools[source_stage_id + 1].stage_type != "diffusion":
+            return
+
+        from vllm_omni.diffusion.diffusion_kv.kv_connector import build_source_kv_transfer_params, mint_transfer_id
+
+        transfer_id = mint_transfer_id(req_state.request_id)
+        req_state.native_kv_transfer_id = transfer_id
+        params = build_source_kv_transfer_params(
+            transfer_id=transfer_id,
+            remote_engine_id=None,
+            remote_bootstrap_addr=None,
+        )
+        for sampling in (req_state.sampling_params_list[source_stage_id], prompt.sampling_params):
+            sampling.extra_args = {**(sampling.extra_args or {}), "kv_transfer_params": params}
+
+    def _diffusion_submit_kwargs(
+        self,
+        request_id: str,
+        source_stage_id: int,
+        next_client: Any,
+        req_state: OrchestratorRequestState,
+        output: Any = None,
+    ) -> dict[str, Any]:
+        source_stage_ids = list(getattr(next_client, "engine_input_source", None) or [source_stage_id])
+        if req_state.native_kv_transfer_id is None:
+            return {"kv_sender_info": self._build_kv_sender_info(source_stage_ids, request_id=request_id)}
+        if output is None:
+            raise NativeKVHandoffError("Native KV handoff requires one completed AR source")
+        from vllm_omni.diffusion.diffusion_kv.kv_connector import (
+            bootstrap_addr_from_kv_transfer_config,
+            build_target_kv_transfer_params,
+        )
+
+        source = self.stage_pools[source_stage_id].get_bound_client(request_id)
+        config = getattr(getattr(source, "vllm_config", None), "kv_transfer_config", None)
+        if source is None or config is None:
+            raise NativeKVHandoffError(
+                f"Native KV handoff for {request_id}: bound AR replica or its KV configuration is unavailable"
+            )
+        params = getattr(output, "kv_transfer_params", None)
+        if not params or "num_transfer_tokens" not in params:
+            raise NativeKVHandoffError("AR source completed without native KV transfer metadata")
+        return {
+            "kv_transfer_params": build_target_kv_transfer_params(
+                source_params=params,
+                remote_engine_id=config.engine_id,
+                remote_bootstrap_addr=bootstrap_addr_from_kv_transfer_config(config),
+            )
+        }
+
     def _build_kv_sender_info(
         self,
         sender_stage_ids: list[int],
@@ -2687,6 +2797,7 @@ class Orchestrator(OrchestratorBase):
             request_artifact_dirs=set(msg.request_artifact_dirs or ()),
         )
         self.request_states[request_id] = req_state
+        self._maybe_attach_native_kv_transfer_params(req_state, prompt)
         self._register_running_request(req_state)
         req_state.streaming.enabled = bool(getattr(prompt, "resumable", False))
         req_state.stage_submit_ts[stage_id] = _time.time()
diff --git a/vllm_omni/engine/orchestrator_monitor.py b/vllm_omni/engine/orchestrator_monitor.py
index e18287762..e91e82196 100644
--- a/vllm_omni/engine/orchestrator_monitor.py
+++ b/vllm_omni/engine/orchestrator_monitor.py
@@ -182,8 +182,8 @@ class OrchestratorMonitor:
 
         self._loop_idle = 0
         self._loop_active = 0
-        self._dispatch_queue_size = 0
-        self._dispatch_queue_high_water = 0
+        # Queued work carries into the next window even without new arrivals.
+        self._dispatch_queue_high_water = self._dispatch_queue_size
         self._window_start_mono = now_mono
 
     def _log_summary(self, output_path: str) -> None:
diff --git a/vllm_omni/engine/request_snapshot.py b/vllm_omni/engine/request_snapshot.py
new file mode 100644
index 000000000..4db02f4c1
--- /dev/null
+++ b/vllm_omni/engine/request_snapshot.py
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Full request snapshots with a fast path for immutable scalar leaves."""
+
+import copy
+from typing import Any
+
+_ATOMIC_TYPES = frozenset((type(None), bool, int, float, complex, str, bytes))
+
+
+def copy_request_snapshot(value: Any, memo: dict[int, Any] | None = None) -> Any:
+    """Deep-copy all fields, preserving aliases and isolating mutable containers.
+
+    Plain numeric/text trees do not need generic object dispatch or an identity
+    lookup for each immutable scalar. Subclasses and other objects retain their
+    regular deepcopy contracts. No model fields are filtered or shared here.
+    """
+    kind = type(value)
+    if kind in _ATOMIC_TYPES:
+        return value
+    if memo is None:
+        memo = {}
+    key = id(value)
+    if key in memo:
+        return memo[key]
+    if kind is list:
+        atomic = all(type(item) in _ATOMIC_TYPES for item in value)
+        result = value.copy() if atomic else []
+        memo[key] = result
+        if not atomic:
+            result.extend(copy_request_snapshot(item, memo) for item in value)
+    elif kind is dict:
+        result = {}
+        memo[key] = result
+        for k, item in value.items():
+            result[copy_request_snapshot(k, memo)] = copy_request_snapshot(item, memo)
+    else:
+        return copy.deepcopy(value, memo)
+    # Keep sources alive for the duration of a copy, including custom deepcopy
+    # implementations that mutate a source container while being visited.
+    memo.setdefault(id(memo), []).append(value)
+    return result
diff --git a/vllm_omni/engine/stage_admission.py b/vllm_omni/engine/stage_admission.py
index 469787bca..bd57f805d 100644
--- a/vllm_omni/engine/stage_admission.py
+++ b/vllm_omni/engine/stage_admission.py
@@ -287,8 +287,13 @@ def check_admission(
 
 
 def _diffusion_utilization(replica: Any) -> float | None:
-    """Best-effort gpu_memory_utilization for a diffusion replica from raw args."""
+    """Resolve a diffusion replica's memory budget from typed or legacy config."""
     stage_cfg = getattr(replica, "stage_cfg", None)
+    cache_config = getattr(stage_cfg, "cache_config", None)
+    util = getattr(cache_config, "gpu_memory_utilization", None)
+    if util is not None:
+        return float(util)
+
     engine_args = getattr(stage_cfg, "engine_args", None)
     if isinstance(engine_args, dict):
         util = engine_args.get("gpu_memory_utilization")
diff --git a/vllm_omni/engine/stage_engine_core_client.py b/vllm_omni/engine/stage_engine_core_client.py
index 5fdd74912..e87d19bb4 100644
--- a/vllm_omni/engine/stage_engine_core_client.py
+++ b/vllm_omni/engine/stage_engine_core_client.py
@@ -19,7 +19,7 @@ import vllm.v1.engine as _vllm_engine_module
 import vllm.v1.engine.core_client as _vllm_core_client_module
 from vllm.logger import init_logger
 from vllm.v1.engine import EngineCoreRequest
-from vllm.v1.engine.core_client import AsyncMPClient, DPLBAsyncMPClient
+from vllm.v1.engine.core_client import AsyncMPClient, DPLBAsyncMPClient, MPClient
 from vllm.v1.engine.exceptions import EngineDeadError
 
 from vllm_omni.distributed.omni_connectors.utils.config import (
@@ -232,6 +232,9 @@ class StageEngineCoreClientBase(StageClientBase):
         if self.resources.engine_dead:
             raise EngineDeadError(f"Stage-{self.stage_id} engine core is dead")
 
+    def _apply_ready_response(self, payload: bytes) -> None:
+        MPClient._apply_ready_response(self, payload)
+
     # ==================== Overrides ====================
 
     async def add_request_async(self, request: EngineCoreRequest) -> None:
diff --git a/vllm_omni/engine/stage_engine_core_proc.py b/vllm_omni/engine/stage_engine_core_proc.py
index a52f58925..839e52495 100644
--- a/vllm_omni/engine/stage_engine_core_proc.py
+++ b/vllm_omni/engine/stage_engine_core_proc.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Stage Core Process for vLLM-Omni V1 architecture.
 
@@ -27,6 +30,7 @@ from vllm.v1.engine.utils import (
     EngineZmqAddresses,
     SignalCallback,
 )
+from vllm.v1.executor.uniproc_executor import UniProcExecutor
 
 from vllm_omni.distributed.omni_coordinator import create_stage_coord_client
 from vllm_omni.engine import OmniEngineCoreRequest
@@ -75,6 +79,24 @@ def _signal_exit_code(signum: int) -> int:
     return _SIGNAL_EXIT_BASE + signum
 
 
+def _bind_native_data_plane_ready_sink(model_executor: Any, scheduler: Any) -> bool:
+    """Bind the TP1 in-process runner control plane directly to its scheduler."""
+    if not isinstance(model_executor, UniProcExecutor):
+        return False
+    parallel_config = model_executor.vllm_config.parallel_config
+    if parallel_config.tensor_parallel_size != 1 or parallel_config.pipeline_parallel_size != 1:
+        return False
+    driver_worker = getattr(model_executor, "driver_worker", None)
+    worker = getattr(driver_worker, "worker", None)
+    model_runner = getattr(worker, "model_runner", None)
+    data_plane = getattr(model_runner, "_omni_data_plane", None)
+    sink = getattr(scheduler, "enqueue_omni_connector_output", None)
+    if data_plane is None or not callable(sink):
+        return False
+    data_plane.set_omni_connector_output_sink(sink)
+    return True
+
+
 class StageEngineCoreProc(EngineCoreProc):
     """Stage-specific engine core process for vLLM-Omni.
 
@@ -83,6 +105,11 @@ class StageEngineCoreProc(EngineCoreProc):
     ``EngineCoreProc.run_engine_core()``.
     """
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        if _bind_native_data_plane_ready_sink(self.model_executor, self.scheduler):
+            logger.info("Bound native MRv2 connector readiness directly to the scheduler inbox.")
+
     def preprocess_add_request(self, request: OmniEngineCoreRequest) -> tuple[Any, int]:
         """Preserve omni payloads when vLLM builds its scheduler request."""
         scheduler_request, current_wave = super().preprocess_add_request(request)
diff --git a/vllm_omni/engine/stage_engine_startup.py b/vllm_omni/engine/stage_engine_startup.py
index 71ba17c7c..1aaebc82b 100644
--- a/vllm_omni/engine/stage_engine_startup.py
+++ b/vllm_omni/engine/stage_engine_startup.py
@@ -13,10 +13,12 @@ import threading
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass, field
 from multiprocessing import connection
+from multiprocessing.process import BaseProcess
 from types import SimpleNamespace
 from typing import Any
 
 import msgspec
+import torch
 import zmq
 from omegaconf import OmegaConf
 from vllm.config import VllmConfig
@@ -33,6 +35,7 @@ from vllm.v1.engine.utils import (
 )
 from vllm.v1.executor import Executor
 
+from vllm_omni.config.omni_config import BaseVllmOmniStageConfig
 from vllm_omni.distributed.omni_connectors.utils import initialization
 from vllm_omni.engine import stage_init_utils
 from vllm_omni.engine.stage_init_utils import (
@@ -67,11 +70,13 @@ def _serialize_stage_config(stage_config: Any) -> Any:
     """Convert a stage config to msgpack-friendly builtins."""
     if stage_config is None or isinstance(stage_config, (str, bytes, int, float, bool)):
         return stage_config
+    if isinstance(stage_config, torch.dtype):
+        return str(stage_config).removeprefix("torch.")
 
     if OmegaConf.is_config(stage_config):
         return _serialize_stage_config(OmegaConf.to_container(stage_config, resolve=True))
 
-    if dataclasses.is_dataclass(stage_config):
+    if dataclasses.is_dataclass(stage_config) and not isinstance(stage_config, type):
         return _serialize_stage_config(dataclasses.asdict(stage_config))
 
     if isinstance(stage_config, dict):
@@ -1134,6 +1139,8 @@ def launch_stage_replica(
     stage_visible_devices: str | None = None,
     spawn_device_lock: threading.Lock | None = None,
     omni_parallel_stage_init: bool = False,
+    num_api_servers: int = 1,
+    watched_frontend_processes: list[BaseProcess] | None = None,
 ) -> Iterator[StageReplicaResources]:
     """Launch a local LLM stage replica.
 
@@ -1144,6 +1151,8 @@ def launch_stage_replica(
     keep the same returned resource bundle.
     """
     if omni_master_server is not None:
+        if num_api_servers != 1:
+            raise ValueError("Multiple API servers are not supported with distributed stage launch")
         with _launch_omni_core_engines(
             vllm_config=vllm_config,
             executor_class=executor_class,
@@ -1169,7 +1178,16 @@ def launch_stage_replica(
 
     from vllm_omni.engine.stage_engine_core_proc_manager import StageEngineCoreProcManager
 
-    addresses = get_engine_zmq_addresses(vllm_config)
+    if num_api_servers > 1:
+        # Multi-API Omni is intentionally local-only. IPC paths avoid the
+        # bind-after-allocation race of tcp://host:0 and are stable for every
+        # stage, including stages that are not used by APIServerProcessManager.
+        addresses = EngineZmqAddresses(
+            inputs=[get_open_zmq_ipc_path() for _ in range(num_api_servers)],
+            outputs=[get_open_zmq_ipc_path() for _ in range(num_api_servers)],
+        )
+    else:
+        addresses = get_engine_zmq_addresses(vllm_config)
     handshake_address = get_open_zmq_ipc_path()
     engines_to_handshake = [CoreEngine(index=0, local=True)]
     with scoped_spawn_device_env(stage_visible_devices, spawn_device_lock, stage_id=stage_id, replica_id=replica_id):
@@ -1193,18 +1211,21 @@ def launch_stage_replica(
             manager=engine_manager,
             addresses=addresses,
         )
+        engine_launch = CoreEngineLaunch(
+            engine_manager=engine_manager,
+            coordinator=None,
+            addresses=addresses,
+            tensor_queue=None,
+        )
+        if watched_frontend_processes is not None:
+            engine_launch.watched_frontend_processes = watched_frontend_processes
         wait_for_engine_startup(
             handshake_socket,
             engines_to_handshake,
             vllm_config.parallel_config,
             False,  # coordinated_dp
             vllm_config.cache_config,
-            CoreEngineLaunch(
-                engine_manager=engine_manager,
-                coordinator=None,
-                addresses=addresses,
-                tensor_queue=None,
-            ),
+            engine_launch,
         )
 
 
@@ -1403,7 +1424,7 @@ def get_headless_replica_devices(
     omni_dp_size_local: int,
 ) -> list[str | None]:
     """Return per-replica device slices for a headless stage."""
-    runtime_cfg = getattr(stage_cfg, "runtime", None)
+    runtime_cfg = getattr(stage_cfg, "runtime_config", getattr(stage_cfg, "runtime", None))
     devices_str: str | None = None
     if runtime_cfg is not None:
         devices_str = (
@@ -1509,10 +1530,11 @@ def launch_headless_diffusion_replicas(
         stage_id,
     )
 
-    # Headless diffusion startup and its downstream helpers still consume the
-    # legacy StageConfig shape; switch this with the coordinated RFC #4021
-    # stage-init cutover.
-    metadata = stage_init_utils.extract_legacy_stage_metadata(stage_cfg)
+    metadata = (
+        stage_init_utils.extract_stage_metadata_from_omni_stage_config(stage_cfg)
+        if isinstance(stage_cfg, BaseVllmOmniStageConfig)
+        else stage_init_utils.extract_legacy_stage_metadata(stage_cfg)
+    )
     if omni_conn_cfg:
         inject_omni_kv_config(stage_cfg, omni_conn_cfg, omni_from, omni_to)
     # Headless single-stage launch must still infer cross-stage TP topology
diff --git a/vllm_omni/engine/stage_init_utils.py b/vllm_omni/engine/stage_init_utils.py
index 9668dfc99..faaf6b707 100644
--- a/vllm_omni/engine/stage_init_utils.py
+++ b/vllm_omni/engine/stage_init_utils.py
@@ -402,6 +402,11 @@ def _tp_size_for_stage(stage_configs: Sequence[Any], stage_id: Any) -> int | Non
     for stage_cfg in stage_configs:
         if str(getattr(stage_cfg, "stage_id", None)) not in id_strs:
             continue
+        if isinstance(stage_cfg, BaseVllmOmniStageConfig):
+            try:
+                return max(1, int(stage_cfg.parallel_config.tensor_parallel_size))
+            except (TypeError, ValueError):
+                return 1
         engine_args = getattr(stage_cfg, "engine_args", None)
         if engine_args is None:
             return 1
@@ -489,11 +494,15 @@ def inject_kv_stage_info(stage_cfg: Any, stage_id: int, stage_configs: Sequence[
     rank mappings automatically.
     """
     try:
-        engine_args = stage_cfg.engine_args
-        if hasattr(engine_args, "get"):
-            omni_kv = engine_args.get("omni_kv_config", None)
+        connector_config = getattr(stage_cfg, "connector_config", None)
+        if connector_config is not None:
+            omni_kv = connector_config.omni_kv_config
         else:
-            omni_kv = getattr(engine_args, "omni_kv_config", None)
+            engine_args = stage_cfg.engine_args
+            if hasattr(engine_args, "get"):
+                omni_kv = engine_args.get("omni_kv_config", None)
+            else:
+                omni_kv = getattr(engine_args, "omni_kv_config", None)
 
         if omni_kv is None:
             return
@@ -504,7 +513,11 @@ def inject_kv_stage_info(stage_cfg: Any, stage_id: int, stage_configs: Sequence[
             if "stage_id" not in omni_kv:
                 omni_kv["stage_id"] = stage_id
 
-        engine_input_source = getattr(stage_cfg, "engine_input_source", None)
+        engine_input_source = (
+            getattr(stage_cfg, "input_sources", None)
+            if connector_config is not None
+            else getattr(stage_cfg, "engine_input_source", None)
+        )
         if engine_input_source is not None:
             if hasattr(omni_kv, "setdefault"):
                 omni_kv.setdefault("engine_input_source", list(engine_input_source))
@@ -703,17 +716,16 @@ def _resolve_omni_metadata_hook(path: str | None) -> Callable | None:
 def extract_stage_metadata_from_omni_stage_config(
     stage_config: BaseVllmOmniStageConfig,
 ) -> StageMetadata:
-    """Project one typed stage config into metadata for a future cutover.
-
-    This projection is not used by production startup yet. Current replica
-    layout, engine-argument, remote-diffusion, and platform setup paths still
-    require the legacy StageConfig/OmegaConf shape.
-    """
+    """Project one typed stage config into production runtime metadata."""
     stage_type: Literal["llm", "diffusion"] = "diffusion" if stage_config.stage_type == StageType.DIFFUSION else "llm"
-    sampling_params_cls = SamplingParams if stage_type == "llm" else OmniDiffusionSamplingParams
-    sampling_params: OmniSamplingParams = sampling_params_cls(
-        **(stage_config.model_config.default_sampling_params or {})
-    )
+    pooling_config = stage_config.pooling_config
+    if stage_type == "llm" and (pooling_config.runner or "").lower() == "pooling":
+        sampling_params: OmniSamplingParams | PoolingParams = (
+            copy.deepcopy(pooling_config.default_pooling_params) or PoolingParams()
+        )
+    else:
+        sampling_params_cls = SamplingParams if stage_type == "llm" else OmniDiffusionSamplingParams
+        sampling_params = sampling_params_cls(**(stage_config.model_config.default_sampling_params or {}))
     custom_process_input_func = _resolve_omni_metadata_hook(stage_config.custom_process_input_func)
 
     if stage_type == "diffusion":
@@ -878,7 +890,9 @@ def _get_local_llm_parallel_sizes(
     unset.
     """
     if engine_args is None:
-        engine_args = getattr(stage_cfg, "engine_args", {})
+        engine_args = getattr(stage_cfg, "parallel_config", None)
+        if engine_args is None:
+            engine_args = getattr(stage_cfg, "engine_args", {})
     tp_size = int(_get_attr_or_item(engine_args, "tensor_parallel_size", 1) or 1)
     pp_size = int(_get_attr_or_item(engine_args, "pipeline_parallel_size", 1) or 1)
     local_dp_size = _get_attr_or_item(engine_args, "data_parallel_size_local", None)
@@ -889,9 +903,12 @@ def _get_local_llm_parallel_sizes(
 
 def get_stage_devices_per_replica(stage_cfg: Any, engine_args: Any | None = None) -> int:
     """Return the number of devices consumed by one replica of *stage_cfg*."""
-    if engine_args is None:
-        engine_args = getattr(stage_cfg, "engine_args", {})
     if getattr(stage_cfg, "stage_type", "llm") == "diffusion":
+        typed_parallel_config = getattr(stage_cfg, "parallel_config", None)
+        if typed_parallel_config is not None:
+            return max(1, int(typed_parallel_config.world_size))
+        if engine_args is None:
+            engine_args = getattr(stage_cfg, "engine_args", {})
         parallel_config = _get_attr_or_item(engine_args, "parallel_config")
         if parallel_config is None:
             return 1
@@ -933,7 +950,7 @@ def compute_replica_layout(
     """
     replicas_per_stage: list[int] = []
     for stage_cfg in stage_configs:
-        runtime_cfg = getattr(stage_cfg, "runtime", {})
+        runtime_cfg = getattr(stage_cfg, "runtime_config", getattr(stage_cfg, "runtime", {}))
         num_replicas = int(
             runtime_cfg.get("num_replicas", 1)
             if hasattr(runtime_cfg, "get")
@@ -948,7 +965,7 @@ def compute_replica_layout(
         num_replicas = replicas_per_stage[stage_id]
         if num_replicas <= 1:
             continue
-        runtime_cfg = getattr(stage_cfg, "runtime", {})
+        runtime_cfg = getattr(stage_cfg, "runtime_config", getattr(stage_cfg, "runtime", {}))
         devices_str = (
             runtime_cfg.get("devices") if hasattr(runtime_cfg, "get") else getattr(runtime_cfg, "devices", None)
         )
@@ -1086,15 +1103,31 @@ def _project_omni_stage_engine_args(
         diffusion_stage = cast(VllmOmniDiffusionStageConfig, stage_config)
         engine_args.update(_project_omni_config_fields(diffusion_stage.diffusion_config))
 
+    model_excluded_fields = {
+        "default_sampling_params",
+        "has_sampling_extra_args",
+    }
+    runtime_excluded_fields = {"devices", "num_replicas", "env", "num_gpus"}
+    if not is_diffusion:
+        # These values configure OmniDiffusionConfig or its worker process;
+        # OmniEngineArgs has no matching fields for LLM stages.
+        model_excluded_fields.update(
+            {
+                "disable_autocast",
+                "enable_multithread_weight_load",
+                "num_weight_load_threads",
+            }
+        )
+        runtime_excluded_fields.add("log_level")
+
     for config, excluded_fields in (
         (
             stage_config.model_config,
-            frozenset({"default_sampling_params", "has_sampling_extra_args"}),
+            frozenset(model_excluded_fields),
         ),
         (
             stage_config.runtime_config,
-            frozenset({"devices", "num_replicas", "env", "num_gpus"})
-            | (frozenset({"additional_config"}) if is_diffusion else frozenset()),
+            frozenset(runtime_excluded_fields) | (frozenset({"additional_config"}) if is_diffusion else frozenset()),
         ),
     ):
         engine_args.update(
@@ -1103,6 +1136,11 @@ def _project_omni_stage_engine_args(
                 exclude=excluded_fields,
             )
         )
+    pooling_config = stage_config.pooling_config
+    if pooling_config.runner is not None:
+        engine_args["runner"] = pooling_config.runner
+    if pooling_config.pooling_output_decoder is not None:
+        engine_args["pooling_output_decoder"] = pooling_config.pooling_output_decoder
 
     if is_diffusion:
         for config, field_map in (
@@ -1151,6 +1189,8 @@ def _project_omni_stage_engine_args(
     engine_args["async_chunk"] = connector_config.async_chunk
     if connector_config.omni_kv_config is not None:
         engine_args["omni_kv_config"] = copy.deepcopy(connector_config.omni_kv_config)
+    if connector_config.kv_transfer_config is not None:
+        engine_args["kv_transfer_config"] = copy.deepcopy(connector_config.kv_transfer_config)
 
     if is_diffusion:
         engine_args["parallel_config"] = _project_omni_config_fields(
@@ -1330,11 +1370,9 @@ def build_engine_args_dict(
     stage_connector_spec: dict[str, Any] | None = None,
     cli_tokenizer: str | None = None,
 ) -> dict[str, Any]:
-    """Build engine arguments through the stable production entry point.
+    """Preserve the legacy engine-argument API for compatibility callers.
 
-    Production inputs still use the legacy stage representation. Keep that
-    compatibility choice behind this function so callers do not bind directly
-    to a representation-specific implementation.
+    Typed runtime stages use ``build_engine_args_dict_from_omni_stage_config``.
     """
     return build_legacy_engine_args_dict(
         stage_config,
@@ -1350,13 +1388,7 @@ def build_engine_args_dict_from_omni_stage_config(
     stage_connector_spec: dict[str, Any] | None = None,
     cli_tokenizer: str | None = None,
 ) -> dict[str, Any]:
-    """Project one typed stage config into backend engine arguments.
-
-    This projection is prepared for the RFC #4021 stage-init cutover. Current
-    production startup reaches the legacy implementation through
-    ``build_engine_args_dict`` while strategy and startup-plan inputs still
-    use the legacy representation.
-    """
+    """Project one typed production stage config into backend engine arguments."""
     engine_args_dict = _project_omni_stage_engine_args(stage_config)
     _apply_rocm_attention_backend(engine_args_dict, stage_config.stage_type)
     return _finalize_engine_args_dict(
@@ -1391,7 +1423,7 @@ def _check_stage_device_layout(stage_config: Any, engine_args_dict: dict[str, An
     """
     from vllm_omni.config.composable_parallel import StrategyApplyError, check_device_layout
 
-    runtime = getattr(stage_config, "runtime", None)
+    runtime = getattr(stage_config, "runtime_config", getattr(stage_config, "runtime", None))
     devices = _get_attr_or_item(runtime, "devices", None) if runtime is not None else None
     if devices is None:
         # No explicit placement -> vLLM assigns devices itself; nothing to check.
@@ -1445,6 +1477,8 @@ def build_vllm_config(
     stage_connector_spec: dict[str, Any] | None = None,
     engine_args_dict: dict[str, Any] | None = None,
     headless: bool = False,
+    api_process_count: int = 1,
+    api_process_rank: int = 0,
 ) -> tuple[Any, type]:
     """Build engine args, then create VllmConfig and executor_class.
 
@@ -1452,13 +1486,18 @@ def build_vllm_config(
         (vllm_config, executor_class)
     """
     if engine_args_dict is None:
-        engine_args_dict = build_engine_args_dict(
-            stage_config,
-            model,
-            stage_connector_spec=stage_connector_spec,
+        engine_args_dict = (
+            build_engine_args_dict_from_omni_stage_config(
+                stage_config, model, stage_connector_spec=stage_connector_spec
+            )
+            if isinstance(stage_config, BaseVllmOmniStageConfig)
+            else build_engine_args_dict(stage_config, model, stage_connector_spec=stage_connector_spec)
         )
 
     filtered_engine_args_dict = filter_dataclass_kwargs(OmniEngineArgs, engine_args_dict)
+    if api_process_count != 1 or api_process_rank != 0:
+        filtered_engine_args_dict["_api_process_count"] = api_process_count
+        filtered_engine_args_dict["_api_process_rank"] = api_process_rank
 
     # _to_dict serializes dataclass fields (e.g. StructuredOutputsConfig) into
     # plain dicts.  When OmniEngineArgs is instantiated with the dict, these
@@ -1715,6 +1754,7 @@ def acquire_device_locks(
     stage_id: int,
     engine_args_dict: dict[str, Any],
     stage_init_timeout: int,
+    locked_devices: set[int] | None = None,
 ) -> list[int]:
     """Acquire exclusive file locks on devices needed by this stage.
 
@@ -1769,8 +1809,7 @@ def acquire_device_locks(
                 f"but only {len(physical_devices)} device(s) are available: {physical_devices}"
             )
 
-        num_devices_to_lock = num_devices_per_stage
-        devices_to_lock = sorted(physical_devices[:num_devices_to_lock])
+        devices_to_lock = sorted(set(physical_devices[:num_devices_per_stage]) - (locked_devices or set()))
 
         logger.debug(
             "Parallel config: TP=%d, PP=%d, DP=%d, PCP=%d, SP=%d, CFG=%d; will lock %d devices: %s",
@@ -1780,7 +1819,7 @@ def acquire_device_locks(
             prefill_context_parallel_size,
             sequence_parallel_size,
             cfg_parallel_size,
-            num_devices_to_lock,
+            len(devices_to_lock),
             devices_to_lock,
         )
 
@@ -1798,6 +1837,8 @@ def acquire_device_locks(
                         record_lock_holder_pid(lock_fd, lock_writable)
                         lock_acquired = True
                         lock_fds.append(lock_fd)
+                        if locked_devices is not None:
+                            locked_devices.add(device_id)
                         logger.debug("Acquired exclusive lock for device %s", device_id)
                     except BlockingIOError:
                         os.close(lock_fd)
@@ -1926,9 +1967,25 @@ def build_diffusion_config(
     metadata: StageMetadata,
 ) -> Any:
     """Build diffusion config for a stage."""
+    from vllm_omni.config.omni_config import extract_diffusion_stage_config_kwargs
 
-    engine_args_dict = build_engine_args_dict(stage_cfg, model)
-    od_config = OmniDiffusionConfig.from_kwargs(**engine_args_dict)
+    engine_args_dict = (
+        build_engine_args_dict_from_omni_stage_config(stage_cfg, model)
+        if isinstance(stage_cfg, BaseVllmOmniStageConfig)
+        else build_engine_args_dict(stage_cfg, model)
+    )
+    stage_id = engine_args_dict.get("stage_id", metadata.stage_id)
+    diffusion_kwargs = extract_diffusion_stage_config_kwargs(
+        engine_args_dict,
+        stage_id=stage_id,
+        include_engine_adapter_metadata=True,
+    )
+    od_config = OmniDiffusionConfig(**{name: value for name, value in diffusion_kwargs.items() if value is not None})
+
+    for dimension in ("height", "width"):
+        value = getattr(metadata.default_sampling_params, dimension, None)
+        if isinstance(value, int) and value > 0:
+            od_config.additional_config.setdefault(f"diffusion_kv_profile_{dimension}", value)
 
     num_devices_per_stage = od_config.parallel_config.world_size
     device_control_env = current_omni_platform.device_control_env_var
diff --git a/vllm_omni/engine/stage_pool.py b/vllm_omni/engine/stage_pool.py
index 0ab6c1da7..46a34dfdb 100644
--- a/vllm_omni/engine/stage_pool.py
+++ b/vllm_omni/engine/stage_pool.py
@@ -15,6 +15,7 @@ from vllm.logger import init_logger
 from vllm.v1.engine import EngineCoreOutputs
 from vllm.v1.metrics.stats import IterationStats
 
+from vllm_omni.data_entry_keys import flatten_payload
 from vllm_omni.distributed.omni_coordinator import (
     LoadBalancer,
     OmniCoordClientForHub,
@@ -22,6 +23,7 @@ from vllm_omni.distributed.omni_coordinator import (
     ReplicaStatus,
 )
 from vllm_omni.distributed.omni_coordinator.load_balancer import Task
+from vllm_omni.engine.serialization import deserialize_additional_information
 from vllm_omni.engine.stage_client import (
     StagePoolClient,
     StagePoolDiffusionClient,
@@ -1136,8 +1138,30 @@ class StagePool:
         # gauges for that interval.
         if not outputs.outputs and outputs.scheduler_stats is None and not outputs.finished_requests:
             return None
+        self._rehydrate_pooling_output_payloads(outputs)
         return outputs
 
+    @staticmethod
+    def _rehydrate_pooling_output_payloads(outputs: EngineCoreOutputs) -> None:
+        """Restore dict-shaped pooling_output from its bytes carrier (MR V2).
+
+        vLLM decodes EngineCoreOutput.pooling_output as a torch.Tensor, so MR
+        V2 runners ship the per-request dict handoff via ``pooling_output_payload``
+        with ``pooling_output=None``. Decode it back here so downstream stage-input
+        processors see the same ``pooling_output`` shape as the legacy runner.
+        """
+        for eco in outputs.outputs:
+            payload = getattr(eco, "pooling_output_payload", None)
+            if payload is None:
+                continue
+            if getattr(eco, "pooling_output", None) is None:
+                # deserialize_* returns the nested OmniPayload form; the producer
+                # serialized a flat (dotted-key) pooler dict, and downstream
+                # consumers (e.g. talker2code2wav_full_payload) read flat keys like
+                # "codes.audio". Re-flatten to restore the exact on-wire shape.
+                eco.pooling_output = flatten_payload(deserialize_additional_information(payload))
+            eco.pooling_output_payload = None
+
     async def process_llm_raw_outputs(
         self,
         replica_id: int,
diff --git a/vllm_omni/engine/stage_runtime.py b/vllm_omni/engine/stage_runtime.py
index 53400df5e..ed22bfa87 100644
--- a/vllm_omni/engine/stage_runtime.py
+++ b/vllm_omni/engine/stage_runtime.py
@@ -6,19 +6,20 @@
 from __future__ import annotations
 
 import concurrent.futures
+import contextlib
 import copy
 import os
 import threading
-import time
 from collections.abc import Callable, Iterator, Mapping, Sequence
-from contextlib import ExitStack, contextmanager
-from dataclasses import dataclass
-from typing import Any, cast
+from contextlib import AbstractContextManager, contextmanager
+from dataclasses import dataclass, field
+from multiprocessing.process import BaseProcess
+from typing import Any, TypedDict, cast
 
 import janus
-from omegaconf import OmegaConf
 from vllm.logger import init_logger
 
+from vllm_omni.config.omni_config import BaseVllmOmniStageConfig, VllmOmniDiffusionStageConfig
 from vllm_omni.distributed.omni_connectors.utils.initialization import (
     resolve_omni_kv_config_for_stage,
 )
@@ -46,14 +47,17 @@ from vllm_omni.engine.stage_engine_startup import (
 from vllm_omni.engine.stage_init_utils import (
     LogicalStageInitPlan,
     ReplicaInitPlan,
+    StageMetadata,
     _inject_inferred_kv_tp_topology,
     acquire_device_locks,
     build_engine_args_dict,
+    build_engine_args_dict_from_omni_stage_config,
     build_llm_stage_output_processor,
     build_vllm_config,
     compute_replica_layout,
     device_overlap_group_keys,
     extract_legacy_stage_metadata,
+    extract_stage_metadata_from_omni_stage_config,
     get_stage_connector_spec,
     inject_kv_stage_info,
     inject_omni_kv_connector_config,
@@ -92,6 +96,44 @@ class StageRemoteFactoryContext:
     executor_class: type | None = None
 
 
+class OmniClientConfig(TypedDict, total=False):
+    """Per-frontend transport/configuration passed across process boundaries."""
+
+    client_count: int
+    client_index: int
+    stage_addresses: dict[int | str, dict[int | str, dict[str, Any]]]
+    input_address: str
+    output_address: str
+    stats_update_address: str
+    actual_address_pipe: Any
+    tensor_queue: Any
+
+
+@dataclass
+class StageEngineLaunch:
+    """Engine resources handed to a local client or the serving parent.
+
+    Successful launch transfers resource ownership to the caller. Startup or
+    attachment failures are rolled back by ``launch_stage_engines``.
+    """
+
+    client_configs: list[OmniClientConfig]
+    resources: list[StageReplicaResources]
+    watched_frontend_processes: list[BaseProcess] = field(default_factory=list)
+
+    def shutdown(self) -> None:
+        seen: set[int] = set()
+        for stage_resources in reversed(self.resources):
+            for resource in (stage_resources.manager, stage_resources.coordinator):
+                if resource is None or id(resource) in seen:
+                    continue
+                seen.add(id(resource))
+                try:
+                    resource.shutdown()
+                except Exception:
+                    logger.warning("[StageEngineLaunch] resource shutdown failed", exc_info=True)
+
+
 def _build_load_balancer_factory(policy: str) -> Callable[[], LoadBalancer]:
     try:
         normalized = LoadBalancingPolicy(policy)
@@ -123,13 +165,14 @@ class StageRuntime:
         self,
         stage_configs: list[Any],
         model: str,
-        config_path: str,
+        config_path: str | None,
         *,
         stage_init_timeout: int,
         async_chunk: bool,
         tokenizer: str | None = None,
         parallel_stage_init: bool = False,
         log_stats: bool = False,
+        client_config: OmniClientConfig | None = None,
     ) -> None:
         self._stage_configs = stage_configs
         self._model = model
@@ -144,6 +187,14 @@ class StageRuntime:
         self._parallel_stage_init = parallel_stage_init
         self._log_stats = log_stats
         self._num_stages = len(stage_configs)
+        self._client_count = int((client_config or {}).get("client_count", 1))
+        self._client_index = int((client_config or {}).get("client_index", 0))
+        if self._client_count < 1:
+            raise ValueError(f"client_count must be >= 1, got {self._client_count}")
+        if self._client_index != -1 and not 0 <= self._client_index < self._client_count:
+            raise ValueError(f"client_index must be in [0, {self._client_count}), got {self._client_index}")
+        self._external_stage_addresses = (client_config or {}).get("stage_addresses")
+        self._api_process_rank = self._client_index
 
         # Populated by initialize()
         self.stage_pools: list[StagePool] = []
@@ -262,6 +313,205 @@ class StageRuntime:
             self._cleanup_after_initialize_failure()
             raise exc
 
+    @contextmanager
+    def launch_stage_engines(
+        self,
+        num_api_servers: int = 1,
+        *,
+        stage_plans: Sequence[LogicalStageInitPlan] | None = None,
+        stage_init_timeout: int | None = None,
+    ) -> Iterator[StageEngineLaunch]:
+        """Launch EngineCore stages for local or subprocess client attachment.
+
+        The regular runtime supplies a replica plan from its device-group
+        scheduler; the serving parent resolves the whole pipeline here. Both
+        use the same device locks, spawn, readiness and rollback machinery.
+        One client completes readiness before attachment, preserving the
+        existing in-process frontend. Multiple clients attach in the caller's
+        ``with`` body before readiness completes on context exit.
+        """
+        if self._external_stage_addresses is not None:
+            raise ValueError("A runtime attached to external stage engines cannot launch engines")
+        if num_api_servers < 1:
+            raise ValueError(f"num_api_servers must be >= 1, got {num_api_servers}")
+        timeout = self._stage_init_timeout if stage_init_timeout is None else stage_init_timeout
+        resolve_plans = stage_plans is None
+        if stage_plans is None:
+            self._client_count = num_api_servers
+            self._api_process_rank = -1 if num_api_servers > 1 else self._client_index
+            self._init_visible_devices_baseline = os.environ.get(current_omni_platform.device_control_env_var)
+            stage_plans = self._prepare_stage_plans()
+
+        unsupported = [
+            plan.stage_id
+            for plan in stage_plans
+            if any(replica.metadata.stage_type == "diffusion" for replica in plan.replicas)
+        ]
+        if unsupported:
+            raise ValueError(
+                "--api-server-count currently supports EngineCore stages only; "
+                f"diffusion stage(s) are not supported: {unsupported}"
+            )
+        if any(replica.launch_mode != "local" for plan in stage_plans for replica in plan.replicas):
+            raise ValueError("--api-server-count is not supported with remote or headless stages")
+
+        if num_api_servers > 1:
+            parallel_configs: list[Any] = []
+            for plan in stage_plans:
+                for replica in plan.replicas:
+                    if replica.stage_vllm_config is None or replica.executor_class is None:
+                        raise RuntimeError(f"LLM stage {plan.stage_id} is missing its engine configuration")
+                    parallel_configs.append(replica.stage_vllm_config.parallel_config)
+            if any(getattr(parallel_config, "enable_fault_tolerance", False) for parallel_config in parallel_configs):
+                raise ValueError("--api-server-count > 1 cannot be combined with --enable-fault-tolerance")
+            if any(getattr(parallel_config, "enable_elastic_ep", False) for parallel_config in parallel_configs):
+                raise ValueError("--api-server-count > 1 cannot be combined with --enable-elastic-ep")
+            if any(
+                getattr(parallel_config, "data_parallel_size", 1) != 1 or getattr(parallel_config, "use_ray", False)
+                for parallel_config in parallel_configs
+            ):
+                raise ValueError(
+                    "--api-server-count > 1 currently supports one local process group per replica; "
+                    "intra-replica data parallelism and Ray backends are not supported"
+                )
+
+        if resolve_plans and self._parallel_stage_init:
+            self._reject_unguardable_executors(stage_plans)
+            self._run_stage_admission(stage_plans)
+
+        client_configs: list[OmniClientConfig] = [
+            OmniClientConfig(
+                client_count=num_api_servers,
+                client_index=client_index,
+                stage_addresses={},
+            )
+            for client_index in range(num_api_servers)
+        ]
+        entered_contexts: list[AbstractContextManager[StageReplicaResources]] = []
+        resources: list[StageReplicaResources] = []
+        watched_frontend_processes: list[BaseProcess] = []
+        # launch_stage_replica performs its readiness handshake in __exit__,
+        # after API workers are started, so initialization locks must remain
+        # held until all launch contexts have exited.
+        lock_fds: list[int] = []
+        locked_devices: set[int] = set()
+        launch: StageEngineLaunch | None = None
+        exited_contexts = 0
+
+        try:
+            for plan in stage_plans:
+                for replica in plan.replicas:
+                    if replica.stage_vllm_config is None or replica.executor_class is None:
+                        raise RuntimeError(f"LLM stage {plan.stage_id} is missing its engine configuration")
+                    if replica.engine_args_dict is None:
+                        raise RuntimeError(f"LLM stage {plan.stage_id} is missing engine args")
+
+                    physical_devices = self._resolve_replica_physical_devices(
+                        replica.metadata.stage_id,
+                        replica.metadata.runtime_cfg,
+                    )
+                    if not self._parallel_stage_init:
+                        with self._scoped_spawn_device_env(physical_devices):
+                            lock_fds.extend(
+                                acquire_device_locks(
+                                    replica.metadata.stage_id,
+                                    replica.engine_args_dict,
+                                    timeout,
+                                    locked_devices,
+                                )
+                            )
+
+                    launch_context = launch_stage_replica(
+                        vllm_config=replica.stage_vllm_config,
+                        executor_class=replica.executor_class,
+                        log_stats=self._log_stats,
+                        stage_id=replica.metadata.stage_id,
+                        replica_id=replica.replica_id,
+                        stage_config=replica.stage_cfg,
+                        omni_master_server=self._get_omni_master_server(),
+                        omni_coordinator_address=self._get_coordinator_address(),
+                        stage_visible_devices=physical_devices,
+                        spawn_device_lock=self._spawn_device_lock,
+                        omni_parallel_stage_init=self._parallel_stage_init,
+                        num_api_servers=num_api_servers,
+                        watched_frontend_processes=watched_frontend_processes if num_api_servers > 1 else None,
+                    )
+                    # Environment overlays are process-global. Serialize spawn;
+                    # parallel initialization waits for READY outside this lock.
+                    with self._replica_launch_lock:
+                        with stage_runtime_env(replica.metadata.stage_id, replica.metadata.runtime_cfg):
+                            stage_resources = launch_context.__enter__()
+                        entered_contexts.append(launch_context)
+                        if stage_resources is None:
+                            raise RuntimeError(f"LLM stage {plan.stage_id} launcher returned no resources")
+                        resources.append(stage_resources)
+                    if num_api_servers == 1:
+                        exited_contexts += 1
+                        launch_context.__exit__(None, None, None)
+                    addresses = stage_resources.addresses
+                    # The generic resource bundle allows no addresses (e.g.
+                    # diffusion), but EngineCore attachment requires them.
+                    if addresses is None:
+                        raise RuntimeError(f"LLM stage {plan.stage_id} launcher returned no addresses")
+                    # Unlike the single-client handshake, only stage 0 is
+                    # handed to APIServerProcessManager for address updates.
+                    # Other stages must already expose connectable endpoints.
+                    if num_api_servers > 1 and any(
+                        address.startswith("tcp://") and address.rsplit(":", 1)[-1] == "0"
+                        for address in (*addresses.inputs, *addresses.outputs)
+                    ):
+                        raise RuntimeError(
+                            f"Stage {plan.stage_id} returned deferred TCP addresses; "
+                            "multi-API launch requires fixed ports or IPC addresses"
+                        )
+                    if len(addresses.inputs) != num_api_servers or len(addresses.outputs) != num_api_servers:
+                        raise RuntimeError(
+                            f"Stage {plan.stage_id} returned {len(addresses.inputs)} input and "
+                            f"{len(addresses.outputs)} output addresses for {num_api_servers} API servers"
+                        )
+
+                    if num_api_servers == 1 and lock_fds:
+                        release_device_locks(lock_fds)
+                        lock_fds.clear()
+                        locked_devices.clear()
+
+                    for client_index, client_config in enumerate(client_configs):
+                        stage_addresses = client_config["stage_addresses"]
+                        replica_addresses = stage_addresses.setdefault(plan.stage_id, {})
+                        replica_addresses[replica.replica_id] = {
+                            "input_address": addresses.inputs[client_index],
+                            "output_address": addresses.outputs[client_index],
+                        }
+                        if addresses.frontend_stats_publish_address is not None:
+                            replica_addresses[replica.replica_id]["stats_update_address"] = (
+                                addresses.frontend_stats_publish_address
+                            )
+
+            launch = StageEngineLaunch(
+                client_configs=client_configs,
+                resources=resources,
+                watched_frontend_processes=watched_frontend_processes,
+            )
+            yield launch
+
+            while exited_contexts < len(entered_contexts):
+                entered_context = entered_contexts[exited_contexts]
+                exited_contexts += 1
+                entered_context.__exit__(None, None, None)
+        except BaseException as exc:
+            if launch is not None:
+                launch.shutdown()
+            else:
+                StageEngineLaunch(client_configs=client_configs, resources=resources).shutdown()
+            exc_info = (type(exc), exc, exc.__traceback__)
+            for pending_context in reversed(entered_contexts[exited_contexts:]):
+                with contextlib.suppress(BaseException):
+                    pending_context.__exit__(*exc_info)
+            raise
+        finally:
+            if lock_fds:
+                release_device_locks(lock_fds)
+
     def shutdown(self) -> None:
         for pool in self.stage_pools:
             for client in pool.clients:
@@ -288,6 +538,7 @@ class StageRuntime:
             replicas_per_stage,
             replica_devices_map,
         )
+        self._validate_native_kv_topology(stage_plans)
         return stage_plans
 
     def _finalize_initialized_stages(
@@ -336,6 +587,113 @@ class StageRuntime:
 
     # ---- Internal methods ----
 
+    def _validate_native_kv_topology(self, plans: list[LogicalStageInitPlan]) -> None:
+        """Reject unsupported native AR->DiT graphs before launching any Worker."""
+        if not any(plan.replicas[0].metadata.stage_type == "diffusion" for plan in plans):
+            return  # Native LLM prefill/decode is outside this path.
+        roles = {}
+        for plan in plans:
+            replica = plan.replicas[0]
+            if replica.stage_vllm_config is not None:
+                config = getattr(replica.stage_vllm_config, "kv_transfer_config", None)
+            elif isinstance(replica.stage_cfg, VllmOmniDiffusionStageConfig):
+                config = (
+                    replica.stage_cfg.connector_config.kv_transfer_config
+                    or replica.stage_cfg.diffusion_config.kv_transfer_config
+                )
+            else:
+                args = getattr(replica.stage_cfg, "engine_args", {})
+                config = (
+                    args.get("kv_transfer_config")
+                    if isinstance(args, Mapping)
+                    else getattr(args, "kv_transfer_config", None)
+                )
+            if config is not None:
+                roles[plan.stage_id] = config.get("kv_role") if isinstance(config, Mapping) else config.kv_role
+        if not roles:
+            return
+        if (
+            self._async_chunk
+            or len(plans) != 2
+            or roles != {0: "kv_producer", 1: "kv_consumer"}
+            or plans[0].replicas[0].metadata.stage_type != "llm"
+            or plans[1].replicas[0].metadata.stage_type != "diffusion"
+            or list(plans[1].replicas[0].metadata.engine_input_source or []) != [0]
+        ):
+            raise ValueError(
+                "Native AR-to-DiT KV transfer currently supports only a two-stage "
+                "0 (kv_producer) -> 1 (diffusion kv_consumer, engine_input_source=[0]) "
+                "pipeline with async_chunk=False"
+            )
+
+    @staticmethod
+    def _prepare_replica_stage_config(
+        stage_cfg: Any,
+        *,
+        stage_id: int,
+        stage_type: str,
+        replica_id: int,
+        num_replicas: int,
+    ) -> tuple[Any, bool]:
+        """Isolate replica config and assign the native DiT KV identity."""
+        if isinstance(stage_cfg, BaseVllmOmniStageConfig):
+            native_kv = stage_cfg.connector_config.kv_transfer_config
+            if native_kv is None and isinstance(stage_cfg, VllmOmniDiffusionStageConfig):
+                native_kv = stage_cfg.diffusion_config.kv_transfer_config
+        else:
+            native_kv = (
+                stage_cfg.engine_args.get("kv_transfer_config")
+                if isinstance(stage_cfg.engine_args, Mapping)
+                else getattr(stage_cfg.engine_args, "kv_transfer_config", None)
+            )
+        # Keep the logical stage's device pool and native KV identity
+        # intact; each replica owns its config throughout startup.
+        replica_cfg = copy.deepcopy(stage_cfg) if num_replicas > 1 or native_kv else stage_cfg
+        if native_kv and stage_type == "diffusion":
+            if isinstance(replica_cfg, VllmOmniDiffusionStageConfig):
+                kv_config = (
+                    replica_cfg.connector_config.kv_transfer_config or replica_cfg.diffusion_config.kv_transfer_config
+                )
+                assert kv_config is not None
+                kv_config.engine_id = f"{kv_config.engine_id}-s{stage_id}-r{replica_id}"
+            else:
+                kv_config = replica_cfg.engine_args["kv_transfer_config"]
+                kv_config["engine_id"] = f"{kv_config['engine_id']}-s{stage_id}-r{replica_id}"
+        return replica_cfg, bool(native_kv)
+
+    @staticmethod
+    def _prepare_replica_vllm_config(
+        stage_vllm_config: Any,
+        replica_cfg: Any,
+        replica_metadata: StageMetadata,
+        *,
+        native_kv: bool,
+    ) -> Any:
+        """Assign native AR KV identity and the producer bootstrap endpoint."""
+        if not native_kv or stage_vllm_config is None:
+            return stage_vllm_config
+        replica_vllm_config = copy.deepcopy(stage_vllm_config)
+        kv_config = replica_vllm_config.kv_transfer_config
+        kv_config.engine_id = f"{kv_config.engine_id}-s{replica_metadata.stage_id}-r{replica_metadata.replica_id}"
+        if kv_config.kv_connector == "MooncakeConnector" and kv_config.kv_role == "kv_producer":
+            extra = kv_config.kv_connector_extra_config
+            port = int(extra.get("bootstrap_port", 8998)) + replica_metadata.replica_id
+            extra["bootstrap_addr"] = f"http://{kv_config.kv_ip}:{port}"
+            if isinstance(replica_cfg, BaseVllmOmniStageConfig):
+                runtime_cfg = replica_cfg.runtime_config
+                runtime_cfg.env = {
+                    **(runtime_cfg.env or {}),
+                    "VLLM_MOONCAKE_BOOTSTRAP_PORT": str(port),
+                }
+            else:
+                runtime_cfg = copy.deepcopy(replica_metadata.runtime_cfg or {})
+                runtime_cfg["env"] = {
+                    **(runtime_cfg.get("env") or {}),
+                    "VLLM_MOONCAKE_BOOTSTRAP_PORT": str(port),
+                }
+                replica_metadata.runtime_cfg = runtime_cfg
+        return replica_vllm_config
+
     def _build_logical_stage_init_plans(
         self,
         omni_transfer_config: Any,
@@ -345,12 +703,12 @@ class StageRuntime:
         """Build startup plans for every logical stage and replica."""
         stage_plans: list[LogicalStageInitPlan] = []
 
-        # RFC #4021 transition boundary: stage planning still relies on legacy
-        # StageConfig.runtime and StageConfig.engine_args for replica and engine
-        # setup. Keep metadata extraction on the legacy path until the
-        # coordinated stage-init cutover.
         for stage_idx, stage_cfg in enumerate(self._stage_configs):
-            base_metadata = extract_legacy_stage_metadata(stage_cfg)
+            base_metadata = (
+                extract_stage_metadata_from_omni_stage_config(stage_cfg)
+                if isinstance(stage_cfg, BaseVllmOmniStageConfig)
+                else extract_legacy_stage_metadata(stage_cfg)
+            )
             stage_id = int(base_metadata.stage_id)
             if stage_id != stage_idx:
                 raise ValueError(
@@ -374,14 +732,20 @@ class StageRuntime:
             executor_class = None
             engine_args_dict = None
             if base_metadata.stage_type != "diffusion":
-                # The stable adapter entry point still receives the same
-                # legacy stage object as replica planning. Its implementation
-                # switches only at the coordinated RFC #4021 cutover.
-                engine_args_dict = build_engine_args_dict(
-                    stage_cfg,
-                    self._model,
-                    stage_connector_spec=stage_connector_spec,
-                    cli_tokenizer=self._tokenizer,
+                engine_args_dict = (
+                    build_engine_args_dict_from_omni_stage_config(
+                        stage_cfg,
+                        self._model,
+                        stage_connector_spec=stage_connector_spec,
+                        cli_tokenizer=self._tokenizer,
+                    )
+                    if isinstance(stage_cfg, BaseVllmOmniStageConfig)
+                    else build_engine_args_dict(
+                        stage_cfg,
+                        self._model,
+                        stage_connector_spec=stage_connector_spec,
+                        cli_tokenizer=self._tokenizer,
+                    )
                 )
                 inject_omni_kv_connector_config(
                     engine_args_dict,
@@ -398,15 +762,36 @@ class StageRuntime:
                     self._model,
                     stage_connector_spec=stage_connector_spec,
                     engine_args_dict=engine_args_dict,
+                    api_process_count=self._client_count,
+                    api_process_rank=self._api_process_rank,
                 )
 
             for replica_id in range(num_replicas):
-                replica_cfg = copy.deepcopy(stage_cfg) if replica_id > 0 else stage_cfg
+                replica_cfg, native_kv = self._prepare_replica_stage_config(
+                    stage_cfg,
+                    stage_id=stage_id,
+                    stage_type=base_metadata.stage_type,
+                    replica_id=replica_id,
+                    num_replicas=num_replicas,
+                )
                 if stage_idx in replica_devices_map:
-                    replica_cfg.runtime.devices = replica_devices_map[stage_idx][replica_id]
+                    devices = replica_devices_map[stage_idx][replica_id]
+                    runtime_cfg = getattr(replica_cfg, "runtime_config", getattr(replica_cfg, "runtime", None))
+                    if runtime_cfg is not None:
+                        runtime_cfg.devices = devices
 
-                replica_metadata = extract_legacy_stage_metadata(replica_cfg)
+                replica_metadata = (
+                    extract_stage_metadata_from_omni_stage_config(replica_cfg)
+                    if isinstance(replica_cfg, BaseVllmOmniStageConfig)
+                    else extract_legacy_stage_metadata(replica_cfg)
+                )
                 replica_metadata.replica_id = replica_id
+                replica_vllm_config = self._prepare_replica_vllm_config(
+                    stage_vllm_config,
+                    replica_cfg,
+                    replica_metadata,
+                    native_kv=native_kv,
+                )
                 if launch_mode == "remote" and replica_metadata.stage_type != "diffusion":
                     replica_metadata.runtime_cfg = None
                 replicas.append(
@@ -418,7 +803,7 @@ class StageRuntime:
                         metadata=replica_metadata,
                         stage_connector_spec=stage_connector_spec,
                         omni_kv_connector=omni_kv_connector,
-                        stage_vllm_config=stage_vllm_config,
+                        stage_vllm_config=replica_vllm_config,
                         executor_class=executor_class,
                         engine_args_dict=copy.deepcopy(engine_args_dict) if engine_args_dict is not None else None,
                     )
@@ -720,122 +1105,70 @@ class StageRuntime:
         stage_init_timeout: int,
     ) -> StagePoolClient:
         """Initialize one local LLM replica using vLLM's launch/attach pattern."""
-        resources: StageReplicaResources | None = None
-        stage_client = None
-        lock_fds: list[int] = []
-        try:
-            physical_devices = self._resolve_replica_physical_devices(
-                plan.metadata.stage_id,
-                plan.metadata.runtime_cfg,
-            )
-            if physical_devices:
-                logger.info(
-                    "[stage_init] Stage-%s set runtime devices: %s",
-                    plan.metadata.stage_id,
-                    physical_devices,
-                )
-            vllm_config = plan.stage_vllm_config
-            executor_class = plan.executor_class
-            if vllm_config is None:
-                raise RuntimeError(f"LLM stage {plan.metadata.stage_id} is missing vllm_config")
-            if executor_class is None:
-                raise RuntimeError(f"LLM stage {plan.metadata.stage_id} is missing executor_class")
-            if plan.engine_args_dict is None:
-                raise RuntimeError(f"LLM stage {plan.metadata.stage_id} is missing engine args")
-            # G3 device locks: in the default (serial) path the parent holds a
-            # per-device LOCK_EX across the whole child init. When parallel stage
-            # init is enabled the engine-core child takes phased SH/EX locks
-            # itself (see stage_phase_lock), so the parent must NOT also hold the
-            # lock here — it would self-deadlock while waiting for the child's
-            # READY handshake.
-            if not self._parallel_stage_init:
-                g3_start = time.perf_counter()
-                with self._scoped_spawn_device_env(physical_devices):
-                    lock_fds = acquire_device_locks(
-                        plan.metadata.stage_id,
-                        plan.engine_args_dict,
-                        stage_init_timeout,
-                    )
-                logger.debug(
-                    "[stage_init] Stage-%s G3 device-lock acquire took %.3fs",
-                    plan.metadata.stage_id,
-                    time.perf_counter() - g3_start,
-                )
-
-            launch_cm = launch_stage_replica(
-                vllm_config=vllm_config,
-                executor_class=executor_class,
-                log_stats=self._log_stats,
-                stage_id=plan.metadata.stage_id,
-                replica_id=plan.replica_id,
-                stage_config=plan.stage_cfg,
-                omni_master_server=self._get_omni_master_server(),
-                omni_coordinator_address=self._get_coordinator_address(),
-                stage_visible_devices=physical_devices,
-                spawn_device_lock=self._spawn_device_lock,
-                omni_parallel_stage_init=self._parallel_stage_init,
-            )
-            # Only process spawning and the runtime.env overlay need the global
-            # launch lock. The launch context's exit waits for READY: holding the
-            # lock there serializes model loading and compilation even across
-            # different GPUs. Default initialization keeps its per-device EX
-            # locks until READY; parallel_stage_init uses child phase locks.
-            g2_start = time.perf_counter()
-            with ExitStack() as launch_stack:
-                with self._replica_launch_lock:
-                    g2_locked = time.perf_counter()
-                    with stage_runtime_env(plan.metadata.stage_id, plan.metadata.runtime_cfg):
-                        resources = launch_stack.enter_context(launch_cm)
-                g2_spawned = time.perf_counter()
-            logger.debug(
-                "[stage_init] Stage-%s G2 launch-lock wait=%.3fs, spawn=%.3fs, READY=%.3fs",
-                plan.metadata.stage_id,
-                g2_locked - g2_start,
-                g2_spawned - g2_locked,
-                time.perf_counter() - g2_spawned,
+        external_addresses = self._get_external_client_addresses(
+            plan.metadata.stage_id,
+            plan.replica_id,
+        )
+        if external_addresses is not None:
+            if plan.stage_vllm_config is None or plan.executor_class is None:
+                raise RuntimeError(f"LLM stage {plan.metadata.stage_id} is missing its engine configuration")
+            return cast(
+                StagePoolClient,
+                StageEngineCoreClientBase.make_async_mp_client(
+                    vllm_config=plan.stage_vllm_config,
+                    executor_class=plan.executor_class,
+                    log_stats=self._log_stats,
+                    metadata=plan.metadata,
+                    client_addresses=external_addresses,
+                    client_count=self._client_count,
+                    client_index=self._client_index,
+                ),
             )
 
-            logger.info("[StageRuntime] Stage %s engine startup completed", plan.metadata.stage_id)
-            if resources is None:
-                raise RuntimeError(f"LLM stage {plan.metadata.stage_id} launcher returned no resources")
-            if resources.addresses is None:
-                raise RuntimeError(f"LLM stage {plan.metadata.stage_id} launcher returned no addresses")
-            stage_client = StageEngineCoreClientBase.make_async_mp_client(
-                vllm_config=vllm_config,
-                executor_class=executor_class,
-                log_stats=self._log_stats,
-                metadata=plan.metadata,
-                client_addresses=self._client_addresses_from_zmq(resources.addresses),
-                engine_manager=resources.manager,
-                coordinator=resources.coordinator,
+        if plan.stage_vllm_config is None or plan.executor_class is None:
+            raise RuntimeError(f"LLM stage {plan.metadata.stage_id} is missing its engine configuration")
+        stage_plan = LogicalStageInitPlan(
+            stage_idx=plan.metadata.stage_id,
+            stage_id=plan.metadata.stage_id,
+            replicas=[plan],
+        )
+        with self.launch_stage_engines(
+            stage_plans=[stage_plan],
+            stage_init_timeout=stage_init_timeout,
+        ) as launch:
+            resources = launch.resources[0]
+            return cast(
+                StagePoolClient,
+                StageEngineCoreClientBase.make_async_mp_client(
+                    vllm_config=plan.stage_vllm_config,
+                    executor_class=plan.executor_class,
+                    log_stats=self._log_stats,
+                    metadata=plan.metadata,
+                    client_addresses=self._client_addresses_from_zmq(resources.addresses),
+                    engine_manager=resources.manager,
+                    coordinator=resources.coordinator,
+                ),
             )
 
-            logger.info("[StageRuntime] Stage %s initialized", plan.metadata.stage_id)
-            return cast(StagePoolClient, stage_client)
-        except Exception:
-            if stage_client is not None:
-                try:
-                    stage_client.shutdown()
-                except Exception as cleanup_error:
-                    logger.warning(
-                        "[StageRuntime] Failed to cleanup stage %s after init failure: %s",
-                        plan.metadata.stage_id,
-                        cleanup_error,
-                    )
-            else:
-                self._cleanup_launched_resources(
-                    stage_id=plan.metadata.stage_id,
-                    resources=resources,
-                )
-            raise
-        finally:
-            if lock_fds:
-                release_device_locks(lock_fds)
-
     def _get_coordinator_address(self) -> str | None:
         """Return coordinator router address. Overridden by DistStageRuntime."""
         return None
 
+    def _get_external_client_addresses(self, stage_id: int, replica_id: int) -> dict[str, Any] | None:
+        if self._external_stage_addresses is None:
+            return None
+        stage_addresses = self._external_stage_addresses.get(stage_id)
+        if stage_addresses is None:
+            stage_addresses = self._external_stage_addresses.get(str(stage_id))
+        if stage_addresses is None:
+            raise ValueError(f"Missing external addresses for stage {stage_id}")
+        replica_addresses = stage_addresses.get(replica_id)
+        if replica_addresses is None:
+            replica_addresses = stage_addresses.get(str(replica_id))
+        if replica_addresses is None:
+            raise ValueError(f"Missing external addresses for stage {stage_id} replica {replica_id}")
+        return dict(replica_addresses)
+
     def _get_omni_master_server(self) -> OmniMasterServer | None:
         """Return the master server for local distributed launches, if any."""
         return None
@@ -859,17 +1192,25 @@ class StageRuntime:
                         raise RuntimeError("Omni KV connector requires source and destination stages")
                     inject_omni_kv_config(plan.stage_cfg, omni_conn_cfg, omni_from, omni_to)
                 inject_kv_stage_info(plan.stage_cfg, plan.metadata.stage_id, self._stage_configs)
-                engine_args = getattr(plan.stage_cfg, "engine_args", {})
-                inline_diffusion = (
-                    engine_args.get("inline_diffusion", False)
-                    if hasattr(engine_args, "get")
-                    else getattr(engine_args, "inline_diffusion", False)
-                )
-                custom_pipeline_args = (
-                    engine_args.get("custom_pipeline_args")
-                    if hasattr(engine_args, "get")
-                    else getattr(engine_args, "custom_pipeline_args", None)
-                )
+                if isinstance(plan.stage_cfg, BaseVllmOmniStageConfig):
+                    inline_diffusion = plan.stage_cfg.stage_pipeline_config.inline_diffusion
+                    custom_pipeline_args = getattr(
+                        getattr(plan.stage_cfg, "diffusion_config", None),
+                        "custom_pipeline_args",
+                        None,
+                    )
+                else:
+                    engine_args = getattr(plan.stage_cfg, "engine_args", {})
+                    inline_diffusion = (
+                        engine_args.get("inline_diffusion", False)
+                        if hasattr(engine_args, "get")
+                        else getattr(engine_args, "inline_diffusion", False)
+                    )
+                    custom_pipeline_args = (
+                        engine_args.get("custom_pipeline_args")
+                        if hasattr(engine_args, "get")
+                        else getattr(engine_args, "custom_pipeline_args", None)
+                    )
                 client, resources = launch_diffusion_stage_replica(
                     model=self._model,
                     stage_config=plan.stage_cfg,
@@ -966,7 +1307,7 @@ class DistStageRuntime(StageRuntime):
         self,
         stage_configs: list[Any],
         model: str,
-        config_path: str,
+        config_path: str | None,
         *,
         stage_init_timeout: int,
         async_chunk: bool,
@@ -1028,7 +1369,7 @@ class DistStageRuntime(StageRuntime):
 
         for idx, stage_cfg in enumerate(self._stage_configs):
             stage_id = int(getattr(stage_cfg, "stage_id", idx))
-            runtime_cfg = getattr(stage_cfg, "runtime", None)
+            runtime_cfg = getattr(stage_cfg, "runtime_config", getattr(stage_cfg, "runtime", None))
             if runtime_cfg is None:
                 continue
             if stage_id == target_stage_id:
@@ -1100,13 +1441,9 @@ class DistStageRuntime(StageRuntime):
         if registered_stage_cfg is None:
             raise ValueError(f"Remote stage {plan.metadata.stage_id} registered without stage config")
 
-        # Remote diffusion registration still transports the legacy mapping
-        # shape. Reconstruct and project that shape until its RFC #4021 cutover.
-        metadata = (
-            extract_legacy_stage_metadata(OmegaConf.create(registered_stage_cfg))
-            if plan.metadata.stage_type == "diffusion"
-            else copy.deepcopy(plan.metadata)
-        )
+        # Registration is transport-only: the head-side typed plan remains
+        # authoritative for metadata and topology.
+        metadata = extract_stage_metadata_from_omni_stage_config(plan.stage_cfg)
         metadata.replica_id = plan.replica_id
         ctx = StageRemoteFactoryContext(
             stage_id=plan.metadata.stage_id,
@@ -1303,7 +1640,7 @@ class DistStageRuntime(StageRuntime):
 def create_stage_runtime(
     stage_configs: list[Any],
     model: str,
-    config_path: str,
+    config_path: str | None,
     *,
     single_stage_mode: bool,
     stage_init_timeout: int,
@@ -1319,6 +1656,7 @@ def create_stage_runtime(
     omni_lb_policy: str = "random",
     request_queue: janus.Queue[EngineQueueMessage] | None = None,
     log_stats: bool = False,
+    client_config: OmniClientConfig | None = None,
 ) -> StageRuntime:
     """Factory: select StageRuntime or DistStageRuntime."""
     if single_stage_mode:
@@ -1350,4 +1688,5 @@ def create_stage_runtime(
         tokenizer=tokenizer,
         parallel_stage_init=parallel_stage_init,
         log_stats=log_stats,
+        client_config=client_config,
     )
diff --git a/vllm_omni/entrypoints/async_omni.py b/vllm_omni/entrypoints/async_omni.py
index 6114bbea2..1291e68f0 100644
--- a/vllm_omni/entrypoints/async_omni.py
+++ b/vllm_omni/entrypoints/async_omni.py
@@ -236,6 +236,7 @@ class AsyncOmni(AsyncOmniBase, EngineClient):
             req_state = ClientRequestState(
                 request_id=request_id,
                 external_request_id=external_request_id,
+                final_stage_id=final_stage_id_for_e2e,
             )
             req_state.metrics = metrics
             req_state.request_arrival_ts = wall_start_ts
diff --git a/vllm_omni/entrypoints/async_omni_base.py b/vllm_omni/entrypoints/async_omni_base.py
index e8adfc02a..6fa98f8cd 100644
--- a/vllm_omni/entrypoints/async_omni_base.py
+++ b/vllm_omni/entrypoints/async_omni_base.py
@@ -481,7 +481,22 @@ class AsyncOmniBase(OmniBase):
             if state is not None and rid not in delivered:
                 queue = getattr(state, "queue", None)
                 if queue is not None:
-                    await state.queue.put(self._synthetic_abort_output_message(rid))
+                    final_stage_id = getattr(state, "final_stage_id", None)
+                    if final_stage_id is None:
+                        final_stage_id = 0
+                    stage_metadata = getattr(self, "_stage_meta_list", ())
+                    final_output_type = (
+                        getattr(stage_metadata[final_stage_id], "final_output_type", None)
+                        if final_stage_id < len(stage_metadata)
+                        else None
+                    ) or "text"
+                    await state.queue.put(
+                        self._synthetic_abort_output_message(
+                            rid,
+                            stage_id=final_stage_id,
+                            final_output_type=final_output_type,
+                        )
+                    )
                     delivered.add(rid)
         for rid in request_ids:
             self._record_request_failure_once(rid, reason="client_abort")
@@ -493,13 +508,18 @@ class AsyncOmniBase(OmniBase):
             logger.info("[AsyncOmni] Aborted request(s) %s", ",".join(request_ids))
 
     @staticmethod
-    def _synthetic_abort_output_message(request_id: str) -> OutputMessage:
+    def _synthetic_abort_output_message(
+        request_id: str,
+        *,
+        stage_id: int,
+        final_output_type: str,
+    ) -> OutputMessage:
         """Terminal abort OutputMessage used when the engine returned none."""
         engine_output = OmniRequestOutput(
             request_id=request_id,
             finished=True,
-            stage_id=0,
-            final_output_type="text",
+            stage_id=stage_id,
+            final_output_type=final_output_type,
             outputs=[
                 CompletionOutput(
                     index=0,
@@ -514,7 +534,7 @@ class AsyncOmniBase(OmniBase):
         )
         return OutputMessage(
             request_id=request_id,
-            stage_id=0,
+            stage_id=stage_id,
             replica_id=None,
             engine_outputs=engine_output,
             metrics=None,
diff --git a/vllm_omni/entrypoints/cli/benchmark/cli_args.py b/vllm_omni/entrypoints/cli/benchmark/cli_args.py
index 626951298..bc8ae064f 100644
--- a/vllm_omni/entrypoints/cli/benchmark/cli_args.py
+++ b/vllm_omni/entrypoints/cli/benchmark/cli_args.py
@@ -192,6 +192,78 @@ def add_daily_omni_cli_args(parser: argparse.ArgumentParser) -> None:
     )
 
 
+def add_videomme_cli_args(parser: argparse.ArgumentParser) -> None:
+    """Add CLI arguments specific to the Video-MME dataset."""
+    group = parser.add_argument_group("Video-MME Dataset Options")
+    group.add_argument(
+        "--videomme-parquet",
+        type=str,
+        default=None,
+        help="Path to local Video-MME parquet "
+        "(e.g. videomme/test-00000-of-00001.parquet). When set, Hub QA loading is skipped.",
+    )
+    group.add_argument(
+        "--videomme-video-dir",
+        type=str,
+        default=None,
+        help="Directory containing extracted Video-MME videos (videoID.mp4). "
+        "Typical layout after unzipping videos_chunked_*.zip: <root>/video/. "
+        "When using file:// URLs, start the server with --allowed-local-media-path "
+        "covering this directory.",
+    )
+    group.add_argument(
+        "--videomme-subtitle-dir",
+        type=str,
+        default=None,
+        help="Directory containing Video-MME .srt subtitles (videoID.srt). Used only with --videomme-use-subtitle.",
+    )
+    group.add_argument(
+        "--videomme-pack-mode",
+        type=str,
+        choices=["minicpm-frames", "minicpm-interleave", "video_url"],
+        default="minicpm-frames",
+        help="Multimodal packing. "
+        "'minicpm-frames' (default): OmniEvalKit MiniCPM videomme recipe — sampled frames "
+        "as image_url only (max_frames=96). "
+        "'minicpm-interleave': OmniEvalKit videomme_short recipe — 1fps frame/audio pairs "
+        "(max_frames=64). "
+        "'video_url': single video_url part (models with native video input).",
+    )
+    group.add_argument(
+        "--videomme-max-frames",
+        type=int,
+        default=None,
+        help="Override max sampled frames (OmniEvalKit defaults: 96 for minicpm-frames, 64 for minicpm-interleave).",
+    )
+    group.add_argument(
+        "--videomme-duration",
+        type=str,
+        choices=["all", "short", "medium", "long"],
+        default="all",
+        help="Filter by Video-MME duration bucket (default: all).",
+    )
+    group.add_argument(
+        "--videomme-use-subtitle",
+        action="store_true",
+        default=False,
+        help="Prepend subtitle text to the user prompt (Video-MME w/ subs setting).",
+    )
+    group.add_argument(
+        "--videomme-inline-local-video",
+        action="store_true",
+        default=False,
+        help="Embed local frames/audio as base64 data URLs so the server does not need "
+        "--allowed-local-media-path. Increases request size; use for small --num-prompts.",
+    )
+    group.add_argument(
+        "--videomme-save-eval-items",
+        action="store_true",
+        default=False,
+        help="Include per-request Video-MME accuracy rows in the saved JSON under "
+        "videomme_eval_items. Or set env VIDEOMME_SAVE_EVAL_ITEMS=1.",
+    )
+
+
 def add_seed_tts_cli_args(parser: argparse.ArgumentParser) -> None:
     """Add CLI arguments for Seed-TTS benchmarks."""
     group = parser.add_argument_group("Seed-TTS Dataset Options")
@@ -266,6 +338,7 @@ _OMNI_BENCH_DATASET_CHOICES = (
     "seed-tts-design",
     "ttsd",
     "sound-effect",
+    "videomme",
 )
 
 
@@ -332,6 +405,7 @@ def update_omni_help(parser: argparse.ArgumentParser) -> None:
 def add_omni_args(parser: argparse.ArgumentParser) -> None:
     """Register all vLLM-Omni serving benchmark arguments."""
     add_daily_omni_cli_args(parser)
+    add_videomme_cli_args(parser)
     add_omniinteract_cli_args(parser)
     add_seed_tts_cli_args(parser)
     add_multi_stage_cli_args(parser)
diff --git a/vllm_omni/entrypoints/cli/serve.py b/vllm_omni/entrypoints/cli/serve.py
index bc7f81132..10ae2166d 100644
--- a/vllm_omni/entrypoints/cli/serve.py
+++ b/vllm_omni/entrypoints/cli/serve.py
@@ -8,13 +8,16 @@ Supports both multi-stage LLM models (e.g., Qwen2.5-Omni) and
 diffusion models (e.g., Qwen-Image) through the same CLI interface.
 """
 
+from __future__ import annotations
+
 import argparse
+import contextlib
 import json
 import math
 import os
 import signal
 from types import FrameType
-from typing import Any, cast
+from typing import TYPE_CHECKING, Any, cast
 
 import uvloop
 from vllm.entrypoints.cli.types import CLISubcommand
@@ -22,11 +25,20 @@ from vllm.entrypoints.launchers.cli_args import make_arg_parser, validate_parsed
 from vllm.entrypoints.serve.utils.api_utils import VLLM_SUBCMD_PARSER_EPILOG
 from vllm.logger import init_logger
 
+from vllm_omni.diffusion.registry import resolve_native_single_file
 from vllm_omni.entrypoints.cli.logo import log_logo
-from vllm_omni.entrypoints.openai.api_server import omni_run_server
-from vllm_omni.entrypoints.utils import parse_stage_overrides
+from vllm_omni.entrypoints.openai.api_server import (
+    omni_run_server,
+    run_omni_api_server_worker_proc,
+)
+from vllm_omni.entrypoints.utils import parse_stage_overrides, prepare_stage_config_inputs
 from vllm_omni.utils.tracking_parser import TrackingArgumentParser, TrackingNamespace
 
+if TYPE_CHECKING:
+    from vllm.v1.utils import APIServerProcessManager
+
+    from vllm_omni.engine.stage_runtime import StageEngineLaunch, StageRuntime
+
 logger = init_logger(__name__)
 
 DESCRIPTION = """Launch a local OpenAI-compatible API server to serve Omni models
@@ -141,6 +153,8 @@ class OmniServeCommand(CLISubcommand):
 
         if args.headless:
             run_headless(args)
+        elif (getattr(args, "api_server_count", None) or 1) > 1:
+            run_multi_api_server_omni(args)
         else:
             uvloop.run(omni_run_server(args))
 
@@ -198,6 +212,39 @@ class OmniServeCommand(CLISubcommand):
         if getattr(args, "omni_replica_address", None) is not None and not args.headless:
             raise ValueError("--omni-replica-address requires --headless to be set")
 
+        api_server_count = getattr(args, "api_server_count", None)
+        if api_server_count is not None and api_server_count < 1 and not args.headless:
+            raise ValueError("--api-server-count must be >= 1 unless --headless is set")
+        if args.headless and api_server_count is not None and api_server_count > 0:
+            raise ValueError("--api-server-count cannot be used with --headless")
+        if api_server_count is not None and api_server_count > 1:
+            distributed_args = (
+                "stage_id",
+                "omni_master_address",
+                "omni_master_port",
+                "omni_replica_address",
+            )
+            if any(getattr(args, name, None) is not None for name in distributed_args):
+                raise ValueError(
+                    "--api-server-count > 1 cannot be combined with stage-based "
+                    "or distributed stage arguments (--stage-id/--omni-master-* / "
+                    "--omni-replica-address)"
+                )
+            if getattr(args, "omni_dp_size_local", 1) != 1:
+                raise ValueError("--api-server-count > 1 requires --omni-dp-size-local=1")
+            if getattr(args, "worker_backend", "multi_process") != "multi_process":
+                raise ValueError("--api-server-count > 1 requires --worker-backend=multi_process")
+            if getattr(args, "enable_fault_tolerance", False):
+                raise ValueError("--api-server-count > 1 cannot be combined with --enable-fault-tolerance")
+            if getattr(args, "enable_elastic_ep", False):
+                raise ValueError("--api-server-count > 1 cannot be combined with --enable-elastic-ep")
+            if getattr(args, "enable_sleep_mode", False):
+                raise ValueError("--api-server-count > 1 cannot be combined with --enable-sleep-mode")
+            from vllm import envs as vllm_envs
+
+            if getattr(vllm_envs, "VLLM_ALLOW_RUNTIME_LORA_UPDATING", False):
+                raise ValueError("--api-server-count > 1 cannot be combined with VLLM_ALLOW_RUNTIME_LORA_UPDATING")
+
         # --omni-dp-size-local is process-local. A value other than 1 only
         # makes sense when this process owns a stage (head or headless).
         omni_dp_size_local = getattr(args, "omni_dp_size_local", None)
@@ -221,7 +268,6 @@ class OmniServeCommand(CLISubcommand):
                 "data_parallel_rpc_port": "--data-parallel-rpc-port",
                 "data_parallel_start_rank": "--data-parallel-start-rank",
                 "data_parallel_backend": "--data-parallel-backend",
-                "api_server_count": "--api-server-count",
                 "enable_expert_parallel": "--enable-expert-parallel",
             }
             offenders = sorted(flag for dest, flag in prohibited_with_omni.items() if dest in explicit_cli_keys)
@@ -260,7 +306,10 @@ class OmniServeCommand(CLISubcommand):
         from vllm_omni.diffusion.utils.hf_utils import is_diffusion_model
 
         model = getattr(args, "model_tag", None) or getattr(args, "model", None)
-        if model and is_diffusion_model(model):
+        native_single_file = resolve_native_single_file(getattr(args, "model_class_name", None))
+        if model and ((native_single_file is not None and os.path.isfile(model)) or is_diffusion_model(model)):
+            if api_server_count is not None and api_server_count > 1:
+                raise ValueError("--api-server-count > 1 is not supported for diffusion models")
             logger.info("Detected diffusion model: %s", model)
             return
         validate_parsed_serve_args(args)
@@ -589,6 +638,16 @@ class OmniServeCommand(CLISubcommand):
                 '(e.g. \'{"num_inference_steps": 30, "guidance_scale": 7.5}\').'
             ),
         )
+        omni_config_group.add_argument(
+            "--custom-pipeline-args",
+            dest="custom_pipeline_args",
+            type=json.loads,
+            default=None,
+            help=(
+                "JSON object passed to native/custom diffusion pipelines. "
+                'Only args containing "pipeline_class" trigger custom pipeline re-initialization.'
+            ),
+        )
         omni_config_group.add_argument(
             "--usp",
             "--ulysses-degree",
@@ -894,7 +953,8 @@ class OmniServeCommand(CLISubcommand):
             "--diffusion-kv-cache-dtype",
             type=str,
             default=None,
-            help="Diffusion attention KV cache dtype (e.g. fp8). Separate from vLLM --kv-cache-dtype.",
+            help="Diffusion Q/K/V precision: fp8, mxfp8, mxfp4, or float (NPU). "
+            "Separate from vLLM --kv-cache-dtype. Use --diffusion-attention-config for per-role fallback.",
         )
         omni_config_group.add_argument(
             "--diffusion-kv-cache-skip-steps",
@@ -1027,6 +1087,207 @@ class OmniServeCommand(CLISubcommand):
         return serve_parser
 
 
+def _build_multi_api_stage_runtime(args: TrackingNamespace, num_api_servers: int) -> StageRuntime:
+    """Resolve the local EngineCore stages that the parent process owns."""
+    from vllm_omni.config.resolver import resolve_omni_config
+    from vllm_omni.engine.stage_runtime import StageRuntime
+
+    kwargs = args.get_explicit_kwargs_dict()
+    model = kwargs.pop("model", None) or args.model
+
+    trust_remote_code = kwargs.get("trust_remote_code")
+    if trust_remote_code is False:
+        trust_remote_code = None
+    config_inputs = prepare_stage_config_inputs(
+        model,
+        kwargs,
+        trust_remote_code=trust_remote_code,
+        snapshot_model=True,
+    )
+    model = config_inputs.model
+    kwargs = config_inputs.kwargs
+    resolved = resolve_omni_config(
+        model,
+        cli_overrides=kwargs,
+        trust_remote_code=config_inputs.trust_remote_code,
+        deploy_config_path=config_inputs.deploy_config_path,
+        stage_overrides=config_inputs.stage_overrides,
+        strategy_config_path=config_inputs.strategy_config_path,
+    )
+
+    config_path = resolved.config_path
+    stage_configs = list(resolved.stage_configs)
+
+    sleep_stages = [
+        int(getattr(stage_config, "stage_id", stage_index))
+        for stage_index, stage_config in enumerate(stage_configs)
+        if bool(
+            getattr(
+                getattr(stage_config, "model_config", getattr(stage_config, "engine_args", None)),
+                "enable_sleep_mode",
+                False,
+            )
+        )
+    ]
+    if sleep_stages:
+        raise ValueError(
+            "--api-server-count > 1 cannot be combined with sleep mode; "
+            f"disable enable_sleep_mode for stage(s) {sleep_stages}"
+        )
+
+    async_chunk = any(
+        bool(
+            getattr(
+                getattr(stage, "connector_config", None),
+                "async_chunk",
+                getattr(getattr(stage, "engine_args", None), "async_chunk", False),
+            )
+        )
+        for stage in stage_configs
+    )
+    return StageRuntime(
+        stage_configs=stage_configs,
+        model=model,
+        config_path=config_path,
+        stage_init_timeout=int(getattr(args, "stage_init_timeout", 300)),
+        parallel_stage_init=bool(getattr(args, "parallel_stage_init", False)),
+        async_chunk=async_chunk,
+        tokenizer=getattr(args, "tokenizer", None),
+        log_stats=not bool(getattr(args, "disable_log_stats", False)),
+    )
+
+
+def _wait_for_multi_api_server_completion(
+    api_server_manager: APIServerProcessManager,
+    engine_launch: StageEngineLaunch,
+) -> None:
+    """Wait until API workers complete or any shared stage engine fails."""
+    from multiprocessing import connection
+
+    api_processes = list(api_server_manager.processes)
+    engine_processes = [
+        process
+        for resources in engine_launch.resources
+        if resources.manager is not None
+        for process in resources.manager.processes
+    ]
+    api_by_sentinel = {process.sentinel: process for process in api_processes}
+    engine_by_sentinel = {process.sentinel: process for process in engine_processes}
+
+    while api_by_sentinel:
+        ready = connection.wait([*api_by_sentinel, *engine_by_sentinel])
+        for sentinel in ready:
+            if sentinel in engine_by_sentinel:
+                process = engine_by_sentinel[sentinel]
+                raise RuntimeError(
+                    f"Shared stage engine process {process.name} (PID: {process.pid}) "
+                    f"exited with code {process.exitcode}"
+                )
+            process = api_by_sentinel.pop(sentinel)
+            if process.exitcode != 0:
+                raise RuntimeError(
+                    f"API server process {process.name} (PID: {process.pid}) exited with code {process.exitcode}"
+                )
+
+
+def _start_api_server_process_manager(
+    *,
+    cleanup_timeout: float,
+    **manager_kwargs: object,
+) -> APIServerProcessManager:
+    """Construct vLLM's manager with rollback for a partial ``__init__``.
+
+    ``APIServerProcessManager`` starts workers one by one in ``__init__`` and
+    installs its finalizer only after every ``Process.start`` succeeds. Keep a
+    reference to the partially initialized object so workers started before a
+    later failure are still terminated.
+    """
+    from vllm.v1.utils import APIServerProcessManager, shutdown
+
+    manager = APIServerProcessManager.__new__(APIServerProcessManager)
+    try:
+        APIServerProcessManager.__init__(manager, **manager_kwargs)
+    except BaseException:
+        try:
+            for pipe in getattr(manager, "_address_pipes", ()):
+                with contextlib.suppress(Exception):
+                    pipe.close()
+            # A Process whose start() raised is still present in the upstream
+            # manager's list, but calling is_alive() on it raises because it
+            # has no Popen object. Only hand successfully started children to
+            # vLLM's shutdown helper.
+            started_processes = [process for process in getattr(manager, "processes", ()) if process.pid is not None]
+            if started_processes:
+                shutdown(started_processes, timeout=cleanup_timeout)
+        except Exception:
+            logger.exception("Failed to clean up partially started API server processes")
+        raise
+    return manager
+
+
+def run_multi_api_server_omni(args: TrackingNamespace) -> None:
+    """Launch API subprocesses that share one set of local stage engines."""
+    from vllm.entrypoints.openai.api_server import setup_server
+    from vllm.v1.metrics.prometheus import setup_multiprocess_prometheus
+
+    num_api_servers = int(args.api_server_count)
+    if num_api_servers < 2:
+        raise ValueError(f"api_server_count must be >= 2, got {num_api_servers}")
+
+    setup_multiprocess_prometheus()
+    shutdown_requested = False
+
+    def signal_handler(signum: int, frame: FrameType | None) -> None:
+        nonlocal shutdown_requested
+        logger.debug("Received %d signal.", signum)
+        if not shutdown_requested:
+            shutdown_requested = True
+            raise SystemExit
+
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    listen_address, sock = setup_server(args, reuse_port=True)
+    stage_runtime = None
+    api_server_manager = None
+    engine_launch = None
+    try:
+        stage_runtime = _build_multi_api_stage_runtime(args, num_api_servers)
+        with stage_runtime.launch_stage_engines(num_api_servers) as engine_launch:
+            args._omni_stage_client_configs = engine_launch.client_configs
+            primary_addresses = engine_launch.resources[0].addresses
+            if primary_addresses is None:
+                raise RuntimeError("Primary stage engine returned no addresses")
+            timeout = float(getattr(args, "shutdown_timeout", 5) or 5)
+            api_server_manager = _start_api_server_process_manager(
+                cleanup_timeout=timeout,
+                listen_address=listen_address,
+                sock=sock,
+                args=args,
+                num_servers=num_api_servers,
+                input_addresses=primary_addresses.inputs,
+                output_addresses=primary_addresses.outputs,
+                target_server_fn=run_omni_api_server_worker_proc,
+            )
+            engine_launch.watched_frontend_processes.extend(api_server_manager.processes)
+            actual_inputs, actual_outputs = api_server_manager.gather_actual_addresses()
+            primary_addresses.inputs = actual_inputs
+            primary_addresses.outputs = actual_outputs
+
+        _wait_for_multi_api_server_completion(api_server_manager, engine_launch)
+    finally:
+        timeout = float(getattr(args, "shutdown_timeout", 5) or 5)
+        if api_server_manager is not None:
+            api_server_manager.shutdown(timeout=timeout)
+        if engine_launch is not None:
+            engine_launch.shutdown()
+        if stage_runtime is not None:
+            stage_runtime.shutdown()
+        sock.close()
+        if shutdown_requested:
+            logger.info("Shared API server shutdown completed")
+
+
 def run_headless(args: TrackingNamespace) -> None:
     """Run a single stage in headless mode.
 
@@ -1048,6 +1309,7 @@ def run_headless(args: TrackingNamespace) -> None:
     )
     from vllm_omni.engine.stage_init_utils import (
         build_engine_args_dict,
+        build_engine_args_dict_from_omni_stage_config,
         build_vllm_config,
         get_stage_connector_spec,
         inject_omni_kv_connector_config,
@@ -1074,15 +1336,6 @@ def run_headless(args: TrackingNamespace) -> None:
 
     # Filter down to a dict of things explicitly requested by the user
     args_dict = args.get_explicit_kwargs_dict()
-    # This controls only the API-process WebSocket and is not a stage-engine option.
-    args_dict.pop("robot_openpi_idle_timeout", None)
-    # This CLI-only negative alias is consumed below when selecting the
-    # launcher log_stats value; it is not a per-stage config override.
-    args_dict.pop("disable_log_stats", None)
-
-    deploy_config_path = args_dict.pop("deploy_config", None)
-    strategy_config_path = args_dict.pop("strategy_config", None)
-    stage_overrides = args_dict.pop("stage_overrides", None)
 
     # ``--replica-id`` is deprecated and ignored — replica ids are
     # auto-assigned by ``OmniMasterServer`` so headless processes carry
@@ -1098,15 +1351,21 @@ def run_headless(args: TrackingNamespace) -> None:
         )
         args_dict.pop("replica_id")
 
-    resolved = resolve_omni_config(
+    config_inputs = prepare_stage_config_inputs(
         model,
+        args_dict,
         # store_true cannot express an explicit False: absent maps to None
         # ("not specified") so the deploy yaml's per-stage value applies.
         trust_remote_code=getattr(args, "trust_remote_code", None) or None,
+    )
+    args_dict = config_inputs.kwargs
+    resolved = resolve_omni_config(
+        model,
+        trust_remote_code=config_inputs.trust_remote_code,
         cli_overrides=args_dict,
-        deploy_config_path=deploy_config_path,
-        stage_overrides=stage_overrides,
-        strategy_config_path=strategy_config_path,
+        deploy_config_path=config_inputs.deploy_config_path,
+        stage_overrides=config_inputs.stage_overrides,
+        strategy_config_path=config_inputs.strategy_config_path,
     )
     config_path = resolved.config_path
     stage_configs = list(resolved.stage_configs)
@@ -1141,21 +1400,21 @@ def run_headless(args: TrackingNamespace) -> None:
     stage_connector_spec = get_stage_connector_spec(
         omni_transfer_config=omni_transfer_config,
         stage_id=stage_id,
-        async_chunk=bool(stage_cfg.engine_args.get("async_chunk", False)),
+        async_chunk=bool(
+            getattr(getattr(stage_cfg, "connector_config", None), "async_chunk", None)
+            if hasattr(stage_cfg, "connector_config")
+            else stage_cfg.engine_args.get("async_chunk", False)
+        ),
     )
 
-    # ``runtime_cfg`` is mostly inherited from the parent's
-    # CUDA_VISIBLE_DEVICES; when ``--omni-dp-size-local > 1`` we additionally
-    # bracket each replica's spawn below with setup_stage_devices so they
-    # don't all stack on cuda:0 (see ``per_replica_devices`` above).
-    # Headless startup still supplies the legacy OmegaConf stage shape through
-    # the stable adapter entry point. The implementation switches only when
-    # RFC #4021 threads structured stage configs through the launch plan.
-    engine_args_dict = build_engine_args_dict(
-        stage_cfg,
-        model,
-        stage_connector_spec=stage_connector_spec,
-        cli_tokenizer=getattr(args, "tokenizer", None),
+    engine_args_dict = (
+        build_engine_args_dict_from_omni_stage_config(
+            stage_cfg, model, stage_connector_spec=stage_connector_spec, cli_tokenizer=getattr(args, "tokenizer", None)
+        )
+        if hasattr(stage_cfg, "connector_config")
+        else build_engine_args_dict(
+            stage_cfg, model, stage_connector_spec=stage_connector_spec, cli_tokenizer=getattr(args, "tokenizer", None)
+        )
     )
 
     inject_omni_kv_connector_config(engine_args_dict, omni_kv_connector, stage_id)
diff --git a/vllm_omni/entrypoints/client_request_state.py b/vllm_omni/entrypoints/client_request_state.py
index 22f1c6d5e..ca9e96bab 100644
--- a/vllm_omni/entrypoints/client_request_state.py
+++ b/vllm_omni/entrypoints/client_request_state.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import asyncio
 
 from vllm_omni.metrics import OrchestratorAggregator
@@ -11,10 +14,12 @@ class ClientRequestState:
         request_id: str,
         external_request_id: str | None = None,
         queue: asyncio.Queue | None = None,
+        final_stage_id: int | None = None,
     ):
         self.request_id = request_id
         self.external_request_id = external_request_id
         self.stage_id: int | None = None
+        self.final_stage_id: int | None = final_stage_id
         self.queue = queue if queue is not None else asyncio.Queue()
         self.metrics: OrchestratorAggregator | None = None
         # Request-scoped idempotency guard for Prometheus failure counters.
diff --git a/vllm_omni/entrypoints/duplex/realtime_input.py b/vllm_omni/entrypoints/duplex/realtime_input.py
index be700ef62..79a081696 100644
--- a/vllm_omni/entrypoints/duplex/realtime_input.py
+++ b/vllm_omni/entrypoints/duplex/realtime_input.py
@@ -5,7 +5,9 @@
 
 Everything that needed session state now lives engine-side
 (``vllm_omni.engine.duplex.realtime_commands`` for the command mapping,
-``vllm_omni.engine.duplex.realtime_events`` for the projection state). What is
+``vllm_omni.engine.duplex.realtime_events`` for the projection state), and the
+model-agnostic parsing both of those build on lives in
+``vllm_omni.protocol.realtime``. What is
 left here is the per-connection handshake policy (query-param defaults,
 autostart / resume-only rules, ``session.resume`` parsing), the wire defaults
 used to translate appends, and error rendering through the typed
@@ -20,10 +22,8 @@ from typing import TYPE_CHECKING
 
 from vllm_omni.engine.duplex.commands import DuplexCommand, DuplexCommandError
 from vllm_omni.engine.duplex.events import error_event
-from vllm_omni.engine.duplex.realtime_commands import (
-    RealtimeInputDefaults,
-    translate_realtime_command,
-)
+from vllm_omni.engine.duplex.realtime_commands import translate_realtime_command
+from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
 if TYPE_CHECKING:
     from starlette.websockets import WebSocket
diff --git a/vllm_omni/entrypoints/duplex/serving.py b/vllm_omni/entrypoints/duplex/serving.py
index 364f715c0..ff1abbe25 100644
--- a/vllm_omni/entrypoints/duplex/serving.py
+++ b/vllm_omni/entrypoints/duplex/serving.py
@@ -36,7 +36,6 @@ from vllm_omni.engine.duplex.events import (
     SessionResyncRequired,
 )
 from vllm_omni.engine.duplex.messages import DuplexSessionError
-from vllm_omni.engine.duplex.realtime_commands import RealtimeInputDefaults
 from vllm_omni.entrypoints.duplex.realtime_input import RealtimeEnvelope, parse_resume_request
 from vllm_omni.entrypoints.duplex.session_attachment import (
     DuplexJournalGapError,
@@ -52,6 +51,7 @@ from vllm_omni.entrypoints.duplex.websocket import (
     receive_text_with_timeout,
 )
 from vllm_omni.entrypoints.duplex_omni import DuplexOmni, DuplexSessionHandle
+from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
 logger = init_logger(__name__)
 
diff --git a/vllm_omni/entrypoints/duplex/warmup.py b/vllm_omni/entrypoints/duplex/warmup.py
index 2c138096d..f711cfccb 100644
--- a/vllm_omni/entrypoints/duplex/warmup.py
+++ b/vllm_omni/entrypoints/duplex/warmup.py
@@ -46,6 +46,7 @@ async def _warmup_duplex_realtime(app, args, warmup_frames: int) -> None:
         # One silence unit as the engine-side plugin defines it (DuplexOmniEngine.plugin).
         plugin = getattr(getattr(app.state.engine_client, "engine", None), "plugin", None)
         frame_samples = int(getattr(plugin, "silence_continuation_samples", 16000))
+        native_append = plugin.capabilities(max_sessions=1).supports_core_resumable_request if plugin else True
         silence = base64.b64encode(bytes(frame_samples * 4)).decode("ascii")
         from vllm_omni.clients.duplex import build_realtime_url
 
@@ -81,7 +82,7 @@ async def _warmup_duplex_realtime(app, args, warmup_frames: int) -> None:
                             "output_audio_format": "pcm16",
                             "idle_timeout_s": 60,
                             "turn_detection": None,
-                            "extra_body": {"auto_response": True},
+                            "extra_body": {"auto_response": native_append},
                         },
                     }
                 )
@@ -108,6 +109,8 @@ async def _warmup_duplex_realtime(app, args, warmup_frames: int) -> None:
                 await ws.send(json.dumps({"type": "input_audio_buffer.append", "audio": silence}))
                 sent += 1
                 await asyncio.sleep(0.08)
+            if not native_append:
+                await ws.send(json.dumps({"type": "input_audio_buffer.commit", "final": True}))
             # Wait for the pipeline's first audio output so every stage ran.
             saw_audio = await _recv_until(lambda e: e.get("type") == "response.output_audio.delta", 30)
             # Close the session EXPLICITLY: a bare websocket close parks the
diff --git a/vllm_omni/entrypoints/openai/api_server.py b/vllm_omni/entrypoints/openai/api_server.py
index 376a9ccd2..3bf3f3ff5 100644
--- a/vllm_omni/entrypoints/openai/api_server.py
+++ b/vllm_omni/entrypoints/openai/api_server.py
@@ -6,6 +6,7 @@ This module owns app construction, server startup, app-state initialization,
 and route bodies that have not yet moved to endpoint-owned modules."""
 
 import asyncio
+import copy
 import dataclasses
 import json
 import multiprocessing
@@ -14,13 +15,17 @@ import os
 
 # Image generation API imports
 import random
+import signal
+import socket
 import time
 from argparse import Namespace
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from http import HTTPStatus
+from pathlib import Path
 from typing import Annotated, Any, Literal
 
+import uvloop
 import vllm.envs as envs
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Request, UploadFile, WebSocket
 from fastapi.responses import FileResponse, JSONResponse, Response, StreamingResponse
@@ -80,12 +85,14 @@ from vllm.renderers.online_renderer import OnlineRenderer
 from vllm.tasks import POOLING_TASKS
 from vllm.tool_parsers import ToolParserManager
 from vllm.utils import random_uuid
-from vllm.utils.system_utils import decorate_logs
+from vllm.utils.system_utils import decorate_logs, set_process_title
 from vllm.v1.engine.exceptions import EngineDeadError, EngineGenerateError
 
 from vllm_omni.config.endpoint_policy import (
     shutdown_unsupported_routes,
 )
+from vllm_omni.engine.stage_init_utils import set_death_signal
+from vllm_omni.engine.stage_runtime import OmniClientConfig
 from vllm_omni.entrypoints.async_omni import ABORT_TIMEOUT_S, AsyncOmni
 from vllm_omni.entrypoints.duplex.serving import OmniDuplexSessionHandler
 from vllm_omni.entrypoints.duplex.warmup import _warmup_duplex_realtime
@@ -121,6 +128,7 @@ from vllm_omni.entrypoints.openai.images.helpers import (
     _check_max_generated_image_size,
     _choose_output_format,
     _extract_images_from_result,
+    _generated_size_str,
     _get_max_edit_input_images,
     _load_input_images,
     _update_if_not_none,
@@ -161,6 +169,7 @@ from vllm_omni.entrypoints.openai.serving_rl_rollout import ServingRLRollout
 from vllm_omni.entrypoints.openai.serving_speech import OmniOpenAIServingSpeech
 from vllm_omni.entrypoints.openai.serving_speech_stream import OmniStreamingSpeechHandler
 from vllm_omni.entrypoints.openai.serving_video import (
+    LatentEditInput,
     OmniOpenAIServingVideo,
     ReferenceAudio,
     ReferenceImage,
@@ -231,8 +240,55 @@ async def omni_run_server(args, **uvicorn_kwargs) -> None:
     await omni_run_server_worker(listen_address, sock, args, **uvicorn_kwargs)
 
 
-async def omni_run_server_worker(listen_address, sock, args, client_config=None, **uvicorn_kwargs) -> None:
+def run_omni_api_server_worker_proc(
+    listen_address: str,
+    sock: socket.socket,
+    args: TrackingNamespace,
+    client_config: dict[str, Any] | None = None,
+    **uvicorn_kwargs: object,
+) -> None:
+    """Entrypoint used by vLLM's API server process manager."""
+    set_death_signal(signal.SIGTERM)
+    manager_config = client_config or {}
+    client_index = int(manager_config.get("client_index", 0))
+    all_client_configs = getattr(args, "_omni_stage_client_configs", None)
+    if not all_client_configs or not 0 <= client_index < len(all_client_configs):
+        raise RuntimeError(f"Missing Omni stage client configuration for API server {client_index}")
+
+    omni_client_config: OmniClientConfig = copy.deepcopy(all_client_configs[client_index])
+    omni_client_config["client_count"] = int(manager_config.get("client_count", 1))
+    omni_client_config["client_index"] = client_index
+
+    stage_addresses = omni_client_config["stage_addresses"]
+    first_stage_id = min(stage_addresses)
+    first_replica_id = min(stage_addresses[first_stage_id])
+    first_addresses = stage_addresses[first_stage_id][first_replica_id]
+    for key in ("input_address", "output_address", "actual_address_pipe", "tensor_queue"):
+        if key in manager_config:
+            first_addresses[key] = manager_config[key]
+
+    set_process_title("APIServer", str(client_index))
+    decorate_logs("APIServer", skip_if_decorated=True)
+    uvloop.run(
+        omni_run_server_worker(
+            listen_address,
+            sock,
+            args,
+            client_config=omni_client_config,
+            **uvicorn_kwargs,
+        )
+    )
+
+
+async def omni_run_server_worker(
+    listen_address: str,
+    sock: socket.socket,
+    args: TrackingNamespace,
+    client_config: OmniClientConfig | None = None,
+    **uvicorn_kwargs: object,
+) -> None:
     """Run a single API server worker."""
+    api_server_count = _resolve_api_server_count(args, client_config)
 
     if args.tool_parser_plugin and len(args.tool_parser_plugin) > 3:
         ToolParserManager.import_tool_parser(args.tool_parser_plugin)
@@ -272,6 +328,7 @@ async def omni_run_server_worker(listen_address, sock, args, client_config=None,
 
         # OMNI: Pass supported_tasks to build_app (required by upstream vLLM)
         app = build_openai_app(args, supported_tasks)
+        app.state.api_server_count = api_server_count
 
         # OMNI: Remove upstream routes that we override with omni-specific handlers
         remove_route_from_app(app, "/v1/chat/completions", {"POST"})
@@ -347,6 +404,7 @@ async def omni_run_server_worker(listen_address, sock, args, client_config=None,
                 if scope["type"] == "http":
                     scope.setdefault("state", {})
                     scope["state"]["request_timestamp"] = time.time()
+
                 await self._inner(scope, receive, send)
 
         # Startup duplex warmup (duplex_session.warmup_frames in the deploy
@@ -405,7 +463,7 @@ async def build_async_omni(
     args: TrackingNamespace,
     *,
     disable_frontend_multiprocessing: bool | None = None,
-    client_config: dict[str, Any] | None = None,
+    client_config: OmniClientConfig | None = None,
 ) -> AsyncIterator[EngineClient]:
     """Build an AsyncOmni instance from command-line arguments.
 
@@ -436,25 +494,41 @@ async def build_async_omni(
     async with build_async_omni_from_stage_config(
         args,
         disable_frontend_multiprocessing=disable_frontend_multiprocessing,
+        client_config=client_config,
     ) as async_omni:
         yield async_omni
 
 
-def _is_duplex_model(model: str, kwargs: dict[str, Any]) -> bool:
-    """Whether ``model``'s pipeline declares a ``duplex_plugin`` (served by ``DuplexOmni``).
-
-    Resolution errors propagate: a duplex model whose pipeline or deploy
-    config cannot be resolved must fail startup rather than silently start a
-    turn-based server.
-    """
+def _should_serve_duplex(model: str, kwargs: dict[str, Any]) -> bool:
+    """Select the serving engine without changing the model's duplex capability."""
     from vllm_omni.config.config_factory import StageConfigFactory
+    from vllm_omni.config.stage_config import _DEPLOY_DIR, resolve_deploy_yaml
 
     pipeline_config = StageConfigFactory.get_pipeline_config(
         model=model,
         trust_remote_code=bool(kwargs.get("trust_remote_code")),
         deploy_config_path=kwargs.get("deploy_config"),
     )
-    return bool(pipeline_config is not None and getattr(pipeline_config, "duplex_plugin", None))
+    if pipeline_config is None or not getattr(pipeline_config, "duplex_plugin", None):
+        return False
+
+    deploy_path = kwargs.get("deploy_config")
+    if deploy_path is None:
+        if pipeline_config.default_deploy_config_name is None:
+            raise ValueError("A duplex-capable model requires a deploy config with session_mode: turn or duplex")
+        deploy_path = _DEPLOY_DIR / pipeline_config.default_deploy_config_name
+    else:
+        deploy_path = Path(deploy_path)
+        if not deploy_path.exists() and deploy_path.parent == Path("."):
+            deploy_path = _DEPLOY_DIR / deploy_path
+
+    # Resolve base_config too, so the API and stage workers use the same mode.
+    session_mode = resolve_deploy_yaml(deploy_path).get(
+        "session_mode", getattr(pipeline_config, "default_session_mode", None)
+    )
+    if session_mode not in ("turn", "duplex"):
+        raise ValueError("A duplex-capable model requires session_mode: turn or duplex in its deploy config")
+    return session_mode == "duplex"
 
 
 @asynccontextmanager
@@ -462,6 +536,7 @@ async def build_async_omni_from_stage_config(
     args: TrackingNamespace,
     *,
     disable_frontend_multiprocessing: bool = False,
+    client_config: OmniClientConfig | None = None,
 ) -> AsyncIterator[EngineClient]:
     """Create AsyncOmni from stage configuration.
 
@@ -518,9 +593,9 @@ async def build_async_omni_from_stage_config(
         kwargs.pop("robot_openpi_idle_timeout", None)
         model = kwargs.pop("model", None) or args.model
         kwargs.setdefault("log_stats", not args.disable_log_stats)
-        if _is_duplex_model(model, kwargs):
-            # A duplex model is always served in duplex mode: sessions over
-            # /v1/realtime?duplex=1, no turn-based HTTP routes.
+        if client_config is not None:
+            kwargs["client_config"] = client_config
+        if _should_serve_duplex(model, kwargs):
             async_omni = DuplexOmni(model=model, **kwargs)
         else:
             async_omni = AsyncOmni(model=model, **kwargs)
@@ -712,9 +787,7 @@ async def omni_init_app_state(
     state.stage_configs = engine_client.stage_configs if hasattr(engine_client, "stage_configs") else None
     model_name = served_model_names[0] if served_model_names else args.model
 
-    # Duplex mode: a duplex model is served through DuplexOmni only. Sessions
-    # run over /v1/realtime?duplex=1; every turn-based HTTP route reports
-    # "not available".
+    # Initialize the API surface for the selected engine, not just the model.
     if isinstance(engine_client, DuplexOmni):
         await _init_duplex_app_state(engine_client, state, args, base_model_paths, vllm_config, request_logger)
         return
@@ -1420,6 +1493,42 @@ async def list_voices(raw_request: Request):
     return JSONResponse(content={"voices": speakers, "uploaded_voices": uploaded_speakers})
 
 
+def _resolve_api_server_count(args: Namespace, client_config: OmniClientConfig | None) -> int:
+    """Resolve frontend topology once, from the launcher's client configuration."""
+    requested = getattr(args, "api_server_count", None)
+    actual = 1 if client_config is None else client_config.get("client_count")
+    if type(actual) is not int or actual < 1:
+        raise ValueError("API client configuration requires a positive integer client_count")
+    if requested is not None and (type(requested) is not int or requested < 1 or requested != actual):
+        raise ValueError("API server count does not match the frontend launch configuration")
+    return actual
+
+
+def _reject_process_local_state_with_multiple_api_workers(raw_request: Request, operation: str) -> None:
+    """Reject access to frontend state that is not shared across API workers."""
+    api_server_count = getattr(raw_request.app.state, "api_server_count", None)
+    if type(api_server_count) is not int or api_server_count < 1:
+        raise HTTPException(
+            status_code=HTTPStatus.SERVICE_UNAVAILABLE.value,
+            detail="API worker topology is not initialized.",
+        )
+    if api_server_count > 1:
+        raise HTTPException(
+            status_code=HTTPStatus.CONFLICT.value,
+            detail=(
+                f"{operation} is not supported with --api-server-count > 1 because "
+                "the operation uses process-local frontend state"
+            ),
+        )
+
+
+async def _require_single_api_video_store(raw_request: Request) -> None:
+    # VIDEO_STORE and VIDEO_TASKS are process-local, including reads and
+    # cancellation. Keep this independent of the temporary diffusion launch
+    # restriction: enabling multi-API diffusion alone cannot make jobs shared.
+    _reject_process_local_state_with_multiple_api_workers(raw_request, "Asynchronous video jobs")
+
+
 @router.post(
     "/v1/audio/voices",
     responses={
@@ -1465,6 +1574,7 @@ async def upload_voice(
     Returns:
         JSON response with voice information
     """
+    _reject_process_local_state_with_multiple_api_workers(raw_request, "Runtime voice upload")
     handler = Omnispeech(raw_request)
     if handler is None:
         return _create_speech_error_json_response(
@@ -1530,6 +1640,7 @@ async def delete_voice(name: str, raw_request: Request):
     Returns:
         JSON response indicating success or failure
     """
+    _reject_process_local_state_with_multiple_api_workers(raw_request, "Runtime voice deletion")
     handler = Omnispeech(raw_request)
     if handler is None:
         return _create_speech_error_json_response(
@@ -1623,16 +1734,24 @@ async def streaming_video_output(websocket: WebSocket):
 @router.websocket("/v1/realtime")
 async def realtime_websocket(websocket: WebSocket):
     """WebSocket endpoint for OpenAI-style realtime interactions."""
-    await _wait_for_duplex_warmup(websocket)
     duplex_handler = getattr(websocket.app.state, "openai_serving_duplex", None)
     duplex_query = websocket.query_params.get("duplex")
     use_duplex_realtime = duplex_handler is not None and (
         duplex_query is None or (isinstance(duplex_query, str) and duplex_query.lower() in {"1", "true", "on"})
     )
     if use_duplex_realtime and duplex_handler is not None:
+        if await _reject_multi_api_duplex(websocket):
+            return
+        await _wait_for_duplex_warmup(websocket)
         await duplex_handler.handle_realtime_session(websocket)
         return
 
+    if isinstance(duplex_query, str) and duplex_query.lower() in {"1", "true", "on"}:
+        await websocket.accept()
+        await websocket.send_json({"type": "error", "code": "unsupported", "error": "VAD realtime is not enabled"})
+        await websocket.close(code=1008)
+        return
+
     serving = getattr(websocket.app.state, "openai_serving_realtime", None)
     if serving is None:
         await websocket.accept()
@@ -1659,6 +1778,8 @@ async def _wait_for_duplex_warmup(websocket: WebSocket) -> None:
 @router.websocket("/v1/duplex")
 async def duplex_websocket(websocket: WebSocket):
     """Alias of ``/v1/realtime?duplex=1``: the same Realtime duplex session protocol."""
+    if await _reject_multi_api_duplex(websocket):
+        return
     await _wait_for_duplex_warmup(websocket)
     handler = getattr(websocket.app.state, "openai_serving_duplex", None)
     if handler is None:
@@ -1699,6 +1820,24 @@ async def realtime_robot_openpi(websocket: WebSocket):
     await connection.handle_connection()
 
 
+async def _reject_multi_api_duplex(websocket: WebSocket) -> bool:
+    # Session credentials and replay state are local to each frontend; a shared
+    # listening socket cannot route reconnects back to the session owner.
+    count = getattr(websocket.app.state, "api_server_count", None)
+    if count is None or (type(count) is int and count == 1):
+        return False
+    await websocket.accept()
+    await websocket.send_json(
+        {
+            "type": "error",
+            "error": "Duplex sessions require a single API worker with initialized topology.",
+            "code": "multi_api_duplex_unsupported",
+        }
+    )
+    await websocket.close(code=1008)
+    return True
+
+
 # RL Rollout serving (RFC #3747, P0)
 
 
@@ -1864,8 +2003,9 @@ def _build_image_generation_response(
             peak_memory_mb=peak_memory_mb,
         ),
     }
-    if request.size is not None:
-        response_kwargs["size"] = request.size
+    size = _generated_size_str(images, request.size)
+    if size is not None:
+        response_kwargs["size"] = size
     response = ImageGenerationResponse(**response_kwargs)
     if request.response_format == ResponseFormat.FILE:
         return response.stream_response()
@@ -1913,6 +2053,8 @@ async def generate_images(
         )
 
     try:
+        width: int | None = None
+        height: int | None = None
         # Unify request construction for any multi-stage pipeline to avoid
         # divergence between /v1/images and /v1/chat/completions.
         if len(stage_configs) > 1:
@@ -1930,7 +2072,6 @@ async def generate_images(
                 "num_outputs_per_prompt": request.n,
             }
             if request.size is not None:
-                parse_size(request.size)
                 width, height = parse_size(request.size)
                 app_state_args = getattr(raw_request.app.state, "args", None)
                 _check_max_generated_image_size(app_state_args, width, height)
@@ -1984,7 +2125,7 @@ async def generate_images(
             )
 
         # Build params - pass through user values directly
-        prompt: OmniTextPrompt = {"prompt": request.prompt, "modalities": ["image"]}
+        prompt = OmniTextPrompt(prompt=request.prompt, modalities=["image"])
         if request.negative_prompt is not None:
             prompt["negative_prompt"] = request.negative_prompt
         gen_params = OmniDiffusionSamplingParams(num_outputs_per_prompt=request.n)
@@ -2000,12 +2141,11 @@ async def generate_images(
         if extra_args:
             gen_params.extra_args = extra_args
         # Parse per-request LoRA (compatible with chat's extra_body.lora shape).
-        lora_request, lora_scale = _parse_lora_request(request.lora)
+        lora_request, lora_scale = _parse_lora_request(request.lora) if request.lora is not None else (None, None)
         _update_if_not_none(gen_params, "lora_request", lora_request)
         _update_if_not_none(gen_params, "lora_scale", lora_scale)
 
         # Parse and add size if provided
-        width, height = None, None
         if request.size:
             width, height = parse_size(request.size)
             size_str = f"{width}x{height}"
@@ -2171,9 +2311,9 @@ async def edit_images(
     try:
         # 2. Build prompt & images params
         cot_output = None
-        prompt: OmniTextPrompt = {"prompt": prompt, "modalities": ["image"]}
+        omni_prompt = OmniTextPrompt(prompt=prompt, modalities=["image"])
         if negative_prompt is not None:
-            prompt["negative_prompt"] = negative_prompt
+            omni_prompt["negative_prompt"] = negative_prompt
         input_images_list = []
         images = image or image_array
         urls = url or url_array
@@ -2204,17 +2344,17 @@ async def edit_images(
         # Hunyuan-aware behavior. RGBA/P uploads otherwise diverge from offline.
         normalize_edit_images_rgb = bot_task is not None or sys_type is not None
         pil_images = await _load_input_images(input_images_list, normalize_rgb=normalize_edit_images_rgb)
-        prompt["multi_modal_data"] = {}
-        prompt["multi_modal_data"]["image"] = pil_images
+        omni_prompt["multi_modal_data"] = {}
+        omni_prompt["multi_modal_data"]["image"] = pil_images
 
         if mask_image is not None:
             # Mask role is different (alpha channel matters); never normalize.
             loaded = await _load_input_images([mask_image], normalize_rgb=False)
-            prompt["multi_modal_data"]["mask_image"] = loaded[0]
+            omni_prompt["multi_modal_data"]["mask_image"] = loaded[0]
 
         if reference_image is not None:
             loaded = await _load_input_images([reference_image], normalize_rgb=normalize_edit_images_rgb)
-            prompt["multi_modal_data"]["reference_image"] = loaded[0]
+            omni_prompt["multi_modal_data"]["reference_image"] = loaded[0]
 
         # 3 Build sample params
         gen_params = OmniDiffusionSamplingParams()
@@ -2280,16 +2420,18 @@ async def edit_images(
         # Keep AR stage target grid in sync with requested output size.
         # GLM-Image consumes target_h/target_w via mm_processor_kwargs.
         if width is not None and height is not None:
-            prompt["mm_processor_kwargs"] = {
+            omni_prompt["mm_processor_kwargs"] = {
                 "target_h": height,
                 "target_w": width,
             }
             # Backward-compatible fallback for processors reading top-level fields.
-            prompt["height"] = height
-            prompt["width"] = width
+            omni_prompt["height"] = height
+            omni_prompt["width"] = width
 
         _update_if_not_none(gen_params, "width", width)
         _update_if_not_none(gen_params, "height", height)
+        gen_params.width_not_provided = size_was_auto
+        gen_params.height_not_provided = size_was_auto
 
         # 3.4 Add optional parameters ONLY if provided
         _update_if_not_none(gen_params, "num_inference_steps", num_inference_steps)
@@ -2384,7 +2526,7 @@ async def edit_images(
             if return_stage_metrics is not None:
                 extra_body["return_stage_metrics"] = return_stage_metrics
 
-            prompt_text = prompt.get("prompt", "")
+            prompt_text = omni_prompt.get("prompt", "")
             generation_result = await chat_handler.generate_diffusion_images(
                 prompt=prompt_text,
                 extra_body=extra_body,
@@ -2415,7 +2557,7 @@ async def edit_images(
                 engine_client=engine_client,
                 gen_params=gen_params,
                 stage_configs=stage_configs,
-                prompt=prompt,
+                prompt=omni_prompt,
                 request_id=request_id,
             )
             images = _extract_images_from_result(result)
@@ -2423,6 +2565,8 @@ async def edit_images(
             peak_memory_mb = getattr(result, "peak_memory_mb", None)
             response_metrics = getattr(result, "metrics", None) if return_stage_metrics else None
 
+        if images is None:
+            images = []
         logger.debug(f"Successfully generated {len(images)} image(s)")
 
         # Encode images to base64
@@ -2440,7 +2584,7 @@ async def edit_images(
             created=int(time.time()),
             data=image_data,
             output_format=output_format,
-            size=size_str,
+            size=_generated_size_str(images, size_str),
             cot_output=cot_output,
             metrics=_build_image_response_metrics(
                 response_metrics=response_metrics,
@@ -2466,6 +2610,7 @@ async def edit_images(
 
 @router.post(
     "/v1/videos",
+    dependencies=[Depends(_require_single_api_video_store)],
     responses={
         HTTPStatus.OK.value: {"model": VideoResponse},
         HTTPStatus.BAD_REQUEST.value: {"model": ErrorResponse},
@@ -2483,6 +2628,7 @@ async def create_video(
         ReferenceVideo | None,
         ReferenceAudio | None,
         str | None,
+        LatentEditInput | None,
     ] = Depends(_parse_video_form),
 ) -> VideoResponse:
     """Create an asynchronous video generation job.
@@ -2498,6 +2644,7 @@ async def create_video(
         reference_video,
         reference_audio,
         control_path,
+        latent_edit_input,
     ) = ctx
     ref = video_response_from_request(effective_model_name, request)
     await VIDEO_STORE.upsert(ref.id, ref)
@@ -2511,6 +2658,7 @@ async def create_video(
             reference_audio,
             control_path,
             app_state=raw_request.app.state,
+            latent_edit_input=latent_edit_input,
         )
     )
     await VIDEO_TASKS.upsert(ref.id, task)
@@ -2536,6 +2684,7 @@ async def create_video_sync(
         ReferenceVideo | None,
         ReferenceAudio | None,
         str | None,
+        LatentEditInput | None,
     ] = Depends(_parse_video_form),
 ) -> Response:
     """Synchronous video generation endpoint.
@@ -2555,6 +2704,7 @@ async def create_video_sync(
         reference_video,
         reference_audio,
         control_path,
+        latent_edit_input,
     ) = ctx
     request_id = f"video_sync-{random_uuid()}"
     raw_request.state.request_metadata = RequestResponseMetadata(request_id=request_id)
@@ -2568,6 +2718,7 @@ async def create_video_sync(
                     reference_image=reference_image,
                     reference_video=reference_video,
                     reference_audio=reference_audio,
+                    latent_edit_input=latent_edit_input,
                 ),
                 timeout=VIDEO_SYNC_TIMEOUT_S,
             ),
@@ -2591,7 +2742,7 @@ async def create_video_sync(
             detail=f"Video generation failed: {str(exc)}",
         ) from exc
     finally:
-        _cleanup_video_references(reference_video, reference_audio, control_path)
+        _cleanup_video_references(reference_video, reference_audio, control_path, latent_edit_input)
     inference_time_s = time.perf_counter() - started_at
 
     return Response(
@@ -2607,7 +2758,7 @@ async def create_video_sync(
     )
 
 
-@router.get("/v1/videos", response_model=VideoListResponse)
+@router.get("/v1/videos", response_model=VideoListResponse, dependencies=[Depends(_require_single_api_video_store)])
 async def list_videos(
     after: str | None = None,
     limit: int | None = Query(None, ge=0, le=100),
@@ -2644,7 +2795,7 @@ async def list_videos(
     return VideoListResponse(data=jobs, has_more=has_more, first_id=first_id, last_id=last_id)
 
 
-@router.get("/v1/videos/{video_id}", response_model=None)
+@router.get("/v1/videos/{video_id}", response_model=None, dependencies=[Depends(_require_single_api_video_store)])
 async def retrieve_video(video_id: str) -> VideoResponse | JSONResponse:
     """Retrieve metadata for a previously created video job.
 
@@ -2672,7 +2823,7 @@ async def retrieve_video(video_id: str) -> VideoResponse | JSONResponse:
     return job
 
 
-@router.delete("/v1/videos/{video_id}")
+@router.delete("/v1/videos/{video_id}", dependencies=[Depends(_require_single_api_video_store)])
 async def delete_video(video_id: str, raw_request: Request) -> VideoDeleteResponse:
     """Delete a stored video job and any generated output.
 
@@ -2742,7 +2893,7 @@ async def delete_video(video_id: str, raw_request: Request) -> VideoDeleteRespon
     return VideoDeleteResponse(id=job.id, deleted=True)
 
 
-@router.get("/v1/videos/{video_id}/content")
+@router.get("/v1/videos/{video_id}/content", dependencies=[Depends(_require_single_api_video_store)])
 async def download_video(video_id: str) -> Response:
     """Download the generated file for a completed video job.
 
@@ -2835,6 +2986,7 @@ async def stop_profile(raw_request: Request, request: ProfileRequest | None = No
 
 @router.post("/v1/omni/sleep")
 async def omni_sleep(request: OmniSleepRequest, raw_request: Request):
+    _reject_process_local_state_with_multiple_api_workers(raw_request, "Sleep")
     engine_client = raw_request.app.state.engine_client
     sleeping_set = raw_request.app.state.sleeping_stages
     if not hasattr(engine_client, "sleep"):
@@ -2842,11 +2994,15 @@ async def omni_sleep(request: OmniSleepRequest, raw_request: Request):
     acks = await engine_client.sleep(stage_ids=request.stage_ids, level=request.level)
     for sid in request.stage_ids:
         sleeping_set.add(sid)
-    return {"status": "SUCCESS", "acks": [dataclasses.asdict(a) if dataclasses.is_dataclass(a) else a for a in acks]}
+    return {
+        "status": "SUCCESS",
+        "acks": [dataclasses.asdict(a) if dataclasses.is_dataclass(a) and not isinstance(a, type) else a for a in acks],
+    }
 
 
 @router.post("/v1/omni/wakeup")
 async def omni_wakeup(request: OmniWakeupRequest, raw_request: Request):
+    _reject_process_local_state_with_multiple_api_workers(raw_request, "Wakeup")
     engine_client = raw_request.app.state.engine_client
     sleeping_set = raw_request.app.state.sleeping_stages
     if not any(sid in sleeping_set for sid in request.stage_ids):
@@ -2857,7 +3013,10 @@ async def omni_wakeup(request: OmniWakeupRequest, raw_request: Request):
     for sid in request.stage_ids:
         if sid in sleeping_set:
             sleeping_set.remove(sid)
-    return {"status": "SUCCESS", "acks": [dataclasses.asdict(a) if dataclasses.is_dataclass(a) else a for a in acks]}
+    return {
+        "status": "SUCCESS",
+        "acks": [dataclasses.asdict(a) if dataclasses.is_dataclass(a) and not isinstance(a, type) else a for a in acks],
+    }
 
 
 if __name__ == "__main__":
diff --git a/vllm_omni/entrypoints/openai/images/helpers.py b/vllm_omni/entrypoints/openai/images/helpers.py
index dd790ca3d..4001409fe 100644
--- a/vllm_omni/entrypoints/openai/images/helpers.py
+++ b/vllm_omni/entrypoints/openai/images/helpers.py
@@ -169,6 +169,14 @@ def _extract_images_from_result(result: Any) -> list[Any]:
     return [_normalize_image(img) for img in flattened]
 
 
+def _generated_size_str(images: list[Any], fallback: str | None) -> str | None:
+    """``"WxH"`` of the first generated image, or ``fallback`` when it is unknown."""
+    size = getattr(images[0], "size", None) if images else None
+    if isinstance(size, tuple) and len(size) == 2 and all(isinstance(value, Integral) for value in size):
+        return f"{size[0]}x{size[1]}"
+    return fallback
+
+
 async def _load_input_images(
     inputs: list[str],
     *,
diff --git a/vllm_omni/entrypoints/openai/serving_chat.py b/vllm_omni/entrypoints/openai/serving_chat.py
index 484d5d170..6926253c5 100644
--- a/vllm_omni/entrypoints/openai/serving_chat.py
+++ b/vllm_omni/entrypoints/openai/serving_chat.py
@@ -248,10 +248,27 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             return obj.get(key, default)
         return getattr(obj, key, default)
 
+    @classmethod
+    def _stage_model_metadata(cls, stage: Any) -> tuple[str | None, str | None]:
+        """Return ``(model_arch, model_stage)`` for typed or legacy stages."""
+        model_config = cls._stage_get(stage, "model_config")
+        model_arch = cls._stage_get(model_config, "model_arch")
+        model_stage = cls._stage_get(stage, "model_stage")
+
+        topology = cls._stage_get(stage, "stage_pipeline_config")
+        if model_stage is None:
+            model_stage = cls._stage_get(topology, "model_stage")
+
+        engine_args = cls._stage_get(stage, "engine_args")
+        if model_arch is None:
+            model_arch = cls._stage_get(engine_args, "model_arch")
+        if model_stage is None:
+            model_stage = cls._stage_get(engine_args, "model_stage")
+        return model_arch, model_stage
+
     def _has_minicpmo45_stage(self) -> bool:
         for stage in getattr(self.engine_client, "stage_configs", []) or []:
-            engine_args = self._stage_get(stage, "engine_args")
-            model_arch = self._stage_get(engine_args, "model_arch")
+            model_arch, _ = self._stage_model_metadata(stage)
             if model_arch == "MiniCPMO45OmniForConditionalGeneration":
                 return True
         return False
@@ -324,11 +341,10 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             if not hasattr(sp, "output_kind"):
                 continue
 
-            engine_args = self._stage_get(stage, "engine_args")
-            if self._stage_get(engine_args, "model_arch") != "MiniCPMO45OmniForConditionalGeneration":
+            model_arch, model_stage = self._stage_model_metadata(stage)
+            if model_arch != "MiniCPMO45OmniForConditionalGeneration":
                 continue
 
-            model_stage = self._stage_get(engine_args, "model_stage")
             if model_stage == "llm":
                 sp.output_kind = RequestOutputKind.FINAL_ONLY
             elif model_stage == "tts":
@@ -802,6 +818,7 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                     if _image_gen_height is not None and _image_gen_width is not None
                     else None
                 )
+                self._apply_text_chat_ar_task_mode(sampling_params_list, request)
                 # Apply user-specified overrides to diffusion stage(s) for image generation
                 for idx, sp in enumerate(sampling_params_list):
                     if idx == comprehension_idx:
@@ -1377,6 +1394,34 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             and delta_message.tool_calls
         )
 
+    @staticmethod
+    def _apply_text_chat_ar_task_mode(
+        sampling_params_list: list[Any],
+        request: ChatCompletionRequest,
+    ) -> None:
+        """Mark AR stages of a text-only chat request as per-request comprehension.
+
+        A generation deployment (e.g. HunyuanImage3 AR+DiT with
+        ``engine_output_type="latent"``) also serves plain chat completions
+        whose answer is text (I2T/T2T). Without a per-request marker the AR
+        model sampler applies its image-generation stage transitions to those
+        requests and leaks DiT scaffold tokens (``<recaption>``/``<answer>``/
+        ``<boi>``/``<img_size_*>``/``<cfg>``) into the text answer (#6088).
+
+        Sets ``extra_args["ar_task_mode"] = "comprehension"`` on every plain
+        ``SamplingParams`` stage when the request output is text-only. Does
+        nothing for image/audio/video-output requests, never overrides an
+        explicit caller-provided ``ar_task_mode``, and models that don't opt
+        into reading extra_args are unaffected.
+        """
+        if set(getattr(request, "modalities", None) or []) - {"text"}:
+            return
+        for sp in sampling_params_list:
+            if isinstance(sp, SamplingParams) and not isinstance(sp, OmniDiffusionSamplingParams):
+                extra_args = dict(getattr(sp, "extra_args", None) or {})
+                extra_args.setdefault("ar_task_mode", "comprehension")
+                sp.extra_args = extra_args
+
     def _build_sampling_params_list_from_request(
         self,
         request: ChatCompletionRequest,
@@ -3126,13 +3171,6 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             engine_prompt["mm_processor_kwargs"] = mm_processor_kwargs
         if engine_prompt_data is not None:
             engine_prompt["multi_modal_data"] = engine_prompt_data
-            # Provide multi_modal_uuids so that newer vLLM versions can
-            # validate multi_modal_data / multi_modal_uuids consistency.
-            # Generate one uuid per image when the value is a list (multi-image inputs).
-            engine_prompt["multi_modal_uuids"] = {
-                k: [f"img-{k}-{i}" for i in range(len(v))] if isinstance(v, list) else [f"img-{k}-0"]
-                for k, v in engine_prompt_data.items()
-            }
 
         comprehension_idx = None
         for idx, stage in enumerate(stage_configs):
diff --git a/vllm_omni/entrypoints/openai/serving_speech.py b/vllm_omni/entrypoints/openai/serving_speech.py
index f54ca3e28..d3c23ca39 100644
--- a/vllm_omni/entrypoints/openai/serving_speech.py
+++ b/vllm_omni/entrypoints/openai/serving_speech.py
@@ -32,9 +32,11 @@ from vllm.entrypoints.launchers.launcher import terminate_if_errored
 from vllm.entrypoints.serve.engine.protocol import ErrorResponse
 from vllm.logger import init_logger
 from vllm.multimodal.media import MediaConnector
+from vllm.sampling_params import RequestOutputKind, SamplingParams
 from vllm.utils import random_uuid
 from vllm.v1.engine.exceptions import EngineDeadError, EngineGenerateError
 
+from vllm_omni.config.stage_config import StagePipelineConfig
 from vllm_omni.entrypoints.openai.audio_utils_mixin import AudioMixin, StreamingAudioResampler
 from vllm_omni.entrypoints.openai.protocol.audio import (
     AudioResponse,
@@ -75,6 +77,24 @@ _SPEECH_USAGE_TOTAL_TOKENS_HEADER = "X-VLLM-OMNI-TOTAL-TOKENS"
 _SPEECH_USAGE_INPUT_TEXT_TOKENS_HEADER = "X-VLLM-OMNI-INPUT-TEXT-TOKENS"
 _SPEECH_USAGE_INPUT_AUDIO_TOKENS_HEADER = "X-VLLM-OMNI-INPUT-AUDIO-TOKENS"
 
+
+def _stage_speech_metadata(stage: Any) -> tuple[str | None, str | None, str | None]:
+    """Return speech routing metadata from typed or legacy stage configs."""
+    topology = getattr(stage, "stage_pipeline_config", None)
+    if isinstance(topology, StagePipelineConfig):
+        return (
+            getattr(topology, "model_stage", None),
+            getattr(getattr(stage, "model_config", None), "model_arch", None),
+            getattr(stage, "worker_type", None),
+        )
+    engine_args = getattr(stage, "engine_args", None)
+    return (
+        getattr(engine_args, "model_stage", None),
+        getattr(engine_args, "model_arch", None),
+        getattr(engine_args, "worker_type", None),
+    )
+
+
 # TTS Configuration
 #
 # The stage-key -> model-type mapping is NOT declared here: it is derived from
@@ -90,8 +110,8 @@ _REF_AUDIO_MIN_DURATION = 1.0  # seconds
 _REF_AUDIO_MAX_DURATION = 30.0  # seconds
 _REF_AUDIO_METADATA_FETCH_ATTEMPTS = 3
 _REMOTE_REF_AUDIO_SCHEMES = frozenset({"http", "https", "data"})
-_REF_AUDIO_RESOLVE_CACHE_MAX_ENTRIES = 256
-_REF_AUDIO_RESOLVE_CACHE_MAX_BYTES = 256 * 1024 * 1024
+_REF_AUDIO_RESOLVE_CACHE_MAX_ENTRIES = 1024
+_REF_AUDIO_RESOLVE_CACHE_MAX_BYTES = 512 * 1024 * 1024
 _TTS_MAX_INSTRUCTIONS_LENGTH = 500
 _DEFAULT_VOICE_NAME = "default"
 
@@ -228,7 +248,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             self._max_uploaded_speakers = 1000
         self.uploaded_speakers: dict[str, dict[str, Any]] = {}
         self._ref_audio_data_url_cache: dict[str, str] = {}
-        self._ref_audio_resolve_cache: OrderedDict[str, tuple[list[float], int, int, str]] = OrderedDict()
+        self._ref_audio_resolve_cache: OrderedDict[str, tuple[np.ndarray, int, int, str]] = OrderedDict()
         self._ref_audio_resolve_cache_bytes = 0
         self._ref_audio_resolve_cache_max_entries = _REF_AUDIO_RESOLVE_CACHE_MAX_ENTRIES
         self._ref_audio_resolve_cache_max_bytes = _REF_AUDIO_RESOLVE_CACHE_MAX_BYTES
@@ -471,12 +491,13 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         """Find and return the TTS stage config, or None if not found."""
         tts_stage_keys = all_tts_stage_keys()
         entry_stage_archs = tts_entry_stage_archs()
-        all_stages = frozenset(stage.engine_args.model_stage for stage in self.engine_client.stage_configs)
+        all_stages = frozenset(
+            model_stage
+            for stage in self.engine_client.stage_configs
+            if (model_stage := _stage_speech_metadata(stage)[0]) is not None
+        )
         for stage in self.engine_client.stage_configs:
-            engine_args = stage.engine_args
-            model_stage = engine_args.model_stage
-            model_arch = getattr(engine_args, "model_arch", None)
-            worker_type = getattr(engine_args, "worker_type", None)
+            model_stage, model_arch, worker_type = _stage_speech_metadata(stage)
             if model_stage in tts_stage_keys:
                 # Owning the stage key is not always enough: a model may be
                 # speech-capable only in some deployment topologies. Ask the
@@ -500,10 +521,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         """
         if self._tts_stage is None:
             return None
-        return detect_tts_model_type(
-            getattr(self._tts_stage.engine_args, "model_stage", None),
-            getattr(self._tts_stage.engine_args, "model_arch", None),
-        )
+        return detect_tts_model_type(*_stage_speech_metadata(self._tts_stage)[:2])
 
     def _compute_max_instructions_length(self) -> int:
         """Compute max instructions length with precedence: CLI > stage config > default.
@@ -517,7 +535,12 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
         # 2. Try to get from TTS stage config
         if self._tts_stage is not None:
-            tts_args = getattr(self._tts_stage, "tts_args", {})
+            topology = getattr(self._tts_stage, "stage_pipeline_config", None)
+            tts_args = (
+                getattr(topology, "extras", {}).get("tts_args", {})
+                if isinstance(topology, StagePipelineConfig)
+                else getattr(self._tts_stage, "tts_args", {})
+            )
             if "max_instructions_length" in tts_args:
                 return tts_args["max_instructions_length"]
 
@@ -1199,7 +1222,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             allowed_local_media_path,
         )
 
-    def _finalize_fetched_ref_audio(self, wav_np: np.ndarray, sr: int) -> tuple[list[float], int, str, float]:
+    def _finalize_fetched_ref_audio(self, wav_np: np.ndarray, sr: int) -> tuple[np.ndarray, int, str, float]:
         wav_np = np.asarray(wav_np, dtype=np.float32)
         if wav_np.ndim > 1:
             wav_np = np.mean(wav_np, axis=-1)
@@ -1215,12 +1238,26 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 f"Reference audio too long ({duration:.1f}s). "
                 f"Maximum {_REF_AUDIO_MAX_DURATION:.0f}s supported — use a shorter clip."
             )
-        artifact_key = self._make_ref_audio_artifact_cache_key(wav_np, sr)
-        return wav_np.tolist(), sr, artifact_key, duration
+        # Own the buffer: a view could retain a much larger decoded allocation.
+        waveform = np.array(wav_np, dtype=np.float32, order="C", copy=True)
+        artifact_key = self._make_ref_audio_artifact_cache_key(waveform, sr)
+        return waveform, sr, artifact_key, duration
 
     async def _resolve_ref_audio(self, ref_audio_str: str) -> tuple[list[float], int, str]:
+        """Keep list-based consumers and their engine transport compatible.
+
+        Only the numeric array is cached; this temporary list belongs to the
+        caller. Server-side reference encoders should use the array resolver.
+        """
+        waveform, sr, cache_key = await self._resolve_ref_audio_array(ref_audio_str)
+        return waveform.tolist(), sr, cache_key
+
+    async def _resolve_ref_audio_array(self, ref_audio_str: str) -> tuple[np.ndarray, int, str]:
         """Resolve ref_audio to (wav_samples, sample_rate, cache_key).
 
+        The float32 array can be shared with the cache. Callers must not mutate
+        it; copy before any in-place processing.
+
         Delegates to upstream vLLM's MediaConnector which handles http(s)
         URLs, ``data:`` base64 URIs, and ``file:`` local paths (the latter
         gated by ``--allowed-local-media-path``).
@@ -1243,7 +1280,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         else:
             allowed_path = getattr(self.model_config, "allowed_local_media_path", None)
 
-        wav_list: list[float] | None = None
+        waveform: np.ndarray | None = None
         sr = 0
         artifact_key = ""
         post_key = ""
@@ -1252,14 +1289,14 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             cached = self._ref_audio_resolve_cache.get(cache_key)
             if cached is not None:
                 self._ref_audio_resolve_cache.move_to_end(cache_key)
-                wav_list, sr, _, _ = cached
+                waveform, sr, _, _ = cached
                 logger.debug(
                     "Resolved ref_audio from cache: samples=%d sr=%d duration_s=%.3f",
-                    len(wav_list),
+                    len(waveform),
                     sr,
-                    len(wav_list) / sr if sr > 0 else 0.0,
+                    len(waveform) / sr if sr > 0 else 0.0,
                 )
-                return wav_list, sr, cache_key
+                return waveform, sr, cache_key
 
             if self._media_connector is None:
                 model_config = self.model_config
@@ -1271,21 +1308,21 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             fetch_start_s = time.perf_counter()
             wav_np, fetched_sr = await self._media_connector.fetch_audio_async(ref_audio_str)
             fetch_decode_ms = (time.perf_counter() - fetch_start_s) * 1000.0
-            tolist_start_s = time.perf_counter()
-            wav_list, sr, artifact_key, duration = self._finalize_fetched_ref_audio(wav_np, fetched_sr)
-            tolist_ms = (time.perf_counter() - tolist_start_s) * 1000.0
+            finalize_start_s = time.perf_counter()
+            waveform, sr, artifact_key, duration = self._finalize_fetched_ref_audio(wav_np, fetched_sr)
+            finalize_ms = (time.perf_counter() - finalize_start_s) * 1000.0
             logger.debug(
-                "Resolved ref_audio: fetch_decode_ms=%.3f tolist_ms=%.3f samples=%d sr=%d duration_s=%.3f",
+                "Resolved ref_audio: fetch_decode_ms=%.3f finalize_ms=%.3f samples=%d sr=%d duration_s=%.3f",
                 fetch_decode_ms,
-                tolist_ms,
-                len(wav_list),
+                finalize_ms,
+                len(waveform),
                 sr,
                 duration,
             )
             post_key = await self._ref_audio_cache_key(ref_audio_str, allowed_path)
             if post_key == cache_key:
-                self._put_resolved_ref_audio(cache_key, wav_list, sr, artifact_key)
-                return wav_list, sr, cache_key
+                self._put_resolved_ref_audio(cache_key, waveform, sr, artifact_key)
+                return waveform, sr, cache_key
             logger.debug(
                 "ref_audio metadata changed during fetch (attempt %d/%d); retrying",
                 attempt + 1,
@@ -1296,8 +1333,8 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             "ref_audio file changed during fetch after %d attempts; skipping resolve cache",
             _REF_AUDIO_METADATA_FETCH_ATTEMPTS,
         )
-        assert wav_list is not None and post_key
-        return wav_list, sr, post_key
+        assert waveform is not None and post_key
+        return waveform, sr, post_key
 
     @staticmethod
     def _make_ref_audio_artifact_cache_key(wav: np.ndarray, sr: int) -> str:
@@ -1322,12 +1359,18 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         self._ref_audio_resolve_cache.move_to_end(cache_key)
         return cached[3]
 
-    def _put_resolved_ref_audio(self, cache_key: str, wav_list: list[float], sr: int, artifact_key: str) -> None:
+    def _put_resolved_ref_audio(
+        self, cache_key: str, waveform: np.ndarray | list[float], sr: int, artifact_key: str
+    ) -> None:
         if self._ref_audio_resolve_cache_max_entries <= 0 or self._ref_audio_resolve_cache_max_bytes <= 0:
             return
-        # Approximate list[float] storage. CPython float objects add per-element
-        # overhead, so max_entries remains the hard cache cap.
-        size = len(wav_list) * 40
+        # Keep the finalized ndarray's ownership and identity for the array
+        # resolver. Legacy list callers are materialized into a compact array;
+        # their Python list remains independent from cached storage.
+        waveform = np.asarray(waveform, dtype=np.float32)
+        if not waveform.flags.c_contiguous:
+            waveform = np.ascontiguousarray(waveform)
+        size = int(waveform.nbytes)
         if size > self._ref_audio_resolve_cache_max_bytes:
             return
         previous = self._ref_audio_resolve_cache.pop(cache_key, None)
@@ -1335,7 +1378,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             self._ref_audio_resolve_cache_bytes -= previous[2]
             if previous[3] != artifact_key:
                 self._discard_ref_audio_artifact_ready_if_unreferenced(previous[3])
-        self._ref_audio_resolve_cache[cache_key] = (wav_list, int(sr), size, artifact_key)
+        self._ref_audio_resolve_cache[cache_key] = (waveform, int(sr), size, artifact_key)
         self._ref_audio_resolve_cache_bytes += size
         while len(self._ref_audio_resolve_cache) > self._ref_audio_resolve_cache_max_entries:
             _, (_, _, old_size, old_artifact_key) = self._ref_audio_resolve_cache.popitem(last=False)
@@ -1444,14 +1487,15 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         tts_params: dict[str, Any] | None = None,
         collect: dict | None = None,
         target_sample_rate: int | None = None,
+        cumulative_audio: bool = False,
     ):
         """Generate audio chunks for streaming response.
 
         Handles two audio output modes from the engine:
         - Cumulative mode (list): Engine returns growing list of chunks;
         we emit only the new tail on each iteration.
-        - Per-step mode (tensor): Engine returns single tensor per iteration;
-        we emit it directly.
+        - Tensor mode: Emit each tensor directly, or only its new samples when
+        cumulative_audio is set for requests that retain audio for alignment.
 
         Args:
             generator: Async generator from the engine
@@ -1462,6 +1506,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             Raw audio bytes for each chunk (with WAV header for first chunk if wav format)
         """
         prev_count = 0
+        emitted_samples = 0
         sample_rate_val = 24000
         first_chunk = True
         first_audio_chunk_s: float | None = None
@@ -1563,6 +1608,12 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     )
                     if chunk_np.ndim > 1:
                         chunk_np = chunk_np.squeeze()
+                    if cumulative_audio and not isinstance(audio_val, list):
+                        total_samples = chunk_np.shape[-1]
+                        chunk_np = chunk_np[..., emitted_samples:]
+                        emitted_samples = total_samples
+                        if chunk_np.size == 0:
+                            continue
                     if resampler is not None:
                         chunk_np = resampler.process(chunk_np)
                         if chunk_np.size == 0:
@@ -1887,9 +1938,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             # chat-template markers (im_start_token_id 151644).  A raw-text
             # prompt produces a 1-token placeholder that crashes the talker's
             # prefill/decode handoff.  Reject early with an actionable message.
-            stage_names = {
-                getattr(getattr(s, "engine_args", None), "model_stage", None) for s in self.engine_client.stage_configs
-            }
+            stage_names = {_stage_speech_metadata(s)[0] for s in self.engine_client.stage_configs}
             if "talker" in stage_names:
                 raise ValueError(
                     "The /v1/audio/speech endpoint is only supported for "
@@ -1957,6 +2006,15 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             from vllm_omni.model_executor.stage_input_processors.forced_aligner import TIMESTAMPS_MODALITY
 
             output_modalities.append(TIMESTAMPS_MODALITY)
+            if is_streaming_request:
+                # The aligner consumes the terminal waveform, so retain earlier
+                # audio chunks instead of draining them after each DELTA output.
+                sampling_params_list = [
+                    sp.clone() if isinstance(sp, SamplingParams) else sp for sp in sampling_params_list
+                ]
+                for sp in sampling_params_list:
+                    if isinstance(sp, SamplingParams):
+                        sp.output_kind = RequestOutputKind.CUMULATIVE
 
         generator = self.engine_client.generate(
             prompt=prompt,
@@ -1990,6 +2048,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         tts_params: dict[str, Any] | None = None,
         collect: dict | None = None,
         target_sample_rate: int | None = None,
+        cumulative_audio: bool = False,
     ):
         """Yield raw PCM byte chunks from the engine generator.
 
@@ -2009,6 +2068,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 tts_params=tts_params,
                 collect=collect,
                 target_sample_rate=target_sample_rate,
+                cumulative_audio=cumulative_audio,
             )
         ) as chunks:
             async for chunk in chunks:
@@ -2024,6 +2084,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     request_id,
                     tts_params=tts_params,
                     target_sample_rate=request.sample_rate,
+                    cumulative_audio=request.word_timestamps,
                 )
             ) as chunks:
                 async for chunk in chunks:
diff --git a/vllm_omni/entrypoints/openai/serving_speech_stream.py b/vllm_omni/entrypoints/openai/serving_speech_stream.py
index ceeb208c9..45bdd4e90 100644
--- a/vllm_omni/entrypoints/openai/serving_speech_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_speech_stream.py
@@ -483,6 +483,7 @@ class OmniStreamingSpeechHandler:
                 include_sample_rate=True,
                 tts_params=tts_params,
                 collect=collect,
+                cumulative_audio=True,
             )
         ) as stream:
             async for chunk, chunk_sample_rate in stream:
diff --git a/vllm_omni/entrypoints/openai/serving_video.py b/vllm_omni/entrypoints/openai/serving_video.py
index 9a24a1ef9..c90a4d162 100644
--- a/vllm_omni/entrypoints/openai/serving_video.py
+++ b/vllm_omni/entrypoints/openai/serving_video.py
@@ -20,7 +20,7 @@ from vllm.engine.protocol import EngineClient
 from vllm.logger import init_logger
 
 from vllm_omni.diffusion.data import is_diffusion_request_started_output
-from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
+from vllm_omni.diffusion.model_metadata import DiffusionModelMetadata, get_diffusion_model_metadata
 from vllm_omni.diffusion.utils.media_utils import count_mp4_frames, normalize_preencode_batch_frames
 from vllm_omni.entrypoints.async_omni import ABORT_TIMEOUT_S, AsyncOmni
 from vllm_omni.entrypoints.openai.protocol.videos import (
@@ -53,6 +53,30 @@ logger = init_logger(__name__)
 
 _VIDEO_RESPONSE_FRAME_CONVERSION_WORKERS = 8
 
+
+def _config_value(config: Any, key: str, default: Any = None) -> Any:
+    if isinstance(config, Mapping):
+        return config.get(key, default)
+    return getattr(config, key, default)
+
+
+def _stage_diffusion_model_class_name(stage_config: Any) -> str | None:
+    """Resolve a stage's diffusion class across typed and legacy shapes."""
+    diffusion_config = _config_value(stage_config, "diffusion_config")
+    model_class_name = _config_value(diffusion_config, "model_class_name")
+    if model_class_name:
+        return str(model_class_name)
+
+    model_config = _config_value(stage_config, "model_config")
+    model_arch = _config_value(model_config, "model_arch") or _config_value(stage_config, "model_arch")
+    if model_arch:
+        return str(model_arch)
+
+    engine_args = _config_value(stage_config, "engine_args", {})
+    model_class_name = _config_value(engine_args, "model_class_name")
+    return str(model_class_name) if model_class_name else None
+
+
 if TYPE_CHECKING:
     from vllm_omni.diffusion.data import OmniDiffusionConfig
 
@@ -80,6 +104,17 @@ class ReferenceAudio:
     cleanup_paths: tuple[str, ...] = ()
 
 
+@dataclass
+class LatentEditInput:
+    """Request-scoped source media and masks for latent-mask editing."""
+
+    source_video: str | None = None
+    source_audio: str | None = None
+    video_noise_mask: Any | None = None
+    audio_noise_mask: Any | None = None
+    cleanup_paths: tuple[str, ...] = ()
+
+
 @dataclass
 class VideoGenerationArtifacts:
     """Normalized outputs and profiler metadata extracted from one request."""
@@ -143,6 +178,15 @@ class OmniOpenAIServingVideo:
             return get_od_config()
         return getattr(self._engine_client, "od_config", None)
 
+    def _resolve_diffusion_metadata(
+        self,
+    ) -> tuple[OmniDiffusionConfig | SimpleNamespace | None, tuple[DiffusionModelMetadata, ...]]:
+        """Resolve capability metadata from the runtime and diffusion stages."""
+        od_config = self._resolve_diffusion_od_config()
+        model_archs = [None if od_config is None else getattr(od_config, "model_class_name", None)]
+        model_archs.extend(_stage_diffusion_model_class_name(stage) for stage in self.stage_configs or ())
+        return od_config, tuple(get_diffusion_model_metadata(model_arch) for model_arch in model_archs)
+
     def _resolve_video_generation_defaults(
         self,
         request: VideoGenerationRequest,
@@ -187,30 +231,18 @@ class OmniOpenAIServingVideo:
     @property
     def supports_mixed_reference_inputs(self) -> bool:
         """Return whether the configured diffusion model accepts mixed refs."""
-        od_config = self._resolve_diffusion_od_config()
+        od_config, metadata = self._resolve_diffusion_metadata()
         if od_config is None:
             return False
 
         capability = getattr(od_config, "supports_mixed_reference_inputs", None)
-        model_class_name = getattr(od_config, "model_class_name", None)
-        model_archs = [model_class_name]
-        for stage_config in self.stage_configs or ():
-            stage_get = (
-                stage_config.get if isinstance(stage_config, Mapping) else lambda key: getattr(stage_config, key, None)
-            )
-            engine_args = stage_get("engine_args") or {}
-            model_archs.extend(
-                (
-                    stage_get("model_arch"),
-                    engine_args.get("model_class_name")
-                    if isinstance(engine_args, Mapping)
-                    else getattr(engine_args, "model_class_name", None),
-                )
-            )
-        metadata_capability = any(
-            get_diffusion_model_metadata(model_arch).supports_mixed_reference_inputs for model_arch in model_archs
-        )
-        return capability is True or metadata_capability
+        return capability is True or any(item.supports_mixed_reference_inputs for item in metadata)
+
+    @property
+    def supports_latent_mask_editing(self) -> bool:
+        """Return whether the configured diffusion model accepts latent edits."""
+        _, metadata = self._resolve_diffusion_metadata()
+        return any(item.supports_latent_mask_editing for item in metadata)
 
     @property
     def supported_control_upload_types(self) -> frozenset[str]:
@@ -220,25 +252,11 @@ class OmniOpenAIServingVideo:
         generic video API isolated from model-specific controls unless a model
         explicitly opts into the ``control_path`` contract in metadata.
         """
-        od_config = self._resolve_diffusion_od_config()
-        model_archs = [None if od_config is None else getattr(od_config, "model_class_name", None)]
-        for stage_config in self.stage_configs or ():
-            stage_get = (
-                stage_config.get if isinstance(stage_config, Mapping) else lambda key: getattr(stage_config, key, None)
-            )
-            engine_args = stage_get("engine_args") or {}
-            model_archs.extend(
-                (
-                    stage_get("model_arch"),
-                    engine_args.get("model_class_name")
-                    if isinstance(engine_args, Mapping)
-                    else getattr(engine_args, "model_class_name", None),
-                )
-            )
+        _, metadata = self._resolve_diffusion_metadata()
 
         supported: set[str] = set()
-        for model_arch in model_archs:
-            supported.update(get_diffusion_model_metadata(model_arch).supported_control_upload_types)
+        for item in metadata:
+            supported.update(item.supported_control_upload_types)
         return frozenset(supported)
 
     @classmethod
@@ -269,6 +287,7 @@ class OmniOpenAIServingVideo:
         reference_video: ReferenceVideo | None = None,
         reference_audio: ReferenceAudio | None = None,
         on_started: Callable[[], Awaitable[None]] | None = None,
+        latent_edit_input: LatentEditInput | None = None,
     ) -> VideoGenerationArtifacts:
         """Run the generation pipeline and extract video/audio/profiler outputs."""
         prompt: OmniTextPrompt = OmniTextPrompt(prompt=request.prompt, modalities=["video"])
@@ -349,6 +368,19 @@ class OmniOpenAIServingVideo:
             multi_modal_data["video"] = input_video
         if reference_audio is not None:
             multi_modal_data["audio"] = reference_audio.path
+        if latent_edit_input is not None:
+            multi_modal_data.update(
+                {
+                    key: value
+                    for key, value in {
+                        "source_video": latent_edit_input.source_video,
+                        "source_audio": latent_edit_input.source_audio,
+                        "video_noise_mask": latent_edit_input.video_noise_mask,
+                        "audio_noise_mask": latent_edit_input.audio_noise_mask,
+                    }.items()
+                    if value is not None
+                }
+            )
         if multi_modal_data:
             prompt["multi_modal_data"] = multi_modal_data
         if vp.width is not None and vp.height is not None:
@@ -487,6 +519,7 @@ class OmniOpenAIServingVideo:
         reference_image: ReferenceImage | None = None,
         reference_video: ReferenceVideo | None = None,
         reference_audio: ReferenceAudio | None = None,
+        latent_edit_input: LatentEditInput | None = None,
     ) -> VideoGenerationResponse:
         artifacts = await self._run_and_extract(
             request,
@@ -494,6 +527,7 @@ class OmniOpenAIServingVideo:
             reference_image=reference_image,
             reference_video=reference_video,
             reference_audio=reference_audio,
+            latent_edit_input=latent_edit_input,
         )
 
         video_codec_options = {"preset": "ultrafast", "threads": "0"}
@@ -539,6 +573,7 @@ class OmniOpenAIServingVideo:
         reference_video: ReferenceVideo | None = None,
         reference_audio: ReferenceAudio | None = None,
         on_started: Callable[[], Awaitable[None]] | None = None,
+        latent_edit_input: LatentEditInput | None = None,
     ) -> tuple[bytes, dict[str, float], float, VideoAction | None, dict[str, object]]:
         """Generate a video and return raw MP4 bytes, bypassing base64 encoding."""
         artifacts = await self._run_and_extract(
@@ -548,6 +583,7 @@ class OmniOpenAIServingVideo:
             reference_video=reference_video,
             reference_audio=reference_audio,
             on_started=on_started,
+            latent_edit_input=latent_edit_input,
         )
         if len(artifacts.videos) > 1:
             logger.warning(
diff --git a/vllm_omni/entrypoints/openai/serving_video_output_stream.py b/vllm_omni/entrypoints/openai/serving_video_output_stream.py
index f8f4722ad..2647ec11c 100644
--- a/vllm_omni/entrypoints/openai/serving_video_output_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_video_output_stream.py
@@ -362,15 +362,41 @@ class OmniStreamingVideoOutputHandler:
         if not isinstance(event, dict):
             await self._send_error(websocket, "session.interaction requires event object", send_lock=send_lock)
             return
-
         prompt = event.get("prompt")
-        if not isinstance(prompt, str) or not prompt.strip():
+        multi_modal_data = event.get("multi_modal_data")
+        has_prompt = isinstance(prompt, str) and bool(prompt.strip())
+        has_mm = isinstance(multi_modal_data, dict) and bool(multi_modal_data)
+        if not has_prompt and not has_mm:
             await self._send_error(
                 websocket,
-                "session.interaction requires a non-empty event.prompt",
+                "session.interaction requires a non-empty event.prompt and/or non-empty event.multi_modal_data",
                 send_lock=send_lock,
             )
             return
+        if "prompt" in event and prompt is not None and not has_prompt:
+            await self._send_error(
+                websocket,
+                "session.interaction event.prompt must be a non-empty string when provided",
+                send_lock=send_lock,
+            )
+            return
+        if "multi_modal_data" in event and multi_modal_data is not None and not has_mm:
+            await self._send_error(
+                websocket,
+                "session.interaction event.multi_modal_data must be a non-empty object when provided",
+                send_lock=send_lock,
+            )
+            return
+        if has_mm:
+            assert isinstance(multi_modal_data, dict)
+            for modality, payload in multi_modal_data.items():
+                if not isinstance(payload, dict):
+                    await self._send_error(
+                        websocket,
+                        f"session.interaction multi_modal_data[{modality!r}] must be an object",
+                        send_lock=send_lock,
+                    )
+                    return
 
         if "negative_prompt" in event and event["negative_prompt"] is not None:
             await self._send_error(
@@ -380,9 +406,19 @@ class OmniStreamingVideoOutputHandler:
             )
             return
 
+        normalized_event: dict[str, Any] = {}
+        if has_prompt:
+            normalized_event["prompt"] = prompt
+        if has_mm:
+            normalized_event["multi_modal_data"] = multi_modal_data
+        # Preserve other event fields that OmniInteractionEvent may carry.
+        for key, value in event.items():
+            if key not in normalized_event and key not in ("prompt", "multi_modal_data"):
+                normalized_event[key] = value
+
         normalized: OmniInteractionPrompt = {
             "event_id": event_id,
-            "event": cast(OmniInteractionEvent, event),
+            "event": cast(OmniInteractionEvent, normalized_event),
         }
         transition_chunks = interaction.get("transition_chunks")
         if transition_chunks is not None:
@@ -572,8 +608,11 @@ class OmniStreamingVideoOutputHandler:
     @staticmethod
     async def _decode_image_reference(request: VideoGenerationRequest) -> Image.Image | None:
         try:
+            image_reference = request.image_reference
+            if isinstance(image_reference, list):
+                raise InvalidInputReferenceError("image_reference must be a single image reference.")
             media_data = await decode_input_reference(
-                request.image_reference,
+                image_reference,
                 None,
                 None,
             )
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/__init__.py b/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
index 9f5387a7f..2b7f93a62 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
@@ -108,7 +108,6 @@ from vllm_omni.entrypoints.openai.tts_adapters import (  # noqa: E402,F401
     breeze_tts_2,
     cosyvoice3,
     covo_audio,
-    dots_tts,
     fish_speech,
     gepard,
     glm_tts,
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/audex.py b/vllm_omni/entrypoints/openai/tts_adapters/audex.py
index 0e31b633f..3b9e4a9a5 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/audex.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/audex.py
@@ -42,7 +42,11 @@ class AudexAdapter(ARTTSAdapter):
 
             from vllm_omni.model_executor.models.audex.checkpoint import ensure_audex_snapshot
 
-            stage = getattr(getattr(self.ctx.server._tts_stage, "engine_args", None), "model_stage", None)
+            stage_config = self.ctx.server._tts_stage
+            topology = getattr(stage_config, "stage_pipeline_config", None)
+            stage = getattr(topology, "model_stage", None)
+            if stage is None:
+                stage = getattr(getattr(stage_config, "engine_args", None), "model_stage", None)
             profile, folder = (
                 ("full", "checkpoint_folder_full") if stage == "audex_omni" else ("tts", "checkpoint_folder_audiogen")
             )
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/base.py b/vllm_omni/entrypoints/openai/tts_adapters/base.py
index ff43b27a5..cb760e865 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/base.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/base.py
@@ -39,6 +39,21 @@ DEFAULT_TTS_LANGUAGES = frozenset(
 )
 
 
+def resolve_stage_model_path(engine_client: Any) -> str | None:
+    """Prefer typed stage model overrides, then legacy and served-model values."""
+    stages = getattr(engine_client, "stage_configs", ()) or ()
+    for stage in stages:
+        model_path = getattr(getattr(stage, "model_config", None), "model", None)
+        if model_path:
+            return str(model_path)
+    for stage in stages:
+        model_path = getattr(getattr(stage, "engine_args", None), "model", None)
+        if model_path:
+            return str(model_path)
+    model_path = getattr(engine_client, "model", None)
+    return str(model_path) if model_path else None
+
+
 def conditioning_cache_salt(request: "OpenAICreateSpeechRequest", tts_params: dict | None = None) -> str:
     """Stable hash of the real Stage 0 conditioning for the prefix cache.
 
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/breeze_tts_2.py b/vllm_omni/entrypoints/openai/tts_adapters/breeze_tts_2.py
index d2851e32c..03f0d3c4b 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/breeze_tts_2.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/breeze_tts_2.py
@@ -4,6 +4,8 @@
 """Breeze-TTS-2 serving adapter for synchronous full-payload generation."""
 
 import asyncio
+import copy
+import math
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
@@ -49,6 +51,7 @@ class BreezeTTS2Adapter(ARTTSAdapter):
         return set()
 
     def _load_codec_frame_rate(self) -> float | None:
+        assert self.ctx.engine_client is not None
         config = self.ctx.engine_client.model_config.hf_config
         codec = getattr(config, "codec_config", None)
         if isinstance(codec, dict):
@@ -99,6 +102,14 @@ class BreezeTTS2Adapter(ARTTSAdapter):
         greedy_error = _validate_greedy_sampling(extra_params)
         if greedy_error is not None:
             return greedy_error
+        repetition_penalty = extra_params.get("repetition_penalty")
+        if repetition_penalty is not None:
+            try:
+                repetition_penalty = float(repetition_penalty)
+            except (TypeError, ValueError):
+                return "Breeze-TTS-2 repetition_penalty must be finite and positive"
+            if not math.isfinite(repetition_penalty) or repetition_penalty <= 0:
+                return "Breeze-TTS-2 repetition_penalty must be finite and positive"
         if request.max_new_tokens is not None:
             if request.max_new_tokens < self.max_new_tokens_min:
                 return f"max_new_tokens must be at least {self.max_new_tokens_min}"
@@ -210,7 +221,16 @@ class BreezeTTS2Adapter(ARTTSAdapter):
         request_id: str | None = None,
     ) -> list:
         del prompt, request_id
-        return apply_max_new_tokens(sampling_params_list, request)
+        sampling_params_list = apply_max_new_tokens(sampling_params_list, request)
+        repetition_penalty = (request.extra_params or {}).get("repetition_penalty")
+        if repetition_penalty is not None:
+            # The generic speech handler copies extra_params to extra_args;
+            # promote this value so the worker receives sampling metadata.
+            # Only this scalar changes; preserve the caller's params without
+            # copying nested state or the unchanged codec-stage parameters.
+            sampling_params_list = [copy.copy(sampling_params_list[0]), *sampling_params_list[1:]]
+            sampling_params_list[0].repetition_penalty = float(repetition_penalty)
+        return sampling_params_list
 
 
 def _validate_greedy_sampling(extra_params: dict[str, Any]) -> str | None:
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/dots_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/dots_tts.py
deleted file mode 100644
index 75cfb8455..000000000
--- a/vllm_omni/entrypoints/openai/tts_adapters/dots_tts.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""dots.tts serving adapter."""
-
-from typing import TYPE_CHECKING
-
-from transformers import AutoTokenizer
-from vllm.utils.async_utils import make_async
-
-from vllm_omni.entrypoints.openai.tts_adapters import register_tts_adapter
-from vllm_omni.entrypoints.openai.tts_adapters.base import ARTTSAdapter, PreparedRequest, apply_max_new_tokens
-
-if TYPE_CHECKING:
-    from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
-
-
-@register_tts_adapter
-class DotsTTSAdapter(ARTTSAdapter):
-    """Adapter for dots.tts (AR ``engine_client`` backend).
-
-    The current integration supports text-only, no-reference speech synthesis.
-    Voice cloning and reference-audio conditioning are not supported yet.
-    """
-
-    stage_keys = frozenset()
-    model_archs = frozenset({"DotsTTSForConditionalGeneration"})
-    name = "dots_tts"
-    detect_priority = 5
-
-    def __init__(self, ctx):
-        super().__init__(ctx)
-        self.tokenizer = None
-        self._build_prompt_async = None
-
-    def _build_prompt(self, text: str) -> dict:
-        from vllm_omni.model_executor.models.dots_tts.dots_tts_prompt import build_dots_tts_prompt
-
-        if self.tokenizer is None:
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.ctx.engine_client.model_config.model,
-                trust_remote_code=True,
-            )
-        return build_dots_tts_prompt(self.tokenizer, text)
-
-    def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        if request.voice not in (None, "default"):
-            return "'voice' is not supported for dots.tts"
-
-        if request.ref_audio is not None:
-            return "'ref_audio' is not supported for dots.tts"
-
-        if request.ref_text is not None:
-            return "'ref_text' is not supported for dots.tts"
-
-        if request.speaker_embedding is not None:
-            return "'speaker_embedding' is not supported for dots.tts"
-
-        if request.x_vector_only_mode is not None:
-            return "'x_vector_only_mode' is not supported for dots.tts"
-        return None
-
-    async def build(
-        self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
-    ) -> PreparedRequest:
-        if self._build_prompt_async is None:
-            self._build_prompt_async = make_async(
-                self._build_prompt,
-                executor=self.ctx.server._tts_executor,
-            )
-        prompt = await self._build_prompt_async(request.input)
-        return PreparedRequest(prompt=prompt, tts_params={}, model_type="dots_tts")
-
-    def apply_sampling_overrides(
-        self,
-        sampling_params_list: list,
-        request: "OpenAICreateSpeechRequest",
-        prompt: dict | None = None,
-        request_id: str | None = None,
-    ) -> list:
-        return apply_max_new_tokens(sampling_params_list, request)
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py
index 207d8b47b..761b5431a 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py
@@ -9,7 +9,13 @@ import numpy as np
 from vllm.inputs import tokens_input
 
 from vllm_omni.entrypoints.openai.tts_adapters import register_tts_adapter
-from vllm_omni.entrypoints.openai.tts_adapters.base import ARTTSAdapter, PreparedRequest, apply_max_new_tokens
+from vllm_omni.entrypoints.openai.tts_adapters.base import (
+    ARTTSAdapter,
+    PreparedRequest,
+    apply_max_new_tokens,
+    conditioning_cache_salt,
+    resolve_stage_model_path,
+)
 
 if TYPE_CHECKING:
     from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
@@ -50,7 +56,7 @@ class HiggsAudioV2Adapter(ARTTSAdapter):
             prompt_token_ids = input_ids_to_python_list(inputs)
             return tokens_input(prompt_token_ids=prompt_token_ids)
 
-        wav_list, sr, _ = await self._resolve_ref_audio(request.ref_audio)
+        wav_list, sr, cache_key = await self._resolve_ref_audio(request.ref_audio)
         wav = np.asarray(wav_list, dtype=np.float32)
         out = await asyncio.to_thread(
             build_voice_clone_prompt,
@@ -70,7 +76,9 @@ class HiggsAudioV2Adapter(ARTTSAdapter):
         prompt["additional_information"] = {
             "audio_input_ids": out["audio_input_ids"],
             "audio_input_ids_mask": out["audio_input_ids_mask"],
+            "ref_audio_cache_key": cache_key,
         }
+        prompt["cache_salt"] = conditioning_cache_salt(request, prompt["additional_information"])
         return prompt
 
     async def _resolve_higgs_audio_v2_processor(self):
@@ -81,17 +89,7 @@ class HiggsAudioV2Adapter(ARTTSAdapter):
 
         from transformers import AutoProcessor
 
-        model_path = None
-        for stage in self.engine_client.stage_configs:
-            model_path = getattr(getattr(stage, "engine_args", None), "model", None)
-            if model_path:
-                break
-        if model_path is None:
-            # Fallback: the orchestrator stores the served model id on the engine
-            # itself (set by AsyncOmniEngine.__init__). Stage-level engine_args
-            # may not surface ``model`` when the deploy yaml doesn't set it per
-            # stage (the CLI-passed model id is the single source of truth).
-            model_path = getattr(self.engine_client, "model", None)
+        model_path = resolve_stage_model_path(self.engine_client)
         if model_path is None:
             raise RuntimeError("higgs_audio_v2 serving could not resolve the model path from the engine stage configs")
         processor = AutoProcessor.from_pretrained(model_path)
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py
index 1e64f7a63..d993a7395 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py
@@ -16,6 +16,7 @@ from vllm_omni.entrypoints.openai.tts_adapters.base import (
     PreparedRequest,
     apply_max_new_tokens,
     conditioning_cache_salt,
+    resolve_stage_model_path,
 )
 
 _REF_CODE_CACHE_MAX_ENTRIES = 256
@@ -170,13 +171,7 @@ class HiggsAudioV3Adapter(ARTTSAdapter):
             HiggsAudioV3TokenizerAdapter,
         )
 
-        model_path = None
-        for stage in self.engine_client.stage_configs:
-            model_path = getattr(getattr(stage, "engine_args", None), "model", None)
-            if model_path:
-                break
-        if model_path is None:
-            model_path = getattr(self.engine_client, "model", None)
+        model_path = resolve_stage_model_path(self.engine_client)
         if model_path is None:
             raise RuntimeError("higgs_audio_v3 serving could not resolve model path")
         tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
index bed20efc2..ea7ff29ec 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
@@ -6,9 +6,14 @@ Both variants share the same build/validate flow (``_build_moss_tts_params``
 handles each); they are registered under distinct model-type names.
 """
 
+import asyncio
+import threading
 from typing import TYPE_CHECKING, Any, cast
 
+from transformers import AutoModel, AutoTokenizer
+from transformers.dynamic_module_utils import get_class_from_dynamic_module
 from vllm.inputs import tokens_input
+from vllm.logger import init_logger
 
 from vllm_omni.entrypoints.openai.tts_adapters import register_tts_adapter
 from vllm_omni.entrypoints.openai.tts_adapters.base import (
@@ -18,10 +23,13 @@ from vllm_omni.entrypoints.openai.tts_adapters.base import (
     apply_max_new_tokens,
     conditioning_cache_salt,
 )
+from vllm_omni.model_executor.models.moss_tts.realtime_prompt import build_realtime_prompt
 
 if TYPE_CHECKING:
     from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
 
+logger = init_logger(__name__)
+
 
 class _MossTTSAdapterBase(ARTTSAdapter):
     accumulate_nonstreaming: bool = False
@@ -30,6 +38,7 @@ class _MossTTSAdapterBase(ARTTSAdapter):
         super().__init__(ctx)
         self._moss_variant = None if self.name == "moss_tts_nano" else self._detect_moss_variant()
         self._moss_processor_cache = None
+        self._moss_realtime_components_lock = threading.Lock()
 
     @property
     def engine_client(self):
@@ -44,7 +53,9 @@ class _MossTTSAdapterBase(ARTTSAdapter):
         return self.ctx.server._speaker_cache
 
     async def _resolve_ref_audio(self, ref_audio: str):
-        return await self.ctx.server._resolve_ref_audio(ref_audio)
+        if self._moss_variant is None:  # Nano sends lists through engine IPC.
+            return await self.ctx.server._resolve_ref_audio(ref_audio)
+        return await self.ctx.server._resolve_ref_audio_array(ref_audio)
 
     def _voice_created_at(self, voice: str) -> int:
         return self.ctx.server._voice_created_at(voice)
@@ -63,7 +74,7 @@ class _MossTTSAdapterBase(ARTTSAdapter):
         # inside the model package; this layer only supplies the processor and
         # the process-wide speaker cache.
         encoder = build_reference_encoder(
-            self._get_moss_processor(),
+            self._get_moss_realtime_components()[2] if self._moss_variant == "realtime" else self._get_moss_processor(),
             variant=cast(str, self._moss_variant),
             speaker_cache=self._speaker_cache,
         )
@@ -137,13 +148,81 @@ class _MossTTSAdapterBase(ARTTSAdapter):
             return "voice_generator"
         return "tts"
 
+    def _codec_stage_devices(self) -> str | None:
+        """Read the runtime ``devices`` entry of this pipeline's codec stage.
+
+        The codec (code2wav) stage is the final stage of every MOSS pipeline
+        (``moss_tts_local_codec`` / ``moss_tts_codec``); prefer a stage whose
+        ``model_stage`` mentions "codec", else anchor on the last stage. The
+        runtime mapping accepts the resolved ``runtime_config`` object, the
+        omegaconf ``runtime`` mapping, and the legacy ``yaml_runtime`` dict.
+        """
+        stages = list(getattr(self.engine_client, "stage_configs", None) or ())
+        if not stages:
+            return None
+        codec_stages = [s for s in stages if "codec" in str(getattr(s, "model_stage", "") or "")]
+        anchor = codec_stages[-1] if codec_stages else stages[-1]
+        for attr in ("runtime_config", "runtime", "yaml_runtime"):
+            runtime_cfg = getattr(anchor, attr, None)
+            if runtime_cfg is None:
+                continue
+            devices = (
+                runtime_cfg.get("devices") if hasattr(runtime_cfg, "get") else getattr(runtime_cfg, "devices", None)
+            )
+            if devices is not None and str(devices).strip():
+                return str(devices)
+        devices = getattr(anchor, "devices", None)
+        return str(devices) if devices is not None and str(devices).strip() else None
+
+    def _resolve_ref_encoder_device(self):
+        """Pick the device of the API-process reference-audio encoder.
+
+        The encoder follows the code2wav stage onto its first GPU: the stage
+        worker remaps its ``devices`` entry through ``CUDA_VISIBLE_DEVICES``
+        and sees it as logical index 0, while replica launch restores the
+        parent environment, so the same index names the same physical GPU in
+        this process. When the stage pins no devices the stage worker and the
+        encoder both default to the first visible GPU. Falls back to CPU when
+        CUDA is unavailable or the stage device is not parseable.
+        """
+        import torch  # local to avoid pulling torch at module import time
+
+        if not torch.cuda.is_available():
+            return torch.device("cpu")
+        devices_str = self._codec_stage_devices()
+        if devices_str is None:
+            # No explicit pinning: the stage worker lands on the first visible
+            # GPU (vLLM picks cuda:0 of the un-remapped environment).
+            return torch.device("cuda", 0)
+        first = devices_str.split(",")[0].strip()
+        if not first:
+            return torch.device("cuda", 0)
+        if first == "cpu":
+            return torch.device("cpu")
+        if not first.isdigit():
+            logger.warning("MOSS ref encoder: codec stage devices %r not parseable; keeping CPU", devices_str)
+            return torch.device("cpu")
+        index = int(first)
+        device_count = torch.accelerator.device_count()
+        if index >= device_count:
+            logger.warning(
+                "MOSS ref encoder: codec stage device cuda:%d out of range (%d visible); keeping CPU",
+                index,
+                device_count,
+            )
+            return torch.device("cpu")
+        return torch.device("cuda", index)
+
     def _get_moss_processor(self):
         """Lazily load the upstream MOSS-TTS processor once per server.
 
         Cached on ``self._moss_processor_cache``. The processor owns its own
-        audio_tokenizer (~1.6 B params); we keep it on CPU so it doesn't
-        compete with the talker (~8 GiB) and codec (~7 GiB) for our 96 GiB
-        GPU — per-request ref-audio encoding is fast enough on CPU.
+        audio_tokenizer (~1.6 B params) used for per-request reference-audio
+        encoding; it is placed on the code2wav stage's GPU (see
+        ``_resolve_ref_encoder_device``) so cold encodes run on device instead
+        of paying a CPU forward per request. Note this memory is charged to
+        the API process, outside each stage's ``gpu_memory_utilization``
+        budget — keep some headroom on the codec GPU.
         """
         cached = getattr(self, "_moss_processor_cache", None)
         if cached is not None:
@@ -153,10 +232,48 @@ class _MossTTSAdapterBase(ARTTSAdapter):
         model_id = self.engine_client.model_config.model
         proc = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
         if hasattr(proc, "audio_tokenizer"):
-            proc.audio_tokenizer = proc.audio_tokenizer.to("cpu").eval()
+            device = self._resolve_ref_encoder_device()
+            proc.audio_tokenizer = proc.audio_tokenizer.to(device).eval()
+            logger.info("MOSS reference-audio encoder (audio_tokenizer) placed on %s", device)
         self._moss_processor_cache = proc
         return proc
 
+    def _get_moss_realtime_components(self):
+        with self._moss_realtime_components_lock:
+            cached = getattr(self, "_moss_realtime_components", None)
+            if cached is not None:
+                return cached
+
+            model_id = self.engine_client.model_config.model
+            processor_cls = get_class_from_dynamic_module(
+                "processing_mossttsrealtime.MossTTSRealtimeProcessor",
+                model_id,
+            )
+            tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+            processor = processor_cls(tokenizer=tokenizer)
+            hf_config = self.engine_client.model_config.hf_config
+            codec_path = str(
+                getattr(
+                    hf_config,
+                    "codec_model_name_or_path",
+                    getattr(
+                        hf_config,
+                        "audio_tokenizer_name_or_path",
+                        "OpenMOSS-Team/MOSS-Audio-Tokenizer",
+                    ),
+                )
+            )
+            codec = AutoModel.from_pretrained(
+                codec_path,
+                trust_remote_code=True,
+            )
+            # Reference encoding runs in the API process; follow the codec
+            # (code2wav) stage's GPU like the processor path above.
+            codec = codec.to(self._resolve_ref_encoder_device()).eval()
+            cached = (tokenizer, processor, codec)
+            self._moss_realtime_components = cached
+            return cached
+
     async def _build_moss_tts_params(
         self,
         request: "OpenAICreateSpeechRequest",
@@ -196,24 +313,18 @@ class _MossTTSAdapterBase(ARTTSAdapter):
             params["ref_audio_cache_key"] = cache_key
             return params
 
-        # ---- MOSS-TTS-Realtime: keep the old prompt_audio_array path ----
-        # ``AutoProcessor.from_pretrained`` doesn't auto-discover
-        # ``MossTTSRealtimeProcessor`` (no ``processor_config.json`` in the
-        # snapshot), and Realtime's prompt format diverges from MossTTSDelay
-        # (16-channel grid, separate per-step text feed). The
-        # ``prompt_audio_array`` shape lines up well enough with what the
-        # talker reads for short prompts; full Realtime support needs a
-        # separate processor.from_module path which we don't wire here.
         if v == "realtime":
-            params = {
-                "text": [request.input or ""],
-                "mode": ["voice_clone"],
-            }
+            tokenizer, processor, _ = await asyncio.to_thread(self._get_moss_realtime_components)
+            references, realtime_resolve_keys = await self._encode_moss_references(
+                request,
+                has_inline_ref_audio=has_inline_ref_audio,
+                two_speaker=False,
+            )
+            params = build_realtime_prompt(tokenizer, processor, request.input or "", references[0])
             if request.max_new_tokens is not None:
                 params["max_new_frames"] = [request.max_new_tokens]
-            wav_list, sr, cache_key = await self._resolve_ref_audio(cast(str, request.ref_audio))
-            params["prompt_audio_array"] = [[wav_list, sr]]
-            params["ref_audio_cache_key"] = cache_key
+            if 0 in realtime_resolve_keys:
+                params["ref_audio_cache_key"] = realtime_resolve_keys[0]
             return params
 
         # ---- MossTTSDelay family (tts/ttsd/sound_effect/voice_generator)
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py b/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
index 5ea82babd..4cdf990f2 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
@@ -99,9 +99,10 @@ class VoxtralTTSAdapter(ARTTSAdapter):
     ) -> PreparedRequest:
         # Cache encoder_loaded property to avoid RPC call on every request with ref_audio
         if self._encoder_loaded is None:
-            loaded = await self.ctx.server.engine_client.collective_rpc("encoder_loaded")
-            #  Flatten results before checking if encoder loaded property is set
-            self._encoder_loaded = any(sum(loaded, []))
+            result = await self.ctx.server.engine_client.collective_rpc("encoder_loaded")
+            self._encoder_loaded = any(
+                bool(x) for r in result if not isinstance(r, dict) for x in (r if isinstance(r, list) else [r])
+            )
 
         prompt = await self._build_prompt_async(request)
         return PreparedRequest(prompt=prompt, tts_params={}, model_type="voxtral_tts")
diff --git a/vllm_omni/entrypoints/openai/video/generation/helpers.py b/vllm_omni/entrypoints/openai/video/generation/helpers.py
index 4473fce07..5ed02443f 100644
--- a/vllm_omni/entrypoints/openai/video/generation/helpers.py
+++ b/vllm_omni/entrypoints/openai/video/generation/helpers.py
@@ -54,10 +54,12 @@ from vllm_omni.entrypoints.openai.protocol.videos import (
     VideoResponse,
 )
 from vllm_omni.entrypoints.openai.serving_video import (
+    LatentEditInput,
     OmniOpenAIServingVideo,
     ReferenceAudio,
     ReferenceImage,
     ReferenceVideo,
+    _stage_diffusion_model_class_name,
 )
 from vllm_omni.entrypoints.openai.storage import STORAGE_MANAGER
 from vllm_omni.entrypoints.openai.stores import VIDEO_STORE
@@ -92,6 +94,9 @@ CONTROL_REFERENCE_IMAGE_SUFFIXES = frozenset({".bmp", ".gif", ".jpg", ".jpeg", "
 CONTROL_REFERENCE_VIDEO_SUFFIXES = frozenset({".mkv", ".mov", ".mp4", ".webm"})
 CONTROL_REFERENCE_MAX_BYTES = 512 * 1024 * 1024
 
+LATENT_EDIT_SOURCE_MAX_BYTES = 512 * 1024 * 1024
+LATENT_EDIT_MASK_FILE_MAX_BYTES = 8 * 1024 * 1024
+
 VIDEO_SYNC_TIMEOUT_S = float(os.environ.get("VLLM_OMNI_VIDEO_SYNC_TIMEOUT", 600.0))
 
 
@@ -125,6 +130,79 @@ def _parse_form_json(value: str | None, expected_type: type | None = None) -> An
     return parsed
 
 
+def _parse_latent_edit_mask_json(
+    value: str,
+    *,
+    field_name: str,
+) -> Any:
+    """Decode one request mask; Stage 0 owns its semantic validation."""
+    try:
+        parsed = _parse_form_json(value)
+        # Bound container nesting at the parsing boundary without duplicating
+        # Stage 0's numeric, range, or shape validation.
+        pending = [(parsed, 0)]
+        while pending:
+            item, depth = pending.pop()
+            if not isinstance(item, (list, dict)):
+                continue
+            if depth >= 64:
+                raise ValueError("JSON nesting exceeds 64 levels")
+            children = item.values() if isinstance(item, dict) else item
+            pending.extend((child, depth + 1) for child in children)
+        return parsed
+    except (RecursionError, ValueError) as exc:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail=f"{field_name} contains invalid JSON or is nested too deeply.",
+        ) from exc
+
+
+async def _read_latent_edit_mask_json(
+    value: UploadFile | None,
+    *,
+    field_name: str,
+) -> Any | None:
+    """Read a mask from a bounded UTF-8 JSON file part."""
+    if value is None:
+        return None
+
+    try:
+        declared_size = value.size
+        if isinstance(declared_size, Integral) and int(declared_size) > LATENT_EDIT_MASK_FILE_MAX_BYTES:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"{field_name} JSON exceeds the {LATENT_EDIT_MASK_FILE_MAX_BYTES // (1024 * 1024)} MiB limit.",
+            )
+
+        payload = await value.read(LATENT_EDIT_MASK_FILE_MAX_BYTES + 1)
+        if len(payload) > LATENT_EDIT_MASK_FILE_MAX_BYTES:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"{field_name} JSON exceeds the {LATENT_EDIT_MASK_FILE_MAX_BYTES // (1024 * 1024)} MiB limit.",
+            )
+        try:
+            text = payload.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"{field_name} JSON file must be UTF-8 encoded.",
+            ) from exc
+        if not text:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"{field_name} JSON file must not be empty.",
+            )
+        parsed = _parse_latent_edit_mask_json(text, field_name=field_name)
+        if parsed is None:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"{field_name} JSON file must contain a mask value.",
+            )
+        return parsed
+    finally:
+        await value.close()
+
+
 def _config_get(config: Any, key: str, default: Any = None) -> Any:
     if isinstance(config, dict):
         return config.get(key, default)
@@ -136,10 +214,6 @@ def _config_get(config: Any, key: str, default: Any = None) -> Any:
     return getattr(config, key, default)
 
 
-def _stage_engine_args(stage_cfg: Any) -> Any:
-    return _config_get(stage_cfg, "engine_args", {}) or {}
-
-
 def _diffusion_model_classes(stage_configs: list[Any] | None) -> list[type]:
     if not stage_configs:
         return []
@@ -150,7 +224,7 @@ def _diffusion_model_classes(stage_configs: list[Any] | None) -> list[type]:
     for stage_cfg in stage_configs:
         if get_stage_type(stage_cfg) != "diffusion":
             continue
-        model_class_name = _config_get(_stage_engine_args(stage_cfg), "model_class_name")
+        model_class_name = _stage_diffusion_model_class_name(stage_cfg)
         if not model_class_name:
             continue
         model_cls = DiffusionModelRegistry._try_load_model_cls(model_class_name)
@@ -281,6 +355,7 @@ def _cleanup_video_references(
     reference_video: ReferenceVideo | None,
     reference_audio: ReferenceAudio | None,
     control_path: str | None = None,
+    latent_edit_input: LatentEditInput | None = None,
 ) -> None:
     if reference_video is not None:
         for path in reference_video.cleanup_paths:
@@ -293,6 +368,10 @@ def _cleanup_video_references(
                 os.unlink(path)
     if control_path is not None and os.path.exists(control_path):
         os.unlink(control_path)
+    if latent_edit_input is not None:
+        for path in latent_edit_input.cleanup_paths:
+            if os.path.exists(path):
+                os.unlink(path)
 
 
 def _unpack_video_generation_result(
@@ -323,11 +402,12 @@ async def _run_video_generation_job(
     reference_audio: ReferenceAudio | None = None,
     control_path: str | None = None,
     app_state: Any | None = None,
+    latent_edit_input: LatentEditInput | None = None,
 ) -> None:
     job = await VIDEO_STORE.get(video_id)
     if job is None:
         logger.warning("Video job %s missing before generation task started; skipping", video_id)
-        _cleanup_video_references(reference_video, reference_audio, control_path)
+        _cleanup_video_references(reference_video, reference_audio, control_path, latent_edit_input)
         return
 
     started_at = time.perf_counter()
@@ -344,6 +424,7 @@ async def _run_video_generation_job(
                 reference_video=reference_video,
                 reference_audio=reference_audio,
                 on_started=_mark_started,
+                latent_edit_input=latent_edit_input,
             )
         )
 
@@ -403,7 +484,7 @@ async def _run_video_generation_job(
         await VIDEO_STORE.pop(video_id)
         raise
     finally:
-        _cleanup_video_references(reference_video, reference_audio, control_path)
+        _cleanup_video_references(reference_video, reference_audio, control_path, latent_edit_input)
 
 
 async def _persist_uploaded_video_references(uploads: list[UploadFile]) -> list[str]:
@@ -426,6 +507,47 @@ async def _persist_uploaded_video_references(uploads: list[UploadFile]) -> list[
     return paths
 
 
+async def _persist_uploaded_reference(
+    upload: UploadFile,
+    *,
+    field_name: str,
+    suffix: str,
+    max_bytes: int,
+) -> str:
+    """Stream one bounded upload to request-scoped local storage."""
+    declared_size = upload.size
+    if isinstance(declared_size, Integral) and int(declared_size) > max_bytes:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail=f"{field_name} exceeds the {max_bytes // (1024 * 1024)} MiB size limit.",
+        )
+
+    fd, path = tempfile.mkstemp(prefix=f"vllm_omni_{field_name}_", suffix=suffix)
+    size = 0
+    persisted = False
+    try:
+        with os.fdopen(fd, "wb") as output:
+            while chunk := await upload.read(min(1024 * 1024, max_bytes - size + 1)):
+                size += len(chunk)
+                if size > max_bytes:
+                    raise HTTPException(
+                        status_code=HTTPStatus.BAD_REQUEST.value,
+                        detail=f"{field_name} exceeds the {max_bytes // (1024 * 1024)} MiB size limit.",
+                    )
+                output.write(chunk)
+        if size == 0:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"{field_name} must not be empty.",
+            )
+        persisted = True
+        return path
+    finally:
+        if not persisted:
+            with suppress(OSError):
+                os.unlink(path)
+
+
 async def _persist_uploaded_control_reference(
     upload: UploadFile,
     *,
@@ -442,38 +564,70 @@ async def _persist_uploaded_control_reference(
         )
     if not suffix:
         suffix = ".png" if kind == "image" else ".mp4"
+    return await _persist_uploaded_reference(
+        upload,
+        field_name="control_reference",
+        suffix=suffix,
+        max_bytes=max_bytes,
+    )
 
-    declared_size = getattr(upload, "size", None)
-    if isinstance(declared_size, Integral) and int(declared_size) > max_bytes:
+
+async def _persist_latent_edit_source(
+    upload: UploadFile,
+    *,
+    field_name: Literal["source_video", "source_audio"],
+    max_bytes: int = LATENT_EDIT_SOURCE_MAX_BYTES,
+) -> str:
+    """Stream one latent-edit source upload to request-scoped storage."""
+    suffix = Path(upload.filename or "").suffix.lower()
+    if field_name == "source_video":
+        allowed_suffixes = MINIMAX_H3_REFERENCE_VIDEO_SUFFIXES
+        expected = "an MP4 or MOV file"
+    else:
+        allowed_suffixes = MINIMAX_H3_REFERENCE_AUDIO_SUFFIXES
+        expected = "a WAV or MP3 file"
+    if suffix not in allowed_suffixes:
         raise HTTPException(
             status_code=HTTPStatus.BAD_REQUEST.value,
-            detail=f"control_reference exceeds the {max_bytes // (1024 * 1024)} MiB size limit.",
+            detail=f"{field_name} must be {expected}.",
         )
 
-    fd, path = tempfile.mkstemp(prefix="vllm_omni_control_reference_", suffix=suffix)
-    size = 0
-    persisted = False
-    try:
-        with os.fdopen(fd, "wb") as output:
-            while chunk := await upload.read(min(1024 * 1024, max_bytes - size + 1)):
-                size += len(chunk)
-                if size > max_bytes:
-                    raise HTTPException(
-                        status_code=HTTPStatus.BAD_REQUEST.value,
-                        detail=f"control_reference exceeds the {max_bytes // (1024 * 1024)} MiB size limit.",
-                    )
-                output.write(chunk)
-        if size == 0:
-            raise HTTPException(
-                status_code=HTTPStatus.BAD_REQUEST.value,
-                detail="control_reference must not be empty.",
-            )
-        persisted = True
-        return path
-    finally:
-        if not persisted:
-            with suppress(OSError):
-                os.unlink(path)
+    return await _persist_uploaded_reference(
+        upload,
+        field_name=field_name,
+        suffix=suffix,
+        max_bytes=max_bytes,
+    )
+
+
+def _validate_latent_edit_inputs(
+    handler: OmniOpenAIServingVideo,
+    *,
+    source_video: UploadFile | None,
+    source_audio: UploadFile | None,
+    video_noise_mask: Any | None,
+    audio_noise_mask: Any | None,
+) -> bool:
+    """Validate cross-field latent-edit requirements before persisting files."""
+    has_any_input = any(value is not None for value in (source_video, source_audio, video_noise_mask, audio_noise_mask))
+    if not has_any_input:
+        return False
+    if not handler.supports_latent_mask_editing:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail="Latent-mask editing is not supported by this model.",
+        )
+    if video_noise_mask is None and audio_noise_mask is None:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail="Latent-mask editing requires at least one of video_noise_mask or audio_noise_mask.",
+        )
+    if source_audio is not None and audio_noise_mask is None:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail="source_audio requires an audio_noise_mask upload.",
+        )
+    return True
 
 
 def _validate_control_upload(
@@ -497,7 +651,7 @@ def _validate_control_upload(
         )
 
     normalized_type = control_type.strip().lower()
-    supported_types = frozenset(getattr(handler, "supported_control_upload_types", ()))
+    supported_types = handler.supported_control_upload_types
     if normalized_type not in supported_types:
         supported = ", ".join(sorted(supported_types)) or "none"
         raise HTTPException(
@@ -735,6 +889,10 @@ async def _parse_video_form(
     lora: str | None = Form(default=None),
     extra_params: str | None = Form(default=None),
     return_stage_metrics: bool | None = Form(default=None),
+    source_video: UploadFile | None = File(default=None),
+    source_audio: UploadFile | None = File(default=None),
+    video_noise_mask: UploadFile | None = File(default=None),
+    audio_noise_mask: UploadFile | None = File(default=None),
 ) -> tuple[
     VideoGenerationRequest,
     "OmniOpenAIServingVideo",
@@ -743,6 +901,7 @@ async def _parse_video_form(
     ReferenceVideo | None,
     ReferenceAudio | None,
     str | None,
+    LatentEditInput | None,
 ]:
     """FastAPI dependency that parses video form data, validates inputs,
     resolves the handler, and decodes any reference image.
@@ -754,6 +913,14 @@ async def _parse_video_form(
     parsed_image_reference = _parse_form_json(image_reference)
     parsed_video_reference = _parse_form_json(video_reference)
     parsed_audio_reference = _parse_form_json(audio_reference)
+    parsed_video_noise_mask = await _read_latent_edit_mask_json(
+        video_noise_mask,
+        field_name="video_noise_mask",
+    )
+    parsed_audio_noise_mask = await _read_latent_edit_mask_json(
+        audio_noise_mask,
+        field_name="audio_noise_mask",
+    )
 
     if input_references and any(
         item is not None for item in (parsed_image_reference, parsed_video_reference, input_reference)
@@ -838,6 +1005,14 @@ async def _parse_video_form(
             detail=f"Video generation setup failed: {str(e)}",
         )
 
+    has_latent_edit = _validate_latent_edit_inputs(
+        handler,
+        source_video=source_video,
+        source_audio=source_audio,
+        video_noise_mask=parsed_video_noise_mask,
+        audio_noise_mask=parsed_audio_noise_mask,
+    )
+
     normalized_control_type = _validate_control_upload(handler, request, control_reference, control_type)
     if normalized_control_type is not None:
         # Make the selected transfer mode visible while choosing the model's
@@ -845,7 +1020,7 @@ async def _parse_video_form(
         # until reference parsing succeeds, preserving failure cleanup.
         _attach_control_upload(request, normalized_control_type)
 
-    supports_mixed_reference_inputs = bool(getattr(handler, "supports_mixed_reference_inputs", False))
+    supports_mixed_reference_inputs = handler.supports_mixed_reference_inputs
     if input_reference is not None:
         input_reference_bytes = await _read_upload_limited(
             input_reference,
@@ -979,6 +1154,38 @@ async def _parse_video_form(
             _cleanup_video_references(reference_video, reference_audio, control_path)
             raise
 
+    latent_edit_input: LatentEditInput | None = None
+    if has_latent_edit:
+        source_paths: list[str] = []
+        try:
+            source_video_path = None
+            source_audio_path = None
+            if source_video is not None:
+                source_video_path = await _persist_latent_edit_source(
+                    source_video,
+                    field_name="source_video",
+                )
+                source_paths.append(source_video_path)
+            if source_audio is not None:
+                source_audio_path = await _persist_latent_edit_source(
+                    source_audio,
+                    field_name="source_audio",
+                )
+                source_paths.append(source_audio_path)
+            latent_edit_input = LatentEditInput(
+                source_video=source_video_path,
+                source_audio=source_audio_path,
+                video_noise_mask=parsed_video_noise_mask,
+                audio_noise_mask=parsed_audio_noise_mask,
+                cleanup_paths=tuple(source_paths),
+            )
+        except (asyncio.CancelledError, Exception):
+            for path in source_paths:
+                with suppress(OSError):
+                    os.unlink(path)
+            _cleanup_video_references(reference_video, reference_audio, control_path)
+            raise
+
     return (
         request,
         handler,
@@ -987,4 +1194,5 @@ async def _parse_video_form(
         reference_video,
         reference_audio,
         control_path,
+        latent_edit_input,
     )
diff --git a/vllm_omni/entrypoints/openpi/serving.py b/vllm_omni/entrypoints/openpi/serving.py
index 562ed70d4..450cfbb79 100644
--- a/vllm_omni/entrypoints/openpi/serving.py
+++ b/vllm_omni/entrypoints/openpi/serving.py
@@ -103,6 +103,14 @@ class ServingRealtimeRobotOpenPI:
             for stage_config in getattr(engine_client, "stage_configs", []) or []:
                 if getattr(stage_config, "stage_type", None) != "diffusion":
                     continue
+                # Typed diffusion stages keep model-owned OpenPI handshake
+                # metadata in diffusion_config.model_config. The out-of-process
+                # head only has this stage view because full od_config lives in
+                # the worker.
+                diffusion_config = getattr(stage_config, "diffusion_config", None)
+                model_config = getattr(diffusion_config, "model_config", None)
+                if model_config is not None:
+                    break
                 engine_args = getattr(stage_config, "engine_args", None)
                 model_config = getattr(engine_args, "model_config", None)
                 if model_config is not None:
@@ -186,6 +194,9 @@ class ServingRealtimeRobotOpenPI:
         # (e.g. a policy deploy yaml's ``extra_args``) and layer the OpenPI
         # protocol fields on top.
         seed = obs.pop("seed", None)
+        # Nested so engine knobs cannot collide with robot-defined obs keys.
+        sampling = obs.get("sampling_params") or {}
+        robot_obs = {key: value for key, value in obs.items() if key != "sampling_params"}
         sampling_params = OmniDiffusionSamplingParams()
         for default_params in get_default_sampling_params_list(self.engine_client):
             if isinstance(default_params, OmniDiffusionSamplingParams):
@@ -197,15 +208,16 @@ class ServingRealtimeRobotOpenPI:
             {
                 "reset": reset,
                 "session_id": session_id,
-                "robot_obs": obs,
+                "robot_obs": robot_obs,
             }
         )
 
         prompt = obs.get("prompt", "")
-        sampling_params = OmniDiffusionSamplingParams(
-            seed=int(seed) if seed is not None else None,
-            extra_args=extra_args,
-        )
+        if seed is not None:
+            sampling_params.seed = int(seed)
+        if "num_inference_steps" in sampling:
+            sampling_params.num_inference_steps = sampling["num_inference_steps"]
+        sampling_params.extra_args = extra_args
         return OmniDiffusionRequest(
             prompt=prompt,
             sampling_params=sampling_params,
diff --git a/vllm_omni/entrypoints/serve/profile/utils.py b/vllm_omni/entrypoints/serve/profile/utils.py
index f444a3534..d91ef2cad 100644
--- a/vllm_omni/entrypoints/serve/profile/utils.py
+++ b/vllm_omni/entrypoints/serve/profile/utils.py
@@ -4,18 +4,20 @@
 
 
 def _should_enable_profiler_endpoints(stage_configs: list | None) -> bool:
-    """Check if any stage has profiler_config set in its engine_args."""
+    """Check whether any typed or legacy stage enables a profiler."""
     if not stage_configs:
         return False
     for stage in stage_configs:
-        engine_args = stage.get("engine_args") if isinstance(stage, dict) else getattr(stage, "engine_args", None)
-        if engine_args is None:
-            continue
         profiler_config = (
-            engine_args.get("profiler_config")
-            if isinstance(engine_args, dict)
-            else getattr(engine_args, "profiler_config", None)
+            stage.get("profiler_config") if isinstance(stage, dict) else getattr(stage, "profiler_config", None)
         )
+        if profiler_config is None:
+            engine_args = stage.get("engine_args") if isinstance(stage, dict) else getattr(stage, "engine_args", None)
+            profiler_config = (
+                engine_args.get("profiler_config")
+                if isinstance(engine_args, dict)
+                else getattr(engine_args, "profiler_config", None)
+            )
         if profiler_config is not None:
             profiler = (
                 profiler_config.get("profiler")
diff --git a/vllm_omni/entrypoints/stage_utils.py b/vllm_omni/entrypoints/stage_utils.py
index 281cbc55c..8c2ba0747 100644
--- a/vllm_omni/entrypoints/stage_utils.py
+++ b/vllm_omni/entrypoints/stage_utils.py
@@ -1,7 +1,11 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from __future__ import annotations
 
 import logging
 import os
+from dataclasses import asdict, is_dataclass
 from multiprocessing import shared_memory as _shm
 from typing import Any
 
@@ -274,6 +278,8 @@ def _to_dict(x: Any) -> dict[str, Any]:
     try:
         if isinstance(x, dict):
             return dict(x)
+        if is_dataclass(x) and not isinstance(x, type):
+            return asdict(x)
         return _omega_to_dict(x)
     except Exception:
         try:
diff --git a/vllm_omni/entrypoints/utils.py b/vllm_omni/entrypoints/utils.py
index 39131fd58..c091ae5e8 100644
--- a/vllm_omni/entrypoints/utils.py
+++ b/vllm_omni/entrypoints/utils.py
@@ -4,12 +4,14 @@
 import json
 import os
 import types
-from dataclasses import fields, is_dataclass
+from collections.abc import Mapping
+from dataclasses import dataclass, fields, is_dataclass
 from typing import Any, get_args, get_origin
 
 from vllm.logger import init_logger
 from vllm.sampling_params import RequestOutputKind, SamplingParams
 
+from vllm_omni.config.config_factory import with_trust_remote_code_override
 from vllm_omni.entrypoints.stage_utils import _to_dict
 from vllm_omni.inputs.data import OmniSamplingParams
 
@@ -18,6 +20,13 @@ logger = init_logger(__name__)
 
 def inject_omni_kv_config(stage: Any, omni_conn_cfg: dict[str, Any], omni_from: str, omni_to: str) -> None:
     """Inject connector configuration into stage engine arguments."""
+    typed_connector_config = getattr(stage, "connector_config", None)
+    if typed_connector_config is not None:
+        omni_conf_dict = dict(typed_connector_config.omni_kv_config or {})
+        omni_conf_dict.update(connector_config=omni_conn_cfg, omni_from_stage=omni_from, omni_to_stage=omni_to)
+        typed_connector_config.omni_kv_config = omni_conf_dict
+        return
+
     # Prepare omni_kv_config dict
     omni_conf_dict = {}
     try:
@@ -79,6 +88,64 @@ def parse_stage_overrides(value: Any) -> dict[str, dict[str, Any]] | None:
     return parsed
 
 
+@dataclass(frozen=True)
+class StageConfigInputs:
+    """Normalized inputs shared by all stage-config loading paths."""
+
+    model: str
+    kwargs: dict[str, Any]
+    trust_remote_code: bool | None
+    deploy_config_path: str | None
+    stage_overrides: dict[str, dict[str, Any]] | None
+    strategy_config_path: str | None
+
+
+def prepare_stage_config_inputs(
+    model: str,
+    kwargs: Mapping[str, Any],
+    *,
+    trust_remote_code: bool | None,
+    snapshot_model: bool = False,
+) -> StageConfigInputs:
+    """Normalize model/config arguments before resolving stage configs.
+
+    The standard API worker, multi-API parent, and headless entrypoint must
+    apply the same legacy-key filtering, trust-remote-code precedence, and
+    config-file extraction before calling :func:`resolve_omni_config`.
+    """
+    resolved_model = model
+    if snapshot_model:
+        # Keep model materialization at the CLI boundary for the parent-owned
+        # launch path. The API worker's OmniBase has already done this work.
+        from vllm_omni.entrypoints.omni_base import omni_snapshot_download
+
+        resolved_model = omni_snapshot_download(model)
+
+    resolved_kwargs = dict(kwargs)
+    for legacy_arg in ("stage_configs_path", "stage_configs"):
+        if legacy_arg in resolved_kwargs:
+            raise ValueError(f"`{legacy_arg}` is no longer supported; use `deploy_config` instead.")
+    # Frontend process count is not a stage engine override.
+    resolved_kwargs.pop("api_server_count", None)
+    resolved_kwargs.pop("disable_log_stats", None)
+    if resolved_kwargs.get("diffusion_streaming_output") and resolved_kwargs.get("streaming_output") is None:
+        resolved_kwargs["streaming_output"] = True
+    resolved_kwargs.pop("model_tag", None)
+
+    resolved_kwargs = with_trust_remote_code_override(resolved_kwargs, trust_remote_code)
+    deploy_config_path = resolved_kwargs.pop("deploy_config", None)
+    strategy_config_path = resolved_kwargs.pop("strategy_config", None)
+    stage_overrides = parse_stage_overrides(resolved_kwargs.pop("stage_overrides", None))
+    return StageConfigInputs(
+        model=resolved_model,
+        kwargs=resolved_kwargs,
+        trust_remote_code=trust_remote_code,
+        deploy_config_path=deploy_config_path,
+        stage_overrides=stage_overrides,
+        strategy_config_path=strategy_config_path,
+    )
+
+
 def get_final_stage_id_for_e2e(
     output_modalities: list[str] | None, default_modalities: list[str], stage_list: list
 ) -> int:
diff --git a/vllm_omni/experimental/ar_diffusion/capability.py b/vllm_omni/experimental/ar_diffusion/capability.py
index 145261513..737487ff2 100644
--- a/vllm_omni/experimental/ar_diffusion/capability.py
+++ b/vllm_omni/experimental/ar_diffusion/capability.py
@@ -40,12 +40,18 @@ class ARDiffusionCrossAttentionKVSpec:
 
     name: str
     num_tokens: int
+    # Head count of this cross-attention cache. Cross-attention need not be sharded the same way as
+    # self-attention: a model whose cross-attention keeps every local head on every rank stores that many heads
+    # here instead of its self-attention share. None means "same as self-attention", the existing behaviour.
+    num_kv_heads: int | None = None
 
     def __post_init__(self) -> None:
         if not self.name:
             raise ValueError("AR-Diffusion cross-attention cache names must be non-empty")
         if self.num_tokens <= 0:
             raise ValueError(f"AR-Diffusion cross-attention num_tokens must be positive, got {self.num_tokens}")
+        if self.num_kv_heads is not None and self.num_kv_heads <= 0:
+            raise ValueError(f"AR-Diffusion cross-attention num_kv_heads must be positive, got {self.num_kv_heads}")
 
 
 @dataclass(frozen=True)
@@ -81,6 +87,7 @@ class ARDiffusionKVCacheSpec:
     sink_frames: int = 0
     reset_at_boundary: bool = False
     cross_attention: tuple[ARDiffusionCrossAttentionKVSpec, ...] = ()
+    # Initial vLLM storage horizon; extended to fit an in-flight span.
     max_model_len: int = 1 << 20
     max_scratch_tokens_per_branch: int = 0
     model_owned_state_bytes_per_session: int = 0
@@ -134,6 +141,11 @@ class ARDiffusionKVCacheSpec:
     def cross_attention_lengths(self) -> dict[str, int]:
         return {cache.name: cache.num_tokens for cache in self.cross_attention}
 
+    @property
+    def cross_attention_kv_heads(self) -> dict[str, int]:
+        """Per-cache head counts, for the caches that do not use the self-attention head count."""
+        return {cache.name: cache.num_kv_heads for cache in self.cross_attention if cache.num_kv_heads is not None}
+
 
 @runtime_checkable
 class SupportsARDiffusionPipeline(Protocol):
@@ -180,3 +192,12 @@ class SupportsARDiffusionWarmup(Protocol):
     def ar_diffusion_warmup_requests(self, session_id: str) -> Iterable[OmniDiffusionRequest]:
         """Yield requests for compiled shapes, each carrying ``session_id``."""
         ...
+
+
+def supports_chunk_step_grouping(pipeline: object) -> bool:
+    """Whether a step-execution ``pipeline`` declares that one chunk's steps may run without scheduler cycles.
+
+    An AR-runner policy input, consulted only after the pipeline has already been admitted to step
+    execution; LingBot-World declares it as a class attribute.
+    """
+    return bool(getattr(pipeline, "supports_chunk_step_grouping", False))
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/config.py b/vllm_omni/experimental/ar_diffusion/kv_cache/config.py
index ca91a8bb6..2d999bc24 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/config.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/config.py
@@ -1,10 +1,24 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Configuration for AR-Diffusion engine-level KV cache management."""
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
 
+KV_GATHER_ENV = "VLLM_OMNI_AR_DIFFUSION_KV_GATHER"
+
+
+def contiguous_kv_gather_enabled() -> bool:
+    """Whether the experimental contiguous-K/V gather attention path is on (``VLLM_OMNI_AR_DIFFUSION_KV_GATHER=1``).
+
+    The one place the switch is read: the KV manager consults it when it budgets and allocates the history
+    staging buffers, and the attention dispatch when it picks the path, so the two cannot disagree. It is the
+    only consumer of ``ARDiffusionKVConfig.reuse_history_staging``.
+    """
+    return os.environ.get(KV_GATHER_ENV, "0") == "1"
+
 
 @dataclass
 class ARDiffusionKVConfig:
@@ -30,6 +44,12 @@ class ARDiffusionKVConfig:
     # DiT graphs for every window-fill shape at load time via a synthetic rollout,
     # so the serving run is fast from the first chunk. No effect when eager.
     warmup_cudagraph: bool = True
+    # Keep one contiguous K/V staging buffer per layer and refresh only the tokens that changed.
+    # Within one AR block every forward attends the same history and differs only in the current
+    # chunk, so re-gathering the whole visible window per forward re-copies bytes that did not move.
+    # Off by default: it costs two max-sequence buffers per layer, per rank. See
+    # ARDiffusionPagedForwardContext.history_staging.
+    reuse_history_staging: bool = False
     # Also capture the post-window-boundary (reset-cycle) forward during warm-up.
     warmup_capture_reset: bool = False
 
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py b/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py
index f4cb416f6..efa5cc2c1 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py
@@ -15,6 +15,8 @@ from __future__ import annotations
 import inspect
 import os
 from collections.abc import Collection, Iterable, Sequence
+from dataclasses import dataclass
+from typing import Any, cast
 
 import torch
 from vllm.logger import init_logger
@@ -28,8 +30,13 @@ from vllm.v1.request import RequestStatus
 
 from vllm_omni.diffusion.diffusion_kv.layout import build_kv_cache_tensor
 from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
-from vllm_omni.experimental.ar_diffusion.kv_cache.config import ARDiffusionKVConfig
+from vllm_omni.experimental.ar_diffusion.kv_cache.config import (
+    KV_GATHER_ENV,
+    ARDiffusionKVConfig,
+    contiguous_kv_gather_enabled,
+)
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged import (
+    ChunkWindowManager,
     ChunkWindowSpec,
     allocate_kv_pool_with_views,
     chunk_slot_mapping,
@@ -49,10 +56,10 @@ class ARDiffusionRequestAdapter:
     real ``KVCacheManager`` against this adapter so the surface cannot silently
     drift across vLLM versions.
 
-    An AR-Diffusion request advances one *chunk* at a time: ``allocate_slots`` is called
-    once per chunk and ``num_computed_tokens`` advances only when a chunk is
-    committed (:meth:`on_chunk_committed`), so the ``T`` denoise steps of a chunk
-    reuse the same slots.
+    ``completed_chunks`` and ``absolute_num_computed_tokens`` track the model
+    timeline. vLLM sees compacted storage positions through ``num_computed_tokens``
+    and ``num_tokens``. A chunk's denoise steps reuse the same slots; only a
+    successful commit advances the timeline and compacts evicted metadata.
     """
 
     def __init__(
@@ -66,6 +73,7 @@ class ARDiffusionRequestAdapter:
         self._chunk_size = chunk_size
         self._prefill = prefill_prefix_tokens
         self._completed_chunks = 0
+        self.compacted_tokens = 0
         # Filled only when cross-request prefix reuse is enabled (Phase 3).
         self.block_hashes: list = []
         self.skip_reading_prefix_cache = True
@@ -79,14 +87,19 @@ class ARDiffusionRequestAdapter:
         self.num_in_flight_tokens = 0
 
     @property
-    def num_computed_tokens(self) -> int:
-        """Persistent KV already materialized (committed chunks + prefill)."""
+    def absolute_num_computed_tokens(self) -> int:
+        """Cumulative model position, unaffected by storage compaction."""
         return self._prefill + self._completed_chunks * self._chunk_size
 
+    @property
+    def num_computed_tokens(self) -> int:
+        """Committed position in the compact vLLM block table."""
+        return self.absolute_num_computed_tokens - self.compacted_tokens
+
     @property
     def num_tokens(self) -> int:
-        """Total tokens once the in-flight chunk is committed."""
-        return self._prefill + (self._completed_chunks + 1) * self._chunk_size
+        """Storage position once the in-flight chunk is committed."""
+        return self.num_computed_tokens + self._chunk_size
 
     @property
     def num_prompt_tokens(self) -> int:
@@ -150,6 +163,18 @@ def build_kv_manager(
     return KVCacheManager(config, **kwargs)
 
 
+@dataclass
+class HistoryStagingState:
+    """What the staged history window currently holds: whose session and which visible blocks.
+
+    Owned by the cache next to the buffers themselves; ``ARDiffusionPagedForwardContext`` reads it to decide
+    whether a forward may keep the staged history and writes back what it staged.
+    """
+
+    adapter: Any | None = None  # weakref to the session adapter the window was staged for
+    signature: tuple[Any, ...] | None = None
+
+
 class ARDiffusionKVCache:
     """Own the paged KV pool and KV-branch-local storage for one model.
 
@@ -172,6 +197,7 @@ class ARDiffusionKVCache:
         kv_branches: tuple[ARDiffusionKVBranchSpec, ...],
         session_capacity: int,
         cross_attention_lengths: dict[str, int] | None = None,
+        cross_attention_kv_heads: dict[str, int] | None = None,
         device: torch.device | None = None,
         frames_per_block: int = 1,
         max_scratch_tokens_per_branch: int = 0,
@@ -217,6 +243,18 @@ class ARDiffusionKVCache:
         self.head_size = head_size
         self.dtype = dtype
         self.cross_attention_lengths = dict(cross_attention_lengths or {})
+        # A cross-attention cache may hold more heads than the self-attention share: a model that keeps every
+        # local head on every rank, rather than sharding heads across the sequence-parallel group, stores the
+        # full local set here. Absent means the self-attention head count, which is what every caller did before.
+        self.cross_attention_kv_heads = {
+            name: int((cross_attention_kv_heads or {}).get(name, num_kv_heads)) for name in self.cross_attention_lengths
+        }
+        invalid_heads = {n: h for n, h in self.cross_attention_kv_heads.items() if h <= 0}
+        if invalid_heads:
+            raise ValueError(f"cross_attention_kv_heads must be positive, got {invalid_heads}")
+        unknown_heads = set(cross_attention_kv_heads or {}) - set(self.cross_attention_lengths)
+        if unknown_heads:
+            raise ValueError(f"cross_attention_kv_heads names unknown caches: {sorted(unknown_heads)}")
         invalid_cross = {name: length for name, length in self.cross_attention_lengths.items() if length <= 0}
         if invalid_cross:
             raise ValueError(f"cross_attention_lengths must be positive, got {invalid_cross}")
@@ -266,20 +304,46 @@ class ARDiffusionKVCache:
         self.scratch_reserved_bytes = self.scratch_num_blocks * page_size_bytes
         self.model_owned_state_bytes_per_session = model_owned_state_bytes_per_session
 
-        def _cross_pool_bytes(length: int) -> int:
-            return int(2 * len(self.kv_branches) * length * num_kv_heads * head_size * dtype.itemsize * num_layers)
+        def _cross_pool_bytes(length: int, heads: int) -> int:
+            return int(2 * len(self.kv_branches) * length * heads * head_size * dtype.itemsize * num_layers)
 
         self.cross_attention_bytes_per_session = sum(
-            _cross_pool_bytes(length) for length in self.cross_attention_lengths.values()
+            _cross_pool_bytes(length, self.cross_attention_kv_heads[name])
+            for name, length in self.cross_attention_lengths.items()
         )
 
         def _required_managed_blocks(capacity: int) -> int:
             resident_per_session = config.sink_chunks + config.window_chunks
             return self.num_local_kv_branches * (capacity * resident_per_session + self.frames_per_block) + 2
 
+        # reuse_history_staging keeps one contiguous K and V buffer per layer,
+        # sized to the padded visible window (sink + window plus the
+        # action-capacity block build_block_table always reserves), for the
+        # whole worker. It is allocated lazily on the first prepared forward,
+        # which is after admission, so it has to be reserved here or admission
+        # can succeed and that first forward run out of memory. Only the
+        # contiguous-gather attention path consumes it.
+        self.history_staging_reserved_bytes = 0
+        self.history_staging_tokens = 0
+        if config.reuse_history_staging:
+            if contiguous_kv_gather_enabled():
+                self.history_staging_tokens = (
+                    self.spec.sliding_window + config.sink_chunks * config.chunk_size + block_size
+                )
+                self.history_staging_reserved_bytes = int(
+                    2 * num_layers * self.history_staging_tokens * num_kv_heads * head_size * dtype.itemsize
+                )
+            else:
+                _log.warning(
+                    "reuse_history_staging is set but the contiguous K/V gather path (%s=1) is off: "
+                    "staging has no consumer and is neither budgeted nor allocated.",
+                    KV_GATHER_ENV,
+                )
+
         def _required_bytes(capacity: int) -> int:
             return (
                 self.scratch_reserved_bytes
+                + self.history_staging_reserved_bytes
                 + capacity * self.cross_attention_bytes_per_session
                 + capacity * self.model_owned_state_bytes_per_session
                 + _required_managed_blocks(capacity) * page_size_bytes
@@ -290,7 +354,7 @@ class ARDiffusionKVCache:
             raise ValueError(
                 "AR-Diffusion available device memory cannot fit one session: "
                 f"available={available_bytes} bytes, required={one_session_bytes} bytes "
-                "(managed self-attention + cross-attention + scratch + model-owned state)."
+                "(managed self-attention + cross-attention + scratch + model-owned state + K/V staging)."
             )
         self.memory_budget_bytes = max(self.configured_memory_budget_bytes, one_session_bytes)
         if self.memory_budget_bytes > self.configured_memory_budget_bytes:
@@ -317,6 +381,7 @@ class ARDiffusionKVCache:
         self_attn_budget_bytes = (
             self.memory_budget_bytes
             - self.scratch_reserved_bytes
+            - self.history_staging_reserved_bytes
             - self.cross_attention_reserved_bytes
             - self.model_owned_state_reserved_bytes
         )
@@ -366,6 +431,20 @@ class ARDiffusionKVCache:
                 dtype,
                 device,
             )
+        # reuse_history_staging: one contiguous (K, V) pair per layer, sized to the padded visible window this
+        # cache admits and budgeted above, owned here next to the pools it stages from. Allocated outside any
+        # capture and marked static, so compiled regions treat it as a stable input rather than a new tensor.
+        self.history_staging: list[tuple[torch.Tensor, torch.Tensor]] = []
+        self.history_staging_state = HistoryStagingState()
+        if self.history_staging_tokens and device is not None:
+            for _ in range(num_layers):
+                pair = (
+                    torch.empty((self.history_staging_tokens, num_kv_heads, head_size), device=device, dtype=dtype),
+                    torch.empty((self.history_staging_tokens, num_kv_heads, head_size), device=device, dtype=dtype),
+                )
+                for buffer in pair:
+                    torch._dynamo.mark_static_address(buffer)
+                self.history_staging.append(pair)
 
     # -- cross-attention pool access -------------------------------------------
     # Cross-attn KV is static once populated — write once (from text encoder),
@@ -447,7 +526,7 @@ class ARDiffusionKVCache:
         if not self._allocate_tensors:
             raise RuntimeError("AR-Diffusion cross-attention tensors require a configured pool device")
 
-        shape = (length, self.num_kv_heads, self.head_size)
+        shape = (length, self.cross_attention_kv_heads[cache_name], self.head_size)
         expected_input_shape = (1, *shape)
         k_pool = [torch.empty(shape, dtype=self.dtype, device=self.device) for _ in range(self.num_layers)]
         v_pool = [torch.empty(shape, dtype=self.dtype, device=self.device) for _ in range(self.num_layers)]
@@ -540,12 +619,9 @@ class ARDiffusionKVCache:
     def allocate_chunk(self, adapter: ARDiffusionRequestAdapter) -> list[int]:
         """Allocate a chunk's blocks (evicting out-of-window blocks first).
 
-        Returns the request's full block table (incl. null_block placeholders).
+        Returns the request's compact storage block table.
         """
-        blocks = self.manager.allocate_slots(adapter, num_new_tokens=self.spec.chunk_size)
-        if blocks is None:
-            raise RuntimeError("AR-Diffusion KV pool exhausted while allocating a chunk")
-        table = self.block_table(adapter)
+        table = self.allocate_token_slots(adapter, self.spec.chunk_size)
         resident = resident_block_ids(table, self.null_block_id)
         _log.debug(
             "AR-Diffusion allocate_chunk: req=%s chunk=%d table_len=%d resident=%d free=%d",
@@ -561,6 +637,10 @@ class ARDiffusionKVCache:
         """Allocate managed blocks for an in-flight video span without committing it."""
         if num_tokens <= 0:
             raise ValueError(f"num_tokens must be positive, got {num_tokens}")
+        # vLLM clips slot allocation at max_model_len. Admit the entire
+        # in-flight span in compact storage coordinates, independent of the
+        # model's absolute frame positions.
+        self.manager.max_model_len = max(self.manager.max_model_len, adapter.num_computed_tokens + num_tokens)
         blocks = self.manager.allocate_slots(adapter, num_new_tokens=num_tokens)
         if blocks is None:
             raise RuntimeError("AR-Diffusion KV pool exhausted while allocating paged attention slots")
@@ -618,6 +698,8 @@ class ARDiffusionKVCache:
             adapter.num_computed_tokens,
             num_prompt_tokens=adapter.num_prompt_tokens,
         )
+        window_manager = cast(ChunkWindowManager, self.manager.coordinator.single_type_managers[0])
+        adapter.compacted_tokens += window_manager.compact_block_table(adapter.request_id)
         _log.debug("AR-Diffusion commit: req=%s after=%d", adapter.request_id, adapter.completed_chunks)
 
     # -- pool-backed K/V access --------------------------------------------
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py b/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py
index ddc1937a2..0ef639c98 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py
@@ -115,11 +115,27 @@ def allocate_kv_pool_with_views(
     cache_shape = (num_blocks, block_size, num_kv_heads, head_dim)
     flat_shape = (num_blocks * block_size, num_kv_heads, head_dim)
     for _ in range(num_layers):
-        k = torch.empty(cache_shape, dtype=dtype, device=device)
-        v = torch.empty(cache_shape, dtype=dtype, device=device)
-        kv_pools.append([k, v])
-        k_pools.append(k.reshape(flat_shape))
-        v_pools.append(v.reshape(flat_shape))
+        # The flat slot views are what the paged-write custom op mutates inside the
+        # compiled block graphs, so they must be the *base* allocations: dynamo only
+        # honours mark_static_address on the tensor object it sees as a graph input,
+        # and a view of a static base is still classified as a mutated input, which
+        # makes inductor skip CUDA graphs for every block ("skipping cudagraphs due
+        # to mutated inputs"). The block-table layout is therefore the view here.
+        k = torch.empty(flat_shape, dtype=dtype, device=device)
+        v = torch.empty(flat_shape, dtype=dtype, device=device)
+        for pool in (k, v):
+            # Block 0 is the manager's null block: block tables are tail-padded with
+            # it and it is never written. The contiguous-K/V gather path may read
+            # (masked) rows from it, so it must hold finite values; every other
+            # block is fully written before it is read.
+            pool[:block_size].zero_()
+            # Session-lifetime storage: tell dynamo/inductor the address is static so
+            # CUDA-graph trees (mode="reduce-overhead") mutate it in place instead of
+            # copying ~300 MB per layer per replay (or skipping the graph).
+            torch._dynamo.mark_static_address(pool)
+        kv_pools.append([k.view(cache_shape), v.view(cache_shape)])
+        k_pools.append(k)
+        v_pools.append(v)
     return kv_pools, k_pools, v_pools
 
 
@@ -197,6 +213,28 @@ class ChunkWindowManager(SlidingWindowManager):
             reset_at_boundary=spec.reset_at_boundary,
         )
 
+    def compact_block_table(self, request_id: str) -> int:
+        """Remove the evicted gap after the sink; return its size in tokens.
+
+        Call only after commit/eviction, then shift the request's storage
+        position by the returned amount. Physical pages and model positions
+        are unchanged, including any allocated but not yet committed tail.
+        """
+        if self.enable_caching:
+            raise RuntimeError("AR block-table compaction requires prefix caching to be disabled")
+        blocks = self.req_to_blocks.get(request_id, [])
+        start = self.kv_cache_spec.sink_chunks
+        end = start
+        while end < len(blocks) and blocks[end] == self._null_block:
+            end += 1
+        if end == start:
+            return 0
+        del blocks[start:end]
+        if request_id in self.num_cached_block:
+            cached = self.num_cached_block[request_id]
+            self.num_cached_block[request_id] = min(cached, start) + max(0, cached - end)
+        return (end - start) * self.block_size
+
     def remove_skipped_blocks(
         self,
         request_id: str,
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py b/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py
index b2e19a95f..92b12f57c 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py
@@ -1,13 +1,16 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Paged self-attention helpers for AR-Diffusion KV reuse."""
 
 from __future__ import annotations
 
+import weakref
 from dataclasses import dataclass, field
 from typing import Any, ClassVar, NamedTuple
 
 import torch
 
+from vllm_omni.experimental.ar_diffusion.kv_cache.config import contiguous_kv_gather_enabled
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged import compute_slot_mapping
 
 _LAYER_IDX_TENSORS: dict[int, torch.Tensor] = {}
@@ -21,6 +24,19 @@ def _layer_idx_tensor(layer_idx: int) -> torch.Tensor:
     return t
 
 
+def _to_device_async(t: torch.Tensor, device: torch.device) -> torch.Tensor:
+    """Host->device copy that does not stall the CPU.
+
+    ``tensor.to(device)`` from pageable memory is synchronous: the CPU blocks until
+    every kernel already queued on the stream has finished. Pinned + non_blocking
+    keeps the CPU running ahead (the caching host allocator keeps the pinned
+    source alive until the copy's stream event completes).
+    """
+    if torch.device(device).type != "cuda" or t.device.type != "cpu":
+        return t.to(device=device)
+    return t.pin_memory().to(device=device, non_blocking=True)
+
+
 class ARDiffusionPagedLayerInputs(NamedTuple):
     """Compiled-region payload for one layer's paged self-attention.
 
@@ -48,6 +64,14 @@ class ARDiffusionPagedLayerInputs(NamedTuple):
     seq_lens: torch.Tensor
     max_query_len: int
     max_seq_len: int
+    # Contiguous K/V staging for this layer, when reuse_history_staging is on. ``reuse_history`` is a host
+    # bool decided once per forward (``_prepare_history_staging``): it selects one of two compiled variants.
+    stage_key: torch.Tensor | None = None
+    stage_value: torch.Tensor | None = None
+    reuse_history: bool = False
+    # Index of the current chunk's first block within the staged window: right after the visible history,
+    # which is not the end of the padded block table (that carries at least one action-capacity block).
+    stage_first_block: int = 0
 
 
 @dataclass
@@ -104,15 +128,15 @@ class ARDiffusionPagedForwardContext:
             start_block = start // self.block_size
             self.current_video_block_ids = [int(b) for b in table[start_block : start_block + n_blocks]]
             positions = torch.arange(start, start + self.seq_len, dtype=torch.long)
-            self.current_video_slot_mapping = compute_slot_mapping(table, positions, self.block_size).to(device=device)
+            self.current_video_slot_mapping = _to_device_async(
+                compute_slot_mapping(table, positions, self.block_size), device
+            )
         else:
             self.current_video_block_ids = self.kv_cache.scratch_block_ids(self.kv_branch, 0, n_blocks)
             positions = torch.arange(self.seq_len, dtype=torch.long)
-            self.current_video_slot_mapping = compute_slot_mapping(
-                self.current_video_block_ids,
-                positions,
-                self.block_size,
-            ).to(device=device)
+            self.current_video_slot_mapping = _to_device_async(
+                compute_slot_mapping(self.current_video_block_ids, positions, self.block_size), device
+            )
         self._allocated_video = True
 
     def ensure_action_slots(self, action_len: int, device: torch.device) -> None:
@@ -135,11 +159,9 @@ class ARDiffusionPagedForwardContext:
             action_blocks,
         )
         positions = torch.arange(action_len, dtype=torch.long)
-        self.action_slot_mapping = compute_slot_mapping(
-            self.action_scratch_block_ids,
-            positions,
-            self.block_size,
-        ).to(device=device)
+        self.action_slot_mapping = _to_device_async(
+            compute_slot_mapping(self.action_scratch_block_ids, positions, self.block_size), device
+        )
         self._action_len = action_len
 
     def video_block_table(self, device: torch.device) -> tuple[list[int], int]:
@@ -192,9 +214,12 @@ class ARDiffusionPagedForwardContext:
         self.query_len = int(query_len)
         self.kv_len = int(video_len + action_len)
         max_seq_len = int(self.max_video_tokens + action_capacity_blocks * self.block_size)
-        block_table = torch.tensor([padded], dtype=torch.int32, device=device)
-        query_start_loc = torch.tensor([0, self.query_len], dtype=torch.int32, device=device)
-        seq_lens = torch.tensor([self.kv_len], dtype=torch.int32, device=device)
+        # Built on the host once per AR block; the copies go through the same
+        # pinned, non-blocking path as the slot mappings above so the CPU does
+        # not wait for the stream to drain three times before the first layer.
+        block_table = _to_device_async(torch.tensor([padded], dtype=torch.int32), device)
+        query_start_loc = _to_device_async(torch.tensor([0, self.query_len], dtype=torch.int32), device)
+        seq_lens = _to_device_async(torch.tensor([self.kv_len], dtype=torch.int32), device)
         return block_table, query_start_loc, seq_lens, self.query_len, max_seq_len
 
     def prepare(self, device: torch.device, action_len: int, query_len: int) -> None:
@@ -218,15 +243,71 @@ class ARDiffusionPagedForwardContext:
         ) = self.build_block_table(action_len=action_len, query_len=query_len, device=device)
         if self.action_slot_mapping is None:
             self.action_slot_mapping = torch.empty(0, dtype=torch.long, device=device)
+        self._prepare_history_staging(action_len)
         self._prepared = True
 
+    def _prepare_history_staging(self, action_len: int) -> None:
+        """Decide whether this forward can keep the history already staged, and from where.
+
+        The staged window is only reusable when nothing about it moved: the same session adapter, the same
+        visible history blocks, the same sequence bounds. Any difference -- a new AR block, a slid window, a
+        different request -- and the buffer is rebuilt from the pools.
+
+        The decision is a host bool, deliberately. It has to be, for the gather to actually be skipped: a
+        device flag could only select between two results already computed. It is the same value for all
+        layers of a forward, so it costs two compiled variants in total rather than one per layer.
+        """
+        self.staging_enabled = False
+        self.reuse_history = False
+        self.stage_first_block = 0
+        # The manager allocates the staging pairs only when reuse_history_staging is on and the contiguous
+        # gather path -- their only consumer -- is switched on.
+        if not self.kv_cache.history_staging:
+            return
+        if action_len or self.block_table.shape[0] != 1:
+            # Action tokens live in scratch blocks outside the video window; staging them is not modelled.
+            return
+        capacity = int(self.kv_cache.history_staging[0][0].shape[0])
+        if int(self.max_seq_len) > capacity:
+            raise RuntimeError(
+                f"history staging buffers hold {capacity} tokens but this forward stages {int(self.max_seq_len)}"
+            )
+        state = self.kv_cache.history_staging_state
+        signature = (
+            int(self.adapter.num_computed_tokens),
+            tuple(self.history_block_ids),
+            int(self.max_seq_len),
+            int(self.seq_len),
+        )
+        same_session = state.adapter is not None and state.adapter() is self.adapter
+        reuse = same_session and state.signature == signature
+        state.adapter = weakref.ref(self.adapter)
+        state.signature = signature
+        self.staging_enabled = True
+        self.reuse_history = bool(reuse)
+        # ``kv_len`` is the visible video window here (no action tokens on this path): the current chunk's
+        # blocks are its last ``num_current_video_blocks`` entries, and the table's trailing padding blocks
+        # come after them.
+        self.stage_first_block = self.kv_len // self.block_size - self.num_current_video_blocks
+
+    def history_staging(self, layer_idx: int) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+        """This layer's staging pair, narrowed to this forward's staged window (a prefix of the manager's buffer)."""
+        if not self.staging_enabled:
+            return None, None
+        key, value = self.kv_cache.history_staging[layer_idx]
+        tokens = int(self.max_seq_len)
+        return key[:tokens], value[:tokens]
+
     def layer_inputs(self, layer_idx: int) -> ARDiffusionPagedLayerInputs:
         if not getattr(self, "_prepared", False):
             raise RuntimeError("ARDiffusionPagedForwardContext.layer_inputs() before prepare()")
+        key_pool = self.kv_cache._k_pools[layer_idx]
+        value_pool = self.kv_cache._v_pools[layer_idx]
+        stage_key, stage_value = self.history_staging(layer_idx)
         return ARDiffusionPagedLayerInputs(
             layer_idx=_layer_idx_tensor(layer_idx),
-            key_pool=self.kv_cache._k_pools[layer_idx],
-            value_pool=self.kv_cache._v_pools[layer_idx],
+            key_pool=key_pool,
+            value_pool=value_pool,
             block_size=int(self.kv_cache.block_size),
             seq_len=int(self.seq_len),
             video_slots=self.current_video_slot_mapping,
@@ -236,6 +317,10 @@ class ARDiffusionPagedForwardContext:
             seq_lens=self.seq_lens,
             max_query_len=int(self.max_query_len),
             max_seq_len=int(self.max_seq_len),
+            stage_key=stage_key,
+            stage_value=stage_value,
+            reuse_history=self.reuse_history,
+            stage_first_block=int(self.stage_first_block),
         )
 
     def mark_committed(self) -> None:
@@ -342,6 +427,23 @@ def _reference_paged_attention(
 _FA_VERSION_BY_HEAD_SIZE: dict[int, int] = {}
 
 
+def _stage_window(stage_key, stage_value, key_cache, value_cache, block_ids, n_blocks, block_size, *, first_block):
+    """Gather visible blocks from ``first_block`` onward into the staging buffers.
+
+    ``first_block`` is 0 for a full restage and the index of the current chunk's first block when the
+    history is already staged. Skipping the leading blocks is the whole point: they were gathered by an
+    earlier forward of the same AR block and cannot have changed since.
+    """
+    ids = block_ids[first_block:]
+    blocks = n_blocks - first_block
+    stage_key.view(n_blocks, block_size, *key_cache.shape[2:])[first_block:].copy_(
+        key_cache.index_select(0, ids).view(blocks, block_size, *key_cache.shape[2:])
+    )
+    stage_value.view(n_blocks, block_size, *value_cache.shape[2:])[first_block:].copy_(
+        value_cache.index_select(0, ids).view(blocks, block_size, *value_cache.shape[2:])
+    )
+
+
 def _resolve_fa_version(head_size: int) -> int:
     # get_flash_attn_version -> current_platform.get_device_capability() is not
     # dynamo-traceable, and the answer is fixed per head size for the process.
@@ -385,6 +487,11 @@ def ar_diffusion_paged_attention(
     max_seq_len: int,
     softmax_scale: float,
     causal: bool = False,
+    stage_key: torch.Tensor | None = None,
+    stage_value: torch.Tensor | None = None,
+    reuse_history: bool = False,
+    current_tokens: int = 0,
+    stage_first_block: int = 0,
 ) -> torch.Tensor:
     """Run non-causal paged attention over a vLLM block table.
 
@@ -437,6 +544,82 @@ def ar_diffusion_paged_attention(
             softmax_scale=float(softmax_scale),
             causal=causal,
         )
+    elif contiguous_kv_gather_enabled() and block_table.shape[0] == 1:
+        # Experimental (VLLM_OMNI_AR_DIFFUSION_KV_GATHER=1): FA3's paged-KV path with the
+        # frame-sized block (1560 tokens, not a multiple of the FA3 K/V tile)
+        # runs ~15-17% slower than the same kernel on contiguous K/V. Gather the
+        # visible blocks into a contiguous buffer once per layer and attend
+        # without a block table; ``seqused_k`` masks the tail-padding block.
+        from vllm.vllm_flash_attn import flash_attn_varlen_func
+
+        fa_version = _resolve_fa_version(query_flat.shape[-1])
+        block_size = key_cache.shape[1]
+        n_blocks = int(max_seq_len) // block_size
+        if n_blocks * block_size != int(max_seq_len):
+            raise ValueError("the contiguous K/V gather path requires max_seq_len to be block-aligned")
+        block_ids = block_table[0, :n_blocks].to(torch.long)
+        if stage_key is None or stage_value is None:
+            # Fresh allocations on purpose: a module-level cached buffer that is first
+            # allocated inside a CUDA-graph-trees warm-up run lives in the graph pool
+            # untracked ("tensor(s) in the cudagraph pool not tracked as outputs").
+            k_buf = key_cache.index_select(0, block_ids)
+            v_buf = value_cache.index_select(0, block_ids)
+            k_flat = k_buf.view(n_blocks * block_size, *key_cache.shape[2:])
+            v_flat = v_buf.view(n_blocks * block_size, *value_cache.shape[2:])
+        else:
+            # Caller-owned staging, allocated outside any capture and marked static, so the buffer this
+            # writes into is the same address every forward and the graph pool never owns it.
+            #
+            # Only the current chunk moved. The block table is the visible history followed by the
+            # current chunk's blocks and then padding (at least the action-capacity block, plus unused
+            # window capacity while the window is still growing), so the rows this forward changed start
+            # at ``stage_first_block`` -- the caller's count of visible history blocks -- and NOT at
+            # ``n_blocks - current_blocks``, which would refresh padding and leave the current K/V stale.
+            # Everything before them was staged by an earlier forward of the same AR block and is still
+            # byte-for-byte what a full gather would produce. When the history did move -- new block,
+            # slid window, different session -- reuse_history is 0 and the whole window is re-gathered,
+            # which is the same work the unstaged path always does.
+            k_flat = stage_key
+            v_flat = stage_value
+            if reuse_history:
+                # The caller's metadata must describe a block-aligned current chunk inside the staged
+                # window; anything else is a wrong offset, not a reason to quietly restage everything.
+                current_blocks = current_tokens // block_size
+                assert current_tokens > 0 and current_blocks * block_size == current_tokens, (
+                    f"staged reuse needs a block-aligned current chunk, got {current_tokens} tokens"
+                )
+                assert 0 <= stage_first_block and stage_first_block + current_blocks <= n_blocks, (
+                    f"stage_first_block={stage_first_block} + {current_blocks} blocks "
+                    f"exceeds the {n_blocks}-block window"
+                )
+            _stage_window(
+                k_flat,
+                v_flat,
+                key_cache,
+                value_cache,
+                block_ids,
+                n_blocks,
+                block_size,
+                first_block=stage_first_block if reuse_history else 0,
+            )
+        out = torch.empty_like(query_flat)
+        # Varlen K/V: cu_seqlens_k = [0, kv_len] built on device from seq_lens
+        # (no host sync). Rows past kv_len (the tail-padding block) are never
+        # read, exactly like the ROCm gather path above.
+        cu_seqlens_k = torch.cat((seq_lens.new_zeros(1), seq_lens.to(torch.int32)))
+        flash_attn_varlen_func(
+            q=query_flat,
+            k=k_flat,
+            v=v_flat,
+            out=out,
+            cu_seqlens_q=query_start_loc,
+            max_seqlen_q=int(max_query_len),
+            cu_seqlens_k=cu_seqlens_k,
+            max_seqlen_k=int(max_seq_len),
+            softmax_scale=float(softmax_scale),
+            causal=causal,
+            fa_version=fa_version,
+        )
     else:
         from vllm.vllm_flash_attn import flash_attn_varlen_func
 
@@ -488,6 +671,10 @@ def _paged_write_attn_impl(
     max_query_len: int,
     max_seq_len: int,
     softmax_scale: float,
+    stage_key: torch.Tensor | None = None,
+    stage_value: torch.Tensor | None = None,
+    reuse_history: bool = False,
+    stage_first_block: int = 0,
 ) -> torch.Tensor:
     key_pool[video_slots] = k_curr.to(key_pool.dtype)
     value_pool[video_slots] = v_curr.to(value_pool.dtype)
@@ -507,16 +694,23 @@ def _paged_write_attn_impl(
         max_seq_len=max_seq_len,
         softmax_scale=softmax_scale,
         causal=False,
+        stage_key=stage_key,
+        stage_value=stage_value,
+        reuse_history=reuse_history,
+        current_tokens=int(k_curr.shape[0]),
+        stage_first_block=stage_first_block,
     )
 
 
 # hasattr guard keeps registration idempotent across test re-imports that pop
 # the module from sys.modules (same as sage_attn3.py).
 if not hasattr(torch.ops.vllm_omni, "ar_diffusion_paged_write_attn"):
-
+    # Keep staging arguments required even when their value is None. The dispatcher
+    # strips trailing defaults, and older PyTorch mutation handlers index the
+    # positional arguments without restoring them before bumping version counters.
     @torch.library.custom_op(
         "vllm_omni::ar_diffusion_paged_write_attn",
-        mutates_args=("key_pool", "value_pool"),
+        mutates_args=("key_pool", "value_pool", "stage_key", "stage_value"),
     )
     def _paged_write_attn_op(
         query: torch.Tensor,
@@ -535,6 +729,10 @@ if not hasattr(torch.ops.vllm_omni, "ar_diffusion_paged_write_attn"):
         max_query_len: int,
         max_seq_len: int,
         softmax_scale: float,
+        stage_key: torch.Tensor | None,
+        stage_value: torch.Tensor | None,
+        reuse_history: bool,
+        stage_first_block: int,
     ) -> torch.Tensor:
         return _paged_write_attn_impl(
             query,
@@ -553,6 +751,10 @@ if not hasattr(torch.ops.vllm_omni, "ar_diffusion_paged_write_attn"):
             max_query_len,
             max_seq_len,
             softmax_scale,
+            stage_key,
+            stage_value,
+            reuse_history,
+            stage_first_block,
         )
 
     @_paged_write_attn_op.register_fake
@@ -573,6 +775,10 @@ if not hasattr(torch.ops.vllm_omni, "ar_diffusion_paged_write_attn"):
         max_query_len,
         max_seq_len,
         softmax_scale,
+        stage_key=None,
+        stage_value=None,
+        reuse_history=False,
+        stage_first_block=0,
     ):
         return torch.empty_like(query)
 
@@ -598,4 +804,8 @@ def paged_write_attn(
         inputs.max_query_len,
         inputs.max_seq_len,
         softmax_scale,
+        inputs.stage_key,
+        inputs.stage_value,
+        inputs.reuse_history,
+        inputs.stage_first_block,
     )
diff --git a/vllm_omni/experimental/ar_diffusion/runner.py b/vllm_omni/experimental/ar_diffusion/runner.py
index 23da43054..858cf843d 100644
--- a/vllm_omni/experimental/ar_diffusion/runner.py
+++ b/vllm_omni/experimental/ar_diffusion/runner.py
@@ -14,13 +14,14 @@ from vllm.logger import init_logger
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.models.interface import supports_step_execution
 from vllm_omni.diffusion.request import OmniDiffusionRequest
-from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput, KVPrefetchJob
+from vllm_omni.diffusion.sched.interface import CachedRequestData, DiffusionSchedulerOutput, KVPrefetchJob
 from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
 from vllm_omni.diffusion.worker.utils import BatchRunnerOutput
 from vllm_omni.experimental.ar_diffusion.capability import (
     ARDiffusionKVCacheSpec,
     SupportsARDiffusionPipeline,
     SupportsARDiffusionWarmup,
+    supports_chunk_step_grouping,
 )
 from vllm_omni.experimental.ar_diffusion.kv_cache.config import ARDiffusionKVConfig
 from vllm_omni.experimental.ar_diffusion.kv_cache.manager import ARDiffusionKVCache
@@ -93,9 +94,9 @@ class ARDiffusionModelRunner(DiffusionModelRunner):
             self._warmup_ar_rollout()
 
     def _available_memory_bytes(self) -> int:
-        if self.device is None or torch.device(self.device).type != "cuda":
-            raise RuntimeError("AR-Diffusion KV preallocation currently requires a CUDA device")
-        return int(torch.cuda.mem_get_info(self.device)[0])
+        if self.device is None:
+            raise RuntimeError("AR-Diffusion KV preallocation requires an initialized device")
+        return current_omni_platform.get_free_memory(torch.device(self.device))
 
     def _preallocate_kv_cache(self, *, available_bytes: int | None = None) -> None:
         """Build pools solely from the pipeline capability and runner config."""
@@ -144,6 +145,7 @@ class ARDiffusionModelRunner(DiffusionModelRunner):
             kv_branches=spec.kv_branches,
             session_capacity=spec.session_capacity,
             cross_attention_lengths=spec.cross_attention_lengths,
+            cross_attention_kv_heads=spec.cross_attention_kv_heads,
             frames_per_block=spec.frames_per_block,
             max_scratch_tokens_per_branch=spec.max_scratch_tokens_per_branch,
             model_owned_state_bytes_per_session=spec.model_owned_state_bytes_per_session,
@@ -163,7 +165,10 @@ class ARDiffusionModelRunner(DiffusionModelRunner):
             config.window_chunks,
             config.sink_chunks,
             [(kv_branch.name, kv_branch.local_index) for kv_branch in spec.kv_branches],
-            spec.cross_attention_lengths,
+            {
+                name: (length, spec.cross_attention_kv_heads.get(name, spec.num_kv_heads))
+                for name, length in spec.cross_attention_lengths.items()
+            },
             self._session_capacity,
             spec.session_capacity,
         )
@@ -338,6 +343,90 @@ class ARDiffusionModelRunner(DiffusionModelRunner):
             "ARDiffusionModelRunner does not support request-batch execution; use request mode with max_num_seqs=1."
         )
 
+    def _groups_chunk_steps(self, scheduler_output: DiffusionSchedulerOutput) -> bool:
+        """Policy: does this stepwise call run the scheduled request's chunk to its boundary?
+
+        Only on the realtime AR path, for a lone streaming request of a
+        pipeline that declares ``supports_chunk_step_grouping``. The session's
+        KV is bound for the whole call and the scheduler regains control at
+        every chunk boundary, which is where this path's interactions are
+        applied anyway; what it gives up is the chance to act between two
+        steps of one chunk.
+        """
+        return (
+            bool(self.od_config.streaming_output)
+            and len(scheduler_output.scheduled_request_ids) == 1
+            and supports_chunk_step_grouping(self.pipeline)
+        )
+
+    def _execute_stepwise_core(
+        self,
+        scheduler_output: DiffusionSchedulerOutput,
+        *,
+        record_output_peak_memory: bool,
+        in_diffusion_kv_memory_profile: bool = False,
+    ) -> BatchRunnerOutput:
+        """Run the shared single-step core once, or repeatedly until the chunk boundary.
+
+        The shared runner keeps its one-step-per-call semantics. When the
+        grouping policy applies, the remaining steps of the request's current
+        chunk are driven from here with a continuation of the scheduler
+        output: the request is presented as a cached request, with nothing
+        new to admit, nothing to retire and no connector work, so every
+        further step is exactly what the next scheduler cycle would have
+        asked for. Grouping the probes and the commit of one block this way
+        drops the scheduler/executor round trips between them.
+
+        The loop stops at the first call that emits a result (a chunk or an
+        error), finishes the request, or leaves it without state; the base
+        core already handles a mid-chunk failure or interrupt by finishing
+        the request with an error and dropping its state.
+        """
+        output = super()._execute_stepwise_core(
+            scheduler_output,
+            record_output_peak_memory=record_output_peak_memory,
+            in_diffusion_kv_memory_profile=in_diffusion_kv_memory_profile,
+        )
+        if not self._groups_chunk_steps(scheduler_output):
+            return output
+        request_id = scheduler_output.scheduled_request_ids[0]
+        continuation = dataclasses.replace(
+            scheduler_output,
+            scheduled_new_reqs=[],
+            scheduled_cached_reqs=CachedRequestData(request_ids=[request_id]),
+            finished_req_ids=set(),
+            kv_prefetch_job=None,
+            kv_connector_metadata=None,
+        )
+        if not self._chunk_step_pending(output, request_id):
+            return output
+        max_steps = self.state_cache[request_id].chunk_num_steps
+        if max_steps is None:
+            return output
+        steps = 1
+        while self._chunk_step_pending(output, request_id):
+            if steps >= max_steps:
+                self.state_cache.pop(request_id)
+                runner_output = output.get_request_output(request_id)
+                assert runner_output is not None
+                runner_output.finished = True
+                runner_output.result = DiffusionOutput(error=f"Chunk did not complete within {max_steps} denoise steps")
+                break
+            steps += 1
+            output = super()._execute_stepwise_core(
+                continuation,
+                record_output_peak_memory=record_output_peak_memory,
+                in_diffusion_kv_memory_profile=in_diffusion_kv_memory_profile,
+            )
+        return output
+
+    def _chunk_step_pending(self, output: BatchRunnerOutput, request_id: str) -> bool:
+        """More steps of the request's current chunk remain after ``output``."""
+        runner_output = output.get_request_output(request_id)
+        if runner_output is None or runner_output.finished or runner_output.result is not None:
+            return False
+        return request_id in self.state_cache
+
     def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> BatchRunnerOutput:
         """Bind runner-owned KV for one stepwise invocation, then inherit the step loop."""
         pipeline = getattr(self, "pipeline", None)
diff --git a/vllm_omni/metrics/stat_logger.py b/vllm_omni/metrics/stat_logger.py
index 9f8dc14b1..c0d5fde62 100644
--- a/vllm_omni/metrics/stat_logger.py
+++ b/vllm_omni/metrics/stat_logger.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """OmniPrometheusStatLogger — wrap upstream PrometheusStatLogger.
 
 Rewrites the upstream ``engine`` single-label scheme into a ``stage`` +
@@ -21,8 +24,9 @@ Contents:
 from __future__ import annotations
 
 from prometheus_client import Counter, Gauge, Histogram
+from prometheus_client.metrics import MetricWrapperBase
 from vllm.config import VllmConfig
-from vllm.distributed.kv_transfer.kv_connector.v1.metrics import KVConnectorProm
+from vllm.distributed.kv_transfer.kv_connector.v1.metrics import KVConnectorProm, KVConnectorPromMetrics
 from vllm.v1.metrics.loggers import PrometheusStatLogger
 from vllm.v1.metrics.perf import PerfMetricsProm
 from vllm.v1.spec_decode.metrics import SpecDecodingProm
@@ -73,7 +77,7 @@ def _engine_to_stage_replica(engine_value) -> tuple[str, str]:
     return _ENGINE_INDEX_MAP[key]
 
 
-class _RelabelMixin:
+class _RelabelMixin(MetricWrapperBase):
     """Mixin: rewrite ``labelnames`` at family creation and ``.labels()`` calls.
 
     Handles all four upstream forms encountered in
@@ -89,6 +93,8 @@ class _RelabelMixin:
     class slots.
     """
 
+    _omni_parent: MetricWrapperBase
+
     def __init__(self, *args, **kwargs):
         # Remember where `engine` sat in the original labelnames so positional
         # `.labels()` calls can splice (stage, replica) at the right offset.
@@ -120,7 +126,9 @@ class _RelabelMixin:
                 #     len(args) is short by 1 — splice (stage, replica)
                 #     in place of the engine value at engine_label_index.
                 if len(args) == len(self._labelnames):
-                    return super().labels(*args, **kwargs)
+                    child = super().labels(*args, **kwargs)
+                    child._omni_parent = self
+                    return child
                 idx = self._engine_label_index
                 if idx < len(args):
                     stage, replica = _engine_to_stage_replica(args[idx])
@@ -129,7 +137,39 @@ class _RelabelMixin:
                 stage, replica = _engine_to_stage_replica(kwargs.pop("engine"))
                 kwargs["stage"] = stage
                 kwargs["replica"] = replica
-        return super().labels(*args, **kwargs)
+        child = super().labels(*args, **kwargs)
+        child._omni_parent = self
+        return child
+
+
+def _extend_metric_maps(value: object, engine_idx: int, stage: str, replica: str) -> None:
+    """Bind new children in upstream's per-engine metric tables.
+
+    Nested tables keep extra labels such as finish reason or token source.
+    Reuse their existing family rather than rebuilding collectors, which
+    would unregister metrics and reset counters for the running replicas.
+    """
+    if isinstance(value, dict):
+        template = next(iter(value.values()), None)
+        if isinstance(template, _RelabelMixin) and "stage" in template._labelnames:
+            labels = dict(zip(template._labelnames, template._labelvalues))
+            labels.update(stage=stage, replica=replica)
+            value[engine_idx] = template._omni_parent.labels(**labels)
+        elif isinstance(template, list) and template and all(isinstance(item, _RelabelMixin) for item in template):
+            value[engine_idx] = [
+                item._omni_parent.labels(
+                    **(dict(zip(item._labelnames, item._labelvalues)) | {"stage": stage, "replica": replica})
+                )
+                for item in template
+            ]
+        else:
+            for child in value.values():
+                _extend_metric_maps(child, engine_idx, stage, replica)
+    elif isinstance(value, (list, tuple)):
+        for child in value:
+            _extend_metric_maps(child, engine_idx, stage, replica)
+    elif isinstance(value, (PerfMetricsProm, SpecDecodingProm, KVConnectorProm, KVConnectorPromMetrics)):
+        _extend_metric_maps(vars(value), engine_idx, stage, replica)
 
 
 class _RelabelGauge(_RelabelMixin, Gauge):
@@ -188,8 +228,8 @@ class OmniPrometheusStatLogger(PrometheusStatLogger):
 
     The orchestrator builds ``stage_replica_map`` from the static stage_pools
     config; flat engine_idx values map 1:1 to (stage_name, replica_id) tuples.
-    Dynamic add/remove of replicas at runtime is intentionally not supported —
-    the map is built once at construction and never mutated afterward.
+    New replicas are registered before their first statistics are recorded.
+    Indices and counters are retained across detach/rejoin of the same replica.
     """
 
     # Inject our wrapper metric classes into upstream's class-level slots so
@@ -217,10 +257,30 @@ class OmniPrometheusStatLogger(PrometheusStatLogger):
         # orchestrator restart) starts from a clean slate.
         _ENGINE_INDEX_MAP.clear()
         _ENGINE_INDEX_MAP.update(stage_replica_map)
-        super().__init__(
-            vllm_config=vllm_config,
-            engine_indexes=list(stage_replica_map.keys()),
-        )
+        self.vllm_config = vllm_config
+        self.engine_indexes = list(stage_replica_map)
+        self._omni_per_engine_labelvalues: dict[int, list[object]] = {}
+        # A head can start without local replicas. Initialize collectors on
+        # its first join so every per-engine table has a binding template.
+        if stage_replica_map:
+            super().__init__(vllm_config=vllm_config, engine_indexes=self.engine_indexes)
+
+    def register_replica(self, engine_idx: int, stage: str, replica: str) -> None:
+        """Register a replica without resetting existing metric series."""
+        pair = (stage, replica)
+        if engine_idx in self._stage_replica_map:
+            if self._stage_replica_map[engine_idx] != pair:
+                raise ValueError(f"Engine index {engine_idx} already belongs to another replica")
+            return
+        self._stage_replica_map[engine_idx] = pair
+        _ENGINE_INDEX_MAP[engine_idx] = pair
+        if not self.engine_indexes:
+            super().__init__(vllm_config=self.vllm_config, engine_indexes=[engine_idx])
+            return
+        _extend_metric_maps(vars(self), engine_idx, stage, replica)
+        self.per_engine_labelvalues[engine_idx] = [self.vllm_config.model_config.served_model_name, stage, replica]
+        self.engine_indexes.append(engine_idx)
+        self.gauge_engine_sleep_state["awake"][engine_idx].set(1)
 
     @property
     def stage_replica_map(self) -> dict[int, tuple[str, str]]:
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_codec.py b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_codec.py
index 7addb3934..860d64c44 100644
--- a/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_codec.py
+++ b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_codec.py
@@ -204,6 +204,7 @@ class BreezeTTS2MimiCodec(nn.Module):
                 f"Breeze codec request id count {len(request_ids)} does not match input request count {len(requests)}"
             )
         valid: list[tuple[str, torch.Tensor, bool]] = []
+        valid_indices: list[int] = []
         for index, request_ids_tensor in enumerate(requests):
             runtime_info = (
                 runtime_additional_information[index]
@@ -238,6 +239,7 @@ class BreezeTTS2MimiCodec(nn.Module):
                 )
             frames = int(flat.numel()) // self._num_codebooks
             valid.append((state_id, flat.reshape(self._num_codebooks, frames), finished))
+            valid_indices.append(index)
 
         waveforms = [empty.to(device=ids.device)] * len(requests)
         sample_rates = [sr] * len(requests)
@@ -247,7 +249,6 @@ class BreezeTTS2MimiCodec(nn.Module):
                 multimodal_outputs={"model_outputs": waveforms, "sr": sample_rates},
             )
         states: list[dict[str, Any]] = []
-        valid_indices: list[int] = []
         max_frames = max(codes.shape[-1] for _, codes, _ in valid)
         batched_codes = valid[0][1].new_zeros((len(valid), self._num_codebooks, max_frames))
         for row, (state_id, row_codes, _) in enumerate(valid):
@@ -258,7 +259,6 @@ class BreezeTTS2MimiCodec(nn.Module):
                 self._decoder_state_cache[state_id] = state
             state.setdefault("prefix_frames", 0)
             states.append(state)
-            valid_indices.append(row)
 
         decoded = decoder.batched_chunked_decode(
             batched_codes,
@@ -353,6 +353,27 @@ class BreezeTTS2MimiCodec(nn.Module):
                     device_map=str(device),
                 )
                 self._sample_rate = int(self._audio_tokenizer.model.get_output_sample_rate())
+                if self._async_chunk:
+                    connector_config = getattr(self.vllm_config.model_config, "stage_connector_config", None)
+                    extra = (
+                        connector_config.get("extra", connector_config)
+                        if isinstance(connector_config, Mapping)
+                        else getattr(connector_config, "extra", None)
+                    )
+                    value = extra.get("breeze_codec_chunk_frames") if isinstance(extra, Mapping) else None
+                    try:
+                        chunk_frames = int(value) if value is not None else 8
+                    except (TypeError, ValueError) as exc:
+                        raise ValueError(f"Invalid Breeze codec_chunk_frames={value!r}") from exc
+                    if chunk_frames <= 0:
+                        raise ValueError(f"Breeze codec_chunk_frames must be positive, got {chunk_frames}")
+                    # Qwen treats chunks shorter than its configured window as
+                    # terminal tails and does not advance their rolling cache.
+                    # Match the producer's chunk size instead of its default 25.
+                    decoder = self._audio_tokenizer.model.decoder
+                    decoder._initial_codec_chunk_frames = chunk_frames
+                    decoder._incremental_chunk_frames = chunk_frames
+                    decoder._incremental_chunk_ramp = []
             for _ in weights:
                 pass
             tokenizer_module = getattr(self._audio_tokenizer, "model", None)
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_talker.py b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_talker.py
index beaa390c8..765df5fbf 100644
--- a/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_talker.py
+++ b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_talker.py
@@ -13,6 +13,7 @@ generation order without importing HuggingFace GenerationMixin.
 from __future__ import annotations
 
 import hashlib
+import math
 import os
 from collections.abc import Iterable, Mapping, Sequence
 from pathlib import Path
@@ -367,10 +368,12 @@ class BreezeTTS2TalkerForGeneration(nn.Module):
             return None
         logits = self._main_head_logits(hidden_states)
 
-        # ``make_omni_output`` runs immediately before this hook. It records
-        # requests whose previous hidden state selected EOS or reached the
-        # frame budget, so the scheduler receives a real stop token instead
-        # of depending on an arbitrary deploy-level max_tokens timeout.
+        # ``make_omni_output`` already selected codebook 0 and completed its
+        # frame. Return that same decision to the scheduler, including EOS.
+        # A finite zero survives the sampler's repetition/temperature passes
+        # without applying the repetition penalty twice or changing the frame.
+        # These logits describe deterministic codec selection, not model
+        # confidence; sampled-token logprobs are consequently zero.
         states = self._batch_state or []
         if states:
             for state, row_start, row_end in _iter_request_rows(
@@ -378,10 +381,11 @@ class BreezeTTS2TalkerForGeneration(nn.Module):
                 getattr(self, "_batch_state_spans", None),
                 int(logits.shape[0]),
             ):
-                if state.get("breeze_force_eos", False):
+                selected_code0 = state.get("breeze_selected_code0")
+                if selected_code0 is not None:
                     row = logits[row_start:row_end]
                     row.fill_(float("-inf"))
-                    row[:, self.codebook_vocab_size] = 0.0
+                    row[:, int(selected_code0)] = 0.0
         return logits
 
     def _main_head_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:
@@ -443,6 +447,13 @@ class BreezeTTS2TalkerForGeneration(nn.Module):
         self._batch_state = info_items
         self._batch_state_spans = spans
         per_request_codes: list[torch.Tensor] = []
+        # The runner passes the same per-request sampling metadata to this
+        # hook and compute_logits, including offline SamplingParams overrides.
+        # When no_penalties is true vLLM does not initialize this GPU buffer.
+        sampling_metadata = kwargs.get("sampling_metadata")
+        repetition_penalties = None
+        if sampling_metadata is not None and not sampling_metadata.no_penalties:
+            repetition_penalties = sampling_metadata.repetition_penalties.tolist()
 
         for index, info in enumerate(info_items):
             if spans is not None and index < len(spans):
@@ -458,11 +469,22 @@ class BreezeTTS2TalkerForGeneration(nn.Module):
             row_hidden = hidden[row_end - 1]
             if self._golden_dump_dir and bool(info.get("_omni_is_prefill", False)):
                 self._dump_golden_prefill(info, row_hidden)
-            main_logits = self._main_head_logits(row_hidden.reshape(1, -1))
+            main_logits = self._main_head_logits(row_hidden.reshape(1, -1)).float()
+            penalty = float(repetition_penalties[index]) if repetition_penalties is not None else 1.0
+            if not math.isfinite(penalty) or penalty <= 0:
+                raise ValueError("Breeze repetition_penalty must be finite and positive")
+            # Match upstream: penalize each previously generated codebook-0
+            # id once, excluding the text prompt and reference audio codes.
+            history = info.setdefault("breeze_generated_code0_ids", [])
+            if penalty != 1.0 and history:
+                history_ids = torch.tensor(history, device=main_logits.device, dtype=torch.long)
+                scores = main_logits[0, history_ids]
+                main_logits[0, history_ids] = torch.where(scores < 0, scores * penalty, scores / penalty)
             code0 = int(torch.argmax(main_logits, dim=-1).item())
             generated_frames = int(info.get("breeze_generated_frames", 0) or 0)
             max_new_frames = int(info.get("breeze_max_new_frames", -1))
             terminal = code0 == self.codebook_vocab_size or (max_new_frames > 0 and generated_frames >= max_new_frames)
+            info["breeze_selected_code0"] = self.codebook_vocab_size if terminal else code0
             if terminal:
                 info["breeze_force_eos"] = True
                 existing = info.get("breeze_audio_codes")
@@ -476,6 +498,7 @@ class BreezeTTS2TalkerForGeneration(nn.Module):
                 raise RuntimeError(f"Breeze main head produced invalid codec id {code0}")
 
             frame = self._generate_depth_codes(row_hidden, code0)
+            history.append(code0)
             info["breeze_current_frame"] = frame[0].detach()
             info["breeze_generated_frames"] = generated_frames + 1
             info["breeze_force_eos"] = False
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py b/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py
index d1aaeb13e..2b538df01 100644
--- a/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py
+++ b/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py
@@ -28,6 +28,12 @@ BREEZE_TTS_2_PIPELINE = PipelineConfig(
             custom_process_next_stage_input_func=f"{_PROC}.talker2codec_full_payload",
             sampling_constraints={
                 "detokenize": False,
+                # Text EOS 1 is a valid codec token; only the backbone's
+                # explicit codec EOS below may terminate audio generation.
+                "ignore_eos": True,
+                # The talker has already selected the emitted frame's token;
+                # min_tokens must not mask that token in the sampler.
+                "min_tokens": 0,
                 "stop_token_ids": [2051],
             },
         ),
diff --git a/vllm_omni/model_executor/models/common/qwen3_code_predictor.py b/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
index eff3305d5..306301c94 100644
--- a/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
+++ b/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
@@ -682,14 +682,20 @@ class CodePredictorWrapper(nn.Module):
         self._lm_heads_list: list[nn.Module] | None = None
         self._codec_embeds_list: list[nn.Module] | None = None
         self._device_graphs: dict[int | tuple[int, int], tuple] = {}  # (graph, static_output) per bucket
+        # Outer-runner execution buckets when a model host declares them (MRv2);
+        # ``None`` keeps the legacy power-of-two bucket derivation.
+        self._execution_batch_buckets: list[int] | None = None
         prefix_graph_cfg = self._stage_connector_extra_config(vllm_config)
         prefix_graphs_requested = self._parse_bool_config(prefix_graph_cfg.get("code_predictor_prefix_graphs"))
         is_npu = current_omni_platform.is_npu()
-        self._prefix_graphs_enabled = prefix_graphs_requested and wrapper_config.use_cuda_graphs and not is_npu
-        if prefix_graphs_requested and not self._prefix_graphs_enabled:
+        # MRv2 captures the whole Talker MTP call. It can therefore capture
+        # shorter compiled re-prefill forwards without nesting predictor-owned
+        # CUDA graphs inside the outer graph.
+        self._prefix_reprefill_enabled = prefix_graphs_requested and not is_npu
+        self._prefix_graphs_enabled = self._prefix_reprefill_enabled and wrapper_config.use_cuda_graphs
+        if prefix_graphs_requested and not self._prefix_reprefill_enabled:
             logger.info_once(
-                "code_predictor: prefix CUDA graphs requested but disabled because use_cuda_graphs=%s is_npu=%s",
-                wrapper_config.use_cuda_graphs,
+                "code_predictor: prefix re-prefill requested but disabled because is_npu=%s",
                 is_npu,
             )
         self._prefix_graph_buckets = self._parse_positive_int_set(
@@ -698,6 +704,7 @@ class CodePredictorWrapper(nn.Module):
         self._prefix_graph_seq_lens = self._parse_positive_int_set(
             prefix_graph_cfg.get("code_predictor_prefix_graph_seq_lens")
         )
+        self._prefix_reprefill_seq_lens = tuple(self._prefix_seq_lens(self._num_groups + 1))
 
     def get_input_embeddings(self) -> nn.ModuleList:
         return self.model.get_input_embeddings()
@@ -761,7 +768,8 @@ class CodePredictorWrapper(nn.Module):
             dynamic=False,
             options={"epilogue_fusion": False},
         )
-        self._warmup_buckets()
+        with torch._dynamo.config.patch(cache_size_limit=self._compile_cache_size_limit()):
+            self._warmup_buckets()
 
         if self._wrapper_config.use_cuda_graphs:
             self._capture_cuda_graphs()
@@ -770,7 +778,7 @@ class CodePredictorWrapper(nn.Module):
             logger.info("code_predictor: torch.compile (dynamic=False, no epilogue fusion)")
 
     def _padded_bsz(self, bsz: int) -> int:
-        """Round batch size up to nearest power-of-2 bucket."""
+        """Round batch size up to the nearest warmed bucket."""
         for bucket in self._bucket_sizes:
             if bsz <= bucket:
                 return bucket
@@ -832,15 +840,28 @@ class CodePredictorWrapper(nn.Module):
         return row_generators
 
     @classmethod
-    def _sample_codes_gumbel(cls, logits: torch.Tensor, generator: _GeneratorLike = None) -> torch.Tensor:
-        """Sample ``logits`` via Gumbel-max with optional per-row generators."""
-        row_generators = cls._normalize_generators(generator, int(logits.shape[0]))
-        u = torch.empty_like(logits, dtype=torch.float32)
-        if isinstance(row_generators, list):
-            for row, row_generator in enumerate(row_generators):
-                u[row : row + 1].uniform_(_UNIFORM_EPS, 1.0 - _UNIFORM_EPS, generator=row_generator)
+    def _sample_codes_gumbel(
+        cls,
+        logits: torch.Tensor,
+        generator: _GeneratorLike = None,
+        uniforms: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Sample ``logits`` via Gumbel-max with optional precomputed noise."""
+        if uniforms is None:
+            row_generators = cls._normalize_generators(generator, int(logits.shape[0]))
+            u = torch.empty_like(logits, dtype=torch.float32)
+            if isinstance(row_generators, list):
+                for row, row_generator in enumerate(row_generators):
+                    u[row : row + 1].uniform_(_UNIFORM_EPS, 1.0 - _UNIFORM_EPS, generator=row_generator)
+            else:
+                u.uniform_(_UNIFORM_EPS, 1.0 - _UNIFORM_EPS, generator=row_generators)
         else:
-            u.uniform_(_UNIFORM_EPS, 1.0 - _UNIFORM_EPS, generator=row_generators)
+            if uniforms.shape != logits.shape:
+                raise ValueError(
+                    f"precomputed sampling uniforms must match logits: uniforms={tuple(uniforms.shape)} "
+                    f"logits={tuple(logits.shape)}"
+                )
+            u = uniforms
         return (logits.float() - torch.log(-torch.log(u))).argmax(dim=-1, keepdim=True)
 
     def _prefix_seq_lens(self, max_seq: int) -> list[int]:
@@ -850,13 +871,64 @@ class CodePredictorWrapper(nn.Module):
         allowed = set(all_seq_lens)
         return sorted(seq_len for seq_len in self._prefix_graph_seq_lens if seq_len in allowed)
 
-    def _warmup_buckets(self) -> None:
-        """Warmup power-of-2 batch-size buckets to front-load Inductor compilation."""
+    @staticmethod
+    def _synchronize_warmup(device: torch.device) -> None:
+        if device.type != "cpu":
+            current_omni_platform.synchronize()
+
+    def configure_mtp_execution_buckets(self, sizes: Iterable[int]) -> None:
+        """Declare the batch buckets the outer runner can actually reach.
+
+        Must be called before the first warmup; once buckets are captured the
+        existing set is only acceptable when it already covers the declaration
+        (never clear active graphs to rebuild them).
+        """
+        max_bsz = int(self._vllm_config.scheduler_config.max_num_seqs)
+        cleaned = sorted({int(size) for size in sizes if 0 < int(size) <= max_bsz} | {max_bsz})
+        if self._bucket_sizes:
+            missing = [size for size in cleaned if size not in self._bucket_sizes]
+            if missing:
+                raise RuntimeError(
+                    "mtp execution buckets must be configured before the first warmup; "
+                    f"missing={missing} existing={self._bucket_sizes}"
+                )
+            return
+        self._execution_batch_buckets = cleaned
+
+    def _batch_bucket_sizes(self) -> list[int]:
         max_bsz = self._vllm_config.scheduler_config.max_num_seqs
+        if self._execution_batch_buckets is not None:
+            # Outer-reachable buckets plus prefix-graph capture buckets and the
+            # full-size eager fallback row already merged at configure time.
+            bucket_sizes = list(self._execution_batch_buckets)
+            bucket_sizes.extend(bucket for bucket in self._prefix_graph_buckets if bucket <= max_bsz)
+            return sorted(set(bucket_sizes))
         bucket_sizes = [1 << i for i in range(max_bsz.bit_length()) if (1 << i) <= max_bsz]
-        if max_bsz not in bucket_sizes:
-            bucket_sizes.append(max_bsz)
-        self._bucket_sizes = sorted(bucket_sizes)
+        bucket_sizes.extend(bucket for bucket in self._prefix_graph_buckets if bucket <= max_bsz)
+        bucket_sizes.append(max_bsz)
+        return sorted(set(bucket_sizes))
+
+    def _compile_cache_size_limit(self) -> int:
+        bucket_sizes = self._batch_bucket_sizes()
+        if not self._prefix_reprefill_enabled:
+            required_entries = len(bucket_sizes)
+        else:
+            prefix_buckets = (
+                self._prefix_graph_buckets.intersection(bucket_sizes)
+                if self._prefix_graph_buckets
+                else set(bucket_sizes)
+            )
+            prefix_seq_lens = self._prefix_reprefill_seq_lens
+            needs_full_graph = set(prefix_seq_lens) != set(range(2, self._num_groups + 1))
+            full_graph_entries = len(bucket_sizes) - len(prefix_buckets)
+            if needs_full_graph:
+                full_graph_entries += len(prefix_buckets)
+            required_entries = full_graph_entries + len(prefix_buckets) * len(prefix_seq_lens)
+        return max(torch._dynamo.config.cache_size_limit, required_entries)
+
+    def _warmup_buckets(self) -> None:
+        """Warm up batch-size buckets to front-load Inductor compilation."""
+        self._bucket_sizes = self._batch_bucket_sizes()
 
         max_seq = self._num_groups + 1
         device = next(self.model.parameters()).device
@@ -866,8 +938,8 @@ class CodePredictorWrapper(nn.Module):
         self._ensure_buffers(device, self._model_dtype, max(self._bucket_sizes))
         proj_buf = self._proj_buf
 
-        if self._prefix_graphs_enabled:
-            prefix_seq_lens = self._prefix_seq_lens(max_seq)
+        if self._prefix_reprefill_enabled:
+            prefix_seq_lens = self._prefix_reprefill_seq_lens
             needs_full_graph = set(prefix_seq_lens) != set(range(2, max_seq))
             for bsz in self._bucket_sizes:
                 capture_prefixes = not self._prefix_graph_buckets or bsz in self._prefix_graph_buckets
@@ -905,6 +977,10 @@ class CodePredictorWrapper(nn.Module):
                     self._compiled_model_fwd(proj_buf[:bsz, :max_seq, :], pos_ids)
             logger.info("code_predictor: warmup done for buckets %s", self._bucket_sizes)
 
+        # Compiled attention warmup is asynchronous. Complete it before graph
+        # capture and serving reuse the same static buffers.
+        self._synchronize_warmup(device)
+
     def _capture_cuda_graphs(self) -> None:
         """Capture a CUDA graph per bucket using vLLM's global graph pool."""
         from vllm.platforms import current_platform
@@ -914,7 +990,7 @@ class CodePredictorWrapper(nn.Module):
         proj_buf = self._proj_buf
 
         if self._prefix_graphs_enabled:
-            prefix_seq_lens = self._prefix_seq_lens(max_seq)
+            prefix_seq_lens = self._prefix_reprefill_seq_lens
             needs_full_graph = set(prefix_seq_lens) != set(range(2, max_seq))
             for bsz in self._bucket_sizes:
                 capture_prefixes = not self._prefix_graph_buckets or bsz in self._prefix_graph_buckets
@@ -1013,13 +1089,20 @@ class CodePredictorWrapper(nn.Module):
         top_p: float = 1.0,
         generator: torch.Generator | None = None,
         generators: Sequence[torch.Generator | None] | None = None,
+        sample_uniforms: torch.Tensor | None = None,
     ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
         """Predict residual codebooks 1..G-1 autoregressively via re-prefill."""
         bsz = int(layer0_code.shape[0])
+        num_groups = self._num_groups
         if generators is not None and len(generators) != bsz:
             raise ValueError(f"generators must have one entry per row: got {len(generators)} for batch {bsz}")
+        if sample_uniforms is not None:
+            expected_shape = (bsz, num_groups - 1, int(self.config.vocab_size))
+            if tuple(sample_uniforms.shape) != expected_shape:
+                raise ValueError(
+                    f"sample_uniforms must have shape {expected_shape}, got {tuple(sample_uniforms.shape)}"
+                )
         sample_generator: _GeneratorLike = generators if generators is not None else generator
-        num_groups = self._num_groups
         device = layer0_code.device
 
         # _setup_compile caches _model_dtype on first call; use it for buffers
@@ -1072,11 +1155,16 @@ class CodePredictorWrapper(nn.Module):
         for step in range(1, num_groups):
             graph_key: int | tuple[int, int] = padded_bsz
             seq_len = max_seq
-            if self._prefix_graphs_enabled:
-                prefix_key = (padded_bsz, step + 1)
-                if prefix_key in self._device_graphs:
-                    graph_key = prefix_key
-                    seq_len = step + 1
+            if self._prefix_reprefill_enabled:
+                actual_seq_len = step + 1
+                for prefix_seq_len in self._prefix_reprefill_seq_lens:
+                    if prefix_seq_len < actual_seq_len:
+                        continue
+                    prefix_key = (padded_bsz, prefix_seq_len)
+                    if prefix_key in self._bucket_pos_ids:
+                        graph_key = prefix_key
+                        seq_len = prefix_seq_len
+                        break
             pos_ids = self._bucket_pos_ids.get(graph_key)
             if pos_ids is None:
                 pos_ids = (
@@ -1123,7 +1211,8 @@ class CodePredictorWrapper(nn.Module):
                     remove_mask = (cumulative_probs - sorted_probs) >= s_top_p
                     sorted_logits[remove_mask] = float("-inf")
                     logits = sorted_logits.scatter(1, sorted_idx, sorted_logits)
-                code = self._sample_codes_gumbel(logits, generator=sample_generator)
+                step_uniforms = sample_uniforms[:, step - 1, :] if sample_uniforms is not None else None
+                code = self._sample_codes_gumbel(logits, generator=sample_generator, uniforms=step_uniforms)
             else:
                 # "per_call" mode: temperature-scaled + top-k -> Gumbel-max
                 if use_sampling:
@@ -1131,7 +1220,8 @@ class CodePredictorWrapper(nn.Module):
                     if top_k > 0:
                         topk_vals, _ = scaled.topk(top_k, dim=-1)
                         scaled = scaled.masked_fill(scaled < topk_vals[:, -1:], float("-inf"))
-                    code = self._sample_codes_gumbel(scaled, generator=sample_generator)
+                    step_uniforms = sample_uniforms[:, step - 1, :] if sample_uniforms is not None else None
+                    code = self._sample_codes_gumbel(scaled, generator=sample_generator, uniforms=step_uniforms)
                 else:
                     code = logits.argmax(dim=-1, keepdim=True)
 
diff --git a/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/hifigan.py b/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/hifigan.py
index 7cbd31e9c..2b8f3e61e 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/hifigan.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/hifigan.py
@@ -98,6 +98,46 @@ class ResBlock(torch.nn.Module):
             remove_weight_norm(self.convs2[idx])
 
 
+def _carry_phase_at_boundary(
+    cum_total: torch.Tensor,
+    phase_acc: torch.Tensor | None,
+    next_overlap: int,
+    *,
+    dim: int,
+    trim: int = 0,
+) -> torch.Tensor | None:
+    """Accumulated phase (mod 1) carried into the next streaming window.
+
+    Shared by SineGen and SineGen2 so harmonic phase stays continuous across
+    chunk boundaries when HiFT runs over a bounded mel window. ``cum_total``
+    must already include ``phase_acc``; falls back to it unchanged if
+    ``next_overlap`` (+ ``trim``) covers the whole window.
+    """
+    length = cum_total.shape[dim]
+    if next_overlap >= length + trim:
+        return phase_acc
+    idx = length + trim - next_overlap - 1
+    return cum_total.narrow(dim, idx, 1) % 1
+
+
+def _wrapped_slice(buf: torch.Tensor, offset: int, length: int, dim: int = 1) -> torch.Tensor:
+    """``length`` elements of ``buf`` along ``dim`` starting at ``offset``,
+    wrapping (mod ``buf.shape[dim]``) instead of running past the end and
+    coming back short. Shared by SineGen/SineGen2/SourceModuleHnNSF's
+    position-indexed noise buffers, now that streams can outlast their 300s.
+    """
+    n = buf.shape[dim]
+    start = offset % n
+    parts = []
+    remaining = length
+    while remaining > 0:
+        take = min(remaining, n - start)
+        parts.append(buf.narrow(dim, start, take))
+        remaining -= take
+        start = 0
+    return parts[0] if len(parts) == 1 else torch.cat(parts, dim=dim)
+
+
 class SineGen(torch.nn.Module):
     """Definition of sine generator
     SineGen(samp_rate, harmonic_num = 0,
@@ -114,13 +154,24 @@ class SineGen(torch.nn.Module):
         segment is always sin(np.pi) or cos(0)
     """
 
-    def __init__(self, samp_rate, harmonic_num=0, sine_amp=0.1, noise_std=0.003, voiced_threshold=0):
+    def __init__(self, samp_rate, harmonic_num=0, sine_amp=0.1, noise_std=0.003, voiced_threshold=0, causal=False):
         super().__init__()
         self.sine_amp = sine_amp
         self.noise_std = noise_std
         self.harmonic_num = harmonic_num
         self.sampling_rate = samp_rate
         self.voiced_threshold = voiced_threshold
+        self.causal = causal
+        # Fixed per model instance like SineGen2's rand_ini, not redrawn per
+        # call, or each harmonic jumps to a new random phase every window.
+        self.phase_vec = Uniform(low=-np.pi, high=np.pi).sample(sample_shape=(1, harmonic_num + 1, 1))
+        self.phase_vec[:, 0, :] = 0
+        if causal:
+            self.register_buffer(
+                "noise_buf",
+                torch.randn(1, 300 * 24000, harmonic_num + 1),
+                persistent=False,
+            )
 
     def _f02uv(self, f0):
         # generate uv signal
@@ -128,22 +179,32 @@ class SineGen(torch.nn.Module):
         return uv
 
     @torch.no_grad()
-    def forward(self, f0):
+    def forward(self, f0, phase_acc=None, next_overlap=0, trim=0, noise_offset=0):
         """sine_tensor, uv = forward(f0)
         input F0: tensor(batchsize=1, dim=1, length)
                   f0 for unvoiced steps should be 0
         output sine_tensor: tensor(batchsize=1, length, dim)
         output uv: tensor(batchsize=1, length, 1)
+
+        ``next_overlap`` and ``trim`` are sample-indexed here (``f0`` arrives
+        post-``f0_upsamp``), unlike SineGen2 which downsamples to mel rate
+        before its own cumsum -- callers must scale both by samples-per-mel.
         """
         f0 = f0.transpose(1, 2)
         F_mat = torch.zeros((f0.size(0), self.harmonic_num + 1, f0.size(-1))).to(f0.device)
         for i in range(self.harmonic_num + 1):
             F_mat[:, i : i + 1, :] = f0 * (i + 1) / self.sampling_rate
 
-        theta_mat = 2 * np.pi * (torch.cumsum(F_mat, dim=-1) % 1)
-        u_dist = Uniform(low=-np.pi, high=np.pi)
-        phase_vec = u_dist.sample(sample_shape=(f0.size(0), self.harmonic_num + 1, 1)).to(F_mat.device)
-        phase_vec[:, 0, :] = 0
+        cum = torch.cumsum(F_mat, dim=-1)
+        cum_total = cum if phase_acc is None else phase_acc + cum
+        theta_mat = 2 * np.pi * (cum_total % 1)
+        new_phase_acc = _carry_phase_at_boundary(cum_total, phase_acc, next_overlap, dim=-1, trim=trim)
+        if self.causal:
+            phase_vec = self.phase_vec.to(F_mat.device)
+        else:
+            u_dist = Uniform(low=-np.pi, high=np.pi)
+            phase_vec = u_dist.sample(sample_shape=(f0.size(0), self.harmonic_num + 1, 1)).to(F_mat.device)
+            phase_vec[:, 0, :] = 0
 
         # generate sine waveforms
         sine_waves = self.sine_amp * torch.sin(theta_mat + phase_vec)
@@ -155,11 +216,16 @@ class SineGen(torch.nn.Module):
         #        std = self.sine_amp/3 -> max value ~ self.sine_amp
         # .       for voiced regions is self.noise_std
         noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-        noise = noise_amp * torch.randn_like(sine_waves)
+        if self.training is False and self.causal is True:
+            noise = noise_amp * _wrapped_slice(self.noise_buf, noise_offset, sine_waves.shape[-1]).transpose(1, 2)
+        else:
+            noise = noise_amp * torch.randn_like(sine_waves)
 
         # first: set the unvoiced part to 0 by uv
         # then: additive noise
         sine_waves = sine_waves * uv + noise
+        if self.causal:
+            return sine_waves.transpose(1, 2), uv.transpose(1, 2), noise, new_phase_acc
         return sine_waves.transpose(1, 2), uv.transpose(1, 2), noise
 
 
@@ -215,7 +281,7 @@ class SineGen2(torch.nn.Module):
         uv = (f0 > self.voiced_threshold).type(torch.float32)
         return uv
 
-    def _f02sine(self, f0_values):
+    def _f02sine(self, f0_values, phase_acc=None, next_overlap=0, trim=0):
         """f0_values: (batchsize, length, dim)
         where dim indicates fundamental tone and overtones
         """
@@ -223,9 +289,12 @@ class SineGen2(torch.nn.Module):
         # because 2 * np.pi * n doesn't affect phase
         rad_values = (f0_values / self.sampling_rate) % 1
 
-        # initial phase noise (no noise for fundamental component)
+        # initial phase noise (no noise for fundamental component). Only applied
+        # on the genuine first chunk of a stream (see rationale above the class);
+        # phase_acc is None exactly when there is no carried-forward phase yet.
         if self.training is False and self.causal is True:
-            rad_values[:, 0, :] = rad_values[:, 0, :] + self.rand_ini.to(rad_values.device)
+            if phase_acc is None:
+                rad_values[:, 0, :] = rad_values[:, 0, :] + self.rand_ini.to(rad_values.device)
         else:
             rand_ini = torch.rand(f0_values.shape[0], f0_values.shape[2], device=f0_values.device)
             rand_ini[:, 0] = 0
@@ -237,7 +306,10 @@ class SineGen2(torch.nn.Module):
                 rad_values.transpose(1, 2), scale_factor=1 / self.upsample_scale, mode="linear"
             ).transpose(1, 2)
 
-            phase = torch.cumsum(rad_values, dim=1) * 2 * np.pi
+            cum = torch.cumsum(rad_values, dim=1)
+            phase = cum if phase_acc is None else cum + phase_acc
+            new_phase_acc = _carry_phase_at_boundary(phase, phase_acc, next_overlap, dim=1, trim=trim)
+            phase = phase * 2 * np.pi
             phase = torch.nn.functional.interpolate(
                 phase.transpose(1, 2) * self.upsample_scale,
                 scale_factor=self.upsample_scale,
@@ -272,9 +344,10 @@ class SineGen2(torch.nn.Module):
 
             # get the sines
             sines = torch.cos(i_phase * 2 * np.pi)
-        return sines
+            new_phase_acc = None
+        return (sines, new_phase_acc) if self.causal else sines
 
-    def forward(self, f0):
+    def forward(self, f0, phase_acc=None, next_overlap=0, trim=0, noise_offset=0):
         """sine_tensor, uv = forward(f0)
         input F0: tensor(batchsize=1, length, dim=1)
                   f0 for unvoiced steps should be 0
@@ -284,8 +357,12 @@ class SineGen2(torch.nn.Module):
         # fundamental component
         fn = torch.multiply(f0, self.harmonic_ids)
 
-        # generate sine waveforms
-        sine_waves = self._f02sine(fn) * self.sine_amp
+        if self.causal:
+            sine_waves, new_phase_acc = self._f02sine(fn, phase_acc, next_overlap, trim)
+        else:
+            sine_waves = self._f02sine(fn)
+            new_phase_acc = None
+        sine_waves = sine_waves * self.sine_amp
 
         # generate uv signal
         uv = self._f02uv(f0)
@@ -295,14 +372,15 @@ class SineGen2(torch.nn.Module):
         # .       for voiced regions is self.noise_std
         noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
         if self.training is False and self.causal is True:
-            noise = noise_amp * self.sine_waves[:, : sine_waves.shape[1]].to(sine_waves.device)
+            # indexed by absolute sample position, not window-relative position
+            noise = noise_amp * _wrapped_slice(self.sine_waves, noise_offset, sine_waves.shape[1]).to(sine_waves.device)
         else:
             noise = noise_amp * torch.randn_like(sine_waves)
 
         # first: set the unvoiced part to 0 by uv
         # then: additive noise
         sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
+        return (sine_waves, uv, noise, new_phase_acc) if self.causal else (sine_waves, uv, noise)
 
 
 class SourceModuleHnNSF(torch.nn.Module):
@@ -338,10 +416,13 @@ class SourceModuleHnNSF(torch.nn.Module):
 
         self.sine_amp = sine_amp
         self.noise_std = add_noise_std
+        self.upsample_scale = upsample_scale
 
         # to produce sine waveforms
         if sinegen_type == "1":
-            self.l_sin_gen = SineGen(sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshold)
+            self.l_sin_gen = SineGen(
+                sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshold, causal=causal
+            )
         else:
             self.l_sin_gen = SineGen2(
                 sampling_rate, upsample_scale, harmonic_num, sine_amp, add_noise_std, voiced_threshold, causal=causal
@@ -354,24 +435,38 @@ class SourceModuleHnNSF(torch.nn.Module):
         if causal is True:
             self.uv = torch.rand(1, 300 * 24000, 1)
 
-    def forward(self, x):
+    def forward(self, x, phase_acc=None, uv_offset=0, next_overlap=0, trim=0):
         """
         Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
         F0_sampled (batchsize, length, 1)
         Sine_source (batchsize, length, 1)
         noise_source (batchsize, length 1)
         """
-        # source for harmonic branch
         with torch.no_grad():
-            sine_wavs, uv, _ = self.l_sin_gen(x)
+            if not self.causal:
+                sine_wavs, uv, _ = self.l_sin_gen(x)
+                new_phase_acc = None
+            elif isinstance(self.l_sin_gen, SineGen):
+                # next_overlap/trim arrive in mel frames; SineGen needs samples.
+                sine_wavs, uv, _, new_phase_acc = self.l_sin_gen(
+                    x,
+                    phase_acc,
+                    next_overlap * self.upsample_scale,
+                    trim * self.upsample_scale,
+                    noise_offset=uv_offset,
+                )
+            else:
+                sine_wavs, uv, _, new_phase_acc = self.l_sin_gen(
+                    x, phase_acc, next_overlap, trim, noise_offset=uv_offset
+                )
         sine_merge = self.l_tanh(self.l_linear(sine_wavs))
 
         # source for noise branch, in the same shape as uv
         if self.training is False and self.causal is True:
-            noise = self.uv[:, : uv.shape[1]] * self.sine_amp / 3
+            noise = _wrapped_slice(self.uv, uv_offset, uv.shape[1]) * self.sine_amp / 3
         else:
             noise = torch.randn_like(uv) * self.sine_amp / 3
-        return sine_merge, noise, uv
+        return sine_merge, noise, uv, new_phase_acc
 
 
 class HiFTGenerator(nn.Module):
@@ -606,7 +701,7 @@ class HiFTGenerator(nn.Module):
         f0 = self.f0_predictor(speech_feat)
         # f0->source
         s = self.f0_upsamp(f0[:, None]).transpose(1, 2)  # bs,n,t
-        s, _, _ = self.m_source(s)
+        s, _, _, _ = self.m_source(s)
         s = s.transpose(1, 2)
         # mel+source->speech
         generated_speech = self.decode(x=speech_feat, s=s)
@@ -622,7 +717,7 @@ class HiFTGenerator(nn.Module):
         f0 = self.f0_predictor(speech_feat)
         # f0->source
         s = self.f0_upsamp(f0[:, None]).transpose(1, 2)  # bs,n,t
-        s, _, _ = self.m_source(s)
+        s, _, _, _ = self.m_source(s)
         s = s.transpose(1, 2)
         # use cache_source to avoid glitch
         if cache_source.shape[2] != 0:
@@ -785,14 +880,28 @@ class CausalHiFTGenerator(HiFTGenerator):
         return x
 
     @torch.inference_mode()
-    def inference(self, speech_feat: torch.Tensor, finalize: bool = True) -> torch.Tensor:
+    def inference(
+        self,
+        speech_feat: torch.Tensor,
+        finalize: bool = True,
+        phase_acc: torch.Tensor | None = None,
+        uv_offset: int = 0,
+        next_overlap: int = 0,
+        trim: int = 0,
+        f0_margin: int = 0,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
         # mel->f0 NOTE f0_predictor precision is crucial for causal inference, move
         # self.f0_predictor to cpu if necessary
         self.f0_predictor.to("cpu")
         f0 = self.f0_predictor(speech_feat.cpu(), finalize=finalize).to(speech_feat)
+        if f0_margin > 0:
+            f0 = f0[:, f0_margin:]
+            speech_feat = speech_feat[:, :, f0_margin:]
         # f0->source
         s = self.f0_upsamp(f0[:, None]).transpose(1, 2)  # bs,n,t
-        s, _, _ = self.m_source(s)
+        s, _, _, new_phase_acc = self.m_source(
+            s, phase_acc=phase_acc, uv_offset=uv_offset, next_overlap=next_overlap, trim=trim
+        )
         s = s.transpose(1, 2)
         if finalize is True:
             generated_speech = self.decode(x=speech_feat, s=s, finalize=finalize)
@@ -800,7 +909,7 @@ class CausalHiFTGenerator(HiFTGenerator):
             generated_speech = self.decode(
                 x=speech_feat[:, :, : -self.f0_predictor.condnet[0].causal_padding], s=s, finalize=finalize
             )
-        return generated_speech, s
+        return generated_speech, s, new_phase_acc
 
 
 class CausalConv1dUpsample(torch.nn.Conv1d):
@@ -954,6 +1063,11 @@ class CausalConvRNNF0Predictor(nn.Module):
             nn.ELU(),
         )
         self.classifier = nn.Linear(in_features=cond_channels, out_features=self.num_class)
+        self.left_context_frames = sum(
+            layer.causal_padding
+            for layer in self.condnet
+            if isinstance(layer, CausalConv1d) and layer.causal_type == "left"
+        )
 
     def forward(self, x: torch.Tensor, finalize: bool = True) -> torch.Tensor:
         if finalize is True:
diff --git a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py
index ef706b6c8..1713467c8 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py
@@ -9,10 +9,8 @@ This module contains the code2wav (token-to-waveform) stage which uses:
 3. HiFiGAN vocoder for waveform synthesis
 """
 
-from __future__ import annotations
-
 from collections import Counter
-from typing import cast
+from typing import TypedDict, cast
 
 import numpy as np
 import torch
@@ -39,6 +37,21 @@ from vllm_omni.transformers_utils.configs.cosyvoice3 import CosyVoice3Config
 logger = init_logger(__name__)
 
 
+class StreamingFlowItem(TypedDict, total=False):
+    """One entry of the batched-streaming item list passed to forward_streaming_batch."""
+
+    index: int
+    req_id: str | None
+    stream_finished: bool
+    token: torch.Tensor
+    prompt_token: torch.Tensor
+    prompt_feat: torch.Tensor
+    embedding: torch.Tensor
+    cache_state: dict[str, torch.Tensor] | None
+    token_offset_tokens: int
+    finalize: bool
+
+
 class CosyVoice3Code2Wav(nn.Module):
     """CosyVoice3 Code2Wav stage for token-to-waveform conversion.
 
@@ -119,6 +132,10 @@ class CosyVoice3Code2Wav(nn.Module):
         self.mel_cache_len = 20
         self.source_cache_len = int(self.mel_cache_len * 256)
         self.speech_window = np.hamming(2 * self.source_cache_len)
+        # Must cover decode()'s own causal receptive field, not just the F0
+        # margin; window_len=48 already passes
+        # test_incremental_hift_bounded_window_is_close, so 64 has headroom.
+        self._hift_window_len = 64
 
     @property
     def input_frame_rate(self) -> int:
@@ -226,40 +243,79 @@ class CosyVoice3Code2Wav(nn.Module):
         chunk_mel = feat.to(device=hift_weight.device, dtype=hift_weight.dtype)
 
         cached_mel = None if not cache_state else cache_state.get("mel")
-        speech_offset_obj = None if not cache_state else cache_state.get("speech_offset")
-        try:
-            speech_offset = int(speech_offset_obj) if speech_offset_obj is not None else 0
-        except (TypeError, ValueError):
-            speech_offset = 0
-
+        cached_offset = 0 if not cache_state else int(cache_state.get("mel_offset", 0))
+        window_len = self._hift_window_len
+        samples_per_mel = int(np.prod(self.hift.upsample_rates) * self.hift.istft_params["hop_len"])
+        trim = int(self.hift.f0_predictor.condnet[0].causal_padding)
+        f0_margin_frames = int(self.hift.f0_predictor.left_context_frames)
+        f0_margin = 0
         if isinstance(cached_mel, torch.Tensor) and cached_mel.numel() > 0:
             cached_mel = cached_mel.to(device=chunk_mel.device, dtype=chunk_mel.dtype)
-            tts_mel = torch.cat([cached_mel, chunk_mel], dim=-1) if chunk_mel.numel() > 0 else cached_mel
+            total_hist = cached_mel.shape[-1]
+            overlap = min(window_len + trim, total_hist)
+            window_mel = torch.cat([cached_mel[..., -overlap:], chunk_mel], dim=-1)
+            window_offset = cached_offset + total_hist - overlap
+            uv_offset = window_offset * samples_per_mel
+            f0_margin = min(f0_margin_frames, total_hist - overlap)
+            f0_input_mel = (
+                torch.cat(
+                    [cached_mel[..., total_hist - overlap - f0_margin : total_hist - overlap], window_mel], dim=-1
+                )
+                if f0_margin > 0
+                else window_mel
+            )
         else:
-            tts_mel = chunk_mel
+            window_mel = chunk_mel
+            f0_input_mel = chunk_mel
+            window_offset = 0
+            uv_offset = 0
 
-        if tts_mel.shape[-1] == 0:
+        phase_acc = None if not cache_state else cache_state.get("phase_acc")
+        if phase_acc is not None:
+            phase_acc = phase_acc.to(device=chunk_mel.device, dtype=chunk_mel.dtype)
+
+        if window_mel.shape[-1] == 0:
             tts_speech = torch.zeros((chunk_mel.shape[0], 1, 0), device=chunk_mel.device, dtype=chunk_mel.dtype)
+            new_phase_acc = phase_acc
         else:
-            tts_speech, _ = self.hift.inference(speech_feat=tts_mel, finalize=finalize)
+            next_overlap = min(window_len + trim, window_mel.shape[-1])
+            # On finalize the F0 predictor consumes the whole window (it does not
+            # hold back `trim` frames), so trim must not inflate the phase-carry
+            # index -- it would point past the end of a short window.
+            carry_trim = 0 if finalize else trim
+            tts_speech, _, new_phase_acc = self.hift.inference(
+                speech_feat=f0_input_mel,
+                finalize=finalize,
+                phase_acc=phase_acc,
+                uv_offset=uv_offset,
+                next_overlap=next_overlap,
+                trim=carry_trim,
+                f0_margin=f0_margin,
+            )
 
         tts_speech = tts_speech.reshape(tts_speech.shape[0], -1)
-        speech_offset = max(0, min(speech_offset, int(tts_speech.shape[-1])))
-        emitted_speech = tts_speech[:, speech_offset:]
+        new_samples = chunk_mel.shape[-1] * samples_per_mel
+        if finalize:
+            frames_withheld_per_chunk = trim + self.hift.conv_pre_look_right + 1
+            released = frames_withheld_per_chunk * samples_per_mel
+            emitted_speech = tts_speech[:, -(new_samples + released) :]
+        else:
+            emitted_speech = tts_speech[:, -new_samples:] if new_samples > 0 else tts_speech[:, :0]
 
         if finalize:
             return emitted_speech.reshape(emitted_speech.shape[0], 1, -1), None
 
         new_state = {
-            "mel": tts_mel.detach().cpu().contiguous(),
-            "speech_offset": int(tts_speech.shape[-1]),
+            "mel": f0_input_mel.detach().cpu().contiguous(),
+            "mel_offset": window_offset - f0_margin,
+            "phase_acc": new_phase_acc.detach().cpu().contiguous() if new_phase_acc is not None else None,
         }
         return emitted_speech.reshape(emitted_speech.shape[0], 1, -1), new_state
 
     @torch.inference_mode()
     def forward_streaming_batch(
         self,
-        items: list[dict[str, object]],
+        items: list[StreamingFlowItem],
         *,
         n_timesteps: int = 10,
     ) -> list[tuple[torch.Tensor, dict[str, torch.Tensor] | None]]:
@@ -270,20 +326,16 @@ class CosyVoice3Code2Wav(nn.Module):
         group and passed to the flow as per-row token lengths.
         """
         results: list[tuple[torch.Tensor, dict[str, torch.Tensor] | None] | None] = [None] * len(items)
-        groups: dict[tuple[int, int, int, bool], list[tuple[int, dict[str, object]]]] = {}
+        groups: dict[tuple[int, int, int, bool], list[tuple[int, StreamingFlowItem]]] = {}
         for index, item in enumerate(items):
-            token = item["token"]
-            prompt_token = item["prompt_token"]
-            prompt_feat = item["prompt_feat"]
-            embedding = item["embedding"]
-            assert isinstance(token, torch.Tensor)
-            assert isinstance(prompt_token, torch.Tensor)
-            assert isinstance(prompt_feat, torch.Tensor)
-            assert isinstance(embedding, torch.Tensor)
+            assert isinstance(item["token"], torch.Tensor)
+            assert isinstance(item["prompt_token"], torch.Tensor)
+            assert isinstance(item["prompt_feat"], torch.Tensor)
+            assert isinstance(item["embedding"], torch.Tensor)
             key = (
-                int(prompt_token.shape[1]),
-                int(prompt_feat.shape[1]),
-                int(embedding.shape[1]),
+                int(item["prompt_token"].shape[1]),
+                int(item["prompt_feat"].shape[1]),
+                int(item["embedding"].shape[1]),
                 bool(item.get("finalize", False)),
             )
             groups.setdefault(key, []).append((index, item))
@@ -305,11 +357,11 @@ class CosyVoice3Code2Wav(nn.Module):
             if len(group) == 1:
                 index, item = group[0]
                 result = self.forward_streaming(
-                    token=item["token"],  # type: ignore[arg-type]
-                    prompt_token=item["prompt_token"],  # type: ignore[arg-type]
-                    prompt_feat=item["prompt_feat"],  # type: ignore[arg-type]
-                    embedding=item["embedding"],  # type: ignore[arg-type]
-                    cache_state=item.get("cache_state"),  # type: ignore[arg-type]
+                    token=item["token"],
+                    prompt_token=item["prompt_token"],
+                    prompt_feat=item["prompt_feat"],
+                    embedding=item["embedding"],
+                    cache_state=item.get("cache_state"),
                     n_timesteps=n_timesteps,
                     token_offset_tokens=int(item.get("token_offset_tokens", 0)),
                     finalize=bool(item.get("finalize", False)),
@@ -318,15 +370,13 @@ class CosyVoice3Code2Wav(nn.Module):
                 continue
 
             token_tensors = [item["token"] for _, item in group]
-            assert all(isinstance(token, torch.Tensor) for token in token_tensors)
             token_lens = torch.tensor(
-                [int(token.shape[1]) for token in token_tensors],  # type: ignore[union-attr]
+                [int(token.shape[1]) for token in token_tensors],
                 dtype=torch.int32,
             )
             max_token_len = int(token_lens.max().item())
             padded_tokens = []
             for token in token_tensors:
-                assert isinstance(token, torch.Tensor)
                 if int(token.shape[1]) == max_token_len:
                     padded_tokens.append(token)
                 else:
@@ -337,9 +387,9 @@ class CosyVoice3Code2Wav(nn.Module):
                     )
                     padded_tokens.append(torch.cat([token, pad], dim=1))
             tokens = torch.cat(padded_tokens, dim=0)
-            prompt_tokens = torch.cat([item["prompt_token"] for _, item in group], dim=0)  # type: ignore[list-item]
-            prompt_feats = torch.cat([item["prompt_feat"] for _, item in group], dim=0)  # type: ignore[list-item]
-            embeddings = torch.cat([item["embedding"] for _, item in group], dim=0)  # type: ignore[list-item]
+            prompt_tokens = torch.cat([item["prompt_token"] for _, item in group], dim=0)
+            prompt_feats = torch.cat([item["prompt_feat"] for _, item in group], dim=0)
+            embeddings = torch.cat([item["embedding"] for _, item in group], dim=0)
             prompt_token_lens = torch.full((len(group),), prompt_tokens.shape[1], dtype=torch.int32)
             prompt_feat_lens = torch.full((len(group),), prompt_feats.shape[1], dtype=torch.int32)
             finalize = bool(group[0][1].get("finalize", False))
@@ -370,7 +420,7 @@ class CosyVoice3Code2Wav(nn.Module):
                     row_feat = row_feat[:, :, trim_mel:]
                 results[index] = self._stream_hift_from_feat(
                     row_feat,
-                    cache_state=item.get("cache_state"),  # type: ignore[arg-type]
+                    cache_state=item.get("cache_state"),
                     finalize=finalize,
                 )
 
@@ -443,7 +493,7 @@ class CosyVoice3Code2Wav(nn.Module):
                 dtype=tts_mel.dtype,
             )
         else:
-            tts_speech, _ = self.hift.inference(speech_feat=tts_mel, finalize=True)
+            tts_speech, _, _ = self.hift.inference(speech_feat=tts_mel, finalize=True)
 
         return tts_speech
 
diff --git a/vllm_omni/model_executor/models/dots_tts/__init__.py b/vllm_omni/model_executor/models/dots_tts/__init__.py
deleted file mode 100644
index fb6738a29..000000000
--- a/vllm_omni/model_executor/models/dots_tts/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-# NOTE: Do not import model classes in this file. Importing any
-# submodule in this package triggers __init__.py execution, and
-# both the model registry and pipeline registry import submodules
-# directly — heavy imports here would be loaded as a side effect
-# even though nothing depends on these re-exports.
diff --git a/vllm_omni/model_executor/models/dots_tts/dots_tts_dit.py b/vllm_omni/model_executor/models/dots_tts/dots_tts_dit.py
deleted file mode 100644
index 086ac109a..000000000
--- a/vllm_omni/model_executor/models/dots_tts/dots_tts_dit.py
+++ /dev/null
@@ -1,457 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2026 The vLLM-Omni team.
-# Copyright (c) rednote-hilab. All rights reserved.
-# Adapted from:
-# https://github.com/rednote-hilab/dots.tts/tree/a393d2e/src/dots_tts/modules/backbone
-#
-# Merged from two upstream files (preserved as-is, inference behaviour
-# unchanged; only internal imports were folded inline):
-#   - modules/backbone/layers.py  -> Dropout, Mlp, rotate_half,
-#                                    apply_rotary_pos_emb, RotaryEmbedding,
-#                                    MultiHeadAttention
-#                                    (Conv1d / ConvTranspose1d are NOT
-#                                    re-vendored here — they already live in
-#                                    dots_tts_vocoder.py)
-#   - modules/backbone/dit.py     -> modulate, TimestepEmbedder, FinalLayer,
-#                                    DiTBlock, DiT
-#
-# Per-section upstream attributions are preserved at each section header.
-# Nothing in this file diverges from upstream behaviour.
-
-from __future__ import annotations
-
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from einops import rearrange
-
-# ============================================================================
-# Building blocks (adapted from modules/backbone/layers.py)
-# ----------------------------------------------------------------------------
-# Conv1d / ConvTranspose1d from layers.py are already vendored in
-# dots_tts_vocoder.py (they are used by the BigVGAN-style AudioVAE).  The
-# pieces below are the ones consumed by the DiT flow-matching head.
-# ============================================================================
-
-
-class Dropout(nn.Module):
-    def __init__(self, p: float = 0.5, inplace: bool = False, force_drop: bool = False, **_kwargs):
-        super().__init__()
-        if p < 0.0 or p > 1.0:
-            raise ValueError(f"dropout probability has to be between 0 and 1, but got {p}")
-        self.p = p
-        self.inplace = inplace
-        self.force_drop = force_drop
-
-    def forward(self, x, **_kwargs):
-        return F.dropout(
-            x,
-            p=self.p,
-            training=True if self.force_drop else self.training,
-            inplace=self.inplace,
-        )
-
-
-class Mlp(nn.Module):
-    def __init__(
-        self,
-        hidden_size,
-        ffn_hidden_size=4096,
-        act_layer=nn.GELU,
-        dropout=0.0,
-        **_kwargs,
-    ):
-        super().__init__()
-        self.fc1 = nn.Linear(hidden_size, ffn_hidden_size)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(ffn_hidden_size, hidden_size)
-        self.drop = Dropout(dropout)
-
-    def forward(self, x, _mask=None):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        return self.drop(x)
-
-
-def rotate_half(x):
-    x1, x2 = x.chunk(2, dim=-1)
-    return torch.cat((-x2, x1), dim=-1)
-
-
-@torch.autocast(enabled=False, device_type="cuda")
-def apply_rotary_pos_emb(pos, t):
-    if pos.dim() == 3:
-        pos = pos.unsqueeze(1)
-    return t * pos.cos() + rotate_half(t) * pos.sin()
-
-
-class RotaryEmbedding(nn.Module):
-    def __init__(self, dim, theta=50000):
-        super().__init__()
-        self.register_buffer(
-            "inv_freq",
-            1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim)),
-            persistent=False,
-        )
-        self._theta = float(theta)
-
-    def _apply(self, fn):
-        inv_freq = self.inv_freq
-        super()._apply(fn)
-        self.inv_freq = inv_freq.to(device=self.inv_freq.device, dtype=torch.float32)
-        return self
-
-    @torch.autocast(enabled=False, device_type="cuda")
-    def forward(self, t):
-        inv_freq = self.inv_freq
-        if inv_freq.device != t.device:
-            raise RuntimeError(f"RotaryEmbedding buffer device mismatch: inv_freq={inv_freq.device} input={t.device}.")
-        t = t.to(dtype=inv_freq.dtype)
-        if t.dim() == 1:
-            freqs = torch.einsum("i , j -> i j", t, inv_freq)
-        else:
-            freqs = torch.einsum("bi, j -> bij", t, inv_freq)
-        return torch.cat((freqs, freqs), dim=-1)
-
-
-class MultiHeadAttention(nn.Module):
-    """Multi-head attention"""
-
-    def __init__(
-        self,
-        hidden_size: int,
-        num_heads: int = 8,
-        qkv_bias: bool = False,
-        qk_norm: bool = False,
-        attn_drop: float = 0.0,
-        dropout: float = 0.0,
-        norm_layer: str = "LayerNorm",
-        rotary_bias: bool = False,
-        rotary_theta: float | None = 50000,
-        **_kwargs,
-    ):
-        super().__init__()
-        assert hidden_size % num_heads == 0, "hidden_size should be divisible by num_heads"
-        self.num_heads = num_heads
-        self.head_dim = hidden_size // num_heads
-        self.scale = self.head_dim**-0.5
-        self.rotary_bias = rotary_bias
-
-        self.q_proj = nn.Linear(hidden_size, hidden_size, bias=qkv_bias)
-        self.k_proj = nn.Linear(hidden_size, hidden_size, bias=qkv_bias)
-        self.v_proj = nn.Linear(hidden_size, hidden_size, bias=qkv_bias)
-
-        norm_layer = getattr(nn, norm_layer)
-        self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
-        self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
-
-        self.attn_drop = Dropout(attn_drop)
-        self.o_proj = nn.Linear(hidden_size, hidden_size)
-        self.o_dropout = Dropout(dropout)
-
-        if self.rotary_bias:
-            self.rotary = RotaryEmbedding(self.head_dim, theta=rotary_theta)
-
-    def forward(self, q, k=None, v=None, mask=None, pos_ids=None, **_kwargs):
-        k = k or q
-        v = v or q
-        B, L, _ = q.shape
-        _, S, _ = v.shape
-        if mask is not None:
-            if mask.ndim == 2:  # [B, L]
-                assert L == S
-                mask = rearrange(mask, "b j -> b 1 1 j")
-                mask = mask.expand(-1, self.num_heads, L, -1)
-            elif mask.ndim == 3:  # [B, L, S]
-                assert mask.size(1) == L and mask.size(2) == S
-                mask = mask.unsqueeze(1).expand(-1, self.num_heads, -1, -1)
-
-        q, k, v = self.q_proj(q), self.k_proj(k), self.v_proj(v)
-        q = rearrange(q, "b n (h d) -> b h n d", h=self.num_heads)
-        k = rearrange(k, "b n (h d) -> b h n d", h=self.num_heads)
-        v = rearrange(v, "b n (h d) -> b h n d", h=self.num_heads)
-        q, k = self.q_norm(q), self.k_norm(k)
-
-        # Apply rotary
-        if self.rotary_bias:
-            if L == S:
-                if pos_ids is None:
-                    rotary_emb = self.rotary(torch.arange(L, device=q.device))
-                else:
-                    rotary_emb = self.rotary(pos_ids)
-                q, k = (apply_rotary_pos_emb(rotary_emb, tensor) for tensor in (q, k))
-            else:
-                q_rotary_emb = self.rotary(torch.arange(L, device=q.device))
-                k_rotary_emb = self.rotary(torch.arange(S, device=k.device))
-                q = apply_rotary_pos_emb(q_rotary_emb, q)
-                k = apply_rotary_pos_emb(k_rotary_emb, k)
-
-        attn_bias = torch.zeros(B, self.num_heads, L, S, dtype=q.dtype, device=q.device)
-
-        if mask is not None:
-            attn_bias.masked_fill_(mask.logical_not(), float("-inf"))
-
-        out = F.scaled_dot_product_attention(
-            q,
-            k,
-            v,
-            attn_mask=attn_bias,
-            dropout_p=self.attn_drop.p if self.training else 0.0,
-        )
-
-        out = rearrange(out, "b h n d -> b n (h d)")
-        return self.o_dropout(self.o_proj(out))
-
-    def decode_step(self, x, *, cache, positions: torch.Tensor):
-        if x.size(1) <= 0:
-            raise ValueError("MultiHeadAttention.decode_step expects a non-empty input.")
-        if positions.ndim != 1 or positions.size(0) != x.size(1):
-            raise ValueError("MultiHeadAttention.decode_step positions must match the decode block length.")
-
-        q = self.q_proj(x)
-        k = self.k_proj(x)
-        v = self.v_proj(x)
-
-        q = rearrange(q, "b n (h d) -> b h n d", h=self.num_heads)
-        k = rearrange(k, "b n (h d) -> b h n d", h=self.num_heads)
-        v = rearrange(v, "b n (h d) -> b h n d", h=self.num_heads)
-        q, k = self.q_norm(q), self.k_norm(k)
-        block_len = q.size(2)
-
-        if self.rotary_bias:
-            rotary_emb = self.rotary(positions)
-            q = apply_rotary_pos_emb(rotary_emb, q)
-            k = apply_rotary_pos_emb(rotary_emb, k)
-
-        cached_k, cached_v = cache
-        cached_k.index_copy_(2, positions, k)
-        cached_v.index_copy_(2, positions, v)
-
-        cache_capacity = cached_k.size(2)
-        key_positions = torch.arange(
-            cache_capacity,
-            device=x.device,
-            dtype=torch.long,
-        ).unsqueeze(0)
-        query_positions = positions.unsqueeze(1)
-        causal_mask = key_positions <= query_positions
-        valid_mask = key_positions <= positions[-1]
-        attn_bias = torch.zeros(
-            q.size(0),
-            self.num_heads,
-            block_len,
-            cache_capacity,
-            dtype=q.dtype,
-            device=q.device,
-        )
-        attn_bias.masked_fill_(
-            (causal_mask & valid_mask).unsqueeze(0).unsqueeze(0).logical_not(),
-            float("-inf"),
-        )
-
-        out = F.scaled_dot_product_attention(
-            q,
-            cached_k,
-            cached_v,
-            attn_mask=attn_bias,
-            dropout_p=self.attn_drop.p if self.training else 0.0,
-        )
-        out = rearrange(out, "b h n d -> b n (h d)")
-        return self.o_dropout(self.o_proj(out)), cache
-
-
-# ============================================================================
-# DiT flow-matching head (adapted from modules/backbone/dit.py)
-# ----------------------------------------------------------------------------
-# DiT.__init__ takes a ``transformer_config`` object exposing ``.to_dict()``,
-# ``.hidden_size`` and ``.num_layers``.  Upstream constructs it from a pydantic
-# config class higher up the stack; vLLM-Omni callers can pass anything that
-# satisfies the same minimal interface (e.g. a stdlib @dataclass with a
-# ``to_dict`` method or SimpleNamespace).  See dots_tts_talker.py for the
-# concrete soar-checkpoint config factory.
-# ============================================================================
-
-
-def modulate(x, shift, scale, **_kwargs):
-    return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
-
-
-class TimestepEmbedder(nn.Module):
-    def __init__(self, hidden_size, frequency_embedding_size=256):
-        super().__init__()
-        self.mlp = nn.Sequential(
-            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
-            nn.SiLU(),
-            nn.Linear(hidden_size, hidden_size, bias=True),
-        )
-        self.frequency_embedding_size = frequency_embedding_size
-
-    @staticmethod
-    def timestep_embedding(t, dim, max_period=10000):
-        half = dim // 2
-        freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half).to(
-            device=t.device
-        )
-        args = t[:, None].float() * freqs[None]
-        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
-        if dim % 2:
-            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
-        return embedding
-
-    def forward(self, t):
-        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
-        return self.mlp(t_freq)
-
-
-class FinalLayer(nn.Module):
-    def __init__(self, hidden_size, output_size):
-        super().__init__()
-        self.adaLN_modulation = nn.Sequential(
-            nn.SiLU(),
-            nn.Linear(hidden_size, 2 * hidden_size, bias=True),
-        )
-        self.norm = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-5)
-        self.linear = nn.Linear(hidden_size, output_size, bias=True)
-
-    def forward(self, x, c, **_kwargs):
-        shift, scale = self.adaLN_modulation(c).chunk(2, dim=1)
-        x = modulate(self.norm(x), shift, scale)
-        return self.linear(x)
-
-
-class DiTBlock(nn.Module):
-    def __init__(
-        self,
-        attention: nn.Module,
-        ffn: nn.Module,
-        hidden_size: int = 1024,
-        modulation: bool = False,
-        eps: float = 1e-5,
-        **_kwargs,
-    ):
-        super().__init__()
-        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=not modulation, eps=eps)
-        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=not modulation, eps=eps)
-        self.attn = attention
-        self.ffn = ffn
-        self.modulation = modulation
-        if modulation:
-            self.adaLN_modulation = nn.Sequential(
-                nn.SiLU(),
-                nn.Linear(hidden_size, 6 * hidden_size, bias=True),
-            )
-
-    def forward(self, x, condition=None, mask=None, **kwargs):
-        if condition is None:
-            assert not self.modulation, "Without global condition, must set modulation to False"
-        else:
-            assert self.modulation, "With global condition, must set modulation to True"
-            shift_attn, scale_attn, gate_attn, shift_ffn, scale_ffn, gate_ffn = self.adaLN_modulation(condition).chunk(
-                6, dim=1
-            )
-
-        if condition is not None:
-            pack_indices = kwargs.get("pack_indices")
-            if pack_indices is not None:
-                gate_attn = gate_attn[pack_indices]
-                gate_ffn = gate_ffn[pack_indices]
-            else:
-                gate_attn = gate_attn.unsqueeze(1)
-                gate_ffn = gate_ffn.unsqueeze(1)
-
-        if condition is not None:
-            x = x + gate_attn * self.attn(
-                modulate(self.norm1(x), shift_attn, scale_attn, **kwargs),
-                mask=mask,
-                **kwargs,
-            )
-        else:
-            x = x + self.attn(self.norm1(x), mask=mask, **kwargs)
-
-        if condition is not None:
-            x = x + gate_ffn * self.ffn(modulate(self.norm2(x), shift_ffn, scale_ffn, **kwargs))
-        else:
-            x = x + self.ffn(self.norm2(x), mask=mask)
-        return x
-
-
-class DiT(nn.Module):
-    def __init__(
-        self,
-        in_dim,
-        out_dim,
-        transformer_config,
-        *,
-        mode: str = "flow_matching",
-    ):
-        super().__init__()
-        if mode not in {"flow_matching", "meanflow"}:
-            raise ValueError(f"DiT mode must be 'flow_matching' or 'meanflow', got {mode!r}.")
-
-        transformer_kwargs = transformer_config.to_dict()
-        model_dim = transformer_config.hidden_size
-        self.mode = mode
-        self.num_layers = transformer_config.num_layers
-
-        self.input_layer = nn.Linear(in_dim, model_dim)
-        self.time_embedder = TimestepEmbedder(model_dim)
-        if mode == "meanflow":
-            self.duration_embedder = TimestepEmbedder(model_dim)
-
-        self.blocks = nn.ModuleList()
-        for i in range(self.num_layers):
-            attn_block = MultiHeadAttention(**transformer_kwargs, name=f"layer_{i}")
-            ffn_block = Mlp(act_layer=lambda: nn.GELU(approximate="tanh"), **transformer_kwargs)
-            self.blocks.append(DiTBlock(attention=attn_block, ffn=ffn_block, **transformer_kwargs))
-
-        self.output_layer = FinalLayer(model_dim, out_dim)
-        self.initialize_weights()
-
-    def initialize_weights(self):
-        def _basic_init(module):
-            if isinstance(module, nn.Linear):
-                torch.nn.init.xavier_uniform_(module.weight)
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-
-        self.apply(_basic_init)
-
-        nn.init.normal_(self.time_embedder.mlp[0].weight, std=0.02)
-        nn.init.normal_(self.time_embedder.mlp[2].weight, std=0.02)
-
-        for block in self.blocks:
-            if hasattr(block, "adaLN_modulation"):
-                nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
-                nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
-
-        nn.init.constant_(self.output_layer.adaLN_modulation[-1].weight, 0)
-        nn.init.constant_(self.output_layer.adaLN_modulation[-1].bias, 0)
-        nn.init.constant_(self.output_layer.linear.weight, 0)
-        nn.init.constant_(self.output_layer.linear.bias, 0)
-
-    def forward(
-        self,
-        x,
-        timesteps,
-        duration: torch.Tensor | None = None,
-        mask=None,
-        attn_mask=None,
-        g_cond: torch.Tensor | None = None,
-        **kwargs,
-    ):
-        t = self.time_embedder(timesteps)
-        c = t
-        duration_embedder = getattr(self, "duration_embedder", None)
-        if duration_embedder is not None and duration is not None:
-            c = c + duration_embedder(duration)
-        if g_cond is not None:
-            c = c + g_cond
-
-        x = self.input_layer(x)
-        for block in self.blocks:
-            x = block(x, c, mask=attn_mask, **kwargs)
-        return self.output_layer(x, c, **kwargs)
diff --git a/vllm_omni/model_executor/models/dots_tts/dots_tts_patch_encoder.py b/vllm_omni/model_executor/models/dots_tts/dots_tts_patch_encoder.py
deleted file mode 100644
index 39d1a4973..000000000
--- a/vllm_omni/model_executor/models/dots_tts/dots_tts_patch_encoder.py
+++ /dev/null
@@ -1,355 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2026 The vLLM-Omni team.
-# Copyright (c) rednote-hilab. All rights reserved.
-# Adapted from:
-# https://github.com/rednote-hilab/dots.tts/tree/a393d2e/src/dots_tts/modules/backbone
-#
-# Single upstream source (preserved as-is, inference behaviour unchanged;
-# only the internal `from dots_tts.modules.backbone.layers import ...` line
-# was folded to point at our sibling vendor files):
-#   - modules/backbone/semantic_encoder.py -> SemanticEncoderDecodeState,
-#                                             TransformerEncoderLayer,
-#                                             SuperviseEncoder,
-#                                             VAESemanticEncoder
-#
-# Building blocks (Conv1d / Mlp / MultiHeadAttention) are imported from the
-# sibling vendor files where they already live:
-#   - Conv1d              <- dots_tts_vocoder.py
-#   - Mlp                 <- dots_tts_dit.py
-#   - MultiHeadAttention  <- dots_tts_dit.py
-#
-# Nothing else in this file diverges from upstream behaviour.
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from einops import rearrange
-
-from vllm_omni.model_executor.models.dots_tts.dots_tts_dit import (
-    Mlp,
-    MultiHeadAttention,
-)
-from vllm_omni.model_executor.models.dots_tts.dots_tts_vocoder import Conv1d
-
-
-@dataclass
-class SemanticEncoderDecodeState:
-    conv_tail: torch.Tensor
-    layer_caches: tuple[tuple[torch.Tensor, torch.Tensor], ...]
-    seq_len: int
-
-
-class TransformerEncoderLayer(nn.Module):
-    def __init__(
-        self,
-        hidden_size,
-        num_heads=16,
-        ffn_hidden_size=4096,
-        attn_dropout=0.0,
-        ffn_dropout=0.0,
-        norm_layer="LayerNorm",
-        **kwargs,
-    ):
-        super().__init__()
-        self.attn = MultiHeadAttention(
-            hidden_size,
-            num_heads,
-            attn_drop=attn_dropout,
-            norm_layer=norm_layer,
-            **kwargs,
-        )
-        norm_cls = getattr(nn, norm_layer)
-        self.attn_norm = norm_cls(hidden_size)
-        self.ffn = Mlp(hidden_size, ffn_hidden_size, dropout=ffn_dropout, act_layer=nn.SiLU)
-        self.ffn_norm = norm_cls(hidden_size)
-        self.hidden_size = hidden_size
-
-    def _build_causal_mask(self, T: int, device):  # noqa: N803
-        return torch.tril(torch.ones(T, T, dtype=torch.bool, device=device))
-
-    def _build_padding_mask(self, x_lens, max_len: int, device):
-        B = x_lens.size(0)
-        positions = torch.arange(max_len, device=device).unsqueeze(0).expand(B, -1)
-        return positions < x_lens.unsqueeze(1)
-
-    def _fuse_attn_mask(self, causal_mask, padding_mask):
-        if causal_mask is None and padding_mask is None:
-            return None
-        if causal_mask is None:
-            row = padding_mask.unsqueeze(2)
-            col = padding_mask.unsqueeze(1)
-            return row & col
-        if padding_mask is None:
-            return causal_mask.unsqueeze(0)
-
-        _B, _T = padding_mask.shape
-        causal = causal_mask.unsqueeze(0)
-        row = padding_mask.unsqueeze(2)
-        col = padding_mask.unsqueeze(1)
-        pad_2d = row & col
-        return causal & pad_2d
-
-    def forward(
-        self,
-        x,
-        x_lens=None,
-        causal=True,
-    ):
-        _B, T, C = x.shape
-        assert self.hidden_size == C
-        device = x.device
-
-        causal_mask = self._build_causal_mask(T, device) if causal else None
-        if x_lens is not None:
-            padding_mask = self._build_padding_mask(x_lens, T, device)
-        else:
-            padding_mask = None
-        fused_mask = self._fuse_attn_mask(causal_mask, padding_mask)
-
-        h = self.attn_norm(x)
-        h = self.attn(
-            q=h,
-            mask=fused_mask,
-        )
-        x = x + h
-
-        h = self.ffn_norm(x)
-        h = self.ffn(h)
-        return x + h
-
-    def decode_step(
-        self,
-        x,
-        *,
-        cache: tuple[torch.Tensor, torch.Tensor],
-        positions: torch.Tensor,
-    ):
-        if x.size(1) <= 0:
-            raise ValueError("TransformerEncoderLayer.decode_step expects a non-empty input.")
-
-        h = self.attn_norm(x)
-        h, cache = self.attn.decode_step(h, cache=cache, positions=positions)
-        x = x + h
-
-        h = self.ffn_norm(x)
-        h = self.ffn(h)
-        return x + h, cache
-
-
-class SuperviseEncoder(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.hidden_size = config.get("hidden_size", 1024)
-        self.layers = nn.ModuleList(
-            [
-                TransformerEncoderLayer(
-                    hidden_size=self.hidden_size,
-                    num_heads=config.get("num_heads", 16),
-                    ffn_hidden_size=config.get("ffn_hidden_size", 4096),
-                    norm_layer=config.get("norm_layer", "LayerNorm"),
-                )
-                for _ in range(config.get("num_layers", 6))
-            ]
-        )
-        self.causal = config.get("causal", False)
-
-    def forward(self, x, x_lens=None):
-        batch_size, seq_len, _ = x.shape
-        if x_lens is None:
-            x_lens = torch.full((batch_size,), seq_len, device=x.device, dtype=torch.long)
-        for layer in self.layers:
-            x = layer(x, x_lens=x_lens, causal=self.causal)
-        return x
-
-    def init_decode_state(
-        self,
-        *,
-        batch_size: int,
-        max_seq_len: int,
-        device: torch.device,
-        dtype: torch.dtype,
-    ):
-        layer_caches = []
-        for layer in self.layers:
-            cache_shape = (
-                batch_size,
-                layer.attn.num_heads,
-                max_seq_len,
-                layer.attn.head_dim,
-            )
-            layer_caches.append(
-                (
-                    torch.zeros(cache_shape, dtype=dtype, device=device),
-                    torch.zeros(cache_shape, dtype=dtype, device=device),
-                )
-            )
-        return tuple(layer_caches)
-
-    def reset_decode_state(
-        self,
-        layer_caches: tuple[tuple[torch.Tensor, torch.Tensor], ...],
-    ) -> None:
-        if len(layer_caches) != len(self.layers):
-            raise ValueError("Layer cache count does not match encoder depth.")
-        for key_cache, value_cache in layer_caches:
-            key_cache.zero_()
-            value_cache.zero_()
-
-    def decode_step(self, x, *, layer_caches, positions: torch.Tensor):
-        if len(layer_caches) != len(self.layers):
-            raise ValueError("Layer cache count does not match encoder depth.")
-
-        for layer, cache in zip(self.layers, layer_caches, strict=True):
-            x, _ = layer.decode_step(x, cache=cache, positions=positions)
-        return x
-
-
-class VAESemanticEncoder(nn.Module):
-    def __init__(self, in_dim, out_dim, config):
-        super().__init__()
-        in_ds_rate = 2
-        self.patch_size = int(config.patch_size)
-        self.in_ds_rate = in_ds_rate
-        self.ds_proj = Conv1d(in_dim, in_dim, kernel_size=in_ds_rate, stride=in_ds_rate, causal=True)
-        self.in_proj = nn.Linear(in_dim, config.PatchEncoder.hidden_size)
-        self.encoder = SuperviseEncoder(config.PatchEncoder)
-        self.out_ds_rate = self.patch_size // in_ds_rate
-        self.out_proj = nn.Linear(config.PatchEncoder.hidden_size * self.out_ds_rate, out_dim)
-
-    def forward(self, x, x_lens=None):
-        x = self._downsample(x)
-        x = self.in_proj(x)
-        z = self.encoder(x, x_lens=x_lens)
-        return self._project_embeddings(z)
-
-    def init_decode_state(
-        self,
-        *,
-        max_audio_patch_count: int,
-        batch_size: int,
-        device: torch.device,
-        dtype: torch.dtype,
-    ) -> SemanticEncoderDecodeState:
-        return SemanticEncoderDecodeState(
-            conv_tail=torch.zeros(
-                (batch_size, self.ds_proj.in_channels, self.ds_proj.left_padding),
-                dtype=dtype,
-                device=device,
-            ),
-            layer_caches=self.encoder.init_decode_state(
-                batch_size=batch_size,
-                max_seq_len=max_audio_patch_count * self.out_ds_rate,
-                device=device,
-                dtype=dtype,
-            ),
-            seq_len=0,
-        )
-
-    def reset_decode_state(self, state: SemanticEncoderDecodeState) -> None:
-        state.conv_tail.zero_()
-        self.encoder.reset_decode_state(state.layer_caches)
-        state.seq_len = 0
-
-    def prefill(
-        self,
-        x,
-        state: SemanticEncoderDecodeState,
-    ) -> tuple[torch.Tensor, SemanticEncoderDecodeState]:
-        if x.ndim != 3:
-            raise ValueError(f"VAESemanticEncoder.prefill expects rank-3 input, got {tuple(x.shape)}.")
-        if x.size(1) % self.patch_size != 0:
-            raise ValueError(f"Prompt latent length {x.size(1)} must be divisible by patch_size={self.patch_size}.")
-
-        if x.size(1) == 0:
-            return (
-                x.new_zeros((x.size(0), 0, self.out_proj.out_features)),
-                state,
-            )
-        if state.conv_tail.size(0) != x.size(0):
-            raise ValueError("VAESemanticEncoder.prefill batch size does not match decode state.")
-
-        step_inputs = self.in_proj(self._downsample(x))
-        expected_token_count = (x.size(1) // self.patch_size) * self.out_ds_rate
-        if step_inputs.size(1) != expected_token_count:
-            raise RuntimeError(
-                "Patch encoder prefill produced an unexpected token count: "
-                f"expected={expected_token_count} actual={step_inputs.size(1)}."
-            )
-
-        current_seq_len = state.seq_len
-        next_seq_len = current_seq_len + step_inputs.size(1)
-        cache_capacity = state.layer_caches[0][0].size(2)
-        if next_seq_len > cache_capacity:
-            raise ValueError(
-                "Patch encoder prefill exceeds decode-state capacity: "
-                f"required={next_seq_len} capacity={cache_capacity}."
-            )
-
-        positions = torch.arange(step_inputs.size(1), device=x.device, dtype=torch.long) + current_seq_len
-        encoded = self.encoder.decode_step(
-            step_inputs,
-            layer_caches=state.layer_caches,
-            positions=positions,
-        )
-        embedding = self._project_embeddings(encoded)
-        raw = x.transpose(1, 2)
-        state.conv_tail.copy_(raw[..., -self.ds_proj.left_padding :])
-        state.seq_len = next_seq_len
-        return embedding, state
-
-    def decode_patch(
-        self,
-        latent_patch,
-        conv_tail: torch.Tensor,
-        layer_caches: tuple[tuple[torch.Tensor, torch.Tensor], ...],
-        positions: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        if latent_patch.ndim != 3:
-            raise ValueError(f"VAESemanticEncoder.decode_patch expects rank-3 input, got {tuple(latent_patch.shape)}.")
-        if latent_patch.size(1) != self.patch_size:
-            raise ValueError(f"decode_patch expects patch length {self.patch_size}, got {latent_patch.size(1)}.")
-        if positions.ndim != 1 or positions.size(0) != self.out_ds_rate:
-            raise ValueError("decode_patch positions must be a rank-1 tensor matching out_ds_rate.")
-
-        step_inputs, conv_tail = self._downsample_step(
-            latent_patch,
-            conv_tail=conv_tail,
-        )
-        if step_inputs.size(1) != self.out_ds_rate:
-            raise RuntimeError(f"Downsample step produced {step_inputs.size(1)} tokens, expected {self.out_ds_rate}.")
-
-        encoded = self.encoder.decode_step(
-            step_inputs,
-            layer_caches=layer_caches,
-            positions=positions,
-        )
-        embedding = self._project_embeddings(encoded)
-        return embedding, conv_tail
-
-    def _downsample(self, x):
-        return self.ds_proj(x.transpose(1, 2)).transpose(1, 2)
-
-    def _project_embeddings(self, z):
-        if self.out_ds_rate > 1:
-            z = rearrange(z, "b (s d) h -> b s (d h)", d=self.out_ds_rate)
-        return self.out_proj(z)
-
-    def _downsample_step(self, latent_patch, *, conv_tail):
-        raw = latent_patch.transpose(1, 2)
-        conv_input = torch.cat([conv_tail, raw], dim=-1)
-
-        projected = F.conv1d(
-            conv_input,
-            self.ds_proj.weight,
-            self.ds_proj.bias,
-            stride=self.ds_proj.stride[0],
-            padding=0,
-            dilation=self.ds_proj.dilation[0],
-            groups=self.ds_proj.groups,
-        ).transpose(1, 2)
-        new_conv_tail = raw[..., -self.ds_proj.left_padding :]
-        return self.in_proj(projected), new_conv_tail
diff --git a/vllm_omni/model_executor/models/dots_tts/dots_tts_prompt.py b/vllm_omni/model_executor/models/dots_tts/dots_tts_prompt.py
deleted file mode 100644
index a2c4ac9f9..000000000
--- a/vllm_omni/model_executor/models/dots_tts/dots_tts_prompt.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""dots.tts prompt builder for vllm-omni's Omni engine + serving layer.
-
-Mirrors upstream ``build_generation_schedule`` (rednote-hilab/dots.tts @
-a393d2e data/pipelines/tokenizing.py:169) for the
-no-prompt-audio + audio-placeholder path — text-only zero-shot TTS.
-
-V1 returns real Qwen2 token IDs (not placeholders ``[1] * N`` like
-voxcpm2's builder).  Reason: our talker's preprocess() runs
-``self.model.embed_tokens(input_ids)`` directly, so real IDs flow
-through naturally.  voxcpm2 uses placeholders because its prefill mixes
-reference-audio embeddings (no token IDs); dots.tts V1 zero-shot is
-purely text + audio_gen_start, all real IDs.
-
-Voice clone (reference audio + speaker x-vector) is intentionally not
-wired here — V1 is zero-shot only.  Add reference_audio /
-voice_profile / prompt_text branches in a follow-up (mirror voxcpm2
-``build_voxcpm2_prompt``).
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from vllm.inputs import tokens_input
-
-# Upstream rednote-hilab/dots.tts @ a393d2e
-# data/pipelines/tts_pipeline.py:17-18
-_TTS_TEXT_PREFIX = "[文本]"
-_TTS_AUDIO_PREFIX = "[文本对应语音]"
-_AUDIO_GEN_START_TOKEN = "<|audio_gen_start|>"
-
-
-def build_dots_tts_prompt(
-    tokenizer: Any,
-    text: str,
-) -> dict[str, Any]:
-    """Build a dots.tts prefill prompt dict for ``Omni.generate()``.
-
-    Returns ``{"prompt_token_ids": [...], "additional_information": {...}}``
-    where ``prompt_token_ids`` is the real Qwen2 token sequence:
-
-        [text_tokens of "[文本]<text>[文本对应语音]", audio_gen_start_id]
-
-    talker's preprocess() embeds these into ``hidden_states`` for the AR
-    base LM.  Decode then drives via ``state.curr_embed_for_next`` (DiT
-    → patch_encoder AR loopback).
-    """
-    if not isinstance(text, str) or not text.strip():
-        raise ValueError(f"text must be a non-empty string, got {text!r}")
-
-    prompt_text = f"{_TTS_TEXT_PREFIX}{text}{_TTS_AUDIO_PREFIX}"
-    text_ids = tokenizer.encode(prompt_text, add_special_tokens=False)
-
-    audio_gen_start_id = tokenizer.convert_tokens_to_ids(_AUDIO_GEN_START_TOKEN)
-    if not isinstance(audio_gen_start_id, int) or audio_gen_start_id == tokenizer.unk_token_id:
-        raise ValueError(
-            f"Tokenizer does not know {_AUDIO_GEN_START_TOKEN!r} "
-            f"(got id={audio_gen_start_id!r}).  Did you load the "
-            f"dots.tts tokenizer (with added_tokens.json)?"
-        )
-    prompt_token_ids = list(text_ids) + [audio_gen_start_id]
-
-    prompt = tokens_input(prompt_token_ids=prompt_token_ids)
-    prompt["additional_information"] = {
-        # Reserved for future voice clone (ref_audio / speaker x-vector).
-        # V1 zero-shot leaves this empty; preprocess() ignores it.
-    }
-    return prompt
diff --git a/vllm_omni/model_executor/models/dots_tts/dots_tts_speaker_encoder.py b/vllm_omni/model_executor/models/dots_tts/dots_tts_speaker_encoder.py
deleted file mode 100644
index 09961d0ab..000000000
--- a/vllm_omni/model_executor/models/dots_tts/dots_tts_speaker_encoder.py
+++ /dev/null
@@ -1,732 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2026 The vLLM-Omni team.
-# Copyright (c) rednote-hilab. All rights reserved.
-# Portions Copyright 3D-Speaker
-# (https://github.com/alibaba-damo-academy/3D-Speaker), Apache-2.0.
-# Adapted from:
-# https://github.com/rednote-hilab/dots.tts/tree/a393d2e/src/dots_tts/modules/speaker
-# (whose CAM++ implementation is itself adapted from 3D-Speaker).
-#
-# Merged from four upstream files (preserved as-is, inference behaviour
-# unchanged; only internal cross-module imports were folded inline):
-#   - modules/speaker/encoder.py         -> SpeakerXVectorFeatures
-#   - modules/speaker/fbank.py           -> fbank constants + extract_speaker_fbank
-#   - modules/speaker/campplus.py        -> FCM, CAMPPlus
-#   - modules/speaker/campplus_layers.py -> get_nonlinear, statistics_pooling,
-#                                           StatsPool, TDNNLayer, CAMLayer,
-#                                           CAMDenseTDNNLayer, CAMDenseTDNNBlock,
-#                                           TransitLayer, DenseLayer, BasicResBlock
-#
-# Plus two tiny helpers folded from utils/audio.py (used by
-# extract_speaker_fbank):
-#   - high_quality_resample, extract_fbank
-#
-# Nothing in this file diverges from upstream behaviour.
-
-from __future__ import annotations
-
-import math
-import random
-from collections import OrderedDict
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as cp
-import torchaudio
-import torchaudio.compliance.kaldi as Kaldi
-import torchaudio.functional as AF
-from torch.nn.utils.rnn import pad_sequence
-
-# ============================================================================
-# Constants (from modules/speaker/fbank.py)
-# ============================================================================
-
-_SPEAKER_FBANK_SAMPLE_RATE = 16000
-_SPEAKER_FBANK_N_MELS = 80
-_SPEAKER_FBANK_MEAN_NORM = True
-_SPEAKER_FBANK_DITHER = 0.0
-
-
-# ============================================================================
-# Audio helpers (folded from utils/audio.py — used by extract_speaker_fbank)
-# ============================================================================
-
-
-def high_quality_resample(x, orig_sr, target_sr):
-    return AF.resample(
-        x,
-        orig_freq=orig_sr,
-        new_freq=target_sr,
-        lowpass_filter_width=64,
-        rolloff=0.95,
-        resampling_method="sinc_interp_kaiser",
-    )
-
-
-def extract_fbank(
-    waveform: torch.Tensor,
-    *,
-    sample_rate: int,
-    n_mels: int,
-    dither: float = 0.0,
-    mean_norm: bool = False,
-) -> torch.Tensor:
-    if waveform.ndim == 1:
-        feature_input = waveform.unsqueeze(0)
-    elif waveform.ndim == 2:
-        feature_input = waveform if waveform.size(0) == 1 else waveform[0:1, :]
-    else:
-        raise ValueError(f"FBank expects a 1D or 2D waveform, got shape {tuple(waveform.shape)}.")
-    features = Kaldi.fbank(
-        feature_input,
-        num_mel_bins=n_mels,
-        sample_frequency=sample_rate,
-        dither=dither,
-    )
-    if mean_norm:
-        features = features - features.mean(dim=0, keepdim=True)
-    return features
-
-
-# ============================================================================
-# Speaker fbank entry (from modules/speaker/fbank.py)
-# ============================================================================
-
-
-def extract_speaker_fbank(
-    waveform: torch.Tensor,
-    *,
-    sample_rate: int,
-) -> torch.Tensor:
-    feature_input = waveform
-    if sample_rate != _SPEAKER_FBANK_SAMPLE_RATE:
-        feature_input = high_quality_resample(
-            waveform,
-            orig_sr=sample_rate,
-            target_sr=_SPEAKER_FBANK_SAMPLE_RATE,
-        )
-    return extract_fbank(
-        feature_input,
-        sample_rate=_SPEAKER_FBANK_SAMPLE_RATE,
-        n_mels=_SPEAKER_FBANK_N_MELS,
-        dither=_SPEAKER_FBANK_DITHER,
-        mean_norm=_SPEAKER_FBANK_MEAN_NORM,
-    )
-
-
-# ============================================================================
-# CAM++ building blocks (from modules/speaker/campplus_layers.py)
-# ----------------------------------------------------------------------------
-# 3D-Speaker, Apache-2.0.
-# ============================================================================
-
-
-def get_nonlinear(config_str, channels):
-    nonlinear = nn.Sequential()
-    for name in config_str.split("-"):
-        if name == "relu":
-            nonlinear.add_module("relu", nn.ReLU(inplace=True))
-        elif name == "prelu":
-            nonlinear.add_module("prelu", nn.PReLU(channels))
-        elif name == "batchnorm":
-            nonlinear.add_module("batchnorm", nn.BatchNorm1d(channels))
-        elif name == "batchnorm_":
-            nonlinear.add_module("batchnorm", nn.BatchNorm1d(channels, affine=False))
-        else:
-            raise ValueError(f"Unexpected module ({name}).")
-    return nonlinear
-
-
-def statistics_pooling(x, dim=-1, keepdim=False, unbiased=True, _eps=1e-2):
-    mean = x.mean(dim=dim)
-    std = x.std(dim=dim, unbiased=unbiased)
-    stats = torch.cat([mean, std], dim=-1)
-    if keepdim:
-        stats = stats.unsqueeze(dim=dim)
-    return stats
-
-
-class StatsPool(nn.Module):
-    def forward(self, x):
-        return statistics_pooling(x)
-
-
-class TDNNLayer(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        kernel_size,
-        stride=1,
-        padding=0,
-        dilation=1,
-        bias=False,
-        config_str="batchnorm-relu",
-    ):
-        super().__init__()
-        if padding < 0:
-            assert kernel_size % 2 == 1, f"Expect equal paddings, but got even kernel size ({kernel_size})"
-            padding = (kernel_size - 1) // 2 * dilation
-        self.linear = nn.Conv1d(
-            in_channels,
-            out_channels,
-            kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias,
-        )
-        self.nonlinear = get_nonlinear(config_str, out_channels)
-
-    def forward(self, x):
-        x = self.linear(x)
-        return self.nonlinear(x)
-
-
-class CAMLayer(nn.Module):
-    def __init__(
-        self,
-        bn_channels,
-        out_channels,
-        kernel_size,
-        stride,
-        padding,
-        dilation,
-        bias,
-        reduction=2,
-    ):
-        super().__init__()
-        self.linear_local = nn.Conv1d(
-            bn_channels,
-            out_channels,
-            kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias,
-        )
-        self.linear1 = nn.Conv1d(bn_channels, bn_channels // reduction, 1)
-        self.relu = nn.ReLU(inplace=True)
-        self.linear2 = nn.Conv1d(bn_channels // reduction, out_channels, 1)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        y = self.linear_local(x)
-        context = x.mean(-1, keepdim=True) + self.seg_pooling(x)
-        context = self.relu(self.linear1(context))
-        m = self.sigmoid(self.linear2(context))
-        return y * m
-
-    def seg_pooling(self, x, seg_len=100, stype="avg"):
-        if stype == "avg":
-            seg = F.avg_pool1d(x, kernel_size=seg_len, stride=seg_len, ceil_mode=True)
-        elif stype == "max":
-            seg = F.max_pool1d(x, kernel_size=seg_len, stride=seg_len, ceil_mode=True)
-        else:
-            raise ValueError("Wrong segment pooling type.")
-        shape = seg.shape
-        seg = seg.unsqueeze(-1).expand(*shape, seg_len).reshape(*shape[:-1], -1)
-        return seg[..., : x.shape[-1]]
-
-
-class CAMDenseTDNNLayer(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        bn_channels,
-        kernel_size,
-        stride=1,
-        dilation=1,
-        bias=False,
-        config_str="batchnorm-relu",
-        memory_efficient=False,
-    ):
-        super().__init__()
-        assert kernel_size % 2 == 1, f"Expect equal paddings, but got even kernel size ({kernel_size})"
-        padding = (kernel_size - 1) // 2 * dilation
-        self.memory_efficient = memory_efficient
-        self.nonlinear1 = get_nonlinear(config_str, in_channels)
-        self.linear1 = nn.Conv1d(in_channels, bn_channels, 1, bias=False)
-        self.nonlinear2 = get_nonlinear(config_str, bn_channels)
-        self.cam_layer = CAMLayer(
-            bn_channels,
-            out_channels,
-            kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            bias=bias,
-        )
-
-    def bn_function(self, x):
-        return self.linear1(self.nonlinear1(x))
-
-    def forward(self, x):
-        if self.training and self.memory_efficient:
-            x = cp.checkpoint(self.bn_function, x)
-        else:
-            x = self.bn_function(x)
-        return self.cam_layer(self.nonlinear2(x))
-
-
-class CAMDenseTDNNBlock(nn.ModuleList):
-    def __init__(
-        self,
-        num_layers,
-        in_channels,
-        out_channels,
-        bn_channels,
-        kernel_size,
-        stride=1,
-        dilation=1,
-        bias=False,
-        config_str="batchnorm-relu",
-        memory_efficient=False,
-    ):
-        super().__init__()
-        for i in range(num_layers):
-            layer = CAMDenseTDNNLayer(
-                in_channels=in_channels + i * out_channels,
-                out_channels=out_channels,
-                bn_channels=bn_channels,
-                kernel_size=kernel_size,
-                stride=stride,
-                dilation=dilation,
-                bias=bias,
-                config_str=config_str,
-                memory_efficient=memory_efficient,
-            )
-            self.add_module(f"tdnnd{i + 1}", layer)
-
-    def forward(self, x):
-        for layer in self:
-            x = torch.cat([x, layer(x)], dim=1)
-        return x
-
-
-class TransitLayer(nn.Module):
-    def __init__(self, in_channels, out_channels, bias=True, config_str="batchnorm-relu"):
-        super().__init__()
-        self.nonlinear = get_nonlinear(config_str, in_channels)
-        self.linear = nn.Conv1d(in_channels, out_channels, 1, bias=bias)
-
-    def forward(self, x):
-        x = self.nonlinear(x)
-        return self.linear(x)
-
-
-class DenseLayer(nn.Module):
-    def __init__(self, in_channels, out_channels, bias=False, config_str="batchnorm-relu"):
-        super().__init__()
-        self.linear = nn.Conv1d(in_channels, out_channels, 1, bias=bias)
-        self.nonlinear = get_nonlinear(config_str, out_channels)
-
-    def forward(self, x):
-        if len(x.shape) == 2:
-            x = self.linear(x.unsqueeze(dim=-1)).squeeze(dim=-1)
-        else:
-            x = self.linear(x)
-        return self.nonlinear(x)
-
-
-class BasicResBlock(nn.Module):
-    expansion = 1
-
-    def __init__(self, in_planes, planes, stride=1):
-        super().__init__()
-        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=(stride, 1), padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(planes)
-        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(planes)
-
-        self.shortcut = nn.Sequential()
-        if stride != 1 or in_planes != self.expansion * planes:
-            self.shortcut = nn.Sequential(
-                nn.Conv2d(
-                    in_planes,
-                    self.expansion * planes,
-                    kernel_size=1,
-                    stride=(stride, 1),
-                    bias=False,
-                ),
-                nn.BatchNorm2d(self.expansion * planes),
-            )
-
-    def forward(self, x):
-        out = F.relu(self.bn1(self.conv1(x)))
-        out = self.bn2(self.conv2(out))
-        out += self.shortcut(x)
-        return F.relu(out)
-
-
-# ============================================================================
-# CAM++ model (from modules/speaker/campplus.py)
-# ----------------------------------------------------------------------------
-# 3D-Speaker, Apache-2.0.
-# ============================================================================
-
-
-class FCM(nn.Module):
-    def __init__(
-        self,
-        block=BasicResBlock,
-        num_blocks=(2, 2),
-        m_channels=32,
-        feat_dim=_SPEAKER_FBANK_N_MELS,
-    ):
-        super().__init__()
-        self.in_planes = m_channels
-        self.conv1 = nn.Conv2d(1, m_channels, kernel_size=3, stride=1, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(m_channels)
-
-        self.layer1 = self._make_layer(block, m_channels, num_blocks[0], stride=2)
-        self.layer2 = self._make_layer(block, m_channels, num_blocks[1], stride=2)
-
-        self.conv2 = nn.Conv2d(m_channels, m_channels, kernel_size=3, stride=(2, 1), padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(m_channels)
-        self.out_channels = m_channels * (feat_dim // 8)
-
-    def _make_layer(self, block, planes, num_blocks, stride):
-        strides = [stride] + [1] * (num_blocks - 1)
-        layers = []
-        for stride in strides:
-            layers.append(block(self.in_planes, planes, stride))
-            self.in_planes = planes * block.expansion
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        x = x.unsqueeze(1)
-        out = F.relu(self.bn1(self.conv1(x)))
-        out = self.layer1(out)
-        out = self.layer2(out)
-        out = F.relu(self.bn2(self.conv2(out)))
-
-        shape = out.shape
-        return out.reshape(shape[0], shape[1] * shape[2], shape[3])
-
-
-class CAMPPlus(nn.Module):
-    _TDNN_KERNEL_SIZE = 5
-    _TDNN_STRIDE = 2
-    _TDNN_PADDING = 2
-
-    def __init__(
-        self,
-        feat_dim=_SPEAKER_FBANK_N_MELS,
-        embedding_size=512,
-        growth_rate=32,
-        bn_size=4,
-        init_channels=128,
-        config_str="batchnorm-relu",
-        memory_efficient=True,
-    ):
-        super().__init__()
-
-        self.head = FCM(feat_dim=feat_dim)
-        channels = self.head.out_channels
-
-        self.xvector = nn.Sequential(
-            OrderedDict(
-                [
-                    (
-                        "tdnn",
-                        TDNNLayer(
-                            channels,
-                            init_channels,
-                            self._TDNN_KERNEL_SIZE,
-                            stride=self._TDNN_STRIDE,
-                            dilation=1,
-                            padding=-1,
-                            config_str=config_str,
-                        ),
-                    ),
-                ]
-            )
-        )
-        channels = init_channels
-        for i, (num_layers, kernel_size, dilation) in enumerate(zip((12, 24, 16), (3, 3, 3), (1, 2, 2), strict=True)):
-            block = CAMDenseTDNNBlock(
-                num_layers=num_layers,
-                in_channels=channels,
-                out_channels=growth_rate,
-                bn_channels=bn_size * growth_rate,
-                kernel_size=kernel_size,
-                dilation=dilation,
-                config_str=config_str,
-                memory_efficient=memory_efficient,
-            )
-            self.xvector.add_module(f"block{i + 1}", block)
-            channels = channels + num_layers * growth_rate
-            self.xvector.add_module(
-                f"transit{i + 1}",
-                TransitLayer(channels, channels // 2, bias=False, config_str=config_str),
-            )
-            channels //= 2
-
-        self.xvector.add_module("out_nonlinear", get_nonlinear(config_str, channels))
-
-        self.xvector.add_module("stats", StatsPool())
-        self.xvector.add_module("dense", DenseLayer(channels * 2, embedding_size, config_str="batchnorm_"))
-
-        for m in self.modules():
-            if isinstance(m, (nn.Conv1d, nn.Linear)):
-                nn.init.kaiming_normal_(m.weight.data)
-                if m.bias is not None:
-                    nn.init.zeros_(m.bias)
-
-    @staticmethod
-    def _conv_output_lengths(lengths, kernel_size, stride=1, padding=0, dilation=1):
-        return (
-            torch.div(
-                lengths + 2 * padding - dilation * (kernel_size - 1) - 1,
-                stride,
-                rounding_mode="floor",
-            )
-            + 1
-        )
-
-    @staticmethod
-    def _make_length_mask(lengths, max_len, device):
-        lengths = lengths.to(device=device, dtype=torch.long).clamp(min=0, max=max_len)
-        return torch.arange(max_len, device=device).unsqueeze(0) < lengths.unsqueeze(1)
-
-    def _masked_stats_pooling(self, x, lengths, unbiased=True, eps=1e-2):
-        lengths = lengths.to(device=x.device, dtype=torch.long).clamp(min=1, max=x.size(-1))
-        mask = self._make_length_mask(lengths, x.size(-1), x.device).unsqueeze(1)
-        mask = mask.to(dtype=x.dtype)
-
-        denom = lengths.to(dtype=x.dtype).view(-1, 1).clamp_min(1.0)
-        mean = (x * mask).sum(dim=-1) / denom
-
-        centered = (x - mean.unsqueeze(-1)) * mask
-        var_denom = (lengths - 1).clamp_min(1).to(dtype=x.dtype).view(-1, 1) if unbiased else denom
-        var = centered.pow(2).sum(dim=-1) / var_denom
-        std = torch.sqrt(var.clamp_min(eps))
-        return torch.cat([mean, std], dim=1)
-
-    def forward(self, x, lengths=None):
-        x = x.permute(0, 2, 1)  # (B,T,F) => (B,F,T)
-        x = self.head(x)
-        if lengths is not None:
-            lengths = lengths.to(device=x.device, dtype=torch.long).clamp(min=1)
-
-        for name, module in self.xvector.named_children():
-            if name == "stats":
-                x = self._masked_stats_pooling(x, lengths) if lengths is not None else module(x)
-                continue
-
-            x = module(x)
-            if name == "tdnn" and lengths is not None:
-                lengths = self._conv_output_lengths(
-                    lengths,
-                    kernel_size=self._TDNN_KERNEL_SIZE,
-                    stride=self._TDNN_STRIDE,
-                    padding=self._TDNN_PADDING,
-                )
-
-        return x
-
-
-# ============================================================================
-# SpeakerXVectorFeatures wrapper (from modules/speaker/encoder.py)
-# ============================================================================
-
-
-class SpeakerXVectorFeatures(nn.Module):
-    """Speaker embedding extractor based on 3D-Speaker CAM++."""
-
-    def __init__(
-        self,
-        sample_rate=_SPEAKER_FBANK_SAMPLE_RATE,
-        campplus_embedding_size=512,
-        max_audio_seconds=10.0,
-    ):
-        super().__init__()
-
-        self.sample_rate = sample_rate
-        self.max_audio_seconds = float(max_audio_seconds)
-        self.model = CAMPPlus(
-            feat_dim=_SPEAKER_FBANK_N_MELS,
-            embedding_size=campplus_embedding_size,
-        )
-        self.resample = None
-        if self.sample_rate != _SPEAKER_FBANK_SAMPLE_RATE:
-            self.resample = torchaudio.transforms.Resample(
-                orig_freq=sample_rate,
-                new_freq=_SPEAKER_FBANK_SAMPLE_RATE,
-            )
-
-        for param in self.model.parameters():
-            param.requires_grad = False
-
-    @staticmethod
-    def _normalize_lengths(lengths, batch_size, max_length, device, *, min_length):
-        if lengths is None:
-            return torch.full(
-                (batch_size,),
-                max_length,
-                device=device,
-                dtype=torch.long,
-            )
-        return lengths.to(device=device, dtype=torch.long).clamp(
-            min=min_length,
-            max=max_length,
-        )
-
-    def _crop_audio(self, audio, audio_lengths=None):
-        original_lengths = self._normalize_lengths(
-            audio_lengths,
-            audio.size(0),
-            audio.size(-1),
-            audio.device,
-            min_length=0,
-        )
-        if self.max_audio_seconds <= 0:
-            return audio, original_lengths, original_lengths, torch.zeros_like(original_lengths)
-
-        max_input_length = round(self.sample_rate * self.max_audio_seconds)
-        cropped_audio = []
-        cropped_lengths = []
-        starts = []
-
-        for index, total_length_tensor in enumerate(original_lengths):
-            total_length = int(total_length_tensor.item())
-            cropped_length = min(total_length, max_input_length)
-            start = random.randint(0, total_length - cropped_length) if total_length > cropped_length else 0
-            cropped_audio.append(audio[index, start : start + cropped_length])
-            cropped_lengths.append(cropped_length)
-            starts.append(start)
-
-        return (
-            pad_sequence(
-                cropped_audio,
-                batch_first=True,
-                padding_value=0.0,
-            ),
-            original_lengths,
-            torch.tensor(
-                cropped_lengths,
-                device=audio.device,
-                dtype=torch.long,
-            ),
-            torch.tensor(starts, device=audio.device, dtype=torch.long),
-        )
-
-    def _crop_fbank(
-        self,
-        fbank,
-        fbank_lengths,
-        original_audio_lengths,
-        cropped_audio_lengths,
-        starts,
-    ):
-        original_fbank_lengths = self._normalize_lengths(
-            fbank_lengths,
-            fbank.size(0),
-            fbank.size(1),
-            fbank.device,
-            min_length=1,
-        )
-        cropped_fbank = []
-        cropped_fbank_lengths = []
-
-        for index, total_feat_length_tensor in enumerate(original_fbank_lengths):
-            total_audio_length = int(original_audio_lengths[index].item())
-            total_feat_length = int(total_feat_length_tensor.item())
-            start_audio = int(starts[index].item())
-            end_audio = start_audio + int(cropped_audio_lengths[index].item())
-
-            if total_audio_length > 0:
-                start_feat = math.floor(start_audio * total_feat_length / total_audio_length)
-                end_feat = math.ceil(end_audio * total_feat_length / total_audio_length)
-            else:
-                start_feat = 0
-                end_feat = 1
-
-            start_feat = min(start_feat, total_feat_length - 1)
-            end_feat = min(max(end_feat, start_feat + 1), total_feat_length)
-            cropped_fbank.append(fbank[index, start_feat:end_feat])
-            cropped_fbank_lengths.append(end_feat - start_feat)
-
-        return pad_sequence(
-            cropped_fbank,
-            batch_first=True,
-            padding_value=0.0,
-        ), torch.tensor(
-            cropped_fbank_lengths,
-            device=fbank.device,
-            dtype=torch.long,
-        )
-
-    def _extract_fbank_batch(self, audio, audio_lengths):
-        if self.resample is not None:
-            audio = self.resample(audio)
-            audio_lengths = torch.ceil(audio_lengths.float() * (_SPEAKER_FBANK_SAMPLE_RATE / self.sample_rate)).long()
-
-        audio_cpu = audio.detach().cpu()
-        features = []
-
-        for index, valid_length_tensor in enumerate(audio_lengths):
-            valid_length = int(valid_length_tensor.item())
-            waveform = audio_cpu[index, :valid_length]
-            if waveform.numel() == 0:
-                waveform = audio_cpu.new_zeros(1)
-            features.append(
-                extract_speaker_fbank(
-                    waveform,
-                    sample_rate=_SPEAKER_FBANK_SAMPLE_RATE,
-                )
-            )
-
-        fbank_lengths = torch.tensor(
-            [feature.size(0) for feature in features],
-            device=audio.device,
-            dtype=torch.long,
-        )
-        fbank = pad_sequence(
-            features,
-            batch_first=True,
-            padding_value=0.0,
-        ).to(device=audio.device, dtype=audio.dtype)
-        return fbank, fbank_lengths
-
-    @torch.no_grad()
-    @torch.autocast(enabled=False, device_type="cuda")
-    def forward(self, audio, audio_lengths=None, fbank=None, fbank_lengths=None, **_kwargs):
-        self.model.eval()
-        audio = audio.float()
-        if audio.dim() == 3:
-            if audio.size(1) != 1:
-                raise ValueError(f"Speaker encoder expects mono audio, got shape {tuple(audio.shape)}.")
-            audio = audio[:, 0]
-        elif audio.dim() != 2:
-            raise ValueError(f"Speaker encoder expects a 2D or 3D audio tensor, got shape {tuple(audio.shape)}.")
-
-        audio, original_audio_lengths, cropped_audio_lengths, starts = self._crop_audio(
-            audio,
-            audio_lengths=audio_lengths,
-        )
-
-        if fbank is None:
-            fbank, fbank_lengths = self._extract_fbank_batch(
-                audio,
-                cropped_audio_lengths,
-            )
-        else:
-            if not isinstance(fbank, torch.Tensor):
-                raise TypeError("Speaker encoder expects `fbank` to be a torch.Tensor.")
-            if fbank.dim() != 3 or fbank.size(0) != audio.size(0):
-                raise ValueError(
-                    f"Speaker encoder expects `fbank` with shape (B, T, F) and matching batch size, got {tuple(fbank.shape)}."  # noqa: E501
-                )
-            fbank, fbank_lengths = self._crop_fbank(
-                fbank.to(device=audio.device, dtype=torch.float32),
-                fbank_lengths,
-                original_audio_lengths,
-                cropped_audio_lengths,
-                starts,
-            )
-
-        return self.model(fbank, lengths=fbank_lengths)
diff --git a/vllm_omni/model_executor/models/dots_tts/dots_tts_talker.py b/vllm_omni/model_executor/models/dots_tts/dots_tts_talker.py
deleted file mode 100644
index 862af8e17..000000000
--- a/vllm_omni/model_executor/models/dots_tts/dots_tts_talker.py
+++ /dev/null
@@ -1,1426 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""dots.tts talker — vLLM-native AR base LM + audio side path.
-
-Mirrors upstream rednote-hilab/dots.tts (pinned @ a393d2e):
-
-  * Qwen2.5-1.5B base LM runs under vLLM PagedAttention (stock
-    ``Qwen2Model``); weights come from the checkpoint's ``llm.model.*``
-    namespace.  ``DotsTTSConfig`` hoists the LM fields to top-level
-    attributes.
-  * Everything else is side computation, invisible to the vLLM
-    scheduler and driven once per step by ``_finish_decode``:
-    DiT flow-matching head (N-step Euler, fp32 integration state,
-    deterministic per-request noise) → io_helper denormalize →
-    patch_encoder AR loopback (produces the next step's LLM input
-    embedding) + streaming AudioVAE decode (per-request
-    ``BigVGANStreamState`` sliding window, so every latent patch is
-    decoded with real left conv context) → 48 kHz wav chunks pushed to
-    ``_audio_queue`` → eos_proj stop signal via ``_results_queue``
-    (threshold 0.8, upstream default; the stop step also drains the
-    vocoder's 2-frame lookahead tail via ``stream_flush``).
-  * Cross-step state is isolated per request in ``_RequestState``
-    (keyed by request_id); eviction is deferred to the end of
-    ``forward()`` so a finishing request's audio still drains.
-  * The CAM++ speaker encoder is constructed and its weights load, but
-    voice cloning is not exposed yet — generation is zero-shot and the
-    DiT falls back to its null conditioning (``fm_null_g_cond``).
-
-Debugging: set ``DOTS_TTS_BETA_TRACE=1`` for an env-gated per-patch
-rms/max trace across the full side path (zero overhead when unset).
-
-Reference implementations: ``vllm_omni/model_executor/models/voxcpm2/``
-(architectural template: vLLM-native base LM + side path + per-request
-state) and ``ming_flash_omni`` (AudioVAE weight-loading pattern).
-"""
-
-from __future__ import annotations
-
-import dataclasses
-import hashlib
-import os
-from collections.abc import Iterable
-from dataclasses import dataclass
-from typing import Any
-
-import torch
-import torch.nn as nn
-from vllm.config import VllmConfig
-from vllm.logger import init_logger
-from vllm.model_executor.models.qwen2 import Qwen2Model
-from vllm.model_executor.models.utils import AutoWeightsLoader, maybe_prefix
-from vllm.sequence import IntermediateTensors
-
-from vllm_omni.model_executor.models.dots_tts.dots_tts_dit import DiT
-from vllm_omni.model_executor.models.dots_tts.dots_tts_patch_encoder import (
-    VAESemanticEncoder,
-)
-from vllm_omni.model_executor.models.dots_tts.dots_tts_speaker_encoder import (
-    SpeakerXVectorFeatures,
-)
-from vllm_omni.model_executor.models.dots_tts.dots_tts_vocoder import (
-    AudioVAE,
-    AudioVAEConfig,
-)
-from vllm_omni.model_executor.models.output_templates import OmniOutput
-
-logger = init_logger(__name__)
-
-
-def _require_config_block(hf_config: Any, name: str) -> dict[str, Any]:
-    """Fetch a sub-config dict (``vocoder`` / ``DiT`` / ``PatchEncoder``)
-    from the checkpoint's config.json, failing loudly when absent —
-    silently falling back to another checkpoint's values would produce
-    garbage audio, not an error."""
-    block = getattr(hf_config, name, None)
-    if not isinstance(block, dict) or not block:
-        raise ValueError(
-            f"dots.tts checkpoint config.json has no '{name}' block — cannot "
-            "build the audio side path.  Expected the upstream dots.tts config "
-            "layout (e.g. dots-studio/dots.tts-soar)."
-        )
-    return block
-
-
-def _build_audio_vae_config(hf_config: Any) -> AudioVAEConfig:
-    # AudioVAEConfig declares exactly the checkpoint's 17 ``vocoder`` keys,
-    # so an unknown / missing key raises TypeError instead of guessing.
-    return AudioVAEConfig(**_require_config_block(hf_config, "vocoder"))
-
-
-# Architecture constants used by the per-request FM workspace math.  All
-# released dots.tts checkpoints (soar / base / mf) share these values;
-# _validate_architecture_constants refuses a checkpoint that disagrees
-# instead of silently generating garbage.
-_FM_HIDDEN = 1024  # DiT.hidden_size  (also LLM↔DiT projection target)
-_LATENT_DIM = 128  # AudioVAE.latent_dim
-_LATENT_PATCH_SIZE = 4  # config.patch_size — DiT samples 4 latent frames / audio patch
-_HIDDEN_PATCH_SIZE = 1  # upstream core.py hardcodes self.hidden_patch_size = 1
-_MAX_AUDIO_PATCHES = 1024  # ~164 s @ 4×1920/48k; bounds per-request FM static buffer
-_DIT_NUM_STEPS = int(
-    os.environ.get("DOTS_TTS_DIT_NUM_STEPS", "10")
-)  # env-gated; upstream default 10 for fixed-step Euler
-_DIT_GUIDANCE_SCALE = 1.2  # upstream default guidance_scale for soar
-_DIT_NOISE_SEED = 20260601  # base seed for per-request FM noise (voxcpm2 parity)
-_PATCH_ENCODER_OUT_DS_RATE = 2  # patch_size / in_ds_rate = 4 / 2 (VAESemanticEncoder hardcodes in_ds_rate=2)
-
-
-class _IOHelper:
-    """Latent stats wrapper.  Holds (mean, var) over the 128-dim VAE latent
-    space and normalizes / denormalizes between DiT-internal space (which
-    operates on normalized latents) and AudioVAE / patch_encoder input space
-    (which expects raw latents).
-
-    Mirrors upstream IOHelper (rednote-hilab/dots.tts @ a393d2e
-    models/dots_tts/core.py:684).  Plain class (not nn.Module) so it stays
-    out of state_dict() and load_weights() doesn't have to mute its buffers.
-    Stats are loaded from latent_stats.pt — independent of safetensors.
-    """
-
-    def __init__(self, latent_stats_path: str | None = None) -> None:
-        if latent_stats_path is None:
-            self.global_mean: torch.Tensor | None = None
-            self.global_var: torch.Tensor | None = None
-            return
-        stats = torch.load(latent_stats_path, weights_only=False)
-        self.global_mean = torch.as_tensor(stats["mean"])
-        self.global_var = torch.as_tensor(stats["var"])
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.global_mean is None or self.global_var is None:
-            return x
-        mean = self.global_mean.to(device=x.device, dtype=x.dtype)
-        var = self.global_var.to(device=x.device, dtype=x.dtype)
-        return (x - mean) / torch.sqrt(var)
-
-    def denormalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.global_mean is None or self.global_var is None:
-            return x
-        mean = self.global_mean.to(device=x.device, dtype=x.dtype)
-        var = self.global_var.to(device=x.device, dtype=x.dtype)
-        return x * torch.sqrt(var) + mean
-
-
-# Per-request state container for AR-loop continuity.  All cross-step
-# side-path state lives here, keyed by request_id, so concurrent requests
-# stay fully isolated (the voxcpm2 _RequestState pattern).
-@dataclass
-class _RequestState:
-    request_id: str
-    # AR loopback: patch_encoder's previous decode output, fed to the LM
-    # as next-step inputs_embeds.  Shape: [1, llm_hidden] = [1, 1536].
-    # (patch_encoder collapses its internal _PATCH_ENCODER_OUT_DS_RATE
-    # positions into one LLM token via out_proj; see
-    # VAESemanticEncoder._project_embeddings.)  _finish_decode writes a
-    # fresh tensor every call.
-    curr_embed_for_next: torch.Tensor | None = None
-    # Stop-signal cache: _finish_decode populates precomputed_stop_logits;
-    # compute_logits drains it.
-    precomputed_stop_logits: torch.Tensor | None = None
-    is_stopping: bool = False
-    prefill_completed: bool = False
-    # Per-request FM noise counter: draw #n of this request hashes to a
-    # deterministic Generator seed (see _run_dit_n_step_euler), so outputs
-    # are reproducible run-to-run and concurrent requests cannot perturb
-    # each other's noise streams (voxcpm2 _fill_deterministic_cfm_noise).
-    noise_step: int = 0
-    # Per-request FM static workspace (lazy-allocated by
-    # _initialize_request_fm_state on first _finish_decode call).  Sized for
-    # _MAX_AUDIO_PATCHES × (_HIDDEN_PATCH_SIZE + _LATENT_PATCH_SIZE) = 1024 × 5
-    # = 5120 positions.
-    fm_sequence: torch.Tensor | None = None  # [1, fm_capacity, _FM_HIDDEN]
-    fm_cfg_sequence: torch.Tensor | None = None  # [1, fm_capacity, _FM_HIDDEN]
-    fm_null_g_cond: torch.Tensor | None = None  # [1, _FM_HIDDEN]
-    fm_seq_len: int = 0
-    fm_capacity: int = 0
-    # Speaker x-vector after _xvec_proj.  Zero-shot generation leaves this
-    # None → DiT falls back to fm_null_g_cond; voice-clone wiring is a
-    # follow-up.
-    g_cond: torch.Tensor | None = None
-    # AR-loop bookkeeping.
-    # patch_encoder_state holds conv_tail + per-layer KV caches for the
-    # patch_encoder's streaming decode (mirrors upstream state.patch_encoder_state).
-    # Lazy-allocated by _run_patch_encoder_loopback on first audio step.
-    patch_encoder_state: Any | None = None
-    # Review M2: streaming vocoder state (BigVGANStreamState — LSTM hidden
-    # + decoder sliding latent window).  Gives each patch real left conv
-    # context; output lags input by decoder.stream_lookahead (2 frames =
-    # 3840 samples).  Lazy-allocated by _run_vocoder_stream_step.
-    vocoder_stream_state: Any | None = None
-
-
-# DiT transformer hyperparameters from dots-studio/dots.tts-soar config.json
-# (the ``DiT`` block).  Mirrors the shape of an upstream pydantic config: DiT's
-# constructor calls ``transformer_config.to_dict()`` and reads ``.hidden_size``
-# / ``.num_layers``, so this @dataclass plus the ``to_dict`` helper satisfies
-# that minimal interface without dragging in upstream's config system.
-#
-# Note: ``attn_dropout`` in the JSON spells differently from MultiHeadAttention's
-# ``attn_drop`` kwarg — the value gets absorbed by ``**_kwargs`` and the MHA
-# default 0.0 applies.  Same numeric outcome for the soar checkpoint (both 0.0),
-# so this is benign; flagging it because it would mask non-default values if
-# upstream ever raised this field.
-@dataclass
-class _DiTConfig:
-    num_layers: int = 18
-    num_heads: int = 16
-    hidden_size: int = 1024
-    ffn_hidden_size: int = 4096
-    modulation: bool = True
-    qkv_bias: bool = False
-    qk_norm: bool = True
-    attn_dropout: float = 0.0
-    dropout: float = 0.0
-    norm_layer: str = "RMSNorm"
-    alibi_bias: bool = False
-    rotary_bias: bool = True
-    rotary_theta: float = 10000.0
-
-    def to_dict(self) -> dict[str, Any]:
-        return dataclasses.asdict(self)
-
-
-def _build_dit_config(hf_config: Any) -> _DiTConfig:
-    # _DiTConfig declares exactly the checkpoint's 13 ``DiT`` keys, so an
-    # unknown key raises TypeError instead of being silently dropped.
-    return _DiTConfig(**_require_config_block(hf_config, "DiT"))
-
-
-# Patch encoder hyperparameters from dots-studio/dots.tts-soar config.json
-# (the top-level ``patch_size`` and the ``PatchEncoder`` sub-block).
-#
-# Two layers of config:
-#   * Outer (``_PatchEncoderConfig``): VAESemanticEncoder reads ``.patch_size``
-#     and forwards ``.PatchEncoder`` to its inner SuperviseEncoder.
-#   * Inner (``_PatchEncoderInner``): the constructor uses BOTH attribute
-#     access (``config.PatchEncoder.hidden_size``) and dict-style
-#     ``config.get("hidden_size", 1024)``.  Upstream's pydantic ConfigBase
-#     supports both natively; we add a tiny ``.get()`` helper to a dataclass.
-#
-# Upstream's ``_EncoderConfig`` also defines qk_norm / rotary_bias /
-# rotary_theta / input_dim, but ``SuperviseEncoder.__init__`` only reads six
-# keys (num_layers / num_heads / hidden_size / ffn_hidden_size / norm_layer /
-# causal).  The rest are swallowed and MultiHeadAttention falls back to its
-# own defaults — matching upstream behaviour means *not* plumbing them through.
-@dataclass
-class _PatchEncoderInner:
-    num_layers: int = 24
-    num_heads: int = 16
-    hidden_size: int = 1024
-    ffn_hidden_size: int = 4096
-    norm_layer: str = "RMSNorm"
-    causal: bool = True
-
-    def get(self, key: str, default: Any = None) -> Any:
-        return getattr(self, key, default)
-
-
-@dataclass
-class _PatchEncoderConfig:
-    patch_size: int = 4
-    PatchEncoder: _PatchEncoderInner = dataclasses.field(default_factory=_PatchEncoderInner)
-
-
-def _build_patch_encoder_config(hf_config: Any) -> _PatchEncoderConfig:
-    block = _require_config_block(hf_config, "PatchEncoder")
-    # SuperviseEncoder reads only the six declared fields; upstream's
-    # pydantic config swallows the other checkpoint keys, so filtering
-    # here matches upstream behaviour exactly.
-    inner_fields = {f.name for f in dataclasses.fields(_PatchEncoderInner)}
-    inner = _PatchEncoderInner(**{k: v for k, v in block.items() if k in inner_fields})
-    return _PatchEncoderConfig(
-        patch_size=int(hf_config.patch_size),
-        PatchEncoder=inner,
-    )
-
-
-def _validate_architecture_constants(hf_config: Any, dit_config: _DiTConfig) -> None:
-    """The FM workspace helpers size buffers off module-level constants;
-    a checkpoint that disagrees would corrupt the DiT conditioning, so
-    refuse it up front (making these fully config-driven is deferred
-    until a released checkpoint actually differs)."""
-    checks = [
-        ("latent_dim", getattr(hf_config, "latent_dim", None), _LATENT_DIM),
-        ("patch_size", getattr(hf_config, "patch_size", None), _LATENT_PATCH_SIZE),
-        ("DiT.hidden_size", dit_config.hidden_size, _FM_HIDDEN),
-    ]
-    mismatches = [f"{name}={got!r} (expected {want})" for name, got, want in checks if got != want]
-    if mismatches:
-        raise ValueError(
-            "dots.tts checkpoint config disagrees with this integration's "
-            "architecture constants: " + ", ".join(mismatches)
-        )
-
-
-class DotsTTSForConditionalGeneration(nn.Module):
-    """dots.tts AR talker: Qwen2.5 base LM + DiT / AudioVAE / CAM++ side path."""
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
-        super().__init__()
-
-        self.vllm_config = vllm_config
-        self.config = vllm_config.model_config.hf_config
-
-        # vllm-omni capability flags — gpu_model_runner checks these to decide
-        # whether to call preprocess() / postprocess() / accept multimodal
-        # outputs.  Without these, the runner bypasses our preprocess hook
-        # and _pending_requests stays empty (forward never dispatches the
-        # side-path).  Voxcpm2 sets the same three.
-        self.have_multimodal_outputs = True
-        self.has_preprocess = True
-        self.has_postprocess = True
-
-        self.model = Qwen2Model(
-            vllm_config=vllm_config,
-            prefix=maybe_prefix(prefix, "model"),
-        )
-        self.make_empty_intermediate_tensors = self.model.make_empty_intermediate_tensors
-
-        # Side-path module hyperparameters come off the checkpoint's
-        # config.json blocks (fail loudly if a block is absent); the FM
-        # workspace constants are cross-checked against the same config.
-        dit_config = _build_dit_config(self.config)
-        _validate_architecture_constants(self.config, dit_config)
-        llm_hidden = self.config.hidden_size
-        fm_hidden = dit_config.hidden_size
-        latent_dim = int(self.config.latent_dim)
-        xvec_dim = int(getattr(self.config, "campplus_embedding_size", 512))
-
-        self._audio_vae = AudioVAE(_build_audio_vae_config(self.config))
-        # Upstream serializes vocoder.safetensors with weight_norm folded into
-        # plain `weight` on the decoder (encoder kept weight_norm — it's not in
-        # the synthesis hot path).  Match that layout before load_weights runs,
-        # so checkpoint keys align with our state_dict 1:1.
-        self._audio_vae.remove_weight_norm()
-        # AudioVAE / speaker encoder stay fp32 — upstream only casts
-        # `model.core` to bf16 (runtime.py:81), leaving vocoder + xvector
-        # extractor in fp32 because their kernels (conv1d / fbank) need
-        # higher precision.  Without this _audio_vae would inherit talker's
-        # bf16 dtype via vLLM's auto-cast and dtype-mismatch under
-        # stream_step (input .float() vs bf16 weights).
-
-        # DiT flow-matching head.  Dimensions per upstream core.py:101-104:
-        #   in_dim  = config.DiT.hidden_size  (DiT internal space)
-        #   out_dim = config.latent_dim       (AudioVAE input space)
-        # mode is "flow_matching" for soar/base; "meanflow" only for the mf
-        # checkpoint (handled by a separate factory in a later step).
-        self._head = DiT(
-            in_dim=fm_hidden,
-            out_dim=latent_dim,
-            transformer_config=dit_config,
-            mode="flow_matching",
-        )
-
-        # Patch encoder: closes the AR loop by mapping each DiT-emitted audio
-        # latent patch back into the LLM hidden space, so Qwen2 "hears" what it
-        # has already generated.  Upstream core.py:75 calls this with
-        # in_dim=latent_dim and out_dim=llm.config.hidden_size.
-        self._patch_encoder = VAESemanticEncoder(
-            in_dim=latent_dim,
-            out_dim=llm_hidden,
-            config=_build_patch_encoder_config(self.config),
-        )
-
-        # Five thin projectors (upstream core.py:82-113).  Soar dimensions:
-        # llm_hidden=1536, fm_hidden=1024, latent_dim=128, xvec_dim=512.
-        # These are kept as direct attributes (no vendor file) — they are flat
-        # nn.Linear / nn.Sequential, and live at the top of the checkpoint
-        # namespace under their own short prefixes (see load_weights).
-        self._hidden_proj = nn.Linear(llm_hidden, fm_hidden)
-        self._latent_proj = nn.Linear(latent_dim, fm_hidden)
-        self._coordinate_proj = nn.Linear(latent_dim, fm_hidden)
-        self._xvec_proj = nn.Sequential(
-            nn.Linear(xvec_dim, fm_hidden),
-            nn.LayerNorm(fm_hidden),
-        )
-        # eos_proj is the stop predictor — feeds LLM hidden through a 2-layer
-        # MLP and produces a 2-way logit (continue / stop).
-        self._eos_proj = nn.Sequential(
-            nn.Linear(llm_hidden, llm_hidden),
-            nn.SiLU(),
-            nn.Linear(llm_hidden, 2),
-        )
-
-        # CAM++ speaker encoder (3D-Speaker), produces the x-vector from
-        # reference audio for voice cloning.  sample_rate matches AudioVAE's
-        # input space (48 kHz); the wrapper resamples to 16k internally for
-        # CAM++.  Weights are frozen (upstream does `requires_grad = False`).
-        self._speaker_encoder = SpeakerXVectorFeatures(
-            sample_rate=self._audio_vae.sample_rate,
-            campplus_embedding_size=xvec_dim,
-            max_audio_seconds=float(getattr(self.config, "xvec_max_audio_seconds", 10.0)),
-        )
-
-        # Pin AudioVAE + speaker encoder to fp32 (mirror upstream
-        # runtime.py:81 where only `model.core` is cast to bf16).  vLLM's
-        # auto-cast would otherwise lower these to bf16, breaking
-        # stream_step (input .float() vs bf16 weights) and the fbank
-        # pipeline.
-        self._audio_vae.float()
-        self._speaker_encoder.float()
-
-        # Latent stats — independent of safetensors (torch.load on
-        # latent_stats.pt sitting next to the checkpoint files).  Used by
-        # _finish_decode to bridge between DiT's normalized latent space and
-        # the raw latent space expected by patch_encoder + AudioVAE.
-        latent_stats_path = self._resolve_latent_stats_path(vllm_config.model_config.model)
-        if latent_stats_path is not None:
-            self._io_helper = _IOHelper(latent_stats_path)
-        else:
-            logger.warning(
-                "latent_stats.pt not resolvable for %s; running with "
-                "identity normalize/denormalize.  Wav will be ~10x quiet "
-                "and distorted (no sqrt(var) denormalize).",
-                vllm_config.model_config.model,
-            )
-            self._io_helper = _IOHelper()
-
-        # (β) diagnostic: env-gated per-patch rms/max trace across the full
-        # side path (LLM hidden → DiT → denormalize → patch_encoder → wav →
-        # eos).  Zero overhead when DOTS_TTS_BETA_TRACE is unset (single
-        # bool check per step); kept as the model's debugging instrument
-        # (cf. voxcpm2's enable_profiling runtime knob).
-        self._beta_trace = bool(os.environ.get("DOTS_TTS_BETA_TRACE"))
-
-        # Per-request state plumbing.
-        # _active_states: per-request state keyed by request_id (created in
-        #   preprocess prefill, evicted by _flush_deferred_cleanup).
-        # _pending_requests: per-step list of (req_id, is_prefill, embeds,
-        #   span_len) populated by preprocess(), consumed by forward().
-        # _deferred_cleanup_ids: requests vLLM has marked finished but whose
-        #   side-path audio still needs draining in the current forward step;
-        #   evicted from _active_states at the end of forward().
-        self._active_states: dict[str, _RequestState] = {}
-        self._pending_requests: list[tuple[str, bool, torch.Tensor, int]] = []
-        self._deferred_cleanup_ids: set[str] = set()
-
-        # Audio side-channel:
-        # _audio_queue: _finish_decode pushes (req_id, audio_tensor) tuples
-        #   here; make_omni_output drains them into multimodal_outputs each
-        #   step.
-        # _sample_rate: cached from AudioVAE config (= 48000 for soar).
-        self._audio_queue: list[tuple[str, torch.Tensor]] = []
-        self._sample_rate = self._audio_vae.sample_rate
-
-        # Stop-signal side-channel:
-        # _results_queue: _finish_decode pushes (req_id, stop_logits) tuples
-        #   here; compute_logits drains them into the [bsz, vocab_size]
-        #   logits tensor each step.
-        self._results_queue: list[tuple[str, torch.Tensor | None]] = []
-
-        logger.info(
-            "DotsTTS talker built (base_lm=Qwen2[28L,12H,1536d], "
-            "audio_vae=AudioVAE, dit=DiT[18L,16H,1024d], "
-            "patch_encoder=VAESemanticEncoder[24L,16H,1024d], "
-            "5 projectors, speaker_encoder=CAM++[7.2M], "
-            "io_helper=%s, model=%s, dit_steps=%d); "
-            "_finish_decode: DiT → denormalize → patch_encoder AR + "
-            "streaming AudioVAE decode → wav + eos_proj → stop signal.",
-            "loaded" if self._io_helper.global_mean is not None else "identity",
-            vllm_config.model_config.model,
-            _DIT_NUM_STEPS,
-        )
-
-    def forward(
-        self,
-        input_ids: torch.Tensor,
-        positions: torch.Tensor,
-        intermediate_tensors: IntermediateTensors | None = None,
-        inputs_embeds: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> torch.Tensor | IntermediateTensors:
-        """Drive the base LM, then the per-request audio side path.
-
-        One vLLM step: base LM forward under PagedAttention, then slice
-        the scaffold hidden states per request (in _pending_requests
-        order) and run _finish_decode on each — DiT sampling, streaming
-        AudioVAE decode, AR loopback, and stop signal all happen there.
-        vLLM only ever sees the returned hidden states; audio leaves
-        through the _audio_queue side channel.
-        """
-        output = self.model(input_ids, positions, intermediate_tensors, inputs_embeds)
-        if isinstance(output, IntermediateTensors):
-            return output
-        if isinstance(output, tuple):
-            output = output[0]
-
-        # Per-request side-path: slice scaffold_hidden by token span_len
-        # in the order preprocess() appended to _pending_requests.
-        token_offset = 0
-        for req_id, is_prefill, _embeds, span_len in self._pending_requests:
-            req_hidden = output[token_offset : token_offset + span_len]
-            token_offset += span_len
-            self._finish_decode(req_id, req_hidden, is_prefill)
-
-        # End-of-step cleanup
-        self._pending_requests.clear()
-        self._flush_deferred_cleanup()
-
-        return output
-
-    # ── vllm-omni protocol methods ──
-
-    @staticmethod
-    def _resolve_latent_stats_path(model_arg: str) -> str | None:
-        """Resolve latent_stats.pt to a local filesystem path.
-
-        ``vllm_config.model_config.model`` is typically an HF repo ID like
-        ``"dots-studio/dots.tts-soar"`` — joining it with ``"latent_
-        stats.pt"`` gives a non-existent path.  Try the local-dir form
-        first (covers ``--model /local/path``), then fall back to HF
-        cache lookup with ``local_files_only=True`` so we never trigger
-        a download from this side (the file was fetched alongside the
-        safetensors at load time).
-        """
-        local = os.path.join(model_arg, "latent_stats.pt")
-        if os.path.exists(local):
-            return local
-        try:
-            from vllm_omni.transformers_utils.repo_utils import hf_api
-
-            return hf_api().hf_hub_download(
-                repo_id=model_arg,
-                filename="latent_stats.pt",
-                local_files_only=True,
-            )
-        except Exception:
-            return None
-
-    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
-        """Map token ids to embeddings via the base LM's embed_tokens.
-
-        Required by vLLM's ``is_text_generation_model`` Protocol check
-        (interfaces_base._check_vllm_model_embed_input_ids).  Without this
-        the model fails ``--runner generate`` validation at engine startup.
-        """
-        return self.model.embed_tokens(input_ids)
-
-    def preprocess(
-        self,
-        input_ids: torch.Tensor,
-        input_embeds: torch.Tensor | None = None,
-        **info_dict: Any,
-    ) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]]:
-        """Per-step embedding + per-request state registration.
-
-        Prefill: embed the wrapped prompt
-        ``[文本]<text>[文本对应语音]<AUDIO_GEN_START>`` via the LM's
-        embed_tokens.  Caller (serving layer or test harness) is
-        responsible for the wrap — talker just embeds whatever it gets.
-
-        Decode (span_len == 1): use ``state.curr_embed_for_next`` from
-        the previous step's AR loopback (DiT → patch_encoder output);
-        zero fallback only if the loopback hasn't produced one yet.
-
-        Voice clone is intentionally not wired here — zero-shot only.
-
-        Returns ``(input_ids unchanged, embeds [span_len, hidden_size],
-        {})``.  ``forward()`` consumes ``self._pending_requests`` to
-        slice scaffold_hidden per request.
-        """
-        # voxcpm2 protocol compatibility: flatten additional_information.
-        additional = info_dict.get("additional_information")
-        if isinstance(additional, dict):
-            merged = {k: v for k, v in info_dict.items() if k != "additional_information"}
-            for k, v in additional.items():
-                merged.setdefault(k, v)
-            info_dict = merged
-
-        span_len = int(input_ids.shape[0])
-        dev = input_ids.device
-        req_id = info_dict.get("request_id", "default")
-        state = self._active_states.get(req_id)
-        # Prefill is detected by state lifecycle (not span_len), so decode
-        # can use span_len=1 with a multi-position curr_embed_for_next.
-        is_prefill = state is None or not state.prefill_completed
-
-        if is_prefill:
-            if state is None:
-                state = _RequestState(request_id=req_id)
-                self._active_states[req_id] = state
-            # Reset per-step state on every prefill — previous run is stale.
-            state.curr_embed_for_next = None
-            state.precomputed_stop_logits = None
-            state.is_stopping = False
-            state.prefill_completed = False
-            state.noise_step = 0
-            # Reset AR-loop state on every prefill.
-            state.patch_encoder_state = None
-            state.vocoder_stream_state = None
-            embeds = self.model.embed_tokens(input_ids)
-        else:
-            curr = state.curr_embed_for_next
-            if curr is not None:
-                embeds = curr.to(dev)  # [1, llm_hidden]
-            else:
-                # First decode step before AR loop closed — zero fallback.
-                embed_dtype = self.model.embed_tokens.weight.dtype
-                embeds = torch.zeros(
-                    1,
-                    self.config.hidden_size,
-                    device=dev,
-                    dtype=embed_dtype,
-                )
-
-        self._pending_requests.append((req_id, is_prefill, embeds, span_len))
-        return input_ids, embeds, {}
-
-    def postprocess(self, *args: Any, **kwargs: Any) -> dict:
-        return {}
-
-    def on_requests_finished(self, finished_req_ids: Iterable[str]) -> None:
-        """Mark finished requests for deferred eviction.
-
-        vLLM scheduler calls this BEFORE forward() to notify that certain
-        requests have completed.  We can't drop their _RequestState yet —
-        the current forward step still needs to drain side-path audio
-        chunks.  Real eviction happens at the end of forward() via
-        _flush_deferred_cleanup.
-        """
-        for req_id in finished_req_ids:
-            if req_id in self._active_states:
-                self._deferred_cleanup_ids.add(req_id)
-
-    def _flush_deferred_cleanup(self) -> None:
-        """Evict states marked by on_requests_finished.  Called at the
-        tail of forward()."""
-        for req_id in self._deferred_cleanup_ids:
-            self._active_states.pop(req_id, None)
-        self._deferred_cleanup_ids.clear()
-
-    def _finish_decode(
-        self,
-        req_id: str,
-        req_hidden: torch.Tensor,
-        is_prefill: bool,
-    ) -> None:
-        """One request's per-step side path: DiT → AR loopback → wav → stop.
-
-        One vLLM step = one audio patch.  patch_encoder.decode_patch
-        collapses its internal _PATCH_ENCODER_OUT_DS_RATE positions into
-        a single LLM input embedding (see VAESemanticEncoder._project_
-        embeddings), so vLLM's span_len=1 decode matches naturally — no
-        slot bookkeeping needed.
-
-        Per-call flow (prefill or decode):
-          1. _hidden_proj(last_hidden) → fm_sequence (+1 position)
-          2. DiT N-step Euler → audio_patch [1, 4, 128] (normalized)
-          3. _latent_proj(audio_patch) → fm_sequence (+4 positions, normalized)
-          4. io_helper.denormalize(audio_patch) → audio_patch_raw
-          5. patch_encoder(audio_patch_raw) → next-step embed [1, 1536]
-          6. AudioVAE stream_step(audio_patch_raw) → wav chunk pushed to
-             _audio_queue (prefill's patch #0 included; output lags 2
-             frames behind input)
-          7. (decode only) eos_proj(last_hidden) → stop_logits pushed to
-             _results_queue; threshold > 0.8 flips state.is_stopping and
-             stream_flush drains the decoder's lookahead tail.
-        """
-        state = self._active_states.get(req_id)
-        if state is None:
-            return
-
-        if state.fm_sequence is None:
-            self._initialize_request_fm_state(
-                state,
-                device=req_hidden.device,
-                dtype=req_hidden.dtype,
-            )
-
-        # This step's append would overflow the per-request FM buffer.
-        # Stop gracefully (same path as a model-decided stop below) instead
-        # of raising past _append_hidden_chunk/_append_history_chunk —
-        # those raises are engine-fatal, not request-fatal, and would take
-        # every other in-flight and future request down with this one.
-        if state.fm_seq_len + _HIDDEN_PATCH_SIZE + _LATENT_PATCH_SIZE > state.fm_capacity:
-            state.is_stopping = True
-            stop_logits = torch.tensor([[0.0, 1.0]], device=req_hidden.device, dtype=req_hidden.dtype)
-            state.precomputed_stop_logits = stop_logits
-            tail = self._audio_vae.stream_flush(state.vocoder_stream_state)
-            if tail.size(-1) > 0:
-                self._audio_queue.append((req_id, tail.reshape(-1)))
-            self._results_queue.append((req_id, stop_logits))
-            return
-
-        # 1. Append last LLM hidden to fm_sequence (+1 position).
-        last_hidden = req_hidden[-_HIDDEN_PATCH_SIZE:].unsqueeze(0)
-
-        self._append_hidden_chunk(state, last_hidden)
-
-        # 2. DiT N-step Euler → audio latent patch [1, 4, 128] (normalized).
-        audio_patch = self._run_dit_n_step_euler(state)
-
-        # 3. Append latent to fm_sequence (+4 positions).  Stays in
-        #    normalized space — DiT's KV cache lives in that space.
-        self._append_history_chunk(state, audio_patch)
-
-        # 4. Denormalize for downstream consumers (patch_encoder, AudioVAE).
-        audio_patch_raw = self._io_helper.denormalize(audio_patch)
-
-        # 5. patch_encoder AR loopback → next-step inputs_embeds [1, 1536].
-        next_embeds = self._run_patch_encoder_loopback(state, audio_patch_raw)
-        state.curr_embed_for_next = next_embeds.squeeze(0).detach()
-
-        # 6. Streaming AudioVAE decode → wav chunk.  Runs on prefill too:
-        #    upstream zero-shot emits every DiT patch including the first
-        #    (_generate_latents_stream drops one patch only under prompt
-        #    prefill / voice clone), and our prefill patch #0 corresponds
-        #    to upstream's first decode-loop patch.
-        wav = self._run_vocoder_stream_step(state, audio_patch_raw)
-        if wav.size(-1) > 0:
-            self._audio_queue.append((req_id, wav.reshape(-1)))
-
-        if is_prefill:
-            if self._beta_trace:
-                self._beta_trace_log(
-                    state,
-                    is_prefill=True,
-                    last_hidden=last_hidden,
-                    audio_patch=audio_patch,
-                    audio_patch_raw=audio_patch_raw,
-                    next_embeds=next_embeds,
-                    wav=wav if wav.size(-1) > 0 else None,
-                    prob_stop=None,
-                )
-            state.prefill_completed = True
-            # Keep len(_results_queue) == bsz: compute_logits pairs queue
-            # entries with batch rows positionally, so every request in the
-            # batch must push exactly one entry per step (voxcpm2_talker.py
-            # prefill placeholder pattern).  None → forced continue via the
-            # stop_logits-is-None branch in compute_logits.
-            self._results_queue.append((req_id, None))
-            return
-
-        # 7. eos_proj → stop probability.  Mirrors upstream
-        #    model.py:1681 — softmax([continue, stop]) on detached LLM
-        #    hidden, threshold the stop slot at 0.8 (upstream default
-        #    eos_threshold).  When stop fires for this step, compute_logits
-        #    drains the high-stop logit on the next dispatch and vLLM
-        #    terminates the request.
-        eos_logits = self._eos_proj(last_hidden.detach()).softmax(dim=-1)
-        stop_logits = eos_logits.squeeze(0)
-        state.precomputed_stop_logits = stop_logits
-        if eos_logits[0, -1, 1].item() > 0.8:
-            state.is_stopping = True
-            # Upstream flushes after its decode loop (model.py:1898); our
-            # request ends when vLLM sees this step's stop token, so drain
-            # the decoder's 2-frame lookahead tail in the same step.
-            # Requests cut by max_tokens/abort never reach this path and
-            # lose the 40 ms tail — no engine hook fires late enough to
-            # flush after the final step.
-            tail = self._audio_vae.stream_flush(state.vocoder_stream_state)
-            if tail.size(-1) > 0:
-                self._audio_queue.append((req_id, tail.reshape(-1)))
-        self._results_queue.append((req_id, stop_logits))
-
-        if self._beta_trace:
-            self._beta_trace_log(
-                state,
-                is_prefill=False,
-                last_hidden=last_hidden,
-                audio_patch=audio_patch,
-                audio_patch_raw=audio_patch_raw,
-                next_embeds=next_embeds,
-                wav=wav if wav.size(-1) > 0 else None,
-                prob_stop=eos_logits[0, -1, 1].item(),
-            )
-
-    def _beta_trace_log(
-        self,
-        state: _RequestState,
-        *,
-        is_prefill: bool,
-        last_hidden: torch.Tensor,
-        audio_patch: torch.Tensor,
-        audio_patch_raw: torch.Tensor,
-        next_embeds: torch.Tensor,
-        wav: torch.Tensor | None,
-        prob_stop: float | None,
-    ) -> None:
-        """(β) diagnostic — patch label matches output.wav indexing in
-        decode rows; prefill row labels itself ``pre``."""
-
-        def rmsmax(t: torch.Tensor) -> tuple[float, float]:
-            f = t.detach().float()
-            return f.pow(2).mean().sqrt().item(), f.abs().max().item()
-
-        patch_label = "pre" if is_prefill else f"{state.fm_seq_len // 5 - 2:2d}"
-        req_tail = state.request_id[-8:]
-        hid_rms, hid_max = rmsmax(last_hidden)
-        dit_rms, dit_max = rmsmax(audio_patch)
-        raw_rms, raw_max = rmsmax(audio_patch_raw)
-        nxt_rms, nxt_max = rmsmax(next_embeds)
-        if wav is not None:
-            w_rms, w_max = rmsmax(wav)
-            wav_part = f"wav:rms={w_rms:.3f} max={w_max:.3f}"
-        else:
-            wav_part = "wav:rms=  -   max=  -  "
-        stop_part = f"stop={prob_stop:.3f}" if prob_stop is not None else "stop=  -  "
-        logger.info(
-            f"[β req={req_tail} patch={patch_label}] "
-            f"hid:rms={hid_rms:.3f} max={hid_max:.3f} | "
-            f"dit:rms={dit_rms:.3f} max={dit_max:.3f} | "
-            f"raw:rms={raw_rms:.3f} max={raw_max:.3f} | "
-            f"next:rms={nxt_rms:.3f} max={nxt_max:.3f} | "
-            f"{wav_part} | {stop_part}"
-        )
-
-    # ── FM helpers (per-request workspace + DiT N-step Euler) ──
-
-    def _initialize_request_fm_state(
-        self,
-        state: _RequestState,
-        *,
-        device: torch.device,
-        dtype: torch.dtype,
-    ) -> None:
-        """Lazy-allocate per-request FM workspace.
-
-        Mirrors upstream _allocate_generate_state (model.py:413) but per-
-        request (no workspace sharing) so concurrent requests stay
-        isolated.
-        """
-        fm_capacity = _MAX_AUDIO_PATCHES * (_HIDDEN_PATCH_SIZE + _LATENT_PATCH_SIZE)
-        state.fm_capacity = fm_capacity
-        state.fm_sequence = torch.zeros(
-            (1, fm_capacity, _FM_HIDDEN),
-            device=device,
-            dtype=dtype,
-        )
-        state.fm_cfg_sequence = torch.zeros(
-            (1, fm_capacity, _FM_HIDDEN),
-            device=device,
-            dtype=dtype,
-        )
-        state.fm_null_g_cond = torch.zeros(
-            (1, _FM_HIDDEN),
-            device=device,
-            dtype=dtype,
-        )
-        state.fm_seq_len = 0
-
-    def _append_hidden_chunk(
-        self,
-        state: _RequestState,
-        hidden_chunk: torch.Tensor,
-    ) -> None:
-        """Project last _HIDDEN_PATCH_SIZE LLM hiddens via _hidden_proj into fm_sequence.
-
-        Mirrors upstream _append_hidden_chunk (model.py:1308): cfg buffer
-        gets the null-projected counterpart (``_hidden_proj`` of zero) so
-        CFG dropout sees no past hidden, only past audio history.
-        """
-        last_hidden = hidden_chunk[:, -_HIDDEN_PATCH_SIZE:, :]
-        projected = self._hidden_proj(last_hidden)
-        null_projected = self._hidden_proj(torch.zeros_like(last_hidden))
-        end = state.fm_seq_len + projected.size(1)
-        if end > state.fm_capacity:
-            raise RuntimeError(f"FM buffer overflow on hidden append: end={end} cap={state.fm_capacity}")
-        state.fm_sequence[:, state.fm_seq_len : end].copy_(projected.to(state.fm_sequence.dtype))
-        state.fm_cfg_sequence[:, state.fm_seq_len : end].copy_(null_projected.to(state.fm_cfg_sequence.dtype))
-        state.fm_seq_len = end
-
-    def _append_history_chunk(
-        self,
-        state: _RequestState,
-        latent_chunk: torch.Tensor,
-    ) -> None:
-        """Project audio latent via _latent_proj into fm_sequence (history append).
-
-        Mirrors upstream _append_history_chunk (model.py:1325): cfg
-        buffer gets the same value (latent history is shared between
-        conditional and unconditional CFG paths — only the hidden chunk
-        gets nulled).
-        """
-        history_latent = self._latent_proj(latent_chunk)
-        end = state.fm_seq_len + history_latent.size(1)
-        if end > state.fm_capacity:
-            raise RuntimeError(f"FM buffer overflow on latent append: end={end} cap={state.fm_capacity}")
-        state.fm_sequence[:, state.fm_seq_len : end].copy_(history_latent.to(state.fm_sequence.dtype))
-        state.fm_cfg_sequence[:, state.fm_seq_len : end].copy_(history_latent.to(state.fm_cfg_sequence.dtype))
-        state.fm_seq_len = end
-
-    def _build_fm_attn_mask(
-        self,
-        state: _RequestState,
-        total_len: int,
-        device: torch.device,
-    ) -> torch.Tensor:
-        """Build DiT attention mask for one decode step.
-
-        Mirrors upstream _build_fm_attn_mask (model.py:1203).  Layout:
-          * [0, fm_seq_len) — committed history.  Causal over the past
-            up to a non-causal tail block of size _HIDDEN_PATCH_SIZE that
-            sees itself and the new noise patch (the just-appended hidden).
-          * [latent_start, total_len) — new noise patch, bidirectional
-            with the committed history and itself.
-        """
-        attn_mask = torch.zeros((1, total_len, total_len), device=device, dtype=torch.bool)
-        latent_start = total_len - _LATENT_PATCH_SIZE
-        block_start = state.fm_seq_len - _HIDDEN_PATCH_SIZE
-        if block_start > 0:
-            causal_mask = torch.ones((block_start, block_start), device=device, dtype=torch.bool).triu(1).logical_not()
-            attn_mask[:, :block_start, :block_start] = causal_mask
-        attn_mask[:, block_start : state.fm_seq_len, : state.fm_seq_len] = True
-        attn_mask[:, block_start : state.fm_seq_len, latent_start:] = True
-        attn_mask[:, latent_start:, : state.fm_seq_len] = True
-        attn_mask[:, latent_start:, latent_start:] = True
-        if latent_start > state.fm_seq_len:
-            padding_indices = torch.arange(state.fm_seq_len, latent_start, device=device)
-            attn_mask[:, padding_indices, padding_indices] = True
-        return attn_mask
-
-    def _build_fm_pos_ids(
-        self,
-        state: _RequestState,
-        total_len: int,
-        device: torch.device,
-    ) -> torch.Tensor:
-        """Build DiT position ids for one decode step.
-
-        Mirrors upstream _build_fm_pos_ids (model.py:1236).  Position ids
-        stay fp32 — DiT's RotaryEmbedding does its own dtype handling.
-        """
-        pos_ids = torch.zeros((1, total_len), device=device, dtype=torch.float32)
-        latent_start = total_len - _LATENT_PATCH_SIZE
-        if state.fm_seq_len > 0:
-            pos_ids[:, : state.fm_seq_len] = torch.arange(
-                state.fm_seq_len,
-                device=device,
-                dtype=pos_ids.dtype,
-            )
-        pos_ids[:, latent_start:] = torch.arange(
-            state.fm_seq_len,
-            state.fm_seq_len + _LATENT_PATCH_SIZE,
-            device=device,
-            dtype=pos_ids.dtype,
-        )
-        return pos_ids
-
-    def _run_dit_n_step_euler(
-        self,
-        state: _RequestState,
-        *,
-        num_steps: int = _DIT_NUM_STEPS,
-        guidance_scale: float = _DIT_GUIDANCE_SCALE,
-    ) -> torch.Tensor:
-        """DiT N-step Euler integration → audio latent patch [1, 4, 128].
-
-        Manual Euler loop (upstream uses torchdyn.odeint; we manualize to
-        avoid the dep and keep control flow explicit).  Each step:
-          1. z_proj = _coordinate_proj(z), placed into the last
-             _LATENT_PATCH_SIZE positions of input_sequence / cfg_sequence.
-          2. Batch [conditional, unconditional] → DiT velocity field.
-          3. CFG blend: v_c + guidance_scale * (v_c - v_u).
-          4. Euler: z += v * dt.
-
-        Mirrors upstream fm_solver_step (core.py:295) + _flow_matching_step_fm
-        (core.py:463), reduced to a fixed-step Euler integrator.
-        """
-        assert state.fm_sequence is not None
-        assert state.fm_cfg_sequence is not None
-        assert state.fm_null_g_cond is not None
-        device = state.fm_sequence.device
-        dtype = state.fm_sequence.dtype
-        total_len = state.fm_seq_len + _LATENT_PATCH_SIZE
-
-        # Workspace: committed history + 4 noise slots (overwritten per step).
-        input_sequence = torch.zeros((1, total_len, _FM_HIDDEN), device=device, dtype=dtype)
-        input_sequence[:, : state.fm_seq_len] = state.fm_sequence[:, : state.fm_seq_len]
-        cfg_sequence = torch.zeros((1, total_len, _FM_HIDDEN), device=device, dtype=dtype)
-        cfg_sequence[:, : state.fm_seq_len] = state.fm_cfg_sequence[:, : state.fm_seq_len]
-
-        attn_mask = self._build_fm_attn_mask(state, total_len, device)
-        pos_ids = self._build_fm_pos_ids(state, total_len, device)
-
-        g_cond = state.g_cond if state.g_cond is not None else state.fm_null_g_cond
-        g_cond = g_cond.to(device=device, dtype=dtype)
-        g_cond_batched = torch.cat([g_cond, torch.zeros_like(g_cond)], dim=0)
-
-        latent_start = total_len - _LATENT_PATCH_SIZE
-        # fp32 ODE integration (same fix as Ming's CFM sampler, PR #4341):
-        # bf16's 7-bit mantissa loses the small per-step increments in the
-        # z += v*dt accumulation (hidden-state cos drift vs upstream past
-        # step ~7) and quantizes the linspace timesteps.  Integration
-        # state stays fp32; DiT matmuls still run bf16 under the autocast
-        # block below, and the result is cast back to the sequence dtype
-        # on return.
-        # Deterministic per-request noise (voxcpm2 _fill_deterministic_cfm_
-        # noise pattern): hash seed:request_key:draw# into a private
-        # Generator instead of the global CUDA RNG, so outputs reproduce
-        # run-to-run and concurrent requests cannot perturb each other's
-        # noise streams.  request_key strips the engine's per-run "<idx>_"
-        # uuid suffix so replay across runs keys on the stable batch index.
-        request_key = state.request_id.split("_", 1)[0]
-        if not request_key.isdigit():
-            request_key = state.request_id
-        noise_key = f"{_DIT_NOISE_SEED}:{request_key}:{state.noise_step}".encode()
-        digest = hashlib.blake2b(noise_key, digest_size=8).digest()
-        gen = torch.Generator(device=device)
-        gen.manual_seed(int.from_bytes(digest, "little") & 0x7FFF_FFFF_FFFF_FFFF)
-        z = torch.empty((1, _LATENT_PATCH_SIZE, _LATENT_DIM), device=device, dtype=torch.float32)
-        z.normal_(generator=gen)
-        state.noise_step += 1
-        dt = 1.0 / num_steps
-        times = torch.linspace(0.0, 1.0, num_steps + 1, device=device, dtype=torch.float32)
-
-        # Match upstream's autocast wrapper (model.py:280).  DiT's
-        # TimestepEmbedder internally forces fp32 (`.float()` on freqs);
-        # without autocast the fp32 output hits a bf16 Linear → dtype
-        # mismatch.  autocast bridges this for matmuls inside DiT.
-        use_amp = device.type == "cuda" and dtype in (torch.float16, torch.bfloat16)
-        with torch.autocast(
-            device_type=device.type if device.type == "cuda" else "cuda",
-            dtype=dtype if use_amp else torch.float32,
-            enabled=use_amp,
-        ):
-            for step in range(num_steps):
-                t = times[step].reshape(1)
-                z_proj = self._coordinate_proj(z)
-                z_c = input_sequence.clone()
-                z_c[:, latent_start:] = z_proj
-                z_u = cfg_sequence.clone()
-                z_u[:, latent_start:] = z_proj
-                z_batched = torch.cat([z_c, z_u], dim=0)
-                t_batched = t.repeat(2)
-                vt = self._head(
-                    x=z_batched,
-                    timesteps=t_batched,
-                    attn_mask=attn_mask,
-                    pos_ids=pos_ids,
-                    g_cond=g_cond_batched,
-                )
-                # Upcast DiT output before CFG blend + Euler update so the
-                # accumulation arithmetic stays fp32 (autocast only affects
-                # matmuls; these pointwise ops keep their input dtype).
-                vt = vt[:, latent_start:].float()
-                vt_c, vt_u = vt[0:1], vt[1:2]
-                velocity = vt_c + guidance_scale * (vt_c - vt_u)
-                z = z + velocity * dt
-        return z.to(dtype)
-
-    def _run_patch_encoder_loopback(
-        self,
-        state: _RequestState,
-        audio_patch_raw: torch.Tensor,
-    ) -> torch.Tensor:
-        """Decode one audio latent patch → 1 LLM input embed.
-
-        Mirrors upstream _consume_audio_patch (model.py:1557) — patch_encoder
-        side only.  Lazy-allocates state.patch_encoder_state on first call.
-        Returns ``llm_embedding`` of shape ``[1, 1, llm_hidden]`` — the
-        _PATCH_ENCODER_OUT_DS_RATE encoder positions fold into the feature
-        axis before ``out_proj``, not into separate output positions.
-
-        ``audio_patch_raw`` must already be denormalized (raw VAE latent
-        space).  Caller (_finish_decode) runs io_helper.denormalize on
-        DiT's normalized output before passing in.
-        """
-        if state.patch_encoder_state is None:
-            state.patch_encoder_state = self._patch_encoder.init_decode_state(
-                max_audio_patch_count=_MAX_AUDIO_PATCHES,
-                batch_size=1,
-                device=audio_patch_raw.device,
-                dtype=audio_patch_raw.dtype,
-            )
-        pe_state = state.patch_encoder_state
-        positions = (
-            torch.arange(
-                _PATCH_ENCODER_OUT_DS_RATE,
-                device=audio_patch_raw.device,
-                dtype=torch.long,
-            )
-            + pe_state.seq_len
-        )
-        llm_embedding, conv_tail = self._patch_encoder.decode_patch(
-            audio_patch_raw,
-            pe_state.conv_tail,
-            pe_state.layer_caches,
-            positions,
-        )
-        pe_state.conv_tail.copy_(conv_tail)
-        pe_state.seq_len += _PATCH_ENCODER_OUT_DS_RATE
-        return llm_embedding
-
-    def _run_vocoder_stream_step(
-        self,
-        state: _RequestState,
-        audio_patch_raw: torch.Tensor,
-    ) -> torch.Tensor:
-        """Streaming AudioVAE decode of one latent patch (review M2).
-
-        Mirrors upstream generate_audio_stream (model.py:1881-1900): a
-        per-request BigVGANStreamState carries the decoder's LSTM hidden
-        and sliding latent window across steps, so each patch is decoded
-        with real left context instead of inference_from_latents'
-        zero-padded isolated boundary.  Output lags input by
-        decoder.stream_lookahead (2 frames): the first call emits 2 frames
-        (3840 samples), steady state 4 (7680); the stop path in
-        _finish_decode drains the tail via stream_flush.
-
-        audio_patch_raw: [1, T=4, D=128] denormalized latents.
-        Returns wav chunk [1, 1, n_samples] (n_samples may be 0).
-        """
-        if state.vocoder_stream_state is None:
-            state.vocoder_stream_state = self._audio_vae.init_stream_state(
-                batch_size=1,
-                chunk_size=_LATENT_PATCH_SIZE,
-            )
-        # stream_step expects [B, latent_dim, T]; the vocoder is pinned
-        # fp32 (__init__), so cast the (possibly bf16) latents up.
-        return self._audio_vae.stream_step(
-            audio_patch_raw.transpose(1, 2).float(),
-            state.vocoder_stream_state,
-        )
-
-    def make_omni_output(
-        self,
-        model_outputs: torch.Tensor | OmniOutput,
-        **kwargs: Any,
-    ) -> OmniOutput:
-        """Drain self._audio_queue into the OmniOutput's multimodal_outputs.
-
-        Output contract is **delta** (SKILL I1): each call emits only
-        audio produced since the previous step; the engine's
-        _consolidate_multimodal_tensors concatenates across steps for
-        offline consumers.
-
-        Same-request multi-chunk: chunks for the same req_id within one
-        step are cat'd together.  Multi-request: one entry per req_id
-        in multimodal_outputs["model_outputs"].
-
-        Note: ``sr`` is not a declared OmniPayload key but the engine /
-        serving consumer reads it (voxcpm2 convention).
-        """
-        if isinstance(model_outputs, OmniOutput):
-            return model_outputs
-
-        mm: dict[str, Any] = {}
-        if self._audio_queue:
-            audio_by_req: dict[str, torch.Tensor] = {}
-            for req_id, audio in self._audio_queue:
-                if audio is None:
-                    continue
-                if req_id in audio_by_req:
-                    audio_by_req[req_id] = torch.cat(
-                        [audio_by_req[req_id].reshape(-1), audio.reshape(-1)],
-                        dim=0,
-                    )
-                else:
-                    audio_by_req[req_id] = audio
-            if audio_by_req:
-                sr = torch.tensor(self._sample_rate, dtype=torch.int32)
-                ready_req_ids = list(audio_by_req)
-                chunks = [audio_by_req[req_id].reshape(-1) for req_id in ready_req_ids]
-                mm["model_outputs"] = chunks
-                mm["sr"] = [sr for _ in ready_req_ids]
-                # sparse_audio: ["1"] flags GPUARModelRunner to skip the default
-                # payload["hidden"] = scaffold_hidden injection (gpu_ar_model_
-                # runner.py:1114).  Otherwise prefill scaffold (24 hidden × 1536
-                # = 29184 numbers observed) leaks into mm["audio"] via the
-                # output_processor "hidden" → target_key="audio" rename
-                # (output_processor.py:84), prepending ~0.61 s of noise.
-                mm["meta"] = {"req_id": ready_req_ids, "sparse_audio": ["1"]}
-            self._audio_queue.clear()
-        else:
-            # Empty-audio step (prefill) still needs the sparse marker so the
-            # engine doesn't bleed scaffold_hidden into mm["audio"].
-            mm["model_outputs"] = []
-            mm["sr"] = []
-            mm["meta"] = {"req_id": [], "sparse_audio": ["1"]}
-
-        if self._beta_trace:
-            payload = mm.get("model_outputs")
-            if payload:
-                for i, t in enumerate(payload):
-                    logger.info(
-                        f"[β-emit] mm[model_outputs][{i}]: shape={tuple(t.shape)} "
-                        f"dtype={t.dtype} samples={t.numel()} "
-                        f"rms={t.float().pow(2).mean().sqrt().item():.4f} "
-                        f"max={t.abs().max().item():.4f}"
-                    )
-            else:
-                logger.info("[β-emit] mm empty / no model_outputs")
-            mo_kind = type(model_outputs).__name__
-            mo_info = f"shape={tuple(model_outputs.shape)}" if hasattr(model_outputs, "shape") else "no_shape"
-            logger.info(f"[β-emit] text_hidden_states arg: {mo_kind} {mo_info}")
-
-        return OmniOutput(text_hidden_states=model_outputs, multimodal_outputs=mm)
-
-    def compute_logits(
-        self,
-        hidden_states: torch.Tensor | OmniOutput,
-        sampling_metadata: Any = None,
-    ) -> torch.Tensor | None:
-        """Per-step stop signal logits (vLLM sampling protocol).
-
-        Encodes continue/stop into ``logits[i, 0]`` / ``logits[i, 1]``
-        (voxcpm2 convention — rest of vocab stays at -inf so the sampler
-        picks between the two slots).  Source of stop logits is
-        ``self._results_queue``, populated by forward()'s _finish_decode.
-        When the queue is empty (preprocess-only steps), defaults to
-        all-continue.
-        """
-        if isinstance(hidden_states, OmniOutput):
-            hidden_states = hidden_states.text_hidden_states
-        if hidden_states is None:
-            return None
-
-        bsz = hidden_states.shape[0]
-        logits = torch.full(
-            (bsz, self.config.vocab_size),
-            float("-inf"),
-            device=hidden_states.device,
-            dtype=hidden_states.dtype,
-        )
-
-        if self._results_queue:
-            for i, (req_id, stop_logits) in enumerate(self._results_queue):
-                if i >= bsz:
-                    break
-                state = self._active_states.get(req_id)
-                if stop_logits is not None:
-                    if state is not None and state.is_stopping:
-                        logits[i, 0] = 0.0
-                        logits[i, 1] = 1.0
-                    else:
-                        # is_stopping=False means prob_stop <= 0.8 — force
-                        # continue.  Feeding the raw softmax (continue, stop)
-                        # pair as logits would let the greedy sampler compare
-                        # them directly, silently lowering the effective stop
-                        # threshold to 0.5 (early stop, swallowed endings).
-                        logits[i, 0] = 1.0
-                    if state is not None:
-                        state.precomputed_stop_logits = None
-                else:
-                    # No stop signal pushed this step (prefill placeholder).
-                    # Default to continue — stop is driven by eos_proj.
-                    logits[i, 0] = 1.0  # continue
-            self._results_queue.clear()
-        else:
-            logits[:, 0] = 1.0  # all continue
-
-        return logits
-
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        """Load all dots.tts checkpoint weights — step 6b.
-
-        Routing branches in a single pass over the input iterator (it can only
-        be consumed once):
-
-        * **AudioVAE**: keys from ``vocoder.safetensors`` (no parent prefix).
-          Matched via set membership against ``self._audio_vae.state_dict()``;
-          acts as the final catch-all so it must run last.
-        * **DiT**: keys from ``model.safetensors`` under ``velocity_field_predictor.``.
-        * **patch_encoder**: keys from ``model.safetensors`` under ``patch_encoder.``.
-        * **Five projectors** (``hidden_proj`` / ``latent_proj`` /
-          ``coordinate_proj`` / ``xvec_proj`` / ``eos_proj``): each lives at
-          its own top-level prefix; dispatched through a shared table.
-        * **Qwen2 base LM**: keys under ``llm.model.``, handed off to vLLM's
-          Qwen2Model fuser (q/k/v_proj -> qkv_proj, gate/up_proj ->
-          gate_up_proj).  ``llm.lm_head.*`` is silently dropped (soar uses
-          ``tie_word_embeddings=True`` and our ``self.model`` is a Qwen2Model
-          with no lm_head module).
-        * **CAM++ speaker encoder**: keys from ``speaker_encoder.safetensors``
-          (no parent prefix, same convention as AudioVAE).  Routed by set
-          membership against ``self._speaker_encoder.state_dict()`` (keys are
-          ``model.*`` / ``resample.kernel``, no distinguishing top-level
-          prefix).  **Placed before the AudioVAE fallback** so its keys don't
-          fall through to the catch-all.
-        """
-        vae_state_keys = set(self._audio_vae.state_dict().keys())
-        dit_state_keys = set(self._head.state_dict().keys())
-        patch_state_keys = set(self._patch_encoder.state_dict().keys())
-        speaker_state_keys = set(self._speaker_encoder.state_dict().keys())
-
-        # (top-level prefix in checkpoint, local attr name, local nn.Module)
-        projector_specs: list[tuple[str, str, nn.Module]] = [
-            ("hidden_proj.", "_hidden_proj", self._hidden_proj),
-            ("latent_proj.", "_latent_proj", self._latent_proj),
-            ("coordinate_proj.", "_coordinate_proj", self._coordinate_proj),
-            ("xvec_proj.", "_xvec_proj", self._xvec_proj),
-            ("eos_proj.", "_eos_proj", self._eos_proj),
-        ]
-        projector_state_keys = {prefix: set(mod.state_dict().keys()) for prefix, _, mod in projector_specs}
-        projector_matched: dict[str, list[tuple[str, torch.Tensor]]] = {prefix: [] for prefix, _, _ in projector_specs}
-
-        matched_vae: list[tuple[str, torch.Tensor]] = []
-        matched_dit: list[tuple[str, torch.Tensor]] = []
-        matched_patch: list[tuple[str, torch.Tensor]] = []
-        matched_llm: list[tuple[str, torch.Tensor]] = []
-        matched_speaker: list[tuple[str, torch.Tensor]] = []
-        skipped_lm_head = 0
-
-        DIT_PREFIX = "velocity_field_predictor."
-        PATCH_PREFIX = "patch_encoder."
-        LLM_MODEL_PREFIX = "llm.model."
-        LLM_LM_HEAD_PREFIX = "llm.lm_head."
-        for name, tensor in weights:
-            if name.startswith(DIT_PREFIX):
-                candidate = name[len(DIT_PREFIX) :]
-                if candidate in dit_state_keys:
-                    matched_dit.append((candidate, tensor))
-                continue
-            if name.startswith(PATCH_PREFIX):
-                candidate = name[len(PATCH_PREFIX) :]
-                if candidate in patch_state_keys:
-                    matched_patch.append((candidate, tensor))
-                continue
-            if name.startswith(LLM_LM_HEAD_PREFIX):
-                # Qwen2.5-1.5B-Base has tie_word_embeddings=True, and our
-                # ``self.model`` is a Qwen2Model (no lm_head submodule).  Drop.
-                skipped_lm_head += 1
-                continue
-            if name.startswith(LLM_MODEL_PREFIX):
-                candidate = name[len(LLM_MODEL_PREFIX) :]
-                # Hand off untouched — Qwen2Model.load_weights does its own
-                # fusion (q/k/v_proj -> qkv_proj, gate/up_proj -> gate_up_proj)
-                # and tolerates unknown keys, so no local key set to gate.
-                matched_llm.append((candidate, tensor))
-                continue
-            # Projectors: 5 candidate top-level prefixes, first hit wins.
-            hit_projector = False
-            for prefix, _attr, _mod in projector_specs:
-                if name.startswith(prefix):
-                    candidate = name[len(prefix) :]
-                    if candidate in projector_state_keys[prefix]:
-                        projector_matched[prefix].append((candidate, tensor))
-                    hit_projector = True
-                    break
-            if hit_projector:
-                continue
-            # Speaker encoder: set-membership match (no distinguishing prefix
-            # in checkpoint; placed before the AudioVAE fallback so its keys
-            # don't get silently dropped by the catch-all).
-            if name in speaker_state_keys:
-                matched_speaker.append((name, tensor))
-                continue
-            candidate = name[len("vocoder.") :] if name.startswith("vocoder.") else name
-            if candidate in vae_state_keys:
-                matched_vae.append((candidate, tensor))
-
-        loaded: set[str] = set()
-
-        if matched_vae:
-            vae_loader = AutoWeightsLoader(self._audio_vae)
-            loaded_vae = vae_loader.load_weights(iter(matched_vae))
-            loaded.update(f"_audio_vae.{name}" for name in loaded_vae)
-            logger.info(
-                "DotsTTS load_weights: loaded %d/%d AudioVAE tensors.",
-                len(loaded_vae),
-                len(vae_state_keys),
-            )
-
-        if matched_dit:
-            dit_loader = AutoWeightsLoader(self._head)
-            loaded_dit = dit_loader.load_weights(iter(matched_dit))
-            loaded.update(f"_head.{name}" for name in loaded_dit)
-            logger.info(
-                "DotsTTS load_weights: loaded %d/%d DiT tensors.",
-                len(loaded_dit),
-                len(dit_state_keys),
-            )
-
-        if matched_patch:
-            patch_loader = AutoWeightsLoader(self._patch_encoder)
-            loaded_patch = patch_loader.load_weights(iter(matched_patch))
-            loaded.update(f"_patch_encoder.{name}" for name in loaded_patch)
-            logger.info(
-                "DotsTTS load_weights: loaded %d/%d patch_encoder tensors.",
-                len(loaded_patch),
-                len(patch_state_keys),
-            )
-
-        any_projector_matched = False
-        for prefix, attr_name, mod in projector_specs:
-            matched = projector_matched[prefix]
-            if not matched:
-                continue
-            any_projector_matched = True
-            proj_loader = AutoWeightsLoader(mod)
-            loaded_proj = proj_loader.load_weights(iter(matched))
-            loaded.update(f"{attr_name}.{name}" for name in loaded_proj)
-            logger.info(
-                "DotsTTS load_weights: loaded %d/%d %s tensors.",
-                len(loaded_proj),
-                len(projector_state_keys[prefix]),
-                prefix[:-1],
-            )
-
-        if matched_llm:
-            # vLLM's Qwen2Model.load_weights does its own fusion + tolerates
-            # unknown keys.  It returns the set of param names it actually
-            # accepted; re-prefix with ``model.`` for our return value (our
-            # local attr is ``self.model``).
-            loaded_llm = self.model.load_weights(iter(matched_llm))
-            loaded.update(f"model.{name}" for name in loaded_llm)
-            logger.info(
-                "DotsTTS load_weights: loaded %d Qwen2 tensors (fed %d; %d llm.lm_head.* skipped — tied embeddings).",
-                len(loaded_llm),
-                len(matched_llm),
-                skipped_lm_head,
-            )
-
-        if matched_speaker:
-            speaker_loader = AutoWeightsLoader(self._speaker_encoder)
-            loaded_speaker = speaker_loader.load_weights(iter(matched_speaker))
-            loaded.update(f"_speaker_encoder.{name}" for name in loaded_speaker)
-            logger.info(
-                "DotsTTS load_weights: loaded %d/%d CAM++ speaker_encoder tensors.",
-                len(loaded_speaker),
-                len(speaker_state_keys),
-            )
-
-        if (
-            not matched_vae
-            and not matched_dit
-            and not matched_patch
-            and not any_projector_matched
-            and not matched_llm
-            and not matched_speaker
-        ):
-            logger.warning(
-                "DotsTTS load_weights: no AudioVAE / DiT / "
-                "patch_encoder / projector / Qwen2 / speaker_encoder keys matched."
-            )
-
-        return loaded
diff --git a/vllm_omni/model_executor/models/dots_tts/dots_tts_vocoder.py b/vllm_omni/model_executor/models/dots_tts/dots_tts_vocoder.py
deleted file mode 100644
index fe17b5c0b..000000000
--- a/vllm_omni/model_executor/models/dots_tts/dots_tts_vocoder.py
+++ /dev/null
@@ -1,1434 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2026 The vLLM-Omni team.
-# Copyright (c) rednote-hilab. All rights reserved.
-# Adapted from:
-# https://github.com/rednote-hilab/dots.tts/tree/a393d2e/src/dots_tts/modules
-#
-# Merged from six upstream files (preserved as-is, inference behaviour
-# unchanged; only internal imports were folded inline):
-#   - modules/vocoder/config.py             -> AudioVAEConfig
-#   - modules/backbone/layers.py            -> Conv1d, ConvTranspose1d
-#                                              (Mlp/MultiHeadAttention/RotaryEmbedding
-#                                              are not vendored here; they belong
-#                                              to the DiT side-path module added later)
-#   - modules/vocoder/alias_free_filter.py  -> sinc, kaiser_sinc_filter1d,
-#                                              LowPassFilter1d
-#   - modules/vocoder/alias_free_resample.py-> UpSample1d, DownSample1d
-#   - modules/vocoder/alias_free_act.py     -> Snake, SnakeBeta, Activation1d
-#   - modules/vocoder/bigvgan.py            -> AudioVAE and all its sub-modules
-#
-# Per-section upstream attributions are preserved at each section header.
-# AudioVAEConfig is the only piece that diverges from upstream: pydantic
-# ConfigBase replaced with a stdlib @dataclass (extra fields not exercised by
-# any shipped checkpoint).
-
-from __future__ import annotations
-
-import itertools
-import math
-from dataclasses import dataclass, field
-from fractions import Fraction
-
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch import pow, sin
-from torch.nn import Parameter
-from torch.nn.utils import remove_weight_norm, weight_norm
-
-# ============================================================================
-# Configuration (adapted from modules/vocoder/config.py)
-# ----------------------------------------------------------------------------
-# Upstream subclasses a pydantic ``ConfigBase`` with ``extra="allow"``; both the
-# dots.tts-soar and dots.tts-mf checkpoint ``config.json`` pass only the 17
-# declared fields below, so the escape hatch is never exercised.  ``.get()``
-# helper preserves bigvgan.py's ``h.get(...)`` call sites without modification.
-# ``num_decoder_lookahead`` / ``num_encoder_lookahead`` are looked up via
-# ``h.get(...)`` but not present in any shipped config; they fall back to 2.
-# ============================================================================
-
-
-@dataclass
-class AudioVAEConfig:
-    sample_rate: int = 24000
-    upsample_rates: list[int] = field(default_factory=list)
-    upsample_kernel_sizes: list[int] = field(default_factory=list)
-    upsample_initial_channel: int = 1536
-    resblock: str = "1"
-    resblock_kernel_sizes: list[int] = field(default_factory=list)
-    resblock_dilation_sizes: list[list[int]] = field(default_factory=list)
-    downsample_rates: list[int] = field(default_factory=list)
-    downsample_channels: list[int] = field(default_factory=list)
-    activation: str = "snakebeta"
-    snake_logscale: bool = True
-    latent_dim: int = 128
-    causal: bool = False
-    mi_num_layers: int = 4
-    causal_encoder: bool = False
-    use_bias_at_final: bool = True
-    use_tanh_at_final: bool = True
-
-    num_decoder_lookahead: int = 2
-    num_encoder_lookahead: int = 2
-
-    def get(self, key: str, default=None):
-        return getattr(self, key, default)
-
-
-# ============================================================================
-# Conv layers (vendored from modules/backbone/layers.py)
-# ----------------------------------------------------------------------------
-# Only the Conv1d / ConvTranspose1d helpers are needed by the AudioVAE.
-# Mlp / MultiHeadAttention / RotaryEmbedding from the same upstream file are
-# reserved for the DiT flow-matching head, which gets its own vendored module
-# in a later step.
-# ============================================================================
-
-
-class Conv1d(nn.Conv1d):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        kernel_size: int = 1,
-        stride: int = 1,
-        dilation: int = 1,
-        groups: int = 1,
-        padding_mode: str = "zeros",
-        bias: bool = True,
-        padding=None,
-        causal: bool = False,
-        **_kwargs,
-    ):
-        self.causal = causal
-        if padding is None:
-            if causal:
-                padding = 0
-                self.left_padding = dilation * (kernel_size - 1)
-            else:
-                padding = int((kernel_size * dilation - dilation) / 2)
-
-        super().__init__(
-            in_channels,
-            out_channels,
-            kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            groups=groups,
-            padding_mode=padding_mode,
-            bias=bias,
-        )
-
-        self.in_channels = in_channels
-
-    def forward(self, x):
-        if self.causal:
-            x = F.pad(x.unsqueeze(2), (self.left_padding, 0, 0, 0)).squeeze(2)
-        return super().forward(x)
-
-
-class ConvTranspose1d(nn.ConvTranspose1d):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        kernel_size: int,
-        stride: int = 1,
-        output_padding: int = 0,
-        groups: int = 1,
-        bias: bool = True,
-        dilation: int = 1,
-        padding=None,
-        padding_mode: str = "zeros",
-        causal: bool = False,
-        **_kwargs,
-    ):
-        if padding is None:
-            padding = 0 if causal else (kernel_size - stride) // 2
-        if causal:
-            assert padding == 0, "padding is not allowed in causal ConvTranspose1d."
-            assert kernel_size == 2 * stride, "kernel_size must be equal to 2*stride in Causal ConvTranspose1d."
-
-        super().__init__(
-            in_channels,
-            out_channels,
-            kernel_size,
-            stride=stride,
-            padding=padding,
-            output_padding=output_padding,
-            groups=groups,
-            bias=bias,
-            dilation=dilation,
-            padding_mode=padding_mode,
-        )
-
-        self.causal = causal
-        self.stride = stride
-
-    def forward(self, x):
-        x = super().forward(x)
-        if self.causal:
-            x = x[:, :, : -self.stride]
-        return x
-
-
-# ============================================================================
-# Alias-free low-pass filter (vendored from modules/vocoder/alias_free_filter.py)
-# ----------------------------------------------------------------------------
-# Adapted from https://github.com/junjun3518/alias-free-torch under
-# the Apache License 2.0.  The sinc fallback is adopted from adefossez's
-# julius.core.sinc (MIT).
-# ============================================================================
-
-
-if "sinc" in dir(torch):
-    sinc = torch.sinc
-else:
-
-    def sinc(x: torch.Tensor):
-        """
-        Implementation of sinc, i.e. sin(pi * x) / (pi * x)
-        __Warning__: Different to julius.sinc, the input is multiplied by `pi`!
-        """
-        return torch.where(
-            x == 0,
-            torch.tensor(1.0, device=x.device, dtype=x.dtype),
-            torch.sin(math.pi * x) / math.pi / x,
-        )
-
-
-def kaiser_sinc_filter1d(cutoff, half_width, kernel_size):  # return filter [1,1,kernel_size]
-    even = kernel_size % 2 == 0
-    half_size = kernel_size // 2
-
-    # For kaiser window
-    delta_f = 4 * half_width
-    A = 2.285 * (half_size - 1) * math.pi * delta_f + 7.95
-    if A > 50.0:
-        beta = 0.1102 * (A - 8.7)
-    elif A >= 21.0:
-        beta = 0.5842 * (A - 21) ** 0.4 + 0.07886 * (A - 21.0)
-    else:
-        beta = 0.0
-    window = torch.kaiser_window(kernel_size, beta=beta, periodic=False)
-
-    # ratio = 0.5/cutoff -> 2 * cutoff = 1 / ratio
-    if even:
-        time = torch.arange(-half_size, half_size) + 0.5
-    else:
-        time = torch.arange(kernel_size) - half_size
-    if cutoff == 0:
-        filter_ = torch.zeros_like(time)
-    else:
-        filter_ = 2 * cutoff * window * sinc(2 * cutoff * time)
-        # Normalize filter to have sum = 1, otherwise we will have a small leakage
-        # of the constant component in the input signal.
-        filter_ /= filter_.sum()
-        filter = filter_.view(1, 1, kernel_size)
-
-    return filter
-
-
-class LowPassFilter1d(nn.Module):
-    def __init__(
-        self,
-        cutoff=0.5,
-        half_width=0.6,
-        stride: int = 1,
-        padding: bool = True,
-        padding_mode: str = "replicate",
-        kernel_size: int = 12,
-        channels: int = 1,
-        causal: bool = True,
-        fixed_filter: bool = False,
-    ):
-        # kernel_size should be even number for stylegan3 setup,
-        # in this implementation, odd number is also possible.
-        super().__init__()
-        if cutoff < -0.0:
-            raise ValueError("Minimum cutoff must be larger than zero.")
-        if cutoff > 0.5:
-            raise ValueError("A cutoff above 0.5 does not make sense.")
-        self.kernel_size = kernel_size
-        if causal:
-            self.pad_left = kernel_size - 1
-            self.pad_right = 0
-        else:
-            self.even = kernel_size % 2 == 0
-            self.pad_left = kernel_size // 2 - int(self.even)
-            self.pad_right = kernel_size // 2
-        self.stride = stride
-        self.padding = padding
-        self.padding_mode = padding_mode
-        self.fixed_filter = fixed_filter
-        filter = kaiser_sinc_filter1d(cutoff, half_width, kernel_size)
-        if fixed_filter:
-            self.register_buffer("filter", filter)
-        else:
-            self.filter = nn.Parameter(filter.expand(channels, -1, -1).clone())
-
-    # input [B, C, T]
-    def forward(self, x):
-        _, C, _ = x.shape
-        if self.padding:
-            x = F.pad(x, (self.pad_left, self.pad_right), mode=self.padding_mode)
-        if self.fixed_filter:
-            out = F.conv1d(x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C)
-        else:
-            out = F.conv1d(x, self.filter, stride=self.stride, groups=C)
-        return out
-
-
-# ============================================================================
-# Alias-free up/down sampling (vendored from modules/vocoder/alias_free_resample.py)
-# ----------------------------------------------------------------------------
-# Adapted from https://github.com/junjun3518/alias-free-torch (Apache 2.0).
-# ============================================================================
-
-
-class UpSample1d(nn.Module):
-    def __init__(self, ratio=2, kernel_size=None, channels=None, causal=True, fixed_filter=False):
-        super().__init__()
-        self.ratio = ratio
-        self.kernel_size = int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
-        self.stride = ratio
-        self.channels = channels
-        self.causal = causal
-        self.fixed_filter = fixed_filter
-        if causal:
-            self.pad = 0
-        else:
-            self.pad = self.kernel_size // ratio - 1
-            self.pad_left = self.pad * self.stride + (self.kernel_size - self.stride) // 2
-            self.pad_right = self.pad * self.stride + (self.kernel_size - self.stride + 1) // 2
-        filter = kaiser_sinc_filter1d(cutoff=0.5 / ratio, half_width=0.6 / ratio, kernel_size=self.kernel_size)
-        if self.fixed_filter:
-            self.register_buffer("filter", filter)
-        else:
-            self.filter = nn.Parameter(filter.expand(channels, -1, -1).clone())
-
-    # x: [B, C, T]
-    def forward(self, x):
-        _, C, _ = x.shape
-        x = F.pad(x, (self.pad, self.pad), mode="replicate")
-        if self.fixed_filter:
-            x = self.ratio * F.conv_transpose1d(x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C)
-        else:
-            x = self.ratio * F.conv_transpose1d(x, self.filter, stride=self.stride, groups=C)
-        if self.causal:
-            x = x[..., : -(self.kernel_size - self.stride)]
-        else:
-            x = x[..., self.pad_left : -self.pad_right]
-
-        return x
-
-
-class DownSample1d(nn.Module):
-    def __init__(self, ratio=2, kernel_size=None, channels=None, causal=True, fixed_filter=False):
-        super().__init__()
-        self.ratio = ratio
-        self.kernel_size = int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
-        self.lowpass = LowPassFilter1d(
-            cutoff=0.5 / ratio,
-            half_width=0.6 / ratio,
-            stride=ratio,
-            kernel_size=self.kernel_size,
-            channels=channels,
-            causal=causal,
-            fixed_filter=fixed_filter,
-        )
-
-    def forward(self, x):
-        return self.lowpass(x)
-
-
-# ============================================================================
-# Snake activations + alias-free Activation1d (vendored from
-# modules/vocoder/alias_free_act.py)
-# ----------------------------------------------------------------------------
-# Adapted from https://github.com/junjun3518/alias-free-torch (Apache 2.0).
-# Snake / SnakeBeta paper: https://arxiv.org/abs/2006.08195
-# ============================================================================
-
-
-class Activation1d(nn.Module):
-    def __init__(
-        self,
-        activation,
-        up_ratio: int = 2,
-        down_ratio: int = 2,
-        up_kernel_size: int = 12,
-        down_kernel_size: int = 12,
-        causal=True,
-        fixed_filter=False,
-    ):
-        super().__init__()
-        # causal=False
-        self.up_ratio = up_ratio
-        self.down_ratio = down_ratio
-        self.act = activation
-        self.upsample = UpSample1d(
-            up_ratio,
-            up_kernel_size,
-            activation.in_features,
-            causal=causal,
-            fixed_filter=fixed_filter,
-        )
-        self.downsample = DownSample1d(
-            down_ratio,
-            down_kernel_size,
-            activation.in_features,
-            causal=causal,
-            fixed_filter=fixed_filter,
-        )
-
-    # x: [B,C,T]
-    def forward(self, x):
-        x = self.upsample(x)
-        x = self.act(x)
-        return self.downsample(x)
-
-
-class Snake(nn.Module):
-    """
-    Implementation of a sine-based periodic activation function
-    Shape:
-        - Input: (B, C, T)
-        - Output: (B, C, T), same shape as the input
-    Parameters:
-        - alpha - trainable parameter
-    """
-
-    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
-        super().__init__()
-        self.in_features = in_features
-
-        # initialize alpha
-        self.alpha_logscale = alpha_logscale
-        if self.alpha_logscale:  # log scale alphas initialized to zeros
-            self.alpha = Parameter(torch.zeros(in_features) * alpha)
-        else:  # linear scale alphas initialized to ones
-            self.alpha = Parameter(torch.ones(in_features) * alpha)
-
-        self.alpha.requires_grad = alpha_trainable
-
-        self.no_div_by_zero = 0.000000001
-
-    def forward(self, x):
-        # Snake := x + 1/a * sin^2 (xa)
-        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)  # line up with x to [B, C, T]
-        if self.alpha_logscale:
-            alpha = torch.exp(alpha)
-        return x + (1.0 / (alpha + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
-
-
-class SnakeBeta(nn.Module):
-    """
-    A modified Snake function which uses separate parameters for the magnitude
-    of the periodic components.
-    Shape:
-        - Input: (B, C, T)
-        - Output: (B, C, T), same shape as the input
-    Parameters:
-        - alpha - trainable parameter that controls frequency
-        - beta - trainable parameter that controls magnitude
-    """
-
-    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
-        super().__init__()
-        self.in_features = in_features
-
-        # initialize alpha
-        self.alpha_logscale = alpha_logscale
-        if self.alpha_logscale:  # log scale alphas initialized to zeros
-            self.alpha = Parameter(torch.zeros(in_features) * alpha)
-            self.beta = Parameter(torch.zeros(in_features) * alpha)
-        else:  # linear scale alphas initialized to ones
-            self.alpha = Parameter(torch.ones(in_features) * alpha)
-            self.beta = Parameter(torch.ones(in_features) * alpha)
-
-        self.alpha.requires_grad = alpha_trainable
-        self.beta.requires_grad = alpha_trainable
-
-        self.no_div_by_zero = 0.000000001
-
-    def forward(self, x):
-        # SnakeBeta := x + 1/b * sin^2 (xa)
-        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)  # line up with x to [B, C, T]
-        beta = self.beta.unsqueeze(0).unsqueeze(-1)
-        if self.alpha_logscale:
-            alpha = torch.exp(alpha)
-            beta = torch.exp(beta)
-        return x + (1.0 / (beta + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
-
-
-# ============================================================================
-# BigVGAN AudioVAE (vendored from modules/vocoder/bigvgan.py)
-# ----------------------------------------------------------------------------
-# Copyright (c) 2022 NVIDIA CORPORATION.
-#   Licensed under the MIT license.
-# Upstream layout flattened: the only modification is that the three
-# original ``from dots_tts.modules.{backbone,vocoder}.* import ...`` lines
-# are dropped, since those names are already defined above in this file.
-# ============================================================================
-
-
-@dataclass(slots=True)
-class BigVGANStreamState:
-    lstm_hidden: tuple[torch.Tensor, torch.Tensor]
-    decoder: DecoderStreamState
-
-
-@dataclass(slots=True)
-class DecoderStreamState:
-    window: torch.Tensor
-    chunk_size: int
-    total_frames: int = 0
-    emitted_frames: int = 0
-
-
-def _empty_chunk(
-    ref: torch.Tensor,
-    *,
-    channels: int | None = None,
-    dtype: torch.dtype | None = None,
-) -> torch.Tensor:
-    return ref.new_zeros(
-        (ref.size(0), channels or ref.size(1), 0),
-        dtype=dtype or ref.dtype,
-    )
-
-
-def _module_state_device_dtype(module: nn.Module) -> tuple[torch.device, torch.dtype]:
-    for name in ("weight", "bias", "filter"):
-        tensor = getattr(module, name, None)
-        if tensor is not None:
-            return tensor.device, tensor.dtype
-    for tensor in itertools.chain(module.parameters(), module.buffers()):
-        return tensor.device, tensor.dtype
-    raise RuntimeError(f"Unable to infer state dtype/device for {type(module).__name__}.")
-
-
-def _stream_state_zeros(
-    batch_size: int,
-    channels: int,
-    length: int,
-    *,
-    device: torch.device,
-    dtype: torch.dtype,
-) -> torch.Tensor:
-    return torch.zeros(
-        (batch_size, channels, max(0, int(length))),
-        device=device,
-        dtype=dtype,
-    )
-
-
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-
-
-class Conv1d_S(nn.Module):
-    "Conv1d for spectral normalisation and orthogonal initialisation"
-
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        kernel_size=1,
-        stride=1,
-        dilation=1,
-        groups=1,
-        causal=False,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.kernel_size = kernel_size
-        self.stride = stride
-        self.dilation = dilation
-        self.groups = groups
-        self.causal = causal
-        pad = 0 if causal else dilation * (kernel_size - 1) // 2
-        self.causal_pad = dilation * (kernel_size - 1) if causal else 0
-
-        self.layer = weight_norm(
-            nn.Conv1d(
-                in_channels,
-                out_channels,
-                kernel_size=kernel_size,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                groups=groups,
-            )
-        )
-
-    def forward(self, inputs):
-        if self.causal and self.causal_pad > 0:
-            inputs = F.pad(inputs, (self.causal_pad, 0))
-        return self.layer(inputs)
-
-
-class SLSTM(nn.Module):
-    """
-    LSTM without worrying about the hidden state, nor the layout of the data.
-    Expects input as convolutional layout.
-    """
-
-    def __init__(
-        self,
-        dimension: int,
-        num_layers: int = 2,
-        skip: bool = True,
-        bidirectional: bool = False,
-    ):
-        super().__init__()
-        self.skip = skip
-        self.bidirectional = bidirectional
-        self.lstm = nn.LSTM(
-            input_size=dimension,
-            hidden_size=dimension,
-            num_layers=num_layers,
-            bidirectional=bidirectional,
-            batch_first=True,
-        )
-        self._stream_num_layers = num_layers
-        self._stream_weight_ih = tuple(getattr(self.lstm, f"weight_ih_l{layer_idx}") for layer_idx in range(num_layers))
-        self._stream_weight_hh = tuple(getattr(self.lstm, f"weight_hh_l{layer_idx}") for layer_idx in range(num_layers))
-        self._stream_bias_ih = tuple(getattr(self.lstm, f"bias_ih_l{layer_idx}") for layer_idx in range(num_layers))
-        self._stream_bias_hh = tuple(getattr(self.lstm, f"bias_hh_l{layer_idx}") for layer_idx in range(num_layers))
-        if self.bidirectional:
-            self.proj_out = nn.Linear(dimension * 2, dimension)
-
-    def forward(self, x):
-        y, _ = self.lstm(x)
-        if self.bidirectional:
-            y = self.proj_out(y)
-        if self.skip:
-            y = y + x
-        return y
-
-    def stream_step(
-        self,
-        x: torch.Tensor,
-        hidden: tuple[torch.Tensor, torch.Tensor] | None,
-    ) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
-        if self.bidirectional:
-            raise RuntimeError("Streaming only supports unidirectional SLSTM.")
-
-        residual = x
-        if hidden is None:
-            hidden = self.init_stream_state(x.size(0))
-
-        hidden_h, hidden_c = hidden
-        next_hidden_h = []
-        next_hidden_c = []
-        for layer_idx in range(self._stream_num_layers):
-            layer_input = x
-            hx = hidden_h[layer_idx]
-            cx = hidden_c[layer_idx]
-            outputs = []
-            weight_ih = self._stream_weight_ih[layer_idx]
-            weight_hh = self._stream_weight_hh[layer_idx]
-            bias_ih = self._stream_bias_ih[layer_idx]
-            bias_hh = self._stream_bias_hh[layer_idx]
-
-            for frame_idx in range(x.size(1)):
-                gates = F.linear(layer_input[:, frame_idx, :], weight_ih, bias_ih)
-                gates = gates + F.linear(hx, weight_hh, bias_hh)
-                input_gate, forget_gate, cell_gate, output_gate = gates.chunk(4, dim=-1)
-                input_gate = torch.sigmoid(input_gate)
-                forget_gate = torch.sigmoid(forget_gate)
-                cell_gate = torch.tanh(cell_gate)
-                output_gate = torch.sigmoid(output_gate)
-                cx = forget_gate * cx + input_gate * cell_gate
-                hx = output_gate * torch.tanh(cx)
-                outputs.append(hx)
-
-            x = torch.stack(outputs, dim=1)
-            next_hidden_h.append(hx)
-            next_hidden_c.append(cx)
-
-        y = x
-        if self.skip:
-            y = y + residual
-        return y, (torch.stack(next_hidden_h, dim=0), torch.stack(next_hidden_c, dim=0))
-
-    def init_stream_state(
-        self,
-        batch_size: int,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        num_directions = 2 if self.bidirectional else 1
-        state_shape = (
-            self.lstm.num_layers * num_directions,
-            batch_size,
-            self.lstm.hidden_size,
-        )
-        weight = self.lstm.weight_hh_l0
-        return (
-            weight.new_zeros(state_shape),
-            weight.new_zeros(state_shape),
-        )
-
-
-class ResStack(nn.Module):
-    def __init__(self, channel, kernel_size=3, base=3, nums=4, causal=False):
-        super().__init__()
-
-        self.layers = nn.ModuleList([])
-        for i in range(nums):
-            dil = base**i
-            pad1 = dil * (kernel_size - 1) if causal else dil
-            pad2 = (kernel_size - 1) if causal else 1
-            block = [
-                nn.LeakyReLU(),
-            ]
-            if causal and pad1 > 0:
-                block.append(nn.ConstantPad1d((pad1, 0), 0.0))
-            block.append(
-                nn.utils.weight_norm(
-                    nn.Conv1d(
-                        channel,
-                        channel,
-                        kernel_size=kernel_size,
-                        dilation=dil,
-                        padding=0 if causal else pad1,
-                    )
-                )
-            )
-            block.append(nn.LeakyReLU())
-            if causal and pad2 > 0:
-                block.append(nn.ConstantPad1d((pad2, 0), 0.0))
-            block.append(
-                nn.utils.weight_norm(
-                    nn.Conv1d(
-                        channel,
-                        channel,
-                        kernel_size=kernel_size,
-                        dilation=1,
-                        padding=0 if causal else pad2,
-                    )
-                )
-            )
-            self.layers.append(nn.Sequential(*block))
-
-    def forward(self, x):
-        for layer in self.layers:
-            x = x + layer(x)
-        return x
-
-
-class Encoder(nn.Module):
-    def __init__(
-        self,
-        in_channels=1,
-        out_channels=100,
-        base_channels=12,
-        proj_kernel_size=3,
-        stack_kernel_size=3,
-        stack_dilation_base=2,
-        stacks=6,
-        channels=(12, 24, 48, 96, 192, 384, 768),
-        down_sample_factors=(2, 2, 2, 2, 4, 4),
-        causal=False,
-        lookahead=0,
-    ):
-        super().__init__()
-
-        act_slope = 0.2
-        layers = []
-        # pre proj_layer
-        layers += [
-            Conv1d_S(
-                in_channels,
-                base_channels,
-                kernel_size=proj_kernel_size,
-                stride=1,
-                causal=causal,
-            ),
-            nn.LeakyReLU(act_slope, True),
-        ]
-
-        # channels: [512, 256, 128, 64], upsample_factors: [5, 2, 2]
-        for (in_c, out_c), down_f in zip(itertools.pairwise(channels), down_sample_factors, strict=True):
-            layers += [
-                Conv1d_S(in_c, out_c, kernel_size=down_f * 2, stride=down_f, causal=causal),
-                ResStack(out_c, stack_kernel_size, stack_dilation_base, stacks, causal=causal),
-                nn.LeakyReLU(act_slope, True),
-            ]
-
-        # post layers
-        if lookahead > 0:
-            layers += [
-                Conv1d_S(
-                    channels[-1],
-                    out_channels,
-                    kernel_size=lookahead * 2 + 1,
-                    stride=1,
-                    causal=False,
-                ),
-            ]
-        else:
-            layers += [
-                Conv1d_S(
-                    channels[-1],
-                    out_channels,
-                    kernel_size=proj_kernel_size,
-                    stride=1,
-                    causal=causal,
-                ),
-            ]
-        self.generator = nn.Sequential(*layers)
-
-    def forward(self, conditions, _z_inputs=None):
-        return self.generator(conditions)
-
-
-class AMPBlock1(torch.nn.Module):
-    def __init__(
-        self,
-        h,
-        channels,
-        kernel_size=3,
-        dilation=(1, 3, 5),
-        activation=None,
-        causal=True,
-    ):
-        super().__init__()
-        self.h = h
-
-        self.convs1 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        causal=causal,
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        causal=causal,
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[2],
-                        causal=causal,
-                    )
-                ),
-            ]
-        )
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList(
-            [
-                weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1, causal=causal)),
-                weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1, causal=causal)),
-                weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1, causal=causal)),
-            ]
-        )
-        self.convs2.apply(init_weights)
-
-        self.num_layers = len(self.convs1) + len(self.convs2)  # total number of conv layers
-
-        if activation == "snake":  # periodic nonlinearity with snake function and anti-aliasing
-            self.activations = nn.ModuleList(
-                [
-                    Activation1d(
-                        activation=Snake(channels, alpha_logscale=h.snake_logscale),
-                        causal=causal,
-                        fixed_filter=True,
-                    )
-                    for _ in range(self.num_layers)
-                ]
-            )
-        elif activation == "snakebeta":  # periodic nonlinearity with snakebeta function and anti-aliasing
-            self.activations = nn.ModuleList(
-                [
-                    Activation1d(
-                        activation=SnakeBeta(channels, alpha_logscale=h.snake_logscale),
-                        causal=causal,
-                        fixed_filter=True,
-                    )
-                    for _ in range(self.num_layers)
-                ]
-            )
-        else:
-            raise NotImplementedError(
-                "activation incorrectly specified. check the config file and look for 'activation'."
-            )
-
-    def forward(self, x):
-        acts1, acts2 = self.activations[::2], self.activations[1::2]
-        for c1, c2, a1, a2 in zip(self.convs1, self.convs2, acts1, acts2, strict=True):
-            xt = a1(x)
-            xt = c1(xt)
-            xt = a2(xt)
-            xt = c2(xt)
-            x = xt + x
-
-        return x
-
-    def remove_weight_norm(self):
-        for layer in self.convs1:
-            remove_weight_norm(layer)
-        for layer in self.convs2:
-            remove_weight_norm(layer)
-
-
-class AMPBlock2(torch.nn.Module):
-    def __init__(self, h, channels, kernel_size=3, dilation=(1, 3), activation=None, causal=True):
-        super().__init__()
-        self.h = h
-
-        self.convs = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        causal=causal,
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        causal=causal,
-                    )
-                ),
-            ]
-        )
-        self.convs.apply(init_weights)
-
-        self.num_layers = len(self.convs)  # total number of conv layers
-
-        if activation == "snake":  # periodic nonlinearity with snake function and anti-aliasing
-            self.activations = nn.ModuleList(
-                [
-                    Activation1d(
-                        activation=Snake(channels, alpha_logscale=h.snake_logscale),
-                        causal=causal,
-                        fixed_filter=True,
-                    )
-                    for _ in range(self.num_layers)
-                ]
-            )
-        elif activation == "snakebeta":  # periodic nonlinearity with snakebeta function and anti-aliasing
-            self.activations = nn.ModuleList(
-                [
-                    Activation1d(
-                        activation=SnakeBeta(channels, alpha_logscale=h.snake_logscale),
-                        causal=causal,
-                        fixed_filter=True,
-                    )
-                    for _ in range(self.num_layers)
-                ]
-            )
-        else:
-            raise NotImplementedError(
-                "activation incorrectly specified. check the config file and look for 'activation'."
-            )
-
-    def forward(self, x):
-        for c, a in zip(self.convs, self.activations, strict=True):
-            xt = a(x)
-            xt = c(xt)
-            x = xt + x
-
-        return x
-
-    def remove_weight_norm(self):
-        for layer in self.convs:
-            remove_weight_norm(layer)
-
-
-class Decoder(nn.Module):
-    def __init__(self, h):
-        super().__init__()
-        self.h = h
-        causal = h.causal
-        self._stream_window_sizes: dict[int, int] = {}
-
-        self.num_kernels = len(h.resblock_kernel_sizes)
-        self.num_upsamples = len(h.upsample_rates)
-
-        num_decoder_lookahead = h.get("num_decoder_lookahead", 2)
-        # pre conv
-        self.conv_pre = weight_norm(
-            Conv1d(
-                h.latent_dim,
-                h.upsample_initial_channel,
-                kernel_size=2 * num_decoder_lookahead + 1,
-                stride=1,
-                causal=False,
-            )
-        )
-
-        # define which AMPBlock to use. BigVGAN uses AMPBlock1 as default
-        resblock = AMPBlock1 if h.resblock == "1" else AMPBlock2
-
-        # transposed conv-based upsamplers. does not apply anti-aliasing
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(h.upsample_rates, h.upsample_kernel_sizes, strict=True)):
-            self.ups.append(
-                nn.ModuleList(
-                    [
-                        weight_norm(
-                            ConvTranspose1d(
-                                h.upsample_initial_channel // (2**i),
-                                h.upsample_initial_channel // (2 ** (i + 1)),
-                                k,
-                                u,
-                                causal=causal,
-                            )
-                        )
-                    ]
-                )
-            )
-
-        # residual blocks using anti-aliased multi-periodicity composition modules (AMP)
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = h.upsample_initial_channel // (2 ** (i + 1))
-            for k, d in zip(h.resblock_kernel_sizes, h.resblock_dilation_sizes, strict=True):
-                self.resblocks.append(resblock(h, ch, k, d, activation=h.activation, causal=causal))
-
-        # post conv
-        if h.activation == "snake":  # periodic nonlinearity with snake function and anti-aliasing
-            activation_post = Snake(ch, alpha_logscale=h.snake_logscale)
-            self.activation_post = Activation1d(activation=activation_post, causal=causal, fixed_filter=False)
-        elif h.activation == "snakebeta":  # periodic nonlinearity with snakebeta function and anti-aliasing
-            activation_post = SnakeBeta(ch, alpha_logscale=h.snake_logscale)
-            self.activation_post = Activation1d(activation=activation_post, causal=causal, fixed_filter=False)
-        else:
-            raise NotImplementedError(
-                "activation incorrectly specified. check the config file and look for 'activation'."
-            )
-
-        self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, causal=causal, bias=h.get("use_bias_at_final", True)))
-
-        # weight initialization
-        for i in range(len(self.ups)):
-            self.ups[i].apply(init_weights)
-        self.conv_post.apply(init_weights)
-
-    def forward(self, z):
-        # pre conv
-        x = self.conv_pre(z)
-
-        for i in range(self.num_upsamples):
-            # upsampling
-            for i_up in range(len(self.ups[i])):
-                x = self.ups[i][i_up](x)
-            # AMP blocks
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-
-        # post conv
-        x = self.activation_post(x)
-        x = self.conv_post(x)
-        if self.h.get("use_tanh_at_final", True):
-            x = torch.tanh(x)
-        else:
-            x = torch.clamp(x, min=-1.0, max=1.0)  # Bound the output to [-1, 1]
-
-        return x
-
-    @property
-    def stream_lookahead(self) -> int:
-        return (self.conv_pre.kernel_size[0] - 1) // 2
-
-    @staticmethod
-    def _conv1d_left_context(layer) -> int:
-        dilation = layer.dilation[0] if isinstance(layer.dilation, tuple) else layer.dilation
-        kernel_size = layer.kernel_size[0] if isinstance(layer.kernel_size, tuple) else layer.kernel_size
-        if getattr(layer, "causal", False):
-            return dilation * (kernel_size - 1)
-        return layer.padding[0] if isinstance(layer.padding, tuple) else layer.padding
-
-    @staticmethod
-    def _convtranspose1d_left_context(layer) -> int:
-        stride = layer.stride[0] if isinstance(layer.stride, tuple) else layer.stride
-        kernel_size = layer.kernel_size[0] if isinstance(layer.kernel_size, tuple) else layer.kernel_size
-        if not getattr(layer, "causal", False):
-            raise NotImplementedError("Streaming only supports causal ConvTranspose1d.")
-        if kernel_size != 2 * stride:
-            raise ValueError(
-                "Streaming ConvTranspose1d expects kernel_size == 2 * stride, got "
-                f"kernel_size={kernel_size} stride={stride}."
-            )
-        return 1
-
-    @classmethod
-    def _activation_left_context(cls, activation: Activation1d) -> int:
-        upsample = activation.upsample
-        downsample = activation.downsample.lowpass
-        if not upsample.causal or not downsample.padding or downsample.pad_right != 0:
-            raise NotImplementedError("Streaming only supports causal alias-free activations.")
-        ratio = int(upsample.ratio)
-        if ratio != int(downsample.stride):
-            raise ValueError(
-                "Alias-free activation expects matched up/down ratios, got "
-                f"up_ratio={ratio} down_ratio={downsample.stride}."
-            )
-        total_left = (upsample.kernel_size - 1) + (downsample.kernel_size - 1)
-        return (total_left + ratio - 1) // ratio
-
-    @classmethod
-    def _ampblock_left_context(cls, block) -> int:
-        if isinstance(block, AMPBlock1):
-            left_context = 0
-            acts1 = block.activations[::2]
-            acts2 = block.activations[1::2]
-            for conv1, conv2, act1, act2 in zip(
-                block.convs1,
-                block.convs2,
-                acts1,
-                acts2,
-                strict=True,
-            ):
-                left_context += (
-                    cls._activation_left_context(act1)
-                    + cls._conv1d_left_context(conv1)
-                    + cls._activation_left_context(act2)
-                    + cls._conv1d_left_context(conv2)
-                )
-            return left_context
-        if isinstance(block, AMPBlock2):
-            left_context = 0
-            for conv, activation in zip(block.convs, block.activations, strict=True):
-                left_context += cls._activation_left_context(activation) + cls._conv1d_left_context(conv)
-            return left_context
-        raise TypeError(f"Unsupported resblock type: {type(block).__name__}.")
-
-    def _stream_left_context(self) -> int:
-        left_context = Fraction(self._conv1d_left_context(self.conv_pre), 1)
-        current_scale = Fraction(1, 1)
-        for stage_idx, upsample_layers in enumerate(self.ups):
-            for upsample in upsample_layers:
-                left_context += current_scale * self._convtranspose1d_left_context(upsample)
-                stride = upsample.stride[0] if isinstance(upsample.stride, tuple) else upsample.stride
-                current_scale /= int(stride)
-
-            stage_start = stage_idx * self.num_kernels
-            stage_end = stage_start + self.num_kernels
-            stage_context = max(self._ampblock_left_context(block) for block in self.resblocks[stage_start:stage_end])
-            left_context += current_scale * stage_context
-
-        left_context += current_scale * self._activation_left_context(self.activation_post)
-        left_context += current_scale * self._conv1d_left_context(self.conv_post)
-        return int(left_context.__ceil__())
-
-    def stream_window_size(self, chunk_size: int) -> int:
-        if chunk_size < 1:
-            raise ValueError(f"chunk_size must be >= 1, got {chunk_size}.")
-        cached = self._stream_window_sizes.get(chunk_size)
-        if cached is not None:
-            return cached
-
-        window_size = chunk_size + self.stream_lookahead + self._stream_left_context()
-        self._stream_window_sizes[chunk_size] = window_size
-        return window_size
-
-    def remove_weight_norm(self):
-        for upsample_layers in self.ups:
-            for upsample_layer in upsample_layers:
-                remove_weight_norm(upsample_layer)
-        for resblock in self.resblocks:
-            resblock.remove_weight_norm()
-        remove_weight_norm(self.conv_pre)
-        remove_weight_norm(self.conv_post)
-
-
-class AudioVAE(nn.Module):
-    def __init__(self, h: AudioVAEConfig):
-        super().__init__()
-        self.config = h
-
-        self.h = h
-        self.hop_size = int(np.prod(h.downsample_rates))
-        self.sample_rate = h.sample_rate
-        self.decoder_lookahead = int(h.get("num_decoder_lookahead", 2))
-
-        self.audio_encoder = Encoder(
-            out_channels=h.latent_dim,
-            down_sample_factors=h.downsample_rates,
-            channels=h.downsample_channels,
-            causal=h.causal_encoder,
-            lookahead=h.get("num_encoder_lookahead", 2),
-        )
-
-        intermediate_size = h.latent_dim * 4
-        self.enc_mi_layer = nn.Sequential(
-            nn.Linear(h.latent_dim, intermediate_size),
-            SLSTM(intermediate_size, num_layers=h.mi_num_layers),
-            nn.Linear(intermediate_size, h.latent_dim),
-        )
-        self.dec_mi_layer = nn.Sequential(
-            nn.Linear(h.latent_dim, intermediate_size),
-            SLSTM(intermediate_size, num_layers=h.mi_num_layers),
-            nn.Linear(intermediate_size, h.latent_dim),
-        )
-        self.pre_proj = Conv1d(
-            in_channels=h.latent_dim,
-            out_channels=h.latent_dim * 2,
-            kernel_size=1,
-            stride=1,
-        )
-        self.post_proj = Conv1d(in_channels=h.latent_dim, out_channels=h.latent_dim, kernel_size=1, stride=1)
-
-        self.decoder = Decoder(h)
-
-    def inference(self, data):
-        latents = self.extract_latents(data["sample"])
-        return {"sample": self.inference_from_latents(latents)}
-
-    @torch.autocast(enabled=False, device_type="cuda")
-    def extract_latents(self, x, do_sample=False):
-        x = x.float()
-        x = self.audio_encoder(x)
-        x = x.permute(0, 2, 1)
-        x = self.enc_mi_layer(x)
-        x = x.permute(0, 2, 1)
-        x = self.pre_proj(x)
-        if do_sample:
-            m_q, logs_q = torch.split(x, self.h.latent_dim, dim=1)
-            x = m_q + torch.randn_like(m_q) * torch.exp(logs_q)
-        return x
-
-    def inference_from_latents(self, x, do_sample=True, noise_scale=1.0):
-        if do_sample:
-            assert x.size(1) == self.h.latent_dim * 2, f"Input must be like [B, D, H], got {x.shape}"
-            m_q, logs_q = torch.split(x, self.h.latent_dim, dim=1)
-            x = m_q + torch.randn_like(m_q) * torch.exp(logs_q) * noise_scale
-        else:
-            assert x.size(1) == self.h.latent_dim, f"Input must be like [B, D, H], got {x.shape}"
-        x = self.post_proj(x)
-        x = x.permute(0, 2, 1)
-        x = self.dec_mi_layer(x)
-        x = x.permute(0, 2, 1)
-        return self.decoder(x)
-
-    def _validate_stream_latents(self, latents: torch.Tensor) -> None:
-        if latents.ndim != 3:
-            raise ValueError(
-                f"Streaming latents must have shape [batch, latent_dim, frames], got {tuple(latents.shape)}."
-            )
-        if latents.size(1) != self.h.latent_dim:
-            raise ValueError(f"Streaming latent_dim must be {self.h.latent_dim}, got {latents.size(1)}.")
-
-    def init_stream_state(
-        self,
-        batch_size: int = 1,
-        chunk_size: int = 8,
-    ) -> BigVGANStreamState:
-        if not self.h.causal:
-            raise RuntimeError("Strict streaming requires a causal vocoder.")
-        if batch_size < 1:
-            raise ValueError(f"batch_size must be >= 1, got {batch_size}.")
-        window_size = self.decoder.stream_window_size(chunk_size)
-        device, dtype = _module_state_device_dtype(self.decoder.conv_pre)
-        return BigVGANStreamState(
-            lstm_hidden=self.dec_mi_layer[1].init_stream_state(batch_size),
-            decoder=DecoderStreamState(
-                window=_stream_state_zeros(
-                    batch_size,
-                    self.h.latent_dim,
-                    window_size,
-                    device=device,
-                    dtype=dtype,
-                ),
-                chunk_size=int(chunk_size),
-            ),
-        )
-
-    def _decode_stream_latents(
-        self,
-        latents: torch.Tensor,
-        lstm_hidden: tuple[torch.Tensor, torch.Tensor],
-    ) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
-        self._validate_stream_latents(latents)
-        latents = latents.float()
-        x = self.post_proj(latents)
-        x = x.permute(0, 2, 1)
-        x = self.dec_mi_layer[0](x)
-        x, lstm_hidden = self.dec_mi_layer[1].stream_step(x, lstm_hidden)
-        x = self.dec_mi_layer[2](x)
-        decoder_dtype = self.decoder.conv_pre.weight.dtype
-        return x.permute(0, 2, 1).to(dtype=decoder_dtype), lstm_hidden
-
-    def _prepare_stream_decoder_input(
-        self,
-        latents: torch.Tensor,
-        state: BigVGANStreamState,
-    ) -> torch.Tensor:
-        decoder_input, state.lstm_hidden = self._decode_stream_latents(
-            latents,
-            state.lstm_hidden,
-        )
-        return decoder_input
-
-    def _append_stream_decoder_input_tensor(
-        self,
-        decoder_input: torch.Tensor,
-        window: torch.Tensor,
-        valid_frames: torch.Tensor,
-    ) -> torch.Tensor:
-        if window.dtype != decoder_input.dtype:
-            window = window.to(dtype=decoder_input.dtype)
-        chunk_size = int(decoder_input.size(-1))
-        if chunk_size >= window.size(-1):
-            raise ValueError(f"decoder window size {window.size(-1)} must be larger than chunk_size {chunk_size}.")
-        positions = torch.arange(
-            window.size(-1),
-            device=window.device,
-            dtype=valid_frames.dtype,
-        )
-        clipped_valid = valid_frames.clamp(min=0, max=window.size(-1))
-        combined = torch.cat(
-            [window, decoder_input.new_zeros(window.size(0), window.size(1), chunk_size)],
-            dim=-1,
-        )
-        insert_index = clipped_valid + torch.arange(
-            chunk_size,
-            device=window.device,
-            dtype=valid_frames.dtype,
-        )
-        combined.scatter_(
-            -1,
-            insert_index.view(1, 1, -1).expand_as(decoder_input),
-            decoder_input,
-        )
-        new_valid = (clipped_valid + chunk_size).clamp(max=window.size(-1))
-        start = (clipped_valid + chunk_size - window.size(-1)).clamp(min=0)
-        gather_index = (start + positions).clamp(max=combined.size(-1) - 1)
-        gathered = combined.gather(
-            -1,
-            gather_index.view(1, 1, -1).expand_as(window),
-        )
-        mask = (positions < new_valid).to(dtype=window.dtype).view(1, 1, -1)
-        return gathered * mask
-
-    def _append_stream_decoder_input(
-        self,
-        decoder_input: torch.Tensor,
-        state: BigVGANStreamState,
-    ) -> torch.Tensor:
-        decoder_state = state.decoder
-        chunk_size = int(decoder_input.size(-1))
-        if chunk_size != decoder_state.chunk_size:
-            raise ValueError(f"Streaming chunk_size must stay fixed at {decoder_state.chunk_size}, got {chunk_size}.")
-        window = decoder_state.window
-        valid_frames = min(decoder_state.total_frames, window.size(-1))
-        valid_frames_tensor = window.new_tensor(valid_frames, dtype=torch.int64)
-        new_window = self._append_stream_decoder_input_tensor(
-            decoder_input,
-            window,
-            valid_frames_tensor,
-        )
-        decoder_state.window = new_window
-        decoder_state.total_frames += chunk_size
-        return new_window
-
-    def compiled_stream_step(
-        self,
-        latents: torch.Tensor,
-        hidden_h: torch.Tensor,
-        hidden_c: torch.Tensor,
-        window: torch.Tensor,
-        valid_frames: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-        decoder_input, (hidden_h, hidden_c) = self._decode_stream_latents(
-            latents,
-            (hidden_h, hidden_c),
-        )
-        new_window = self._append_stream_decoder_input_tensor(
-            decoder_input,
-            window,
-            valid_frames,
-        )
-        audio_window = self.decode_stream_window(new_window)
-        return audio_window, hidden_h, hidden_c, new_window
-
-    def decode_stream_window(self, window: torch.Tensor) -> torch.Tensor:
-        decoder_dtype = self.decoder.conv_pre.weight.dtype
-        if window.dtype != decoder_dtype:
-            window = window.to(dtype=decoder_dtype)
-        return self.decoder(window)
-
-    def _slice_stream_audio_window(
-        self,
-        audio_window: torch.Tensor,
-        state: BigVGANStreamState,
-        *,
-        final: bool,
-    ) -> torch.Tensor:
-        decoder_state = state.decoder
-        stable_end = (
-            decoder_state.total_frames if final else max(0, decoder_state.total_frames - self.decoder.stream_lookahead)
-        )
-        if stable_end <= decoder_state.emitted_frames:
-            return _empty_chunk(audio_window, channels=1)
-
-        window_size = decoder_state.window.size(-1)
-        valid_frames = min(decoder_state.total_frames, window_size)
-        window_start = decoder_state.total_frames - valid_frames
-        if decoder_state.emitted_frames < window_start:
-            raise RuntimeError("Decoder stream window is too short for fixed-graph decoding.")
-
-        local_start = decoder_state.emitted_frames - window_start
-        local_end = stable_end - window_start
-        sample_start = local_start * self.hop_size
-        sample_end = local_end * self.hop_size
-        decoder_state.emitted_frames = stable_end
-        return audio_window[..., sample_start:sample_end]
-
-    def stream_step(
-        self,
-        latents: torch.Tensor,
-        state: BigVGANStreamState,
-    ) -> torch.Tensor:
-        decoder_input = self._prepare_stream_decoder_input(latents, state)
-        window = self._append_stream_decoder_input(decoder_input, state)
-        audio_window = self.decode_stream_window(window)
-        return self._slice_stream_audio_window(audio_window, state, final=False)
-
-    def stream_flush(self, state: BigVGANStreamState) -> torch.Tensor:
-        audio_window = self.decode_stream_window(state.decoder.window)
-        return self._slice_stream_audio_window(audio_window, state, final=True)
-
-    def remove_weight_norm(self):
-        self.decoder.remove_weight_norm()
-
-
-__all__ = ["AudioVAEConfig", "AudioVAE"]
diff --git a/vllm_omni/model_executor/models/dots_tts/pipeline.py b/vllm_omni/model_executor/models/dots_tts/pipeline.py
deleted file mode 100644
index 22b50c629..000000000
--- a/vllm_omni/model_executor/models/dots_tts/pipeline.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""dots.tts pipeline topology (frozen).
-
-Single-stage AR TTS: text → 48 kHz waveform in one pass.
-Architecture: Qwen2.5-1.5B base LM (vLLM-native) → DiTAR / MeanFlow head
-→ AudioVAE.decode → BigVGAN → 48 kHz mono.
-
-Speaker conditioning via CAM++ x-vector injected in preprocess().
-
-Modeled after voxcpm2's single-stage pipeline (same "vLLM-native base LM
-+ side-path computation" pattern), but simplified: no residual LM, no FSQ.
-"""
-
-from vllm_omni.config.stage_config import (
-    PipelineConfig,
-    StageExecutionType,
-    StagePipelineConfig,
-)
-
-DOTS_TTS_PIPELINE = PipelineConfig(
-    model_type="dots_tts",
-    model_arch="DotsTTSForConditionalGeneration",
-    default_deploy_config_name="dots_tts.yaml",
-    stages=(
-        StagePipelineConfig(
-            stage_id=0,
-            model_stage="latent_generator",
-            execution_type=StageExecutionType.LLM_AR,
-            input_sources=(),
-            final_output=True,
-            final_output_type="audio",
-            owns_tokenizer=True,
-            engine_output_type="audio",
-            sampling_constraints={
-                "detokenize": False,
-                # Stop signal slot in compute_logits (voxcpm2 convention —
-                # talker emits logits[i, 1] = 1.0 when prob_stop > 0.8, vLLM
-                # matches against this list to terminate the request).  Not
-                # Qwen2.5 EOS (151643) — that ID would never come out of the
-                # 2-slot continue/stop softmax our compute_logits builds.
-                "stop_token_ids": [1],
-            },
-        ),
-    ),
-)
diff --git a/vllm_omni/model_executor/models/dynin_omni/__init__.py b/vllm_omni/model_executor/models/dynin_omni/__init__.py
deleted file mode 100644
index fb6738a29..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-# NOTE: Do not import model classes in this file. Importing any
-# submodule in this package triggers __init__.py execution, and
-# both the model registry and pipeline registry import submodules
-# directly — heavy imports here would be loaded as a side effect
-# even though nothing depends on these re-exports.
diff --git a/vllm_omni/model_executor/models/dynin_omni/dynin_omni.py b/vllm_omni/model_executor/models/dynin_omni/dynin_omni.py
deleted file mode 100644
index 9b8baac7d..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/dynin_omni.py
+++ /dev/null
@@ -1,747 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable, Mapping, Sequence
-from functools import cached_property
-from importlib import import_module
-from typing import Any
-
-import numpy as np
-import torch
-import torch.nn as nn
-from vllm.config import VllmConfig
-from vllm.config.multimodal import BaseDummyOptions
-from vllm.inputs import MultiModalDataDict
-from vllm.inputs import MultiModalInput as MultiModalInputs
-from vllm.model_executor.models.interfaces import SupportsMultiModal
-from vllm.multimodal import MULTIMODAL_REGISTRY
-from vllm.multimodal.inputs import (
-    MultiModalFieldConfig,
-    MultiModalKwargsItems,
-    PlaceholderRange,
-)
-from vllm.multimodal.parse import MultiModalDataItems, MultiModalDataParser
-from vllm.multimodal.processing import (
-    BaseDummyInputsBuilder,
-    BaseMultiModalProcessor,
-    BaseProcessingInfo,
-    ProcessorInputs,
-    PromptUpdate,
-    TimingContext,
-)
-from vllm.sequence import IntermediateTensors
-from vllm.v1.outputs import SamplerOutput
-from vllm.v1.sample.metadata import SamplingMetadata
-from vllm.v1.sample.sampler import Sampler
-
-from vllm_omni.model_executor.models.output_templates import OmniOutput
-
-from .dynin_omni_common import build_zero_input_embeddings
-
-try:
-    from PIL import Image as PILImage
-except Exception:  # pragma: no cover
-    PILImage = None
-
-
-_MODALITY_ORDER = ("image", "video", "audio")
-
-_MODALITY_ALIASES = {
-    "img2img": "image",
-}
-
-_MODALITY_INPUT_KEY_BY_NAME = {
-    "image": "pixel_values",
-    "video": "pixel_values_videos",
-    "audio": "input_audio_features",
-}
-
-_MODALITY_PLACEHOLDER_BY_NAME = {
-    "image": "<|soi|><|image|><|eoi|>",
-    "video": "<|sov|><|video|><|eov|>",
-    "audio": "<|soa|><|audio|><|eoa|>",
-}
-
-_MODALITY_INPUT_ALIASES = {
-    "image": ("pixel_values", "image_embeds", "img2img"),
-    "video": ("pixel_values_videos", "video_embeds"),
-    "audio": ("input_audio_features", "audio_embeds"),
-}
-
-
-def _normalize_modality_name(modality: str) -> str:
-    return _MODALITY_ALIASES.get(modality, modality)
-
-
-def _get_modality_count(mm_counts: Mapping[str, int], modality: str) -> int:
-    canonical = _normalize_modality_name(modality)
-    count = mm_counts.get(canonical, 0)
-    for alias, target in _MODALITY_ALIASES.items():
-        if target == canonical:
-            count += mm_counts.get(alias, 0)
-    return count
-
-
-def _normalize_mm_data_aliases(mm_data: MultiModalDataDict) -> MultiModalDataDict:
-    normalized: dict[str, Any] = {}
-    for modality, value in mm_data.items():
-        canonical = _normalize_modality_name(modality)
-        if canonical in normalized and normalized[canonical] is not None and value is not None:
-            raise ValueError(
-                "Dynin received duplicate multimodal inputs for "
-                f"{canonical!r} via {modality!r}. "
-                "Provide either the canonical modality or its alias, not both."
-            )
-        if canonical not in normalized or normalized[canonical] is None:
-            normalized[canonical] = value
-    return normalized
-
-
-def _get_placeholder_text(modality: str) -> str | None:
-    modality = _normalize_modality_name(modality)
-    for base_modality, placeholder in _MODALITY_PLACEHOLDER_BY_NAME.items():
-        if modality.startswith(base_modality):
-            return placeholder
-    return None
-
-
-class DyninOmniProcessingInfo(BaseProcessingInfo):
-    def get_data_parser(self) -> MultiModalDataParser:
-        return DyninOmniMultiModalDataParser(
-            expected_hidden_size=self._get_expected_hidden_size(),
-        )
-
-    def get_supported_mm_limits(self) -> Mapping[str, int | None]:
-        limits = {modality: 1 for modality in _MODALITY_ORDER}
-        for alias, target in _MODALITY_ALIASES.items():
-            if target in limits:
-                limits[alias] = limits[target]
-        return limits
-
-    def get_mm_max_tokens_per_item(
-        self,
-        seq_len: int,
-        mm_counts: Mapping[str, int],
-    ) -> Mapping[str, int] | None:
-        del seq_len, mm_counts
-        limits = {modality: 1 for modality in _MODALITY_ORDER}
-        for alias, target in _MODALITY_ALIASES.items():
-            if target in limits:
-                limits[alias] = limits[target]
-        return limits
-
-
-class DyninOmniDummyInputsBuilder(BaseDummyInputsBuilder[DyninOmniProcessingInfo]):
-    def get_dummy_text(self, mm_counts: Mapping[str, int]) -> str:
-        chunks: list[str] = []
-        for modality in _MODALITY_ORDER:
-            placeholder = _get_placeholder_text(modality)
-            if placeholder is None:
-                continue
-            chunks.extend([placeholder] * _get_modality_count(mm_counts, modality))
-        return " ".join(chunks)
-
-    def get_dummy_mm_data(
-        self,
-        seq_len: int,
-        mm_counts: Mapping[str, int],
-        mm_options: Mapping[str, BaseDummyOptions] | None = None,
-    ) -> MultiModalDataDict:
-        del seq_len
-
-        mm_data: dict[str, Any] = {}
-
-        num_images = _get_modality_count(mm_counts, "image")
-        if num_images > 0:
-            mm_data["image"] = self._get_dummy_images(
-                width=224,
-                height=224,
-                num_images=num_images,
-                overrides=mm_options.get("image") if mm_options else None,
-            )
-
-        num_videos = _get_modality_count(mm_counts, "video")
-        if num_videos > 0:
-            mm_data["video"] = self._get_dummy_videos(
-                width=224,
-                height=224,
-                num_frames=8,
-                num_videos=num_videos,
-                overrides=mm_options.get("video") if mm_options else None,
-            )
-
-        num_audios = _get_modality_count(mm_counts, "audio")
-        if num_audios > 0:
-            mm_data["audio"] = self._get_dummy_audios(
-                length=16000,
-                num_audios=num_audios,
-                overrides=mm_options.get("audio") if mm_options else None,
-            )
-
-        return mm_data
-
-
-class DyninOmniMultiModalDataParser(MultiModalDataParser):
-    def parse_mm_data(self, mm_data: MultiModalDataDict) -> MultiModalDataItems:
-        normalized = _normalize_mm_data_aliases(mm_data)
-        mm_items = super().parse_mm_data(normalized)
-
-        for alias, canonical in _MODALITY_ALIASES.items():
-            if alias in mm_data and canonical in mm_items and alias not in mm_items:
-                mm_items[alias] = mm_items[canonical]
-
-        return mm_items
-
-    def _get_audio_with_sr(self, audio: Any) -> tuple[np.ndarray, float | None]:
-        audio_array, orig_sr = super()._get_audio_with_sr(audio)
-        if self.audio_resampler.target_sr is None:
-            return audio_array, None
-        return audio_array, orig_sr
-
-
-class DyninOmniMultiModalProcessor(BaseMultiModalProcessor[DyninOmniProcessingInfo]):
-    @staticmethod
-    def _find_subsequence(
-        haystack: list[int],
-        needle: list[int],
-        start: int,
-    ) -> int | None:
-        if not needle:
-            return None
-
-        max_start = len(haystack) - len(needle)
-        if max_start < start:
-            return None
-
-        for idx in range(start, max_start + 1):
-            if haystack[idx : idx + len(needle)] == needle:
-                return idx
-        return None
-
-    @staticmethod
-    def _make_disabled_embed_mask(length: int) -> torch.Tensor:
-        return torch.zeros(length, dtype=torch.bool)
-
-    @staticmethod
-    def _encode_prompt_to_token_ids(
-        prompt: str | list[int],
-        tokenizer: Any | None,
-    ) -> list[int]:
-        if isinstance(prompt, str):
-            if tokenizer is None:
-                raise ValueError("Tokenizer is required to process string prompts for Dynin multimodal inputs.")
-            return tokenizer.encode(prompt, add_special_tokens=False)
-        return list(prompt)
-
-    @staticmethod
-    def _ensure_non_empty_prompt_ids(
-        prompt_token_ids: list[int],
-        tokenizer: Any | None,
-    ) -> list[int]:
-        if prompt_token_ids:
-            return prompt_token_ids
-
-        fallback_id = None
-        if tokenizer is not None:
-            fallback_id = getattr(tokenizer, "bos_token_id", None)
-            if fallback_id is None:
-                fallback_id = getattr(tokenizer, "eos_token_id", None)
-            if fallback_id is None:
-                fallback_id = getattr(tokenizer, "pad_token_id", None)
-
-        return [0 if fallback_id is None else int(fallback_id)]
-
-    @classmethod
-    def _image_to_chw_float_tensor(cls, image: Any) -> torch.Tensor:
-        if isinstance(image, torch.Tensor):
-            tensor = image.detach()
-        elif isinstance(image, np.ndarray):
-            tensor = torch.from_numpy(image)
-        elif PILImage is not None and isinstance(image, PILImage.Image):
-            tensor = torch.from_numpy(np.asarray(image).copy())
-        else:
-            raise TypeError(f"Unsupported image item type: {type(image)!r}")
-
-        if tensor.ndim == 2:
-            tensor = tensor.unsqueeze(-1)
-        if tensor.ndim != 3:
-            raise ValueError(f"Expected 3D image tensor, got shape={tuple(tensor.shape)}")
-
-        if tensor.shape[-1] in (1, 3, 4) and tensor.shape[0] not in (1, 3, 4):
-            tensor = tensor.permute(2, 0, 1)
-
-        if tensor.shape[0] == 1:
-            tensor = tensor.repeat(3, 1, 1)
-        if tensor.shape[0] == 4:
-            tensor = tensor[:3]
-
-        tensor = tensor.to(dtype=torch.float32)
-        if tensor.numel() > 0 and torch.max(tensor) > 1.0:
-            tensor = tensor / 255.0
-        return tensor.contiguous()
-
-    @classmethod
-    def _video_to_tchw_float_tensor(cls, video: Any) -> torch.Tensor:
-        if isinstance(video, (list, tuple)) and not isinstance(video, torch.Tensor):
-            frames = [cls._image_to_chw_float_tensor(frame) for frame in video]
-            if not frames:
-                return torch.zeros((1, 3, 1, 1), dtype=torch.float32)
-            return torch.stack(frames, dim=0).contiguous()
-
-        if isinstance(video, torch.Tensor):
-            tensor = video.detach()
-        elif isinstance(video, np.ndarray):
-            tensor = torch.from_numpy(video)
-        else:
-            raise TypeError(f"Unsupported video item type: {type(video)!r}")
-
-        if tensor.ndim == 3:
-            return cls._image_to_chw_float_tensor(tensor).unsqueeze(0).contiguous()
-
-        if tensor.ndim != 4:
-            raise ValueError(f"Expected 4D video tensor, got shape={tuple(tensor.shape)}")
-
-        if tensor.shape[-1] in (1, 3, 4) and tensor.shape[1] not in (1, 3, 4):
-            tensor = tensor.permute(0, 3, 1, 2)
-
-        if tensor.shape[1] == 1:
-            tensor = tensor.repeat(1, 3, 1, 1)
-        if tensor.shape[1] == 4:
-            tensor = tensor[:, :3]
-
-        tensor = tensor.to(dtype=torch.float32)
-        if tensor.numel() > 0 and torch.max(tensor) > 1.0:
-            tensor = tensor / 255.0
-        return tensor.contiguous()
-
-    @staticmethod
-    def _audio_to_float_tensor(audio: Any) -> torch.Tensor:
-        if isinstance(audio, tuple) and len(audio) == 2:
-            audio = audio[0]
-
-        if isinstance(audio, torch.Tensor):
-            tensor = audio.detach()
-        elif isinstance(audio, np.ndarray):
-            tensor = torch.from_numpy(audio)
-        else:
-            tensor = torch.as_tensor(audio)
-
-        tensor = tensor.to(dtype=torch.float32).contiguous().view(-1)
-        if tensor.numel() == 0:
-            return torch.zeros((16000,), dtype=torch.float32)
-
-        max_abs = torch.max(torch.abs(tensor))
-        if max_abs > 1.0:
-            tensor = tensor / max_abs
-
-        return tensor.contiguous()
-
-    @classmethod
-    def _convert_modality_item(cls, modality: str, item: Any) -> torch.Tensor:
-        if modality == "image":
-            return cls._image_to_chw_float_tensor(item)
-        if modality == "video":
-            return cls._video_to_tchw_float_tensor(item)
-        if modality == "audio":
-            return cls._audio_to_float_tensor(item)
-        raise ValueError(f"Unsupported modality for Dynin processor: {modality}")
-
-    def _build_modality_kwargs(
-        self,
-        modality: str,
-        modality_items: Sequence[Any],
-    ) -> Sequence[Any]:
-        modality = _normalize_modality_name(modality)
-        input_key = _MODALITY_INPUT_KEY_BY_NAME[modality]
-        tensor_items = [self._convert_modality_item(modality, item) for item in modality_items]
-        mm_kwargs = MultiModalKwargsItems.from_hf_inputs(
-            {input_key: tensor_items},
-            {input_key: MultiModalFieldConfig.batched(modality)},
-        )
-        return mm_kwargs[modality]
-
-    def _build_placeholder_ranges(
-        self,
-        *,
-        modality: str,
-        item_count: int,
-        prompt_token_ids: list[int],
-        tokenizer: Any | None,
-        search_start: int,
-    ) -> tuple[list[PlaceholderRange], int]:
-        ranges: list[PlaceholderRange] = []
-
-        for _ in range(item_count):
-            placeholder_text = _get_placeholder_text(modality)
-            placeholder_token_ids: list[int] = []
-
-            if placeholder_text and tokenizer is not None:
-                placeholder_token_ids = tokenizer.encode(
-                    placeholder_text,
-                    add_special_tokens=False,
-                )
-
-            found_offset = None
-            if placeholder_token_ids:
-                found_offset = self._find_subsequence(
-                    prompt_token_ids,
-                    placeholder_token_ids,
-                    search_start,
-                )
-
-            if found_offset is None:
-                found_offset = min(search_start, len(prompt_token_ids) - 1)
-                placeholder_len = 1
-            else:
-                placeholder_len = len(placeholder_token_ids)
-
-            ranges.append(
-                PlaceholderRange(
-                    offset=found_offset,
-                    length=placeholder_len,
-                    is_embed=self._make_disabled_embed_mask(placeholder_len),
-                )
-            )
-            search_start = found_offset + placeholder_len
-
-        return ranges, search_start
-
-    def _get_mm_fields_config(
-        self,
-        hf_inputs: Any,
-        hf_processor_mm_kwargs: Mapping[str, object],
-    ) -> Mapping[str, MultiModalFieldConfig]:
-        del hf_inputs, hf_processor_mm_kwargs
-        return {}
-
-    def _get_prompt_updates(
-        self,
-        mm_items: MultiModalDataItems,
-        hf_processor_mm_kwargs: Mapping[str, object],
-        out_mm_kwargs: MultiModalKwargsItems,
-    ) -> Sequence[PromptUpdate]:
-        del mm_items, hf_processor_mm_kwargs, out_mm_kwargs
-        return []
-
-    def apply(
-        self,
-        inputs: ProcessorInputs,
-        timing_ctx: TimingContext,
-    ) -> MultiModalInputs:
-        prompt = inputs.prompt
-        mm_items = inputs.mm_data_items
-
-        with timing_ctx.record("get_mm_hashes"):
-            mm_hashes = inputs.get_mm_hashes(
-                self.info.model_id,
-                self.info.ctx.get_mm_config().mm_hasher_algorithm,
-            )
-
-        tokenizer = self.info.ctx.tokenizer
-        prompt_token_ids = self._encode_prompt_to_token_ids(prompt, tokenizer)
-        prompt_token_ids = self._ensure_non_empty_prompt_ids(prompt_token_ids, tokenizer)
-
-        mm_kwargs_by_modality: dict[str, Sequence[Any]] = {}
-        mm_placeholders: dict[str, list[PlaceholderRange]] = {}
-        search_start = 0
-        mm_counts = mm_items.get_all_counts()
-
-        for modality in _MODALITY_ORDER:
-            item_count = mm_counts.get(modality, 0)
-            if item_count <= 0:
-                continue
-
-            modality_items = mm_items[modality].get_all()
-            if len(modality_items) != item_count:
-                raise RuntimeError(
-                    f"Parsed {len(modality_items)} items but expected {item_count} for modality={modality!r}"
-                )
-
-            mm_kwargs_by_modality[modality] = self._build_modality_kwargs(
-                modality,
-                modality_items,
-            )
-
-            placeholder_ranges, search_start = self._build_placeholder_ranges(
-                modality=modality,
-                item_count=item_count,
-                prompt_token_ids=prompt_token_ids,
-                tokenizer=tokenizer,
-                search_start=search_start,
-            )
-            mm_placeholders[modality] = placeholder_ranges
-
-        return MultiModalInputs(
-            type="multimodal",
-            prompt_token_ids=prompt_token_ids,
-            mm_kwargs=MultiModalKwargsItems(mm_kwargs_by_modality),
-            mm_hashes=mm_hashes,
-            mm_placeholders=mm_placeholders,
-        )
-
-
-class DyninOmniStageBase(nn.Module):
-    stage_name = "Dynin stage"
-
-    def make_empty_intermediate_tensors(
-        self,
-        batch_size: int,
-        dtype: torch.dtype,
-        device: torch.device,
-    ) -> IntermediateTensors:
-        del batch_size, dtype, device
-        return IntermediateTensors({})
-
-    def embed_input_ids(
-        self,
-        input_ids: torch.Tensor,
-        multimodal_embeddings: Any = None,
-        is_multimodal: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> torch.Tensor:
-        del multimodal_embeddings, is_multimodal, kwargs
-        return build_zero_input_embeddings(
-            input_ids=input_ids,
-            hidden_size=self.hidden_size,
-            stage_name=self.stage_name,
-        )
-
-    def load_weights(
-        self,
-        weights: Iterable[tuple[str, torch.Tensor]],
-    ) -> set[str]:
-        return {name for name, _ in weights}
-
-    def compute_logits(
-        self,
-        hidden_states: torch.Tensor | OmniOutput,
-        sampling_metadata: Any = None,
-    ) -> torch.Tensor | None:
-        del hidden_states, sampling_metadata
-        return None
-
-
-@MULTIMODAL_REGISTRY.register_processor(
-    DyninOmniMultiModalProcessor,
-    info=DyninOmniProcessingInfo,
-    dummy_inputs=DyninOmniDummyInputsBuilder,
-)
-class DyninOmniForConditionalGeneration(nn.Module, SupportsMultiModal):
-    supports_multimodal_raw_input_only = True
-    STAGE_ALIAS = {
-        "tokenizer": "token2text",
-        "token2token": "token2text",
-        "detok_text": "token2text",
-        "token2img": "token2image",
-        "token2wav": "token2audio",
-        "token2speech": "token2audio",
-    }
-
-    STAGE_IMPL = {
-        "token2text": (".dynin_omni_token2text", "DyninOmniToken2Text"),
-        "token2image": (".dynin_omni_token2image", "DyninOmniToken2Image"),
-        "token2audio": (".dynin_omni_token2audio", "DyninOmniToken2Audio"),
-    }
-
-    _STAGE_IMPL_CACHE: dict[str, type[nn.Module]] = {}
-
-    @classmethod
-    def get_placeholder_str(cls, modality: str, i: int) -> str | None:
-        del i
-        return _get_placeholder_text(modality)
-
-    @classmethod
-    def _resolve_stage_impl_class(cls, model_stage: str) -> type[nn.Module]:
-        impl = cls._STAGE_IMPL_CACHE.get(model_stage)
-        if impl is not None:
-            return impl
-
-        module_name, class_name = cls.STAGE_IMPL[model_stage]
-        module = import_module(module_name, package=__package__)
-        impl = getattr(module, class_name)
-        cls._STAGE_IMPL_CACHE[model_stage] = impl
-        return impl
-
-    @classmethod
-    def _normalize_stage_name(cls, raw_stage: str) -> str:
-        normalized = cls.STAGE_ALIAS.get(raw_stage, raw_stage)
-        if normalized not in cls.STAGE_IMPL:
-            raise ValueError(
-                "Unsupported DYNIN omni model_stage: "
-                f"{raw_stage} (normalized={normalized}). "
-                f"Supported: {sorted(cls.STAGE_IMPL.keys())}"
-            )
-        return normalized
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        super().__init__()
-
-        raw_stage = str(getattr(vllm_config.model_config, "model_stage", "token2text")).lower()
-        self.model_stage = self._normalize_stage_name(raw_stage)
-
-        impl_cls = self._resolve_stage_impl_class(self.model_stage)
-        self.impl = impl_cls(vllm_config=vllm_config, prefix=prefix)
-        self.model = self.impl
-
-        self.has_preprocess = False
-        self.has_postprocess = False
-        self.have_multimodal_outputs = getattr(self.impl, "have_multimodal_outputs", True)
-        self.requires_raw_input_tokens = getattr(self.impl, "requires_raw_input_tokens", True)
-        self.language_model = self._resolve_language_model()
-
-    def _resolve_language_model(self) -> Any | None:
-        if hasattr(self.impl, "get_language_model"):
-            language_model = self.impl.get_language_model()
-            if language_model is not None:
-                return language_model
-
-        if hasattr(self.impl, "language_model"):
-            language_model = getattr(self.impl, "language_model")
-            if language_model is not None:
-                return language_model
-
-        if self.model_stage == "token2text":
-            return getattr(self.impl, "model", None)
-
-        return None
-
-    def get_language_model(self) -> Any | None:
-        return self.language_model
-
-    @cached_property
-    def sampler(self):
-        if hasattr(self.model, "sampler"):
-            return self.model.sampler
-        if self.language_model is not None and hasattr(self.language_model, "sampler"):
-            return self.language_model.sampler
-        return Sampler()
-
-    def init_multi_modal(self, thinker_config: Any = None) -> None:
-        if hasattr(self.model, "init_multi_modal"):
-            self.model.init_multi_modal(thinker_config)
-
-    def _collect_multimodal_inputs(self, **kwargs: Any) -> dict[str, Any]:
-        mm_inputs: dict[str, Any] = {}
-        for modality, aliases in _MODALITY_INPUT_ALIASES.items():
-            for alias in aliases:
-                if alias in kwargs and kwargs[alias] is not None:
-                    mm_inputs[modality] = kwargs[alias]
-                    break
-        return mm_inputs
-
-    def _normalize_loaded_weight_names(
-        self,
-        loaded: set[str],
-        expected_param_names: set[str],
-    ) -> set[str]:
-        if self.model_stage != "token2text":
-            return loaded
-
-        normalized_loaded: set[str] = set()
-        prefixes = ("", "impl.", "impl.model.")
-
-        for name in loaded:
-            for prefix in prefixes:
-                candidate = f"{prefix}{name}" if prefix else name
-                if candidate in expected_param_names:
-                    normalized_loaded.add(candidate)
-                    break
-
-        if len(normalized_loaded) < len(expected_param_names):
-            normalized_loaded.update(expected_param_names)
-
-        return normalized_loaded
-
-    def forward(
-        self,
-        input_ids: torch.Tensor | None = None,
-        positions: torch.Tensor | None = None,
-        intermediate_tensors: IntermediateTensors | None = None,
-        inputs_embeds: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> OmniOutput:
-        return self.model(
-            input_ids=input_ids,
-            positions=positions,
-            intermediate_tensors=intermediate_tensors,
-            inputs_embeds=inputs_embeds,
-            **kwargs,
-        )
-
-    def make_empty_intermediate_tensors(
-        self,
-        batch_size: int,
-        dtype: torch.dtype,
-        device: torch.device,
-    ) -> IntermediateTensors:
-        return self.model.make_empty_intermediate_tensors(batch_size, dtype, device)
-
-    def embed_input_ids(
-        self,
-        input_ids: torch.Tensor,
-        multimodal_embeddings: Any = None,
-        is_multimodal: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> torch.Tensor:
-        squeezed_batch = False
-        staged_input_ids = input_ids
-
-        if input_ids.ndim == 0:
-            staged_input_ids = input_ids.view(1, 1)
-            squeezed_batch = True
-        elif input_ids.ndim == 1:
-            staged_input_ids = input_ids.unsqueeze(0)
-            squeezed_batch = True
-
-        embeddings = self.model.embed_input_ids(
-            staged_input_ids,
-            multimodal_embeddings=multimodal_embeddings,
-            is_multimodal=is_multimodal,
-            **kwargs,
-        )
-
-        if squeezed_batch and isinstance(embeddings, torch.Tensor):
-            if embeddings.ndim == 3 and embeddings.shape[0] == 1:
-                return embeddings.squeeze(0)
-            if embeddings.ndim == 2 and input_ids.ndim == 0 and embeddings.shape[0] == 1:
-                return embeddings
-
-        return embeddings
-
-    def embed_multimodal(self, **kwargs: Any) -> Any:
-        if hasattr(self.model, "embed_multimodal"):
-            return self.model.embed_multimodal(**kwargs)
-
-        self._collect_multimodal_inputs(**kwargs)
-        return None
-
-    def load_weights(
-        self,
-        weights: Iterable[tuple[str, torch.Tensor]],
-    ) -> set[str]:
-        loaded = self.model.load_weights(weights)
-        if loaded is None:
-            loaded = set()
-
-        expected_param_names = {name for name, _ in self.named_parameters()}
-        if not expected_param_names:
-            return loaded
-
-        return self._normalize_loaded_weight_names(loaded, expected_param_names)
-
-    def compute_logits(
-        self,
-        hidden_states: torch.Tensor | OmniOutput,
-        sampling_metadata: Any = None,
-    ) -> torch.Tensor | None:
-        return self.model.compute_logits(hidden_states, sampling_metadata=sampling_metadata)
-
-    def sample(
-        self,
-        logits: torch.Tensor,
-        sampling_metadata: SamplingMetadata,
-    ) -> SamplerOutput | None:
-        if hasattr(self.model, "sample"):
-            return self.model.sample(logits, sampling_metadata)
-        if self.language_model is not None and hasattr(self.language_model, "sample"):
-            return self.language_model.sample(logits, sampling_metadata)
-        return None
diff --git a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_common.py b/vllm_omni/model_executor/models/dynin_omni/dynin_omni_common.py
deleted file mode 100644
index 125822c1e..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_common.py
+++ /dev/null
@@ -1,1242 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import hashlib
-import importlib.util
-import os
-import sys
-import threading
-import types
-from collections.abc import Iterable
-from dataclasses import dataclass
-from enum import IntEnum
-from functools import lru_cache
-from pathlib import Path
-from typing import Any
-
-import torch
-from vllm.config import VllmConfig
-from vllm.logger import init_logger
-
-logger = init_logger(__name__)
-
-try:
-    from vllm_omni.transformers_utils.repo_utils import hf_api
-except Exception:  # pragma: no cover
-    hf_api = None
-
-
-class DetokTarget(IntEnum):
-    TEXT = 0
-    AUDIO = 1
-    IMAGE = 2
-
-
-TASK_TO_DETOK = {
-    "mmu": DetokTarget.TEXT,
-    "s2t": DetokTarget.TEXT,
-    "mmu_fast": DetokTarget.TEXT,
-    "mmu_fastdllm_v1": DetokTarget.TEXT,
-    "v2t": DetokTarget.TEXT,
-    "t2s": DetokTarget.AUDIO,
-    "t2s_mmu_like": DetokTarget.AUDIO,
-    "t2s_fixed": DetokTarget.AUDIO,
-    "s2s": DetokTarget.AUDIO,
-    "v2s": DetokTarget.AUDIO,
-    "t2i": DetokTarget.IMAGE,
-    "i2i": DetokTarget.IMAGE,
-    "ti2ti": DetokTarget.IMAGE,
-}
-
-DEFAULT_VQ_IMAGE_SOURCE = "snu-aidas/magvitv2"
-DEFAULT_VQ_AUDIO_SOURCE = "snu-aidas/emova_speech_tokenizer_vllm"
-DEFAULT_MAGVIT_REMOTE_CODE_REPO = "snu-aidas/magvitv2"
-DEFAULT_DYNIN_REMOTE_CODE_REPO = "snu-aidas/Dynin-Omni"
-DYNIN_PROMPT_SOURCE_KEY = "dynin_prompt_source"
-DYNIN_PROMPT_SOURCE_OFFLINE_PREBUILT = "offline_prebuilt"
-
-DYNIN_TASK_DEFAULT_RUNTIME = {
-    "t2t": ("mmu", "mmu", 0, "text"),
-    "t2i": ("t2i", "t2i_gen", 2, "image"),
-    "t2s": ("t2s_mmu_like", "t2s_gen", 1, "audio"),
-    "i2i": ("i2i", "i2i", 2, "image"),
-}
-
-DYNIN_TASK_RUNTIME_FALLBACKS: dict[str, dict[str, Any]] = {
-    "t2t": {
-        "prompt_max_text_len": 1024,
-        "max_new_tokens": 1024,
-        "steps": 1024,
-        "block_length": 16,
-        "temperature": 0.0,
-        "cfg_scale": 0.0,
-    },
-    "t2i": {
-        "prompt_max_text_len": 128,
-        "image_token_count": 1024,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "timesteps": 20,
-        "guidance_scale": 3.5,
-        "temperature": 1.0,
-    },
-    "i2i": {
-        "prompt_max_text_len": 128,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "timesteps": 64,
-        "guidance_scale": 3.5,
-        "temperature": 1.0,
-        "image_resolution": 336,
-        "use_train_i2i_prompt": True,
-    },
-    "t2s": {
-        "runtime_task": "t2s_mmu_like",
-        "prompting_task": "t2s_gen",
-        "prompt_max_text_len": 1024,
-        "t2s_token_length": 512,
-        "mask_token_id": 126336,
-        "codebook_size": 8192,
-        "audio_codebook_size": 4096,
-        "steps": 512,
-        "block_length": 128,
-        "temperature": 1.0,
-        "cfg_scale": 2.5,
-        "t2s_condition": "gender-female_emotion-neutral_speed-normal_pitch-normal",
-    },
-}
-
-DEFAULT_DYNIN_T2S_INSTRUCTION = "Please read the following text naturally."
-
-DYNIN_SPECIAL_TOKENS = (
-    "<|soi|>",
-    "<|eoi|>",
-    "<|sov|>",
-    "<|eov|>",
-    "<|t2i|>",
-    "<|mmu|>",
-    "<|t2v|>",
-    "<|v2v|>",
-    "<|lvg|>",
-    "<|i2i|>",
-    "<|ti2ti|>",
-    "<|v2t|>",
-    "<|v2s|>",
-    "<|s2t|>",
-    "<|t2s|>",
-    "<|s2s|>",
-    "<|soa|>",
-    "<|eoa|>",
-)
-
-_DYNIN_ONLINE_PROMPT_TOKEN_BY_TASK = {
-    "t2i": "<|t2i|>",
-    "i2i": "<|i2i|>",
-    "t2s": "<|t2s|>",
-}
-
-_DYNIN_MODALITY_PLACEHOLDERS = (
-    "<|soi|><|image|><|eoi|>",
-    "<|sov|><|video|><|eov|>",
-    "<|soa|><|audio|><|eoa|>",
-)
-
-_DYNIN_CONFIG_CANDIDATE_RELPATHS = (
-    "configs/dynin_omni.yaml",
-    "models/configs/dynin_omni.yaml",
-    "vllm_omni/model_executor/models/dynin_omni/configs/dynin_omni.yaml",
-    "dynin_omni.yaml",
-)
-
-_DYNIN_REMOTE_ALLOW_PATTERNS = ("*.py", "*.json", "*.yaml", "*.yml")
-
-_DYNIN_REMOTE_CACHE_LOCK = threading.Lock()
-_DYNIN_REMOTE_PACKAGE_BY_SNAPSHOT: dict[str, str] = {}
-_DYNIN_REMOTE_ATTR_CACHE: dict[tuple[str, str, str, str | None, bool], Any] = {}
-
-
-@dataclass(frozen=True)
-class DyninInferSources:
-    model_source: str
-    tokenizer_source: str
-    vq_image_source: str
-    vq_audio_source: str
-    model_local_files_only: bool
-    vq_image_local_files_only: bool
-    vq_audio_local_files_only: bool
-    config_path: str | None = None
-
-    @property
-    def local_files_only(self) -> bool:
-        return self.model_local_files_only
-
-
-@dataclass(frozen=True)
-class RemoteCodeSettings:
-    default_repo: str
-    repo_env: str
-    revision_env: str
-    local_only_env: str
-
-
-DYNIN_REMOTE_SETTINGS = RemoteCodeSettings(
-    default_repo=DEFAULT_DYNIN_REMOTE_CODE_REPO,
-    repo_env="DYNIN_REMOTE_CODE_REPO_ID",
-    revision_env="DYNIN_REMOTE_CODE_REVISION",
-    local_only_env="DYNIN_REMOTE_CODE_LOCAL_FILES_ONLY",
-)
-
-MAGVIT_REMOTE_SETTINGS = RemoteCodeSettings(
-    default_repo=DEFAULT_MAGVIT_REMOTE_CODE_REPO,
-    repo_env="DYNIN_MAGVIT_REMOTE_CODE_REPO_ID",
-    revision_env="DYNIN_MAGVIT_REMOTE_CODE_REVISION",
-    local_only_env="DYNIN_MAGVIT_REMOTE_CODE_LOCAL_FILES_ONLY",
-)
-
-
-def unwrap_first_value(value: Any, default: Any = None) -> Any:
-    if value is None:
-        return default
-    if isinstance(value, list):
-        return default if not value else value[0]
-    if isinstance(value, torch.Tensor):
-        if value.numel() == 0:
-            return default
-        if value.numel() == 1:
-            return value.item()
-        return value
-    return value
-
-
-def normalize_runtime_info(runtime_additional_information: Any) -> dict[str, Any]:
-    if isinstance(runtime_additional_information, list):
-        if not runtime_additional_information:
-            return {}
-        first = runtime_additional_information[0]
-        return first if isinstance(first, dict) else {}
-    if isinstance(runtime_additional_information, dict):
-        return runtime_additional_information
-    return {}
-
-
-def logical_dynin_task(task: Any) -> str:
-    task_text = str(unwrap_first_value(task, "") or "").strip().lower()
-    if task_text in ("t2s", "t2s_mmu_like", "t2s_fixed"):
-        return "t2s"
-    if task_text in ("t2i", "i2i"):
-        return task_text
-    return "t2t"
-
-
-def dynin_runtime_fallback(task: str, key: str, value: Any = None) -> Any:
-    if isinstance(value, str):
-        if value.strip() != "":
-            return value
-    elif value is not None:
-        return value
-    return DYNIN_TASK_RUNTIME_FALLBACKS.get(task, {}).get(key)
-
-
-def coerce_token_ids_1d(
-    value: Any,
-    ref_device: torch.device | None = None,
-) -> torch.Tensor:
-    if isinstance(value, tuple):
-        value = value[0]
-
-    if isinstance(value, list):
-        if not value:
-            device = ref_device or torch.device("cpu")
-            return torch.empty(0, dtype=torch.long, device=device)
-        if isinstance(value[0], torch.Tensor):
-            value = value[0]
-        else:
-            value = torch.tensor(
-                value[0] if isinstance(value[0], list) else value,
-                dtype=torch.long,
-            )
-
-    if not isinstance(value, torch.Tensor):
-        value = torch.tensor(value, dtype=torch.long)
-
-    if value.ndim == 0:
-        value = value.unsqueeze(0)
-    if value.ndim > 1:
-        value = value[0]
-
-    if ref_device is not None and value.device != ref_device:
-        value = value.to(ref_device)
-
-    return value.to(dtype=torch.long).contiguous()
-
-
-def _first_positive_int(value: Any) -> int | None:
-    if value is None:
-        return None
-    if isinstance(value, torch.Tensor):
-        if value.numel() != 1:
-            return None
-        value = value.item()
-    try:
-        value = int(value)
-    except (TypeError, ValueError):
-        return None
-    return value if value > 0 else None
-
-
-def resolve_hidden_size(
-    *,
-    vllm_config: VllmConfig,
-    model: Any | None = None,
-    default: int = 1024,
-) -> int:
-    if model is not None:
-        try:
-            embeddings = model.get_input_embeddings()
-            weight = getattr(embeddings, "weight", None)
-            if isinstance(weight, torch.Tensor) and weight.ndim >= 2:
-                hidden_size = _first_positive_int(weight.shape[-1])
-                if hidden_size is not None:
-                    return hidden_size
-        except Exception:
-            pass
-
-        model_cfg = getattr(model, "config", None)
-        for key in ("hidden_size", "d_model", "n_embd", "dim", "model_dim", "embed_dim"):
-            hidden_size = _first_positive_int(getattr(model_cfg, key, None))
-            if hidden_size is not None:
-                return hidden_size
-
-    for config_obj in (
-        getattr(vllm_config.model_config, "hf_config", None),
-        getattr(vllm_config.model_config, "hf_text_config", None),
-    ):
-        if config_obj is None:
-            continue
-        for key in ("hidden_size", "d_model", "n_embd", "dim", "model_dim", "embed_dim"):
-            value = config_obj.get(key) if isinstance(config_obj, dict) else getattr(config_obj, key, None)
-            hidden_size = _first_positive_int(value)
-            if hidden_size is not None:
-                return hidden_size
-
-    return default
-
-
-def build_zero_input_embeddings(
-    *,
-    input_ids: torch.Tensor,
-    hidden_size: int,
-    stage_name: str,
-    dtype: torch.dtype = torch.bfloat16,
-) -> torch.Tensor:
-    if input_ids.ndim == 0:
-        shape = (1, hidden_size)
-    elif input_ids.ndim == 1:
-        shape = (input_ids.shape[0], hidden_size)
-    elif input_ids.ndim == 2:
-        shape = (input_ids.shape[0], input_ids.shape[1], hidden_size)
-    else:
-        raise ValueError(f"Unsupported input_ids rank for {stage_name}: {input_ids.ndim}")
-    return torch.zeros(shape, dtype=dtype, device=input_ids.device)
-
-
-def _to_bool(value: Any, default: bool = False) -> bool:
-    if value is None:
-        return default
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, (int, float)):
-        return bool(value)
-
-    text = str(value).strip().lower()
-    if text in ("1", "true", "yes", "y", "on"):
-        return True
-    if text in ("0", "false", "no", "n", "off", "", "none", "null"):
-        return False
-    return default
-
-
-def _runtime_value(runtime_info: dict[str, Any], key: str) -> Any:
-    return unwrap_first_value(runtime_info.get(key), None)
-
-
-def _runtime_first_value(runtime_info: dict[str, Any], keys: tuple[str, ...]) -> Any:
-    for key in keys:
-        value = _runtime_value(runtime_info, key)
-        if value is not None:
-            return value
-    return None
-
-
-def _node_value(node: Any, key: str, default: Any = None) -> Any:
-    if node is None:
-        return default
-    if isinstance(node, dict):
-        return node.get(key, default)
-    try:
-        return node.get(key, default)
-    except Exception:
-        return getattr(node, key, default)
-
-
-def _looks_like_hf_repo_id(value: str | None) -> bool:
-    if not isinstance(value, str):
-        return False
-    if value.count("/") != 1:
-        return False
-    org, name = value.split("/", 1)
-    return bool(org and name)
-
-
-def _find_dynin_config_under_root(root: Path) -> Path | None:
-    for rel_path in _DYNIN_CONFIG_CANDIDATE_RELPATHS:
-        candidate = root.expanduser() / rel_path
-        if candidate.exists():
-            return candidate.resolve()
-    return None
-
-
-@lru_cache(maxsize=16)
-def _resolve_dynin_config_from_hf_repo(repo_id: str) -> str | None:
-    if not _looks_like_hf_repo_id(repo_id) or hf_api is None:
-        return None
-
-    try:
-        snapshot_dir = (
-            Path(
-                hf_api().snapshot_download(
-                    repo_id=repo_id,
-                    repo_type="model",
-                    allow_patterns=list(_DYNIN_CONFIG_CANDIDATE_RELPATHS),
-                    local_files_only=True,
-                )
-            )
-            .expanduser()
-            .resolve()
-        )
-    except Exception:
-        return None
-
-    found = _find_dynin_config_under_root(snapshot_dir)
-    return str(found) if found is not None else None
-
-
-def _resolve_existing_path(path_like: Any, source_name: str) -> str | None:
-    if path_like is None:
-        return None
-    text = str(path_like).strip()
-    if not text:
-        return None
-
-    path = Path(text).expanduser()
-    if path.is_file():
-        return str(path.resolve())
-
-    logger.warning(
-        "DYNIN config path from %s does not exist: %s. Falling back to auto-discovery.",
-        source_name,
-        path,
-    )
-    return None
-
-
-def _resolve_config_path(vllm_config: VllmConfig, runtime_info: dict[str, Any]) -> str | None:
-    for value, name in (
-        (_runtime_value(runtime_info, "dynin_config_path"), "runtime_info.dynin_config_path"),
-        (os.getenv("DYNIN_CONFIG_PATH"), "DYNIN_CONFIG_PATH"),
-        (getattr(vllm_config.model_config, "dynin_config_path", None), "vllm_config.model_config.dynin_config_path"),
-    ):
-        resolved = _resolve_existing_path(value, name)
-        if resolved:
-            return resolved
-
-    model_source = str(getattr(vllm_config.model_config, "model", "") or "")
-    tokenizer_source = str(getattr(vllm_config.model_config, "tokenizer", "") or "")
-    hf_config = getattr(vllm_config.model_config, "hf_config", None)
-    hf_name_or_path = (
-        hf_config.get("_name_or_path") if isinstance(hf_config, dict) else getattr(hf_config, "_name_or_path", None)
-    )
-
-    hf_repo_candidates: list[str] = []
-    for source in (model_source, tokenizer_source, hf_name_or_path):
-        if not _looks_like_hf_repo_id(source):
-            continue
-        source = str(source)
-        if source not in hf_repo_candidates:
-            hf_repo_candidates.append(source)
-
-    for source in hf_repo_candidates:
-        resolved = _resolve_dynin_config_from_hf_repo(source)
-        if resolved is not None:
-            logger.info("Resolved dynin config from Hugging Face cache for %s: %s", source, resolved)
-            return resolved
-
-    for source in (model_source, tokenizer_source):
-        source_path = Path(source).expanduser()
-        if source_path.is_dir():
-            found = _find_dynin_config_under_root(source_path)
-            if found is not None:
-                return str(found)
-
-    module_root = Path(__file__).resolve().parent
-    for bundled in (
-        module_root / "configs" / "dynin_omni.yaml",
-        module_root / "models" / "configs" / "dynin_omni.yaml",
-    ):
-        if bundled.exists():
-            return str(bundled)
-
-    return None
-
-
-@lru_cache(maxsize=16)
-def _load_omega_config(config_path: str) -> Any:
-    try:
-        from omegaconf import OmegaConf
-    except ImportError as e:
-        raise ImportError(
-            f"omegaconf is required to load Dynin config files. Install it to read config: {config_path}"
-        ) from e
-    return OmegaConf.load(config_path)
-
-
-def resolve_dynin_infer_sources(
-    *,
-    vllm_config: VllmConfig,
-    runtime_info: dict[str, Any] | None = None,
-) -> DyninInferSources:
-    runtime_info = runtime_info or {}
-
-    base_model_source = str(getattr(vllm_config.model_config, "model", ""))
-    base_model_path = Path(base_model_source).expanduser()
-    local_vllm_model_source = str(base_model_path) if base_model_path.is_dir() else None
-
-    model_source = base_model_source
-    tokenizer_source = model_source
-    vq_image_source = DEFAULT_VQ_IMAGE_SOURCE
-    vq_audio_source = DEFAULT_VQ_AUDIO_SOURCE
-    model_local_files_only = False
-    vq_image_local_files_only = False
-    vq_audio_local_files_only = False
-
-    resolver_source: str | None = base_model_source if base_model_source else None
-    resolver_local_files_only: bool | None = True if base_model_path.is_dir() else None
-    resolve_model_pretrained_source_fn = get_dynin_config_resolver_attr(
-        "resolve_model_pretrained_source",
-        source=resolver_source,
-        local_files_only=resolver_local_files_only,
-    )
-    resolve_tokenizer_source_fn = get_dynin_config_resolver_attr(
-        "resolve_tokenizer_source",
-        source=resolver_source,
-        local_files_only=resolver_local_files_only,
-    )
-    resolve_model_local_files_only_fn = get_dynin_config_resolver_attr(
-        "resolve_model_local_files_only",
-        source=resolver_source,
-        local_files_only=resolver_local_files_only,
-    )
-    resolve_vq_cfg_block_fn = get_dynin_config_resolver_attr(
-        "resolve_vq_cfg_block",
-        source=resolver_source,
-        local_files_only=resolver_local_files_only,
-    )
-    resolve_vq_repo_source_fn = get_dynin_config_resolver_attr(
-        "resolve_vq_repo_source",
-        source=resolver_source,
-        local_files_only=resolver_local_files_only,
-    )
-
-    config_path = _resolve_config_path(vllm_config, runtime_info)
-    if config_path:
-        config_file = Path(config_path).expanduser()
-        if config_file.exists():
-            try:
-                dynin_cfg = _load_omega_config(str(config_file))
-                model_source = resolve_model_pretrained_source_fn(
-                    dynin_cfg,
-                    default=model_source,
-                )
-                tokenizer_source = resolve_tokenizer_source_fn(
-                    dynin_cfg,
-                    default=tokenizer_source,
-                )
-                model_local_files_only = resolve_model_local_files_only_fn(
-                    dynin_cfg,
-                    default=model_local_files_only,
-                )
-                vq_image_cfg = resolve_vq_cfg_block_fn(dynin_cfg, modality="image")
-                vq_audio_cfg = resolve_vq_cfg_block_fn(dynin_cfg, modality="audio")
-                vq_image_source = resolve_vq_repo_source_fn(
-                    vq_image_cfg,
-                    default=vq_image_source,
-                )
-                vq_audio_source = resolve_vq_repo_source_fn(
-                    vq_audio_cfg,
-                    default=vq_audio_source,
-                )
-                vq_image_local_files_only = _to_bool(
-                    _node_value(vq_image_cfg, "local_files_only", None),
-                    default=model_local_files_only,
-                )
-                vq_audio_local_files_only = _to_bool(
-                    _node_value(vq_audio_cfg, "local_files_only", None),
-                    default=model_local_files_only,
-                )
-            except Exception as e:
-                logger.warning(
-                    "Failed to resolve DYNIN inference config from %s: %s",
-                    config_file,
-                    e,
-                )
-        else:
-            logger.warning("DYNIN config path does not exist: %s", config_file)
-
-    runtime_model_source = _runtime_value(runtime_info, "dynin_model_path")
-    if runtime_model_source:
-        model_source = str(runtime_model_source)
-
-    runtime_tokenizer_source = _runtime_value(runtime_info, "tokenizer_path")
-    if runtime_tokenizer_source:
-        tokenizer_source = str(runtime_tokenizer_source)
-
-    runtime_vq_image_source = _runtime_value(runtime_info, "vq_model_image_path")
-    if runtime_vq_image_source is None:
-        runtime_vq_image_source = _runtime_value(runtime_info, "vq_model_path_image")
-    if runtime_vq_image_source:
-        vq_image_source = str(runtime_vq_image_source)
-
-    runtime_vq_audio_source = _runtime_value(runtime_info, "vq_model_audio_path")
-    if runtime_vq_audio_source is None:
-        runtime_vq_audio_source = _runtime_value(runtime_info, "vq_model_path_audio")
-    if runtime_vq_audio_source:
-        vq_audio_source = str(runtime_vq_audio_source)
-
-    runtime_local_global = _runtime_value(runtime_info, "local_files_only")
-    runtime_local_model = _runtime_first_value(
-        runtime_info,
-        ("model_local_files_only", "local_files_only_model"),
-    )
-    runtime_local_vq_image = _runtime_first_value(
-        runtime_info,
-        ("vq_model_image_local_files_only", "local_files_only_vq_image"),
-    )
-    runtime_local_vq_audio = _runtime_first_value(
-        runtime_info,
-        ("vq_model_audio_local_files_only", "local_files_only_vq_audio"),
-    )
-
-    if runtime_local_global is not None:
-        global_local = _to_bool(runtime_local_global, default=False)
-        if runtime_local_model is None:
-            model_local_files_only = global_local
-        if runtime_local_vq_image is None:
-            vq_image_local_files_only = global_local
-        if runtime_local_vq_audio is None:
-            vq_audio_local_files_only = global_local
-
-    if runtime_local_model is not None:
-        model_local_files_only = _to_bool(
-            runtime_local_model,
-            default=model_local_files_only,
-        )
-    if runtime_local_vq_image is not None:
-        vq_image_local_files_only = _to_bool(
-            runtime_local_vq_image,
-            default=vq_image_local_files_only,
-        )
-    if runtime_local_vq_audio is not None:
-        vq_audio_local_files_only = _to_bool(
-            runtime_local_vq_audio,
-            default=vq_audio_local_files_only,
-        )
-
-    if runtime_local_global is None and runtime_local_model is None and local_vllm_model_source is not None:
-        model_local_files_only = True
-
-    if local_vllm_model_source is not None:
-        if not runtime_model_source:
-            if model_source != local_vllm_model_source:
-                logger.info(
-                    "DYNIN infer model source overridden to local vLLM model path: %s (from %s)",
-                    local_vllm_model_source,
-                    model_source,
-                )
-            model_source = local_vllm_model_source
-        if not runtime_tokenizer_source:
-            tokenizer_source = local_vllm_model_source
-
-    return DyninInferSources(
-        model_source=model_source,
-        tokenizer_source=tokenizer_source,
-        vq_image_source=vq_image_source,
-        vq_audio_source=vq_audio_source,
-        model_local_files_only=model_local_files_only,
-        vq_image_local_files_only=vq_image_local_files_only,
-        vq_audio_local_files_only=vq_audio_local_files_only,
-        config_path=config_path,
-    )
-
-
-def _resolve_remote_source(source: str | None, settings: RemoteCodeSettings) -> str:
-    if isinstance(source, str):
-        stripped = source.strip()
-        if stripped:
-            source_path = Path(stripped).expanduser()
-            if source_path.is_dir():
-                return str(source_path.resolve())
-            if _looks_like_hf_repo_id(stripped):
-                return stripped
-
-    env_repo = os.getenv(settings.repo_env)
-    if _looks_like_hf_repo_id(env_repo):
-        return str(env_repo).strip()
-
-    return settings.default_repo
-
-
-def _resolve_remote_revision(revision: str | None, settings: RemoteCodeSettings) -> str | None:
-    if isinstance(revision, str) and revision.strip():
-        return revision.strip()
-    env_revision = os.getenv(settings.revision_env)
-    if isinstance(env_revision, str) and env_revision.strip():
-        return env_revision.strip()
-    return None
-
-
-def _resolve_remote_local_only(local_files_only: bool | None, settings: RemoteCodeSettings) -> bool:
-    if local_files_only is not None:
-        return bool(local_files_only)
-    return _to_bool(os.getenv(settings.local_only_env), default=False)
-
-
-def _resolve_remote_snapshot_dir(
-    *,
-    source: str,
-    revision: str | None,
-    local_files_only: bool,
-) -> str:
-    source_path = Path(source).expanduser()
-    if source_path.is_dir():
-        return str(source_path.resolve())
-
-    if hf_api is None:
-        raise RuntimeError("huggingface_hub is required to load remote code.")
-
-    kwargs: dict[str, Any] = {
-        "repo_id": source,
-        "repo_type": "model",
-        "allow_patterns": list(_DYNIN_REMOTE_ALLOW_PATTERNS),
-        "local_files_only": bool(local_files_only),
-    }
-    if revision is not None:
-        kwargs["revision"] = revision
-
-    try:
-        return str(hf_api().snapshot_download(**kwargs))
-    except TypeError:
-        kwargs.pop("local_files_only", None)
-        return str(hf_api().snapshot_download(**kwargs))
-
-
-def _ensure_remote_package(snapshot_dir: str) -> str:
-    with _DYNIN_REMOTE_CACHE_LOCK:
-        existing = _DYNIN_REMOTE_PACKAGE_BY_SNAPSHOT.get(snapshot_dir)
-        if existing is not None:
-            return existing
-
-        digest = hashlib.sha1(snapshot_dir.encode("utf-8")).hexdigest()[:12]
-        package_name = f"_dynin_hf_remote_{digest}"
-
-        package = types.ModuleType(package_name)
-        package.__path__ = [snapshot_dir]  # type: ignore[attr-defined]
-        package.__file__ = str(Path(snapshot_dir) / "__init__.py")
-
-        sys.modules.setdefault(package_name, package)
-        _DYNIN_REMOTE_PACKAGE_BY_SNAPSHOT[snapshot_dir] = package_name
-        return package_name
-
-
-def _load_remote_module(
-    *,
-    module_name: str,
-    source: str,
-    revision: str | None,
-    local_files_only: bool,
-):
-    snapshot_dir = _resolve_remote_snapshot_dir(
-        source=source,
-        revision=revision,
-        local_files_only=local_files_only,
-    )
-
-    module_path = Path(snapshot_dir) / f"{module_name}.py"
-    if not module_path.is_file():
-        raise ImportError(f"Remote code module '{module_name}.py' not found under '{snapshot_dir}'. source={source!r}")
-
-    package_name = _ensure_remote_package(snapshot_dir)
-    full_name = f"{package_name}.{module_name}"
-
-    existing = sys.modules.get(full_name)
-    if existing is not None:
-        return existing
-
-    spec = importlib.util.spec_from_file_location(full_name, module_path)
-    if spec is None or spec.loader is None:
-        raise ImportError(f"Failed to create import spec for '{module_path}'.")
-
-    module = importlib.util.module_from_spec(spec)
-    module.__package__ = package_name
-    sys.modules[full_name] = module
-    try:
-        spec.loader.exec_module(module)
-    except Exception:
-        sys.modules.pop(full_name, None)
-        raise
-    return module
-
-
-def resolve_remote_attr(
-    attr_name: str,
-    *,
-    module_name: str,
-    settings: RemoteCodeSettings,
-    source: str | None = None,
-    revision: str | None = None,
-    local_files_only: bool | None = None,
-    fallback_module_names: Iterable[str] = (),
-    optional: bool = False,
-) -> Any | None:
-    resolved_source = _resolve_remote_source(source, settings)
-    resolved_revision = _resolve_remote_revision(revision, settings)
-    resolved_local_only = _resolve_remote_local_only(local_files_only, settings)
-
-    module_candidates = [module_name, *[m for m in fallback_module_names if m and m != module_name]]
-    last_error: Exception | None = None
-
-    for candidate in module_candidates:
-        cache_key = (attr_name, candidate, resolved_source, resolved_revision, resolved_local_only)
-        cached = _DYNIN_REMOTE_ATTR_CACHE.get(cache_key)
-        if cached is not None:
-            return cached
-
-        try:
-            module = _load_remote_module(
-                module_name=candidate,
-                source=resolved_source,
-                revision=resolved_revision,
-                local_files_only=resolved_local_only,
-            )
-            if hasattr(module, attr_name):
-                value = getattr(module, attr_name)
-                _DYNIN_REMOTE_ATTR_CACHE[cache_key] = value
-                return value
-        except Exception as e:
-            last_error = e
-
-    if optional:
-        if last_error is not None:
-            logger.debug(
-                "Optional remote attr not found: attr=%s source=%s revision=%s err=%s",
-                attr_name,
-                resolved_source,
-                resolved_revision,
-                last_error,
-            )
-        return None
-
-    raise ImportError(
-        f"Failed to resolve '{attr_name}' from remote code "
-        f"(source={resolved_source!r}, revision={resolved_revision!r}, modules={module_candidates})."
-    ) from last_error
-
-
-_DYNIN_MODELING_REMOTE_EXPORTS = {
-    "DyninOmniConfig": "DyninOmniConfig",
-    "DyninOmniModelLM": "DyninOmniModelLM",
-    "VideoTokenMerger": "VideoTokenMerger",
-}
-
-_DYNIN_SAMPLING_REMOTE_EXPORTS = {
-    "log": "log",
-    "gumbel_noise": "gumbel_noise",
-    "gumbel_sample": "gumbel_sample",
-    "top_k": "top_k",
-    "mask_by_random_topk": "mask_by_random_topk",
-    "cosine_schedule": "cosine_schedule",
-    "linear_schedule": "linear_schedule",
-    "pow": "pow",
-    "sigmoid_schedule": "sigmoid_schedule",
-    "get_mask_schedule": "get_mask_schedule",
-    "top_k_top_p_filtering": "top_k_top_p_filtering",
-}
-
-_DYNIN_CONFIG_RESOLVER_REMOTE_EXPORTS = {
-    "resolve_model_pretrained_source": "resolve_model_pretrained_source",
-    "resolve_tokenizer_source": "resolve_tokenizer_source",
-    "resolve_model_local_files_only": "resolve_model_local_files_only",
-    "resolve_vq_cfg_block": "resolve_vq_cfg_block",
-    "resolve_vq_repo_source": "resolve_vq_repo_source",
-}
-
-_DYNIN_MAGVIT_REMOTE_EXPORTS = {
-    "VQGANEncoder": "VQGANEncoder",
-    "VQGANDecoder": "VQGANDecoder",
-    "LFQuantizer": "LFQuantizer",
-    "MAGVITv2": "MAGVITv2",
-}
-
-
-def _get_export_attr(
-    name: str,
-    export_map: dict[str, str],
-    *,
-    module_name: str,
-    settings: RemoteCodeSettings,
-    source: str | None = None,
-    revision: str | None = None,
-    local_files_only: bool | None = None,
-    optional: bool = False,
-) -> Any | None:
-    attr_name = export_map.get(name)
-    if attr_name is None:
-        raise AttributeError(f"Unsupported export: {name!r}")
-
-    return resolve_remote_attr(
-        attr_name,
-        module_name=module_name,
-        settings=settings,
-        source=source,
-        revision=revision,
-        local_files_only=local_files_only,
-        optional=optional,
-    )
-
-
-def get_dynin_modeling_attr(name: str) -> Any:
-    return _get_export_attr(
-        name,
-        _DYNIN_MODELING_REMOTE_EXPORTS,
-        module_name="modeling_dynin_omni",
-        settings=DYNIN_REMOTE_SETTINGS,
-    )
-
-
-def get_dynin_sampling_attr(name: str) -> Any:
-    return _get_export_attr(
-        name,
-        _DYNIN_SAMPLING_REMOTE_EXPORTS,
-        module_name="sampling",
-        settings=DYNIN_REMOTE_SETTINGS,
-    )
-
-
-def get_dynin_config_resolver_attr(
-    name: str,
-    *,
-    source: str | None = None,
-    revision: str | None = None,
-    local_files_only: bool | None = None,
-) -> Any:
-    attr_name = _DYNIN_CONFIG_RESOLVER_REMOTE_EXPORTS.get(name)
-    if attr_name is None:
-        raise AttributeError(f"Unsupported Dynin config_resolver export: {name!r}")
-
-    if source is not None:
-        value = resolve_remote_attr(
-            attr_name,
-            module_name="config_resolver",
-            settings=DYNIN_REMOTE_SETTINGS,
-            source=source,
-            revision=revision,
-            local_files_only=local_files_only,
-            optional=True,
-        )
-        if value is not None:
-            return value
-
-    return resolve_remote_attr(
-        attr_name,
-        module_name="config_resolver",
-        settings=DYNIN_REMOTE_SETTINGS,
-        source=DEFAULT_DYNIN_REMOTE_CODE_REPO,
-        revision=revision,
-        local_files_only=local_files_only,
-        optional=False,
-    )
-
-
-def get_dynin_magvit_attr(
-    name: str,
-    *,
-    source: str | None = None,
-    revision: str | None = None,
-    local_files_only: bool | None = None,
-) -> Any:
-    attr_name = _DYNIN_MAGVIT_REMOTE_EXPORTS.get(name)
-    if attr_name is None:
-        raise AttributeError(f"Unsupported Dynin MAGVIT export: {name!r}")
-
-    value = resolve_remote_attr(
-        attr_name,
-        module_name="modeling_magvitv2",
-        settings=MAGVIT_REMOTE_SETTINGS,
-        source=source,
-        revision=revision,
-        local_files_only=local_files_only,
-        optional=True,
-    )
-    if value is not None:
-        return value
-
-    resolved_source = _resolve_remote_source(source, MAGVIT_REMOTE_SETTINGS)
-    resolved_revision = _resolve_remote_revision(revision, MAGVIT_REMOTE_SETTINGS)
-    resolved_local_only = _resolve_remote_local_only(local_files_only, MAGVIT_REMOTE_SETTINGS)
-
-    if resolved_source != DEFAULT_MAGVIT_REMOTE_CODE_REPO:
-        return resolve_remote_attr(
-            attr_name,
-            module_name="modeling_magvitv2",
-            settings=MAGVIT_REMOTE_SETTINGS,
-            source=DEFAULT_MAGVIT_REMOTE_CODE_REPO,
-            revision=resolved_revision,
-            local_files_only=resolved_local_only,
-            optional=False,
-        )
-
-    raise ImportError(
-        f"Failed to resolve MAGVIT attr '{attr_name}' from source={resolved_source!r} (revision={resolved_revision!r})."
-    )
-
-
-def build_dynin_chat_prompt(content: str) -> str:
-    return (
-        f"<|start_header_id|>user<|end_header_id|>\n{content}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n"
-    )
-
-
-def extract_dynin_user_prompt_text(decoded_prompt: str) -> str:
-    text = str(decoded_prompt or "")
-    assistant_marker = "<|start_header_id|>assistant<|end_header_id|>"
-    user_marker = "<|start_header_id|>user<|end_header_id|>"
-    end_header_marker = "<|end_header_id|>"
-    eot_marker = "<|eot_id|>"
-
-    if assistant_marker in text:
-        text = text.rsplit(assistant_marker, 1)[0]
-    if eot_marker in text:
-        text = text.rsplit(eot_marker, 1)[0]
-    if user_marker in text:
-        text = text.rsplit(user_marker, 1)[-1]
-    if end_header_marker in text:
-        text = text.split(end_header_marker, 1)[-1]
-    return text.strip()
-
-
-def normalize_dynin_online_prompt_text(task: str, decoded_prompt: str) -> str:
-    text = extract_dynin_user_prompt_text(decoded_prompt)
-    if not text:
-        text = str(decoded_prompt or "")
-
-    for placeholder in _DYNIN_MODALITY_PLACEHOLDERS:
-        text = text.replace(placeholder, " ")
-
-    task_token = _DYNIN_ONLINE_PROMPT_TOKEN_BY_TASK.get(task)
-    if task_token:
-        text = text.replace(task_token, " ", 1)
-
-    text = " ".join(text.split()).strip()
-
-    if task == "t2s":
-        if not text:
-            text = "Hello. This is a default text-to-speech sample."
-        text = build_dynin_chat_prompt(f"{DEFAULT_DYNIN_T2S_INSTRUCTION}\n{text}")
-    elif task in {"t2i", "i2i"} and not text:
-        text = "A high quality detailed image."
-
-    return text
-
-
-def infer_dynin_online_task(
-    *,
-    decoded_prompt: str,
-    has_image: bool = False,
-    has_audio: bool = False,
-    has_video: bool = False,
-) -> str:
-    prompt = str(decoded_prompt or "")
-    if "<|i2i|>" in prompt:
-        return "i2i"
-    if "<|t2i|>" in prompt and not has_audio and not has_video:
-        return "t2i"
-    if "<|t2s|>" in prompt and not has_audio and not has_video:
-        return "t2s"
-    return "t2t"
-
-
-def build_dynin_prompt_payload(
-    *,
-    task: str,
-    text: str,
-    image_tokens: torch.Tensor | None,
-    image_placeholder_tokens: int,
-    audio_placeholder_tokens: int,
-    image_token_offset: int,
-    mask_token_id: int,
-    use_train_i2i_prompt: bool,
-) -> tuple[Any, str]:
-    _, prompting_task, _, _ = DYNIN_TASK_DEFAULT_RUNTIME[task]
-
-    if task == "t2t":
-        payload = ([[]], [build_dynin_chat_prompt(text)])
-        return payload, prompting_task
-
-    if task == "t2i":
-        image_placeholder = torch.full(
-            (1, int(image_placeholder_tokens)),
-            fill_value=int(mask_token_id),
-            dtype=torch.long,
-        )
-        payload = ([text], image_placeholder)
-        return payload, prompting_task
-
-    if task == "i2i":
-        if image_tokens is None:
-            raise ValueError("i2i requires image tokens")
-        src = image_tokens.view(1, -1).long() + int(image_token_offset)
-        target_len = int(image_placeholder_tokens) if image_placeholder_tokens > 0 else int(src.shape[1])
-        image_placeholder = torch.full(
-            (1, target_len),
-            fill_value=int(mask_token_id),
-            dtype=torch.long,
-        )
-        if use_train_i2i_prompt:
-            labels_placeholder = torch.full(
-                (1, target_len),
-                fill_value=-100,
-                dtype=torch.long,
-            )
-            payload = ([text], src, image_placeholder, labels_placeholder)
-            return payload, "i2i"
-        payload = ([text], src, image_placeholder)
-        return payload, "i2i_gen"
-
-    if task == "t2s":
-        audio_placeholder = torch.full(
-            (1, int(audio_placeholder_tokens)),
-            fill_value=int(mask_token_id),
-            dtype=torch.long,
-        )
-        payload = ([text], audio_placeholder)
-        return payload, prompting_task
-
-    raise ValueError(f"Unsupported Dynin online bootstrap task: {task}")
-
-
-def _wrap_runtime_field(value: Any) -> list[Any]:
-    return [value]
-
-
-def build_dynin_online_runtime_info(
-    *,
-    task: str,
-    text_vocab_size: int,
-    infer_sources: DyninInferSources,
-    dynin_config_path: str | None = None,
-    prompting_input: Any | None = None,
-    attention_mask: list[int] | None = None,
-    prompt_length: int | None = None,
-    uncond_prompting_input: Any | None = None,
-    image_token_count: int = 0,
-    t2s_token_length: int | None = None,
-    use_train_i2i_prompt: bool | None = None,
-) -> dict[str, Any]:
-    runtime_task, prompting_task, detok_id, _ = DYNIN_TASK_DEFAULT_RUNTIME[task]
-
-    prompt_max_text_len = int(dynin_runtime_fallback(task, "prompt_max_text_len", None) or 1024)
-    max_new_tokens = int(dynin_runtime_fallback(task, "max_new_tokens", None) or 256)
-    steps = int(dynin_runtime_fallback(task, "steps", None) or 256)
-    block_length = int(dynin_runtime_fallback(task, "block_length", None) or 2)
-    temperature = float(dynin_runtime_fallback(task, "temperature", None) or 0.0)
-    cfg_scale = float(dynin_runtime_fallback(task, "cfg_scale", None) or 0.0)
-    remasking = str(dynin_runtime_fallback(task, "remasking", None) or "low_confidence")
-    timesteps = int(dynin_runtime_fallback(task, "timesteps", None) or 20)
-    guidance_scale = float(dynin_runtime_fallback(task, "guidance_scale", None) or 0.0)
-    mask_token_id = int(dynin_runtime_fallback(task, "mask_token_id", None) or 126336)
-    codebook_size = int(dynin_runtime_fallback(task, "codebook_size", None) or 8192)
-    audio_codebook_size = int(dynin_runtime_fallback(task, "audio_codebook_size", None) or 4096)
-    image_resolution = int(dynin_runtime_fallback(task, "image_resolution", None) or 336)
-    if image_token_count <= 0 and task in {"t2i", "i2i"}:
-        fallback_count = dynin_runtime_fallback(task, "image_token_count", None)
-        if fallback_count is not None:
-            image_token_count = int(fallback_count)
-        else:
-            image_token_count = max(1, (image_resolution // 16) ** 2)
-
-    if t2s_token_length is None:
-        t2s_token_length = int(dynin_runtime_fallback(task, "t2s_token_length", None) or 383)
-    t2s_condition = str(
-        dynin_runtime_fallback(
-            task,
-            "t2s_condition",
-            None,
-        )
-        or "gender-female_emotion-neutral_speed-normal_pitch-normal"
-    )
-    if use_train_i2i_prompt is None:
-        use_train_i2i_prompt = bool(dynin_runtime_fallback(task, "use_train_i2i_prompt", task == "i2i"))
-
-    runtime_info: dict[str, Any] = {
-        "task": _wrap_runtime_field(runtime_task),
-        "prompting_task": _wrap_runtime_field(prompting_task),
-        "detok_id": _wrap_runtime_field(int(detok_id)),
-        "prompt_max_text_len": _wrap_runtime_field(prompt_max_text_len),
-        "prompting_max_text_len": _wrap_runtime_field(prompt_max_text_len),
-        "cond_dropout_prob": _wrap_runtime_field(0.0),
-        "prompting_cond_dropout_prob": _wrap_runtime_field(0.0),
-        "tokenizer_path": _wrap_runtime_field(str(infer_sources.tokenizer_source)),
-        "text_vocab_size": _wrap_runtime_field(int(text_vocab_size)),
-        "model_local_files_only": _wrap_runtime_field(bool(infer_sources.model_local_files_only)),
-        "max_new_tokens": _wrap_runtime_field(int(t2s_token_length if task == "t2s" else max_new_tokens)),
-        "steps": _wrap_runtime_field(steps),
-        "block_length": _wrap_runtime_field(block_length),
-        "temperature": _wrap_runtime_field(temperature),
-        "cfg_scale": _wrap_runtime_field(cfg_scale),
-        "remasking": _wrap_runtime_field(remasking),
-        "mask_id": _wrap_runtime_field(mask_token_id),
-        "mask_token_id": _wrap_runtime_field(mask_token_id),
-        "codebook_size": _wrap_runtime_field(codebook_size),
-        "audio_codebook_size": _wrap_runtime_field(audio_codebook_size),
-        "timesteps": _wrap_runtime_field(timesteps),
-        "guidance_scale": _wrap_runtime_field(guidance_scale),
-        "noise_type": _wrap_runtime_field("mask"),
-        "noise_schedule_name": _wrap_runtime_field("cosine"),
-        "noise_schedule_params": _wrap_runtime_field({}),
-        "seq_len": _wrap_runtime_field(int(image_token_count)),
-        "condition": _wrap_runtime_field(t2s_condition),
-        "t2s_condition": _wrap_runtime_field(t2s_condition),
-        "vq_model_image_path": _wrap_runtime_field(str(infer_sources.vq_image_source)),
-        "vq_model_image_local_files_only": _wrap_runtime_field(bool(infer_sources.vq_image_local_files_only)),
-        "vq_model_audio_path": _wrap_runtime_field(str(infer_sources.vq_audio_source)),
-        "vq_model_audio_local_files_only": _wrap_runtime_field(bool(infer_sources.vq_audio_local_files_only)),
-        "image_resolution": _wrap_runtime_field(image_resolution),
-        "t2s_token_length": _wrap_runtime_field(int(t2s_token_length)),
-        "use_train_i2i_prompt": _wrap_runtime_field(bool(use_train_i2i_prompt)),
-    }
-
-    if dynin_config_path:
-        runtime_info["dynin_config_path"] = _wrap_runtime_field(str(dynin_config_path))
-    if prompting_input is not None:
-        runtime_info["prompting_input"] = _wrap_runtime_field(prompting_input)
-    if uncond_prompting_input is not None:
-        runtime_info["uncond_prompting_input"] = _wrap_runtime_field(uncond_prompting_input)
-    if attention_mask:
-        runtime_info["attention_mask"] = _wrap_runtime_field(list(attention_mask))
-    if prompt_length is None and attention_mask:
-        prompt_length = len(attention_mask)
-    if prompt_length is not None:
-        runtime_info["prompt_length"] = _wrap_runtime_field(int(prompt_length))
-
-    return runtime_info
diff --git a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2audio.py b/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2audio.py
deleted file mode 100644
index dbbb63524..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2audio.py
+++ /dev/null
@@ -1,313 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import os
-import tempfile
-from pathlib import Path
-from typing import Any
-
-import torch
-from vllm.config import VllmConfig
-from vllm.logger import init_logger
-from vllm.sequence import IntermediateTensors
-
-from vllm_omni.model_executor.models.output_templates import OmniOutput
-
-from .dynin_omni import DyninOmniStageBase
-from .dynin_omni_common import (
-    DetokTarget,
-    _looks_like_hf_repo_id,
-    coerce_token_ids_1d,
-    normalize_runtime_info,
-    resolve_dynin_infer_sources,
-    resolve_hidden_size,
-    unwrap_first_value,
-)
-
-logger = init_logger(__name__)
-
-
-def _get_hf_token() -> str | None:
-    return os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
-
-
-def _ensure_transformers_tied_weights_compat() -> None:
-    """Provide the transformers>=5 tied-weight attr expected during loading.
-
-    The DYNIN audio detokenizer uses Hugging Face remote code that still only
-    defines the older ``_tied_weights_keys`` attribute. transformers 5.x now
-    reads ``all_tied_weights_keys`` inside ``from_pretrained`` before the model
-    instance is returned, so patching the loaded object is too late.
-    """
-    try:
-        from transformers import PreTrainedModel
-    except Exception:
-        return
-
-    if hasattr(PreTrainedModel, "all_tied_weights_keys"):
-        return
-
-    def all_tied_weights_keys(self: Any) -> dict[str, Any]:
-        keys: dict[str, Any] = {}
-        for attr_name in ("_tied_weights_keys", "_dynamic_tied_weights_keys"):
-            raw_keys = getattr(self, attr_name, None)
-            if raw_keys is None:
-                continue
-            if isinstance(raw_keys, dict):
-                keys.update({str(k): v for k, v in raw_keys.items()})
-                continue
-            if isinstance(raw_keys, str):
-                keys[raw_keys] = None
-                continue
-            for key in raw_keys:
-                keys[str(key)] = None
-        return keys
-
-    PreTrainedModel.all_tied_weights_keys = property(all_tied_weights_keys)  # type: ignore[attr-defined]
-
-
-def _ensure_remote_s2u_vendor_root(
-    *,
-    repo_id: str,
-    local_files_only: bool,
-) -> str | None:
-    if local_files_only or not _looks_like_hf_repo_id(repo_id):
-        return None
-
-    existing = os.environ.get("DYNIN_S2U_VENDOR_ROOT")
-    if existing:
-        existing_path = Path(existing).expanduser().resolve()
-        if existing_path.is_dir():
-            return str(existing_path)
-
-    try:
-        from vllm_omni.transformers_utils.repo_utils import hf_api
-    except Exception as e:
-        logger.warning("huggingface_hub unavailable; cannot fetch s2u_vendor from %s: %s", repo_id, e)
-        return None
-
-    token = _get_hf_token()
-    last_error: Exception | None = None
-    revisions: list[str | None] = [None]
-
-    for revision in revisions:
-        try:
-            snapshot_dir = hf_api().snapshot_download(
-                repo_id=repo_id,
-                revision=revision,
-                allow_patterns=["s2u_vendor/**"],
-                token=token,
-            )
-        except TypeError:
-            try:
-                snapshot_dir = hf_api().snapshot_download(
-                    repo_id=repo_id,
-                    revision=revision,
-                    allow_patterns=["s2u_vendor/**"],
-                )
-            except Exception as e:
-                last_error = e
-                continue
-        except Exception as e:
-            last_error = e
-            continue
-
-        vendor_root = (Path(snapshot_dir) / "s2u_vendor").resolve()
-        if vendor_root.is_dir():
-            os.environ["DYNIN_S2U_VENDOR_ROOT"] = str(vendor_root)
-            logger.info("Using remote S2U vendor root: %s", vendor_root)
-            return str(vendor_root)
-
-    if last_error is not None:
-        logger.warning("Failed to download remote s2u_vendor from %s: %s", repo_id, last_error)
-    return None
-
-
-class DyninOmniToken2Audio(DyninOmniStageBase):
-    """Stage-3: token detokenization to speech (or pass-through)."""
-
-    stage_name = "Dynin token2audio"
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        del prefix
-        super().__init__()
-        self.vllm_config = vllm_config
-        self.have_multimodal_outputs = True
-        self.requires_raw_input_tokens = True
-        self.hidden_size = resolve_hidden_size(vllm_config=vllm_config)
-        self._vq_audio = None
-        self._vq_audio_path: str | None = None
-        self._vq_audio_local_files_only: bool | None = None
-
-    def forward(
-        self,
-        input_ids: torch.Tensor | None = None,
-        positions: torch.Tensor | None = None,
-        intermediate_tensors: IntermediateTensors | None = None,
-        inputs_embeds: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> OmniOutput:
-        del positions, intermediate_tensors, inputs_embeds
-        if input_ids is None:
-            raise ValueError("token2audio stage requires input_ids")
-
-        runtime_info = normalize_runtime_info(kwargs.get("runtime_additional_information"))
-        detok_id = int(unwrap_first_value(runtime_info.get("detok_id"), 0))
-        tokens = coerce_token_ids_1d(input_ids)
-
-        if detok_id != DetokTarget.AUDIO:
-            return OmniOutput(
-                text_hidden_states=None,
-                multimodal_outputs={
-                    "token_ids": tokens,
-                    "detok_id": torch.tensor([detok_id], dtype=torch.long, device=tokens.device),
-                },
-            )
-
-        audio, sample_rate = self._decode_audio_tokens(tokens, runtime_info=runtime_info)
-        return OmniOutput(
-            text_hidden_states=None,
-            multimodal_outputs={
-                "speech": audio,
-                "audio": audio,
-                "sr": torch.tensor([sample_rate], dtype=torch.int, device=audio.device),
-                "detok_id": torch.tensor([detok_id], dtype=torch.long, device=audio.device),
-            },
-        )
-
-    def _decode_audio_tokens(self, tokens: torch.Tensor, runtime_info: dict[str, Any]) -> tuple[torch.Tensor, int]:
-        # Follow DYNIN validation path:
-        #   token list -> "<|speech_x|>" string -> vq_model_audio.decode(...).
-        vq_audio = self._ensure_vq_audio(runtime_info=runtime_info, ref_device=tokens.device)
-
-        audio_codebook_size = int(unwrap_first_value(runtime_info.get("audio_codebook_size"), 4096))
-        audio_vocab_offset = unwrap_first_value(
-            runtime_info.get("audio_vocab_offset"),
-            unwrap_first_value(runtime_info.get("t2s_vocab_start"), None),
-        )
-
-        token_ids = tokens.to(torch.long)
-        if audio_vocab_offset is not None:
-            off = int(audio_vocab_offset)
-            token_ids = torch.where(token_ids >= off, token_ids - off, token_ids)
-        token_ids = token_ids[(token_ids >= 0) & (token_ids < audio_codebook_size)]
-        if token_ids.numel() == 0:
-            raise RuntimeError("Audio detokenizer got no valid audio token ids.")
-
-        speech_unit_str = " ".join(map(str, token_ids.detach().cpu().tolist()))
-        speech_unit_for_decode = "".join(f"<|speech_{unit}|>" for unit in speech_unit_str.split(" ") if unit != "")
-
-        condition = unwrap_first_value(
-            runtime_info.get("condition"),
-            unwrap_first_value(runtime_info.get("t2s_condition"), None),
-        )
-        output_wav_file = unwrap_first_value(runtime_info.get("output_wav_file"), None)
-        created_tmp = False
-        if output_wav_file is None:
-            fd, tmp_wav = tempfile.mkstemp(prefix="dynin_t2s_", suffix=".wav")
-            os.close(fd)
-            output_wav_file = tmp_wav
-            created_tmp = True
-
-        audio_array = vq_audio.decode(speech_unit_for_decode, condition=condition, output_wav_file=output_wav_file)
-        if created_tmp:
-            try:
-                os.remove(output_wav_file)
-            except Exception:
-                pass
-        if not isinstance(audio_array, torch.Tensor):
-            audio_array = torch.as_tensor(audio_array, dtype=torch.float32, device=tokens.device)
-        else:
-            audio_array = audio_array.to(device=tokens.device, dtype=torch.float32)
-
-        if audio_array.ndim > 1:
-            audio_array = audio_array.reshape(-1)
-        audio_array = audio_array.contiguous()
-
-        sample_rate = int(
-            unwrap_first_value(
-                runtime_info.get("sr"),
-                unwrap_first_value(runtime_info.get("sample_rate"), 24000),
-            )
-        )
-        try:
-            cfg = getattr(vq_audio, "u2s_config", None)
-            cfg_sr = getattr(cfg, "sampling_rate", None)
-            if cfg_sr is None:
-                cfg_sr = getattr(getattr(cfg, "data", None), "sampling_rate", None)
-            if cfg_sr is not None:
-                sample_rate = int(cfg_sr)
-        except Exception:
-            pass
-        return audio_array, sample_rate
-
-    def _ensure_vq_audio(self, runtime_info: dict[str, Any], ref_device: torch.device) -> Any:
-        sources = resolve_dynin_infer_sources(vllm_config=self.vllm_config, runtime_info=runtime_info)
-        model_path = str(sources.vq_audio_source)
-        local_files_only = bool(sources.vq_audio_local_files_only)
-
-        _ensure_remote_s2u_vendor_root(
-            repo_id=model_path,
-            local_files_only=local_files_only,
-        )
-
-        if (
-            self._vq_audio is None
-            or self._vq_audio_path != model_path
-            or self._vq_audio_local_files_only != local_files_only
-        ):
-            logger.info(
-                "Loading DYNIN audio detokenizer from %s (local_files_only=%s)",
-                model_path,
-                local_files_only,
-            )
-            try:
-                from transformers import AutoModel
-            except Exception as e:
-                raise RuntimeError(
-                    "transformers is required to load EMOVASpeechTokenizer remote code from Hugging Face."
-                ) from e
-
-            _ensure_transformers_tied_weights_compat()
-            try:
-                self._vq_audio = AutoModel.from_pretrained(
-                    model_path,
-                    trust_remote_code=True,
-                    local_files_only=local_files_only,
-                    low_cpu_mem_usage=False,
-                )
-            except TypeError:
-                try:
-                    self._vq_audio = AutoModel.from_pretrained(
-                        model_path,
-                        trust_remote_code=True,
-                        local_files_only=local_files_only,
-                    )
-                except TypeError:
-                    self._vq_audio = AutoModel.from_pretrained(
-                        model_path,
-                        trust_remote_code=True,
-                    )
-            except Exception as e:
-                raise RuntimeError(
-                    f"Failed to load EMOVASpeechTokenizer from Hugging Face remote code for model path '{model_path}'."
-                ) from e
-
-            if not hasattr(self._vq_audio, "decode"):
-                raise RuntimeError(
-                    "Loaded audio tokenizer does not expose decode(). "
-                    "Check HF config.json auto_map/model_type and ensure trust_remote_code=True."
-                )
-            self._vq_audio.eval()
-            self._vq_audio.requires_grad_(False)
-            self._vq_audio_path = model_path
-            self._vq_audio_local_files_only = local_files_only
-        if hasattr(self._vq_audio, "to"):
-            self._vq_audio = self._vq_audio.to(ref_device)
-        return self._vq_audio
-
-    def embed_multimodal(self, **kwargs: Any) -> Any:
-        del kwargs
-        return None
diff --git a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2image.py b/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2image.py
deleted file mode 100644
index 6b5110a77..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2image.py
+++ /dev/null
@@ -1,150 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Any
-
-import torch
-from vllm.config import VllmConfig
-from vllm.logger import init_logger
-from vllm.sequence import IntermediateTensors
-
-from vllm_omni.model_executor.models.output_templates import OmniOutput
-
-from .dynin_omni import DyninOmniStageBase
-from .dynin_omni_common import (
-    DetokTarget,
-    _to_bool,
-    coerce_token_ids_1d,
-    get_dynin_magvit_attr,
-    normalize_runtime_info,
-    resolve_dynin_infer_sources,
-    resolve_hidden_size,
-    unwrap_first_value,
-)
-
-logger = init_logger(__name__)
-
-
-class DyninOmniToken2Image(DyninOmniStageBase):
-    """Stage-2: token detokenization to image (or pass-through)."""
-
-    stage_name = "Dynin token2image"
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        del prefix
-        super().__init__()
-
-        self.vllm_config = vllm_config
-        self.have_multimodal_outputs = True
-        self.requires_raw_input_tokens = True
-        self.hidden_size = resolve_hidden_size(vllm_config=vllm_config)
-        self._vq_model = None
-        self._vq_model_path: str | None = None
-        self._vq_local_files_only: bool | None = None
-
-    def forward(
-        self,
-        input_ids: torch.Tensor | None = None,
-        positions: torch.Tensor | None = None,
-        intermediate_tensors: IntermediateTensors | None = None,
-        inputs_embeds: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> OmniOutput:
-        del positions, intermediate_tensors, inputs_embeds
-        if input_ids is None:
-            raise ValueError("token2image stage requires input_ids")
-        runtime_info = normalize_runtime_info(kwargs.get("runtime_additional_information"))
-        detok_id = int(unwrap_first_value(runtime_info.get("detok_id"), 0))
-        tokens = coerce_token_ids_1d(input_ids)
-
-        if detok_id != DetokTarget.IMAGE:
-            return OmniOutput(
-                text_hidden_states=None,
-                multimodal_outputs={
-                    "token_ids": tokens,
-                    "detok_id": torch.tensor([detok_id], dtype=torch.long, device=tokens.device),
-                },
-            )
-
-        image = self._decode_image_tokens(tokens, runtime_info=runtime_info)
-        return OmniOutput(
-            text_hidden_states=None,
-            multimodal_outputs={
-                "image": image,
-                "detok_id": torch.tensor([detok_id], dtype=torch.long, device=image.device),
-            },
-        )
-
-    def _decode_image_tokens(self, tokens: torch.Tensor, runtime_info: dict[str, Any]) -> torch.Tensor:
-        # Follow DYNIN validation path:
-        #   tokens -> clamp -> vq_model.decode_code -> (x+1)/2 -> [0,1].
-        vq_model = self._ensure_vq_model(runtime_info=runtime_info, ref_device=tokens.device)
-        codebook_size = int(unwrap_first_value(runtime_info.get("codebook_size"), 8192))
-        image_vocab_offset = unwrap_first_value(runtime_info.get("image_vocab_offset"), None)
-        if image_vocab_offset is None:
-            text_vocab_size = unwrap_first_value(runtime_info.get("text_vocab_size"), None)
-            num_new_special_tokens = int(unwrap_first_value(runtime_info.get("num_new_special_tokens"), 0))
-            if text_vocab_size is not None:
-                image_vocab_offset = int(text_vocab_size) + num_new_special_tokens
-
-        token_ids = tokens.to(torch.long)
-        if image_vocab_offset is not None:
-            off = int(image_vocab_offset)
-            token_ids = torch.where(token_ids >= off, token_ids - off, token_ids)
-        token_ids = torch.clamp(token_ids, min=0, max=max(0, codebook_size - 1))
-        token_ids = token_ids.unsqueeze(0)
-
-        decoded = vq_model.decode_code(token_ids)
-        decoded = torch.clamp((decoded + 1.0) / 2.0, min=0.0, max=1.0)
-        if decoded.ndim != 4 or decoded.shape[0] == 0:
-            raise RuntimeError(f"Unexpected MAGVIT decode output shape: {tuple(decoded.shape)}")
-        return decoded[0].contiguous()
-
-    def _ensure_vq_model(self, runtime_info: dict[str, Any], ref_device: torch.device) -> Any:
-        sources = resolve_dynin_infer_sources(vllm_config=self.vllm_config, runtime_info=runtime_info)
-        model_path = str(sources.vq_image_source)
-        local_files_only = bool(sources.vq_image_local_files_only)
-        if self._vq_model is None or self._vq_model_path != model_path or self._vq_local_files_only != local_files_only:
-            disable_xet = unwrap_first_value(
-                runtime_info.get("hf_hub_disable_xet"),
-                unwrap_first_value(runtime_info.get("disable_hf_xet"), True),
-            )
-            if _to_bool(disable_xet, default=True):
-                os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
-            logger.info(
-                "Loading DYNIN image detokenizer from %s (local_files_only=%s)",
-                model_path,
-                local_files_only,
-            )
-            try:
-                MAGVITv2 = get_dynin_magvit_attr(
-                    "MAGVITv2",
-                    source=model_path,
-                    local_files_only=local_files_only,
-                )
-                try:
-                    self._vq_model = MAGVITv2.from_pretrained(
-                        model_path,
-                        local_files_only=local_files_only,
-                    )
-                except TypeError:
-                    self._vq_model = MAGVITv2.from_pretrained(model_path)
-            except Exception as e:
-                raise RuntimeError(
-                    "Failed to load MAGVITv2 from local DYNIN submodel implementation "
-                    f"for model path '{model_path}'. "
-                    "If your environment cannot access huggingface.co, set "
-                    "additional_information.vq_model_image_path to a local MAGVITv2 directory "
-                    "and set additional_information.vq_model_image_local_files_only=true."
-                ) from e
-            self._vq_model.eval()
-            self._vq_model.requires_grad_(False)
-            self._vq_model_path = model_path
-            self._vq_local_files_only = local_files_only
-        if hasattr(self._vq_model, "to"):
-            self._vq_model = self._vq_model.to(ref_device)
-        return self._vq_model
-
-    def embed_multimodal(self, **kwargs: Any) -> Any:
-        del kwargs
-        return None
diff --git a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2text.py b/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2text.py
deleted file mode 100644
index 38caa84f7..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/dynin_omni_token2text.py
+++ /dev/null
@@ -1,1640 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import json
-from contextlib import contextmanager
-from typing import Any
-
-import torch
-import torch.nn.functional as F
-from transformers import AutoTokenizer
-from vllm.config import VllmConfig
-from vllm.logger import init_logger
-from vllm.sequence import IntermediateTensors
-
-from vllm_omni.model_executor.models.output_templates import OmniOutput
-
-from .dynin_omni import DyninOmniStageBase
-from .dynin_omni_common import (
-    DYNIN_PROMPT_SOURCE_KEY,
-    DYNIN_PROMPT_SOURCE_OFFLINE_PREBUILT,
-    DYNIN_REMOTE_SETTINGS,
-    DYNIN_SPECIAL_TOKENS,
-    TASK_TO_DETOK,
-    DetokTarget,
-    _to_bool,
-    build_dynin_online_runtime_info,
-    build_dynin_prompt_payload,
-    coerce_token_ids_1d,
-    dynin_runtime_fallback,
-    get_dynin_magvit_attr,
-    get_dynin_modeling_attr,
-    get_dynin_sampling_attr,
-    infer_dynin_online_task,
-    logical_dynin_task,
-    normalize_dynin_online_prompt_text,
-    normalize_runtime_info,
-    resolve_dynin_infer_sources,
-    resolve_hidden_size,
-    resolve_remote_attr,
-    unwrap_first_value,
-)
-
-logger = init_logger(__name__)
-
-TASK_TO_PROMPTING_TASK = {
-    "t2i": "t2i_gen",
-    "i2i": "i2i_gen",
-    "ti2ti": "ti2ti_gen",
-    "t2s": "t2s_gen",
-    "t2s_mmu_like": "t2s_gen",
-    "t2s_fixed": "t2s_fixed_gen",
-    "s2s": "s2s_gen",
-    "v2s": "v2s_gen",
-    "mmu": "mmu",
-    "mmu_fast": "mmu",
-    "mmu_fastdllm_v1": "mmu",
-    "s2t": "s2t",
-    "v2t": "v2t",
-}
-
-TASK_TO_GENERATE_FN = {
-    "t2i": "t2i_generate",
-    "i2i": "i2i_generate",
-    "ti2ti": "ti2ti_generate",
-    "t2s": "t2s_generate",
-    "t2s_mmu_like": "t2s_generate_mmu_like",
-    "t2s_fixed": "t2s_fixed_generate",
-    "s2s": "t2s_generate_mmu_like",
-    "v2s": "t2s_generate_mmu_like",
-    "s2t": "s2t_generate",
-    "mmu": "mmu_generate",
-    "t2t": "generate",
-    "mmu_fast": "mmu_generate_fast",
-    "mmu_fastdllm_v1": "mmu_generate_fastdllm_v1",
-    "v2t": "mmu_generate",
-}
-
-TASKS_USING_UNI_PROMPTING = set(TASK_TO_PROMPTING_TASK.keys())
-PROMPT_PAYLOAD_REQUIRED_TASKS = {
-    "t2i",
-    "i2i",
-    "ti2ti",
-    "t2s",
-    "t2s_mmu_like",
-    "t2s_fixed",
-    "s2s",
-    "v2s",
-}
-
-GENERATE_RUNTIME_KWARG_KEYS = (
-    "uncond_input_ids",
-    "uncond_attention_mask",
-    "noise_schedule",
-    "generator",
-    "config",
-    "uni_prompting",
-    "resolution",
-    "max_new_tokens",
-    "steps",
-    "block_length",
-    "temperature",
-    "top_k",
-    "eot_token",
-    "cfg_scale",
-    "remasking",
-    "mask_id",
-    "attention_mask",
-    "timesteps",
-    "guidance_scale",
-    "noise_type",
-    "seq_len",
-    "mask_token_id",
-    "codebook_size",
-    "audio_codebook_size",
-    "use_cache",
-    "threshold",
-    "factor",
-)
-
-PASSTHROUGH_GENERATE_KWARG_KEYS = (
-    "attention_mask",
-    "uncond_input_ids",
-    "uncond_attention_mask",
-    "noise_schedule",
-    "uni_prompting",
-    "generator",
-    "noise_type",
-)
-
-PROMPTING_PAYLOAD_KEYS = (
-    "prompting_input",
-    "prompting_inputs",
-    "dynin_inputs",
-    "model_inputs",
-    "raw_inputs",
-)
-
-UNCOND_PROMPTING_PAYLOAD_KEYS = (
-    "uncond_prompting_input",
-    "uncond_prompting_inputs",
-)
-
-PROMPTING_META_KEYS = (
-    "uncond_prompting_input",
-    "uncond_prompting_inputs",
-    "uni_prompting",
-    "prompting_task",
-    "prompting_config",
-)
-
-MM_INPUT_ALIASES = {
-    "image": ("pixel_values", "image_embeds", "img2img"),
-    "video": ("pixel_values_videos", "video_embeds"),
-    "audio": ("input_audio_features", "audio_embeds"),
-}
-
-
-class DyninOmniToken2Text(DyninOmniStageBase):
-    """Stage-1: DYNIN generation + text detokenization or pass-through."""
-
-    stage_name = "Dynin token2text"
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        del prefix
-        super().__init__()
-
-        self.vllm_config = vllm_config
-        self.have_multimodal_outputs = True
-        self.requires_raw_input_tokens = True
-
-        self._infer_sources = resolve_dynin_infer_sources(vllm_config=vllm_config)
-        if self._infer_sources.config_path:
-            logger.info(
-                "DYNIN token2text using inference config: %s",
-                self._infer_sources.config_path,
-            )
-
-        self.model = self._load_text_model(
-            self._infer_sources.model_source,
-            local_files_only=self._infer_sources.model_local_files_only,
-        )
-        self.model.eval()
-        self.model.requires_grad_(False)
-
-        self.hidden_size = resolve_hidden_size(
-            vllm_config=vllm_config,
-            model=self.model,
-        )
-
-        self.tokenizer: Any | None = None
-        self._tokenizer_path: str | None = None
-        self._uni_prompting: Any | None = None
-        self._uni_prompting_init_spec: tuple[Any, ...] | None = None
-        self._prompt_vq_model: Any | None = None
-        self._prompt_vq_model_path: str | None = None
-        self._prompt_vq_local_files_only: bool | None = None
-        self._cached_mm_inputs: dict[str, Any] = {}
-
-        try:
-            self._set_tokenizer(
-                self._infer_sources.tokenizer_source,
-                local_files_only=self._infer_sources.model_local_files_only,
-            )
-        except Exception:
-            self.tokenizer = None
-            self._tokenizer_path = None
-
-    @staticmethod
-    def _load_text_model(model_path: str, *, local_files_only: bool = False) -> Any:
-        try:
-            dynin_model_cls = get_dynin_modeling_attr("DyninOmniModelLM")
-            # Remote Dynin `DyninOmniConfig` may omit `use_cache`, but bundled
-            # `modeling_llada.forward` reads `self.config.use_cache` like a
-            # standard HF causal LM config (see kernel warmup / mmu_generate).
-            dynin_config_cls = get_dynin_modeling_attr("DyninOmniConfig")
-            if not getattr(dynin_config_cls, "_dynin_use_cache_shim_applied", False):
-                _orig_cfg_init = dynin_config_cls.__init__
-
-                def _cfg_init_shim(self, *args, **kwargs):
-                    _orig_cfg_init(self, *args, **kwargs)
-                    if not hasattr(self, "use_cache"):
-                        setattr(self, "use_cache", True)
-
-                dynin_config_cls.__init__ = _cfg_init_shim  # type: ignore[method-assign]
-                dynin_config_cls._dynin_use_cache_shim_applied = True
-            # transformers>=5.0 renamed the weight-tying manifest accessor from
-            # `_tied_weights_keys` (a class attribute) to `all_tied_weights_keys`
-            # (a property returning a {module_path: [tied_keys]} mapping) and
-            # invokes it during `from_pretrained -> caching_allocator_warmup
-            # -> get_total_byte_count`. Remote Dynin code pre-dates the rename,
-            # so patch a minimal shim onto the class if it's missing. Keeping
-            # the mapping empty is safe here — the root module has no weight
-            # tying; the real tied-weights (if any) live on nested submodules
-            # that transformers discovers via their own `_tied_weights_keys`.
-            if not hasattr(dynin_model_cls, "all_tied_weights_keys"):
-                dynin_model_cls.all_tied_weights_keys = property(lambda self: {})
-            # transformers>=5.0 also calls `get_total_byte_count` which does
-            # `len(model._tp_plan)`; PreTrainedModel's class default for
-            # `_tp_plan` is `None`, and unless `self.config.base_model_tp_plan`
-            # was populated during __init__ (via `post_init`) the instance
-            # attribute remains None, crashing with
-            # `TypeError: object of type 'NoneType' has no len()`. The remote
-            # Dynin model class bypasses that path, so shim an empty dict at
-            # the class level as a safe fallback (PreTrainedModel sets the
-            # instance attribute when the config actually carries a plan).
-            if getattr(dynin_model_cls, "_tp_plan", None) is None:
-                dynin_model_cls._tp_plan = {}
-            # transformers>=5.0 `_finalize_model_loading` calls
-            # `model.tie_weights(missing_keys=..., recompute_mapping=...)` while
-            # the remote Dynin code still defines `tie_weights(self)` with no
-            # keyword arguments, raising
-            # `TypeError: LLaDAModelLM.tie_weights() got an unexpected keyword
-            # argument 'missing_keys'`. Wrap the method once to silently drop
-            # the new kwargs; the remote implementation is a no-op w.r.t. the
-            # missing-keys bookkeeping transformers would otherwise perform.
-            _orig_tie_weights = dynin_model_cls.tie_weights
-            if not getattr(_orig_tie_weights, "_dynin_accepts_v5_kwargs", False):
-                _tie_sig = inspect.signature(_orig_tie_weights)
-                _tie_accepts_var_kw = any(p.kind is inspect.Parameter.VAR_KEYWORD for p in _tie_sig.parameters.values())
-                _tie_accepts_new_kwargs = _tie_accepts_var_kw or (
-                    "missing_keys" in _tie_sig.parameters and "recompute_mapping" in _tie_sig.parameters
-                )
-                if not _tie_accepts_new_kwargs:
-
-                    def _tie_weights_shim(self, *args, **kwargs):
-                        kwargs.pop("missing_keys", None)
-                        kwargs.pop("recompute_mapping", None)
-                        return _orig_tie_weights(self, *args, **kwargs)
-
-                    _tie_weights_shim._dynin_accepts_v5_kwargs = True  # type: ignore[attr-defined]
-                    dynin_model_cls.tie_weights = _tie_weights_shim
-            try:
-                return dynin_model_cls.from_pretrained(
-                    model_path,
-                    torch_dtype=torch.bfloat16,
-                    local_files_only=local_files_only,
-                )
-            except TypeError:
-                return dynin_model_cls.from_pretrained(
-                    model_path,
-                    torch_dtype=torch.bfloat16,
-                )
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to load DyninOmniModelLM via remote Dynin code for model path '{model_path}'."
-            ) from e
-
-    @staticmethod
-    def _load_tokenizer_from_source(
-        source: str,
-        *,
-        local_files_only: bool = False,
-        trust_remote_code: bool = False,
-    ) -> Any:
-        load_kwargs = {
-            "trust_remote_code": trust_remote_code,
-            "local_files_only": _to_bool(local_files_only, default=False),
-        }
-        try:
-            return AutoTokenizer.from_pretrained(source, **load_kwargs)
-        except TypeError:
-            load_kwargs.pop("local_files_only", None)
-            return AutoTokenizer.from_pretrained(source, **load_kwargs)
-
-    def _set_tokenizer(self, source: str, *, local_files_only: bool) -> None:
-        try:
-            tokenizer = self._load_tokenizer_from_source(
-                source,
-                local_files_only=local_files_only,
-                trust_remote_code=False,
-            )
-        except Exception as e:
-            logger.info(
-                "Falling back to trust_remote_code=True tokenizer loading for %s: %s",
-                source,
-                e,
-            )
-            tokenizer = self._load_tokenizer_from_source(
-                source,
-                local_files_only=local_files_only,
-                trust_remote_code=True,
-            )
-
-        self.tokenizer = tokenizer
-        self._tokenizer_path = source
-        self._reset_uni_prompting_cache()
-
-    def _reset_uni_prompting_cache(self) -> None:
-        self._uni_prompting = None
-        self._uni_prompting_init_spec = None
-
-    def get_language_model(self) -> Any:
-        return self.model
-
-    @staticmethod
-    def _merge_runtime_info_missing_values(
-        runtime_info: dict[str, Any],
-        fallback_info: dict[str, Any],
-    ) -> dict[str, Any]:
-        merged = dict(runtime_info)
-        for key, value in fallback_info.items():
-            if unwrap_first_value(merged.get(key), None) is None:
-                merged[key] = value
-        return merged
-
-    def _runtime_info_needs_bootstrap(
-        self,
-        runtime_info: dict[str, Any],
-        logical_task_name: str,
-    ) -> bool:
-        task = str(unwrap_first_value(runtime_info.get("task"), "") or "").lower()
-        detok_id = unwrap_first_value(runtime_info.get("detok_id"), None)
-        prompt_length = unwrap_first_value(runtime_info.get("prompt_length"), None)
-
-        if not task or detok_id is None:
-            return True
-        if prompt_length is None:
-            return True
-        if (
-            task in PROMPT_PAYLOAD_REQUIRED_TASKS
-            and self._find_first_payload(
-                runtime_info=runtime_info,
-                kwargs={},
-                keys=PROMPTING_PAYLOAD_KEYS,
-            )
-            is None
-        ):
-            return True
-        if logical_task_name in {"t2i", "i2i"}:
-            for key in ("codebook_size", "text_vocab_size", "vq_model_image_path"):
-                if unwrap_first_value(runtime_info.get(key), None) is None:
-                    return True
-        if logical_task_name == "t2s":
-            for key in ("audio_codebook_size", "condition", "vq_model_audio_path"):
-                if unwrap_first_value(runtime_info.get(key), None) is None:
-                    return True
-        return False
-
-    def _decode_prompt_for_bootstrap(
-        self,
-        input_ids: torch.Tensor,
-        runtime_info: dict[str, Any],
-    ) -> str:
-        self._maybe_load_runtime_tokenizer(runtime_info)
-        if self.tokenizer is None:
-            return ""
-        token_ids = coerce_token_ids_1d(input_ids).detach().cpu().tolist()
-        try:
-            return str(self.tokenizer.decode(token_ids, skip_special_tokens=False))
-        except Exception:
-            return ""
-
-    def _bootstrap_runtime_info_if_needed(
-        self,
-        *,
-        input_ids: torch.Tensor,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-    ) -> dict[str, Any]:
-        if unwrap_first_value(runtime_info.get(DYNIN_PROMPT_SOURCE_KEY), None) == DYNIN_PROMPT_SOURCE_OFFLINE_PREBUILT:
-            return runtime_info
-
-        mm_inputs = self._collect_mm_inputs(**kwargs)
-        decoded_prompt = ""
-
-        task_value = unwrap_first_value(runtime_info.get("task"), None)
-        if task_value is None:
-            decoded_prompt = self._decode_prompt_for_bootstrap(input_ids, runtime_info)
-            logical_task_name = infer_dynin_online_task(
-                decoded_prompt=decoded_prompt,
-                has_image="image" in mm_inputs,
-                has_audio="audio" in mm_inputs,
-                has_video="video" in mm_inputs,
-            )
-        else:
-            logical_task_name = logical_dynin_task(task_value)
-
-        if not self._runtime_info_needs_bootstrap(runtime_info, logical_task_name):
-            return runtime_info
-
-        self._maybe_load_runtime_tokenizer(runtime_info)
-        if self.tokenizer is None:
-            logger.warning("Unable to bootstrap Dynin runtime info because tokenizer is unavailable.")
-            return runtime_info
-
-        if not decoded_prompt:
-            decoded_prompt = self._decode_prompt_for_bootstrap(input_ids, runtime_info)
-
-        text_vocab_size = int(len(self.tokenizer))
-        prompt_len = int(coerce_token_ids_1d(input_ids).numel())
-        dynin_config_path = self._infer_sources.config_path
-
-        base_runtime_info = build_dynin_online_runtime_info(
-            task=logical_task_name,
-            text_vocab_size=text_vocab_size,
-            infer_sources=self._infer_sources,
-            dynin_config_path=dynin_config_path,
-            attention_mask=([1] * prompt_len) if logical_task_name == "t2t" else None,
-            prompt_length=prompt_len if logical_task_name == "t2t" else None,
-        )
-        merged_runtime_info = self._merge_runtime_info_missing_values(runtime_info, base_runtime_info)
-
-        payload_required = logical_task_name in {"t2i", "i2i", "t2s"}
-        existing_prompt_payload = self._find_first_payload(
-            runtime_info=merged_runtime_info,
-            kwargs=kwargs,
-            keys=PROMPTING_PAYLOAD_KEYS,
-        )
-        has_prompt_payload = existing_prompt_payload is not None
-        needs_prompt_length = unwrap_first_value(merged_runtime_info.get("prompt_length"), None) is None
-        if not payload_required:
-            return merged_runtime_info
-
-        use_train_i2i_prompt = _to_bool(
-            unwrap_first_value(
-                merged_runtime_info.get("use_train_i2i_prompt"),
-                dynin_runtime_fallback(logical_task_name, "use_train_i2i_prompt", logical_task_name == "i2i"),
-            ),
-            default=logical_task_name == "i2i",
-        )
-        t2s_token_length = int(
-            dynin_runtime_fallback(
-                logical_task_name,
-                "t2s_token_length",
-                unwrap_first_value(merged_runtime_info.get("t2s_token_length"), None),
-            )
-            or 383
-        )
-        image_resolution = int(
-            dynin_runtime_fallback(
-                logical_task_name,
-                "image_resolution",
-                unwrap_first_value(merged_runtime_info.get("image_resolution"), None),
-            )
-            or 336
-        )
-
-        image_token_count = int(
-            dynin_runtime_fallback(
-                logical_task_name,
-                "image_token_count",
-                unwrap_first_value(merged_runtime_info.get("seq_len"), None),
-            )
-            or 0
-        )
-        image_tokens: torch.Tensor | None = None
-        if logical_task_name == "i2i" and (not has_prompt_payload or image_token_count <= 0):
-            image_tokens = self._encode_prompt_image_tokens(
-                runtime_info=merged_runtime_info,
-                mm_inputs=mm_inputs,
-                resolution=image_resolution,
-            )
-            image_token_count = int(image_tokens.numel())
-
-        mask_token_id = int(unwrap_first_value(merged_runtime_info.get("mask_token_id"), 126336))
-        prompting_input = self._unwrap_singleton(existing_prompt_payload)
-        prompting_task = str(
-            unwrap_first_value(
-                merged_runtime_info.get("prompting_task"),
-                TASK_TO_PROMPTING_TASK.get(
-                    str(unwrap_first_value(merged_runtime_info.get("task"), "mmu")).lower(),
-                    "mmu",
-                ),
-            )
-        )
-        if not has_prompt_payload:
-            prompt_text = normalize_dynin_online_prompt_text(logical_task_name, decoded_prompt)
-            prompting_input, prompting_task = build_dynin_prompt_payload(
-                task=logical_task_name,
-                text=prompt_text,
-                image_tokens=image_tokens,
-                image_placeholder_tokens=image_token_count,
-                audio_placeholder_tokens=t2s_token_length,
-                image_token_offset=text_vocab_size,
-                mask_token_id=mask_token_id,
-                use_train_i2i_prompt=use_train_i2i_prompt,
-            )
-
-        prompt_runtime_info = build_dynin_online_runtime_info(
-            task=logical_task_name,
-            text_vocab_size=text_vocab_size,
-            infer_sources=self._infer_sources,
-            dynin_config_path=dynin_config_path,
-            image_token_count=image_token_count,
-            t2s_token_length=t2s_token_length,
-            use_train_i2i_prompt=use_train_i2i_prompt,
-        )
-        prompt_runtime_info["prompting_task"] = [str(prompting_task)]
-        prompt_runtime_info["prompting_input"] = [prompting_input]
-        merged_runtime_info = self._merge_runtime_info_missing_values(merged_runtime_info, prompt_runtime_info)
-
-        if not needs_prompt_length and has_prompt_payload:
-            return merged_runtime_info
-
-        uni_prompting = self._get_or_create_uni_prompting(
-            runtime_info=merged_runtime_info,
-            kwargs=kwargs,
-        )
-        if uni_prompting is not None:
-            prepared_input_ids, prepared_attention_mask = self._prepare_prompting_input(
-                payload=prompting_input,
-                task=str(unwrap_first_value(merged_runtime_info.get("task"), "mmu")),
-                runtime_info=merged_runtime_info,
-                kwargs=kwargs,
-                uni_prompting=uni_prompting,
-                ref_device=input_ids.device,
-            )
-            if prepared_input_ids is not None:
-                prepared_prompt_len = int(prepared_input_ids.shape[-1])
-                prepared_attention_list: list[int] | None = None
-                if prepared_attention_mask is not None:
-                    prepared_attention_list = prepared_attention_mask.view(-1).detach().cpu().tolist()
-                final_runtime_info = build_dynin_online_runtime_info(
-                    task=logical_task_name,
-                    text_vocab_size=text_vocab_size,
-                    infer_sources=self._infer_sources,
-                    dynin_config_path=dynin_config_path,
-                    prompting_input=prompting_input,
-                    attention_mask=prepared_attention_list,
-                    prompt_length=prepared_prompt_len,
-                    image_token_count=image_token_count,
-                    t2s_token_length=t2s_token_length,
-                    use_train_i2i_prompt=use_train_i2i_prompt,
-                )
-                final_runtime_info["prompting_task"] = [str(prompting_task)]
-
-                guidance_scale = float(unwrap_first_value(merged_runtime_info.get("guidance_scale"), 0.0))
-                if logical_task_name in {"t2i", "i2i"} and guidance_scale > 0:
-                    uncond_prompting_input, _ = build_dynin_prompt_payload(
-                        task=logical_task_name,
-                        text="",
-                        image_tokens=image_tokens,
-                        image_placeholder_tokens=image_token_count,
-                        audio_placeholder_tokens=t2s_token_length,
-                        image_token_offset=text_vocab_size,
-                        mask_token_id=mask_token_id,
-                        use_train_i2i_prompt=use_train_i2i_prompt,
-                    )
-                    final_runtime_info["uncond_prompting_input"] = [uncond_prompting_input]
-
-                merged_runtime_info = self._merge_runtime_info_missing_values(
-                    merged_runtime_info,
-                    final_runtime_info,
-                )
-
-        return merged_runtime_info
-
-    @staticmethod
-    def _build_downstream_runtime_info(runtime_info: dict[str, Any]) -> dict[str, Any]:
-        bridge_keys = (
-            "task",
-            "detok_id",
-            "dynin_config_path",
-            "codebook_size",
-            "audio_codebook_size",
-            "text_vocab_size",
-            "num_new_special_tokens",
-            "image_vocab_offset",
-            "audio_vocab_offset",
-            "t2s_vocab_start",
-            "condition",
-            "t2s_condition",
-            "vq_model_image_path",
-            "vq_model_image_local_files_only",
-            "vq_model_audio_path",
-            "vq_model_audio_local_files_only",
-            "model_local_files_only",
-            "local_files_only",
-            "hf_hub_disable_xet",
-            "disable_hf_xet",
-        )
-        return {key: runtime_info[key] for key in bridge_keys if key in runtime_info}
-
-    @staticmethod
-    def _jsonify_runtime_value(value: Any) -> Any:
-        if isinstance(value, torch.Tensor):
-            return value.detach().cpu().tolist()
-        if isinstance(value, (list, tuple)):
-            return [DyninOmniToken2Text._jsonify_runtime_value(item) for item in value]
-        if isinstance(value, dict):
-            return {str(key): DyninOmniToken2Text._jsonify_runtime_value(val) for key, val in value.items()}
-        if isinstance(value, (str, int, float, bool)) or value is None:
-            return value
-        return str(value)
-
-    def _encode_runtime_info_tensor(
-        self,
-        runtime_info: dict[str, Any],
-        *,
-        device: torch.device,
-    ) -> torch.Tensor | None:
-        if not runtime_info:
-            return None
-        payload = {key: self._jsonify_runtime_value(value) for key, value in runtime_info.items()}
-        encoded = json.dumps(
-            payload,
-            ensure_ascii=False,
-            separators=(",", ":"),
-            sort_keys=True,
-        ).encode("utf-8")
-        if not encoded:
-            return None
-        return torch.tensor(list(encoded), dtype=torch.uint8, device=device)
-
-    def forward(
-        self,
-        input_ids: torch.Tensor | None = None,
-        positions: torch.Tensor | None = None,
-        intermediate_tensors: IntermediateTensors | None = None,
-        inputs_embeds: torch.Tensor | None = None,
-        **kwargs: Any,
-    ) -> OmniOutput:
-        del positions, intermediate_tensors, inputs_embeds
-
-        if input_ids is None:
-            raise ValueError("token2text stage requires input_ids")
-        try:
-            runtime_info = normalize_runtime_info(kwargs.get("runtime_additional_information"))
-            runtime_info = self._bootstrap_runtime_info_if_needed(
-                input_ids=input_ids,
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-            )
-            task = str(unwrap_first_value(runtime_info.get("task"), "mmu")).lower()
-
-            detok_id = int(
-                unwrap_first_value(
-                    runtime_info.get("detok_id"),
-                    TASK_TO_DETOK.get(task, DetokTarget.TEXT),
-                )
-            )
-
-            token_ids = self._generate_token_ids(
-                task=task,
-                input_ids=input_ids,
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-            )
-            bridge_runtime_info = self._build_downstream_runtime_info(runtime_info)
-            runtime_info_tensor = self._encode_runtime_info_tensor(
-                bridge_runtime_info,
-                device=token_ids.device,
-            )
-
-            if detok_id != int(DetokTarget.TEXT):
-                multimodal_outputs = {
-                    "token_ids": token_ids,
-                    "detok_id": torch.tensor(
-                        [detok_id],
-                        dtype=torch.long,
-                        device=token_ids.device,
-                    ),
-                }
-                if runtime_info_tensor is not None:
-                    multimodal_outputs["runtime_info_json"] = runtime_info_tensor
-                return OmniOutput(
-                    text_hidden_states=None,
-                    multimodal_outputs=multimodal_outputs,
-                )
-
-            decode_tokens = self._extract_decode_tokens(token_ids, runtime_info=runtime_info)
-            multimodal_outputs = {
-                "token_ids": token_ids,
-                "text_tokens": decode_tokens,
-                "detok_id": torch.tensor(
-                    [detok_id],
-                    dtype=torch.long,
-                    device=token_ids.device,
-                ),
-            }
-            if runtime_info_tensor is not None:
-                multimodal_outputs["runtime_info_json"] = runtime_info_tensor
-
-            return OmniOutput(
-                text_hidden_states=None,
-                multimodal_outputs=multimodal_outputs,
-            )
-        finally:
-            self._cached_mm_inputs = {}
-
-    def _generate_token_ids(
-        self,
-        task: str,
-        input_ids: torch.Tensor,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-    ) -> torch.Tensor:
-        precomputed = self._get_precomputed_token_ids(runtime_info)
-        if precomputed is not None:
-            return coerce_token_ids_1d(precomputed, ref_device=input_ids.device)
-
-        gen_fn_name = TASK_TO_GENERATE_FN.get(task, "mmu_generate")
-        gen_fn = self._resolve_generate_fn(gen_fn_name)
-
-        gen_kwargs = self._collect_generate_kwargs(runtime_info=runtime_info, kwargs=kwargs)
-
-        if "noise_schedule" not in gen_kwargs:
-            noise_schedule = self._resolve_noise_schedule(
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-            )
-            if noise_schedule is not None:
-                gen_kwargs["noise_schedule"] = noise_schedule
-
-        if task in TASKS_USING_UNI_PROMPTING and "uni_prompting" not in gen_kwargs:
-            uni_prompting = self._get_or_create_uni_prompting(
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-            )
-            if uni_prompting is not None:
-                gen_kwargs["uni_prompting"] = uni_prompting
-
-        should_prepare_prompting_inputs = task in TASKS_USING_UNI_PROMPTING or self._contains_prompting_payload(
-            runtime_info=runtime_info, kwargs=kwargs
-        )
-        if should_prepare_prompting_inputs:
-            input_ids, gen_kwargs = self._prepare_prompting_inputs_if_needed(
-                task=task,
-                input_ids=input_ids,
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-                gen_kwargs=gen_kwargs,
-            )
-
-        input_ids, gen_kwargs = self._normalize_generate_inputs(
-            input_ids=input_ids,
-            gen_kwargs=gen_kwargs,
-            ref_device=input_ids.device,
-        )
-        gen_kwargs = self._filter_supported_generate_kwargs(
-            gen_fn=gen_fn,
-            gen_kwargs=gen_kwargs,
-            fn_name=gen_fn_name,
-        )
-
-        generated = self._call_generate_fn(
-            gen_fn=gen_fn,
-            input_ids=input_ids,
-            gen_kwargs=gen_kwargs,
-        )
-        return coerce_token_ids_1d(generated, ref_device=input_ids.device)
-
-    @staticmethod
-    def _get_precomputed_token_ids(runtime_info: dict[str, Any]) -> Any | None:
-        precomputed = runtime_info.get("generated_token_ids")
-        if precomputed is None:
-            precomputed = runtime_info.get("token_ids")
-        return precomputed
-
-    def _resolve_generate_fn(self, fn_name: str) -> Any:
-        if not hasattr(self.model, fn_name):
-            raise RuntimeError(
-                f"DYNIN model does not expose '{fn_name}'. "
-                "Pass additional_information.generated_token_ids or adjust task mapping."
-            )
-        return getattr(self.model, fn_name)
-
-    @staticmethod
-    def _collect_generate_kwargs(
-        *,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-    ) -> dict[str, Any]:
-        gen_kwargs: dict[str, Any] = {}
-
-        for key in GENERATE_RUNTIME_KWARG_KEYS:
-            if key in runtime_info:
-                gen_kwargs[key] = unwrap_first_value(runtime_info[key])
-
-        for key in PASSTHROUGH_GENERATE_KWARG_KEYS:
-            if key not in gen_kwargs and key in kwargs:
-                gen_kwargs[key] = kwargs[key]
-
-        return gen_kwargs
-
-    @staticmethod
-    def _contains_prompting_payload(
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-    ) -> bool:
-        keys = PROMPTING_PAYLOAD_KEYS + PROMPTING_META_KEYS
-        return any(key in runtime_info for key in keys) or any(key in kwargs for key in keys)
-
-    @staticmethod
-    def _filter_supported_generate_kwargs(
-        *,
-        gen_fn: Any,
-        gen_kwargs: dict[str, Any],
-        fn_name: str,
-    ) -> dict[str, Any]:
-        if not gen_kwargs:
-            return gen_kwargs
-
-        try:
-            signature = inspect.signature(gen_fn)
-        except (TypeError, ValueError):
-            return gen_kwargs
-
-        params = signature.parameters
-        accepts_var_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values())
-        if accepts_var_kwargs:
-            return gen_kwargs
-
-        allowed_keys = {
-            name
-            for name, param in params.items()
-            if param.kind
-            in (
-                inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                inspect.Parameter.KEYWORD_ONLY,
-            )
-        }
-        filtered = {k: v for k, v in gen_kwargs.items() if k in allowed_keys}
-
-        removed_keys = sorted(set(gen_kwargs.keys()) - set(filtered.keys()))
-        if removed_keys:
-            logger.debug("Filtered unsupported kwargs for %s: %s", fn_name, removed_keys)
-
-        return filtered
-
-    @staticmethod
-    def _call_generate_fn(
-        *,
-        gen_fn: Any,
-        input_ids: torch.Tensor,
-        gen_kwargs: dict[str, Any],
-    ) -> Any:
-        try:
-            signature = inspect.signature(gen_fn)
-            params = signature.parameters
-        except (TypeError, ValueError):
-            params = {}
-
-        if "idx" in params:
-            return gen_fn(idx=input_ids, **gen_kwargs)
-        if "input_ids" in params:
-            return gen_fn(input_ids=input_ids, **gen_kwargs)
-
-        try:
-            return gen_fn(input_ids, **gen_kwargs)
-        except TypeError:
-            try:
-                return gen_fn(idx=input_ids, **gen_kwargs)
-            except TypeError:
-                return gen_fn(input_ids=input_ids, **gen_kwargs)
-
-    def _normalize_generate_inputs(
-        self,
-        *,
-        input_ids: torch.Tensor,
-        gen_kwargs: dict[str, Any],
-        ref_device: torch.device,
-    ) -> tuple[torch.Tensor, dict[str, Any]]:
-        normalized_input_ids = self._coerce_long_tensor_2d(input_ids, ref_device)
-        if normalized_input_ids is None:
-            normalized_input_ids = input_ids
-
-        normalized_kwargs = dict(gen_kwargs)
-        for key in ("attention_mask", "uncond_input_ids", "uncond_attention_mask"):
-            if key not in normalized_kwargs:
-                continue
-            normalized_value = self._coerce_long_tensor_2d(
-                normalized_kwargs[key],
-                ref_device,
-            )
-            if normalized_value is not None:
-                normalized_kwargs[key] = normalized_value
-
-        return normalized_input_ids, normalized_kwargs
-
-    def _get_or_create_uni_prompting(
-        self,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-    ) -> Any | None:
-        runtime_uni_prompting = runtime_info.get("uni_prompting")
-        if runtime_uni_prompting is not None:
-            runtime_uni_prompting = self._unwrap_singleton(runtime_uni_prompting)
-            if runtime_uni_prompting is not None:
-                return runtime_uni_prompting
-
-        kwargs_uni_prompting = self._unwrap_singleton(kwargs.get("uni_prompting"))
-        if kwargs_uni_prompting is not None:
-            return kwargs_uni_prompting
-
-        self._maybe_load_runtime_tokenizer(runtime_info)
-        if self.tokenizer is None:
-            return None
-
-        use_reserved_token = _to_bool(
-            unwrap_first_value(
-                runtime_info.get("use_reserved_token"),
-                unwrap_first_value(runtime_info.get("prompting_use_reserved_token"), True),
-            ),
-            default=True,
-        )
-
-        max_text_len_value = unwrap_first_value(
-            runtime_info.get("prompt_max_text_len"),
-            unwrap_first_value(
-                runtime_info.get("prompting_max_text_len"),
-                unwrap_first_value(runtime_info.get("max_text_len"), None),
-            ),
-        )
-        cond_dropout_value = unwrap_first_value(
-            runtime_info.get("cond_dropout_prob"),
-            unwrap_first_value(runtime_info.get("prompting_cond_dropout_prob"), None),
-        )
-        max_audio_len_value = unwrap_first_value(
-            runtime_info.get("max_audio_len"),
-            unwrap_first_value(runtime_info.get("t2s_token_length"), None),
-        )
-        max_audio_len_short_value = unwrap_first_value(
-            runtime_info.get("max_audio_len_short"),
-            None,
-        )
-
-        max_text_len: int | None = None
-        if max_text_len_value is not None:
-            try:
-                parsed = int(max_text_len_value)
-                if parsed > 0:
-                    max_text_len = parsed
-            except Exception:
-                pass
-
-        cond_dropout_prob: float | None = None
-        if cond_dropout_value is not None:
-            try:
-                cond_dropout_prob = float(cond_dropout_value)
-            except Exception:
-                pass
-
-        max_audio_len: int | None = None
-        if max_audio_len_value is not None:
-            try:
-                parsed = int(max_audio_len_value)
-                if parsed > 0:
-                    max_audio_len = max(parsed, 512)
-            except Exception:
-                pass
-
-        max_audio_len_short: int | None = None
-        if max_audio_len_short_value is not None:
-            try:
-                parsed = int(max_audio_len_short_value)
-                if parsed > 0:
-                    max_audio_len_short = parsed
-            except Exception:
-                pass
-        elif max_audio_len is not None:
-            max_audio_len_short = max(256, max_audio_len // 2)
-
-        if self._uni_prompting is not None:
-            if max_text_len is None and hasattr(self._uni_prompting, "max_text_len"):
-                try:
-                    existing_max_text_len = int(getattr(self._uni_prompting, "max_text_len"))
-                    if existing_max_text_len > 0:
-                        max_text_len = existing_max_text_len - 1
-                except Exception:
-                    pass
-            if cond_dropout_prob is None and hasattr(self._uni_prompting, "cond_dropout_prob"):
-                try:
-                    cond_dropout_prob = float(getattr(self._uni_prompting, "cond_dropout_prob"))
-                except Exception:
-                    pass
-
-        desired_spec = (
-            id(self.tokenizer),
-            use_reserved_token,
-            max_text_len,
-            cond_dropout_prob,
-            max_audio_len,
-            max_audio_len_short,
-        )
-
-        if self._uni_prompting is not None and self._uni_prompting_init_spec != desired_spec:
-            self._reset_uni_prompting_cache()
-
-        if self._uni_prompting is None:
-            try:
-                universal_prompting_cls = resolve_remote_attr(
-                    "UniversalPrompting",
-                    module_name="prompting_utils",
-                    settings=DYNIN_REMOTE_SETTINGS,
-                    source=self._infer_sources.model_source,
-                    local_files_only=self._infer_sources.model_local_files_only,
-                    fallback_module_names=("modeling_dynin_omni",),
-                    optional=True,
-                )
-            except Exception:
-                universal_prompting_cls = None
-
-            try:
-                if universal_prompting_cls is None:
-                    raise ImportError("UniversalPrompting is not available in the configured remote Dynin code.")
-
-                init_kwargs: dict[str, Any] = {
-                    "use_reserved_token": use_reserved_token,
-                    "special_tokens": DYNIN_SPECIAL_TOKENS,
-                    "ignore_id": -100,
-                }
-                if max_text_len is not None:
-                    init_kwargs["max_text_len"] = max_text_len
-                if cond_dropout_prob is not None:
-                    init_kwargs["cond_dropout_prob"] = cond_dropout_prob
-                if max_audio_len is not None:
-                    init_kwargs["max_audio_len"] = max_audio_len
-                if max_audio_len_short is not None:
-                    init_kwargs["max_audio_len_short"] = max_audio_len_short
-
-                try:
-                    self._uni_prompting = universal_prompting_cls(self.tokenizer, **init_kwargs)
-                except TypeError:
-                    trimmed_audio_kwargs = dict(init_kwargs)
-                    trimmed_audio_kwargs.pop("max_audio_len", None)
-                    trimmed_audio_kwargs.pop("max_audio_len_short", None)
-                    try:
-                        self._uni_prompting = universal_prompting_cls(self.tokenizer, **trimmed_audio_kwargs)
-                    except TypeError:
-                        minimal_kwargs = dict(trimmed_audio_kwargs)
-                        minimal_kwargs.pop("special_tokens", None)
-                        minimal_kwargs.pop("ignore_id", None)
-                        self._uni_prompting = universal_prompting_cls(self.tokenizer, **minimal_kwargs)
-                self._uni_prompting_init_spec = desired_spec
-            except Exception as e:
-                logger.warning("Failed to initialize UniversalPrompting: %s", e)
-                self._reset_uni_prompting_cache()
-
-        return self._uni_prompting
-
-    @staticmethod
-    def _unwrap_singleton(value: Any) -> Any:
-        if isinstance(value, list) and len(value) == 1:
-            return value[0]
-        return value
-
-    @classmethod
-    def _coerce_schedule_params(cls, value: Any) -> dict[str, Any]:
-        value = cls._unwrap_singleton(value)
-        if value is None:
-            return {}
-        if isinstance(value, dict):
-            return {str(k): v for k, v in value.items()}
-        if hasattr(value, "items"):
-            try:
-                return {str(k): v for k, v in dict(value).items()}
-            except Exception:
-                return {}
-        if isinstance(value, str):
-            text = value.strip()
-            if not text:
-                return {}
-            try:
-                parsed = json.loads(text)
-            except Exception:
-                return {}
-            if isinstance(parsed, dict):
-                return {str(k): v for k, v in parsed.items()}
-        return {}
-
-    def _resolve_noise_schedule(
-        self,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-    ) -> Any | None:
-        runtime_noise_schedule = unwrap_first_value(
-            runtime_info.get("noise_schedule"),
-            kwargs.get("noise_schedule"),
-        )
-        runtime_noise_schedule = self._unwrap_singleton(runtime_noise_schedule)
-        if callable(runtime_noise_schedule):
-            return runtime_noise_schedule
-
-        schedule_name: str | None = None
-        if isinstance(runtime_noise_schedule, str) and runtime_noise_schedule.strip():
-            schedule_name = runtime_noise_schedule.strip()
-
-        if schedule_name is None:
-            for key in ("noise_schedule_name", "mask_schedule", "schedule"):
-                value = unwrap_first_value(runtime_info.get(key), None)
-                if value is None and key in kwargs:
-                    value = self._unwrap_singleton(kwargs.get(key))
-                if isinstance(value, str) and value.strip():
-                    schedule_name = value.strip()
-                    break
-
-        if schedule_name is None:
-            return None
-
-        schedule_params = self._coerce_schedule_params(
-            unwrap_first_value(
-                runtime_info.get("noise_schedule_params"),
-                kwargs.get("noise_schedule_params"),
-            )
-        )
-
-        try:
-            get_mask_schedule = get_dynin_sampling_attr("get_mask_schedule")
-            return get_mask_schedule(schedule_name, **schedule_params)
-        except Exception as e:
-            logger.warning(
-                "Failed to resolve mask schedule '%s' with params=%s: %s",
-                schedule_name,
-                schedule_params,
-                e,
-            )
-            return None
-
-    @staticmethod
-    def _coerce_long_tensor_2d(
-        value: Any,
-        device: torch.device,
-    ) -> torch.Tensor | None:
-        if value is None:
-            return None
-        out = value if isinstance(value, torch.Tensor) else torch.as_tensor(value)
-        if out.ndim == 1:
-            out = out.unsqueeze(0)
-        if out.ndim > 2:
-            out = out.view(out.shape[0], -1)
-        return out.to(device=device, dtype=torch.long).contiguous()
-
-    @staticmethod
-    def _config_get(config_obj: Any, key: str) -> Any:
-        if config_obj is None:
-            return None
-        if isinstance(config_obj, dict):
-            return config_obj.get(key)
-        if hasattr(config_obj, "get"):
-            try:
-                return config_obj.get(key)
-            except Exception:
-                return None
-        return None
-
-    @classmethod
-    def _is_numeric_token_structure(cls, value: Any) -> bool:
-        if isinstance(value, torch.Tensor):
-            return True
-        if isinstance(value, bool):
-            return True
-        if isinstance(value, int):
-            return True
-        if isinstance(value, float):
-            return float(value).is_integer()
-        if isinstance(value, (list, tuple)):
-            if not value:
-                return False
-            return all(cls._is_numeric_token_structure(v) for v in value)
-        return False
-
-    @classmethod
-    def _materialize_prompting_payload(cls, value: Any, ref_device: torch.device) -> Any:
-        if isinstance(value, torch.Tensor):
-            return value.to(device=ref_device, dtype=torch.long).contiguous()
-        if isinstance(value, dict):
-            return {k: cls._materialize_prompting_payload(v, ref_device) for k, v in value.items()}
-        if isinstance(value, (list, tuple)):
-            if cls._is_numeric_token_structure(value):
-                try:
-                    return torch.as_tensor(value, dtype=torch.long, device=ref_device)
-                except Exception:
-                    pass
-            converted = [cls._materialize_prompting_payload(v, ref_device) for v in value]
-            return tuple(converted) if isinstance(value, tuple) else converted
-        return value
-
-    @contextmanager
-    def _temporary_prompting_overrides(self, uni_prompting: Any, prompting_cfg: Any):
-        restore_values: dict[str, Any] = {}
-        try:
-            max_text_len_override = self._config_get(prompting_cfg, "max_text_len_override")
-            if max_text_len_override is not None and hasattr(uni_prompting, "max_text_len"):
-                try:
-                    override_int = int(max_text_len_override)
-                    if override_int > 0:
-                        restore_values["max_text_len"] = getattr(uni_prompting, "max_text_len")
-                        setattr(uni_prompting, "max_text_len", override_int + 1)
-                except Exception:
-                    pass
-            yield
-        finally:
-            for attr_name, original_value in restore_values.items():
-                try:
-                    setattr(uni_prompting, attr_name, original_value)
-                except Exception:
-                    pass
-
-    def _prepare_prompting_input(
-        self,
-        *,
-        payload: Any,
-        task: str,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-        uni_prompting: Any,
-        ref_device: torch.device,
-    ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
-        if payload is None:
-            return None, None
-
-        payload = self._unwrap_singleton(payload)
-        prompting_task = str(
-            self._unwrap_singleton(
-                unwrap_first_value(
-                    runtime_info.get("prompting_task"),
-                    TASK_TO_PROMPTING_TASK.get(task, task),
-                )
-            )
-        )
-        prompting_cfg = self._unwrap_singleton(
-            unwrap_first_value(
-                runtime_info.get("prompting_config"),
-                kwargs.get("prompting_config"),
-            )
-        )
-
-        if isinstance(payload, dict):
-            if payload.get("task") is not None:
-                prompting_task = str(payload["task"])
-            if payload.get("config") is not None:
-                prompting_cfg = payload["config"]
-            payload = payload.get("input", payload.get("inputs", payload.get("data", payload)))
-
-        payload = self._materialize_prompting_payload(payload, ref_device)
-
-        try:
-            with self._temporary_prompting_overrides(uni_prompting, prompting_cfg):
-                prepared = uni_prompting(payload, prompting_task, config=prompting_cfg)
-        except Exception as e:
-            logger.warning(
-                "UniversalPrompting failed for task=%s prompting_task=%s: %s",
-                task,
-                prompting_task,
-                e,
-            )
-            return None, None
-
-        if isinstance(prepared, tuple):
-            prepared_input_ids = prepared[0] if len(prepared) > 0 else None
-            prepared_attention_mask = prepared[1] if len(prepared) > 1 else None
-        else:
-            prepared_input_ids = prepared
-            prepared_attention_mask = None
-
-        return (
-            self._coerce_long_tensor_2d(prepared_input_ids, ref_device),
-            self._coerce_long_tensor_2d(prepared_attention_mask, ref_device),
-        )
-
-    def _prepare_prompting_inputs_if_needed(
-        self,
-        *,
-        task: str,
-        input_ids: torch.Tensor,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-        gen_kwargs: dict[str, Any],
-    ) -> tuple[torch.Tensor, dict[str, Any]]:
-        uni_prompting = gen_kwargs.get("uni_prompting")
-        if uni_prompting is None:
-            uni_prompting = self._get_or_create_uni_prompting(
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-            )
-            if uni_prompting is not None:
-                gen_kwargs["uni_prompting"] = uni_prompting
-
-        if uni_prompting is None:
-            return input_ids, gen_kwargs
-
-        payload = self._find_first_payload(
-            runtime_info=runtime_info,
-            kwargs=kwargs,
-            keys=PROMPTING_PAYLOAD_KEYS,
-        )
-
-        if payload is not None:
-            prepared_input_ids, prepared_attention_mask = self._prepare_prompting_input(
-                payload=payload,
-                task=task,
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-                uni_prompting=uni_prompting,
-                ref_device=input_ids.device,
-            )
-            if prepared_input_ids is not None:
-                input_ids = prepared_input_ids
-                if prepared_attention_mask is not None and "attention_mask" not in gen_kwargs:
-                    gen_kwargs["attention_mask"] = prepared_attention_mask
-
-        uncond_payload = self._find_first_payload(
-            runtime_info=runtime_info,
-            kwargs=kwargs,
-            keys=UNCOND_PROMPTING_PAYLOAD_KEYS,
-        )
-        if uncond_payload is not None and "uncond_input_ids" not in gen_kwargs:
-            uncond_input_ids, uncond_attention_mask = self._prepare_prompting_input(
-                payload=uncond_payload,
-                task=task,
-                runtime_info=runtime_info,
-                kwargs=kwargs,
-                uni_prompting=uni_prompting,
-                ref_device=input_ids.device,
-            )
-            if uncond_input_ids is not None:
-                gen_kwargs["uncond_input_ids"] = uncond_input_ids
-            if uncond_attention_mask is not None and "uncond_attention_mask" not in gen_kwargs:
-                gen_kwargs["uncond_attention_mask"] = uncond_attention_mask
-
-        return input_ids, gen_kwargs
-
-    @staticmethod
-    def _find_first_payload(
-        *,
-        runtime_info: dict[str, Any],
-        kwargs: dict[str, Any],
-        keys: tuple[str, ...],
-    ) -> Any | None:
-        for key in keys:
-            if key in runtime_info:
-                return runtime_info[key]
-            if key in kwargs:
-                return kwargs[key]
-        return None
-
-    def _extract_decode_tokens(
-        self,
-        tokens: torch.Tensor,
-        runtime_info: dict[str, Any],
-    ) -> torch.Tensor:
-        prompt_len = int(
-            unwrap_first_value(
-                runtime_info.get("prompt_length"),
-                unwrap_first_value(
-                    runtime_info.get("prompt_len"),
-                    unwrap_first_value(runtime_info.get("prompt_token_len"), 0),
-                ),
-            )
-        )
-
-        decode_tokens = tokens
-        if 0 < prompt_len < tokens.numel():
-            decode_tokens = tokens[prompt_len:]
-
-        text_vocab_size = unwrap_first_value(runtime_info.get("text_vocab_size"), None)
-        if text_vocab_size is None and self.tokenizer is not None:
-            text_vocab_size = len(self.tokenizer)
-
-        if text_vocab_size is not None:
-            vocab_size = int(text_vocab_size)
-            valid = decode_tokens[(decode_tokens >= 0) & (decode_tokens < vocab_size)]
-            if valid.numel() > 0:
-                decode_tokens = valid
-
-        return decode_tokens.contiguous()
-
-    def _decode_text(self, tokens: torch.Tensor, runtime_info: dict[str, Any]) -> str:
-        self._maybe_load_runtime_tokenizer(runtime_info)
-        if self.tokenizer is None:
-            return ""
-        try:
-            return self.tokenizer.decode(
-                tokens.detach().cpu().tolist(),
-                skip_special_tokens=True,
-            )
-        except Exception:
-            return ""
-
-    def _maybe_load_runtime_tokenizer(self, runtime_info: dict[str, Any]) -> None:
-        tokenizer_path = unwrap_first_value(runtime_info.get("tokenizer_path"), None)
-        if tokenizer_path is not None:
-            tokenizer_path = str(tokenizer_path)
-
-        runtime_local_files_only = unwrap_first_value(
-            runtime_info.get("local_files_only_model"),
-            unwrap_first_value(
-                runtime_info.get("model_local_files_only"),
-                unwrap_first_value(
-                    runtime_info.get("local_files_only"),
-                    self._infer_sources.model_local_files_only,
-                ),
-            ),
-        )
-        local_only = _to_bool(
-            runtime_local_files_only,
-            default=self._infer_sources.model_local_files_only,
-        )
-
-        if tokenizer_path and tokenizer_path != self._tokenizer_path:
-            try:
-                logger.info("Loading DYNIN text tokenizer from %s", tokenizer_path)
-                self._set_tokenizer(tokenizer_path, local_files_only=local_only)
-            except Exception as e:
-                logger.warning("Failed to load tokenizer from %s: %s", tokenizer_path, e)
-
-    def _ensure_prompt_vq_model(self, runtime_info: dict[str, Any], ref_device: torch.device) -> Any:
-        sources = resolve_dynin_infer_sources(vllm_config=self.vllm_config, runtime_info=runtime_info)
-        model_path = str(sources.vq_image_source)
-        local_files_only = bool(sources.vq_image_local_files_only)
-        if (
-            self._prompt_vq_model is None
-            or self._prompt_vq_model_path != model_path
-            or self._prompt_vq_local_files_only != local_files_only
-        ):
-            logger.info(
-                "Loading DYNIN prompt VQ encoder from %s (local_files_only=%s)",
-                model_path,
-                local_files_only,
-            )
-            magvit_cls = get_dynin_magvit_attr(
-                "MAGVITv2",
-                source=model_path,
-                local_files_only=local_files_only,
-            )
-            try:
-                self._prompt_vq_model = magvit_cls.from_pretrained(
-                    model_path,
-                    local_files_only=local_files_only,
-                )
-            except TypeError:
-                self._prompt_vq_model = magvit_cls.from_pretrained(model_path)
-            self._prompt_vq_model.eval()
-            self._prompt_vq_model.requires_grad_(False)
-            self._prompt_vq_model_path = model_path
-            self._prompt_vq_local_files_only = local_files_only
-        if hasattr(self._prompt_vq_model, "to"):
-            self._prompt_vq_model = self._prompt_vq_model.to(ref_device)
-        return self._prompt_vq_model
-
-    @staticmethod
-    def _prepare_prompt_image_tensor(
-        image: Any,
-        *,
-        resolution: int,
-        device: torch.device,
-    ) -> torch.Tensor:
-        tensor = image if isinstance(image, torch.Tensor) else torch.as_tensor(image)
-        if tensor.ndim == 4:
-            tensor = tensor[0]
-        if tensor.ndim != 3:
-            raise ValueError(f"Unsupported image tensor shape for Dynin bootstrap: {tuple(tensor.shape)}")
-
-        if tensor.shape[0] not in (1, 3, 4) and tensor.shape[-1] in (1, 3, 4):
-            tensor = tensor.permute(2, 0, 1)
-        if tensor.shape[0] == 1:
-            tensor = tensor.repeat(3, 1, 1)
-        if tensor.shape[0] == 4:
-            tensor = tensor[:3]
-
-        tensor = tensor.to(device=device, dtype=torch.float32)
-        if tensor.numel() > 0 and tensor.max() > 1.0:
-            tensor = tensor / 255.0
-
-        tensor = tensor.unsqueeze(0)
-        _, _, height, width = tensor.shape
-        short_side = max(1, min(int(height), int(width)))
-        scale = float(resolution) / float(short_side)
-        new_height = max(1, int(round(height * scale)))
-        new_width = max(1, int(round(width * scale)))
-        tensor = F.interpolate(
-            tensor,
-            size=(new_height, new_width),
-            mode="bicubic",
-            align_corners=False,
-        )
-        top = max(0, (new_height - resolution) // 2)
-        left = max(0, (new_width - resolution) // 2)
-        tensor = tensor[:, :, top : top + resolution, left : left + resolution]
-        if tensor.shape[-2:] != (resolution, resolution):
-            tensor = F.interpolate(
-                tensor,
-                size=(resolution, resolution),
-                mode="bicubic",
-                align_corners=False,
-            )
-        tensor = torch.clamp(tensor, min=0.0, max=1.0)
-        return ((tensor - 0.5) / 0.5).contiguous()
-
-    def _encode_prompt_image_tokens(
-        self,
-        *,
-        runtime_info: dict[str, Any],
-        mm_inputs: dict[str, Any],
-        resolution: int,
-    ) -> torch.Tensor:
-        image_value = mm_inputs.get("image")
-        image_items = self._split_mm_items(image_value)
-        if not image_items:
-            raise ValueError("Dynin online i2i bootstrap requires an image input.")
-
-        device = self._default_mm_device()
-        image_tensor = self._prepare_prompt_image_tensor(
-            image_items[0],
-            resolution=resolution,
-            device=device,
-        )
-        vq_model = self._ensure_prompt_vq_model(runtime_info=runtime_info, ref_device=device)
-        with torch.no_grad():
-            token_ids = vq_model.get_code(image_tensor)
-        token_ids = torch.as_tensor(token_ids, dtype=torch.long).detach().cpu()
-        if token_ids.ndim == 2 and token_ids.shape[0] == 1:
-            token_ids = token_ids[0]
-        return token_ids.contiguous()
-
-    @staticmethod
-    def _split_mm_items(value: Any) -> list[Any]:
-        if value is None:
-            return []
-        if isinstance(value, torch.Tensor):
-            if value.ndim == 0:
-                return [value]
-            return [value[i] for i in range(value.shape[0])]
-        if isinstance(value, list):
-            return value
-        if isinstance(value, tuple):
-            if len(value) == 2 and isinstance(value[1], (int, float)):
-                return [value]
-            return list(value)
-        return [value]
-
-    def _default_mm_device(self) -> torch.device:
-        try:
-            return next(self.model.parameters()).device
-        except StopIteration:
-            return torch.device("cpu")
-
-    @staticmethod
-    def _coerce_mm_item_to_float_tensor(
-        item: Any,
-        *,
-        device: torch.device,
-    ) -> torch.Tensor:
-        if isinstance(item, tuple) and len(item) == 2 and isinstance(item[1], (int, float)):
-            item = item[0]
-
-        if isinstance(item, torch.Tensor):
-            tensor = item.detach().to(device=device, dtype=torch.float32)
-        else:
-            tensor = torch.as_tensor(item, dtype=torch.float32, device=device)
-
-        return tensor.contiguous()
-
-    def _build_deterministic_mm_embedding(
-        self,
-        item: Any,
-        *,
-        device: torch.device,
-    ) -> torch.Tensor:
-        tensor = self._coerce_mm_item_to_float_tensor(item, device=device)
-        if tensor.numel() == 0:
-            return torch.zeros((1, self.hidden_size), dtype=torch.bfloat16, device=device)
-
-        flattened = tensor.view(-1)
-        first = flattened[0]
-        last = flattened[-1]
-        mean = flattened.mean()
-        std = flattened.std(unbiased=False)
-        abs_mean = flattened.abs().mean()
-        max_abs = flattened.abs().max()
-        l2 = torch.linalg.vector_norm(flattened) / max(float(flattened.numel()), 1.0)
-
-        base = torch.stack([first, last, mean, std, abs_mean, max_abs, l2], dim=0)
-        denom = torch.clamp(base.abs().max(), min=1.0)
-        base = base / denom
-
-        repeats = (self.hidden_size + base.numel() - 1) // base.numel()
-        embedding = base.repeat(repeats)[: self.hidden_size].to(dtype=torch.bfloat16)
-        return embedding.unsqueeze(0).contiguous()
-
-    def _collect_mm_inputs(self, **kwargs: Any) -> dict[str, Any]:
-        mm_inputs: dict[str, Any] = {}
-        for modality, aliases in MM_INPUT_ALIASES.items():
-            for alias in aliases:
-                if alias in kwargs and kwargs[alias] is not None:
-                    mm_inputs[modality] = kwargs[alias]
-                    break
-        for modality, value in self._cached_mm_inputs.items():
-            if modality not in mm_inputs and value is not None:
-                mm_inputs[modality] = value
-        return mm_inputs
-
-    def embed_multimodal(self, **kwargs: Any) -> Any:
-        mm_inputs = self._collect_mm_inputs(**kwargs)
-        self._cached_mm_inputs = dict(mm_inputs)
-        if not mm_inputs:
-            return None
-
-        device = self._default_mm_device()
-        mm_embeddings: list[torch.Tensor] = []
-
-        for modality in ("image", "video", "audio"):
-            value = mm_inputs.get(modality)
-            if value is None:
-                continue
-            for item in self._split_mm_items(value):
-                mm_embeddings.append(self._build_deterministic_mm_embedding(item, device=device))
-
-        return tuple(mm_embeddings) if mm_embeddings else None
diff --git a/vllm_omni/model_executor/models/dynin_omni/pipeline.py b/vllm_omni/model_executor/models/dynin_omni/pipeline.py
deleted file mode 100644
index 6f59ebb36..000000000
--- a/vllm_omni/model_executor/models/dynin_omni/pipeline.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Dynin-Omni pipeline topology (frozen).
-
-Stage 0: token2text  — multimodal understanding / text generation (comprehension)
-Stage 1: token2image — stage-0 tokens → image latents
-Stage 2: token2audio — stage-1 tokens → audio latents
-
-All three stages run on the generation worker (``LLM_GENERATION``); the
-inter-stage hand-off uses the worker-connector full-payload data plane
-(``*_full_payload`` producers + ``token2text_to_token2image`` /
-``token2image_to_token2audio`` consumers). Deploy knobs (devices, GPU memory,
-batched tokens, connectors) live in ``vllm_omni/deploy/dynin_omni*.yaml``.
-"""
-
-from vllm_omni.config.stage_config import (
-    PipelineConfig,
-    StageExecutionType,
-    StagePipelineConfig,
-)
-
-_PROC = "vllm_omni.model_executor.stage_input_processors.dynin_omni"
-
-DYNIN_OMNI_PIPELINE = PipelineConfig(
-    model_type="dynin_omni",
-    default_deploy_config_name="dynin_omni.yaml",
-    model_arch="DyninOmniForConditionalGeneration",
-    # Arch-fallback safety net: route by hf_config.architectures when the
-    # auto-detected model_type does not match the registry key exactly.
-    hf_architectures=("DyninOmniForConditionalGeneration",),
-    stages=(
-        StagePipelineConfig(
-            stage_id=0,
-            model_stage="token2text",
-            execution_type=StageExecutionType.LLM_GENERATION,
-            input_sources=(),
-            final_output=True,
-            final_output_type="text",
-            owns_tokenizer=True,
-            engine_output_type="latent",
-            custom_process_next_stage_input_func=f"{_PROC}.token2text_to_token2image_full_payload",
-        ),
-        StagePipelineConfig(
-            stage_id=1,
-            model_stage="token2image",
-            execution_type=StageExecutionType.LLM_GENERATION,
-            input_sources=(0,),
-            final_output=True,
-            final_output_type="image",
-            engine_output_type="latent",
-            custom_process_input_func=f"{_PROC}.token2text_to_token2image",
-            custom_process_next_stage_input_func=f"{_PROC}.token2image_to_token2audio_full_payload",
-            requires_full_payload_input=True,
-        ),
-        StagePipelineConfig(
-            stage_id=2,
-            model_stage="token2audio",
-            execution_type=StageExecutionType.LLM_GENERATION,
-            input_sources=(1,),
-            final_output=True,
-            final_output_type="audio",
-            engine_output_type="latent",
-            custom_process_input_func=f"{_PROC}.token2image_to_token2audio",
-            requires_full_payload_input=True,
-        ),
-    ),
-)
diff --git a/vllm_omni/model_executor/models/fish_speech/fish_speech_slow_ar.py b/vllm_omni/model_executor/models/fish_speech/fish_speech_slow_ar.py
index 1317dc044..57f37f3d9 100644
--- a/vllm_omni/model_executor/models/fish_speech/fish_speech_slow_ar.py
+++ b/vllm_omni/model_executor/models/fish_speech/fish_speech_slow_ar.py
@@ -32,6 +32,7 @@ from vllm.model_executor.models.utils import PPMissingLayer, maybe_prefix
 from vllm.sequence import IntermediateTensors
 
 from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.platforms import current_omni_platform
 from vllm_omni.utils.speaker_cache import get_speaker_cache
 
 from .configuration_fish_speech import FishSpeechConfig, FishSpeechFastARConfig, FishSpeechSlowARConfig
@@ -195,7 +196,11 @@ class FishSpeechSlowARForConditionalGeneration(nn.Module):
         self.mtp_hidden_size = int(self.text_config.hidden_size)
         self.talker_mtp_output_key = ("codes", "audio")
         self.gpu_resident_buffer_keys: set[tuple[str, str]] = {("hidden_states", "last")}
-        self.talker_mtp_graph_safe = True
+        # NPU (Ascend) ACL graphs cannot capture the Fast-AR random-sampling ops
+        # (torch.nonzero / torch.multinomial used for top-p), so keep the talker
+        # MTP eager on NPU to fall back to native (non-graph) execution. Mirrors
+        # the 310P patch for Qwen3-TTS (talker_mtp_graph_safe=False).
+        self.talker_mtp_graph_safe = not current_omni_platform.is_npu()
 
         # Qwen3 transformer backbone.
         self.model = Qwen3Model(vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model"))
diff --git a/vllm_omni/model_executor/models/hunyuan_image3/hunyuan_image3.py b/vllm_omni/model_executor/models/hunyuan_image3/hunyuan_image3.py
index b15a19982..02106a2cc 100755
--- a/vllm_omni/model_executor/models/hunyuan_image3/hunyuan_image3.py
+++ b/vllm_omni/model_executor/models/hunyuan_image3/hunyuan_image3.py
@@ -1448,6 +1448,9 @@ class HunyuanImage3ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo
 
     prefer_model_sampler = True
     logitsprocs_need_output_token_ids = True
+    # Ask the AR model runner to pass each row's SamplingParams.extra_args to
+    # sample(), so per-request task modes (ar_task_mode) can reach the sampler.
+    model_sampler_wants_extra_args = True
 
     # Siglip2 ViT supports data-parallel encoding (mm_encoder_tp_mode="data"):
     # weights are replicated and the image batch is sharded across TP ranks.
@@ -1536,7 +1539,10 @@ class HunyuanImage3ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo
         # Used to embed timestep information into the input sequence.
         self.timestep_emb = TimestepEmbedder(hidden_size=config.hidden_size)
 
-        tokenizer = get_tokenizer(vllm_config.model_config.tokenizer)
+        tokenizer = get_tokenizer(
+            vllm_config.model_config.tokenizer,
+            trust_remote_code=vllm_config.model_config.trust_remote_code,
+        )
         self._mrope_img_token_id = tokenizer.convert_tokens_to_ids("<img>")
         self._mrope_boi_token_id = tokenizer.convert_tokens_to_ids("<boi>")
         self._mrope_eoi_token_id = tokenizer.convert_tokens_to_ids("<eoi>")
@@ -1557,31 +1563,48 @@ class HunyuanImage3ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo
         self._end_ratio_id = tokenizer.convert_tokens_to_ids("<img_ratio_32>")
         ratio_33 = tokenizer.convert_tokens_to_ids("<img_ratio_33>")
         ratio_36 = tokenizer.convert_tokens_to_ids("<img_ratio_36>")
-        self._ratio_other_slices = [(ratio_33, ratio_36 + 1)]
+        # The base checkpoint stops at <img_ratio_32>; only Instruct has 33-36.
+        if ratio_33 is None or ratio_36 is None:
+            self._ratio_other_slices = []
+        else:
+            self._ratio_other_slices = [(ratio_33, ratio_36 + 1)]
         # Build the full set of ratio token IDs for use as stop tokens.
         self._all_ratio_ids = set(range(self._start_ratio_id, self._end_ratio_id + 1))
         for s, e in self._ratio_other_slices:
             self._all_ratio_ids.update(range(s, e))
 
         # Determine mode: comprehension (I2T/T2T) vs generation (IT2I/T2I).
+        # ``engine_output_type`` is a per-engine static (from the pipeline
+        # registry), but a generation deployment (e.g. the AR+DiT
+        # hunyuan_image_3_moe pipeline, engine_output_type="latent") also
+        # serves plain chat completions whose answer is text (I2T/T2T).
+        # Those requests are marked per-request via
+        # ``SamplingParams.extra_args["ar_task_mode"] == "comprehension"``
+        # by the serving layer and must not go through the image-generation
+        # stage transitions below (#6088).
         engine_output_type = getattr(vllm_config.model_config, "engine_output_type", None)
         self._is_comprehension = engine_output_type in (None, "text")
 
-        # For comprehension mode, block image generation tokens but allow
+        # For comprehension requests, block image generation tokens but allow
         # text structure tokens (<think>, <answer>, etc.) so the model can
         # follow its natural generation pattern. Runtime sampling params
         # decide stop tokens from the active bot_task, matching the official
         # HunyuanImage3 generation path without hard-coded YAML token ids.
-        self._blocked_token_ids: set[int] = set()
-        if self._is_comprehension:
-            self._blocked_token_ids.update(
-                [
-                    self._mrope_boi_token_id,  # <boi>
-                    self._mrope_eoi_token_id,  # <eoi>
-                    self._size_token_id,  # <img_size_*>
-                ]
-            )
-            self._blocked_token_ids.update(self._all_ratio_ids)
+        # <cfg>, <img>, <timestep> and <joint_img_sep> are DiT-side scaffold
+        # tokens that are never valid in a text answer; without them in the
+        # blocklist an I2T request can degenerate into a stream of <cfg>
+        # tokens (#6088).
+        self._cfg_token_id = tokenizer.convert_tokens_to_ids("<cfg>")
+        self._blocked_token_ids: set[int] = {
+            self._mrope_boi_token_id,  # <boi>
+            self._mrope_eoi_token_id,  # <eoi>
+            self._size_token_id,  # <img_size_*>
+            self._cfg_token_id,  # <cfg>
+            self._mrope_img_token_id,  # <img>
+            self._timestep_token_id,  # <timestep>
+            self._mrope_joint_img_sep_token_id,  # <joint_img_sep>
+        }
+        self._blocked_token_ids.update(self._all_ratio_ids)
 
         # For generation mode, build stage transition map.
         # Official logic: </think> → [<recaption>],
@@ -2054,6 +2077,7 @@ class HunyuanImage3ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo
         self,
         logits: torch.Tensor,
         sampling_metadata: SamplingMetadata,
+        per_req_extra_args: Sequence[Mapping[str, Any] | None] | None = None,
     ) -> SamplerOutput | None:
         if logits is None or logits.numel() == 0:
             return None
@@ -2063,25 +2087,34 @@ class HunyuanImage3ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo
 
         min_score = torch.finfo(logits.dtype).min
 
+        if self._blocked_token_ids_tensor is None and self._blocked_token_ids:
+            self._blocked_token_ids_tensor = torch.tensor(
+                sorted(self._blocked_token_ids),
+                dtype=torch.long,
+                device=logits.device,
+            )
+
         if self._is_comprehension:
             # Comprehension path is stateless: we only need to mask a fixed
             # set of blocked token ids on every step. Do it in one batched
             # index_fill_ instead of a per-(req, id) Python loop of scalar
             # GPU writes, and skip reading `output_token_ids` from CPU
             # (unused here) so this branch never forces a D2H sync.
-            if self._blocked_token_ids_tensor is None and self._blocked_token_ids:
-                self._blocked_token_ids_tensor = torch.tensor(
-                    sorted(self._blocked_token_ids),
-                    dtype=torch.long,
-                    device=logits.device,
-                )
             if self._blocked_token_ids_tensor is not None:
                 logits.index_fill_(-1, self._blocked_token_ids_tensor, min_score)
             return self._sampler(logits=logits, sampling_metadata=sampling_metadata)
 
-        # Generation path retains the per-request stateful logic for forced
-        # stage-transition tokens and ratio-restriction.
+        # Generation-mode engine. Individual requests can still be
+        # comprehension (I2T/T2T chat served by an AR+DiT deployment); the
+        # serving layer marks those with extra_args["ar_task_mode"] ==
+        # "comprehension", and they get the stateless blocking above instead
+        # of stage-transition forcing (#6088).
         for req_idx in range(logits.shape[0]):
+            if self._row_is_comprehension(per_req_extra_args, req_idx):
+                if self._blocked_token_ids_tensor is not None:
+                    logits[req_idx].index_fill_(-1, self._blocked_token_ids_tensor, min_score)
+                continue
+
             decoded_tokens: list[int] = (
                 sampling_metadata.output_token_ids[req_idx] if req_idx < len(sampling_metadata.output_token_ids) else []
             )
@@ -2099,6 +2132,24 @@ class HunyuanImage3ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo
 
         return self._sampler(logits=logits, sampling_metadata=sampling_metadata)
 
+    @staticmethod
+    def _row_is_comprehension(
+        per_req_extra_args: Sequence[Mapping[str, Any] | None] | None,
+        req_idx: int,
+    ) -> bool:
+        """Whether this batch row is a per-request comprehension override.
+
+        Defaults to False (generation) when no extra_args reached the
+        sampler, so offline ``Omni.generate`` image-generation flows keep
+        the stage-transition behavior unchanged.
+        """
+        if per_req_extra_args is None or req_idx >= len(per_req_extra_args):
+            return False
+        extra_args = per_req_extra_args[req_idx]
+        if not extra_args:
+            return False
+        return extra_args.get("ar_task_mode") == "comprehension"
+
     def _get_forced_token(self, decoded_tokens: list[int]) -> int | None:
         """Derive the next forced token from output history (stateless).
 
diff --git a/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py b/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py
index 830c63aff..be2e256fb 100644
--- a/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py
+++ b/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """MammothModa2 pipeline topology (frozen).
 
 Stage 0: AR  — multimodal understanding + latent generation
@@ -8,6 +8,7 @@ Stage 1: DiT — latent → image
 For text/image understanding tasks (text output only), use MAMMOTH_MODA2_AR_PIPELINE.
 """
 
+from vllm_omni.config.endpoint_policy import EndpointRestriction, OmniServingCapability
 from vllm_omni.config.stage_config import (
     PipelineConfig,
     StageExecutionType,
@@ -21,6 +22,13 @@ MAMMOTH_MODA2_PIPELINE = PipelineConfig(
     default_deploy_config_name="mammoth_moda2.yaml",
     model_arch="MammothModa2ForConditionalGeneration",
     hf_architectures=("Mammothmoda2Model", "MammothModa2ForConditionalGeneration"),
+    endpoint_restrictions=(
+        EndpointRestriction(
+            OmniServingCapability.IMAGE_EDITS,
+            "MammothModa2 image editing (img2img) is not supported. "
+            "Use /v1/images/generations for text-to-image requests.",
+        ),
+    ),
     stages=(
         StagePipelineConfig(
             stage_id=0,
@@ -35,14 +43,15 @@ MAMMOTH_MODA2_PIPELINE = PipelineConfig(
         StagePipelineConfig(
             stage_id=1,
             model_stage="dit",
-            execution_type=StageExecutionType.LLM_GENERATION,
+            execution_type=StageExecutionType.DIFFUSION,
             input_sources=(0,),
             final_output=True,
             final_output_type="image",
             owns_tokenizer=False,
             requires_multimodal_data=False,
-            engine_output_type="image",
-            custom_process_input_func=f"{_PROC}.ar2dit",
+            model_arch="MammothModa2DiTPipeline",
+            custom_process_input_func=f"{_PROC}.ar2diffusion",
+            omni_kv_config={"need_recv_cache": False},
         ),
     ),
 )
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/__init__.py b/vllm_omni/model_executor/models/minicpmo_4_5/__init__.py
index 6e8677cf2..77ee3b9a0 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/__init__.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/__init__.py
@@ -9,3 +9,9 @@
 
 # One MiniCPMTTS.generate_chunk emits 25 codec frames plus its terminator.
 MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK = 26
+# Codec budget for the Talker chunk that carries the Thinker's turn end. The
+# Talker paces ~1 s of speech per unit and emits its chunk EOS at the 25-frame
+# cadence, while the text it still owes at turn end can exceed one unit. The
+# turn-end chunk may run for several units so the tail of the turn is spoken
+# (see ``_native_duplex_chunk_budget`` and the boundary EOS mask in the Talker).
+MINICPMO45_DUPLEX_TURN_END_CODEC_TOKENS = MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK * 4
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py
index 673640461..e57377766 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py
@@ -63,6 +63,15 @@ _DUPLEX_VISION_TOKENS_PER_FRAME = 66
 # Official stacked pair uses max_slice_nums=[2, 1]: the current frame is HD
 # sliced (1 source + 2 patches on 960x540) and the composite is not.
 _DUPLEX_HD_SLICES_PER_BASE_FRAME = 3
+# How many blocks that slicing costs depends on the frame, and at
+# ``max_slice_nums=2`` the processor's grid search has only two outcomes.
+# ``MiniCPMVImageProcessor.get_sliced_grid`` takes
+# ``multiple = min(ceil(w * h / scale_resolution**2), max_slice_nums)`` and
+# returns no grid at all for ``multiple <= 1``; at 2 the only candidate split
+# is 2, so a frame is either unsliced or a 2-cell grid. One normalization tile
+# is therefore the whole decision -- but ``scale_resolution`` is the
+# checkpoint's, not a constant, so it is read from the model rather than
+# assumed.
 
 PRIVATE_RUNTIME_CONFIG_KEYS = frozenset(
     {
@@ -70,6 +79,7 @@ PRIVATE_RUNTIME_CONFIG_KEYS = frozenset(
         "duplex_stage_max_tokens",
         "duplex_stage0_max_tokens",
         "duplex_scheduler_token_id",
+        "duplex_vision_tile_pixels",
         "duplex_first_append_context_tokens",
         "ref_audio_data",
         "ref_audio_format",
@@ -86,29 +96,68 @@ class MiniCPMO45ClientRuntimeConfigError(DuplexRuntimeConfigError):
 # ---- engine policy helpers: scheduler token budget ----
 
 
-def _duplex_frame_count(payload: object) -> int:
+def _duplex_frames(payload: object) -> list[str]:
     if not isinstance(payload, dict):
-        return 0
+        return []
     frames = payload.get("video_frames")
     if not isinstance(frames, list):
-        return 0
-    return sum(1 for frame in frames if isinstance(frame, str) and frame)
+        return []
+    return [frame for frame in frames if isinstance(frame, str) and frame]
 
 
-def _duplex_vision_tokens(payload: object) -> int:
+def _duplex_base_frame_blocks(frame: str, tile_pixels: int | None) -> int:
+    """Blocks the HD-sliced frame of a stacked pair costs, read from the frame.
+
+    Wire format is the one Stage0 decodes: bare base64 JPEG/PNG, and only the
+    header is parsed -- the pixels are the worker's job.
+
+    Every uncertainty resolves to the sliced count, because the two directions
+    are not symmetric. Over-reserving wastes scheduler slots. Under-reserving
+    hands the worker fewer prompt slots than it has embeddings, and
+    ``MiniCPMO45OmniModel`` then drops the tail of the unit with a warning
+    rather than failing, which is silent audio loss.
+    """
+    if tile_pixels is None:
+        return _DUPLEX_HD_SLICES_PER_BASE_FRAME
+
+    from io import BytesIO
+
+    from PIL import Image
+
+    try:
+        raw = b64decode(frame, validate=True)
+        with Image.open(BytesIO(raw)) as image:
+            width, height = image.size
+    except (BinasciiError, ValueError, OSError, Image.DecompressionBombError):
+        return _DUPLEX_HD_SLICES_PER_BASE_FRAME
+    if width * height <= tile_pixels:
+        return 1
+    return _DUPLEX_HD_SLICES_PER_BASE_FRAME
+
+
+def _duplex_vision_tile_pixels(runtime_config: object) -> int | None:
+    """Area of the tile this model normalizes a frame to, or ``None`` if unknown."""
+    if not isinstance(runtime_config, dict):
+        return None
+    value = runtime_config.get("duplex_vision_tile_pixels")
+    return value if isinstance(value, int) and value > 0 else None
+
+
+def _duplex_vision_tokens(payload: object, *, tile_pixels: int | None = None) -> int:
     """Scheduler slots for this append's camera track.
 
     Audio is never stacked: a unit still carries one second of soundtrack.
     ``stack_frames`` only adds a second *image*. Official HD on that pair is
-    ``[2, 1]``, so the base frame reserves three 66-token blocks and every
-    extra frame reserves one.
+    ``[2, 1]``, so only the first frame is sliced and every other frame
+    reserves one 66-token block.
     """
-    count = _duplex_frame_count(payload)
-    if count <= 0:
+    frames = _duplex_frames(payload)
+    if not frames:
         return 0
-    if count >= 2:
-        return (_DUPLEX_HD_SLICES_PER_BASE_FRAME + (count - 1)) * _DUPLEX_VISION_TOKENS_PER_FRAME
-    return count * _DUPLEX_VISION_TOKENS_PER_FRAME
+    if len(frames) == 1:
+        return _DUPLEX_VISION_TOKENS_PER_FRAME
+    blocks = _duplex_base_frame_blocks(frames[0], tile_pixels) + (len(frames) - 1)
+    return blocks * _DUPLEX_VISION_TOKENS_PER_FRAME
 
 
 def _duplex_pcm_sample_count(payload: object) -> int | None:
@@ -136,8 +185,8 @@ def duplex_first_append_unit_count(payload: object) -> int | None:
     return max(1, sample_count // _DUPLEX_CHUNK_SAMPLES - 1)
 
 
-def duplex_scheduler_token_budget(payload: object, *, default: int = 64) -> int:
-    vision_tokens = _duplex_vision_tokens(payload)
+def duplex_scheduler_token_budget(payload: object, *, default: int = 64, tile_pixels: int | None = None) -> int:
+    vision_tokens = _duplex_vision_tokens(payload, tile_pixels=tile_pixels)
     sample_count = _duplex_pcm_sample_count(payload)
     if sample_count is None:
         return max(1, int(default)) + vision_tokens
@@ -185,13 +234,15 @@ def build_duplex_data_plane_prompt(
     payload: object,
     final: bool,
 ) -> dict[str, object]:
-    token_budget = duplex_scheduler_token_budget(payload)
+    tile_pixels = _duplex_vision_tile_pixels(runtime_config)
+    token_budget = duplex_scheduler_token_budget(payload, tile_pixels=tile_pixels)
     if seq <= 1:
         context_reserve = duplex_first_append_context_reserve(runtime_config)
         token_budget += context_reserve
         first_units = duplex_first_append_unit_count(payload)
         if first_units is not None:
-            token_budget = context_reserve + first_units * 12 - 1 + _duplex_vision_tokens(payload)
+            vision_tokens = _duplex_vision_tokens(payload, tile_pixels=tile_pixels)
+            token_budget = context_reserve + first_units * 12 - 1 + vision_tokens
     if seq > 1 and duplex_payload_is_exact_chunks(payload):
         token_budget += 1
     if final and duplex_payload_is_exact_chunks(payload):
@@ -466,11 +517,34 @@ def _apply_first_append_context_tokens(
     runtime_config["duplex_first_append_context_tokens"] = len(prefix_ids) + ref_tokens + len(suffix_ids)
 
 
+def _model_vision_tile_pixels(model_config: ModelConfig | None) -> int | None:
+    """Area of one normalization tile, from the checkpoint that will do the slicing.
+
+    ``MiniCPMVImageProcessor`` is built with ``scale_resolution=config.image_size``
+    and Stage0 loads the checkpoint's own processor, so this is per-checkpoint
+    configuration. ``None`` when it cannot be read, which keeps the reservation
+    at the sliced count.
+    """
+    hf_config = getattr(model_config, "hf_config", None)
+    if hf_config is None:
+        return None
+    slice_config = getattr(hf_config, "slice_config", None)
+    side = getattr(slice_config, "scale_resolution", None)
+    if not isinstance(side, int):
+        side = slice_config.get("scale_resolution") if isinstance(slice_config, dict) else None
+    if not isinstance(side, int):
+        side = getattr(hf_config, "image_size", None)
+    if not isinstance(side, int) or side <= 0:
+        return None
+    return side * side
+
+
 def _apply_default_scheduler_policy(
     runtime_config: dict[str, object],
     *,
     config: DuplexSessionConfig,
     tokenizer: PreTrainedTokenizerBase | None,
+    model_config: ModelConfig | None = None,
 ) -> None:
     stage0_max_tokens = config.max_tokens if isinstance(config.max_tokens, int) and config.max_tokens > 0 else 20
     runtime_config["duplex_stage_max_tokens"] = {"0": stage0_max_tokens, "1": 8192}
@@ -491,6 +565,9 @@ def _apply_default_scheduler_policy(
     scheduler_token_id = _scheduler_token_id(tokenizer)
     if scheduler_token_id is not None:
         runtime_config["duplex_scheduler_token_id"] = scheduler_token_id
+    tile_pixels = _model_vision_tile_pixels(model_config)
+    if tile_pixels is not None:
+        runtime_config["duplex_vision_tile_pixels"] = tile_pixels
 
 
 class MiniCPMO45DuplexPlugin(DuplexModelPlugin):
@@ -653,7 +730,7 @@ class MiniCPMO45DuplexPlugin(DuplexModelPlugin):
         if isinstance(initial_user_text, str) and initial_user_text:
             runtime_config["initial_user_text"] = initial_user_text
         tokenizer = await self._tokenizer_for(model_config)
-        _apply_default_scheduler_policy(runtime_config, config=config, tokenizer=tokenizer)
+        _apply_default_scheduler_policy(runtime_config, config=config, tokenizer=tokenizer, model_config=model_config)
 
         ref_audio = config.ref_audio
         extra_ref_audio = extra_body.get("ref_audio")
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/session.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/session.py
index 49d0caab6..fe53ec653 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/session.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/session.py
@@ -29,6 +29,11 @@ class MiniCPMO45ServingSessionState(DuplexModelSessionState):
     continuation_units: int = 0
     pending_silence_task: asyncio.Task[bool] | None = None
     pending_silence_owner_id: str | None = None
+    # Deadline-aligned silence continuation state: the monotonic submission
+    # time of the most recent native input unit and the next silence
+    # continuation deadline. A real (non-silence) input resets the chain.
+    last_native_submit_monotonic: float | None = None
+    silence_deadline_monotonic: float | None = None
 
     def retain_committed_audio(
         self,
@@ -55,3 +60,5 @@ class MiniCPMO45ServingSessionState(DuplexModelSessionState):
         self.continuation_units = 0
         self.pending_silence_task = None
         self.pending_silence_owner_id = None
+        self.last_native_submit_monotonic = None
+        self.silence_deadline_monotonic = None
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py
index bdc418f05..67843833d 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py
@@ -28,7 +28,10 @@ from vllm.model_executor.models.utils import maybe_prefix
 from vllm.v1.sample.sampler import Sampler
 
 from vllm_omni.engine.duplex.intermediate import get_tts_handoff
-from vllm_omni.model_executor.models.minicpmo_4_5 import MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK
+from vllm_omni.model_executor.models.minicpmo_4_5 import (
+    MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK,
+    MINICPMO45_DUPLEX_TURN_END_CODEC_TOKENS,
+)
 from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.platforms import current_omni_platform
 
@@ -48,13 +51,38 @@ _OFFLINE_CODEC_MAX_NEW_TOKENS = 2048
 # Without this, the single-vocab Sampler keeps the stage-1 request alive
 # until codec EOS / 4096 and Thinker never starts the next model turn.
 _DUPLEX_CODEC_TOKENS_PER_CHUNK = MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK
+_DUPLEX_TURN_END_CODEC_TOKENS = MINICPMO45_DUPLEX_TURN_END_CODEC_TOKENS
+#: Frames the Talker forwards per generate_chunk before its cadence EOS.
+_DUPLEX_CODEC_FRAMES_PER_CHUNK = MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK - 1
+#: On a turn-end chunk the Talker's EOS is masked for this many steps after
+#: each 25-frame boundary: the model emits a cadence EOS there whether or not
+#: its text is spoken, while a genuine end of text shows up as an EOS anywhere
+#: else in the window.
+_DUPLEX_TURN_END_BOUNDARY_MASK_STEPS = 5
 
 
 def _native_duplex_chunk_budget(meta: Mapping[str, Any] | None) -> tuple[int, int]:
     """Return ``(max_tokens, min_tokens)`` for one native-duplex Talker request."""
-    boundary = isinstance(meta, Mapping) and (bool(meta.get("turn_start")) or bool(meta.get("turn_end")))
+    turn_start = isinstance(meta, Mapping) and bool(meta.get("turn_start"))
+    turn_end = isinstance(meta, Mapping) and bool(meta.get("turn_end"))
+    if turn_end:
+        # The turn-end chunk drains the text the Talker still owes: no floor
+        # (an early EOS means the text is spoken) and a multi-unit ceiling.
+        return _DUPLEX_TURN_END_CODEC_TOKENS, 0
     ceiling = _DUPLEX_CODEC_TOKENS_PER_CHUNK
-    return ceiling, 0 if boundary else ceiling
+    return ceiling, 0 if turn_start else ceiling
+
+
+def _turn_end_boundary_eos_masked(step: int) -> bool:
+    """Whether a turn-end chunk masks codec EOS at ``step`` forwarded frames.
+
+    The Talker emits a cadence EOS after every 25 frames regardless of the text
+    left, so a turn-end chunk ignores EOS in a short window after each boundary
+    and lets the model continue; EOS elsewhere ends the chunk as usual.
+    """
+    if step < _DUPLEX_CODEC_FRAMES_PER_CHUNK:
+        return False
+    return step % _DUPLEX_CODEC_FRAMES_PER_CHUNK < _DUPLEX_TURN_END_BOUNDARY_MASK_STEPS
 
 
 def blank_scheduler_prompt_for_penalties(
@@ -367,7 +395,7 @@ class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
             code_ids = torch.as_tensor(previous_codes, device=self.emb_code[0].weight.device, dtype=torch.long)
         else:
             raise ValueError("streaming prompt recompute is missing confirmed codec ids")
-        if code_ids.numel() > _DUPLEX_CODEC_TOKENS_PER_CHUNK - 1:
+        if code_ids.numel() > _DUPLEX_TURN_END_CODEC_TOKENS - 1:
             raise ValueError(f"streaming prompt recompute has too many codec ids: {code_ids.numel()}")
         if code_ids.numel() and bool(((code_ids < 0) | (code_ids >= self._codec_eos_id)).any()):
             raise ValueError("streaming prompt recompute codec ids include an invalid or terminal token")
@@ -500,6 +528,7 @@ class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
                 "step": 0,
                 "max_tokens": max_tokens,
                 "min_tokens": min_tokens,
+                "turn_end_drain": bool(native_duplex and isinstance(meta, Mapping) and bool(meta.get("turn_end"))),
             }
             if retained_codes:
                 state["recent_codes"] = retained_codes
@@ -653,7 +682,10 @@ class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
                 # plane does not wait for a follow-up empty decode.
                 state["finished"] = True
             force_eos_rows[index] = chunk_done
-            mask_eos_rows[index] = not force_eos_rows[index] and min_tokens is not None and step < int(min_tokens)
+            mask_eos_rows[index] = not force_eos_rows[index] and (
+                (min_tokens is not None and step < int(min_tokens))
+                or (bool(state.get("turn_end_drain")) and _turn_end_boundary_eos_masked(step))
+            )
             terminal_flags[index] = torch.tensor(chunk_done, dtype=torch.bool)
 
         # Empty-speech rows, finished duplex chunks, and offline requests that
diff --git a/vllm_omni/model_executor/models/minimax_h3/checkpoint.py b/vllm_omni/model_executor/models/minimax_h3/checkpoint.py
index 0143e9675..b39af5cf8 100644
--- a/vllm_omni/model_executor/models/minimax_h3/checkpoint.py
+++ b/vllm_omni/model_executor/models/minimax_h3/checkpoint.py
@@ -1,10 +1,16 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""MiniMax H3 checkpoint resolution for the AR text-encoder stage."""
+
 from pathlib import Path
 
+from vllm_omni.diffusion.utils.hf_utils import get_diffusion_model_index
 from vllm_omni.model_executor.model_loader.weight_utils import (
     download_weights_from_hf_specific,
 )
 
+_FASTH3_MODULAR_MODEL_PREFIX = "FastVideo/"
+
 MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS = {
     partition: [
         f"{subdir}/text_encoder/**",
@@ -16,6 +22,22 @@ MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS = {
 MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS["combined"] = MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS["fl2va"]
 
 
+def is_minimax_h3_modular(model: str, revision: str | None = None) -> bool:
+    path = Path(model)
+    if path.is_dir():
+        # Native MiniMax-H3 snapshots can advertise the Diffusers modular
+        # class in ``model_index.json`` while retaining the legacy FL2VA /
+        # Ref2VA layout.  FastH3 modular releases carry this marker file.
+        return (path / "modular_model_index.json").is_file() or (path / "fastvideo_inference.json").is_file()
+    # The FastVideo release is the modular checkpoint handled by this
+    # resolver.  Do not classify the native MiniMax-H3 Hub repository from
+    # its class name alone; its partition files are still required here.
+    if not model.startswith(_FASTH3_MODULAR_MODEL_PREFIX):
+        return False
+    index = get_diffusion_model_index(model, revision=revision) or {}
+    return index.get("_class_name") == "MiniMaxH3ModularPipeline"
+
+
 def resolve_minimax_h3_partition(
     model: str,
     task_type: str | None,
@@ -42,10 +64,13 @@ def resolve_minimax_h3_encoder_model_root(
 ) -> str:
     path = Path(model)
     partition = resolve_minimax_h3_partition(model, task_type, auto_partition="fl2va")
+    modular = is_minimax_h3_modular(model, revision)
 
     if path.is_dir():
         if path.name == "text_encoder" and (path / "config.json").is_file():
             return str(path)
+        if modular:
+            return str(path / "text_encoder")
         if path.name in {"FL2VA", "Ref2VA"}:
             path = path.parent
         subdir = "Ref2VA" if partition == "ref2va" else "FL2VA"
@@ -53,11 +78,13 @@ def resolve_minimax_h3_encoder_model_root(
     snapshot = download_weights_from_hf_specific(
         model_name_or_path=model,
         cache_dir=None,
-        allow_patterns=MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS[partition],
+        allow_patterns=["text_encoder/**"] if modular else MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS[partition],
         revision=revision,
         require_all=True,
     )
 
+    if modular:
+        return str(Path(snapshot) / "text_encoder")
     subdir = "Ref2VA" if partition == "ref2va" else "FL2VA"
     return str(Path(snapshot) / subdir / "text_encoder")
 
diff --git a/vllm_omni/model_executor/models/minimax_h3/conditioning.py b/vllm_omni/model_executor/models/minimax_h3/conditioning.py
index 761292dc3..5d362f440 100644
--- a/vllm_omni/model_executor/models/minimax_h3/conditioning.py
+++ b/vllm_omni/model_executor/models/minimax_h3/conditioning.py
@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import math
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, fields
 from typing import Any
@@ -123,7 +124,7 @@ class MiniMaxH3TextConditioning:
 
 MINIMAX_H3_ENCODER_REQUEST_KEY = "minimax_h3_encoder_request"
 MINIMAX_H3_ENCODER_LAYOUT_KEY = "minimax_h3_encoder_layout"
-STAGE_SCHEMA_VERSION = 1
+STAGE_SCHEMA_VERSION = 2
 _ENCODER_WIRE_SCHEMA_ID = 1
 
 _TASK_TO_CODE = {"t2va": 1, "fl2va": 2, "ref2va": 3}
@@ -144,6 +145,104 @@ _AUDIO_CONDITION_WIDTH = 32
 _AUDIO_CONDITION_CHANNELS = 2
 
 
+def _validate_edit_mask_structure(
+    mask: torch.Tensor,
+    *,
+    name: str,
+    shape: tuple[int, ...],
+) -> None:
+    """Validate only the internal tensor contract after encoder-boundary parsing."""
+    if mask.dtype != torch.float32 or tuple(mask.shape) != shape:
+        raise ValueError(f"MiniMax H3 {name} edit mask must be FP32 with shape {shape}")
+    _validate_contiguous_strided_layout(f"{name} edit mask", mask)
+
+
+def _validate_edit_tensors(
+    clean_rows: torch.Tensor | None,
+    raw_mask: torch.Tensor | None,
+    *,
+    name: str,
+    width: int,
+    mask_shape: tuple[int, ...],
+) -> int:
+    values = (clean_rows, raw_mask)
+    if all(value is None for value in values):
+        return 0
+    if clean_rows is None or raw_mask is None:
+        raise ValueError(f"MiniMax H3 {name} edit requires clean rows and a raw mask tensor")
+    if clean_rows.dtype != torch.float32 or clean_rows.ndim != 2 or clean_rows.shape[1] != width:
+        raise ValueError(f"MiniMax H3 {name} edit rows must be FP32 with shape [rows, {width}]")
+    row_count = int(clean_rows.shape[0])
+    if row_count <= 0:
+        raise ValueError(f"MiniMax H3 {name} edit rows must not be empty")
+    _validate_edit_mask_structure(raw_mask, name=name, shape=mask_shape)
+    if raw_mask.device != clean_rows.device:
+        raise ValueError(f"MiniMax H3 {name} edit tensors must share one device")
+    _validate_contiguous_strided_layout(f"{name} edit rows", clean_rows)
+    return row_count
+
+
+def _packed_vector_rows(value: torch.Tensor, *, width: int) -> torch.Tensor:
+    flat = value.reshape(-1)
+    padding = (-int(flat.numel())) % width
+    if padding:
+        flat = torch.cat((flat, flat.new_zeros(padding)))
+    return flat.reshape(-1, width)
+
+
+def _pack_condition_slot(
+    condition: torch.Tensor | None,
+    clean_rows: torch.Tensor | None,
+    raw_mask: torch.Tensor | None,
+    *,
+    width: int,
+) -> torch.Tensor:
+    if clean_rows is None:
+        return condition if condition is not None else torch.empty((0,), dtype=torch.float32)
+    if raw_mask is None:
+        raise ValueError("MiniMax H3 edit rows require a raw mask tensor")
+    values = [clean_rows, _packed_vector_rows(raw_mask, width=width)]
+    if condition is not None:
+        values.insert(0, condition)
+    return torch.cat(values).contiguous()
+
+
+def _unpack_condition_slot(
+    value: torch.Tensor,
+    *,
+    condition_rows: int,
+    edit_rows: int,
+    mask_shape: tuple[int, ...],
+    width: int,
+    name: str,
+) -> tuple[torch.Tensor | None, torch.Tensor | None, torch.Tensor | None]:
+    mask_values = math.prod(mask_shape) if mask_shape else int(edit_rows > 0)
+    mask_wire_rows = (mask_values + width - 1) // width
+    expected_rows = condition_rows + edit_rows + mask_wire_rows
+    if expected_rows == 0:
+        if value.dtype != torch.float32 or tuple(value.shape) != (0,):
+            raise ValueError(f"MiniMax H3 empty {name} condition slot must be FP32 with shape [0]")
+        return None, None, None
+    if value.dtype != torch.float32 or value.ndim != 2 or tuple(value.shape) != (expected_rows, width):
+        raise ValueError(
+            f"MiniMax H3 packed {name} condition must be FP32 with shape "
+            f"[{expected_rows}, {width}], got {value.dtype} {tuple(value.shape)}"
+        )
+    cursor = 0
+    condition = value[:condition_rows].contiguous() if condition_rows else None
+    cursor += condition_rows
+    if edit_rows == 0:
+        return condition, None, None
+    clean_rows = value[cursor : cursor + edit_rows].contiguous()
+    cursor += edit_rows
+    raw_mask = value[cursor : cursor + mask_wire_rows].reshape(-1)[:mask_values].clone()
+    if mask_shape:
+        raw_mask = raw_mask.reshape(mask_shape)
+    else:
+        raw_mask = raw_mask.reshape(())
+    return condition, clean_rows, raw_mask
+
+
 def _wire_layout(payload: Mapping[str, Any]) -> torch.Tensor:
     private_metadata = payload.get("kv_metadata")
     if not isinstance(private_metadata, Mapping):
@@ -259,6 +358,11 @@ class MiniMaxH3EncoderMediaInput:
     video_audios: tuple[tuple[torch.Tensor, int] | None, ...] = ()
     audios: tuple[tuple[torch.Tensor, int], ...] = ()
     keyframe_frame_indices: tuple[int, ...] = ()
+    audio_mode: str = "native"
+    video_edit: torch.Tensor | None = None
+    video_edit_mask: torch.Tensor | None = None
+    audio_edit: tuple[torch.Tensor, int] | None = None
+    audio_edit_mask: torch.Tensor | None = None
 
     @classmethod
     def from_mm_tensors(
@@ -331,9 +435,41 @@ class MiniMaxH3EncoderMediaInput:
             if waveform.ndim not in (1, 2):
                 raise ValueError("MiniMax H3 audio must have shape [samples] or [channels, samples]")
             audios.append((waveform, sample_rate))
+
+        video_edit = None
+        video_edit_mask = None
+        if bool(metadata.get("has_video_edit", False)):
+            if cursor + 2 > len(tensors):
+                raise ValueError("MiniMax H3 encoder video edit input is truncated")
+            video_edit, video_edit_mask = tensors[cursor : cursor + 2]
+            cursor += 2
+            if tuple(video_edit.shape) != (num_frames, height, width, 3):
+                raise ValueError(
+                    "MiniMax H3 encoder video edit must have shape "
+                    f"[{num_frames}, {height}, {width}, 3], got {tuple(video_edit.shape)}"
+                )
+            _validate_edit_mask_structure(
+                video_edit_mask,
+                name="video",
+                shape=(latent_t, height // 16, width // 16),
+            )
+
+        audio_edit = None
+        audio_edit_mask = None
+        audio_edit_sample_rate = int(metadata.get("audio_edit_sample_rate", 0))
+        if audio_edit_sample_rate:
+            if cursor + 2 > len(tensors):
+                raise ValueError("MiniMax H3 encoder audio edit input is truncated")
+            waveform, audio_edit_mask = tensors[cursor : cursor + 2]
+            cursor += 2
+            if waveform.ndim not in (1, 2) or audio_edit_sample_rate <= 0:
+                raise ValueError("MiniMax H3 encoder audio edit requires a waveform and positive sample rate")
+            _validate_edit_mask_structure(audio_edit_mask, name="audio", shape=(2, audio_t))
+            audio_edit = (waveform, audio_edit_sample_rate)
         if cursor != len(tensors):
             raise ValueError(f"MiniMax H3 encoder media input has {len(tensors) - cursor} trailing tensors")
         return cls(
+            audio_mode=str(metadata.get("audio_mode", "native")),
             task=task,
             height=height,
             width=width,
@@ -345,6 +481,10 @@ class MiniMaxH3EncoderMediaInput:
             video_audios=tuple(video_audios),
             audios=tuple(audios),
             keyframe_frame_indices=tuple(int(value) for value in metadata.get("keyframe_frame_indices", ())),
+            video_edit=video_edit,
+            video_edit_mask=video_edit_mask,
+            audio_edit=audio_edit,
+            audio_edit_mask=audio_edit_mask,
         )
 
     def to_mm_tensors(self) -> list[torch.Tensor]:
@@ -362,6 +502,28 @@ class MiniMaxH3EncoderMediaInput:
         audio_items = [item for item in self.video_audios if item is not None] + list(self.audios)
         if any(waveform.ndim not in (1, 2) or int(sample_rate) <= 0 for waveform, sample_rate in audio_items):
             raise ValueError("MiniMax H3 encoder audio must have a waveform and positive sample rate")
+        video_edit_values = (self.video_edit, self.video_edit_mask)
+        if any(value is not None for value in video_edit_values):
+            if self.video_edit is None or self.video_edit_mask is None:
+                raise ValueError("MiniMax H3 encoder video edit requires a source and mask")
+            if tuple(self.video_edit.shape) != (self.num_frames, self.height, self.width, 3):
+                raise ValueError(
+                    "MiniMax H3 encoder video edit must have shape "
+                    f"[{self.num_frames}, {self.height}, {self.width}, 3], got {tuple(self.video_edit.shape)}"
+                )
+            _validate_edit_mask_structure(
+                self.video_edit_mask,
+                name="video",
+                shape=(self.latent_t, self.height // 16, self.width // 16),
+            )
+        audio_edit_values = (self.audio_edit, self.audio_edit_mask)
+        if any(value is not None for value in audio_edit_values):
+            if self.audio_edit is None or self.audio_edit_mask is None:
+                raise ValueError("MiniMax H3 encoder audio edit requires a source and mask")
+            waveform, sample_rate = self.audio_edit
+            if waveform.ndim not in (1, 2) or int(sample_rate) <= 0:
+                raise ValueError("MiniMax H3 encoder audio edit requires a waveform and positive sample rate")
+            _validate_edit_mask_structure(self.audio_edit_mask, name="audio", shape=(2, self.audio_t))
         tensors = [*self.images, *self.videos]
         for item in self.video_audios:
             if item is None:
@@ -369,10 +531,19 @@ class MiniMaxH3EncoderMediaInput:
             waveform, _sample_rate = item
             tensors.append(waveform)
         tensors.extend(waveform for waveform, _sample_rate in self.audios)
+        if self.video_edit is not None:
+            if self.video_edit_mask is None:
+                raise ValueError("MiniMax H3 encoder video edit requires a mask")
+            tensors.extend((self.video_edit, self.video_edit_mask))
+        if self.audio_edit is not None:
+            if self.audio_edit_mask is None:
+                raise ValueError("MiniMax H3 encoder audio edit requires a mask")
+            tensors.extend((self.audio_edit[0], self.audio_edit_mask))
         return tensors
 
     def to_metadata(self) -> dict[str, Any]:
-        return {
+        metadata = {
+            "audio_mode": self.audio_mode,
             "task": self.task,
             "height": self.height,
             "width": self.width,
@@ -387,6 +558,11 @@ class MiniMaxH3EncoderMediaInput:
             "audio_sample_rates": [sample_rate for _waveform, sample_rate in self.audios],
             "keyframe_frame_indices": list(self.keyframe_frame_indices),
         }
+        if self.video_edit is not None:
+            metadata["has_video_edit"] = True
+        if self.audio_edit is not None:
+            metadata["audio_edit_sample_rate"] = int(self.audio_edit[1])
+        return metadata
 
 
 @dataclass(frozen=True)
@@ -403,6 +579,11 @@ class MiniMaxH3EncoderMediaConditioning:
     audio_condition_lengths: tuple[int, ...] = ()
     ref_blocks: tuple[dict[str, Any], ...] = ()
     keyframe_frame_indices: tuple[int, ...] = ()
+    video_edit_clean_rows: torch.Tensor | None = None
+    video_edit_mask: torch.Tensor | None = None
+    audio_edit_clean_rows: torch.Tensor | None = None
+    audio_edit_mask: torch.Tensor | None = None
+    audio_edit_source_t: int = 0
 
     def to_omni_components(
         self,
@@ -418,7 +599,33 @@ class MiniMaxH3EncoderMediaConditioning:
             self.audio_condition,
             self.audio_condition_lengths,
         )
-        empty = torch.empty((0,), dtype=torch.float32)
+        video_mask_shape = (self.latent_t, self.height // 16, self.width // 16)
+        audio_mask_shape = (2, self.audio_t)
+        video_edit_rows = _validate_edit_tensors(
+            self.video_edit_clean_rows,
+            self.video_edit_mask,
+            name="video",
+            width=_VIDEO_CONDITION_WIDTH,
+            mask_shape=video_mask_shape,
+        )
+        audio_edit_rows = _validate_edit_tensors(
+            self.audio_edit_clean_rows,
+            self.audio_edit_mask,
+            name="audio",
+            width=_AUDIO_CONDITION_WIDTH,
+            mask_shape=audio_mask_shape,
+        )
+        expected_video_rows = self.latent_t * (self.height // 32) * (self.width // 32)
+        if video_edit_rows not in (0, expected_video_rows):
+            raise ValueError(f"MiniMax H3 video edit has {video_edit_rows} rows, expected {expected_video_rows}")
+        expected_audio_rows = self.audio_t * _AUDIO_CONDITION_CHANNELS
+        if audio_edit_rows not in (0, expected_audio_rows):
+            raise ValueError(f"MiniMax H3 audio edit has {audio_edit_rows} rows, expected {expected_audio_rows}")
+        if audio_edit_rows == 0:
+            if self.audio_edit_source_t != 0:
+                raise ValueError("MiniMax H3 audio_edit_source_t requires audio edit rows")
+        elif not 0 < self.audio_edit_source_t <= self.audio_t:
+            raise ValueError(f"MiniMax H3 audio_edit_source_t must be in [1, {self.audio_t}]")
         ref_rows = _ref_block_rows(self.ref_blocks)
         layout = [
             _ENCODER_WIRE_SCHEMA_ID,
@@ -433,14 +640,27 @@ class MiniMaxH3EncoderMediaConditioning:
             len(self.audio_condition_lengths),
             len(ref_rows),
             len(self.keyframe_frame_indices),
+            video_edit_rows,
+            audio_edit_rows,
+            self.audio_edit_source_t,
         ]
         layout.extend(item for shape in self.visual_condition_shapes for item in shape)
         layout.extend(self.audio_condition_lengths)
         layout.extend(item for row in ref_rows for item in row)
         layout.extend(self.keyframe_frame_indices)
         return (
-            self.visual_condition if self.visual_condition is not None else empty,
-            self.audio_condition if self.audio_condition is not None else empty,
+            _pack_condition_slot(
+                self.visual_condition,
+                self.video_edit_clean_rows,
+                self.video_edit_mask,
+                width=_VIDEO_CONDITION_WIDTH,
+            ),
+            _pack_condition_slot(
+                self.audio_condition,
+                self.audio_edit_clean_rows,
+                self.audio_edit_mask,
+                width=_AUDIO_CONDITION_WIDTH,
+            ),
             torch.tensor(layout, dtype=torch.int64),
         )
 
@@ -461,6 +681,11 @@ class MiniMaxH3EncoderConditioning:
     audio_condition_lengths: tuple[int, ...] = ()
     ref_blocks: tuple[dict[str, Any], ...] = ()
     keyframe_frame_indices: tuple[int, ...] = ()
+    video_edit_clean_rows: torch.Tensor | None = None
+    video_edit_mask: torch.Tensor | None = None
+    audio_edit_clean_rows: torch.Tensor | None = None
+    audio_edit_mask: torch.Tensor | None = None
+    audio_edit_source_t: int = 0
 
     @classmethod
     def from_components(
@@ -509,11 +734,16 @@ class MiniMaxH3EncoderConditioning:
         if layout.dtype not in _INTEGER_DTYPES or layout.ndim != 1:
             raise ValueError("MiniMax H3 encoder layout must be a one-dimensional integer tensor")
         values = [int(item) for item in layout.detach().cpu().tolist()]
-        if len(values) < 12:
+        if len(values) < 2:
+            raise ValueError("MiniMax H3 encoder layout header is truncated")
+        schema_id, version = values[:2]
+        if schema_id != _ENCODER_WIRE_SCHEMA_ID or version != STAGE_SCHEMA_VERSION:
+            raise ValueError(f"unsupported MiniMax H3 encoder wire schema {schema_id}:{version}")
+        if len(values) < 15:
             raise ValueError("MiniMax H3 encoder layout header is truncated")
         (
-            schema_id,
-            version,
+            _schema_id,
+            _version,
             task_code,
             height,
             width,
@@ -524,9 +754,10 @@ class MiniMaxH3EncoderConditioning:
             audio_count,
             ref_count,
             keyframe_count,
-        ) = values[:12]
-        if schema_id != _ENCODER_WIRE_SCHEMA_ID or version != STAGE_SCHEMA_VERSION:
-            raise ValueError(f"unsupported MiniMax H3 encoder wire schema {schema_id}:{version}")
+            video_edit_rows,
+            audio_edit_rows,
+            audio_edit_source_t,
+        ) = values[:15]
         task = _CODE_TO_TASK.get(task_code)
         if task is None:
             raise ValueError(f"unsupported MiniMax H3 wire task code {task_code!r}")
@@ -534,10 +765,12 @@ class MiniMaxH3EncoderConditioning:
             raise ValueError("MiniMax H3 encoder wire dimensions must be positive")
         if min(visual_count, audio_count, ref_count, keyframe_count) < 0:
             raise ValueError("MiniMax H3 encoder layout counts must be non-negative")
-        expected_size = 12 + 3 * visual_count + audio_count + 5 * ref_count + keyframe_count
+        if min(video_edit_rows, audio_edit_rows, audio_edit_source_t) < 0:
+            raise ValueError("MiniMax H3 encoder edit layout values must be non-negative")
+        expected_size = 15 + 3 * visual_count + audio_count + 5 * ref_count + keyframe_count
         if len(values) != expected_size:
             raise ValueError(f"MiniMax H3 encoder layout has {len(values)} integers, expected {expected_size}")
-        cursor = 12
+        cursor = 15
         visual_shapes = tuple(
             tuple(values[cursor + 3 * index : cursor + 3 * (index + 1)]) for index in range(visual_count)
         )
@@ -548,14 +781,55 @@ class MiniMaxH3EncoderConditioning:
         cursor += 5 * ref_count
         ref_blocks_tensor = torch.tensor(ref_rows, dtype=torch.int64).reshape(-1, 5)
         keyframe_frame_indices = tuple(values[cursor : cursor + keyframe_count])
-        visual_condition = visual if visual.numel() else None
-        audio_condition = audio if audio.numel() else None
+        video_mask_shape = (latent_t, height // 16, width // 16) if video_edit_rows else ()
+        audio_mask_shape = (2, audio_t) if audio_edit_rows else ()
+        visual_condition_rows = sum(t * (h // 2) * (w // 2) for t, h, w in visual_shapes)
+        audio_condition_rows = _AUDIO_CONDITION_CHANNELS * sum(audio_lengths)
+        visual_condition, video_edit_clean_rows, video_edit_mask = _unpack_condition_slot(
+            visual,
+            condition_rows=visual_condition_rows,
+            edit_rows=video_edit_rows,
+            mask_shape=video_mask_shape,
+            width=_VIDEO_CONDITION_WIDTH,
+            name="visual",
+        )
+        audio_condition, audio_edit_clean_rows, audio_edit_mask = _unpack_condition_slot(
+            audio,
+            condition_rows=audio_condition_rows,
+            edit_rows=audio_edit_rows,
+            mask_shape=audio_mask_shape,
+            width=_AUDIO_CONDITION_WIDTH,
+            name="audio",
+        )
         _validate_condition_tensors(
             visual_condition,
             visual_shapes,
             audio_condition,
             audio_lengths,
         )
+        _validate_edit_tensors(
+            video_edit_clean_rows,
+            video_edit_mask,
+            name="video",
+            width=_VIDEO_CONDITION_WIDTH,
+            mask_shape=(latent_t, height // 16, width // 16),
+        )
+        _validate_edit_tensors(
+            audio_edit_clean_rows,
+            audio_edit_mask,
+            name="audio",
+            width=_AUDIO_CONDITION_WIDTH,
+            mask_shape=(2, audio_t),
+        )
+        expected_video_edit_rows = latent_t * (height // 32) * (width // 32)
+        if video_edit_rows not in (0, expected_video_edit_rows):
+            raise ValueError(f"MiniMax H3 video edit has {video_edit_rows} rows, expected {expected_video_edit_rows}")
+        if audio_edit_rows not in (0, audio_t * _AUDIO_CONDITION_CHANNELS):
+            raise ValueError(f"MiniMax H3 audio edit has {audio_edit_rows} rows, expected {audio_t * 2}")
+        if (audio_edit_rows == 0 and audio_edit_source_t != 0) or (
+            audio_edit_rows and not 0 < audio_edit_source_t <= audio_t
+        ):
+            raise ValueError("MiniMax H3 encoder audio edit source length is inconsistent")
         return cls(
             hidden_states=text.hidden_states,
             token_tags=text.token_tags,
@@ -571,6 +845,11 @@ class MiniMaxH3EncoderConditioning:
             audio_condition_lengths=audio_lengths,
             ref_blocks=_decode_ref_blocks(ref_blocks_tensor),
             keyframe_frame_indices=keyframe_frame_indices,
+            video_edit_clean_rows=video_edit_clean_rows,
+            video_edit_mask=video_edit_mask,
+            audio_edit_clean_rows=audio_edit_clean_rows,
+            audio_edit_mask=audio_edit_mask,
+            audio_edit_source_t=audio_edit_source_t,
         )
 
     def to_omni_payload(self) -> dict[str, Any]:
@@ -593,6 +872,11 @@ class MiniMaxH3EncoderConditioning:
             audio_condition_lengths=self.audio_condition_lengths,
             ref_blocks=self.ref_blocks,
             keyframe_frame_indices=self.keyframe_frame_indices,
+            video_edit_clean_rows=self.video_edit_clean_rows,
+            video_edit_mask=self.video_edit_mask,
+            audio_edit_clean_rows=self.audio_edit_clean_rows,
+            audio_edit_mask=self.audio_edit_mask,
+            audio_edit_source_t=self.audio_edit_source_t,
         ).to_omni_components()
         return {
             "hidden_states": {"output": text.hidden_states},
diff --git a/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py b/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py
index 2d6998b7a..7ea4db459 100644
--- a/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py
+++ b/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py
@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import math
 import os
+import subprocess
 import tempfile
 from collections.abc import Callable, Mapping, Sequence
 from contextlib import AbstractContextManager, nullcontext
@@ -21,6 +22,7 @@ from vllm_omni.model_executor.models.minimax_h3.conditioning import (
     MiniMaxH3EncoderMediaConditioning,
     MiniMaxH3EncoderMediaInput,
 )
+from vllm_omni.model_executor.models.minimax_h3.long_video import max_output_seconds, resolve_long_video_mode
 from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
     MINIMAX_H3_OUTPUT_SHORT_EDGE,
     load_minimax_h3_images,
@@ -33,6 +35,7 @@ from vllm_omni.model_executor.models.minimax_h3.reference_video import (
     load_audio_file,
     load_video_audio,
     load_video_frames,
+    prepare_edit_video,
     prepare_reference_videos,
     sample_reference_video_frames,
     validate_reference_audio_files,
@@ -158,28 +161,25 @@ def resolve_minimax_h3_shape(
     if target is not None and not isinstance(target, Mapping):
         raise OmniClientError("MiniMax H3 extra_args['target'] must be an object")
     target = target if isinstance(target, Mapping) else {}
+    max_seconds = max_output_seconds(extra, task)
+    duration_range = f"in [4, {max_seconds:g}] seconds"
     duration = target.get("duration_seconds", extra.get("duration_seconds", extra.get("duration")))
     if duration is not None:
         if isinstance(duration, bool):
-            raise OmniClientError(f"MiniMax H3 output duration must be in [4, 15] seconds, got {duration!r}")
+            raise OmniClientError(f"MiniMax H3 output duration must be {duration_range}, got {duration!r}")
         try:
             duration = float(duration)
         except (TypeError, ValueError) as exc:
-            raise OmniClientError(f"MiniMax H3 output duration must be in [4, 15] seconds, got {duration!r}") from exc
-        if (
-            not math.isfinite(duration)
-            or not MINIMAX_H3_MIN_OUTPUT_SECONDS <= duration <= MINIMAX_H3_MAX_OUTPUT_SECONDS
-        ):
-            raise OmniClientError(f"MiniMax H3 output duration must be in [4, 15] seconds, got {duration}")
+            raise OmniClientError(f"MiniMax H3 output duration must be {duration_range}, got {duration!r}") from exc
+        if not math.isfinite(duration) or not MINIMAX_H3_MIN_OUTPUT_SECONDS <= duration <= max_seconds:
+            raise OmniClientError(f"MiniMax H3 output duration must be {duration_range}, got {duration}")
         requested_frames = int(round(duration * fps))
     elif int(getattr(sampling, "num_frames", None) or 1) > 1:
         requested_frames = int(sampling.num_frames)
     else:
         requested_frames = 124 if task == "ref2va" else 209
-    if not MINIMAX_H3_MIN_OUTPUT_SECONDS <= requested_frames / fps <= MINIMAX_H3_MAX_OUTPUT_SECONDS:
-        raise OmniClientError(
-            f"MiniMax H3 output duration must be in [4, 15] seconds, got {requested_frames / fps:.3f}"
-        )
+    if not MINIMAX_H3_MIN_OUTPUT_SECONDS <= requested_frames / fps <= max_seconds:
+        raise OmniClientError(f"MiniMax H3 output duration must be {duration_range}, got {requested_frames / fps:.3f}")
     num_frames = minimax_h3_align_frame_count(requested_frames)
 
     height = getattr(sampling, "height", None)
@@ -218,7 +218,10 @@ def _resolve_task(
     requested = extra_args.get("task")
     if requested is not None:
         return str(requested).lower()
-    if multi_modal_data.get("video") is not None or multi_modal_data.get("audio") is not None:
+    has_reference_audio = (
+        multi_modal_data.get("audio") is not None and extra_args.get("audio_mode", "native") != "lock_source"
+    )
+    if multi_modal_data.get("video") is not None or has_reference_audio:
         return "ref2va"
     if multi_modal_data.get("image") is not None:
         return "fl2va"
@@ -263,6 +266,101 @@ def _frames_to_tensor(frames: Sequence[Any]) -> torch.Tensor:
     )
 
 
+def _contains_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return True
+    if isinstance(value, torch.Tensor):
+        return value.dtype == torch.bool
+    return isinstance(value, (list, tuple)) and any(_contains_bool(item) for item in value)
+
+
+def _edit_mask(value: Any, *, name: str) -> torch.Tensor:
+    if _contains_bool(value):
+        raise OmniClientError(f"MiniMax H3 {name} must not contain booleans")
+    try:
+        mask = torch.as_tensor(value, dtype=torch.float32)
+    except (TypeError, ValueError, RuntimeError, OverflowError) as exc:
+        raise OmniClientError(f"MiniMax H3 {name} must be a finite numeric tensor") from exc
+    if mask.numel() == 0 or not bool(torch.isfinite(mask).all().item()):
+        raise OmniClientError(f"MiniMax H3 {name} must be non-empty and finite")
+    if bool(((mask < 0.0) | (mask > 1.0)).any().item()):
+        raise OmniClientError(f"MiniMax H3 {name} values must be in [0, 1]")
+    return mask
+
+
+def _canonical_video_edit_mask(
+    value: Any,
+    *,
+    latent_t: int,
+    latent_h: int,
+    latent_w: int,
+) -> torch.Tensor:
+    """Normalize every accepted request shape to one full latent grid."""
+    mask = _edit_mask(value, name="video_noise_mask")
+    token_shape = (latent_t, latent_h // 2, latent_w // 2)
+    full_shape = (latent_t, latent_h, latent_w)
+    row_count = math.prod(token_shape)
+    candidate = mask
+    while True:
+        if candidate.ndim == 0:
+            return candidate.expand(full_shape).contiguous()
+        if candidate.ndim == 1 and candidate.numel() == row_count:
+            candidate = candidate.reshape(token_shape)
+        if tuple(candidate.shape) == token_shape:
+            return candidate.repeat_interleave(2, dim=1).repeat_interleave(2, dim=2).contiguous()
+        if tuple(candidate.shape) == full_shape:
+            return candidate.contiguous()
+        if not candidate.ndim or candidate.shape[0] != 1:
+            break
+        candidate = candidate.squeeze(0)
+    raise OmniClientError(
+        "MiniMax H3 video_noise_mask shape must be "
+        f"scalar, ({row_count},), {token_shape}, or {full_shape}; got {tuple(mask.shape)}"
+    )
+
+
+def _canonical_audio_edit_mask(value: Any, *, audio_t: int) -> torch.Tensor:
+    """Normalize every accepted request shape to a channel-major grid."""
+    mask = _edit_mask(value, name="audio_noise_mask")
+    row_count = 2 * audio_t
+    candidate = mask
+    while True:
+        if candidate.ndim == 0:
+            return candidate.expand(2, audio_t).contiguous()
+        if candidate.ndim == 1 and candidate.numel() == audio_t:
+            return candidate.expand(2, audio_t).contiguous()
+        if candidate.ndim == 1 and candidate.numel() == row_count:
+            return candidate.reshape(2, audio_t).contiguous()
+        if tuple(candidate.shape) == (2, audio_t):
+            return candidate.contiguous()
+        if not candidate.ndim or candidate.shape[0] != 1:
+            break
+        candidate = candidate.squeeze(0)
+    raise OmniClientError(
+        "MiniMax H3 audio_noise_mask shape must be "
+        f"scalar, ({audio_t},), (2, {audio_t}), or ({row_count},); got {tuple(mask.shape)}"
+    )
+
+
+def _fit_audio_edit_rows(
+    rows: torch.Tensor,
+    source_audio_t: int,
+    *,
+    target_audio_t: int,
+) -> tuple[torch.Tensor, int]:
+    """Pad or trim channel-major clean source rows to the generated duration."""
+    if rows.ndim != 2 or rows.shape[0] % 2 or rows.shape[1] != 32:
+        raise ValueError("MiniMax H3 audio edit rows must have shape [2 * audio_t, 32]")
+    encoded_audio_t = int(rows.shape[0]) // 2
+    if not 0 < source_audio_t <= encoded_audio_t:
+        raise ValueError(f"MiniMax H3 source audio length must be in [1, {encoded_audio_t}]")
+    copied_t = min(source_audio_t, target_audio_t)
+    source = rows.reshape(2, encoded_audio_t, 32)
+    fitted = rows.new_zeros((2, target_audio_t, 32))
+    fitted[:, :copied_t] = source[:, :copied_t]
+    return fitted.reshape(2 * target_audio_t, 32).contiguous(), copied_t
+
+
 def _reuse_prepared_reference_videos(
     prepared: list[dict[str, Any]] | None,
     *,
@@ -331,14 +429,20 @@ def prepare_encoder_inputs(
     audio_values = _audio_items(raw_audio)
     diffusion_sampling_params = sampling
     extra_args = getattr(diffusion_sampling_params, "extra_args", None) or {}
+    audio_mode = extra_args.get("audio_mode", "native")
+    if audio_mode not in ("native", "lock_source"):
+        raise OmniClientError("MiniMax H3 audio_mode must be native or lock_source")
+    lock_audio = audio_mode == "lock_source"
+    if lock_audio and len(audio_values) != 1:
+        raise OmniClientError("MiniMax H3 lock_source requires exactly one driving audio")
     task = task if task is not None else _resolve_task(extra_args, multi_modal_data)
     raw_images = load_minimax_h3_images(image_values) if image_values else []
 
     if task == "t2va":
-        if raw_images or videos or audio_values:
+        if raw_images or videos or (audio_values and not lock_audio):
             raise OmniClientError("t2va does not accept image, video, or audio conditions")
     elif task == "fl2va":
-        if not raw_images or videos or audio_values:
+        if not raw_images or videos or (audio_values and not lock_audio):
             raise OmniClientError("fl2va requires image conditions only")
         if len(raw_images) > 2:
             raise OmniClientError("fl2va accepts at most first and last images")
@@ -356,6 +460,43 @@ def prepare_encoder_inputs(
         diffusion_sampling_params,
         raw_images[0] if raw_images else None,
     )
+    source_video = multi_modal_data.get("source_video")
+    source_audio = multi_modal_data.get("source_audio")
+    raw_video_edit_mask = multi_modal_data.get("video_noise_mask")
+    raw_audio_edit_mask = multi_modal_data.get("audio_noise_mask")
+    if (source_video is not None or source_audio is not None) and (
+        raw_video_edit_mask is None and raw_audio_edit_mask is None
+    ):
+        raise OmniClientError("MiniMax H3 edit sources require video_noise_mask or audio_noise_mask")
+    video_edit_mask = (
+        _canonical_video_edit_mask(
+            raw_video_edit_mask,
+            latent_t=latent_t,
+            latent_h=height // 16,
+            latent_w=width // 16,
+        )
+        if raw_video_edit_mask is not None
+        else None
+    )
+    audio_edit_mask = (
+        _canonical_audio_edit_mask(raw_audio_edit_mask, audio_t=audio_t) if raw_audio_edit_mask is not None else None
+    )
+    # An all-generate mask has no clean source dependency and remains a no-op.
+    if video_edit_mask is not None and bool(torch.all(video_edit_mask == 1.0).item()):
+        video_edit_mask = None
+    if audio_edit_mask is not None and bool(torch.all(audio_edit_mask == 1.0).item()):
+        audio_edit_mask = None
+    if resolve_long_video_mode(extra_args, task) == "continuation" and (
+        video_edit_mask is not None or audio_edit_mask is not None
+    ):
+        raise OmniClientError("MiniMax H3 continuation does not support latent-mask editing; use long_video_mode=full")
+    if lock_audio and audio_edit_mask is not None:
+        raise OmniClientError("MiniMax H3 audio_mode=lock_source cannot be combined with audio latent-mask editing")
+    if video_edit_mask is not None and source_video is None:
+        raise OmniClientError("MiniMax H3 video_noise_mask requires source_video")
+    if audio_edit_mask is not None and source_audio is None and source_video is None:
+        raise OmniClientError("MiniMax H3 audio_noise_mask requires source_audio or source_video")
+
     images = _prepare_encoder_images(
         task,
         raw_images,
@@ -427,14 +568,61 @@ def prepare_encoder_inputs(
                 audio_index += 1
                 condition_labels.append(("audio", audio_index))
             condition_labels.append(("video", video_index))
-        for _ in audio_values:
+        for _ in [] if lock_audio else audio_values:
             audio_index += 1
             condition_labels.append(("audio", audio_index))
 
-    if raw_audio is not None:
+    video_edit: torch.Tensor | None = None
+    edit_video_metadata: dict[str, Any] | None = None
+    if video_edit_mask is not None:
+        with tempfile.TemporaryDirectory(prefix="minimax_h3_edit_") as workdir:
+            try:
+                edit_video_metadata = prepare_edit_video(
+                    source_video,
+                    target_width=width,
+                    target_height=height,
+                    target_frame_count=num_frames,
+                    workdir=workdir,
+                )
+                edit_video_frames = load_video_frames(edit_video_metadata["prepared_path"])
+            except subprocess.CalledProcessError as exc:
+                raise OmniClientError("MiniMax H3 could not decode source_video for editing") from exc
+            video_edit = _frames_to_tensor(edit_video_frames)
+
+    audio_edit: tuple[torch.Tensor, int] | None = None
+    if audio_edit_mask is not None:
+        if source_audio is not None:
+            try:
+                waveform, sample_rate = _load_audio(source_audio)
+            except subprocess.CalledProcessError as exc:
+                raise OmniClientError("MiniMax H3 could not decode source_audio for editing") from exc
+        else:
+            if edit_video_metadata is not None and not edit_video_metadata["input_has_audio"]:
+                raise OmniClientError("MiniMax H3 source_video has no audio track for audio editing")
+            try:
+                waveform, sample_rate = load_video_audio(
+                    str(source_video),
+                    duration_seconds=float(num_frames) / MINIMAX_H3_FPS,
+                )
+            except subprocess.CalledProcessError as exc:
+                raise OmniClientError("MiniMax H3 could not decode source_video audio for editing") from exc
+        if waveform.ndim not in (1, 2) or int(sample_rate) <= 0:
+            raise OmniClientError("MiniMax H3 edit audio requires a waveform and positive sample rate")
+        max_samples = max(1, int(round(float(num_frames) / MINIMAX_H3_FPS * int(sample_rate))))
+        waveform = waveform[..., :max_samples].float().contiguous()
+        if waveform.shape[-1] == 0:
+            raise OmniClientError("MiniMax H3 edit audio must not be empty")
+        audio_edit = (waveform, int(sample_rate))
+
+    if raw_audio is not None and not lock_audio:
         validate_reference_audio_files(raw_audio)
     standalone_audios = _load_audios(raw_audio) if raw_audio is not None else []
-    validate_reference_audio_waveforms(standalone_audios)
+    if lock_audio:
+        waveform, rate = standalone_audios[0]
+        if rate <= 0 or waveform.ndim not in (1, 2) or waveform.numel() == 0 or not torch.isfinite(waveform).all():
+            raise OmniClientError("MiniMax H3 driving audio must be a finite non-empty waveform with a positive rate")
+    else:
+        validate_reference_audio_waveforms(standalone_audios)
     media_input = MiniMaxH3EncoderMediaInput(
         task=task,
         height=height,
@@ -447,6 +635,11 @@ def prepare_encoder_inputs(
         video_audios=tuple(video_audio_inputs),
         audios=tuple((waveform.float().contiguous(), int(sample_rate)) for waveform, sample_rate in standalone_audios),
         keyframe_frame_indices=tuple(keyframe_indices),
+        audio_mode=audio_mode,
+        video_edit=video_edit,
+        video_edit_mask=video_edit_mask,
+        audio_edit=audio_edit,
+        audio_edit_mask=audio_edit_mask,
     )
     audio_inputs = _effective_audio_inputs(
         media_input.video_audios,
@@ -456,7 +649,8 @@ def prepare_encoder_inputs(
     embedded_audio_count = sum(item is not None for item in media_input.video_audios)
     # Video soundtracks and standalone references have separate 15-second budgets.
     validate_reference_audio_waveforms(audio_inputs[:embedded_audio_count])
-    validate_reference_audio_waveforms(audio_inputs[embedded_audio_count:])
+    if not lock_audio:
+        validate_reference_audio_waveforms(audio_inputs[embedded_audio_count:])
 
     return PreparedEncoderInputs(
         prompt=text,
@@ -491,7 +685,8 @@ def encode_media(
     """
     visual_rows: list[torch.Tensor] = []
     visual_shapes: list[tuple[int, int, int]] = []
-    if media.images or media.videos:
+    video_edit_clean_rows: torch.Tensor | None = None
+    if media.images or media.videos or media.video_edit is not None:
         if video_vae is None:
             raise RuntimeError("MiniMax H3 video VAE is not resident on this rank")
         with component_scope(video_vae):
@@ -504,19 +699,34 @@ def encode_media(
                 rows, shape = video_vae.encode_video(frames)
                 visual_rows.append(rows)
                 visual_shapes.append(tuple(int(item) for item in shape))
+            if media.video_edit is not None:
+                frames = np.asarray(media.video_edit.detach().cpu().to(torch.uint8).contiguous().numpy())
+                rows, shape = video_vae.encode_video(frames)
+                shape = tuple(int(item) for item in shape)
+                expected_shape = (media.latent_t, media.height // 16, media.width // 16)
+                expected_rows = media.latent_t * (media.height // 32) * (media.width // 32)
+                if shape != expected_shape or tuple(rows.shape) != (expected_rows, 96):
+                    raise ValueError(
+                        "MiniMax H3 video edit encoder shape mismatch: "
+                        f"got latent shape {shape} and rows {tuple(rows.shape)}, "
+                        f"expected {expected_shape} and ({expected_rows}, 96)"
+                    )
+                video_edit_clean_rows = rows.to(dtype=torch.float32).contiguous()
 
     if not emit_conditioning:
         return None
 
     audio_rows: list[torch.Tensor] = []
     audio_lengths: list[int] = []
+    audio_edit_clean_rows: torch.Tensor | None = None
+    audio_edit_source_t = 0
     embedded_audio_count = sum(item is not None for item in media.video_audios)
     audio_inputs = _effective_audio_inputs(
         media.video_audios,
         media.audios,
         max_standalone_seconds=float(media.num_frames) / MINIMAX_H3_FPS,
     )
-    if audio_inputs:
+    if audio_inputs or media.audio_edit is not None:
         if audio_vae is None:
             raise RuntimeError("MiniMax H3 audio WVAE is not resident on the encoder leader")
         with component_scope(audio_vae):
@@ -524,10 +734,20 @@ def encode_media(
                 rows, length = audio_vae.encode_waveform(waveform, sample_rate)
                 audio_rows.append(rows)
                 audio_lengths.append(int(length))
-    if audio_lengths:
-        if any(length < 80 or length > 600 for length in audio_lengths):
+            if media.audio_edit is not None:
+                waveform, sample_rate = media.audio_edit
+                rows, source_audio_t = audio_vae.encode_waveform(waveform, sample_rate)
+                rows = rows.to(dtype=torch.float32).contiguous()
+                audio_edit_clean_rows, audio_edit_source_t = _fit_audio_edit_rows(
+                    rows,
+                    int(source_audio_t),
+                    target_audio_t=media.audio_t,
+                )
+    reference_lengths = audio_lengths[:-1] if media.audio_mode == "lock_source" else audio_lengths
+    if reference_lengths:
+        if any(length < 80 or length > 600 for length in reference_lengths):
             raise ValueError("MiniMax H3 audio references must each be between 2 and 15 seconds")
-        if sum(audio_lengths[:embedded_audio_count]) > 600 or sum(audio_lengths[embedded_audio_count:]) > 600:
+        if sum(reference_lengths[:embedded_audio_count]) > 600 or sum(reference_lengths[embedded_audio_count:]) > 600:
             raise ValueError("MiniMax H3 audio references must be at most 15 seconds in total")
 
     ref_blocks: list[dict[str, Any]] = []
@@ -551,8 +771,24 @@ def encode_media(
             "kind": "audio",
             "ref_audio_t": int(length),
         }
-        for length in audio_lengths[embedded_audio_count:]
+        for length in reference_lengths[embedded_audio_count:]
     )
+    video_edit_mask = None
+    if video_edit_clean_rows is not None:
+        if media.video_edit_mask is None:
+            raise ValueError("MiniMax H3 video edit rows require a mask")
+        video_edit_mask = media.video_edit_mask.to(
+            device=video_edit_clean_rows.device,
+            dtype=torch.float32,
+        ).contiguous()
+    audio_edit_mask = None
+    if audio_edit_clean_rows is not None:
+        if media.audio_edit_mask is None:
+            raise ValueError("MiniMax H3 audio edit rows require a mask")
+        audio_edit_mask = media.audio_edit_mask.to(
+            device=audio_edit_clean_rows.device,
+            dtype=torch.float32,
+        ).contiguous()
     return MiniMaxH3EncoderMediaConditioning(
         task=media.task,
         height=media.height,
@@ -566,4 +802,9 @@ def encode_media(
         audio_condition_lengths=tuple(audio_lengths),
         ref_blocks=tuple(ref_blocks),
         keyframe_frame_indices=media.keyframe_frame_indices,
+        video_edit_clean_rows=video_edit_clean_rows,
+        video_edit_mask=video_edit_mask,
+        audio_edit_clean_rows=audio_edit_clean_rows,
+        audio_edit_mask=audio_edit_mask,
+        audio_edit_source_t=audio_edit_source_t,
     )
diff --git a/vllm_omni/model_executor/models/minimax_h3/long_video.py b/vllm_omni/model_executor/models/minimax_h3/long_video.py
new file mode 100644
index 000000000..3c86efd9e
--- /dev/null
+++ b/vllm_omni/model_executor/models/minimax_h3/long_video.py
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Shared long-video request limits for encoder and diffusion entry points."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from vllm_omni.errors import OmniClientError
+
+MINIMAX_H3_MAX_FULL_SECONDS = 30.0
+MINIMAX_H3_MAX_CONTINUATION_SECONDS = 300.0
+
+
+def resolve_long_video_mode(extra: Mapping[str, Any], task: str) -> str:
+    long_video = extra.get("long_video", False)
+    if not isinstance(long_video, bool):
+        raise OmniClientError("MiniMax H3 long_video must be a boolean")
+    mode = extra.get("long_video_mode", "continuation" if long_video and task == "ref2va" else "full")
+    if mode not in ("full", "continuation"):
+        raise OmniClientError("MiniMax H3 long_video_mode must be full or continuation")
+    if mode == "continuation" and task != "ref2va":
+        raise OmniClientError("MiniMax H3 continuation requires Ref2VA request execution (not step execution)")
+    return mode
+
+
+def max_output_seconds(extra: Mapping[str, Any], task: str) -> float:
+    mode = resolve_long_video_mode(extra, task)
+    if not extra.get("long_video", False):
+        return 15.0
+    return MINIMAX_H3_MAX_CONTINUATION_SECONDS if mode == "continuation" else MINIMAX_H3_MAX_FULL_SECONDS
+
+
+def validate_encoded_frame_limit(extra: Mapping[str, Any], task: str, num_frames: int) -> None:
+    """Apply the same cap to externally encoded requests, allowing grid rounding."""
+    seconds = max_output_seconds(extra, task)
+    requested_max = int(seconds * 24)
+    aligned_max = ((requested_max - 5 + 16) // 17) * 17 + 5
+    if num_frames > aligned_max:
+        raise OmniClientError(
+            f"MiniMax H3 output duration exceeds the {seconds:g}-second request limit "
+            f"({aligned_max} frames after alignment); got {num_frames} frames"
+        )
diff --git a/vllm_omni/model_executor/models/minimax_h3/reference_video.py b/vllm_omni/model_executor/models/minimax_h3/reference_video.py
index 4b361b26c..6531f1265 100644
--- a/vllm_omni/model_executor/models/minimax_h3/reference_video.py
+++ b/vllm_omni/model_executor/models/minimax_h3/reference_video.py
@@ -324,10 +324,21 @@ def _transcode_reference_video(
     workdir: str,
     start_time_seconds: float = 0.0,
     duration_seconds: float | None = None,
+    pad_last_frame: bool = False,
 ) -> str:
     output = str(Path(workdir) / "prepared.mp4")
     duration_args = ["-t", f"{float(duration_seconds):.6f}"] if duration_seconds is not None else []
     frame_count_args = ["-frames:v", str(int(target_frame_count))] if target_frame_count > 0 else []
+    filters = [
+        f"fps={MINIMAX_H3_FPS:g}",
+        f"scale={target_width}:{target_height}:flags=lanczos",
+        "setsar=1",
+    ]
+    if pad_last_frame:
+        # Keep cloning the final converted frame until -frames:v reaches the
+        # requested target; longer inputs are deterministically trimmed by the
+        # same -frames:v limit without enabling this padding filter.
+        filters.append("tpad=stop_mode=clone:stop=-1")
     subprocess.run(
         [
             "ffmpeg",
@@ -342,7 +353,7 @@ def _transcode_reference_video(
             "0:v:0",
             "-an",
             "-vf",
-            (f"fps={MINIMAX_H3_FPS:g},scale={target_width}:{target_height}:flags=lanczos,setsar=1"),
+            ",".join(filters),
             *duration_args,
             *frame_count_args,
             "-metadata:s:v:0",
@@ -366,6 +377,41 @@ def _transcode_reference_video(
     return output
 
 
+def prepare_edit_video(
+    value: Any,
+    target_width: int,
+    target_height: int,
+    target_frame_count: int,
+    workdir: str,
+) -> dict[str, Any]:
+    """Resize an edit source and clone its last frame to the target length."""
+    if not isinstance(value, str | os.PathLike):
+        raise OmniClientError("MiniMax H3 edit video input must be a single file path")
+    source = str(value)
+    source_meta = _probe_video(source)
+    if int(source_meta.get("frame_count", 0)) <= 0:
+        raise OmniClientError(f"video has no frames: {source}")
+
+    Path(workdir).mkdir(parents=True, exist_ok=True)
+    prepared_path = _transcode_reference_video(
+        source,
+        target_width=target_width,
+        target_height=target_height,
+        target_frame_count=target_frame_count,
+        workdir=workdir,
+        pad_last_frame=True,
+    )
+
+    return {
+        "original_path": source,
+        "prepared_path": prepared_path,
+        "input_has_audio": bool(source_meta.get("audio_codecs")),
+        "width": target_width,
+        "height": target_height,
+        "frame_count": target_frame_count,
+    }
+
+
 def prepare_reference_videos(
     values: Any,
     *,
@@ -674,6 +720,7 @@ __all__ = [
     "load_audio_file",
     "load_video_audio",
     "load_video_frames",
+    "prepare_edit_video",
     "prepare_reference_videos",
     "sample_reference_video_frames",
     "validate_reference_audio_files",
diff --git a/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py b/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py
index 99dcb33e4..a8fd5b25d 100644
--- a/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py
+++ b/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # Copyright 2026 OpenMOSS and the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -8,7 +11,6 @@
 #
 # Vendored from OpenMOSS-Team/MOSS-Audio-Tokenizer (configuration_moss_audio_tokenizer.py
 # and modeling_moss_audio_tokenizer.py).  Simplified for inference-only use:
-#   - Streaming KV-cache infrastructure removed (single-pass batch decode only).
 #   - Training-only methods (forward, encode, decode) removed.
 #   - Dead branches removed: gating="none" always, weights_per_step=0 always,
 #     positional_embedding="rope" always, norm="layer_norm" always in default config.
@@ -155,6 +157,29 @@ class MossAudioTokenizerDecoderOutput(ModelOutput):
     audio_lengths: torch.Tensor | None = None
 
 
+@dataclass(frozen=True)
+class _StreamingExecutionContext:
+    state_slot_ids: torch.Tensor
+    valid_rows: torch.Tensor
+
+    def validate(self, *, batch_size: int, state_capacity: int, device: torch.device) -> None:
+        if self.state_slot_ids.shape != (batch_size,):
+            raise ValueError(f"Expected state_slot_ids shape ({batch_size},), got {tuple(self.state_slot_ids.shape)}")
+        if self.valid_rows.shape != (batch_size,):
+            raise ValueError(f"Expected valid_rows shape ({batch_size},), got {tuple(self.valid_rows.shape)}")
+        if self.state_slot_ids.device != device or self.valid_rows.device != device:
+            raise ValueError("Streaming execution metadata must be on the same device as decoder inputs.")
+        if self.state_slot_ids.dtype != torch.long or self.valid_rows.dtype != torch.bool:
+            raise TypeError("state_slot_ids must be int64 and valid_rows must be bool.")
+        if device.type == "cpu" and self.state_slot_ids.numel() > 0:
+            min_slot = int(self.state_slot_ids.min())
+            max_slot = int(self.state_slot_ids.max())
+            if min_slot < 0 or max_slot >= state_capacity:
+                raise ValueError(
+                    f"Decoder state slots must be in [0, {state_capacity}), got {self.state_slot_ids.tolist()}"
+                )
+
+
 # ---------------------------------------------------------------------------
 # Building blocks
 # ---------------------------------------------------------------------------
@@ -169,7 +194,12 @@ class _LayerScale(nn.Module):
         return self.scale * x
 
 
-def _apply_rope(q: torch.Tensor, k: torch.Tensor, max_period: float = 10_000) -> tuple[torch.Tensor, torch.Tensor]:
+def _apply_rope(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    offsets: torch.Tensor | None = None,
+    max_period: float = 10_000,
+) -> tuple[torch.Tensor, torch.Tensor]:
     """Rotary position embedding over sequence dimension (B, H, T, D).
 
     Matches upstream MossAudioTokenizer's ``apply_rope``: pair the last dim
@@ -181,7 +211,10 @@ def _apply_rope(q: torch.Tensor, k: torch.Tensor, max_period: float = 10_000) ->
     half = D // 2
     ds = torch.arange(half, device=q.device, dtype=torch.float32)
     freqs = torch.exp(ds * (-math.log(max_period) * 2 / D))
-    ts = torch.arange(T, device=q.device, dtype=torch.float32).view(1, 1, -1, 1)  # (1, 1, T, 1)
+    if offsets is None:
+        offsets = torch.zeros(B, device=q.device, dtype=torch.long)
+    ts = offsets.float().view(B, 1) + torch.arange(T, device=q.device, dtype=torch.float32)
+    ts = ts.view(B, 1, T, 1)
     rotr = torch.cos(freqs * ts)  # (1, 1, T, D/2)
     roti = torch.sin(freqs * ts)
 
@@ -201,8 +234,80 @@ def _apply_rope(q: torch.Tensor, k: torch.Tensor, max_period: float = 10_000) ->
     return qo, ko
 
 
+class _RingKVCache:
+    def __init__(
+        self,
+        state_capacity: int,
+        num_heads: int,
+        context: int,
+        head_dim: int,
+        *,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> None:
+        self.context = context
+        self.cache = torch.zeros(
+            (2, state_capacity, num_heads, context, head_dim),
+            device=device,
+            dtype=dtype,
+        )
+
+    def complete(
+        self,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        offsets: torch.Tensor,
+        execution_context: _StreamingExecutionContext,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        batch_size, num_heads, num_frames, head_dim = k.shape
+        slots = execution_context.state_slot_ids
+        row_cache = self.cache.index_select(1, slots)
+        cache_indexes = torch.arange(self.context, device=offsets.device, dtype=torch.long)
+        last_offset = offsets.view(-1, 1) - 1
+        end_index = last_offset % self.context
+        delta = cache_indexes - end_index
+        cached_positions = torch.where(
+            delta <= 0,
+            last_offset + delta,
+            last_offset + delta - self.context,
+        )
+        cached_positions = torch.where(
+            (cache_indexes < offsets.view(-1, 1)) & execution_context.valid_rows.view(-1, 1),
+            cached_positions,
+            torch.full_like(cached_positions, -1),
+        )
+        current_positions = offsets.view(-1, 1) + torch.arange(num_frames, device=offsets.device, dtype=offsets.dtype)
+        current_positions = torch.where(
+            execution_context.valid_rows.view(-1, 1),
+            current_positions,
+            torch.full_like(current_positions, -1),
+        )
+
+        # Keep this chunk separate from the pre-write cache so a ring wrap does
+        # not overwrite keys that early queries in the chunk still need.
+        keys = torch.cat((row_cache[0], k), dim=2)
+        values = torch.cat((row_cache[1], v), dim=2)
+        positions = torch.cat((cached_positions, current_positions), dim=1)
+
+        cache_frames = min(num_frames, self.context)
+        cache_start = offsets.view(-1, 1) + num_frames - cache_frames
+        indexes = torch.arange(cache_frames, device=offsets.device, dtype=offsets.dtype)
+        indexes = (indexes + cache_start) % self.context
+        scatter_indexes = indexes.view(batch_size, 1, cache_frames, 1).expand(-1, num_heads, -1, head_dim)
+        row_cache[0].scatter_(2, scatter_indexes, k[:, :, -cache_frames:])
+        row_cache[1].scatter_(2, scatter_indexes, v[:, :, -cache_frames:])
+        self.cache.index_copy_(1, slots, row_cache)
+        return keys, values, positions
+
+
+@dataclass
+class _AttentionStreamingState:
+    offsets: torch.Tensor
+    kv_cache: _RingKVCache
+
+
 class _Attention(nn.Module):
-    """Causal multi-head self-attention with RoPE, no streaming KV cache."""
+    """Causal multi-head self-attention with request-addressed streaming state."""
 
     def __init__(
         self,
@@ -220,6 +325,7 @@ class _Attention(nn.Module):
         self.causal = causal
         self.max_period = max_period
         self.context = context
+        self._streaming_state: _AttentionStreamingState | None = None
         kw = {"device": device, "dtype": dtype}
         self.in_proj = nn.Linear(embed_dim, 3 * embed_dim, bias=False, **kw)
         self.out_proj = nn.Linear(embed_dim, embed_dim, bias=False, **kw)
@@ -240,12 +346,58 @@ class _Attention(nn.Module):
                     dst = src.replace("in_projs.0.", "in_proj.").replace("out_projs.0.", "out_proj.")
                     state_dict[dst] = state_dict.pop(src)
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
+    def initialize_streaming_state(self, offsets: torch.Tensor) -> None:
+        if self._streaming_state is not None:
+            raise RuntimeError("MOSS Audio Tokenizer attention is already streaming.")
+        weight = self.in_proj.weight
+        head_dim = self.embed_dim // self.num_heads
+        self._streaming_state = _AttentionStreamingState(
+            offsets=offsets,
+            kv_cache=_RingKVCache(
+                offsets.shape[0],
+                self.num_heads,
+                self.context or 1024,
+                head_dim,
+                device=weight.device,
+                dtype=weight.dtype,
+            ),
+        )
+
+    def close_streaming_state(self) -> None:
+        self._streaming_state = None
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        execution_context: _StreamingExecutionContext | None = None,
+    ) -> torch.Tensor:
         B, T, _ = x.shape
         H, D = self.num_heads, self.embed_dim // self.num_heads
         qkv = self.in_proj(x).reshape(B, T, 3, H, D).permute(2, 0, 3, 1, 4)
         q, k, v = qkv[0], qkv[1], qkv[2]  # each (B, H, T, D)
-        q, k = _apply_rope(q, k, self.max_period)
+        state = self._streaming_state
+        if execution_context is None:
+            offsets = torch.zeros(B, device=x.device, dtype=torch.long)
+        else:
+            if state is None:
+                raise RuntimeError("MOSS Audio Tokenizer decoder state pool is not initialized.")
+            offsets = state.offsets.index_select(0, execution_context.state_slot_ids)
+        q, k = _apply_rope(q, k, offsets, self.max_period)
+
+        if execution_context is not None:
+            assert state is not None
+            k, v, key_positions = state.kv_cache.complete(k, v, offsets, execution_context)
+            query_positions = offsets.view(-1, 1, 1) + torch.arange(T, device=x.device).view(1, -1, 1)
+            delta = query_positions - key_positions.view(B, 1, -1)
+            mask = (key_positions.view(B, 1, -1) >= 0) & (delta >= 0)
+            if self.context is not None:
+                mask &= delta < self.context
+            out = F.scaled_dot_product_attention(q, k, v, attn_mask=mask.unsqueeze(1))
+            next_offsets = torch.where(execution_context.valid_rows, offsets + T, offsets)
+            state.offsets.index_copy_(0, execution_context.state_slot_ids, next_offsets)
+            out = out.transpose(1, 2).reshape(B, T, self.embed_dim)
+            return self.out_proj(out)
+
         if self.context is not None and self.context < T:
             # Local-windowed causal attention: query i may only see keys in
             # [i - context + 1, i]. Matches upstream's per-stage receptive
@@ -310,8 +462,12 @@ class _TransformerLayer(nn.Module):
             self.ls1 = nn.Identity()
             self.ls2 = nn.Identity()
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = x + self.ls1(self.attn(self.norm1(x)))
+    def forward(
+        self,
+        x: torch.Tensor,
+        execution_context: _StreamingExecutionContext | None = None,
+    ) -> torch.Tensor:
+        x = x + self.ls1(self.attn(self.norm1(x), execution_context))
         x = x + self.ls2(self.ff2(F.gelu(self.ff1(self.norm2(x)))))
         return x
 
@@ -340,9 +496,13 @@ class _Transformer(nn.Module):
             ]
         )
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
+    def forward(
+        self,
+        x: torch.Tensor,
+        execution_context: _StreamingExecutionContext | None = None,
+    ) -> torch.Tensor:
         for layer in self.layers:
-            x = layer(x)
+            x = layer(x, execution_context)
         return x
 
 
@@ -360,9 +520,14 @@ class _ProjectedTransformer(nn.Module):
             nn.Linear(d_model, output_dimension, bias=False) if output_dimension != d_model else nn.Identity()
         )
 
-    def forward(self, x: torch.Tensor, lengths: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def forward(
+        self,
+        x: torch.Tensor,
+        lengths: torch.Tensor,
+        execution_context: _StreamingExecutionContext | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         x = self.in_proj(x.transpose(1, 2))  # (B, D, T) → (B, T, d_model)
-        x = self.transformer(x)
+        x = self.transformer(x, execution_context)
         x = self.out_proj(x).transpose(1, 2)  # (B, T, D) → (B, D, T)
         return x, lengths
 
@@ -544,7 +709,7 @@ def _build_modules(
 
 
 class MossAudioTokenizerModel(PreTrainedModel):
-    """MOSS Audio Tokenizer — inference-only (batch_encode / batch_decode)."""
+    """MOSS Audio Tokenizer inference model with stateful decoder streaming."""
 
     config_class = MossAudioTokenizerConfig
     base_model_prefix = ""
@@ -579,8 +744,83 @@ class MossAudioTokenizerModel(PreTrainedModel):
 
         kw = dict(config.quantizer_kwargs)
         self.quantizer = _ResidualQ(**kw)
+        self._decoder_streaming_attentions: list[_Attention] = []
+        self._decoder_slot_offsets: torch.Tensor | None = None
+        self._decoder_state_capacity = 0
         self.post_init()
 
+    def initialize_decoder_state_pool(self, state_capacity: int, scratch_capacity: int = 0) -> None:
+        if state_capacity <= 0 or scratch_capacity < 0:
+            raise ValueError(f"Invalid decoder state capacities: state={state_capacity}, scratch={scratch_capacity}.")
+        if self._decoder_streaming_attentions:
+            raise RuntimeError("MOSS Audio Tokenizer decoder state pool is already initialized.")
+        attentions = [module for module in self.decoder.modules() if isinstance(module, _Attention)]
+        if not attentions:
+            raise RuntimeError("MOSS Audio Tokenizer decoder has no streaming attention layers.")
+        total_capacity = state_capacity + scratch_capacity
+        offsets = torch.zeros(
+            (len(attentions), total_capacity),
+            device=next(self.parameters()).device,
+            dtype=torch.long,
+        )
+        for index, attention in enumerate(attentions):
+            attention.initialize_streaming_state(offsets[index])
+        self._decoder_streaming_attentions = attentions
+        self._decoder_slot_offsets = offsets
+        self._decoder_state_capacity = total_capacity
+
+    def close_decoder_state_pool(self) -> None:
+        for attention in self._decoder_streaming_attentions:
+            attention.close_streaming_state()
+        self._decoder_streaming_attentions = []
+        self._decoder_slot_offsets = None
+        self._decoder_state_capacity = 0
+
+    def reset_decoder_state_slots(self, state_slot_ids: torch.Tensor) -> None:
+        if not self._decoder_streaming_attentions or self._decoder_slot_offsets is None:
+            raise RuntimeError("MOSS Audio Tokenizer decoder state pool is not initialized.")
+        if state_slot_ids.numel() == 0:
+            return
+        if state_slot_ids.device.type == "cpu":
+            min_slot = int(state_slot_ids.min())
+            max_slot = int(state_slot_ids.max())
+            if min_slot < 0 or max_slot >= self._decoder_state_capacity:
+                raise ValueError(
+                    f"Decoder state slots must be in [0, {self._decoder_state_capacity}), got {state_slot_ids.tolist()}"
+                )
+        slots = state_slot_ids.to(device=self._decoder_slot_offsets.device, dtype=torch.long)
+        # A zero offset marks every old ring-cache entry invalid, so the large
+        # KV buffers do not need to be cleared when a slot is reused.
+        self._decoder_slot_offsets.index_fill_(1, slots, 0)
+
+    def decode_streaming_batch(
+        self,
+        codes: torch.Tensor,
+        codes_lengths: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        valid_rows: torch.Tensor,
+    ) -> MossAudioTokenizerDecoderOutput:
+        if not self._decoder_streaming_attentions:
+            raise RuntimeError("MOSS Audio Tokenizer decoder state pool is not initialized.")
+        execution_context = _StreamingExecutionContext(state_slot_ids, valid_rows)
+        execution_context.validate(
+            batch_size=int(codes.shape[1]),
+            state_capacity=self._decoder_state_capacity,
+            device=codes.device,
+        )
+        audio, audio_lengths = self._decode_tensors(codes, codes_lengths, execution_context)
+        return MossAudioTokenizerDecoderOutput(audio=audio, audio_lengths=audio_lengths)
+
+    def decode_streaming_tensors(
+        self,
+        codes: torch.Tensor,
+        codes_lengths: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        valid_rows: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        execution_context = _StreamingExecutionContext(state_slot_ids, valid_rows)
+        return self._decode_tensors(codes, codes_lengths, execution_context)
+
     @torch.no_grad()
     def batch_encode(
         self,
@@ -688,13 +928,26 @@ class MossAudioTokenizerModel(PreTrainedModel):
         self,
         codes: torch.Tensor,
         lengths: torch.Tensor,
+        execution_context: _StreamingExecutionContext | None = None,
     ) -> MossAudioTokenizerDecoderOutput:
+        audio, audio_lengths = self._decode_tensors(codes, lengths, execution_context)
+        return MossAudioTokenizerDecoderOutput(audio=audio, audio_lengths=audio_lengths)
+
+    def _decode_tensors(
+        self,
+        codes: torch.Tensor,
+        lengths: torch.Tensor,
+        execution_context: _StreamingExecutionContext | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         z = self.quantizer.decode_codes(codes)
         d, d_len = z, lengths
         for m in self.decoder:
-            d, d_len = m(d, d_len)
+            if isinstance(m, _ProjectedTransformer):
+                d, d_len = m(d, d_len, execution_context)
+            else:
+                d, d_len = m(d, d_len)
         d, d_len = self._restore_channels_from_codec(d, d_len)
-        return MossAudioTokenizerDecoderOutput(audio=d, audio_lengths=d_len)
+        return d, d_len
 
 
 __all__ = [
diff --git a/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py b/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py
index 52815dd3b..4d277f44e 100644
--- a/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py
+++ b/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # Copyright 2026 OpenMOSS and the vLLM-Omni team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License").
@@ -30,11 +33,10 @@ logger = init_logger(__name__)
     }
 )
 class _MossStreamingDecodeCompileAdapter(nn.Module):
-    """Expose the BF16 codec streaming hot path to vLLM compile.
+    """Expose the codec streaming hot path to vLLM compile.
 
-    The dtype is part of the class identity intentionally: vLLM's AOT cache
-    drops runtime guards, so an artifact traced with the old FP32 decoder
-    weights must never be reused after the decoder is materialized as BF16.
+    The wrapper preserves the codec dtype: v1 decodes in FP32 to match its
+    quantizer output, while v2 uses BF16.
     """
 
     def __init__(self, codec: nn.Module, *, vllm_config: VllmConfig) -> None:
diff --git a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py
index c27949310..6fd097d71 100644
--- a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py
+++ b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py
@@ -63,7 +63,7 @@ class _MossCodecStreamSession:
         self._cudagraph_wrapper: CUDAGraphStreamingDecoderWrapper | None = None
         batch_sizes = sorted({int(size) for size in (graph_batch_sizes or []) if 0 < int(size) <= self._state_capacity})
         frame_sizes = sorted({int(size) for size in (graph_frame_sizes or []) if int(size) > 0})
-        scratch_capacity = max(batch_sizes, default=0) if self._device.type == "cuda" else 0
+        scratch_capacity = max(batch_sizes, default=0) if self._device.type in ("cuda", "npu") else 0
         self._total_state_capacity = self._state_capacity + scratch_capacity
         self._state_slot_ids = torch.arange(
             self._total_state_capacity,
@@ -76,15 +76,29 @@ class _MossCodecStreamSession:
             raise RuntimeError("The streaming codec does not implement a decoder state pool.")
         with torch.no_grad():
             initialize_state_pool(self._state_capacity, scratch_capacity)
-        if batch_sizes and frame_sizes and self._device.type == "cuda":
-            self._cudagraph_wrapper = CUDAGraphStreamingDecoderWrapper(
-                codec,
-                state_capacity=self._state_capacity,
-                batch_sizes=batch_sizes,
-                frame_sizes=frame_sizes,
-                num_quantizers=self._n_vq,
-                vllm_config=vllm_config,
-            )
+        if batch_sizes and frame_sizes and self._device.type in ("cuda", "npu"):
+            if self._device.type == "npu":
+                from vllm_omni.platforms.npu.models.moss_tts_streaming_decode_wrapper import (
+                    NPUGraphStreamingDecoderWrapper,
+                )
+
+                self._cudagraph_wrapper = NPUGraphStreamingDecoderWrapper(
+                    codec,
+                    state_capacity=self._state_capacity,
+                    batch_sizes=batch_sizes,
+                    frame_sizes=frame_sizes,
+                    num_quantizers=self._n_vq,
+                    vllm_config=vllm_config,
+                )
+            else:
+                self._cudagraph_wrapper = CUDAGraphStreamingDecoderWrapper(
+                    codec,
+                    state_capacity=self._state_capacity,
+                    batch_sizes=batch_sizes,
+                    frame_sizes=frame_sizes,
+                    num_quantizers=self._n_vq,
+                    vllm_config=vllm_config,
+                )
             self._cudagraph_wrapper.warmup(self._device)
             self.reset_slots(list(range(self._state_capacity + scratch_capacity)))
             if not self._cudagraph_wrapper.is_ready:
@@ -767,7 +781,8 @@ class MossTTSCodecDecoder(nn.Module):
         )
 
         codec.eval()
-        if device.type != "cpu":
+        # The v1 quantizer emits FP32 tensors, so its decoder must remain FP32.
+        if device.type != "cpu" and isinstance(codec, MossAudioTokenizerV2Model):
             codec.decoder.to(dtype=torch.bfloat16)
         attention_backend = getattr(self.vllm_config.model_config.hf_config, "codec_attention_backend", "sdpa")
         if attention_backend != "sdpa":
diff --git a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py
index ba19c02d1..a7e7606a3 100644
--- a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py
+++ b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py
@@ -222,6 +222,42 @@ class MossTTSLocalDepthTransformer(nn.Module):
         forward_prefix = self._compiled_forward_prefix or self._forward_prefix
         return forward_prefix(seq_embeds, kv_cache, position)
 
+    @staticmethod
+    def _sample_channel(
+        audio_lm_heads: nn.ModuleList,
+        local_hidden: torch.Tensor,
+        codes: torch.Tensor,
+        *,
+        channel_index: int,
+        repetition_penalty: float,
+        history_per_codebook: list[list[int]] | None,
+        temperature: float,
+        top_k: int,
+        top_p: float,
+        do_sample: bool,
+        generator: torch.Generator | None,
+    ) -> torch.Tensor:
+        """Compute channel logits, apply repetition penalty, sample, store."""
+        channel_logits = audio_lm_heads[channel_index](local_hidden).float()
+        if repetition_penalty != 1.0 and history_per_codebook is not None and channel_index < len(history_per_codebook):
+            hist = history_per_codebook[channel_index]
+            if hist:
+                hist_t = torch.tensor(hist, dtype=torch.long, device=channel_logits.device)
+                sel = channel_logits.index_select(-1, hist_t)
+                pos = sel > 0
+                sel = torch.where(pos, sel / repetition_penalty, sel * repetition_penalty)
+                channel_logits.index_copy_(-1, hist_t, sel)
+        channel_token = _sample_token(
+            channel_logits,
+            temperature,
+            top_k,
+            top_p,
+            do_sample,
+            generator=generator,
+        )
+        codes[:, channel_index] = channel_token
+        return channel_token
+
     @torch.no_grad()
     def generate_frame(
         self,
@@ -296,28 +332,19 @@ class MossTTSLocalDepthTransformer(nn.Module):
 
         codes = backbone_last_hidden.new_zeros((batch_size, n_vq), dtype=torch.long)
         for channel_index in range(n_vq):
-            channel_logits = audio_lm_heads[channel_index](local_hidden).float()
-            if (
-                repetition_penalty != 1.0
-                and history_per_codebook is not None
-                and channel_index < len(history_per_codebook)
-            ):
-                hist = history_per_codebook[channel_index]
-                if hist:
-                    hist_t = torch.tensor(hist, dtype=torch.long, device=channel_logits.device)
-                    sel = channel_logits.index_select(-1, hist_t)
-                    pos = sel > 0
-                    sel = torch.where(pos, sel / repetition_penalty, sel * repetition_penalty)
-                    channel_logits.index_copy_(-1, hist_t, sel)
-            channel_token = _sample_token(
-                channel_logits,
-                temperature,
-                top_k,
-                top_p,
-                do_sample,
+            channel_token = self._sample_channel(
+                audio_lm_heads,
+                local_hidden,
+                codes,
+                channel_index=channel_index,
+                repetition_penalty=repetition_penalty,
+                history_per_codebook=history_per_codebook,
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+                do_sample=do_sample,
                 generator=generator,
             )
-            codes[:, channel_index] = channel_token
 
             if channel_index + 1 < n_vq:
                 embeds = audio_embeddings[channel_index](channel_token).to(dtype)[:, None, :]
diff --git a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py
index 9d2d2d171..249289dc3 100644
--- a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py
+++ b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py
@@ -35,6 +35,7 @@ from vllm_omni.model_executor.models.moss_tts.modeling_moss_tts_local_depth impo
     MossTTSLocalDepthTransformer,
 )
 from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.platforms import current_omni_platform
 
 logger = init_logger(__name__)
 
@@ -44,10 +45,10 @@ def _maybe_prefix(prefix: str, name: str) -> str:
 
 
 def _iter_state_row_spans(
-    states: Sequence[dict[str, Any]],
+    states: Sequence[dict[str, Any] | None],
     spans: Sequence[tuple[int, int]] | None,
     num_rows: int,
-) -> Iterable[tuple[dict[str, Any], int, int]]:
+) -> Iterable[tuple[dict[str, Any] | None, int, int]]:
     """Yield state/logit-row ranges without assuming equal request row counts."""
     if num_rows <= 0 or not states:
         return
@@ -798,6 +799,9 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
     have_multimodal_outputs: bool = True
     has_preprocess: bool = True
     has_postprocess: bool = True
+    # Intermediate prefill chunks reach make_omni_output but must not produce
+    # audio until the scheduler has completed the prompt.
+    requires_request_sample_eligibility: bool = True
 
     AUDIO_BOS = 1025
     AUDIO_EOS = 1026
@@ -858,7 +862,7 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
         # We still need a logits_processor so vLLM downstream stays happy with
         # something callable; a minimal pass-through suffices.
         self.logits_processor = LogitsProcessor(self.text_vocab_size)
-        self._batch_state: list[dict[str, Any]] | None = None
+        self._batch_state: list[dict[str, Any] | None] | None = None
 
         # Stacked weight cache built after load_weights().
         # shape: (n_vq, audio_vocab_size, hidden_size)
@@ -972,13 +976,14 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
         span_len = int(input_ids.shape[0])
         audio_state = info_dict.get("audio_state")
         is_first_call = not isinstance(audio_state, dict)
+        is_prefill = bool(info_dict.get("_omni_is_prefill", span_len > 1))
 
-        if span_len > 1 or is_first_call:
+        if is_prefill or is_first_call:
             # Prefill: read the full reference-audio code grid (channels x T)
             # from ``info_dict["codes"]["ref"]``; slice the chunk that aligns
             # with this prefill window.
             ref_codes = (info_dict.get("codes", {}) or {}).get("ref")
-            ref_offset = int(info_dict.get("ref_offset", 0))
+            ref_offset = int(info_dict.get("_omni_num_computed_tokens", info_dict.get("ref_offset", 0)))
             chunk_audio = None
             if isinstance(ref_codes, torch.Tensor) and ref_codes.numel() > 0:
                 if ref_codes.dim() == 1 and ref_codes.numel() % self.n_vq == 0:
@@ -994,22 +999,24 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
                 if chunk_audio is not None
                 else torch.full((self.n_vq,), self.audio_pad_token, dtype=torch.long, device=device)
             )
-            # Capture the streaming-text list from the request (set by the
-            # realtime end2end builder; empty for the delay variants which
-            # don't take this code path anyway).
-            remaining = (info_dict.get("ids", {}) or {}).get("all")
-            if not isinstance(remaining, list):
-                remaining = []
             info_update: dict[str, Any] = {
-                "audio_state": {
+                "audio_codes": {"current": current_codes},
+                "ref_offset": ref_offset + span_len,
+            }
+            if is_first_call:
+                remaining = (info_dict.get("ids", {}) or {}).get("all")
+                if not isinstance(remaining, list):
+                    remaining = []
+                max_new_frames = info_dict.get("max_new_frames")
+                if isinstance(max_new_frames, (list, tuple)):
+                    max_new_frames = max_new_frames[0] if max_new_frames else None
+                info_update["audio_state"] = {
                     "is_stopping": False,
                     "step": 0,
                     "text_cursor": 0,
                     "remaining_text": list(remaining),
-                },
-                "audio_codes": {"current": current_codes},
-                "ref_offset": ref_offset + span_len,
-            }
+                    "max_new_frames": int(max_new_frames) if max_new_frames is not None else -1,
+                }
             return input_ids, embeds, info_update
 
         # Decode step: text_token from the just-sampled vLLM logit, plus the
@@ -1046,13 +1053,21 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
         info_dicts: list[dict[str, Any]] = (
             kwargs.get("model_intermediate_buffer") or kwargs.get("runtime_additional_information") or []
         )
+        sample_eligible = kwargs.get("request_sample_eligible")
+        eligible = [
+            sample_eligible is None or i >= len(sample_eligible) or bool(sample_eligible[i])
+            for i in range(len(info_dicts))
+        ]
 
         # Defensive state init.
         for info in info_dicts:
             if isinstance(info, dict) and not isinstance(info.get("audio_state"), dict):
                 info["audio_state"] = {"is_stopping": False, "step": 0}
 
-        self._batch_state = [(info["audio_state"] if isinstance(info, dict) else {}) for info in info_dicts]
+        self._batch_state = [
+            (info["audio_state"] if isinstance(info, dict) and eligible[i] else None)
+            for i, info in enumerate(info_dicts)
+        ]
         self._batch_state_spans = kwargs.get("request_token_spans")
 
         # See delay talker: real per-request row spans from the runner are
@@ -1074,6 +1089,8 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
             for i, info in enumerate(info_dicts):
                 if not isinstance(info, dict):
                     continue
+                if not eligible[i]:
+                    continue
                 row_start, row_end = spans[i]
                 row_end = min(int(row_end), num_rows)
                 if row_start >= row_end:
@@ -1115,10 +1132,13 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
                     )
 
                 ch0 = int(new_codes[0].item())
+                state["step"] = int(state.get("step", 0)) + 1
+                max_new_frames = int(state.get("max_new_frames", -1))
+                if max_new_frames > 0 and state["step"] >= max_new_frames:
+                    state["is_stopping"] = True
                 # Stop condition mirrors upstream: codebook 0 == eos_audio_id.
                 if ch0 == self.AUDIO_EOS:
                     state["is_stopping"] = True
-                    state["step"] = int(state.get("step", 0)) + 1
                     info["audio_codes"] = {
                         "current": new_codes,
                         "accumulated": (info.get("audio_codes", {}) or {}).get("accumulated"),
@@ -1127,7 +1147,6 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
 
                 if ch0 in (self.AUDIO_BOS, self.audio_pad_token):
                     # Skip the bos / pad frames — they don't decode to real audio.
-                    state["step"] = int(state.get("step", 0)) + 1
                     info["audio_codes"] = {
                         "current": new_codes,
                         "accumulated": (info.get("audio_codes", {}) or {}).get("accumulated"),
@@ -1141,7 +1160,6 @@ class MossTTSRealtimeTalkerForGeneration(nn.Module):
                     updated_acc = new_codes.unsqueeze(0)
 
                 info["audio_codes"] = {"current": new_codes, "accumulated": updated_acc}
-                state["step"] = int(state.get("step", 0)) + 1
                 per_req_codes[i] = new_codes.unsqueeze(0)
                 have_codes = True
 
@@ -1336,7 +1354,7 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
         # additive-fusion gathers (avoids an n_vq-iteration Python loop).
         self._stacked_audio_emb_w: torch.Tensor | None = None
         self.mtp_hidden_size = hidden_size
-        self.talker_mtp_graph_safe = True
+        self.talker_mtp_graph_safe = not current_omni_platform.is_npu()
         self.talker_mtp_output_key = ("audio_codes", "current")
         # ``make_omni_output`` keeps code rows fixed-shape and performs all
         # state updates eagerly, so the runner can safely pack/snapshot them
diff --git a/vllm_omni/model_executor/models/moss_tts/realtime_prompt.py b/vllm_omni/model_executor/models/moss_tts/realtime_prompt.py
new file mode 100644
index 000000000..985f76205
--- /dev/null
+++ b/vllm_omni/model_executor/models/moss_tts/realtime_prompt.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Prompt construction for MOSS-TTS-Realtime."""
+
+from typing import Any
+
+import numpy as np
+import torch
+
+REALTIME_AUDIO_CHANNELS = 16
+REALTIME_PREFILL_TEXT_TOKENS = 12
+
+
+def build_realtime_prompt(
+    tokenizer: Any,
+    processor: Any,
+    text: str,
+    reference_codes: torch.Tensor,
+) -> dict[str, Any]:
+    """Build the mixed text/audio prompt consumed by the Realtime talker."""
+    audio_tokens = reference_codes.detach().cpu().numpy()
+    system_grid = np.asarray(processor.make_ensemble(prompt_audio_tokens=audio_tokens), dtype=np.int64)
+    expected_width = REALTIME_AUDIO_CHANNELS + 1
+    if system_grid.ndim != 2 or system_grid.shape[1] != expected_width:
+        raise ValueError(
+            f"MOSS-TTS-Realtime processor returned shape {system_grid.shape}; "
+            f"expected (sequence_length, {expected_width})"
+        )
+
+    assistant_ids = tokenizer.encode("<|im_start|>assistant\n", add_special_tokens=False)
+    assistant_grid = np.full(
+        (len(assistant_ids), expected_width),
+        processor.audio_channel_pad,
+        dtype=np.int64,
+    )
+    assistant_grid[:, 0] = assistant_ids
+
+    text_ids = tokenizer.encode(text, add_special_tokens=False)
+    if not text_ids:
+        raise ValueError("MOSS-TTS-Realtime input is empty after tokenization")
+
+    prefill_len = min(len(text_ids), REALTIME_PREFILL_TEXT_TOKENS)
+    text_grid = np.full(
+        (prefill_len, expected_width),
+        processor.audio_channel_pad,
+        dtype=np.int64,
+    )
+    text_grid[:, 0] = text_ids[:prefill_len]
+    text_grid[-1, 1] = processor.audio_bos_token
+
+    prompt_grid = np.concatenate((system_grid, assistant_grid, text_grid), axis=0)
+    params: dict[str, Any] = {
+        "prompt_token_ids": prompt_grid[:, 0].tolist(),
+        "codes": {"ref": torch.from_numpy(prompt_grid[:, 1:].copy())},
+    }
+    remaining_text_ids = text_ids[prefill_len:]
+    if remaining_text_ids:
+        params["ids"] = {"all": remaining_text_ids}
+    return params
diff --git a/vllm_omni/model_executor/models/moss_tts/reference_encoder.py b/vllm_omni/model_executor/models/moss_tts/reference_encoder.py
index 36b2616e7..384336ebe 100644
--- a/vllm_omni/model_executor/models/moss_tts/reference_encoder.py
+++ b/vllm_omni/model_executor/models/moss_tts/reference_encoder.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Reference-audio encoding + speaker cache for the MOSS-TTS-family talker.
 
 This lives in the model package (not the shared serving layer) so all
@@ -15,7 +18,7 @@ arriving via different locators shares one entry), single-flight (concurrent
 requests for one uncached clip join a single encode), and micro-batched
 encoding (cold encodes arriving close together share one processor forward).
 
-Kept import-light (only ``asyncio`` / ``hashlib`` / ``torch`` plus the logger)
+Kept import-light (``asyncio`` / ``hashlib`` / ``numpy`` / ``torch`` plus the logger)
 so importing it from the API-server process does not pull the talker/codec.
 """
 
@@ -26,7 +29,9 @@ import hashlib
 from collections.abc import Awaitable, Callable
 from typing import Any
 
+import numpy as np
 import torch
+from numpy.typing import NDArray
 from vllm.logger import init_logger
 
 logger = init_logger(__name__)
@@ -38,14 +43,16 @@ _REF_ENCODE_MAX_BATCH = 8
 
 _INT32_MAX = 2**31
 
+_Waveform = NDArray[np.float32] | list[float]
+
 
 def _sha1(s: str) -> str:
     return hashlib.sha1((s or "").encode("utf-8")).hexdigest()
 
 
-def _prep_wav_sync(wav_list: list, sr: int, sr_target: int) -> torch.Tensor:
+def _prep_wav_sync(waveform: _Waveform, sr: int, sr_target: int) -> torch.Tensor:
     """Tensor-ise + resample one clip to ``sr_target`` (the blocking prep)."""
-    wav = torch.tensor(wav_list, dtype=torch.float32)
+    wav = torch.tensor(waveform, dtype=torch.float32)
     if wav.dim() == 1:
         wav = wav.unsqueeze(0)
     if sr != sr_target:
@@ -98,12 +105,12 @@ class _RefEncodeBatcher:
 
     def __init__(
         self,
-        encode_batch_fn: Callable[[list[tuple[list, int]]], list],
+        encode_batch_fn: Callable[[list[tuple[_Waveform, int]]], list],
         *,
         window_ms: float,
         max_batch: int,
     ):
-        # encode_batch_fn: sync, takes [(wav_list, sr), ...], returns a list of
+        # encode_batch_fn: sync, takes [(waveform, sr), ...], returns a list of
         # (codes_tensor | Exception) aligned to the input order.
         self._encode_batch_fn = encode_batch_fn
         self._window_s = max(0.0, float(window_ms) / 1000.0)
@@ -117,18 +124,23 @@ class _RefEncodeBatcher:
         if self._drainer is None or self._drainer.done():
             self._drainer = asyncio.create_task(self._drain_loop())
 
-    async def submit(self, wav_list: list, sr: int) -> torch.Tensor:
+    async def submit(self, waveform: _Waveform, sr: int) -> torch.Tensor:
         self._ensure_started()
         fut: asyncio.Future = asyncio.get_running_loop().create_future()
-        self._queue.put_nowait((wav_list, sr, fut))  # type: ignore[union-attr]
+        self._queue.put_nowait((waveform, sr, fut))  # type: ignore[union-attr]
         return await fut
 
     async def _drain_loop(self) -> None:
         assert self._queue is not None
         while True:
             first = await self._queue.get()
-            jobs = await self._coalesce(first)
-            await self._run_batch(jobs)
+            jobs = None
+            try:
+                jobs = await self._coalesce(first)
+                await self._run_batch(jobs)
+            finally:
+                # Do not retain the completed batch while waiting for new work.
+                del first, jobs
 
     async def _coalesce(self, first: tuple) -> list[tuple]:
         """Group ``first`` with jobs arriving within the batch window."""
@@ -152,8 +164,8 @@ class _RefEncodeBatcher:
                     break
         return jobs
 
-    async def _run_batch(self, jobs: list[tuple[list, int, asyncio.Future]]) -> None:
-        payload = [(wav_list, sr) for wav_list, sr, _ in jobs]
+    async def _run_batch(self, jobs: list[tuple[_Waveform, int, asyncio.Future]]) -> None:
+        payload = [(waveform, sr) for waveform, sr, _ in jobs]
         futs = [fut for _, _, fut in jobs]
         try:
             results = await asyncio.to_thread(self._encode_batch_fn, payload)
@@ -212,14 +224,14 @@ class MossReferenceEncoder:
         self,
         ref_str: str,
         *,
-        resolve_ref_audio: Callable[[str], Awaitable[tuple[list, int, str]]],
+        resolve_ref_audio: Callable[[str], Awaitable[tuple[_Waveform, int, str]]],
         get_artifact_key: Callable[[str], str | None],
         voice_name: str | None = None,
         voice_created_at: int = 0,
     ) -> tuple[torch.Tensor, str | None]:
         """Encode one reference clip into MOSS RVQ codes, reusing the cache.
 
-        ``resolve_ref_audio`` maps ``ref_str`` to ``(wav_list, sr, cache_key)``
+        ``resolve_ref_audio`` maps ``ref_str`` to ``(waveform, sr, cache_key)``
         where *cache_key* is the content-aware resolve key (it folds mtime/size
         for local files). ``get_artifact_key`` maps that resolve key to the
         waveform-content artifact key, or ``None`` when unknown.
@@ -288,13 +300,13 @@ class MossReferenceEncoder:
     async def _resolve_and_encode(
         self,
         ref_str: str,
-        resolve_ref_audio: Callable[[str], Awaitable[tuple[list, int, str]]],
+        resolve_ref_audio: Callable[[str], Awaitable[tuple[_Waveform, int, str]]],
         get_artifact_key: Callable[[str], str | None],
         voice_name: str | None,
         created_at: int,
     ) -> tuple[torch.Tensor, str]:
         """Flight body: resolve → re-check cache by content hash → batch-encode."""
-        wav_list, sr, resolve_key = await resolve_ref_audio(ref_str)
+        waveform, sr, resolve_key = await resolve_ref_audio(ref_str)
 
         # The content hash is available now that the clip is resolved; this also
         # catches the case where another flight populated the cache in between.
@@ -309,7 +321,7 @@ class MossReferenceEncoder:
         if cached is not None:
             return cached["codes"], resolve_key
 
-        codes = await self._batcher.submit(wav_list, sr)
+        codes = await self._batcher.submit(waveform, sr)
         compact = _to_compact_codes(codes)
         self._speaker_cache.put(key, {"codes": compact})
         logger.debug(
@@ -320,15 +332,15 @@ class MossReferenceEncoder:
         )
         return compact, resolve_key
 
-    def _encode_batch_sync(self, payload: list[tuple[list, int]]) -> list:
+    def _encode_batch_sync(self, payload: list[tuple[_Waveform, int]]) -> list:
         """Worker-thread body: prep each clip, then one batched forward."""
         n = len(payload)
         results: list = [None] * n
         prepared: list[torch.Tensor] = []
         prepared_idx: list[int] = []
-        for i, (wav_list, sr) in enumerate(payload):
+        for i, (waveform, sr) in enumerate(payload):
             try:
-                prepared.append(_prep_wav_sync(wav_list, sr, self._sr_target))
+                prepared.append(_prep_wav_sync(waveform, sr, self._sr_target))
                 prepared_idx.append(i)
             except Exception as exc:  # noqa: BLE001 — isolate this clip's failure
                 results[i] = exc
@@ -360,6 +372,18 @@ class MossReferenceEncoder:
         await self._batcher.aclose()
 
 
+class MossRealtimeReferenceEncoder(MossReferenceEncoder):
+    """Use the realtime codec with the shared reference cache and batcher."""
+
+    def _encode_prepared(self, prepared: list[torch.Tensor]) -> list[torch.Tensor]:
+        with torch.no_grad():
+            encoded = self._processor.batch_encode([wav.squeeze(0) for wav in prepared], num_quantizers=self._n_vq)
+        return [
+            encoded.audio_codes[:, i, : int(length.item())].transpose(0, 1).contiguous()
+            for i, length in enumerate(encoded.audio_codes_lengths)
+        ]
+
+
 def build_reference_encoder(
     processor: Any,
     *,
@@ -369,9 +393,17 @@ def build_reference_encoder(
     """Build the per-server encoder for a MOSS-TTS ``variant``.
 
     Derives the encode geometry (``n_vq`` and the working sample rate) from the
-    upstream processor's ``model_config`` so the variant knowledge stays in the
-    model package rather than in ``serving_speech.py``.
+    upstream processor's ``model_config``; Realtime takes its codec directly
+    and uses 16 codebooks at 24 kHz. Variant knowledge stays in the model package.
     """
+    if variant == "realtime":
+        return MossRealtimeReferenceEncoder(
+            processor,
+            variant=variant,
+            n_vq=16,
+            sr_target=24000,
+            speaker_cache=speaker_cache,
+        )
     n_vq = int(getattr(processor.model_config, "n_vq", 32))
     # Local-v1.5 encodes reference audio at a fixed 24 kHz working rate
     # regardless of its 48 kHz stereo *output* codec -- mirrors the offline
@@ -393,7 +425,7 @@ async def encode_request_references(
     ref_audio: str,
     ref_audio_2: str | None = None,
     *,
-    resolve_ref_audio: Callable[[str], Awaitable[tuple[list, int, str]]],
+    resolve_ref_audio: Callable[[str], Awaitable[tuple[_Waveform, int, str]]],
     get_artifact_key: Callable[[str], str | None],
     voice_name: str | None = None,
     voice_created_at: int = 0,
diff --git a/vllm_omni/model_executor/models/output_templates.py b/vllm_omni/model_executor/models/output_templates.py
index 9d6a84ac4..f8848cf51 100644
--- a/vllm_omni/model_executor/models/output_templates.py
+++ b/vllm_omni/model_executor/models/output_templates.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from typing import NamedTuple
 
 import torch
@@ -6,6 +9,18 @@ from vllm.sequence import IntermediateTensors
 from vllm_omni.data_entry_keys import OmniPayload
 
 
+class OwnedBatchTensor(NamedTuple):
+    """A batch tensor whose producer transfers ownership to the buffer.
+
+    The producer must have freshly allocated the tensor (e.g. an index_select
+    result) and must not write it afterwards. The buffer keeps row views
+    instead of taking a second snapshot. Tensors without this marker are
+    treated as borrowed (graph output / shared scratch) and still get a clone.
+    """
+
+    tensor: torch.Tensor
+
+
 class OmniOutput(NamedTuple):
     """Output from the merged Omni model containing both text and audio."""
 
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py b/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py
index 3b8813faf..356694380 100644
--- a/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py
@@ -43,6 +43,19 @@ FRAME_SIZE = 1920
 CODEBOOKS = 8
 
 
+def _normalize_active(active: torch.Tensor | None, all_active: torch.Tensor) -> torch.Tensor:
+    # Stage 0 and Code2Wav currently use one B=1 codec per session and omit
+    # `active`, so preserve that API by treating None as all rows active. When
+    # they switch to shared B>1 codecs, their batch builders must pass bool[B]:
+    # True advances that row's streaming state; False keeps an absent or padded
+    # row's offsets and convolution carries unchanged.
+    if active is None:
+        return all_active
+    if active.shape != all_active.shape:
+        raise ValueError(f"active must have shape {tuple(all_active.shape)}, got {tuple(active.shape)}")
+    return active.to(device=all_active.device, dtype=torch.bool)
+
+
 def _map_moshi_codec_weights(
     state_dict: dict[str, torch.Tensor],
 ) -> dict[str, torch.Tensor]:
@@ -107,23 +120,24 @@ class _StreamConv1d:
     def reset(self, batch_size: int, device, dtype) -> None:
         pad = self.kernel - self.stride
         self.prev = torch.zeros(batch_size, self.conv.in_channels, pad, device=device, dtype=dtype)
-        self._fresh = torch.ones(batch_size, dtype=torch.bool)
+        self._fresh = torch.ones(batch_size, dtype=torch.bool, device=device)
 
     def reset_slot(self, b: int) -> None:
         self.prev[b].zero_()
         self._fresh[b] = True
 
-    def __call__(self, x: torch.Tensor) -> torch.Tensor:
-        if self.pad_mode == "replicate" and bool(self._fresh.any()):
+    def __call__(self, x: torch.Tensor, active: torch.Tensor) -> torch.Tensor:
+        if self.pad_mode == "replicate":
             pad = self.prev.shape[-1]
             edge = x[..., 0:1].expand(-1, -1, pad)
-            fresh = self._fresh.to(x.device).view(-1, 1, 1)
+            fresh = (self._fresh & active).view(-1, 1, 1)
             self.prev = torch.where(fresh, edge.to(self.prev.dtype), self.prev)
-        self._fresh[:] = False
+        self._fresh[active] = False
         x = torch.cat([self.prev, x], dim=-1)
         t = x.shape[-1]
         num_frames = max(0, (t - self.kernel) // self.stride + 1)
-        self.prev = x[..., num_frames * self.stride :]
+        prev = x[..., num_frames * self.stride :]
+        self.prev = torch.where(active.view(-1, 1, 1), prev, self.prev)
         if num_frames == 0:
             return x.new_zeros(x.shape[0], self.conv.out_channels, 0)
         return self.conv(x[..., : (num_frames - 1) * self.stride + self.kernel])
@@ -137,18 +151,19 @@ class _StreamConvTr1d:
         self.kernel = conv.kernel_size[0]
         self.stride = conv.stride[0]
         self.partial: torch.Tensor | None = None
+        self._fresh: torch.Tensor | None = None
 
     def reset(self, batch_size: int, device, dtype) -> None:
         self.partial = torch.zeros(
             batch_size, self.conv.out_channels, self.kernel - self.stride, device=device, dtype=dtype
         )
-        self._fresh = torch.ones(batch_size, dtype=torch.bool)
+        self._fresh = torch.ones(batch_size, dtype=torch.bool, device=device)
 
     def reset_slot(self, b: int) -> None:
         self.partial[b].zero_()
         self._fresh[b] = True
 
-    def __call__(self, x: torch.Tensor) -> torch.Tensor:
+    def __call__(self, x: torch.Tensor, active: torch.Tensor) -> torch.Tensor:
         out = self.conv(x)
         length = out.shape[-1]
         tail = self.kernel - self.stride
@@ -159,10 +174,11 @@ class _StreamConvTr1d:
             # it again, so subtract one copy -- except on a row's very first
             # frame, where the carry is zeros by construction.
             merge = merge - self.conv.bias[:, None]
-            merge[self._fresh] = 0.0
-            self._fresh[:] = False
+            merge[self._fresh & active] = 0.0
+            self._fresh[active] = False
         out[..., :pt] += merge
-        self.partial = out[..., length - tail :].clone()
+        partial = out[..., length - tail :].clone()
+        self.partial = torch.where(active.view(-1, 1, 1), partial, self.partial)
         return out[..., : length - tail]
 
 
@@ -183,16 +199,23 @@ class _MimiTransformerLayer(nn.Module):
         self.scale1 = nn.Parameter(torch.empty(dim))
         self.scale2 = nn.Parameter(torch.empty(dim))
 
-    def forward(self, x: torch.Tensor, kv: _RingKV, offset: torch.Tensor, context: int) -> torch.Tensor:
+    def forward(
+        self,
+        x: torch.Tensor,
+        kv: _RingKV,
+        offset: torch.Tensor,
+        context: int,
+        active: torch.Tensor,
+    ) -> torch.Tensor:
         B, T, _ = x.shape
         h = self.norm1(x)
         qkv = F.linear(h, self.in_proj_weight)
         qkv = qkv.view(B, T, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
         q, k, v = qkv[0], qkv[1], qkv[2]
         q, k = _apply_rope(q, k, offset)
-        keys, values, pos_k = kv.complete(k, v)
+        keys, values, pos_k = kv.complete(k, v, active=active)
         pos_k = pos_k.view(pos_k.shape[0], 1, pos_k.shape[1])
-        pos_q = offset + torch.arange(T, device=q.device, dtype=torch.long).view(1, -1, 1)
+        pos_q = offset.view(-1, 1, 1) + torch.arange(T, device=q.device, dtype=torch.long).view(1, -1, 1)
         delta = pos_q - pos_k
         attn_bias = (pos_k >= 0) & (delta >= 0) & (delta < context)
         attn = F.scaled_dot_product_attention(q, keys, values, attn_bias.unsqueeze(1), dropout_p=0.0)
@@ -218,7 +241,7 @@ class _MimiStreamingTransformer(nn.Module):
         heads = self.layers[0].num_heads
         hd = self.layers[0].head_dim
         self._kv = [_RingKV(batch_size, heads, hd, self.context, p.device, p.dtype) for _ in self.layers]
-        self._offset = torch.zeros(1, device=p.device, dtype=torch.long)
+        self._offset = torch.zeros(batch_size, device=p.device, dtype=torch.long)
 
     def reset_streaming(self) -> None:
         for kv in self._kv:
@@ -229,11 +252,11 @@ class _MimiStreamingTransformer(nn.Module):
         for kv in self._kv:
             kv.reset_slot(b)
 
-    def step(self, x: torch.Tensor) -> torch.Tensor:
+    def step(self, x: torch.Tensor, active: torch.Tensor) -> torch.Tensor:
         """``x`` is ``[B, T, dim]`` (T = positions this frame, typically 2)."""
         for layer, kv in zip(self.layers, self._kv):
-            x = layer(x, kv, self._offset, self.context)
-        self._offset.add_(x.shape[1])
+            x = layer(x, kv, self._offset, self.context, active)
+        self._offset.add_(x.shape[1] * active.to(self._offset.dtype))
         return x
 
     def load_weights(self, state_dict: dict[str, torch.Tensor], prefix: str) -> int:
@@ -339,6 +362,7 @@ class PersonaPlexMimiCodec(nn.Module):
         self._upsample = _StreamConvTr1d(m.upsample.conv)
         self._dec_stages = _walk_seanet(m.decoder.layers)
         self._batch_size: int | None = None
+        self._all_active: torch.Tensor
 
     # -- streaming state ------------------------------------------------------
 
@@ -354,6 +378,7 @@ class PersonaPlexMimiCodec(nn.Module):
 
     def streaming_init(self, batch_size: int) -> None:
         self._batch_size = batch_size
+        self._all_active = torch.ones(batch_size, dtype=torch.bool, device=self.device)
         for s in self._conv_states():
             s.reset(batch_size, self.device, self.dtype)
         self.encoder_transformer.streaming_init(batch_size)
@@ -376,39 +401,42 @@ class PersonaPlexMimiCodec(nn.Module):
     # -- per-frame codec -------------------------------------------------------
 
     @staticmethod
-    def _run_stages(x: torch.Tensor, stages) -> torch.Tensor:
+    def _run_stages(x: torch.Tensor, stages, active: torch.Tensor) -> torch.Tensor:
         for kind, stage in stages:
             if kind == "res":
                 act0, conv1, act2, conv3 = stage
-                x = x + conv3(act2(conv1(act0(x))))
+                x = x + conv3(act2(conv1(act0(x), active)), active)
             else:
-                x = stage(x)
+                x = stage(x, active) if kind in {"conv", "convtr"} else stage(x)
         return x
 
     @torch.no_grad()
-    def encode_frame(self, pcm: torch.Tensor) -> torch.Tensor:
+    def encode_frame(self, pcm: torch.Tensor, active: torch.Tensor | None = None) -> torch.Tensor:
         """``[B, frame_size]`` float PCM -> ``[B, 8]`` codes."""
         x = pcm.to(self.device, self.dtype).view(-1, 1, FRAME_SIZE)
-        x = self._run_stages(x, self._enc_stages)
-        x = self.encoder_transformer.step(x.transpose(1, 2)).transpose(1, 2)
-        x = self._downsample(x)
+        active = _normalize_active(active, self._all_active)
+        x = self._run_stages(x, self._enc_stages, active)
+        x = self.encoder_transformer.step(x.transpose(1, 2), active).transpose(1, 2)
+        x = self._downsample(x, active)
         codes = self.model.quantizer.encode(x)  # [Q, B, T]
         return codes[:CODEBOOKS, :, 0].transpose(0, 1).contiguous()
 
     @torch.no_grad()
-    def decode_frame(self, codes: torch.Tensor) -> torch.Tensor:
+    def decode_frame(self, codes: torch.Tensor, active: torch.Tensor | None = None) -> torch.Tensor:
         """``[B, 8]`` codes -> ``[B, frame_size]`` float PCM."""
         emb = self.model.quantizer.decode(codes.to(self.device).view(-1, CODEBOOKS, 1))
-        emb = self._upsample(emb)
-        emb = self.decoder_transformer.step(emb.transpose(1, 2)).transpose(1, 2)
-        x = self._run_stages(emb, self._dec_stages)
+        active = _normalize_active(active, self._all_active)
+        emb = self._upsample(emb, active)
+        emb = self.decoder_transformer.step(emb.transpose(1, 2), active).transpose(1, 2)
+        x = self._run_stages(emb, self._dec_stages, active)
         return x[:, 0, :]
 
     @torch.no_grad()
-    def decode_frames(self, codes: torch.Tensor) -> torch.Tensor:
+    def decode_frames(self, codes: torch.Tensor, active: torch.Tensor | None = None) -> torch.Tensor:
         """``[B, 8, F]`` codes -> ``[B, F * frame_size]`` float PCM."""
         emb = self.model.quantizer.decode(codes.to(self.device))
-        emb = self._upsample(emb)
-        emb = self.decoder_transformer.step(emb.transpose(1, 2)).transpose(1, 2)
-        x = self._run_stages(emb, self._dec_stages)
+        active = _normalize_active(active, self._all_active)
+        emb = self._upsample(emb, active)
+        emb = self.decoder_transformer.step(emb.transpose(1, 2), active).transpose(1, 2)
+        x = self._run_stages(emb, self._dec_stages, active)
         return x[:, 0, :]
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py b/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py
index 717e4d505..28759dafb 100644
--- a/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Streaming Helium temporal transformer for PersonaPlex (moshi-free, plain torch).
 
 Frame-clocked duplex needs a stateful per-frame forward: one 80 ms step consumes
@@ -49,8 +49,8 @@ def _apply_rope(q: torch.Tensor, k: torch.Tensor, offset: torch.Tensor, max_peri
     B, H, T, D = q.shape
     ds = torch.arange(D // 2, device=q.device, dtype=torch.float32)
     freqs = torch.exp(ds * (-math.log(max_period) * 2 / D))
-    ts = offset.float() + torch.arange(T, device=q.device, dtype=torch.float32)
-    ts = ts.view(1, -1, 1)
+    ts = offset.float().view(-1, 1) + torch.arange(T, device=q.device, dtype=torch.float32)
+    ts = ts.view(-1, 1, T, 1)
 
     dims = q.shape[:-1]
     q = q.view(*dims, D // 2, 2)
@@ -80,7 +80,7 @@ class _RingKV:
     def __init__(self, batch_size: int, num_heads: int, dim_per_head: int, capacity: int, device, dtype):
         self.capacity = capacity
         self.cache = torch.zeros((2, batch_size, num_heads, capacity, dim_per_head), device=device, dtype=dtype)
-        self.end_offset = torch.zeros(1, device=device, dtype=torch.long)
+        self.end_offset = torch.zeros(batch_size, device=device, dtype=torch.long)
         self.start_offset = torch.zeros(batch_size, device=device, dtype=torch.long)
 
     def reset(self) -> None:
@@ -90,23 +90,36 @@ class _RingKV:
     def reset_slot(self, b: int) -> None:
         # Mask everything written so far for row b; the row's next write is its
         # first visible entry. (LM sacrifice-tick +1 is applied by the caller.)
-        self.start_offset[b] = self.end_offset.clone()
+        self.start_offset[b] = self.end_offset[b]
 
     def bump_slot_start(self, b: int) -> None:
         self.start_offset[b] += 1
 
-    def complete(self, k: torch.Tensor, v: torch.Tensor):
+    def complete(self, k: torch.Tensor, v: torch.Tensor, active: torch.Tensor):
         B, H, T, D = k.shape
-        indexes = torch.arange(T, device=self.end_offset.device, dtype=self.end_offset.dtype) + self.end_offset
-        indexes = indexes % self.capacity
-        self.cache[0].index_copy_(2, indexes, k)
-        self.cache[1].index_copy_(2, indexes, v)
-        self.end_offset.add_(T)
+        indexes = (
+            torch.arange(T, device=self.end_offset.device, dtype=self.end_offset.dtype).view(1, -1)
+            + self.end_offset.view(-1, 1)
+        ) % self.capacity
+        idx4 = indexes.view(B, 1, T, 1).expand(-1, H, -1, D)
+        # Keep inactive rows completely inert. Once the ring is full, the
+        # physical future-write slot is also addressable by the position mask;
+        # writing it for an inactive row would therefore leak padded data into
+        # its next attention step.
+        active_view = active.view(B, 1, 1, 1)
+        old_k = self.cache[0].gather(2, idx4)
+        old_v = self.cache[1].gather(2, idx4)
+        k = torch.where(active_view, k, old_k)
+        v = torch.where(active_view, v, old_v)
+        self.cache[0].scatter_(2, idx4, k)
+        self.cache[1].scatter_(2, idx4, v)
+        self.end_offset.add_(T * active.to(self.end_offset.dtype))
 
         idx = torch.arange(self.capacity, device=self.end_offset.device, dtype=torch.long)
-        invalid = idx >= self.end_offset
-        end_index = self.end_offset % self.capacity
-        delta = idx - end_index
+        end_offset = self.end_offset.view(-1, 1)
+        invalid = idx.view(1, -1) >= end_offset
+        end_index = end_offset % self.capacity
+        delta = idx.view(1, -1) - end_index
         # `delta <= 0` (not `< 0`) is moshi's exact convention (transformer.py
         # RingKVCache.complete). It labels the just-past-newest slot as the future
         # write position, so once the ring has wrapped the single oldest in-window
@@ -114,14 +127,19 @@ class _RingKV:
         # verbatim from the reference and only shows after the window fills (Helium
         # ~3000 frames / 240 s); it costs one frame out of thousands. Do NOT change
         # this to `< 0`: it would diverge from moshi and break greedy bit-parity.
-        positions = torch.where(delta <= 0, self.end_offset + delta, self.end_offset + delta - self.capacity)
+        positions = torch.where(delta <= 0, end_offset + delta, end_offset + delta - self.capacity)
         positions = torch.where(invalid, torch.full_like(positions, -1), positions)
-        positions = positions.view(1, -1)  # [1, capacity]
         below = positions < self.start_offset.view(-1, 1)  # [B, capacity]
         positions = torch.where(below, torch.full_like(positions, -1), positions)
         return self.cache[0], self.cache[1], positions
 
 
+def _normalize_temporal_active(active: torch.Tensor, reference: torch.Tensor) -> torch.Tensor:
+    if active.shape != reference.shape:
+        raise ValueError(f"active must have shape {tuple(reference.shape)}, got {tuple(active.shape)}")
+    return active.to(device=reference.device, dtype=torch.bool)
+
+
 class _TemporalLayer(nn.Module):
     """One Helium decoder layer in the checkpoint's fused layout."""
 
@@ -137,7 +155,14 @@ class _TemporalLayer(nn.Module):
         self.norm1_alpha = nn.Parameter(torch.ones(1, 1, dim))
         self.norm2_alpha = nn.Parameter(torch.ones(1, 1, dim))
 
-    def forward(self, x: torch.Tensor, kv: _RingKV, offset: torch.Tensor, context: int) -> torch.Tensor:
+    def forward(
+        self,
+        x: torch.Tensor,
+        kv: _RingKV,
+        offset: torch.Tensor,
+        context: int,
+        active: torch.Tensor,
+    ) -> torch.Tensor:
         B, T, _ = x.shape
         h = _rms_norm_f32(x, self.norm1_alpha, 1e-8)
         qkv = F.linear(h, self.in_proj_weight)
@@ -147,9 +172,9 @@ class _TemporalLayer(nn.Module):
         q, k, v = qkv[0], qkv[1], qkv[2]
         q, k = _apply_rope(q, k, offset)
 
-        keys, values, pos_k = kv.complete(k, v)
+        keys, values, pos_k = kv.complete(k, v, active)
         pos_k = pos_k.view(pos_k.shape[0], 1, pos_k.shape[1])  # [B, 1, cap]
-        pos_q = offset + torch.arange(T, device=q.device, dtype=torch.long).view(1, -1, 1)
+        pos_q = offset.view(-1, 1, 1) + torch.arange(T, device=q.device, dtype=torch.long).view(1, -1, 1)
         delta = pos_q - pos_k
         attn_bias = (pos_k >= 0) & (delta >= 0) & (delta < context)
         attn_bias = attn_bias.unsqueeze(1)  # [B, 1, T, cap]
@@ -199,7 +224,7 @@ class PersonaPlexTemporalStreaming(nn.Module):
         head_dim = self.layers[0].head_dim
         # Capacity = context window (the mask truncates at `context` anyway).
         self._kv = [_RingKV(batch_size, heads, head_dim, self.context, p.device, p.dtype) for _ in self.layers]
-        self._offset = torch.zeros(1, device=p.device, dtype=torch.long)
+        self._offset = torch.zeros(batch_size, device=p.device, dtype=torch.long)
 
     def reset_streaming(self) -> None:
         assert self._kv is not None, "call streaming_init first"
@@ -221,12 +246,17 @@ class PersonaPlexTemporalStreaming(nn.Module):
     # -- per-frame step -------------------------------------------------------
 
     @torch.no_grad()
-    def step(self, frame_embedding: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def step(
+        self,
+        frame_embedding: torch.Tensor,
+        active: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         assert self._kv is not None, "call streaming_init first"
+        active = _normalize_temporal_active(active, self._offset)
         x = frame_embedding
         for layer, kv in zip(self.layers, self._kv):
-            x = layer(x, kv, self._offset, self.context)
-        self._offset.add_(x.shape[1])
+            x = layer(x, kv, self._offset, self.context, active)
+        self._offset.add_(x.shape[1] * active.to(self._offset.dtype))
         out = _rms_norm_f32(x, self.out_norm_alpha, 1e-8)
         text_logits = F.linear(out, self.text_linear)
         return out, text_logits[:, None]
diff --git a/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py b/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
index 263ffa2ab..b7b7d074c 100644
--- a/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
+++ b/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
@@ -758,6 +758,7 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
         tokenizer = self.info.get_tokenizer()
         processor = self.info.get_hf_processor()
         audio_token_id = tokenizer.get_vocab()[processor.audio_token]
+        video_token_id = tokenizer.get_vocab()[processor.video_token]
 
         result_placeholders = dict(placeholders)
         audio_placeholders = []
@@ -765,7 +766,10 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
 
         audio_idx = 0
         for video_idx, video_placeholder in enumerate(placeholders["video"]):
-            audio_is_embed = torch.tensor(video_placeholder.tokens) == audio_token_id
+            placeholder_tokens = torch.tensor(video_placeholder.tokens)
+            audio_is_embed = placeholder_tokens == audio_token_id
+            # Audio boundary tokens keep their text embeddings.
+            video_is_embed = placeholder_tokens == video_token_id
 
             if video_use_audio_in_video[video_idx]:
                 audio_placeholder = PlaceholderFeaturesInfo(
@@ -783,7 +787,7 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
                 item_idx=video_idx,
                 start_idx=video_placeholder.start_idx,
                 tokens=video_placeholder.tokens,
-                is_embed=~audio_is_embed,
+                is_embed=video_is_embed,
             )
             video_placeholders.append(video_placeholder_with_mask)
 
diff --git a/vllm_omni/model_executor/models/qwen3_omni/duplex/__init__.py b/vllm_omni/model_executor/models/qwen3_omni/duplex/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/vllm_omni/model_executor/models/qwen3_omni/duplex/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
diff --git a/vllm_omni/model_executor/models/qwen3_omni/duplex/input.py b/vllm_omni/model_executor/models/qwen3_omni/duplex/input.py
new file mode 100644
index 000000000..caba0b174
--- /dev/null
+++ b/vllm_omni/model_executor/models/qwen3_omni/duplex/input.py
@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Transactional PCM buffering for committed Qwen speech turns."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import pybase64 as base64
+
+from vllm_omni.engine.duplex.plugin import PcmAppendBuffer, PcmAppendReservation
+
+
+@dataclass
+class Reservation(PcmAppendReservation):
+    owner: QwenPcmBuffer
+    operation_id: str
+    payload: dict[str, object] | None
+    raw: bytes
+    _active: bool = True
+
+    @property
+    def active(self):
+        return self._active
+
+    @property
+    def byte_count(self):
+        return len(self.raw)
+
+    def commit(self):
+        if self._active:
+            self._active = False
+            self.owner.reservations.remove(self)
+
+    def rollback(self):
+        if self._active:
+            self.owner.buffer[:0] = self.raw
+            self.commit()
+
+
+@dataclass
+class QwenPcmBuffer(PcmAppendBuffer):
+    buffer: bytearray = field(default_factory=bytearray)
+    reservations: list[Reservation] = field(default_factory=list)
+
+    @property
+    def pending_byte_count(self):
+        return len(self.buffer)
+
+    def clear(self):
+        for reservation in self.reservations:
+            reservation._active = False
+        self.reservations.clear()
+        self.buffer.clear()
+
+    def clear_force_listen(self):
+        pass
+
+    def has_pending(self):
+        return bool(self.buffer)
+
+    def has_reserved(self):
+        return bool(self.reservations)
+
+    def prepare_append(self, payload, *, operation_id, chunk_period_ms, allow_emit):
+        if payload.get("format") != "pcm_f32le" or payload.get("sample_rate_hz") != 16000:
+            raise ValueError("Qwen duplex requires normalized 16 kHz pcm_f32le")
+        if payload.get("video_frames"):
+            # Qwen answers whole turns, so it has no audio unit for a frame
+            # track to interleave against. Images arrive the OpenAI way, as
+            # input_image conversation items, and stay until deleted.
+            raise ValueError(
+                "Qwen duplex does not take video_frames on an audio append; "
+                "send images as conversation.item.create items with input_image content"
+            )
+        raw = base64.b64decode(payload.get("audio", ""), validate=True)
+        if len(raw) % 4:
+            raise ValueError("Invalid float32 PCM length")
+        self.buffer.extend(raw)
+        # Qwen inference starts on commit, never on an individual audio chunk.
+        return None
+
+    def prepare_commit(self, *, operation_id, chunk_period_ms):
+        raw = bytes(self.buffer)
+        payload = (
+            {
+                "audio": base64.b64encode(raw).decode(),
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+                "is_speech": True,
+            }
+            if raw
+            else None
+        )
+        self.buffer.clear()
+        reservation = Reservation(self, operation_id, payload, raw)
+        self.reservations.append(reservation)
+        return reservation
+
+    def flush(self, *, chunk_period_ms):
+        reservation = self.prepare_commit(operation_id="flush", chunk_period_ms=chunk_period_ms)
+        reservation.commit()
+        return reservation.payload
diff --git a/vllm_omni/model_executor/models/qwen3_omni/duplex/plugin.py b/vllm_omni/model_executor/models/qwen3_omni/duplex/plugin.py
new file mode 100644
index 000000000..89b2c6ffd
--- /dev/null
+++ b/vllm_omni/model_executor/models/qwen3_omni/duplex/plugin.py
@@ -0,0 +1,444 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Engine-owned VAD/commit turns with concurrent input and interruptible output.
+
+Qwen3-Omni is a turn model: this plugin does not advertise native streaming KV
+or model-driven turn decisions. Each committed utterance is a fresh request.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import hashlib
+import io
+import json
+import os
+from collections.abc import Mapping
+from pathlib import Path
+
+import numpy as np
+import pybase64 as base64
+from PIL import Image
+from vllm.logger import init_logger
+from vllm.sampling_params import RequestOutputKind
+
+from vllm_omni.engine.duplex.config import DuplexCapabilities
+from vllm_omni.engine.duplex.contracts import DuplexAppendPlan, duplex_resource_request_belongs_to_session
+from vllm_omni.engine.duplex.plugin import DuplexDataPlane, DuplexModelPlugin, DuplexRuntimeConfigError
+from vllm_omni.model_executor.models.qwen3_omni.duplex.session import QwenDuplexSessionState
+
+logger = init_logger(__name__)
+
+#: Mirrors ``limit_mm_per_prompt.image`` in ``deploy/qwen3_omni_duplex.yaml``.
+#: The session already refuses a ninth stored image, but that budget lives in
+#: the engine and this one in the deploy config; the prompt is the only place
+#: that can keep them from drifting apart into a rejected submission.
+MAX_PROMPT_IMAGES = 8
+
+
+class QwenDataPlane(DuplexDataPlane):
+    def __init__(self, encode_audio):
+        self.encode_audio = encode_audio
+        self.terminal: set[str] = set()
+
+    def begin_request(self, request_id):
+        self.terminal.discard(request_id)
+
+    def is_terminal(self, request_id):
+        return request_id in self.terminal
+
+    def mark_terminal(self, request_id):
+        self.terminal.add(request_id)
+
+    def close_stream(self, request_id):
+        pass
+
+    def close_session(self, session_id, *, active_request_id=None):
+        self.terminal = {
+            rid for rid in self.terminal if not duplex_resource_request_belongs_to_session(rid, session_id)
+        }
+
+    def project(self, result, *, context=None):
+        if not isinstance(result, dict):
+            return
+        context = context or {}
+        for output in result.get("data_plane_outputs", []):
+            rid = output.request_id
+            if self.is_terminal(rid):
+                continue
+            completion = next(iter(getattr(output, "outputs", ()) or ()), None)
+            stage_id = getattr(output, "stage_id", 0)
+            text = getattr(completion, "text", "") if stage_id == 0 else ""
+            mm = getattr(output, "multimodal_output", None)
+            if not isinstance(mm, Mapping) or "audio" not in mm:
+                mm = getattr(completion, "multimodal_output", {}) or {}
+            audio = mm.get("audio")
+            encoded = None
+            duration_ms = 0
+            rate = mm.get("sr", mm.get("sample_rate", mm.get("sample_rate_hz", 24000)))
+            if isinstance(rate, (list, tuple)):
+                rate = next((value for value in rate if value is not None), 24000)
+            rate = int(rate)
+            if rate <= 0:
+                raise ValueError("Invalid output audio sample rate")
+            if audio is not None and "audio" in context.get("modalities", ()):
+                chunks = audio if isinstance(audio, (list, tuple)) else [audio]
+                arrays = [
+                    np.asarray(
+                        chunk.detach().float().cpu().numpy() if hasattr(chunk, "detach") else chunk, dtype=np.float32
+                    ).reshape(-1)
+                    for chunk in chunks
+                ]
+                audio = np.concatenate(arrays) if arrays else np.empty(0, dtype=np.float32)
+                duration_ms = audio.size * 1000 / rate
+                if audio.size:
+                    encoded = self.encode_audio(
+                        audio, rate, context.get("response_format", "pcm16"), context.get("speed")
+                    )
+            yield {
+                "supported": True,
+                "data_plane_request_id": rid,
+                "text": text or "",
+                "audio_data": encoded or "",
+                "audio_format": context.get("response_format", "pcm16"),
+                "audio_duration_ms": duration_ms,
+                # Thinker text and codec chunks are independent streams. Only
+                # the final audio boundary can conservatively attest all text.
+                "audio_text_mark": False,
+                "text_requires_complete_audio": "audio" in context.get("modalities", ()),
+                "audio_complete": bool(output.finished) and stage_id == 2,
+                "sample_rate_hz": rate,
+                "end_of_turn": bool(output.finished),
+                "model_turn_id": context.get("active_response_turn_id")
+                if context.get("active_response_turn_id") is not None
+                else context.get("turn_id", 0),
+                "runtime_impl": "qwen3_commit",
+                "uses_model_runner_scheduler": True,
+                "runner_kv_backed": True,
+            }
+
+
+class Qwen3OmniDuplexPlugin(DuplexModelPlugin):
+    plugin_id = "qwen3-omni"
+    projects_intermediate_outputs = True
+
+    def __init__(self, encode_audio):
+        self.data_plane = QwenDataPlane(encode_audio)
+        self.processor = None
+        self._processor_lock = asyncio.Lock()
+
+    def capabilities(self, *, max_sessions):
+        return DuplexCapabilities(
+            supports_model_native_turn_policy=False,
+            supports_input_append=True,
+            supports_barge_in=True,
+            supports_replace_latest_chunk=False,
+            supports_reencode_context=True,
+            supports_turn_commit_only=True,
+            supports_core_resumable_request=False,
+            supports_independent_io_streams=True,
+            supports_realtime_endpoint=True,
+            supports_multi_session=max_sessions > 1,
+            supports_multi_session_same_replica=max_sessions > 1,
+            supports_session_lease=True,
+            supports_session_resume=True,
+            session_admission_mode="engine_managed",
+            supports_audio_truncate=True,
+            supports_chat_completions=True,
+            supports_image_input=True,
+            supports_text_only_turn=True,
+            adapter_patterns=["turn_commit"],
+            signal_sources=["client_event", "server_policy"],
+            stage_handoff_transport="scheduler_data_plane",
+            target_barge_in_latency_ms=None,
+        )
+
+    def create_session_state(self):
+        return QwenDuplexSessionState()
+
+    def validate_client_extra_body(self, extra_body):
+        if not isinstance(extra_body, Mapping):
+            return
+        if extra_body.get("auto_response") or extra_body.get("full_duplex"):
+            raise DuplexRuntimeConfigError(
+                "Qwen requires server VAD or explicit commits; native auto_response is unsupported"
+            )
+        if extra_body.get("realtime_tools"):
+            raise DuplexRuntimeConfigError("Qwen duplex tool calls are not implemented")
+
+    async def prepare_runtime_config(self, config, *, model_config):
+        self.validate_client_extra_body(config.extra_body)
+        if config.ref_audio:
+            raise DuplexRuntimeConfigError("Qwen duplex does not support reference voice audio")
+        if model_config is None and self.processor is None:
+            raise DuplexRuntimeConfigError("Qwen duplex requires the stage-0 model configuration")
+        async with self._processor_lock:
+            if self.processor is None:
+                from transformers import AutoProcessor
+
+                self.processor = await asyncio.to_thread(
+                    AutoProcessor.from_pretrained,
+                    model_config.model,
+                    trust_remote_code=model_config.trust_remote_code,
+                    revision=getattr(model_config, "revision", None),
+                )
+        return self.runtime_config_for_update(config, {})
+
+    def runtime_config_for_update(self, config, current):
+        self.validate_client_extra_body(config.extra_body)
+        if config.ref_audio:
+            raise DuplexRuntimeConfigError("Qwen duplex does not support reference voice audio")
+        return {
+            "instructions": config.instructions,
+            "initial_user_text": config.initial_user_text,
+            "temperature": config.temperature,
+            "max_tokens": config.max_tokens,
+        }
+
+    def configure_sampling_params(self, *, runtime_config, defaults):
+        params = copy.deepcopy(defaults)
+        for value in params:
+            if value is not None:
+                value.output_kind = RequestOutputKind.DELTA
+        if params and params[0] is not None:
+            if runtime_config.get("temperature") is not None:
+                params[0].temperature = float(runtime_config["temperature"])
+            if isinstance(runtime_config.get("max_tokens"), int):
+                params[0].max_tokens = runtime_config["max_tokens"]
+        return params
+
+    def prepare_prompt_config(self, config, *, state, payload):
+        history = config.get("conversation", [])
+        # The history accessor copies message dicts but preserves content identity.
+        # Keep payloads privately, never put PCM into public conversation events.
+        has_audio = bool(payload.get("audio"))
+        # A committed audio item need not be last: camera/text items can arrive
+        # before response.create. Search only the unanswered user turn so a new
+        # payload can never overwrite an earlier, already answered utterance.
+        current_contents = []
+        if has_audio:
+            for message in reversed(history):
+                if message.get("role") != "user":
+                    break
+                content = message.get("content")
+                if isinstance(content, list) and any(part.get("type") == "audio_url" for part in content):
+                    current_contents.append(content)
+        current_is_in_history = bool(current_contents)
+        if current_is_in_history:
+            # The runner concatenates multiple commits made before a response.
+            # Associate that single payload with all of its source audio items.
+            state.audio_history = [
+                (keys, value)
+                for keys, value in state.audio_history
+                if not any(key is content for key in keys for content in current_contents)
+            ]
+            state.audio_history.append((tuple(current_contents), payload))
+        # Reserve one of the four audio slots for the actual submitted input,
+        # including when deferred input has no trailing user history entry.
+        history_limit = 4 if current_is_in_history or not has_audio else 3
+        retained = state.audio_history[-history_limit:]
+        while len(retained) > 1 and sum(len(value.get("audio", "")) for _, value in retained) > 8 * 1024 * 1024:
+            retained.pop(0)
+        state.audio_history = retained
+        # Match the official demo's unit of history: consecutive user items
+        # followed by their assistant reply(s). Prune whole turns, before
+        # formatting, so a camera item cannot rescue an orphaned answer.
+        turns = []
+        for index, message in enumerate(history):
+            role = message.get("role")
+            if not turns or role == "system" or (role == "user" and turns[-1][1][-1].get("role") != "user"):
+                turns.append((index, []))
+            turns[-1][1].append(message)
+
+        messages = []
+        for index, turn in turns:
+            # Keep the existing recent-message window, rounded outwards to a
+            # complete turn. Never retain an answer whose input was cut off.
+            if index + len(turn) <= len(history) - 16:
+                continue
+            if turn[0].get("role") == "assistant":
+                continue
+            resolved = []
+            included_audio = set()
+            for message in turn:
+                content = message.get("content")
+                if message.get("role") == "user" and isinstance(content, list):
+                    if any(part.get("type") == "audio_url" for part in content):
+                        audio = next((value for keys, value in retained if any(key is content for key in keys)), None)
+                        if audio is None:
+                            break
+                        if id(audio) not in included_audio:
+                            resolved.append({"role": "user", "audio_payload": audio})
+                            included_audio.add(id(audio))
+                        # Preserve text/images in mixed source items as well.
+                        other_parts = [part for part in content if part.get("type") != "audio_url"]
+                        if other_parts:
+                            resolved.append({"role": "user", "content": other_parts})
+                        continue
+                resolved.append(message)
+            else:
+                messages.extend(resolved)
+        if has_audio and not current_is_in_history:
+            # History is context, not a replacement for the current request.
+            # Re-encoding only history here makes Qwen answer an old question.
+            messages.append({"role": "user", "audio_payload": payload})
+        return {**config, "qwen_messages": messages}
+
+    @staticmethod
+    def format_history(messages):
+        """Merge user items as Qwen's official web_demo.format_history does.
+
+        This is a model-input view, not a mutation of addressable session items.
+        Empty assistant messages remain boundaries for interrupted/unheard turns.
+        """
+        formatted = []
+        pending = []
+        for message in messages:
+            if message.get("role") == "user":
+                content = message.get("content")
+                pending.extend([{"type": "text", "text": content}] if isinstance(content, str) else content or [])
+                continue
+            if pending:
+                formatted.append({"role": "user", "content": pending})
+                pending = []
+            formatted.append(message)
+        if pending:
+            # The official demo puts media before the final turn's instruction.
+            media = [part for part in pending if part.get("type") != "text"]
+            text = [part for part in pending if part.get("type") == "text"]
+            formatted.append({"role": "user", "content": media + text})
+        return formatted
+
+    @staticmethod
+    def _trim_prompt_images(messages, images):
+        """Drop the oldest images, with their placeholders, down to the prompt limit.
+
+        The processor pairs ``{"type": "image"}`` parts with ``mm["image"]``
+        positionally, and the placeholders read across *messages* in the same
+        order as *images*, so a dropped image has to take its placeholder with
+        it. Oldest first keeps what the client shared most recently.
+        """
+        excess = len(images) - MAX_PROMPT_IMAGES
+        if excess <= 0:
+            return messages, images
+        logger.warning(
+            "Qwen duplex prompt carries %d images; dropping the %d oldest to stay within %d",
+            len(images),
+            excess,
+            MAX_PROMPT_IMAGES,
+        )
+        remaining = excess
+        for message in messages:
+            if remaining <= 0:
+                break
+            content = message.get("content")
+            if not isinstance(content, list):
+                continue
+            kept = []
+            for part in content:
+                if remaining > 0 and isinstance(part, dict) and part.get("type") == "image":
+                    remaining -= 1
+                    continue
+                kept.append(part)
+            message["content"] = kept
+        return [message for message in messages if message.get("content") != []], images[excess:]
+
+    @staticmethod
+    def _audio_content(payload):
+        raw = base64.b64decode(payload["audio"], validate=True)
+        audio = np.frombuffer(raw, dtype="<f4").copy()
+        if not audio.size or not np.isfinite(audio).all():
+            raise DuplexRuntimeConfigError("Audio must contain finite PCM samples")
+        return [{"type": "audio"}], audio
+
+    async def prepare_append_plan(self, **kwargs):
+        # History mutation has already happened on the session loop. The worker
+        # owns this snapshot and never reads or mutates live session state.
+        snapshot = copy.deepcopy(kwargs)
+        return await asyncio.to_thread(self.plan_append, **snapshot)
+
+    def plan_append(
+        self, *, request_id, fence, session_config, runtime_config, seq, turn_seq, payload, final, sampling_params
+    ):
+        if not final or not isinstance(payload, dict):
+            raise DuplexRuntimeConfigError("Qwen generation requires a committed audio turn")
+        messages = []
+        if runtime_config.get("instructions"):
+            messages.append({"role": "system", "content": runtime_config["instructions"]})
+        history = session_config.get("qwen_messages")
+        if history is None and payload.get("audio"):
+            # Nothing prepared the conversation, so the committed payload is
+            # the whole turn. An empty prepared list is not that: it means the
+            # preparation ran and found nothing to say.
+            history = [{"role": "user", "audio_payload": payload}]
+        if not history:
+            raise DuplexRuntimeConfigError("Qwen generation requires committed audio or conversation history")
+        audios = []
+        images = []
+        for message in history:
+            if "audio_payload" not in message:
+                content = message.get("content")
+                if isinstance(content, list):
+                    parts = []
+                    for part in content:
+                        if part.get("type") == "image_url":
+                            encoded = part["image_url"]["url"].split(",", 1)[1]
+                            with Image.open(io.BytesIO(base64.b64decode(encoded, validate=True))) as image:
+                                image.thumbnail((448, 448))
+                                images.append(image.convert("RGB").copy())
+                            parts.append({"type": "image"})
+                        elif part.get("type") == "text":
+                            parts.append(part)
+                    messages.append({"role": message["role"], "content": parts})
+                else:
+                    messages.append(message)
+                continue
+            content, audio = self._audio_content(message["audio_payload"])
+            audios.append((audio, 16000))
+            messages.append({"role": "user", "content": content})
+        if payload.get("audio") and runtime_config.get("initial_user_text"):
+            messages.append({"role": "user", "content": runtime_config["initial_user_text"]})
+        messages, images = self._trim_prompt_images(messages, images)
+        messages = self.format_history(messages)
+        prompt = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        mm = {"audio": audios} if audios else {}
+        if images:
+            mm["image"] = images
+        logger.info(
+            "Qwen duplex visual input request=%s images=%d sizes=%s audios=%d",
+            request_id,
+            len(images),
+            [image.size for image in images],
+            len(audios),
+        )
+        # Opt-in capture of the exact decoded images submitted to the processor.
+        # Request IDs are hashed because they need not be safe path components.
+        debug_dir = os.environ.get("VLLM_OMNI_QWEN_VISUAL_DEBUG_DIR")
+        if debug_dir:
+            try:
+                target = Path(debug_dir) / hashlib.sha256(request_id.encode()).hexdigest()[:24]
+                target.mkdir(parents=True, exist_ok=True)
+                filenames = []
+                for index, image in enumerate(images):
+                    filename = f"image_{index:02d}.png"
+                    image.save(target / filename)
+                    filenames.append(filename)
+                (target / "input.json").write_text(
+                    json.dumps(
+                        {"request_id": request_id, "images": filenames, "audio_count": len(audios), "prompt": prompt},
+                        ensure_ascii=False,
+                        indent=2,
+                    ),
+                    encoding="utf-8",
+                )
+                logger.info("Qwen duplex visual input capture request=%s path=%s", request_id, target)
+            except (OSError, ValueError):
+                logger.exception("Failed to capture Qwen visual input request=%s", request_id)
+        return DuplexAppendPlan(prompt={"prompt": prompt, "multi_modal_data": mm})
+
+    def decide_output(self, **kwargs):
+        return None
+
+    def data_plane_context(self, **kwargs):
+        return kwargs
diff --git a/vllm_omni/model_executor/models/qwen3_omni/duplex/session.py b/vllm_omni/model_executor/models/qwen3_omni/duplex/session.py
new file mode 100644
index 000000000..038474e9b
--- /dev/null
+++ b/vllm_omni/model_executor/models/qwen3_omni/duplex/session.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+
+from vllm_omni.engine.duplex.plugin import DuplexModelSessionState
+from vllm_omni.model_executor.models.qwen3_omni.duplex.input import (
+    QwenPcmBuffer,
+)
+
+
+@dataclass(slots=True)
+class QwenDuplexSessionState(DuplexModelSessionState):
+    """Mutable model-owned state of one Qwen duplex session (owned by the session runner)."""
+
+    audio_buffer: QwenPcmBuffer = field(default_factory=QwenPcmBuffer)
+    # Each payload can combine several audio commits from one pending turn.
+    # Keep their content objects so associations survive shallow history copies.
+    audio_history: list[tuple[tuple[object, ...], dict]] = field(default_factory=list)
+    input_since_commit: bool = False
+    speech_since_commit: bool = False
+    context_locked: bool = False
+    committed_audio_payload: dict[str, object] | None = None
+    committed_audio_operation_id: str | None = None
+    committed_audio_reserved_bytes: int = 0
+    deferred_response_create: bool = False
+    deferred_precreate_response: bool = False
+    continuation_owner_id: str | None = None
+    continuation_units: int = 0
+    pending_silence_task: asyncio.Task[bool] | None = None
+    pending_silence_owner_id: str | None = None
+
+    def retain_committed_audio(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str | None,
+        reserved_bytes: int = 0,
+    ) -> None:
+        self.committed_audio_payload = payload
+        self.committed_audio_operation_id = operation_id
+        self.committed_audio_reserved_bytes += max(0, int(reserved_bytes))
+
+    def clear_committed_audio(self) -> int:
+        reserved_bytes = self.committed_audio_reserved_bytes
+        self.committed_audio_payload = None
+        self.committed_audio_operation_id = None
+        self.committed_audio_reserved_bytes = 0
+        self.deferred_response_create = False
+        self.deferred_precreate_response = False
+        return reserved_bytes
+
+    def clear_continuation(self) -> None:
+        self.continuation_owner_id = None
+        self.continuation_units = 0
+        self.pending_silence_task = None
+        self.pending_silence_owner_id = None
diff --git a/vllm_omni/model_executor/models/qwen3_omni/pipeline.py b/vllm_omni/model_executor/models/qwen3_omni/pipeline.py
index 1e515d0dd..9caff6d27 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/pipeline.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/pipeline.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Qwen3-Omni-MoE pipeline topology (frozen).
 
 Stage 0: Thinker — multimodal understanding + text generation
@@ -21,6 +21,8 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.qwen3_omni"
 
 QWEN3_OMNI_PIPELINE = PipelineConfig(
     model_type="qwen3_omni_moe",
+    default_session_mode="turn",
+    duplex_plugin="vllm_omni.model_executor.models.qwen3_omni.duplex.plugin.Qwen3OmniDuplexPlugin",
     default_deploy_config_name="qwen3_omni_moe.yaml",
     model_arch="Qwen3OmniMoeForConditionalGeneration",
     endpoint_restrictions=(
diff --git a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py
index 28accbc51..f7542d3e3 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py
@@ -171,15 +171,15 @@ class Qwen3OmniMoeForConditionalGeneration(
         # such as the vLLM-text perf benchmark.
         #
         # Default to the thinker: it is the text-generation stage, which is what
-        # a non-staged run of this model is asking for. Same shape as
-        # dynin_omni ("token2text") and glm_tts ("glm_tts"). An explicitly wrong
-        # value still reaches the ValueError below rather than being silently
-        # accepted.
+        # a non-staged run of this model is asking for. Same shape as glm_tts
+        # ("glm_tts"). An explicitly wrong value still reaches the ValueError
+        # below rather than being silently accepted.
         self.model_stage = getattr(vllm_config.model_config, "model_stage", None) or "thinker"
         # Staged startup always injects model_stage; its absence means a plain
         # vLLM run with no talker stage downstream, so no one consumes captured
         # thinker layers and the forward must return what stock vLLM expects.
         self.is_staged_run = getattr(vllm_config.model_config, "model_stage", None) is not None
+        self._returns_tuple = self.model_stage == "thinker" and self.is_staged_run
 
         if self.model_stage == "thinker":
             self.use_async_omni_output = True
diff --git a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py
index 8d0389d63..5d5edf0df 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py
@@ -588,7 +588,10 @@ class Qwen3MoeLLMModel(_Qwen3MoeLLMModel):
                 if layer_idx in capture_set:
                     hs = captured_hidden_states.setdefault("hidden_states", {})
                     layers = hs.setdefault("layers", {})
-                    layers[layer_idx] = hidden_states.clone().view(-1, hidden_states.shape[-1])
+                    # vLLM defers the residual addition until the next RMSNorm.
+                    # Reconstruct the logical decoder state before capturing it.
+                    captured = hidden_states.clone() if residual is None else hidden_states + residual
+                    layers[layer_idx] = captured.view(-1, captured.shape[-1])
 
             hidden_states, residual = layer(
                 positions,
@@ -1270,14 +1273,12 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
         *,
         is_multimodal: torch.Tensor | None = None,
     ) -> torch.Tensor:
-        inputs_embeds = self._embed_text_input_ids(
-            input_ids,
-            self.language_model.embed_input_ids,
-            is_multimodal=is_multimodal,
-        )
-
         if multimodal_embeddings is None or len(multimodal_embeddings) == 0:
-            return inputs_embeds
+            return self._embed_text_input_ids(
+                input_ids,
+                self.language_model.embed_input_ids,
+                is_multimodal=is_multimodal,
+            )
 
         # Detect interleaved audio-in-video early, since it affects
         # both the deepstack path and the final embedding merge.
@@ -1292,12 +1293,12 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
 
         is_interleaved = check_interleaved_audio_video(is_video, is_audio, num_video, num_audio)
 
-        deepstack_input_embeds = None
         # split the feat dim to obtain multi-scale visual feature
         has_vision_embeddings = [
             embeddings.shape[-1] != self.config.text_config.hidden_size for embeddings in multimodal_embeddings
         ]
-        if self.visual.deepstack_visual_indexes is not None and any(has_vision_embeddings):
+        has_deepstack_embeddings = self.visual.deepstack_visual_indexes is not None and any(has_vision_embeddings)
+        if has_deepstack_embeddings:
             multiscale_len = len(self.visual.deepstack_visual_indexes)
             multimodal_embeddings_multiscale = []
 
@@ -1340,6 +1341,28 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                 if not is_interleaved:
                     mm_position_idx += num_tokens
 
+        if is_interleaved:
+            inputs_embeds = self._embed_text_input_ids(
+                input_ids,
+                self.language_model.embed_input_ids,
+                is_multimodal=is_multimodal,
+            )
+            inputs_embeds = merge_interleaved_embeddings(
+                inputs_embeds,
+                multimodal_embeddings,
+                is_video,
+                is_audio,
+                is_mm_device,
+            )
+        else:
+            # multimodal_embeddings now contains the main-scale features.
+            inputs_embeds = super().embed_input_ids(
+                input_ids,
+                multimodal_embeddings=multimodal_embeddings,
+                is_multimodal=is_multimodal,
+            )
+
+        if has_deepstack_embeddings:
             deepstack_input_embeds = inputs_embeds.new_zeros(
                 inputs_embeds.size(0), multiscale_len * inputs_embeds.size(1)
             )
@@ -1355,24 +1378,7 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
             )
             self._set_deepstack_input_embeds(deepstack_input_embeds)
 
-        if is_interleaved:
-            return merge_interleaved_embeddings(
-                inputs_embeds,
-                multimodal_embeddings,
-                is_video,
-                is_audio,
-                is_mm_device,
-            )
-
-        # Default: standard merge (no interleaving), same as parent class.
-        # multimodal_embeddings may have been updated above (deepstack
-        # main-scale). Use super() to stay consistent with the parent
-        # implementation and avoid issues seen in Qwen2.5-Omni (#34506).
-        return super().embed_input_ids(
-            input_ids,
-            multimodal_embeddings=multimodal_embeddings,
-            is_multimodal=is_multimodal,
-        )
+        return inputs_embeds
 
     def forward(
         self,
diff --git a/vllm_omni/model_executor/models/qwen3_tts/configuration_qwen3_tts.py b/vllm_omni/model_executor/models/qwen3_tts/configuration_qwen3_tts.py
index 36bf663dd..e8776ed40 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/configuration_qwen3_tts.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/configuration_qwen3_tts.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # Copyright 2026 The Qwen team, Alibaba Group and the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -533,6 +536,10 @@ class Qwen3TTSConfig(PretrainedConfig):
         if any("Code2Wav" in str(a) for a in archs):
             if hasattr(config, "rope_parameters"):
                 delattr(config, "rope_parameters")
+            # Code2Wav doesn't use position embeddings, but vLLM validates
+            # max_model_len <= max_position_embeddings. Set a large value
+            # to allow the pipeline.yaml max_model_len (65536) to pass validation.
+            config.max_position_embeddings = 131072
         return config
 
 
diff --git a/vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py b/vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py
index abeaf243d..6aa56ab09 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py
@@ -1,5 +1,6 @@
 # Copyright 2026 The Alibaba Qwen team.
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """
 CUDA Graph wrapper for Qwen3TTSTokenizerV2Decoder.
 
@@ -8,10 +9,8 @@ reducing kernel launch overhead during inference.
 """
 
 import bisect
-import os
 import time
-from collections import Counter
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Collection, Sequence
 
 import torch
 from torch.cuda import CUDAGraph
@@ -187,22 +186,6 @@ class CUDAGraphDecoderWrapper:
 
         self._warmed_up = False
         self._device = None
-        self._stats_enabled = os.environ.get("VLLM_OMNI_QWEN3_CODE2WAV_CUDAGRAPH_STATS", "").lower() in (
-            "1",
-            "true",
-            "yes",
-            "on",
-        )
-        self._stats_log_every = int(os.environ.get("VLLM_OMNI_QWEN3_CODE2WAV_CUDAGRAPH_STATS_LOG_EVERY", "0") or 0)
-        self._stats_total = 0
-        self._stats_hits = 0
-        self._stats_compiled_hits = 0
-        self._stats_fallbacks = 0
-        self._stats_stream_capture_fallbacks = 0
-        self._stats_requests: Counter[tuple[int, int]] = Counter()
-        self._stats_hit_shapes: Counter[tuple[int, int, int]] = Counter()
-        self._stats_compiled_shapes: Counter[tuple[int, int]] = Counter()
-        self._stats_fallback_shapes: Counter[tuple[int, int, int]] = Counter()
 
     @staticmethod
     def compute_capture_sizes(
@@ -244,57 +227,19 @@ class CUDAGraphDecoderWrapper:
         shapes.update(self.extra_capture_shapes)
         return sorted(shapes)
 
-    def _record_decode_stats(
-        self,
-        *,
-        hit: bool,
-        batch_size: int,
+    @staticmethod
+    def _select_replay_shape(
+        actual_batch_size: int,
         actual_size: int,
-        padded_size: int | None,
-        stream_capture: bool = False,
-        compiled: bool = False,
-    ) -> None:
-        if not self._stats_enabled:
-            return
-
-        padded_key = int(padded_size) if padded_size is not None else -1
-        self._stats_total += 1
-        self._stats_requests[(batch_size, actual_size)] += 1
-        if hit:
-            self._stats_hits += 1
-            if compiled:
-                self._stats_compiled_hits += 1
-                self._stats_compiled_shapes[(batch_size, actual_size)] += 1
-            else:
-                self._stats_hit_shapes[(batch_size, actual_size, padded_key)] += 1
-        else:
-            self._stats_fallbacks += 1
-            self._stats_fallback_shapes[(batch_size, actual_size, padded_key)] += 1
-            if stream_capture:
-                self._stats_stream_capture_fallbacks += 1
-
-        if self._stats_log_every > 0 and self._stats_total % self._stats_log_every == 0:
-            self.log_decode_stats()
-
-    def log_decode_stats(self) -> None:
-        if not self._stats_enabled or self._stats_total == 0:
-            return
-        hit_rate = 100.0 * self._stats_hits / self._stats_total
-        logger.info(
-            "Code2Wav CUDA Graph stats: total=%d hits=%d fallbacks=%d "
-            "compiled_hits=%d stream_capture_fallbacks=%d hit_rate=%.2f%% "
-            "top_requests=%s top_compiled=%s top_hits=%s top_fallbacks=%s",
-            self._stats_total,
-            self._stats_hits,
-            self._stats_fallbacks,
-            self._stats_compiled_hits,
-            self._stats_stream_capture_fallbacks,
-            hit_rate,
-            self._stats_requests.most_common(12),
-            self._stats_compiled_shapes.most_common(12),
-            self._stats_hit_shapes.most_common(12),
-            self._stats_fallback_shapes.most_common(12),
+        available_shapes: Collection[tuple[int, int]],
+    ) -> tuple[int, int] | None:
+        """Select the lowest-cost captured shape that contains the request."""
+        candidates = (
+            (batch_size, size)
+            for batch_size, size in available_shapes
+            if batch_size >= actual_batch_size and size >= actual_size
         )
+        return min(candidates, key=lambda shape: (shape[0] * shape[1], shape[0], shape[1]), default=None)
 
     def warmup(
         self,
@@ -486,68 +431,42 @@ class CUDAGraphDecoderWrapper:
         # outside the startup capture window, so normal inference still hits
         # the graph fast path.
         if torch.cuda.is_current_stream_capturing():
-            self._record_decode_stats(
-                hit=False,
-                batch_size=int(codes.shape[0]),
-                actual_size=int(codes.shape[-1]),
-                padded_size=None,
-                stream_capture=True,
-            )
             return self.decoder(codes)
 
         batch_size = int(codes.shape[0])
         actual_size = int(codes.shape[-1])
-        padded_size = self._get_padded_size(actual_size)
-        compile_key = (batch_size, actual_size)
-        if compile_key not in self._compiled_shapes and padded_size is not None:
-            compile_key = (batch_size, padded_size)
-        if compile_key in self._compiled_shapes:
+        compile_key = self._select_replay_shape(batch_size, actual_size, self._compiled_shapes)
+        if compile_key is not None:
             compiled_size = compile_key[1]
-            self._record_decode_stats(
-                hit=True,
-                batch_size=batch_size,
-                actual_size=actual_size,
-                padded_size=compiled_size,
-                compiled=True,
-            )
             static_input = self._compiled_static_inputs[compile_key]
-            if actual_size == compiled_size:
+            if actual_size == compiled_size and batch_size == compile_key[0]:
                 static_input.copy_(codes)
             else:
                 static_input.zero_()
-                static_input[:, :, :actual_size] = codes
+                static_input[:batch_size, :, :actual_size] = codes
             self._compiled_graphs[compile_key].replay()
             output = self._trim_replay_output(self._compiled_static_outputs[compile_key], actual_size, compiled_size)
+            output = output[:batch_size]
             if clone_graph_output:
                 return output.clone()
             return output
 
-        graph_key = (batch_size, padded_size) if padded_size is not None else None
+        graph_key = self._select_replay_shape(batch_size, actual_size, self.graphs)
 
-        if graph_key is None or graph_key not in self.graphs:
-            self._record_decode_stats(
-                hit=False,
-                batch_size=batch_size,
-                actual_size=actual_size,
-                padded_size=padded_size,
-            )
+        if graph_key is None:
             return self.decoder(codes)
 
-        self._record_decode_stats(
-            hit=True,
-            batch_size=batch_size,
-            actual_size=actual_size,
-            padded_size=padded_size,
-        )
         static_input = self.static_inputs[graph_key]
-        if actual_size == padded_size:
+        graph_size = graph_key[1]
+        if actual_size == graph_size and batch_size == graph_key[0]:
             static_input.copy_(codes)
         else:
             static_input.zero_()
-            static_input[:, :, :actual_size] = codes
+            static_input[:batch_size, :, :actual_size] = codes
         self.graphs[graph_key].replay()
 
-        output = self._trim_replay_output(self.static_outputs[graph_key], actual_size, padded_size)
+        output = self._trim_replay_output(self.static_outputs[graph_key], actual_size, graph_size)
+        output = output[:batch_size]
         if clone_graph_output:
             return output.clone()
         return output
diff --git a/vllm_omni/model_executor/models/qwen3_tts/pipeline.py b/vllm_omni/model_executor/models/qwen3_tts/pipeline.py
index dd33aeca8..dd753861d 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/pipeline.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/pipeline.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Qwen3-TTS pipeline: Talker (text → RVQ codec) → Code2Wav (codec → audio).
 
 Chunked vs end-to-end mode is dispatched from ``deploy.async_chunk``.
@@ -41,6 +41,7 @@ QWEN3_TTS_PIPELINE = PipelineConfig(
             owns_tokenizer=True,
             engine_output_type="latent",
             async_chunk_process_next_stage_input_func=(f"{_PROC}.talker2code2wav_async_chunk"),
+            supports_native_mrv2_data_plane=True,
             custom_process_next_stage_input_func=f"{_PROC}.talker2code2wav_full_payload",
             sampling_constraints={
                 "detokenize": False,
@@ -56,6 +57,7 @@ QWEN3_TTS_PIPELINE = PipelineConfig(
             final_output_type="audio",
             engine_output_type="audio",
             model_arch="Qwen3TTSCode2Wav",
+            supports_native_mrv2_data_plane=True,
             # ``sync_process_input_func`` is the only input-proc override for
             # this stage in sync (non-async-chunk) mode: a length-only
             # ``_token_only`` placeholder.  The bulk codec payload itself
diff --git a/vllm_omni/model_executor/models/qwen3_tts/prompt_embeds_builder.py b/vllm_omni/model_executor/models/qwen3_tts/prompt_embeds_builder.py
index 609117ce3..45d887ee2 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/prompt_embeds_builder.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/prompt_embeds_builder.py
@@ -198,10 +198,6 @@ def mel_spectrogram(
     hann_window: torch.Tensor | None = None,
 ) -> torch.Tensor:
     """Mel spectrogram via torch STFT and a (cached) mel filterbank."""
-    if torch.min(y) < -1.0:
-        logger.warning("Min value of input waveform signal is %s", torch.min(y))
-    if torch.max(y) > 1.0:
-        logger.warning("Max value of input waveform signal is %s", torch.max(y))
     device = y.device
     if mel_basis is None:
         mel_basis = _cached_mel_filter_bank(sampling_rate, n_fft, num_mels, fmin, fmax).to(device)
@@ -350,7 +346,7 @@ class Qwen3TTSPromptEmbedsBuilder:
         tts_pad_embed: torch.Tensor,
         encode_ref_audio_batch: Callable[..., list[torch.Tensor]],
         speaker_cache: Any | None = None,
-        ref_audio_artifact_cache_max_entries: int = 256,
+        ref_audio_artifact_cache_max_entries: int = 1024,
     ):
         self._config = config
         self._talker_config = talker_config
@@ -366,9 +362,14 @@ class Qwen3TTSPromptEmbedsBuilder:
         self._embedding_dtype = torch.bfloat16
 
         self._text_tokenizer: Any | None = None
+        # Projected special-token embeddings are immutable model constants.
+        # Reusing them avoids launching the embedding/projection pair once per
+        # request during prompt construction.
+        self._projected_token_cache: dict[tuple[str, tuple[int, ...]], torch.Tensor] = {}
 
         self._ref_audio_artifact_cache_max_entries = int(ref_audio_artifact_cache_max_entries)
         self._ref_audio_artifact_cache: OrderedDict[str, dict[str, torch.Tensor | bool]] = OrderedDict()
+        self._long_tensor_cache: dict[tuple[str, tuple[int, ...]], torch.Tensor] = {}
 
         # Bounded LRU; caller-supplied orig_sr can otherwise grow this without limit.
         self._resampler_cache: OrderedDict[tuple[int, int], AudioResampler] = OrderedDict()
@@ -384,6 +385,29 @@ class Qwen3TTSPromptEmbedsBuilder:
         """Return the pad-token embedding on the requested device/dtype, shape ``[1, 1, H]``."""
         return self._tts_pad_embed_buffer.to(device=device, dtype=dtype).reshape(1, 1, -1)
 
+    def _long_tensor(self, values: Sequence[int], device: torch.device) -> torch.Tensor:
+        device = torch.device(device)
+        if device.type == "cuda" and device.index is None:
+            device = torch.device("cuda", torch.accelerator.current_device_index())
+        key = (str(device), tuple(int(v) for v in values))
+        cache = getattr(self, "_long_tensor_cache", None)
+        if cache is None:
+            cache = self._long_tensor_cache = {}
+        cached = cache.get(key)
+        if cached is None or cached.device != device:
+            cached = torch.tensor([list(key[1])], device=device, dtype=torch.long)
+            cache[key] = cached
+        return cached
+
+    def _projected_tokens(self, values: Sequence[int], device: torch.device) -> torch.Tensor:
+        device = torch.device(device)
+        key = (str(device), tuple(int(v) for v in values))
+        cached = self._projected_token_cache.get(key)
+        if cached is None:
+            cached = self._text_projection(self._text_embedding(self._long_tensor(values, device)))
+            self._projected_token_cache[key] = cached
+        return cached
+
     def _get_resampler(self, orig_sr: int, target_sr: int) -> AudioResampler:
         key = (int(orig_sr), int(target_sr))
         cache = self._resampler_cache
@@ -631,9 +655,9 @@ class Qwen3TTSPromptEmbedsBuilder:
         if entry is None:
             entry = {}
         if isinstance(ref_code, torch.Tensor):
-            entry["ref_code"] = ref_code.detach().to("cpu", dtype=torch.long).contiguous()
+            entry["ref_code"] = ref_code.detach().to(dtype=torch.long).contiguous()
         if isinstance(ref_spk_embedding, torch.Tensor):
-            entry["ref_spk_embedding"] = ref_spk_embedding.detach().to("cpu", dtype=self._embedding_dtype).reshape(-1)
+            entry["ref_spk_embedding"] = ref_spk_embedding.detach().to(dtype=self._embedding_dtype).reshape(-1)
         if not entry:
             return
         self._ref_audio_artifact_cache[cache_key] = entry
@@ -659,7 +683,6 @@ class Qwen3TTSPromptEmbedsBuilder:
                 self._speaker_encoder.to(device=dev, dtype=dtype)
         except StopIteration:
             pass
-
         # Resample to 24kHz for speaker encoder.
         target_sr = int(getattr(self._config.speaker_encoder_config, "sample_rate", 24000))
         if sr != target_sr:
@@ -761,6 +784,23 @@ class Qwen3TTSPromptEmbedsBuilder:
         req_ids: list[str],
         model_intermediate_buffer: dict[str, dict[str, Any]],
         device: torch.device,
+    ) -> None:
+        """MRv1 adapter for the request-info batch implementation."""
+        self.preprocess_infos_batch(
+            req_infos=[
+                info_dict
+                for req_id in req_ids
+                if isinstance((info_dict := model_intermediate_buffer.get(req_id)), dict)
+            ],
+            device=device,
+        )
+
+    @torch.inference_mode()
+    def preprocess_infos_batch(
+        self,
+        *,
+        req_infos: list[dict[str, Any]],
+        device: torch.device,
     ) -> None:
         """Batch Base voice-clone ref-audio codec extraction for current prefill requests.
 
@@ -775,11 +815,7 @@ class Qwen3TTSPromptEmbedsBuilder:
         pending_text: list[tuple[dict[str, Any], str]] = []
         pending_ref_text: list[tuple[dict[str, Any], str]] = []
         groups: dict[int, list[tuple[dict[str, Any], np.ndarray, int]]] = {}
-        for req_id in req_ids:
-            info_dict = model_intermediate_buffer.get(req_id)
-            if not isinstance(info_dict, dict):
-                continue
-
+        for info_dict in req_infos:
             if (
                 self._needs_initial_prompt_preprocess(info_dict)
                 and first_value(info_dict.get("task_type"), "CustomVoice") == "Base"
@@ -837,17 +873,31 @@ class Qwen3TTSPromptEmbedsBuilder:
                 except Exception as exc:
                     logger.debug("Qwen3-TTS batched text tokenization failed; falling back to serial path: %s", exc)
                     continue
-                input_ids = tokenized.get("input_ids") if isinstance(tokenized, dict) else None
+                input_ids = tokenized.get("input_ids") if isinstance(tokenized, Mapping) else None
                 if not isinstance(input_ids, list) or len(input_ids) != len(items):
                     continue
+                valid_items: list[tuple[dict[str, Any], int]] = []
+                flat_ids: list[int] = []
                 for (info_dict, _), ids in zip(items, input_ids, strict=True):
-                    if isinstance(ids, list) and ids:
-                        info_dict[key] = torch.tensor(ids, dtype=torch.long)
+                    if not (
+                        isinstance(ids, list)
+                        and ids
+                        and all(isinstance(token_id, (int, np.integer)) for token_id in ids)
+                    ):
+                        continue
+                    valid_items.append((info_dict, len(ids)))
+                    flat_ids.extend(int(token_id) for token_id in ids)
+                if not valid_items:
+                    continue
+                use_async_h2d = device.type == "cuda"
+                packed_ids_cpu = torch.tensor(flat_ids, dtype=torch.long, pin_memory=use_async_h2d)
+                packed_ids = packed_ids_cpu.to(device=device, non_blocking=use_async_h2d)
+                offset = 0
+                for info_dict, num_ids in valid_items:
+                    info_dict[key] = packed_ids.narrow(0, offset, num_ids)
+                    offset += num_ids
 
         groups = {sr: items for sr, items in groups.items() if len(items) >= 2}
-        if not groups:
-            return
-
         for sr, items in groups.items():
             wavs = [wav for _, wav, _ in items]
             try:
@@ -892,9 +942,7 @@ class Qwen3TTSPromptEmbedsBuilder:
         codec_embed_sum = torch.cat(codec_embed, dim=1).sum(1).unsqueeze(0)  # [1,T,H]
         codec_embed_sum = torch.cat(
             [
-                self._codec_embed(
-                    torch.tensor([[self._talker_config.codec_bos_id]], device=codec_embed_sum.device, dtype=torch.long)
-                ),
+                self._codec_embed(self._long_tensor([self._talker_config.codec_bos_id], codec_embed_sum.device)),
                 codec_embed_sum,
             ],
             dim=1,
@@ -990,12 +1038,8 @@ class Qwen3TTSPromptEmbedsBuilder:
         # tts special token embeds (projected into talker hidden).
         # ``tts_pad_embed`` is precomputed (request-independent), so we only
         # need bos/eos here.
-        tts_tokens = torch.tensor(
-            [[config.tts_bos_token_id, config.tts_eos_token_id]],
-            device=input_ids.device,
-            dtype=input_ids.dtype,
-        )
-        tts_bos_embed, tts_eos_embed = text_projection(text_embedding(tts_tokens)).chunk(2, dim=1)
+        projected_tts = self._projected_tokens([config.tts_bos_token_id, config.tts_eos_token_id], input_ids.device)
+        tts_bos_embed, tts_eos_embed = projected_tts.chunk(2, dim=1)
         tts_pad_embed = self._pad_embed(input_ids.device, tts_bos_embed.dtype)
 
         # Codec prefill tags.
@@ -1032,9 +1076,9 @@ class Qwen3TTSPromptEmbedsBuilder:
                 ]
             ]
 
-        codec_input_0 = codec_embed(torch.tensor(codec_prefill_list, device=input_ids.device, dtype=torch.long))
+        codec_input_0 = codec_embed(self._long_tensor(codec_prefill_list[0], input_ids.device))
         codec_input_1 = codec_embed(
-            torch.tensor([[talker_config.codec_pad_id, talker_config.codec_bos_id]], device=input_ids.device)
+            self._long_tensor([talker_config.codec_pad_id, talker_config.codec_bos_id], input_ids.device)
         )
 
         # Speaker embedding/token (task-dependent)
@@ -1339,7 +1383,7 @@ class Qwen3TTSPromptEmbedsBuilder:
                             talker_prompt,
                             text_all + codec_embed(pad_ids),
                             tts_pad_embed
-                            + codec_embed(torch.tensor([[talker_config.codec_bos_id]], device=input_ids.device)),
+                            + codec_embed(self._long_tensor([talker_config.codec_bos_id], input_ids.device)),
                         ],
                         dim=1,
                     )
@@ -1392,8 +1436,7 @@ class Qwen3TTSPromptEmbedsBuilder:
                     [
                         talker_prompt,
                         text_all + codec_embed(pad_ids),
-                        tts_pad_embed
-                        + codec_embed(torch.tensor([[talker_config.codec_bos_id]], device=input_ids.device)),
+                        tts_pad_embed + codec_embed(self._long_tensor([talker_config.codec_bos_id], input_ids.device)),
                     ],
                     dim=1,
                 )
@@ -1431,8 +1474,7 @@ class Qwen3TTSPromptEmbedsBuilder:
                     [
                         talker_prompt,
                         text_all + codec_embed(pad_ids),
-                        tts_pad_embed
-                        + codec_embed(torch.tensor([[talker_config.codec_bos_id]], device=input_ids.device)),
+                        tts_pad_embed + codec_embed(self._long_tensor([talker_config.codec_bos_id], input_ids.device)),
                     ],
                     dim=1,
                 )
diff --git a/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_code2wav.py b/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_code2wav.py
index 8ab5c5e34..ce9f0b04a 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_code2wav.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_code2wav.py
@@ -46,9 +46,9 @@ def _codec_ids_from_payload_or_input(
         if isinstance(codes, dict):
             audio = codes.get("audio")
             if isinstance(audio, torch.Tensor) and audio.numel() > 0:
-                return audio.reshape(-1).to(device=input_ids.device, dtype=torch.long)
+                return audio.reshape(-1).to(dtype=torch.long)
             if isinstance(audio, (list, tuple)) and audio:
-                return torch.as_tensor(audio, device=input_ids.device, dtype=torch.long).reshape(-1)
+                return torch.as_tensor(audio, dtype=torch.long).reshape(-1)
     return input_ids.reshape(-1).to(dtype=torch.long)
 
 
@@ -63,6 +63,10 @@ class Qwen3TTSCode2Wav(nn.Module):
     # decoder caches must use the same IDs delivered by on_requests_finished;
     # payload metadata carries an external ID which may differ.
     requires_request_ids = True
+    # A nonempty native codes.audio payload is authoritative; token IDs may
+    # serve only as per-request control slots for the generation scheduler.
+    supports_native_payload_input = True
+    batched_gpu_staging_keys = {("codes", "audio")}
 
     def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
         super().__init__()
@@ -427,12 +431,9 @@ class Qwen3TTSCode2Wav(nn.Module):
             try:
                 _, c = valid_codes_qf[0]
                 logger.info(
-                    "Code2Wav codec: frames=%d q=%d uniq=%d range=[%d,%d] batch=%d",
+                    "Code2Wav codec: frames=%d q=%d batch=%d",
                     c.shape[1],
                     q,
-                    int(torch.unique(c).numel()),
-                    int(c.min().item()),
-                    int(c.max().item()),
                     len(valid_codes_qf),
                 )
             except Exception:
@@ -454,9 +455,22 @@ class Qwen3TTSCode2Wav(nn.Module):
 
         request_lengths = [int(codes_qf.shape[-1]) for _, codes_qf in valid_codes_qf]
         max_request_length = max(request_lengths)
-        request_codes = valid_codes_qf[0][1].new_zeros((len(valid_codes_qf), q, max_request_length))
-        for row, (_, codes_qf) in enumerate(valid_codes_qf):
-            request_codes[row, :, : codes_qf.shape[-1]].copy_(codes_qf)
+        request_codes_shape = (len(valid_codes_qf), q, max_request_length)
+        target_device = ids.device
+        if target_device.type == "cuda" and all(codes_qf.device.type == "cpu" for _, codes_qf in valid_codes_qf):
+            staged_codes = torch.zeros(
+                request_codes_shape,
+                dtype=torch.long,
+                device="cpu",
+                pin_memory=True,
+            )
+            for row, (_, codes_qf) in enumerate(valid_codes_qf):
+                staged_codes[row, :, : codes_qf.shape[-1]].copy_(codes_qf)
+            request_codes = staged_codes.to(device=target_device, non_blocking=True)
+        else:
+            request_codes = torch.zeros(request_codes_shape, dtype=torch.long, device=target_device)
+            for row, (_, codes_qf) in enumerate(valid_codes_qf):
+                request_codes[row, :, : codes_qf.shape[-1]].copy_(codes_qf)
 
         self._record_decode_batch_stats(
             group_size=len(valid_codes_qf),
diff --git a/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_talker.py b/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_talker.py
index dfb24516a..1a1358c17 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_talker.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_talker.py
@@ -4,7 +4,8 @@
 from __future__ import annotations
 
 import copy
-from collections.abc import Iterable, Mapping, Sequence
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from contextlib import contextmanager
 from typing import Any
 
 import numpy as np
@@ -25,13 +26,14 @@ from vllm.multimodal.audio import AudioResampler
 from vllm.sequence import IntermediateTensors
 
 from vllm_omni.data_entry_keys import OmniPayload
-from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.model_executor.models.output_templates import OmniOutput, OwnedBatchTensor
 from vllm_omni.utils.speaker_cache import (
     get_speaker_cache,
     iter_custom_voice_profiles,
     load_validated_profile_tensors,
     validate_qwen3_tts_profile,
 )
+from vllm_omni.worker.sampling_utils import get_tts_local_seed
 
 from .configuration_qwen3_tts import Qwen3TTSConfig, Qwen3TTSSpeakerEncoderConfig, Qwen3TTSTalkerConfig
 from .prompt_embeds_builder import PRECOMPUTED_TEXT_IDS_KEY, Qwen3TTSPromptEmbedsBuilder, resolve_x_vector_only
@@ -42,6 +44,80 @@ from .tokenizer_12hz.modeling_qwen3_tts_tokenizer_v2 import Qwen3TTSTokenizerV2E
 logger = init_logger(__name__)
 
 _TRAILING_TEXT_COMPACT_MIN_FRAMES = 64
+_ASYNC_REF_CODES_PUBLISHED_KEY = "_qwen3_tts_ref_codes_published"
+
+
+def _qwen3_tts_gpu_resident_buffer_keys(
+    use_v2_model_runner: bool,
+) -> set[tuple[str, str]]:
+    keys = {
+        ("codes", "audio"),
+        ("hidden_states", "last"),
+        ("hidden_states", "trailing_text"),
+    }
+    if use_v2_model_runner:
+        keys.update(
+            {
+                ("codes", "ref"),
+                ("embed", "prefill"),
+                ("meta", "codec_frame_valid"),
+            }
+        )
+    return keys
+
+
+def _materialize_span_scalars(
+    values: Sequence[int],
+    span_lengths: Sequence[int],
+    *,
+    dtype: torch.dtype,
+    device: torch.device,
+) -> torch.Tensor | None:
+    """Expand a uniform scalar cohort with one GPU allocation."""
+    if len(values) != len(span_lengths):
+        raise ValueError(
+            f"values and span_lengths must have the same length, got {len(values)} and {len(span_lengths)}"
+        )
+    total = sum(int(length) for length in span_lengths)
+    if not values:
+        return torch.empty((0,), dtype=dtype, device=device)
+    first = int(values[0])
+    if not all(int(value) == first for value in values[1:]):
+        return None
+    return torch.full((total,), first, dtype=dtype, device=device)
+
+
+def _should_publish_async_ref_codes(info: dict[str, Any]) -> bool:
+    """Publish ref codes exactly once, including after a KV-resumed prefill."""
+    meta = info.get("meta")
+    return not (isinstance(meta, dict) and bool(meta.get(_ASYNC_REF_CODES_PUBLISHED_KEY)))
+
+
+def _mark_async_ref_codes_published(info: dict[str, Any]) -> None:
+    meta = info.setdefault("meta", {})
+    if not isinstance(meta, dict):
+        raise TypeError("Qwen3-TTS payload meta must be a dict")
+    meta[_ASYNC_REF_CODES_PUBLISHED_KEY] = True
+
+
+def _ref_audio_artifact_cache_capacity(vllm_config: VllmConfig) -> int:
+    model_cfg = getattr(vllm_config, "model_config", None)
+    connector_cfg = getattr(model_cfg, "stage_connector_config", None)
+    connector_extra = (
+        connector_cfg.get("extra", connector_cfg)
+        if isinstance(connector_cfg, dict)
+        else getattr(connector_cfg, "extra", None)
+    )
+    if not isinstance(connector_extra, dict):
+        connector_extra = {}
+    raw_capacity = connector_extra.get("ref_audio_artifact_cache_max_entries", 1024)
+    try:
+        capacity = int(raw_capacity)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Invalid ref_audio_artifact_cache_max_entries={raw_capacity!r}") from exc
+    if capacity < 0:
+        raise ValueError(f"ref_audio_artifact_cache_max_entries must be non-negative, got {capacity}")
+    return capacity
 
 
 def _has_tts_text_conditioning(info_dict: dict[str, Any], hidden_states: Any | None = None) -> bool:
@@ -267,8 +343,7 @@ class Qwen3TTSSpeakerEncoder(torch.nn.Module):
 
 
 class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
-    """vLLM-AR talker: step-wise layer-0 codec decoding.
-    Predicts residual codebooks (1..Q-1) into `audio_codes` and streams text via `tailing_text_hidden`."""
+    """vLLM-AR talker with step-wise layer-0 codec decoding."""
 
     hf_to_vllm_mapper = WeightsMapper(
         orig_to_new_prefix={
@@ -329,29 +404,13 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         # per-request additional_information.
         self.talker_mtp_output_key = ("codes", "audio")
         self.talker_mtp_graph_safe = True
-        # talker_mtp samples with per-row generators, so explicitly-seeded
-        # requests stay batched instead of one scalar forward per row (#4883).
-        # This is only valid while talker_mtp receives the *unpadded* active
-        # batch, i.e. when it is NOT graph-wrapped. The runner wraps talker_mtp
-        # (padded batches + a single captured RNG stream) whenever full
-        # cudagraphs are enabled, so disable per-row generators in that case.
-        # Consequence: under full cudagraphs, per-request ``tts_local_seed`` is
-        # not reproducible (matching Qwen3-Omni, which has no per-row seeding);
-        # eager mode keeps the per-row generator fast-path.
-        # TODO(#4923): the model should not read ``cudagraph_mode`` — it is an
-        # upstream (runner) concern, and the runner already re-derives the same
-        # wrap decision in ``_init_talker_mtp``. Once all TTS models declare
-        # ``talker_mtp_graph_safe`` we should move this gating into the model
-        # runner (models only expose the static capability flag, and users can
-        # then configure ``cudagraph_mode`` freely). This also means mtp seeding
-        # is silently dropped when the decode batch > 1 under full cudagraphs;
-        # the follow-up should refactor the per-row generator in the runner to
-        # be cudagraph-safe so seeded batches stay reproducible.
-        cudagraph_mode = getattr(vllm_config.compilation_config, "cudagraph_mode", None)
-        talker_mtp_graph_wrapped = (
-            self.talker_mtp_graph_safe and cudagraph_mode is not None and cudagraph_mode.has_full_cudagraphs()
-        )
-        self.talker_mtp_accepts_per_row_generators = not talker_mtp_graph_wrapped
+        # The runners bypass only the outer whole-MTP graph when explicit
+        # generators are present, so seeded requests can still share one raw
+        # batched MTP call with independent per-row streams.
+        self.talker_mtp_accepts_per_row_generators = True
+        self.mtp_sample_uniforms = True
+        self.mtp_sample_steps = max(0, int(self.talker_config.num_code_groups) - 1)
+        self.mtp_sample_vocab_size = self._codebook_vocab_size
         self.use_async_omni_output = True
         self.eager_omni_postprocess_before_async_output = True
         self.omni_pooler_payload_include_hidden = False
@@ -445,14 +504,24 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         # the same req_id ordering that indexes sampling_metadata.
         self._req_x_vector_only: dict[str, bool | None] = {}
         self._batch_req_ids: list[str] = []
+        self._mrv2_silence_ban_mask: torch.Tensor | None = None
 
         # Keys that should stay on GPU in model_intermediate_buffer to avoid
         # CPU-to-GPU round-trips on every decode step.
-        self.gpu_resident_buffer_keys: set[tuple[str, str]] = {
-            ("codes", "audio"),
-            ("hidden_states", "last"),
-            ("hidden_states", "trailing_text"),
-        }
+        self._use_v2_model_runner = bool(getattr(vllm_config.model_config, "use_v2_model_runner", False))
+        self.gpu_resident_buffer_keys = _qwen3_tts_gpu_resident_buffer_keys(self._use_v2_model_runner)
+
+        if self._use_v2_model_runner:
+            # Align predictor warmup/capture buckets with the outer MRv2 MTP
+            # graph buckets so the compile cache covers every reachable size.
+            outer_max_bsz = int(vllm_config.scheduler_config.max_num_seqs)
+            outer_buckets = {
+                int(size)
+                for size in vllm_config.compilation_config.cudagraph_capture_sizes
+                if 0 < int(size) <= outer_max_bsz
+            }
+            outer_buckets.update({1, outer_max_bsz})  # eager fallback rows
+            self.code_predictor.configure_mtp_execution_buckets(sorted(outer_buckets))
 
         # ``text_proj(text_emb(tts_pad_token_id))`` is request-independent —
         # it depends only on frozen ``text_embedding`` / ``text_projection``
@@ -492,6 +561,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         self._subtalker_sampling_params: dict[str, Any] = (
             dict(raw_subtalker_sampling) if isinstance(raw_subtalker_sampling, Mapping) else {}
         )
+        self.mtp_sampling_params = self._subtalker_sampling_params
 
         self._stacked_codec_embed: torch.Tensor | None = None
 
@@ -514,6 +584,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             tts_pad_embed=self._tts_pad_embed,
             encode_ref_audio_batch=self._encode_ref_audio_batch,
             speaker_cache=self._speaker_cache,
+            ref_audio_artifact_cache_max_entries=_ref_audio_artifact_cache_capacity(vllm_config),
         )
         self._load_custom_voice_profiles()
 
@@ -592,6 +663,10 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         # Suppress silence-region tokens for the first N decode frames (#4966). The
         # per-request decode step is the length of its generated-token history.
         ban_n = self._silence_ban_frames
+        if ban_n > 0 and sampling_metadata is None and self._mrv2_silence_ban_mask is not None:
+            if self._mrv2_silence_ban_mask.shape[0] != logits.shape[0]:
+                raise ValueError("MRV2 silence-ban batch must match the sampled logits rows")
+            return logits.masked_fill(self._mrv2_silence_ban_mask & self._silence_mask, float("-inf"))
         if ban_n > 0 and sampling_metadata is not None:
             output_token_ids = getattr(sampling_metadata, "output_token_ids", None)
             if output_token_ids is None or len(output_token_ids) != logits.shape[0]:
@@ -645,11 +720,17 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             info_dicts = kwargs.get("runtime_additional_information") or []
         if "runtime_additional_information" in kwargs and "model_intermediate_buffer" not in kwargs:
             logger.warning_once("runtime_additional_information is deprecated, use model_intermediate_buffer")
+        model_config = getattr(getattr(self, "vllm_config", None), "model_config", None)
+        async_chunk = bool(getattr(model_config, "async_chunk", False))
         audio_codes_list: list[torch.Tensor] = []
-        ref_code_len_list: list[torch.Tensor] = []
+        ref_code_len_segments: list[tuple[int | torch.Tensor, int, torch.device]] = []
         ref_code_list: list[torch.Tensor] = []
         has_ref_code = False
-        codec_streaming_list: list[torch.Tensor] = []
+        codec_streaming_values: list[int] = []
+        codec_streaming_span_lengths: list[int] = []
+        codec_streaming_device: torch.device | None = None
+        codec_frame_valid_device: torch.device | None = None
+        codec_frame_valid_parts: list[torch.Tensor] = []
         for info in info_dicts:
             if not isinstance(info, dict):
                 ref_code_list.append(torch.empty(0, dtype=torch.long))
@@ -659,17 +740,46 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             ac = codes.get("audio")
             if isinstance(ac, torch.Tensor):
                 audio_codes_list.append(ac)
-                cs = meta.get("codec_streaming")
-                if isinstance(cs, bool):
-                    codec_streaming_list.append(
-                        torch.full((int(ac.shape[0]),), int(cs), dtype=torch.int8, device=ac.device)
+                frame_valid = meta.get("codec_frame_valid")
+                if isinstance(frame_valid, bool):
+                    codec_frame_valid_device = ac.device
+                    codec_frame_valid_parts.append(
+                        torch.full(
+                            (int(ac.shape[0]),),
+                            int(frame_valid),
+                            dtype=torch.int8,
+                            device=ac.device,
+                        )
                     )
+                elif isinstance(frame_valid, torch.Tensor):
+                    if frame_valid.numel() != 1:
+                        raise ValueError("codec_frame_valid must be scalar per request")
+                    codec_frame_valid_device = ac.device
+                    codec_frame_valid_parts.append(
+                        frame_valid.to(device=ac.device, dtype=torch.int8, non_blocking=True)
+                        .reshape(1)
+                        .expand(int(ac.shape[0]))
+                    )
+                cs = meta.get("codec_streaming")
+                if not async_chunk and isinstance(cs, bool):
+                    codec_streaming_values.append(int(cs))
+                    codec_streaming_span_lengths.append(int(ac.shape[0]))
+                    codec_streaming_device = ac.device
             ref_code = codes.get("ref")
-            if isinstance(ref_code, torch.Tensor) and ref_code.numel() > 0:
+            publish_ref_code = not async_chunk or _should_publish_async_ref_codes(info)
+            if publish_ref_code and isinstance(ref_code, torch.Tensor) and ref_code.numel() > 0:
                 ref_code_list.append(ref_code)
                 has_ref_code = True
+                if async_chunk:
+                    _mark_async_ref_codes_published(info)
             else:
                 ref_code_list.append(torch.empty(0, dtype=torch.long))
+            if async_chunk:
+                # The streaming consumer uses codes.ref.shape[0] directly and
+                # does not read ref_code_len or codec_streaming. Avoid creating
+                # GPU control tensors that would only be snapshotted and copied
+                # back to the CPU on every decode step.
+                continue
             ref_len = meta.get("ref_code_len")
             if ref_len is None:
                 continue
@@ -680,7 +790,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
                 if ref_len.numel() == 0:
                     raise ValueError("ref_code_len is an empty tensor")
                 ref_len_tail = ref_len.reshape(-1)[-1:].to(dtype=torch.int32, device=ac.device)
-                ref_code_len_list.append(ref_len_tail.expand(span_len).contiguous())
+                ref_code_len_segments.append((ref_len_tail, span_len, ac.device))
                 continue
             if isinstance(ref_len, list):
                 if len(ref_len) != 1:
@@ -688,7 +798,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
                 ref_len_val = int(ref_len[0])
             else:
                 ref_len_val = int(ref_len)
-            ref_code_len_list.append(torch.full((span_len,), ref_len_val, dtype=torch.int32, device=ac.device))
+            ref_code_len_segments.append((ref_len_val, span_len, ac.device))
 
         if not audio_codes_list:
             return OmniOutput(text_hidden_states=hidden, multimodal_outputs={})
@@ -696,15 +806,61 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         audio_codes = torch.cat(audio_codes_list, dim=0)
         span_len = int(audio_codes.shape[0])
         mm: OmniPayload = {"codes": {"audio": audio_codes}}
-        if ref_code_len_list:
-            mm.setdefault("meta", {})["ref_code_len"] = torch.cat(ref_code_len_list, dim=0)[:span_len]
+        if ref_code_len_segments:
+            if all(isinstance(value, int) for value, _length, _device in ref_code_len_segments):
+                ref_code_len = _materialize_span_scalars(
+                    [int(value) for value, _length, _device in ref_code_len_segments],
+                    [length for _value, length, _device in ref_code_len_segments],
+                    dtype=torch.int32,
+                    device=ref_code_len_segments[0][2],
+                )
+                if ref_code_len is None:
+                    ref_code_len = torch.cat(
+                        [
+                            torch.full((length,), int(value), dtype=torch.int32, device=device)
+                            for value, length, device in ref_code_len_segments
+                        ],
+                        dim=0,
+                    )
+            else:
+                ref_code_len_parts = [
+                    value.expand(length)
+                    if isinstance(value, torch.Tensor)
+                    else torch.full((length,), value, dtype=torch.int32, device=device)
+                    for value, length, device in ref_code_len_segments
+                ]
+                ref_code_len = torch.cat(ref_code_len_parts, dim=0)
+            mm.setdefault("meta", {})["ref_code_len"] = ref_code_len[:span_len]
         if has_ref_code:
             # Batch-aligned, one entry per request: ``to_payload_element``
             # indexes ``element[idx]`` per request, and a shorter list would
             # silently broadcast one request's reference codes to the others.
             mm.setdefault("codes", {})["ref"] = ref_code_list
-        if codec_streaming_list:
-            mm.setdefault("meta", {})["codec_streaming"] = torch.cat(codec_streaming_list, dim=0)[:span_len]
+        if codec_streaming_values:
+            assert codec_streaming_device is not None
+            codec_streaming = _materialize_span_scalars(
+                codec_streaming_values,
+                codec_streaming_span_lengths,
+                dtype=torch.int8,
+                device=codec_streaming_device,
+            )
+            if codec_streaming is None:
+                codec_streaming = torch.cat(
+                    [
+                        torch.full((length,), value, dtype=torch.int8, device=codec_streaming_device)
+                        for value, length in zip(
+                            codec_streaming_values,
+                            codec_streaming_span_lengths,
+                            strict=True,
+                        )
+                    ],
+                    dim=0,
+                )
+            mm.setdefault("meta", {})["codec_streaming"] = codec_streaming[:span_len]
+        if codec_frame_valid_parts:
+            assert codec_frame_valid_device is not None
+            codec_frame_valid = torch.cat(codec_frame_valid_parts, dim=0)
+            mm.setdefault("meta", {})["codec_frame_valid"] = codec_frame_valid[:span_len]
         return OmniOutput(text_hidden_states=hidden, multimodal_outputs=mm)
 
     # -------------------- preprocess / postprocess --------------------
@@ -763,27 +919,32 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
 
         if is_prefill:
             # Prefill (prompt embeddings)
-            prompt_embeds_cpu = embed.get("prefill")
-            # First prefill round: prompt_embeds_cpu is not yet populated.
-            # Subsequent prefill rounds (multi-chunk): prompt_embeds_cpu is a Tensor stored by the first round.
-            is_first_prefill = not isinstance(prompt_embeds_cpu, torch.Tensor) or prompt_embeds_cpu.ndim != 2
+            prompt_embeds_buffer = embed.get("prefill")
+            # First prefill round: the retained prompt buffer is not populated.
+            # Subsequent chunks slice the buffer stored by the first round.
+            is_first_prefill = not isinstance(prompt_embeds_buffer, torch.Tensor) or prompt_embeds_buffer.ndim != 2
             if is_first_prefill:
                 full_prompt_embeds, tailing_text_hidden, ref_code_len, ref_code = (
                     self._prompt_builder.build_prompt_embeds(task_type=task_type, info_dict=info_dict)
                 )
-                # Store full prompt embeddings on CPU (large, prefill-only).
-                # tailing_text_hidden stays on GPU (gpu_resident_buffer_keys).
-                prompt_embeds_cpu = full_prompt_embeds.detach().to("cpu").contiguous()
+                prompt_embeds_buffer = full_prompt_embeds.detach()
+                if not bool(getattr(self, "_use_v2_model_runner", False)):
+                    prompt_embeds_buffer = prompt_embeds_buffer.to("cpu")
+                prompt_embeds_buffer = prompt_embeds_buffer.contiguous()
                 info_update: OmniPayload = {
-                    "embed": {"prefill": prompt_embeds_cpu},
+                    "embed": {"prefill": prompt_embeds_buffer},
                     "hidden_states": {"trailing_text": tailing_text_hidden.detach()},
                     "meta": {
                         "talker_text_offset": 0,
                         "codec_streaming": codec_streaming,
+                        "codec_frame_valid": torch.zeros((), dtype=torch.bool, device=input_ids.device),
                     },
                 }
                 if isinstance(ref_code, torch.Tensor) and ref_code.numel() > 0:
-                    info_update.setdefault("codes", {})["ref"] = ref_code.detach().to("cpu").contiguous()
+                    ref_code_buffer = ref_code.detach()
+                    if not bool(getattr(self, "_use_v2_model_runner", False)):
+                        ref_code_buffer = ref_code_buffer.to("cpu")
+                    info_update.setdefault("codes", {})["ref"] = ref_code_buffer.contiguous()
                 if ref_code_len is not None:
                     info_update["meta"]["ref_code_len"] = int(ref_code_len)
                 # First prefill: source the slice offset from `_omni_num_computed_tokens`
@@ -794,16 +955,21 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             else:
                 # Subsequent prefill chunk: slice from stored embeddings at running offset.
                 offset = max(0, int(meta.get("talker_prefill_offset", 0) or 0))
-                info_update = {"meta": {"codec_streaming": codec_streaming}}
+                info_update = {
+                    "meta": {
+                        "codec_streaming": codec_streaming,
+                        "codec_frame_valid": torch.zeros((), dtype=torch.bool, device=input_ids.device),
+                    }
+                }
 
             # Always return a span_len slice; if the scheduled placeholder is longer than what
             # the prompt actually fills, pad with tts_pad_embed (preserves placeholder/embedding alignment).
-            s = max(0, min(offset, int(prompt_embeds_cpu.shape[0])))
-            e = max(0, min(offset + span_len, int(prompt_embeds_cpu.shape[0])))
-            take = prompt_embeds_cpu[s:e]
+            s = max(0, min(offset, int(prompt_embeds_buffer.shape[0])))
+            e = max(0, min(offset + span_len, int(prompt_embeds_buffer.shape[0])))
+            take = prompt_embeds_buffer[s:e]
             if int(take.shape[0]) < span_len:
                 pad_n = int(span_len - int(take.shape[0]))
-                pad_rows = tts_pad_embed.reshape(1, -1).to("cpu").expand(pad_n, -1)
+                pad_rows = tts_pad_embed.to(device=take.device).reshape(1, -1).expand(pad_n, -1)
                 take = torch.cat([take, pad_rows], dim=0)
             prompt_embeds = take.to(device=input_ids.device, dtype=dtype)
             info_update["meta"]["talker_prefill_offset"] = int(offset + span_len)
@@ -826,7 +992,16 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
                 .to(device=input_ids.device, dtype=dtype)
                 .reshape(span_len, -1)
             )
-            return input_ids, inputs_embeds_out, {"meta": {"codec_streaming": codec_streaming}}
+            return (
+                input_ids,
+                inputs_embeds_out,
+                {
+                    "meta": {
+                        "codec_streaming": codec_streaming,
+                        "codec_frame_valid": torch.zeros((), dtype=torch.bool, device=input_ids.device),
+                    }
+                },
+            )
 
         # Decode: span_len == 1
         # Pop one text-step vector from tailing_text_hidden queue.
@@ -884,6 +1059,9 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             "meta": {
                 "talker_text_offset": int(next_text_offset),
                 "codec_streaming": codec_streaming,
+                "codec_frame_valid": (
+                    (input_ids.reshape(-1)[-1] >= 0) & (input_ids.reshape(-1)[-1] < self._codebook_vocab_size)
+                ).reshape(()),
             },
         }
         if trailing_text_update is not None:
@@ -895,11 +1073,13 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         *,
         input_ids: torch.Tensor,
         req_infos: list[dict[str, Any]],
+        input_embeds: torch.Tensor | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, list[dict[str, Any]]]:
         """Batch the decode-only preprocess path for Qwen3-TTS.
 
         This mirrors the scalar decode branch in ``preprocess()``, but performs
-        the token embedding lookup once for the whole decode batch.
+        the token embedding lookup once for the whole decode batch, unless
+        the runner has already prepared embeddings for these input ids.
         """
         input_ids_flat = input_ids.reshape(-1)
         if int(input_ids_flat.numel()) != len(req_infos):
@@ -907,6 +1087,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
                 f"preprocess_decode_batch expected {len(req_infos)} input ids, got {int(input_ids_flat.numel())}"
             )
 
+        codec_frame_valid_batch = (input_ids_flat >= 0) & (input_ids_flat < self._codebook_vocab_size)
         device = input_ids_flat.device
         dtype = self._embedding_dtype
         # Request-independent constant (see :meth:`_init_runtime_buffers`) —
@@ -979,17 +1160,16 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
                 "meta": {
                     "talker_text_offset": int(next_text_offset),
                     "codec_streaming": codec_streaming,
+                    "codec_frame_valid": codec_frame_valid_batch[len(updates)].reshape(()),
                 },
             }
             if trailing_text_update is not None:
                 info_update["hidden_states"] = {"trailing_text": trailing_text_update.detach()}
             updates.append(info_update)
 
-        inputs_embeds_out = self.embed_input_ids(input_ids_flat.reshape(-1, 1).to(torch.long)).to(
-            device=device,
-            dtype=dtype,
-        )
-        inputs_embeds_out = inputs_embeds_out.reshape(len(req_infos), -1)
+        if input_embeds is None:
+            input_embeds = self.embed_input_ids(input_ids_flat.reshape(-1, 1).to(torch.long))
+        inputs_embeds_out = input_embeds.to(device=device, dtype=dtype).reshape(len(req_infos), -1)
         return (
             input_ids_flat,
             inputs_embeds_out,
@@ -998,6 +1178,16 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             updates,
         )
 
+    def preprocess_decode_batch_mrv2(
+        self,
+        *,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor,
+        req_infos: list[dict[str, Any]],
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, list[dict[str, Any]]]:
+        """Expose the existing TTS decode batcher through the MRv2 contract."""
+        return self.preprocess_decode_batch(input_ids=input_ids, req_infos=req_infos, input_embeds=input_embeds)
+
     def postprocess(self, hidden_states: torch.Tensor, **_: Any) -> dict[str, Any]:
         # Keep the last token hidden for the next decode step's code predictor.
         # Stays on GPU - gpu_resident_buffer_keys avoids the CPU round-trip.
@@ -1006,6 +1196,23 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         last = hidden_states[-1, :].detach()
         return {"hidden_states": {"last": last}}
 
+    def postprocess_batch_mrv2(
+        self,
+        *,
+        hidden_states: torch.Tensor,
+        last_token_indices: torch.Tensor,
+    ) -> tuple[tuple[str, str], OwnedBatchTensor]:
+        """Gather every request's Talker tail in one GPU operation.
+
+        ``index_select`` freshly allocates the result, so the batch is marked
+        as owned and the intermediate buffer stores row views without taking
+        a second snapshot.
+        """
+        return (
+            ("hidden_states", "last"),
+            OwnedBatchTensor(hidden_states.index_select(0, last_token_indices)),
+        )
+
     @torch.inference_mode()
     def preprocess_batch(
         self,
@@ -1026,6 +1233,39 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             device=device,
         )
 
+    @torch.inference_mode()
+    def preprocess_batch_mrv2(
+        self,
+        *,
+        req_infos: list[dict[str, Any]],
+        device: torch.device,
+    ) -> None:
+        """Batch new MRv2 prefill slots without rebuilding a req-id map."""
+        if self._silence_ban_frames > 0:
+            for info in req_infos:
+                self._req_x_vector_only[info["req_id"]] = resolve_x_vector_only(info)
+        self._prompt_builder.preprocess_infos_batch(
+            req_infos=req_infos,
+            device=device,
+        )
+
+    @contextmanager
+    def mrv2_sampling_context(self, *, req_ids: list[str], num_output_tokens: torch.Tensor) -> Iterator[None]:
+        """Scope the silence gate to sampling, never prompt-logprob computation."""
+        self.set_batch_req_ids(req_ids)
+        self._mrv2_silence_ban_mask = None
+        if self._silence_ban_frames > 0:
+            in_scope = torch.tensor(
+                [self._req_x_vector_only.get(req_id) is True for req_id in req_ids],
+                device=num_output_tokens.device,
+                dtype=torch.bool,
+            )
+            self._mrv2_silence_ban_mask = (in_scope & (num_output_tokens < self._silence_ban_frames)).unsqueeze(1)
+        try:
+            yield
+        finally:
+            self._mrv2_silence_ban_mask = None
+
     def set_batch_req_ids(self, req_ids: Sequence[str]) -> None:
         """Record the current batch's req_ids, in the order that indexes logits.
 
@@ -1051,10 +1291,9 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             sampling_rate=target_sr,
             return_tensors="pt",
         )
-        inputs = inputs.to(device).to(torch.bfloat16)
-
-        input_values = inputs["input_values"].squeeze(1)
-        padding_mask = inputs["padding_mask"].squeeze(1)
+        input_values = inputs["input_values"].squeeze(1).to(device=device, dtype=torch.bfloat16)
+        downsample = self._encoder_downsample_rate
+        valid_code_lengths = [(int(wav.size) + downsample - 1) // downsample for wav in wavs]
 
         with torch.inference_mode():
             encoded = self.encoder.encode(
@@ -1063,13 +1302,13 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             )
 
         audio_codes = encoded.audio_codes[:, : self._encoder_valid_num_quantizers]
-        downsample = self._encoder_downsample_rate
         return [
-            code[..., : -(-mask.sum() // downsample)].transpose(0, 1).to(device=device, dtype=torch.long)
-            for code, mask in zip(audio_codes, padding_mask)
+            code[:, : int(valid_len)].transpose(0, 1).to(dtype=torch.long).contiguous()
+            for code, valid_len in zip(audio_codes, valid_code_lengths, strict=True)
         ]
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        self._prompt_builder._projected_token_cache.clear()
         # Consume talker weights, and conditionally consume speaker encoder
         # weights only if they are present in the checkpoint.
         speaker_weights: list[tuple[str, torch.Tensor]] = []
@@ -1256,6 +1495,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         top_p: float | None = None,
         generator: torch.Generator | None = None,
         generators: Sequence[torch.Generator | None] | None = None,
+        sample_uniforms: torch.Tensor | None = None,
         **kwargs: Any,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         """GPU fast-path used by OmniGPUModelRunner to predict residual codebooks (1..Q-1).
@@ -1296,6 +1536,7 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
             top_p=top_p,
             generator=generator,
             generators=generators,
+            sample_uniforms=sample_uniforms,
         )  # [B, Q]
 
         # Map invalid layer-0 ids (e.g. EOS) to PAD=0 so SpeechTokenizer sees only real codes.
@@ -1313,3 +1554,20 @@ class Qwen3TTSTalkerForConditionalGeneration(nn.Module):
         summed = (last_id_hidden.squeeze(1) + gathered.sum(dim=1)).unsqueeze(1)
         inputs_embeds_out = (summed + text_step).reshape(bsz, -1)
         return inputs_embeds_out, audio_codes.to(dtype=torch.long)
+
+    # MRV2 capability names read the V1 canonical values so platform patches
+    # such as the NPU 310P graph-safety override apply to both runners.
+    mtp = talker_mtp
+    get_mtp_seed = staticmethod(get_tts_local_seed)
+
+    @property
+    def mtp_output_key(self) -> tuple[str, str]:
+        return self.talker_mtp_output_key
+
+    @property
+    def mtp_graph_safe(self) -> bool:
+        return self.talker_mtp_graph_safe
+
+    @property
+    def mtp_accepts_per_row_generators(self) -> bool:
+        return self.talker_mtp_accepts_per_row_generators
diff --git a/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py b/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py
index 9572d9ee2..d01eae654 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # Copyright 2026 The Qwen team, Alibaba Group and the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,7 +31,7 @@ from transformers import MimiConfig, MimiModel
 from transformers.activations import ACT2FN
 from transformers.cache_utils import Cache, DynamicCache
 from transformers.integrations import use_kernel_forward_from_hub
-from transformers.masking_utils import create_causal_mask, create_sliding_window_causal_mask
+from transformers.masking_utils import create_sliding_window_causal_mask
 from transformers.modeling_flash_attention_utils import FlashAttentionKwargs
 from transformers.modeling_layers import GradientCheckpointingLayer
 from transformers.modeling_outputs import BaseModelOutputWithPast
@@ -521,15 +524,63 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
         self.norm = Qwen3TTSTokenizerV2DecoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
         self.rotary_emb = Qwen3TTSTokenizerV2DecoderRotatoryEmbedding(config=config)
         self.gradient_checkpointing = False
-        self.has_sliding_layers = "sliding_attention" in self.config.layer_types
         self.window_size = config.sliding_window
 
         self.input_proj = nn.Linear(config.latent_dim, config.hidden_size)
         self.output_proj = nn.Linear(config.hidden_size, config.latent_dim)
+        # Stateless calls with implicit positions share one broadcastable mask
+        # per warmup shape. Incremental or explicit-position calls build a live mask.
+        self._sliding_attention_mask_cache: dict[tuple[int, torch.dtype, torch.device, str], torch.Tensor | None] = {}
 
         # Initialize weights and apply final processing
         self.post_init()
 
+    def _apply(self, fn, recurse=True):
+        # A placement or dtype change invalidates every cached mask.
+        self._sliding_attention_mask_cache.clear()
+        return super()._apply(fn, recurse=recurse)
+
+    def _get_sliding_attention_mask(
+        self,
+        inputs_embeds: torch.Tensor,
+    ) -> torch.Tensor | None:
+        sequence_length = int(inputs_embeds.shape[1])
+        max_position_embeddings = int(self.config.max_position_embeddings)
+        if sequence_length > max_position_embeddings:
+            raise ValueError(
+                f"Input length {sequence_length} exceeds max_position_embeddings {max_position_embeddings}"
+            )
+
+        cache_key = (
+            sequence_length,
+            inputs_embeds.dtype,
+            inputs_embeds.device,
+            str(self.config._attn_implementation),
+        )
+        if cache_key not in self._sliding_attention_mask_cache:
+            mask_inputs = inputs_embeds[:1]
+            mask_kwargs = {
+                "config": self.config,
+                "attention_mask": None,
+                "past_key_values": None,
+                "position_ids": None,
+            }
+            sig = inspect.signature(create_sliding_window_causal_mask)
+            if "input_embeds" in sig.parameters:
+                mask_kwargs["input_embeds"] = mask_inputs
+                mask_kwargs["cache_position"] = torch.arange(
+                    sequence_length,
+                    device=inputs_embeds.device,
+                )
+            else:
+                mask_kwargs["inputs_embeds"] = mask_inputs
+            sliding_attention_mask = create_sliding_window_causal_mask(**mask_kwargs)
+            if sliding_attention_mask is not None:
+                sliding_attention_mask = sliding_attention_mask.contiguous()
+            self._sliding_attention_mask_cache[cache_key] = sliding_attention_mask
+
+        return self._sliding_attention_mask_cache[cache_key]
+
     # Note: @check_model_inputs decorator removed for vLLM compatibility
     # The decorator causes "unexpected keyword argument 'inputs_embeds'" error
     @auto_docstring
@@ -558,6 +609,17 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
 
         inputs_embeds = self.input_proj(inputs_embeds)
 
+        sequence_length = inputs_embeds.shape[1]
+        # Only internally generated positions are known to be contiguous and
+        # zero-based without reading CUDA tensor values back to the host.
+        # Explicit positions use the live mask path, including during capture.
+        uses_prepared_or_incremental_mask = (
+            attention_mask is not None
+            or bool(use_cache)
+            or past_key_values is not None
+            or cache_position is not None
+            or position_ids is not None
+        )
         if use_cache and past_key_values is None:
             past_key_values = DynamicCache(config=self.config)
 
@@ -565,7 +627,7 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
             past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
             cache_position = torch.arange(
                 past_seen_tokens,
-                past_seen_tokens + inputs_embeds.shape[1],
+                past_seen_tokens + sequence_length,
                 device=inputs_embeds.device,
             )
 
@@ -574,22 +636,24 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
 
         hidden_states = inputs_embeds
 
-        if not isinstance(causal_mask_mapping := attention_mask, dict):
+        if isinstance(attention_mask, dict):
+            sliding_attention_mask = attention_mask["sliding_attention"]
+        elif uses_prepared_or_incremental_mask:
             mask_kwargs = {
                 "config": self.config,
                 "attention_mask": attention_mask,
                 "past_key_values": past_key_values,
                 "position_ids": position_ids,
             }
-            sig = inspect.signature(create_causal_mask)
+            sig = inspect.signature(create_sliding_window_causal_mask)
             if "input_embeds" in sig.parameters:
                 mask_kwargs["input_embeds"] = inputs_embeds
                 mask_kwargs["cache_position"] = cache_position
             else:
                 mask_kwargs["inputs_embeds"] = inputs_embeds
-            causal_mask_mapping = {"full_attention": create_causal_mask(**mask_kwargs)}
-            if self.has_sliding_layers:
-                causal_mask_mapping["sliding_attention"] = create_sliding_window_causal_mask(**mask_kwargs)
+            sliding_attention_mask = create_sliding_window_causal_mask(**mask_kwargs)
+        else:
+            sliding_attention_mask = self._get_sliding_attention_mask(inputs_embeds)
 
         # create position embeddings to be shared across the decoder layers
         position_embeddings = self.rotary_emb(hidden_states, position_ids)
@@ -597,7 +661,7 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
         for decoder_layer in self.layers[: self.config.num_hidden_layers]:
             hidden_states = decoder_layer(
                 hidden_states,
-                attention_mask=causal_mask_mapping[decoder_layer.attention_type],
+                attention_mask=sliding_attention_mask,
                 position_ids=position_ids,
                 past_key_values=past_key_values,
                 use_cache=use_cache,
@@ -1400,13 +1464,15 @@ class Qwen3TTSTokenizerV2Decoder(Qwen3TTSTokenizerV2DecoderPreTrainedModel):
 
     @staticmethod
     def _slice_dynamic_cache(cache: DynamicCache, row: int) -> DynamicCache:
-        request_cache = copy.deepcopy(cache)
-        for layer in request_cache.layers:
-            if layer.keys is not None:
-                layer.keys = layer.keys[row : row + 1].clone()
-            if layer.values is not None:
-                layer.values = layer.values[row : row + 1].clone()
-        return request_cache
+        # Preserve cache metadata and independent ownership without cloning the
+        # full batch for every request. Seed deepcopy with only the selected KV
+        # rows; it will copy the remaining cache structure normally.
+        memo: dict[int, Any] = {}
+        for layer in cache.layers:
+            for tensor in (layer.keys, layer.values):
+                if tensor is not None and id(tensor) not in memo:
+                    memo[id(tensor)] = tensor[row : row + 1].clone()
+        return copy.deepcopy(cache, memo)
 
     @staticmethod
     def _cache_tensors_are_batchable(request_caches: list[dict[str, Any]], keys: tuple[str, ...]) -> bool:
diff --git a/vllm_omni/model_executor/models/registry.py b/vllm_omni/model_executor/models/registry.py
index 1a519917c..468ed5302 100644
--- a/vllm_omni/model_executor/models/registry.py
+++ b/vllm_omni/model_executor/models/registry.py
@@ -142,11 +142,6 @@ _OMNI_MODELS = {
         "mammoth_moda2",
         "MammothModa2Qwen3ForCausalLM",
     ),
-    "MammothModa2DiTPipeline": (
-        "mammoth_moda2",
-        "pipeline_mammothmoda2_dit",
-        "MammothModa2DiTPipeline",
-    ),
     "MammothModa2ForConditionalGeneration": (
         "mammoth_moda2",
         "mammoth_moda2",
@@ -326,12 +321,6 @@ _OMNI_MODELS = {
         "voxcpm2_talker",
         "VoxCPM2TalkerForConditionalGeneration",
     ),
-    ## dots.tts
-    "DotsTTSForConditionalGeneration": (
-        "dots_tts",
-        "dots_tts_talker",
-        "DotsTTSForConditionalGeneration",
-    ),
     ## Voxtral TTS
     "VoxtralTTSForConditionalGeneration": (
         "voxtral_tts",
@@ -401,11 +390,6 @@ _OMNI_MODELS = {
         "modeling_moss_tts_codec",
         "MossTTSCodecDecoder",
     ),
-    "DyninOmniForConditionalGeneration": (
-        "dynin_omni",
-        "dynin_omni",
-        "DyninOmniForConditionalGeneration",
-    ),
     ## IndexTTS2
     "IndexTTS2TalkerForConditionalGeneration": (
         "indextts2",
diff --git a/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py b/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
index 78c0b26ea..47c6f1dd3 100644
--- a/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
+++ b/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
@@ -77,6 +77,7 @@ class _ForwardContextLike(Protocol):
 class VoxCPM2PreprocessInput(TypedDict, total=False):
     additional_information: dict[str, Any]
     request_id: str
+    _omni_seed: int | None
     text_token_ids: list[list[int]]
     reference_audio: object
     ref_audio: object
@@ -250,6 +251,10 @@ def _encode_raw_audio(
 @dataclasses.dataclass
 class _RequestState:
     request_id: str
+    # Per-request CFM noise generator, seeded once from the request's seed at
+    # first prefill chunk (runner passes it as ``_omni_seed``). None means the
+    # request carried no seed and draws noise from the global RNG stream.
+    cfm_generator: torch.Generator | None = None
     curr_embed_for_next: torch.Tensor | None = None
     prev_feat_embed: torch.Tensor | None = None
     curr_prefix_feat_cond: torch.Tensor | None = None
@@ -352,20 +357,44 @@ class _PendingAudioCopy:
 # ===================================================================
 
 
+class _TimingEvent(Protocol):
+    def record(self) -> None: ...
+
+    def elapsed_time(self, end_event: _TimingEvent) -> float: ...
+
+
 class _PerfTimer:
-    __slots__ = ("_enabled", "_timers", "_counts", "_starts", "_pairs")
+    __slots__ = (
+        "_enabled",
+        "_device_module",
+        "_timers",
+        "_counts",
+        "_starts",
+        "_pairs",
+    )
 
     def __init__(self, enabled: bool = False):
         self._enabled = enabled
+        self._device_module = None
+        if enabled:
+            device_module = torch.get_device_module(current_omni_platform.get_torch_device())
+            if not hasattr(device_module, "Event"):
+                logger.warning_once(
+                    "VoxCPM2 profiler disabled: the current device does not provide accelerator timing events"
+                )
+                self._enabled = False
+            else:
+                self._device_module = device_module
         self._timers: dict[str, float] = {}
         self._counts: dict[str, int] = {}
-        self._starts: dict[str, torch.cuda.Event] = {}
-        self._pairs: list[tuple[str, torch.cuda.Event, torch.cuda.Event]] = []
+        self._starts: dict[str, _TimingEvent] = {}
+        self._pairs: list[tuple[str, _TimingEvent, _TimingEvent]] = []
 
     def start(self, name: str) -> None:
         if not self._enabled:
             return
-        evt = torch.cuda.Event(enable_timing=True)
+        assert self._device_module is not None
+        evt = self._device_module.Event(enable_timing=True)
         evt.record()
         self._starts[name] = evt
 
@@ -373,7 +402,8 @@ class _PerfTimer:
         if not self._enabled or name not in self._starts:
             return
         start_evt = self._starts.pop(name)
-        end_evt = torch.cuda.Event(enable_timing=True)
+        assert self._device_module is not None
+        end_evt = self._device_module.Event(enable_timing=True)
         end_evt.record()
         self._pairs.append((name, start_evt, end_evt))
 
@@ -382,7 +412,18 @@ class _PerfTimer:
             return
         torch.accelerator.synchronize()
         for name, s, e in self._pairs:
-            self._timers[name] = self._timers.get(name, 0.0) + s.elapsed_time(e)
+            try:
+                elapsed_ms = s.elapsed_time(e)
+            except RuntimeError as error:
+                # An event recorded during accelerator graph capture may not
+                # own a runtime recorder. Profiling must not fail inference.
+                logger.warning_once(
+                    "VoxCPM2 profiler discarded invalid event pair %r: %s",
+                    name,
+                    error,
+                )
+                continue
+            self._timers[name] = self._timers.get(name, 0.0) + elapsed_ms
             self._counts[name] = self._counts.get(name, 0) + 1
         self._pairs.clear()
 
@@ -1198,14 +1239,11 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         self._feat_encoder_for_unified_capture = compiled
         return compiled
 
-    def _setup_torch_compile(self) -> None:
-        if not self._enable_torch_compile:
+    def _setup_execution_optimizations(self) -> None:
+        if getattr(self, "_eager_optimizations_applied", False):
             return
         tts = self.tts
         estimator = tts.feat_decoder.estimator
-        if hasattr(estimator, "_compiled"):
-            return
-
         targets: list[str] = []
         cfg = self._runtime_config
 
@@ -1225,6 +1263,24 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
             if _install_locdit_zero_dt_cache(estimator):
                 targets.append("LocDiT zero-dt embedding cache")
 
+        # The rewrites above are regular eager PyTorch operations. Ascend does
+        # not support TorchInductor, but still benefits from fused projections
+        # and the cached delta-time embedding.
+        self._eager_optimizations_applied = True
+        if targets:
+            logger.info("VoxCPM2: eager optimizations applied to: %s", ", ".join(targets))
+        if self._enable_torch_compile:
+            self._setup_torch_compile()
+
+    def _setup_torch_compile(self) -> None:
+        tts = self.tts
+        estimator = tts.feat_decoder.estimator
+        if hasattr(estimator, "_compiled"):
+            return
+
+        targets: list[str] = []
+        cfg = self._runtime_config
+
         external_cfm_capture = self._enable_cfm_cuda_graph or self._enable_unified_decode_graph
         if cfg.enable_loc_dit_layer_nvtx:
             patched = _install_locdit_layer_nvtx(estimator)
@@ -1655,8 +1711,8 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         with _NvtxRange("voxcpm2.cfm.graph_copy_cond"):
             graph.cond.copy_(cond)
         with _NvtxRange("voxcpm2.cfm.graph_noise"):
-            if self._deterministic_cfm_noise:
-                self._fill_deterministic_cfm_noise(state, graph.noise)
+            if self._has_deterministic_cfm_noise(state):
+                self._fill_deterministic_cfm_noise_for_state(state, graph.noise)
             else:
                 graph.noise.normal_()
         with _NvtxRange("voxcpm2.cfm.graph_replay"):
@@ -1684,8 +1740,7 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         dtype = self._side_dtype
 
         self._setup_cfm_buffers()
-        if self._enable_torch_compile:
-            self._setup_torch_compile()
+        self._setup_execution_optimizations()
         self.model.precompute_fused_qkv()
         self.residual_model.precompute_fused_qkv()
 
@@ -1878,6 +1933,11 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                 g.prefix_feat_cond[last : last + 1].expand(graph_size - num_reqs, -1, -1)
             )
         g.cfm_noise.normal_()
+        # Seeded rows overwrite their slice from their own generator, so the
+        # noise a seeded request sees does not depend on batch composition.
+        for i, state in enumerate(states[:num_reqs]):
+            if state.cfm_generator is not None:
+                g.cfm_noise[i : i + 1].normal_(generator=state.cfm_generator)
         self._perf.stop("unified.copy_inputs")
 
         self._perf.start("unified.replay")
@@ -2320,14 +2380,14 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         with _NvtxRange("voxcpm2.cfm"):
             if self._cfm_buffers is not None:
                 if self._enable_cfm_cuda_graph and dit_h.device.type == current_omni_platform.device_type:
-                    if self._deterministic_cfm_noise and not self._enable_cfm_prealloc_output:
+                    if self._has_deterministic_cfm_noise(state) and not self._enable_cfm_prealloc_output:
                         graph = self._get_cfm_cuda_graph(dit_h, cond)
                         with _NvtxRange("voxcpm2.cfm.graph_copy_mu"):
                             graph.mu.copy_(dit_h)
                         with _NvtxRange("voxcpm2.cfm.graph_copy_cond"):
                             graph.cond.copy_(cond)
                         with _NvtxRange("voxcpm2.cfm.graph_noise"):
-                            self._fill_deterministic_cfm_noise(state, graph.noise)
+                            self._fill_deterministic_cfm_noise_for_state(state, graph.noise)
                         with _NvtxRange("voxcpm2.cfm.graph_replay"):
                             graph.graph.replay()
                         with _NvtxRange("voxcpm2.cfm.graph_output_clone"):
@@ -2335,9 +2395,9 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                     if not self._enable_cfm_prealloc_output:
                         return self._run_cfm_cuda_graph(dit_h, cond).transpose(1, 2)
                     return self._run_cfm_cuda_graph_to_state_buffer(state, dit_h, cond)
-                if self._deterministic_cfm_noise:
+                if self._has_deterministic_cfm_noise(state):
                     noise = self._cfm_buffers.noise[: dit_h.shape[0]]
-                    self._fill_deterministic_cfm_noise(state, noise)
+                    self._fill_deterministic_cfm_noise_for_state(state, noise)
                     return _optimized_solve_euler_with_noise(
                         self.tts.feat_decoder,
                         dit_h,
@@ -2369,6 +2429,23 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                 cfg_value=self._cfg_value,
             ).transpose(1, 2)
 
+    def _has_deterministic_cfm_noise(self, state: _RequestState) -> bool:
+        """Whether this request's CFM noise is drawn deterministically."""
+        return state.cfm_generator is not None or self._deterministic_cfm_noise
+
+    def _fill_deterministic_cfm_noise_for_state(self, state: _RequestState, out: torch.Tensor) -> None:
+        """Deterministically fill ``out`` for a request with deterministic noise.
+
+        A request-level seed wins: the noise stream is a pure function of the
+        seed, so identical text + seed reproduces byte-identical audio
+        regardless of batch composition or request id. The replay-only
+        ``deterministic_cfm_noise`` hash applies otherwise.
+        """
+        if state.cfm_generator is not None:
+            out.normal_(generator=state.cfm_generator)
+        else:
+            self._fill_deterministic_cfm_noise(state, out)
+
     def _fill_deterministic_cfm_noise(self, state: _RequestState, out: torch.Tensor) -> None:
         """Fill CFM noise deterministically for benchmark replay only."""
         request_key = state.request_id.split("_", 1)[0]
@@ -2391,8 +2468,7 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         self._perf.start("prefill_tail_batch")
         tts = self.tts
         self._setup_cfm_buffers()
-        if self._enable_torch_compile:
-            self._setup_torch_compile()
+        self._setup_execution_optimizations()
 
         dit_hs: list[torch.Tensor] = []
         conds: list[torch.Tensor] = []
@@ -2413,10 +2489,14 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         batched_cond = torch.cat(conds, dim=0)
         b = batched_dit_h.shape[0]
 
-        if self._deterministic_cfm_noise and self._cfm_buffers is not None:
+        any_seeded = any(state.cfm_generator is not None for state, _, _ in batch)
+        if (self._deterministic_cfm_noise or any_seeded) and self._cfm_buffers is not None:
             noise = self._cfm_buffers.noise[:b]
             for i, (state, _, _) in enumerate(batch):
-                self._fill_deterministic_cfm_noise(state, noise[i : i + 1])
+                if self._has_deterministic_cfm_noise(state):
+                    self._fill_deterministic_cfm_noise_for_state(state, noise[i : i + 1])
+                else:
+                    noise[i : i + 1].normal_()
         else:
             noise = torch.randn(
                 b,
@@ -2477,8 +2557,7 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         self._perf.stop("prefill.dit_proj")
 
         self._setup_cfm_buffers()
-        if self._enable_torch_compile:
-            self._setup_torch_compile()
+        self._setup_execution_optimizations()
 
         pred_feat = self._run_cfm_for_state(state, dit_h, prefix_feat_cond.transpose(1, 2).contiguous())
 
@@ -2554,10 +2633,14 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
             with _NvtxRange("voxcpm2.dit_proj"):
                 dit_h = dit_proj(lm_h, batch_out)
             cond = pfc.transpose(1, 2).contiguous()
-            if self._deterministic_cfm_noise and self._cfm_buffers is not None:
+            any_seeded = any(state.cfm_generator is not None for state in states)
+            if (self._deterministic_cfm_noise or any_seeded) and self._cfm_buffers is not None:
                 noise = self._cfm_buffers.noise[: dit_h.size(0)]
                 for i, state in enumerate(states):
-                    self._fill_deterministic_cfm_noise(state, noise[i : i + 1])
+                    if self._has_deterministic_cfm_noise(state):
+                        self._fill_deterministic_cfm_noise_for_state(state, noise[i : i + 1])
+                    else:
+                        noise[i : i + 1].normal_()
                 pred_feat = _optimized_solve_euler_with_noise(
                     self.tts.feat_decoder,
                     dit_h,
@@ -3104,6 +3187,15 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                 state.precomputed_stop_logits = None
                 state.precomputed_is_stopping = None
                 state.last_audio_patch_gpu = None
+                # SamplingParams.seed reaches vLLM's own sampler but never the
+                # CFM noise draws below, so a seeded request threads its seed
+                # into a dedicated generator here (same pattern as gepard).
+                state.cfm_noise_step = 0
+                state.cfm_generator = None
+                seed = info_dict.get("_omni_seed")
+                if seed is not None:
+                    state.cfm_generator = torch.Generator(device=self._device)
+                    state.cfm_generator.manual_seed(int(seed))
                 if not hasattr(state, "pending_audio_chunks_gpu"):
                     state.pending_audio_chunks_gpu = []
                 if not hasattr(state, "pending_audio_copies"):
diff --git a/vllm_omni/model_executor/stage_input_processors/dynin_omni.py b/vllm_omni/model_executor/stage_input_processors/dynin_omni.py
deleted file mode 100644
index 5a5804de3..000000000
--- a/vllm_omni/model_executor/stage_input_processors/dynin_omni.py
+++ /dev/null
@@ -1,276 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any
-
-import torch
-from vllm.inputs import TextPrompt
-from vllm.logger import init_logger
-
-from vllm_omni.inputs.data import OmniTokensPrompt
-
-logger = init_logger(__name__)
-
-
-def _to_prompt_dict(prompt_item: OmniTokensPrompt | TextPrompt | str | None) -> dict[str, Any]:
-    if isinstance(prompt_item, dict):
-        return prompt_item
-    return {}
-
-
-def _to_token_id_list(value: Any) -> list[int]:
-    if isinstance(value, torch.Tensor):
-        value = value.detach().to("cpu")
-        if value.ndim == 0:
-            return [int(value.item())]
-        if value.ndim > 1:
-            value = value[0]
-        return [int(x) for x in value.tolist()]
-    if isinstance(value, list):
-        if not value:
-            return []
-        if isinstance(value[0], list):
-            return [int(x) for x in value[0]]
-        return [int(x) for x in value]
-    if value is None:
-        return []
-    return [int(value)]
-
-
-def _to_int(value: Any, default: int = 0) -> int:
-    if isinstance(value, torch.Tensor):
-        if value.numel() == 0:
-            return default
-        return int(value.view(-1)[0].item())
-    if isinstance(value, list):
-        if not value:
-            return default
-        return int(value[0])
-    if value is None:
-        return default
-    return int(value)
-
-
-def _normalize_additional_info(value: Any) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        return {}
-    normalized: dict[str, Any] = {}
-    for key, val in value.items():
-        if isinstance(val, list):
-            normalized[key] = val
-        else:
-            normalized[key] = [val]
-    return normalized
-
-
-def _decode_runtime_bridge_info(value: Any) -> dict[str, Any]:
-    if isinstance(value, torch.Tensor):
-        tensor = value.detach().to("cpu").reshape(-1).to(torch.uint8)
-        raw = bytes(tensor.tolist())
-    elif isinstance(value, (bytes, bytearray)):
-        raw = bytes(value)
-    elif isinstance(value, list):
-        try:
-            raw = bytes(int(item) for item in value)
-        except Exception:
-            return {}
-    elif value is None:
-        return {}
-    else:
-        return value if isinstance(value, dict) else {}
-
-    if not raw:
-        return {}
-
-    try:
-        decoded = json.loads(raw.decode("utf-8"))
-    except Exception:
-        return {}
-    return decoded if isinstance(decoded, dict) else {}
-
-
-def _bridge_tokens(
-    source_outputs,
-    prompt: OmniTokensPrompt | TextPrompt = None,
-    requires_multimodal_data: bool = False,
-):
-    next_inputs = []
-    if not isinstance(prompt, list):
-        prompt = [prompt]
-
-    prompt_meta_by_reqid = {src_out.request_id: _to_prompt_dict(p) for src_out, p in zip(source_outputs, prompt)}
-
-    for source_output in source_outputs:
-        output = source_output.outputs[0]
-        mm_out = getattr(output, "multimodal_output", None) or {}
-
-        token_ids = _to_token_id_list(mm_out.get("token_ids"))
-        if not token_ids:
-            token_ids = _to_token_id_list(mm_out.get("text_tokens"))
-        if not token_ids:
-            token_ids = list(output.cumulative_token_ids or [])
-        if not token_ids:
-            raise RuntimeError(f"Stage output for request {source_output.request_id} has no token_ids")
-
-        detok_id = _to_int(mm_out.get("detok_id"), default=0)
-        src_prompt = prompt_meta_by_reqid.get(source_output.request_id, {})
-        src_additional_info = src_prompt.get("additional_information", {}) or {}
-        runtime_bridge_info = _decode_runtime_bridge_info(mm_out.get("runtime_info_json"))
-        if not runtime_bridge_info:
-            runtime_bridge_info = mm_out.get("runtime_info", {}) or {}
-
-        additional_information: dict[str, Any] = _normalize_additional_info(src_additional_info)
-        additional_information.update(_normalize_additional_info(runtime_bridge_info))
-        additional_information["detok_id"] = [detok_id]
-
-        next_inputs.append(
-            OmniTokensPrompt(
-                prompt_token_ids=token_ids,
-                additional_information=additional_information,
-                multi_modal_data=(src_prompt.get("multi_modal_data") if requires_multimodal_data else None),
-                mm_processor_kwargs=None,
-            )
-        )
-
-    return next_inputs
-
-
-def token2text_to_token2image(
-    source_outputs,
-    prompt: OmniTokensPrompt | TextPrompt = None,
-    requires_multimodal_data: bool = False,
-):
-    return _bridge_tokens(source_outputs, prompt, requires_multimodal_data)
-
-
-def token2image_to_token2audio(
-    source_outputs,
-    prompt: OmniTokensPrompt | TextPrompt = None,
-    requires_multimodal_data: bool = False,
-):
-    return _bridge_tokens(source_outputs, prompt, requires_multimodal_data)
-
-
-# ============================================================================
-# Worker-connector data plane (non-async-chunk path).
-# ============================================================================
-
-# Per-model REPLACE-keys for the full-payload accumulator.  dynin_omni's
-# producer model emits new chunks per step (token_ids / runtime_info_json),
-# all of which use the default CONCAT/replace semantics — no model_outputs
-# entry needs explicit REPLACE.
-_FULL_PAYLOAD_REPLACE_KEYS: frozenset[str] = frozenset()
-
-
-def _build_full_payload(pooling_output: dict[str, Any] | None, request: Any) -> dict[str, Any] | None:
-    """Producer-side payload builder: assemble dynin_omni connector payload.
-
-    Reads token_ids from ``pooling_output["token_ids"]`` (preferred) or
-    ``request.output_token_ids`` (fallback).  Reads structured non-tensor
-    metadata from ``pooling_output["runtime_info_json"]`` (JSON-in-uint8)
-    if present, falling back to ``pooling_output["runtime_info"]`` dict.
-    Carries forward ``request.additional_information`` so prompt-side
-    metadata (speaker / language / detok_id) survives the IPC boundary.
-    """
-    if not isinstance(pooling_output, dict):
-        pooling_output = {}
-
-    token_ids = _to_token_id_list(pooling_output.get("token_ids"))
-    if not token_ids:
-        token_ids = _to_token_id_list(pooling_output.get("text_tokens"))
-    if not token_ids and request is not None:
-        token_ids = _to_token_id_list(getattr(request, "output_token_ids", None))
-    if not token_ids:
-        logger.warning(
-            "dynin_omni._build_full_payload: no token_ids found in pooling_output "
-            "(keys=%s) or request.output_token_ids for req=%s; consumer wait gate may hang.",
-            list(pooling_output.keys()),
-            getattr(request, "request_id", "?"),
-        )
-        return None
-
-    src_additional_info = getattr(request, "additional_information", {}) if request is not None else {}
-    if not isinstance(src_additional_info, dict):
-        src_additional_info = {}
-
-    runtime_bridge_info = _decode_runtime_bridge_info(pooling_output.get("runtime_info_json"))
-    if not runtime_bridge_info:
-        runtime_bridge_info = pooling_output.get("runtime_info", {}) or {}
-
-    payload = _normalize_additional_info(src_additional_info)
-    payload.update(_normalize_additional_info(runtime_bridge_info))
-    payload["detok_id"] = [_to_int(pooling_output.get("detok_id"), default=_to_int(payload.get("detok_id"), default=0))]
-    # Use nested OmniPayload shape so the scheduling-metadata extractor in
-    # OmniConnectorModelRunnerMixin reads codes.audio and meta.finished
-    # (flat keys at the top level are silently dropped with a warning).
-    payload["codes"] = {"audio": token_ids}
-    payload["meta"] = {"finished": torch.tensor(True, dtype=torch.bool)}
-    return payload
-
-
-def token2text_to_token2image_full_payload(
-    transfer_manager: Any,
-    pooling_output: dict[str, Any],
-    request: Any,
-) -> dict[str, Any] | None:
-    """Producer-side payload builder for the Stage-0 → Stage-1 (text → image) transition."""
-    del transfer_manager
-    return _build_full_payload(pooling_output, request)
-
-
-def token2image_to_token2audio_full_payload(
-    transfer_manager: Any,
-    pooling_output: dict[str, Any],
-    request: Any,
-) -> dict[str, Any] | None:
-    """Producer-side payload builder for the Stage-1 → Stage-2 (image → audio) transition."""
-    del transfer_manager
-    return _build_full_payload(pooling_output, request)
-
-
-def _token_only_from_source(source_outputs: list[Any]) -> list[OmniTokensPrompt]:
-    """Length-only placeholder list mirroring ``_bridge_tokens`` token counts."""
-    inputs: list[OmniTokensPrompt] = []
-    for source_output in source_outputs:
-        output = source_output.outputs[0]
-        mm_out = getattr(output, "multimodal_output", None) or {}
-        token_ids = _to_token_id_list(mm_out.get("token_ids"))
-        if not token_ids:
-            token_ids = _to_token_id_list(mm_out.get("text_tokens"))
-        if not token_ids:
-            token_ids = list(getattr(output, "token_ids", []) or [])
-        if not token_ids:
-            token_ids = [0]
-        inputs.append(
-            OmniTokensPrompt(
-                prompt_token_ids=[0] * len(token_ids),
-                additional_information=None,
-                multi_modal_data=None,
-                mm_processor_kwargs=None,
-            )
-        )
-    return inputs
-
-
-def token2text_to_token2image_token_only(
-    stage_list,
-    engine_input_source,
-    prompt: OmniTokensPrompt | TextPrompt = None,
-    requires_multimodal_data: bool = False,
-) -> list[OmniTokensPrompt]:
-    """Sync-side placeholder for Stage-1 input (token2image)."""
-    source_stage_id = engine_input_source[0] if engine_input_source else 0
-    source_outputs = stage_list[source_stage_id].engine_outputs
-    return _token_only_from_source(source_outputs)
-
-
-def token2image_to_token2audio_token_only(
-    stage_list,
-    engine_input_source,
-    prompt: OmniTokensPrompt | TextPrompt = None,
-    requires_multimodal_data: bool = False,
-) -> list[OmniTokensPrompt]:
-    """Sync-side placeholder for Stage-2 input (token2audio)."""
-    source_stage_id = engine_input_source[0] if engine_input_source else 0
-    source_outputs = stage_list[source_stage_id].engine_outputs
-    return _token_only_from_source(source_outputs)
diff --git a/vllm_omni/model_executor/stage_input_processors/mammoth_moda2.py b/vllm_omni/model_executor/stage_input_processors/mammoth_moda2.py
index fab22b739..5972dfa02 100644
--- a/vllm_omni/model_executor/stage_input_processors/mammoth_moda2.py
+++ b/vllm_omni/model_executor/stage_input_processors/mammoth_moda2.py
@@ -1,21 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Stage input processor for MammothModa2 (AR -> DiT)."""
+"""Stage input processor for MammothModa2 (AR -> diffusion)."""
 
 from collections.abc import Mapping
 from typing import Any
 
-from vllm.inputs import TextPrompt
-
-from vllm_omni.inputs.data import OmniTokensPrompt
-
 
 def _as_dict(prompt: Any) -> dict[str, Any]:
-    """Coerce an original-stage prompt to a dict.
-
-    It may arrive as a dict, a NamedTuple/object, or a bare string depending on
-    the calling flow (the shared text_to_image example vs the bespoke script).
-    """
     if isinstance(prompt, dict):
         return prompt
     if hasattr(prompt, "_asdict"):
@@ -27,93 +18,73 @@ def _as_dict(prompt: Any) -> dict[str, Any]:
 
 def _coerce_dim(value: Any, default: int) -> int:
     try:
-        iv = int(value)
+        resolved = int(value)
     except (TypeError, ValueError):
         return default
-    return iv if iv > 0 else default
+    return resolved if resolved > 0 else default
 
 
-def ar2dit(
+def ar2diffusion(
     source_outputs: list[Any],
-    prompts: OmniTokensPrompt | TextPrompt | list[OmniTokensPrompt | TextPrompt] | None = None,
-    _requires_multimodal_data: bool = False,
-) -> list[OmniTokensPrompt]:
-    """Convert AR stage outputs to DiT stage inputs."""
-    ar_outputs = source_outputs
-
-    # The shared text_to_image example forwards a single prompt (not a list); normalize
-    # so a lone dict isn't iterated as its keys. Mirrors glm_image.ar2diffusion.
-    if not isinstance(prompts, list):
-        prompts = [prompts] if prompts is not None else [{}]
-
-    dit_inputs: list[OmniTokensPrompt] = []
-    for i, ar_output in enumerate(ar_outputs):
-        prompt_dict = _as_dict(prompts[i] if i < len(prompts) else {})
-        addi_info = prompt_dict.get("additional_information") or {}
-        mm_kwargs = prompt_dict.get("mm_processor_kwargs") or {}
-
-        # Image size: prefer mm_processor_kwargs target_h/target_w (set by the serving
-        # layer), fall back to additional_information, then a 1024 default.
-        image_height = _coerce_dim(
-            mm_kwargs.get("target_h"),
-            _coerce_dim((addi_info.get("image_height") or [None])[0], 1024),
-        )
-        image_width = _coerce_dim(
-            mm_kwargs.get("target_w"),
-            _coerce_dim((addi_info.get("image_width") or [None])[0], 1024),
+    prompt: Any | None = None,
+    requires_multimodal_data: bool = False,
+) -> dict[str, Any]:
+    del requires_multimodal_data
+    if len(source_outputs) != 1:
+        raise ValueError(
+            f"MammothModa2 request-mode diffusion expects exactly one AR output, got {len(source_outputs)}"
         )
 
-        # Sampling knobs arrive on the DiT stage via extra_body -> extra_args; these are
-        # defensive fallbacks (defaults mirror the former bespoke script's argparse).
-        text_guidance_scale = (addi_info.get("text_guidance_scale") or [9.0])[0]
-        cfg_range = addi_info.get("cfg_range") or [0.0, 1.0]
-        num_inference_steps = (addi_info.get("num_inference_steps") or [50])[0]
+    ar_output = source_outputs[0]
+    if isinstance(prompt, list):
+        prompt = prompt[0] if prompt else {}
+    prompt_dict = _as_dict(prompt)
+    additional = prompt_dict.get("additional_information") or {}
+    mm_kwargs = prompt_dict.get("mm_processor_kwargs") or {}
+    height = _coerce_dim(
+        mm_kwargs.get("target_h"),
+        _coerce_dim((additional.get("image_height") or [None])[0], 1024),
+    )
+    width = _coerce_dim(
+        mm_kwargs.get("target_w"),
+        _coerce_dim((additional.get("image_width") or [None])[0], 1024),
+    )
 
-        prompt_token_ids = ar_output.prompt_token_ids
-        # exclude the last token because it has no corresponding hidden state
-        completion_output = ar_output.outputs[0]
-        gen_token_ids = completion_output.cumulative_token_ids[:-1]
-        full_token_ids = prompt_token_ids + gen_token_ids
-
-        mm_output = getattr(completion_output, "multimodal_output", None)
-        if not isinstance(mm_output, Mapping) or "latent" not in mm_output:
-            raise ValueError(
-                "AR stage output missing latent multimodal output. "
-                f"request_id={getattr(ar_output, 'request_id', None)}, "
-                f"completion_has_mm={hasattr(completion_output, 'multimodal_output')}"
-            )
-        full_hidden_states = mm_output["latent"]
-        hidden_total = int(full_hidden_states.shape[0])
-        assert hidden_total == len(prompt_token_ids) + len(gen_token_ids), (
-            f"Hidden states length mismatch: expected {len(prompt_token_ids) + len(gen_token_ids)}, got {hidden_total}"
+    completion = ar_output.outputs[0]
+    generated_token_ids = list(completion.cumulative_token_ids[:-1])
+    prompt_token_ids = list(ar_output.prompt_token_ids)
+    full_token_ids = prompt_token_ids + generated_token_ids
+    multimodal_output = getattr(completion, "multimodal_output", None)
+    if not isinstance(multimodal_output, Mapping) or "latent" not in multimodal_output:
+        raise ValueError(
+            "MammothModa2 AR stage output is missing latent multimodal output; "
+            f"request_id={getattr(ar_output, 'request_id', None)}"
         )
 
-        # The text/image condition split is performed in the DiT pipeline, which sources
-        # the distinguishing token ids (gen_vocab_start_index, vision placeholder ids)
-        # from the model config. Pass through the raw AR hidden states + token ids and
-        # the question/answer boundary so the pipeline can reconstruct the masks.
-        additional_information = {
-            # The EngineCore payload serializer preserves bfloat16 as raw bytes.
-            # Keep the AR representation compact across the CPU/IPC boundary;
-            # the DiT selects its conditioning rows and casts them only when it
-            # consumes them.
+    full_hidden_states = multimodal_output["latent"]
+    hidden_total = int(full_hidden_states.shape[0])
+    if hidden_total != len(full_token_ids):
+        raise ValueError(
+            "Hidden states length mismatch: "
+            f"expected {len(full_token_ids)}, got {hidden_total}; "
+            f"request_id={getattr(ar_output, 'request_id', None)}"
+        )
+
+    return {
+        "prompt": "",
+        "height": height,
+        "width": width,
+        "additional_information": {
+            # Keep #7102's compact BF16/FP16 payload across the EngineCore
+            # boundary. The diffusion pipeline casts only after selecting the
+            # text/image condition rows.
             "full_hidden_states": full_hidden_states.contiguous(),
             "full_token_ids": full_token_ids,
-            "answer_start_index": [len(prompt_token_ids)],
-            "image_height": [int(image_height)],
-            "image_width": [int(image_width)],
-            "text_guidance_scale": [float(text_guidance_scale)],
-            "cfg_range": [float(cfg_range[0]), float(cfg_range[1])],
-            "num_inference_steps": [int(num_inference_steps)],
-        }
-
-        dit_inputs.append(
-            OmniTokensPrompt(
-                prompt_token_ids=[0],
-                additional_information=additional_information,
-                multi_modal_data=None,
-                mm_processor_kwargs=None,
-            )
-        )
-
-    return dit_inputs
+            "answer_start_index": len(prompt_token_ids),
+            **{
+                key: additional[key]
+                for key in ("text_guidance_scale", "num_inference_steps", "cfg_range")
+                if key in additional
+            },
+        },
+    }
diff --git a/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py b/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
index 1c374be85..4d818b79f 100644
--- a/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+++ b/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
@@ -16,7 +16,10 @@ from vllm_omni.engine.duplex.intermediate import (
     set_tts_handoff,
 )
 from vllm_omni.inputs.data import OmniTokensPrompt
-from vllm_omni.model_executor.models.minicpmo_4_5 import MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK
+from vllm_omni.model_executor.models.minicpmo_4_5 import (
+    MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK,
+    MINICPMO45_DUPLEX_TURN_END_CODEC_TOKENS,
+)
 from vllm_omni.model_executor.models.minicpmo_4_5.pipeline import MINICPMO45_REFERENCE_AUDIO_KEY
 
 logger = logging.getLogger(__name__)
@@ -1010,7 +1013,11 @@ def llm2tts(
             handoff_meta = model_intermediate_buffer.setdefault("meta", {})
             handoff_meta["next_stage_prompt_len"] = condition_length
             if is_native_duplex_handoff:
-                handoff_meta["next_stage_generation_tokens"] = MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK
+                handoff_meta["next_stage_generation_tokens"] = (
+                    MINICPMO45_DUPLEX_TURN_END_CODEC_TOKENS
+                    if native_turn_end_handoff
+                    else MINICPMO45_DUPLEX_CODEC_TOKENS_PER_CHUNK
+                )
                 bridge_states = getattr(_streaming_context, "bridge_states", None)
                 handoff_state = bridge_states.get("minicpmo45_tts_handoff") if isinstance(bridge_states, dict) else None
                 if not isinstance(handoff_state, dict) or handoff_state.get("request_id") != str(llm_output.request_id):
diff --git a/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py b/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
index 431569626..79a6e782a 100644
--- a/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+++ b/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
@@ -70,7 +70,7 @@ def _extract_last_frame(multimodal_output: OmniPayload | dict[str, Any]) -> torc
         return None
     if audio_codes.ndim == 2:
         frame = audio_codes[-1]
-        if frame.numel() == 0 or not bool(frame.any().item()):
+        if frame.numel() == 0:
             return None
         return frame.to(torch.long).reshape(-1)
     if audio_codes.ndim == 1:
@@ -78,6 +78,31 @@ def _extract_last_frame(multimodal_output: OmniPayload | dict[str, Any]) -> torc
     raise ValueError(f"Invalid audio_codes shape for Qwen3-TTS async_chunk: {tuple(audio_codes.shape)}")
 
 
+def _should_append_async_frame(
+    multimodal_output: OmniPayload | dict[str, Any],
+    frame: torch.Tensor,
+) -> bool:
+    meta = multimodal_output.get("meta", {})
+    frame_valid = meta.get("codec_frame_valid") if isinstance(meta, Mapping) else None
+    if isinstance(frame_valid, torch.Tensor):
+        if frame_valid.numel() == 0:
+            raise ValueError("codec_frame_valid must not be empty")
+        # A single request can carry a multi-token prefill span. The model
+        # emits one validity entry per codec row, while _extract_last_frame()
+        # selects the final row from that span.
+        return bool(frame_valid.reshape(-1)[-1].item())
+    if frame_valid is not None:
+        return bool(frame_valid)
+    # Compatibility for payload producers predating the explicit validity
+    # contract. Real Qwen3-TTS outputs carry codec_frame_valid and avoid this
+    # value-dependent synchronization.
+    return bool(frame.any().item())
+
+
+def _append_tensor_frame(transfer_manager: Any, request_id: str, frame: torch.Tensor) -> None:
+    transfer_manager.code_prompt_token_ids[request_id].append(frame.detach().to(torch.long).reshape(-1).contiguous())
+
+
 def talker2code2wav_async_chunk(
     transfer_manager: Any,
     multimodal_output: OmniPayload | dict[str, Any] | None,
@@ -93,12 +118,11 @@ def talker2code2wav_async_chunk(
 
     if isinstance(multimodal_output, Mapping):
         frame = _extract_last_frame(multimodal_output)
-        if frame is not None:
-            codec_codes = frame.cpu().tolist()
-            transfer_manager.code_prompt_token_ids[request_id].append(codec_codes)
+        if frame is not None and _should_append_async_frame(multimodal_output, frame):
+            _append_tensor_frame(transfer_manager, request_id, frame)
         ref_code = multimodal_output.get("codes", {}).get("ref")
         if isinstance(ref_code, torch.Tensor) and ref_code.numel() > 0 and request_payload.get(request_id) is None:
-            request_payload[request_id] = ref_code.to(torch.long).cpu().contiguous()
+            request_payload[request_id] = ref_code.detach().to(torch.long).contiguous()
     elif not finished:
         return None
 
@@ -183,6 +207,17 @@ def talker2code2wav_async_chunk(
         )
         initial_chunk_size = chunk_size
     length = len(transfer_manager.code_prompt_token_ids[request_id])
+    emitted_frames = getattr(transfer_manager, "_qwen3_tts_emitted_frames", None)
+    if emitted_frames is None:
+        emitted_frames = {}
+        transfer_manager._qwen3_tts_emitted_frames = emitted_frames
+    if request_id in emitted_frames and length <= emitted_frames[request_id]:
+        if finished:
+            return OmniPayloadStruct(
+                codes=CodesStruct(audio=torch.empty(0, dtype=torch.long)),
+                meta=MetaStruct(request_id=request_id, left_context_size=0, finished=torch.tensor(True)),
+            )
+        return None
 
     # Full-utterance Code2Wav is gated by ``full_utterance_decode`` (explicit
     # opt-in via additional_information). Do not reuse ``non_streaming_mode``:
@@ -305,6 +340,8 @@ def talker2code2wav_async_chunk(
 
     if finished and first_chunk:
         context_length = length
+    if request_id in emitted_frames:
+        context_length = min(context_length, length - emitted_frames[request_id])
 
     if adaptive_enabled:
         ctrl = transfer_manager._adaptive_states.get(request_id)
@@ -343,7 +380,7 @@ def talker2code2wav_async_chunk(
     if isinstance(ref_code, torch.Tensor) and ref_code.numel() > 0:
         ref_context = ref_code
         if ref_code_context_frames > 0 and int(ref_context.shape[0]) > ref_code_context_frames:
-            logger.info_once(
+            logger.debug(
                 "Qwen3-TTS async chunk uses the last %d/%d ref_code frames as bounded Code2Wav context.",
                 ref_code_context_frames,
                 int(ref_context.shape[0]),
@@ -375,6 +412,7 @@ def talker2code2wav_async_chunk(
         meta.ref_context_request_id = ref_context_request_id
         meta.ref_context_included = ref_context_included
 
+    emitted_frames[request_id] = length
     return OmniPayloadStruct(
         codes=CodesStruct(audio=code_predictor_codes),
         meta=meta,
@@ -383,6 +421,91 @@ def talker2code2wav_async_chunk(
     )
 
 
+def _copy_async_chunk_tensors_to_cpu(
+    tensors: list[torch.Tensor],
+) -> list[torch.Tensor]:
+    """Materialize one producer cohort with at most one D2H per device."""
+    if not tensors:
+        return []
+
+    outputs: list[torch.Tensor | None] = [None] * len(tensors)
+    by_device: dict[torch.device, list[tuple[int, torch.Tensor]]] = {}
+    for index, tensor in enumerate(tensors):
+        value = tensor.detach().to(dtype=torch.long).reshape(-1).contiguous()
+        if value.device.type == "cpu":
+            outputs[index] = value
+        else:
+            by_device.setdefault(value.device, []).append((index, value))
+
+    for entries in by_device.values():
+        lengths = [int(value.numel()) for _, value in entries]
+        combined = torch.cat([value for _, value in entries], dim=0).to(device="cpu")
+        offset = 0
+        for (index, source), length in zip(entries, lengths):
+            outputs[index] = combined[offset : offset + length].reshape(source.shape).contiguous()
+            offset += length
+
+    return [value for value in outputs if value is not None]
+
+
+def talker2code2wav_async_chunk_batch(
+    transfer_manager: Any,
+    pooling_outputs: list[OmniPayload | dict[str, Any] | None],
+    requests: list[Any],
+    is_finished: list[bool],
+) -> list[OmniPayloadStruct | None]:
+    """Build one Talker model-step worth of Code2Wav payloads.
+
+    MRv2 invokes this hook from its ordered native output worker. Codec frames
+    and first-chunk reference codes from the same model step are copied as a
+    cohort, while chunk boundaries and request metadata remain delegated to the
+    scalar builder below.
+    """
+    if not (len(pooling_outputs) == len(requests) == len(is_finished)):
+        raise ValueError("batch codec inputs must have identical lengths")
+
+    request_payload = getattr(transfer_manager, "request_payload", None)
+    if request_payload is None:
+        request_payload = {}
+        transfer_manager.request_payload = request_payload
+
+    selected: list[torch.Tensor] = []
+    destinations: list[tuple[str, str, tuple[int, ...]]] = []
+    for pooling_output, request in zip(pooling_outputs, requests):
+        if not isinstance(pooling_output, Mapping):
+            continue
+        request_id = request.external_req_id
+        frame = _extract_last_frame(pooling_output)
+        if frame is not None and _should_append_async_frame(pooling_output, frame):
+            selected.append(frame)
+            destinations.append(("frame", request_id, tuple(frame.shape)))
+
+        ref_code = pooling_output.get("codes", {}).get("ref")
+        if isinstance(ref_code, torch.Tensor) and ref_code.numel() > 0 and request_payload.get(request_id) is None:
+            selected.append(ref_code)
+            destinations.append(("ref", request_id, tuple(ref_code.shape)))
+
+    copied = _copy_async_chunk_tensors_to_cpu(selected)
+    for value, (kind, request_id, shape) in zip(copied, destinations):
+        value = value.reshape(shape)
+        if kind == "frame":
+            _append_tensor_frame(transfer_manager, request_id, value)
+        else:
+            request_payload[request_id] = value.contiguous()
+
+    payloads: list[OmniPayloadStruct | None] = []
+    for request, finished in zip(requests, is_finished):
+        payloads.append(
+            talker2code2wav_async_chunk(
+                transfer_manager=transfer_manager,
+                multimodal_output={},
+                request=request,
+                is_finished=finished,
+            )
+        )
+    return payloads
+
+
 # ============================================================================
 # Worker-connector data plane (non-async-chunk path).
 # AR runner's `flatten_payload` converts the model emit
diff --git a/vllm_omni/outputs/__init__.py b/vllm_omni/outputs/__init__.py
index e74931a20..ff0a21d45 100644
--- a/vllm_omni/outputs/__init__.py
+++ b/vllm_omni/outputs/__init__.py
@@ -60,6 +60,10 @@ class OmniModelRunnerOutput(ModelRunnerOutput):
     # The Scheduler can safely free the block tables for these requests.
     kv_extracted_req_ids: list[str] | None = None
     omni_connector_output: OmniConnectorOutput | None = None
+    # True when sampled_token_ids has already been materialized on the host.
+    # MRv2 consumers must treat the value as immutable and must not perform
+    # another device-to-host conversion or rebuild it from sampler tensors.
+    sampled_token_ids_materialized: bool = False
 
     @classmethod
     def with_kv_conn_output_only(cls, kv_connector_output: Any) -> "OmniModelRunnerOutput":
diff --git a/vllm_omni/outputs/output_processor.py b/vllm_omni/outputs/output_processor.py
index 5d2ede43d..cac8d9990 100644
--- a/vllm_omni/outputs/output_processor.py
+++ b/vllm_omni/outputs/output_processor.py
@@ -684,11 +684,19 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
 
             # Accumulate multimodal tensors regardless of path.
             if isinstance(req_state, OmniRequestState):
+                mm_type = getattr(eco, "output_type", None) or default_mm_type
+
                 mm_output = getattr(eco, "multimodal_output", None)
                 if mm_output is not None:
-                    mm_type = getattr(eco, "output_type", None) or default_mm_type
                     req_state.add_multimodal_tensor(mm_output, mm_type)
 
+                # Omni AR stages carry model payloads alongside text tokens in
+                # pooling_output. Preserve the payload, then clear the field so
+                # upstream still runs the normal detokenization path.
+                if eco.pooling_output is not None and req_state.detokenizer is not None:
+                    req_state.add_multimodal_tensor(eco.pooling_output, mm_type)
+                    eco.pooling_output = None
+
             # Route: if no detokenizer and no pooling output, handle locally
             # to avoid upstream's assert on detokenizer.
             if req_state.detokenizer is None and eco.pooling_output is None:
@@ -697,20 +705,22 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
                 upstream_outputs.append(eco)
 
         # Handle multimodal-only outputs (generation stages) locally.
-        mm_request_outputs = self._process_mm_only_outputs(
+        mm_request_outputs, mm_reqs_to_abort = self._process_mm_only_outputs(
             mm_only_outputs,
             engine_core_timestamp=engine_core_timestamp,
             iteration_stats=iteration_stats,
         )
 
         # Delegate text/pooling outputs to upstream.
-        processed = super().process_outputs(
+        upstream_processed = super().process_outputs(
             upstream_outputs,
             engine_core_timestamp=engine_core_timestamp,
             iteration_stats=iteration_stats,
         )
-        processed.request_outputs.extend(mm_request_outputs)
-        return processed
+        return OutputProcessorOutput(
+            request_outputs=mm_request_outputs + upstream_processed.request_outputs,
+            reqs_to_abort=mm_reqs_to_abort + upstream_processed.reqs_to_abort,
+        )
 
     def _process_mm_only_outputs(
         self,
@@ -718,30 +728,32 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
         *,
         engine_core_timestamp: float | None = None,
         iteration_stats: IterationStats | None = None,
-    ) -> list[OmniRequestOutput | PoolingRequestOutput]:
+    ) -> tuple[list[OmniRequestOutput | PoolingRequestOutput], list[str]]:
         """Handle outputs from generation stages that have no detokenizer.
 
         These cannot go through upstream process_outputs because it asserts
         detokenizer is not None when pooling_output is None.
         """
         request_outputs: list[OmniRequestOutput | PoolingRequestOutput] = []
+        reqs_to_abort: list[str] = []
         for eco in engine_core_outputs:
             req_state = self.request_states.get(eco.request_id)
             if req_state is None or not isinstance(req_state, OmniRequestState):
                 continue
 
-            new_token_ids = eco.new_token_ids
-            finish_reason = eco.finish_reason
-            stop_reason = eco.stop_reason
-            kv_transfer_params = eco.kv_transfer_params
-            ec_transfer_params = getattr(eco, "ec_transfer_params", None)
-            routed_experts = eco.routed_experts
             self._update_stats_from_output(
                 req_state,
                 eco,
                 engine_core_timestamp,
                 iteration_stats,
             )
+
+            new_token_ids = eco.new_token_ids
+            finish_reason = eco.finish_reason
+            stop_reason = eco.stop_reason
+            kv_transfer_params = eco.kv_transfer_params
+            ec_transfer_params = eco.ec_transfer_params
+            routed_experts = eco.routed_experts
             prefill_stats = getattr(eco, "prefill_stats", None)
             if prefill_stats is not None:
                 req_state.num_cached_tokens = prefill_stats.num_cached_tokens
@@ -770,12 +782,17 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             is_segment_finished = bool(getattr(eco, "is_segment_finished", False))
             if finish_reason is not None and not is_segment_finished and not is_non_final_audio_chunk:
                 self._finish_request(req_state)
+                if not getattr(eco, "finished", True):
+                    reqs_to_abort.append(eco.request_id)
                 self._update_stats_from_finished(
                     req_state,
                     finish_reason,
                     iteration_stats,
                 )
-        return request_outputs
+                if self.tracing_enabled:
+                    self.do_tracing(eco, req_state, iteration_stats)
+
+        return request_outputs, reqs_to_abort
 
     def _update_stats_from_output(
         self,
@@ -804,6 +821,10 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             None,
         )
 
+        reported_count = getattr(engine_core_output, "num_generation_tokens", None)
+        if isinstance(reported_count, int) and not isinstance(reported_count, bool) and reported_count >= 0:
+            self._native_text_metric_record(req_state.external_req_id)["num_generation_tokens"] = reported_count
+
         if iteration_stats is None or engine_core_timestamp is None or native_stats is None:
             return
 
@@ -816,7 +837,11 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             req_state.lora_name,
         )
         record = self._native_text_metric_record(req_state.external_req_id)
-        record["num_generation_tokens"] = int(native_stats.num_generation_tokens)
+        record["num_generation_tokens"] = (
+            reported_count
+            if isinstance(reported_count, int) and not isinstance(reported_count, bool) and reported_count >= 0
+            else int(native_stats.num_generation_tokens)
+        )
         if was_prefilling:
             record["vllm_ttft_ms"] = max(float(native_stats.first_token_latency) * 1000.0, 0.0)
             return
diff --git a/vllm_omni/platforms/npu/models/moss_tts_streaming_decode_wrapper.py b/vllm_omni/platforms/npu/models/moss_tts_streaming_decode_wrapper.py
new file mode 100644
index 000000000..5928de4bb
--- /dev/null
+++ b/vllm_omni/platforms/npu/models/moss_tts_streaming_decode_wrapper.py
@@ -0,0 +1,220 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""MOSS-TTS codec streaming NPUGraph acceleration on Ascend.
+
+Mirrors :class:`CUDAGraphStreamingDecoderWrapper` but uses
+:class:`NPUExactGraphRunner` for capture/replay.  Graph capture is gated
+by ``enforce_eager: false`` → ``cudagraph_capture_sizes`` → batch sizes;
+set ``enforce_eager: true`` on Stage 1 to disable.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+
+import torch
+import torch.nn as nn
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+
+from vllm_omni.platforms.npu.graph_tools import NPUExactGraphRunner
+
+logger = init_logger(__name__)
+
+
+def _prepare_moss_codec_graph_runtime() -> None:
+    """Select graph-capturable ACLNN kernels before MOSS-TTS codec capture.
+
+    Mirrors ``prepare_code2wav_graph_runtime`` from minicpmo_4_5_code2wav:
+    ``allow_internal_format=False`` + ``jit_compile=False`` are required for
+    NPUGraph capture of the codec's conv/attention kernels, but must only be
+    set when graph capture is actually enabled.
+    """
+    if os.environ.get("ASCEND_LAUNCH_BLOCKING") == "1":
+        raise RuntimeError(
+            "MOSS-TTS codec NPUGraph capture is incompatible with "
+            "ASCEND_LAUNCH_BLOCKING=1; unset it or set it to 0 before startup."
+        )
+    npu = torch.npu
+    npu.config.allow_internal_format = False
+    npu.set_compile_mode(jit_compile=False)
+    logger.info("Configured MOSS-TTS codec NPUGraph runtime (allow_internal_format=False, jit_compile=False)")
+
+
+class NPUGraphStreamingDecoderWrapper:
+    """Replay streaming decode graphs keyed by ``(B_bucket, exact_T)`` on NPU.
+
+    Delegates capture/replay to :class:`NPUExactGraphRunner`.  Bucket selection
+    (batch + frame padding) mirrors the CUDA wrapper so
+    ``_MossCodecStreamSession.step`` can use either interchangeably.  Codec
+    state is updated in-place during replay via ``state_slot_ids``; scratch
+    slots isolate padding rows.
+
+    Fatal NPUGraph failures propagate as ``RuntimeError`` (eager fallback is
+    unsafe after corrupt capture state); restart with ``enforce_eager: true``
+    on Stage 1 to recover.
+    """
+
+    def __init__(
+        self,
+        codec: nn.Module,
+        *,
+        state_capacity: int,
+        batch_sizes: list[int],
+        frame_sizes: list[int],
+        num_quantizers: int,
+        vllm_config: VllmConfig,
+    ) -> None:
+        self.codec = codec
+        self.state_capacity = int(state_capacity)
+        self.batch_sizes = sorted({int(size) for size in batch_sizes if 0 < int(size) <= state_capacity})
+        self.frame_sizes = sorted({int(size) for size in frame_sizes if int(size) > 0})
+        self.num_quantizers = int(num_quantizers)
+
+        # vllm_config is accepted for interface parity but unused; graph
+        # capture is gated by enforce_eager on Stage 1.
+        del vllm_config
+        _prepare_moss_codec_graph_runtime()
+        max_graphs = len(self.batch_sizes) * len(self.frame_sizes)
+        self._graph_runner: NPUExactGraphRunner | None = NPUExactGraphRunner(
+            max_graphs=max_graphs,
+            component_name="MOSS-TTS Codec",
+            disable_config_hint="set enforce_eager: true on Stage 1",
+        )
+        if not self._graph_runner.is_supported():
+            logger.warning("MOSS-TTS codec NPUGraph is not supported on this platform; falling back to eager.")
+            self._graph_runner = None
+
+    @property
+    def is_ready(self) -> bool:
+        return self._graph_runner is not None
+
+    @property
+    def scratch_capacity(self) -> int:
+        return max(self.batch_sizes, default=0)
+
+    @torch.no_grad()
+    def warmup(self, device: torch.device) -> None:
+        if self._graph_runner is None or not self.batch_sizes or not self.frame_sizes:
+            return
+        if device.type != "npu":
+            return
+
+        capture_keys = sorted(
+            ((b, t) for b in self.batch_sizes for t in self.frame_sizes),
+            reverse=True,
+        )
+        logger.info(
+            "MOSS-TTS streaming decoder NPUGraph warmup: n_vq=%d (B,T)=%s",
+            self.num_quantizers,
+            list(reversed(capture_keys)),
+        )
+        start_s = time.perf_counter()
+        for batch_size, frame_size in capture_keys:
+            self._warmup_bucket(batch_size, frame_size, device)
+            logger.info(
+                "  Captured MOSS-TTS streaming decoder NPUGraph for (B,T)=(%d,%d)",
+                batch_size,
+                frame_size,
+            )
+
+        stats = self._graph_runner.stats if self._graph_runner else {}
+        captured = stats.get("captures", 0)
+        logger.info(
+            "MOSS-TTS streaming decoder NPUGraph warmup complete: %d/%d captured in %.1f ms (stats=%s)",
+            captured,
+            len(capture_keys),
+            (time.perf_counter() - start_s) * 1000.0,
+            stats,
+        )
+
+    @torch.no_grad()
+    def _warmup_bucket(self, batch_size: int, frame_size: int, device: torch.device) -> None:
+        """Trigger first-run capture for one (B,T) bucket using scratch slots.
+
+        Feeds scratch slot ids + ``valid_rows=False`` so capture-side state
+        writes land in scratch slots, then resets them.
+        """
+        assert self._graph_runner is not None
+        codes = torch.zeros(
+            self.num_quantizers,
+            batch_size,
+            frame_size,
+            dtype=torch.long,
+            device=device,
+        )
+        lengths = torch.zeros(batch_size, dtype=torch.long, device=device)
+        scratch_slots = self.state_capacity + torch.arange(batch_size, dtype=torch.long, device=device)
+        valid_rows = torch.zeros(batch_size, dtype=torch.bool, device=device)
+
+        self._graph_runner.run(
+            "moss_codec_decode",
+            (codes, lengths, scratch_slots, valid_rows),
+            (batch_size, frame_size),
+            lambda c, lengths, s, v: self.codec.decode_streaming_tensors(c, lengths, s, v),
+        )
+        self.codec.reset_decoder_state_slots(scratch_slots)
+
+    def _select_batch_size(self, actual_batch_size: int) -> int | None:
+        return next((size for size in self.batch_sizes if size >= actual_batch_size), None)
+
+    def _select_frame_size(self, actual_frame_size: int, allow_padding: bool) -> int | None:
+        if actual_frame_size in self.frame_sizes:
+            return actual_frame_size
+        if not allow_padding:
+            return None
+        return next((size for size in self.frame_sizes if size >= actual_frame_size), None)
+
+    @torch.no_grad()
+    def decode(
+        self,
+        codes: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        *,
+        allow_frame_padding: bool = False,
+    ) -> tuple[torch.Tensor, torch.Tensor, int] | None:
+        if self._graph_runner is None:
+            return None
+        if codes.device.type != "npu":
+            return None
+
+        n_vq, actual_batch_size, frame_size = codes.shape
+        if int(n_vq) != self.num_quantizers or state_slot_ids.shape != (actual_batch_size,):
+            return None
+
+        batch_size = self._select_batch_size(int(actual_batch_size))
+        if batch_size is None:
+            return None
+        graph_frame_size = self._select_frame_size(int(frame_size), allow_frame_padding)
+        if graph_frame_size is None:
+            return None
+
+        device = codes.device
+        # Padding rows use scratch slots + valid_rows=False to isolate state.
+        padded_codes = torch.zeros(
+            self.num_quantizers,
+            batch_size,
+            graph_frame_size,
+            dtype=torch.long,
+            device=device,
+        )
+        padded_codes[:, :actual_batch_size, :frame_size].copy_(codes)
+        lengths = torch.zeros(batch_size, dtype=torch.long, device=device)
+        lengths[:actual_batch_size].fill_(int(frame_size))
+        padded_slots = self.state_capacity + torch.arange(batch_size, dtype=torch.long, device=device)
+        padded_slots[:actual_batch_size].copy_(state_slot_ids)
+        valid_rows = torch.zeros(batch_size, dtype=torch.bool, device=device)
+        valid_rows[:actual_batch_size].fill_(True)
+
+        audio, audio_lengths = self._graph_runner.run(
+            "moss_codec_decode",
+            (padded_codes, lengths, padded_slots, valid_rows),
+            (batch_size, graph_frame_size),
+            lambda c, lengths, s, v: self.codec.decode_streaming_tensors(c, lengths, s, v),
+        )
+
+        return audio, audio_lengths, int(actual_batch_size)
+
+
+__all__ = ["NPUGraphStreamingDecoderWrapper"]
diff --git a/vllm_omni/platforms/npu/quant/kv_quant_npu.py b/vllm_omni/platforms/npu/quant/kv_quant_npu.py
index cb76aab51..76d090a7a 100644
--- a/vllm_omni/platforms/npu/quant/kv_quant_npu.py
+++ b/vllm_omni/platforms/npu/quant/kv_quant_npu.py
@@ -1,127 +1,25 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""FP8 quantization utilities for diffusion attention tensors.
-
-Provides per-tensor dynamic quantization of Q/K/V tensors to
-float8_e4m3fn format. Designed for diffusion models where Q/K/V are
-computed fresh each forward pass (no persistent KV cache).
-"""
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Seeded rotation matrices for MindIE-SD quantized attention."""
 
 from __future__ import annotations
 
+import functools
 import math
-import threading
-from functools import lru_cache
 
 import torch
 
-# Hadamard rotation matrix for QuaRot-style preprocessing
-# keyed by (device, dtype, head_dim) to avoid matmul dtype mismatch.
-_ROT_MATRIXS: dict[tuple[torch.device, torch.dtype, int], torch.Tensor] = {}
-_ROT_MATRIX_LOCK = threading.Lock()
 
-_FP8_KV_LABELS = frozenset({"fp8"})
-
-
-def is_quantized_kv_cache(kv_cache_dtype: str | None) -> bool:
-    """True if config requests FP8-style KV / QKV quantization for the NPU FA path."""
-    return kv_cache_dtype in _FP8_KV_LABELS
-
-
-@lru_cache(maxsize=1)
-def _load_quant_ops():
-    try:
-        import torch_npu
-        from mindiesd.layers.quant.block_quant import fa_block_quant_preprocess
-        from msmodelslim.processor.quarot.common.quarot_utils import QuaRotMode, create_rot
-    except ImportError as e:
-        raise ImportError(
-            "fp8_rotate_quant_fa requires torch_npu, MindIE-SD (mindiesd), and MSModelSlim. "
-            "See https://gitcode.com/Ascend/MindIE-SD and https://gitcode.com/Ascend/msmodelslim"
-        ) from e
-    return torch_npu, fa_block_quant_preprocess, QuaRotMode, create_rot
-
-
-def _get_rot_matrix(
-    device: torch.device,
-    dtype: torch.dtype,
-    head_dim: int,
-    qua_rot_mode,
-    create_rot,
-) -> torch.Tensor:
-    key = (device, dtype, head_dim)
-    with _ROT_MATRIX_LOCK:
-        rot = _ROT_MATRIXS.get(key)
-        if rot is None:
-            rot = create_rot(qua_rot_mode.HADAMARD, head_dim, seed=425500).to(device=device, dtype=dtype)
-            _ROT_MATRIXS[key] = rot
-    return rot
-
-
-def fp8_rotate_quant_fa(
-    query: torch.Tensor,
-    key: torch.Tensor,
-    value: torch.Tensor,
-    *,
-    layout: str = "BNSD",
-    softmax_scale: float | None = None,
-) -> torch.Tensor:
-    """Run NPU fused attention with dynamic FP8 Q/K/V and optional QuaRot preprocess.
-
-    Args:
-        query: Query tensor in ``layout`` order (default BNSD: batch, heads, seq, dim).
-        key: Key tensor in ``layout`` order (default BNSD: batch, heads, seq, dim).
-        value: Value tensor in ``layout`` order (default BNSD: batch, heads, seq, dim).
-        layout: ``BNSD`` or ``BSND`` for ``npu_fused_infer_attention_score_v2``.
-        softmax_scale: If None, uses ``1 / sqrt(head_dim)``.
-
-    Returns:
-        Attention output in the same layout as inputs.
-    """
-    torch_npu, fa_block_quant_preprocess, qua_rot_mode, create_rot = _load_quant_ops()
-
-    out_dtype = query.dtype
-    device = query.device
-
-    if layout == "BNSD":
-        _, n, s, d = query.shape
-    elif layout == "BSND":
-        _, s, n, d = query.shape
-    else:
-        raise ValueError(f"fp8_rotate_quant_fa: unsupported layout {layout!r}, expected BNSD or BSND")
-
-    rot = _get_rot_matrix(device, query.dtype, d, qua_rot_mode, create_rot)
-    q_f = torch.matmul(query, rot)
-    k_f = torch.matmul(key, rot)
-
-    q, q_scale = fa_block_quant_preprocess(q_f, block_size=128, dst_type=torch_npu.float8_e4m3fn, layout=layout)
-    k, k_scale = fa_block_quant_preprocess(k_f, block_size=256, dst_type=torch_npu.float8_e4m3fn, layout=layout)
-    v, v_scale = fa_block_quant_preprocess(value, block_size=256, dst_type=torch_npu.float8_e4m3fn, layout=layout)
-
-    scale = softmax_scale if softmax_scale is not None else 1.0 / math.sqrt(d)
-
-    out = torch_npu.npu_fused_infer_attention_score_v2(
-        q,
-        k,
-        v,
-        input_layout=layout,
-        num_query_heads=n,
-        softmax_scale=scale,
-        pre_tokens=2147483647,  # INT32_MAX: no left-context truncation.
-        next_tokens=2147483647,  # INT32_MAX: no right-context truncation.
-        query_quant_mode=7,  # NPU mode id for block FP8 dequant path.
-        key_quant_mode=7,  # Same quant mode as query branch.
-        value_quant_mode=7,  # Same quant mode as key/query branches.
-        dequant_scale_query=q_scale,
-        dequant_scale_key=k_scale,
-        dequant_scale_value=v_scale,
-        out_dtype=out_dtype,
-    )[0]
-
-    if out.shape[2] != s:
-        if layout == "BNSD":
-            out = out[:, :, :s, :]
-        elif layout == "BSND":
-            out = out[:, :s, :, :]
-
-    return out
+@functools.lru_cache(maxsize=128)
+def get_quant_attention_rotation(device: torch.device, dtype: torch.dtype, head_dim: int) -> torch.Tensor:
+    """Preserve Omni's fixed Walsh-Hadamard rotation without changing global RNG."""
+    if head_dim <= 0 or head_dim & (head_dim - 1):
+        raise ValueError("Generated attention rotations require a power-of-two head dimension.")
+    generator = torch.Generator(device="cpu").manual_seed(425500)
+    signs = torch.randint(0, 2, (head_dim,), generator=generator, dtype=torch.int64)
+    signs = signs.to(dtype=torch.float32).mul_(2).sub_(1)
+    hadamard = torch.ones(1, 1)
+    while hadamard.shape[0] < head_dim:
+        hadamard = torch.cat((torch.cat((hadamard, hadamard), dim=1), torch.cat((hadamard, -hadamard), dim=1)), dim=0)
+    rotation = signs[:, None] * hadamard / math.sqrt(head_dim)
+    return rotation.to(device=device, dtype=dtype).contiguous()
diff --git a/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py b/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py
index 7bc6c21c6..aa01b7a8e 100644
--- a/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py
@@ -54,7 +54,7 @@ from vllm_omni.worker.omni_connector_model_runner_mixin import (
     OmniConnectorModelRunnerMixin,
     needs_omni_connector,
 )
-from vllm_omni.worker.sampling_utils import sanitize_min_tokens_stop_ids
+from vllm_omni.worker.sampling_utils import call_model_sampler, sanitize_min_tokens_stop_ids
 
 
 def _ensure_tensor_values(payload: dict[str, object]) -> dict[str, torch.Tensor]:
@@ -107,6 +107,9 @@ class ExecuteModelState(NamedTuple):
     cudagraph_stats: CUDAGraphStat | None
     batch_desc: BatchDescriptor
     multimodal_outputs: Any # Omni-Specific
+    # Omni: prefix-cache step id; its context must be consumed exactly
+    # once (materialize or discard_step) in sample_tokens.
+    prefix_cache_step_id: int | None = None
 
 class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, DuplexSamplingRunnerMixin):
     """Autoregressive NPU model runner that returns hidden states per request."""
@@ -177,6 +180,7 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                         num_scheduled_tokens_np=np.ones(bsz, dtype=np.int32),
                         max_num_scheduled_tokens=1,
                         use_cascade_attn=False,
+                        force_uniform_decode=True,
                     )
                     n = batch_desc.num_tokens
                     ids = self.talker_mtp_input_ids.gpu[:n]
@@ -210,88 +214,6 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         finally:
             set_cudagraph_capturing_enabled(False)
 
-    def _model_needs_full_prefix_hidden_states(self) -> bool:
-        """See gpu_ar_model_runner._model_needs_full_prefix_hidden_states."""
-        model = getattr(self, "model", None)
-        return bool(getattr(model, "requires_full_prefix_cached_hidden_states", True))
-
-    def _deferred_prefix_cache_mm_keys(self) -> set[str]:
-        """Model-declared multimodal keys whose prefix-cache writes are deferred."""
-        model = getattr(self, "model", None)
-        keys = getattr(model, "deferred_prefix_cache_mm_keys", ())
-        return set(keys or ())
-
-    def _stage_deferred_prefix_cache_mm_outputs(
-        self,
-        *,
-        scheduler_output: SchedulerOutput,
-        multimodal_outputs: Any,
-        query_start_loc_cpu: Any,
-    ) -> None:
-        """See gpu_ar_model_runner._stage_deferred_prefix_cache_mm_outputs."""
-        if self.omni_prefix_cache is None:
-            return
-
-        deferred_mm_cache_keys = self._deferred_prefix_cache_mm_keys()
-        if not deferred_mm_cache_keys:
-            return
-
-        self.omni_prefix_cache.stage_deferred_mm_outputs(
-            query_start_loc=query_start_loc_cpu,
-            input_batch=self.input_batch,
-            multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
-            num_scheduled_tokens=scheduler_output.num_scheduled_tokens,
-            deferred_mm_cache_keys=deferred_mm_cache_keys,
-        )
-
-    def _maybe_update_prefix_cache(
-        self,
-        hidden_states: torch.Tensor,
-        multimodal_outputs: dict,
-        num_tokens_unpadded: int,
-        num_tokens_padded: int,
-    ):
-        if self.omni_prefix_cache is not None and get_pp_group().is_last_rank:
-            hs_for_cache = hidden_states if self._model_needs_full_prefix_hidden_states() else None
-            slot_mapping_gpu = self.input_batch.block_table[0].slot_mapping.gpu
-            slot_mapping_cpu = slot_mapping_gpu[:num_tokens_padded].cpu()
-            self.omni_prefix_cache.update_omni_tensor_prefix_cache(
-                hidden_states=hs_for_cache,
-                multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
-                num_tokens_unpadded=num_tokens_unpadded,
-                slot_mapping=slot_mapping_cpu,
-                num_tokens_padded=num_tokens_padded,
-                skip_mm_cache_keys=self._deferred_prefix_cache_mm_keys(),
-            )
-
-    def _maybe_get_combined_prefix_cache_tensors(
-        self,
-        hidden_states: torch.Tensor,
-        multimodal_outputs: dict,
-        num_scheduled_tokens: dict[str, int],
-    ) -> tuple[dict[str, torch.Tensor] | None, dict | None]:
-        combined_hidden_states, combined_multimodal_outputs = None, None
-        if self.omni_prefix_cache is not None:
-            if (
-                not self._model_needs_full_prefix_hidden_states()
-                and not self.omni_prefix_cache.has_prefix_cached_new_req_ids()
-            ):
-                return None, None
-            if self._model_needs_full_prefix_hidden_states():
-                combined_hidden_states = self.omni_prefix_cache.get_merged_hidden_states(
-                    query_start_loc=self.query_start_loc.cpu,
-                    input_batch=self.input_batch,
-                    hidden_states=hidden_states,
-                    num_scheduled_tokens=num_scheduled_tokens,
-                )
-            combined_multimodal_outputs = self.omni_prefix_cache.get_merged_multimodal_states(
-                query_start_loc=self.query_start_loc.cpu,
-                input_batch=self.input_batch,
-                multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
-                num_scheduled_tokens=num_scheduled_tokens,
-            )
-        return combined_hidden_states, combined_multimodal_outputs
-
     @staticmethod
     def _resolve_req_hidden_states(
         hidden_states_cpu: torch.Tensor,
@@ -451,11 +373,8 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                 if flush_ids:
                     self.flush_full_payload_outputs(flush_ids)
 
-        if self.omni_prefix_cache is not None and scheduler_output.finished_req_ids:
-            self.omni_prefix_cache.commit_deferred_mm_outputs(
-                set(scheduler_output.finished_req_ids),
-                self.input_batch,
-            )
+        # Exactly once per real scheduler_output, before _update_states.
+        self._prefix_cache_step_begin(scheduler_output)
 
         #  -------------------------------------- Omni-new -------------------------------------------------
         if self.speculative_config is not None and self.speculative_config.use_ngram_gpu():
@@ -781,9 +700,9 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                 hidden_states, aux_hidden_states = hidden_states
 
             #  -------------------------------------- Omni-new -------------------------------------------------
-            self._maybe_update_prefix_cache(
-                hidden_states=hidden_states,
-                multimodal_outputs=multimodal_outputs,
+            prefix_cache_step_id = self._prefix_cache_save_step(
+                hidden_states,
+                multimodal_outputs,
                 num_tokens_unpadded=num_tokens_unpadded,
                 num_tokens_padded=num_tokens_padded,
             )
@@ -863,6 +782,7 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                 cudagraph_stats,
                 batch_desc,
                 multimodal_outputs, # Omni-specific
+                prefix_cache_step_id,
             )
             self.kv_connector_output = kv_connector_output
 
@@ -898,7 +818,14 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                     )
                 prepared_sampling_metadata = self._sampling_metadata_for_model_sampler(sampling_metadata)
                 self._apply_duplex_sampling(logits, prepared_sampling_metadata)
-                sampler_output = model_sample(logits, prepared_sampling_metadata)
+                sampler_output = call_model_sampler(
+                    self.model,
+                    model_sample,
+                    logits,
+                    prepared_sampling_metadata,
+                    input_batch=self.input_batch,
+                    requests=getattr(self, "requests", None),
+                )
                 if sampler_output is not None:
                     return sampler_output
             return self.sampler(
@@ -955,6 +882,7 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             cudagraph_stats,
             batch_desc,
             multimodal_outputs, # Omni-Specific
+            prefix_cache_step_id,
         ) = self.execute_model_state
         # Clear ephemeral state.
         self.execute_model_state = None
@@ -1105,9 +1033,15 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         hidden_states_cpu = None
         req_hidden_states_cpu: dict[str, torch.Tensor] | None = None
         audio_sparse_output = engine_output_type == "audio" and sparse_mm_req_ids is not None
+        _omni_cache_on = self.omni_prefix_cache is not None
         needs_scheduled_hidden_payload = needs_pooler_payload and (
-            self.omni_prefix_cache is None or not self._model_needs_full_prefix_hidden_states()
+            not _omni_cache_on or not self._model_needs_full_prefix_hidden_states()
         )
+        if not needs_pooler_payload and prefix_cache_step_id is not None:
+            # No consumer for this step's merge: consume the step context by
+            # id (exactly-once contract). The cache write still lands.
+            self.omni_prefix_cache.discard_step(prefix_cache_step_id)
+            prefix_cache_step_id = None
         if needs_scheduled_hidden_payload:
             num_valid_tokens = min(
                 int(scheduler_output.total_num_scheduled_tokens),
@@ -1130,27 +1064,17 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         if callable(query_start_loc_cpu):
             query_start_loc_cpu = query_start_loc_cpu()
 
-        self._stage_deferred_prefix_cache_mm_outputs(
-            scheduler_output=scheduler_output,
-            multimodal_outputs=multimodal_outputs,
-            query_start_loc_cpu=query_start_loc_cpu,
-        )
-
         pooler_output: list[dict[str, object]] | None = None
         if needs_pooler_payload:
             combined_hidden_states = None
             combined_multimodal_outputs = None
             mm_cpu = None
-            if self.omni_prefix_cache is not None:
+            if _omni_cache_on:
                 (
                     combined_hidden_states,
                     combined_multimodal_outputs,
-                ) = self._maybe_get_combined_prefix_cache_tensors(
-                    hidden_states,
-                    multimodal_outputs,
-                    scheduler_output.num_scheduled_tokens,
-                )
-            if self.omni_prefix_cache is None or combined_multimodal_outputs is None:
+                ) = self._prefix_cache_materialize(prefix_cache_step_id, list(req_ids_output_copy))
+            if not _omni_cache_on or combined_multimodal_outputs is None:
                 mm_cpu = build_mm_cpu(
                     flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs
                 )
diff --git a/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py b/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
index 59dfc88a3..d796dec8e 100644
--- a/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
@@ -459,6 +459,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin
             cudagraph_stats,
             _batch_desc,
             multimodal_outputs_raw,  # Omni-Specific
+            _prefix_cache_step_id,  # generation stages never save to the prefix cache
         ) = self.execute_model_state
         # Clear ephemeral state.
         self.execute_model_state = None
diff --git a/vllm_omni/platforms/npu/worker/npu_model_runner.py b/vllm_omni/platforms/npu/worker/npu_model_runner.py
index bd7c7dce4..d8e352d48 100644
--- a/vllm_omni/platforms/npu/worker/npu_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_model_runner.py
@@ -20,7 +20,7 @@ from vllm_ascend.ops.rotary_embedding import update_cos_sin
 from vllm_ascend.utils import enable_sp, lmhead_tp_enable
 from vllm_ascend.worker.model_runner_v1 import SEQ_LEN_WITH_MAX_PA_WORKSPACE
 
-from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
+from vllm_omni.core.prefix_cache import stage_prefix_cache_config
 from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.platforms.npu._310p import is_310p
 from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
@@ -36,35 +36,32 @@ else:
 
 class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
     def initialize_kv_cache(self, kv_cache_config) -> None:
-        """Create the omni tensor prefix cache.
-
-        The omni prefix cache is used to store the hidden states of the prefix tokens
-        """
+        """Stage the omni prefix-cache config (hidden / mm tensors reused on hits)."""
         NPUModelRunner.initialize_kv_cache(self, kv_cache_config)
-        if self.omni_prefix_cache is None and self.cache_config.enable_prefix_caching:
-            # Read num_blocks back off self.kv_cache_config: vllm-ascend
-            # deepcopies the config it was handed, so the value it stored is the
-            # authoritative one, not our caller's argument.
-            num_blocks = self.kv_cache_config.num_blocks
-            self.omni_prefix_cache = OmniTensorPrefixCache(
-                num_blocks=num_blocks,
-                block_size=self.cache_config.block_size,
-                hidden_size=self.model_config.get_hidden_size(),
-                hs_dtype=self.dtype,
-            )
-            logger.info(
-                "Initialized omni prefix cache on NPU (num_blocks=%d, block_size=%d, hidden_size=%d). "
-                "Hidden-state cache is pinned host memory of roughly %.1f GiB; each per-token "
-                "multimodal output key allocates another tensor of the same block shape.",
-                num_blocks,
-                self.cache_config.block_size,
-                self.model_config.get_hidden_size(),
-                num_blocks
-                * self.cache_config.block_size
-                * self.model_config.get_hidden_size()
-                * self.dtype.itemsize
-                / (1024**3),
+        if getattr(self, "_omni_prefix_cache_cfg", None) is None:
+            # Same gate as the GPU runner (pooling stage, kv_consumer /
+            # kv_both, hybrid kv groups). Read the config back off
+            # self.kv_cache_config: vllm-ascend deepcopies the one it was
+            # handed, so the stored value is the authoritative one.
+            # Controller runs in eager mode on NPU (no CUDA streams:
+            # dispatch() completes the copy+scatter synchronously). Built once
+            # on the first step via the inherited _ensure_omni_prefix_cache.
+            cfg = stage_prefix_cache_config(
+                kv_cache_config=self.kv_cache_config,
+                cache_config=self.cache_config,
+                kv_transfer_config=getattr(self.vllm_config, "kv_transfer_config", None),
+                scheduler_config=self.scheduler_config,
+                model_config=self.model_config,
+                is_pooling_model=self.is_pooling_model,
+                speculative_config=self.speculative_config,
             )
+            if cfg is not None:
+                self._omni_prefix_cache_cfg = cfg
+                logger.info(
+                    "Initialized omni prefix cache on NPU (eager mode, num_blocks=%d, block_size=%d).",
+                    cfg.num_blocks,
+                    cfg.block_size,
+                )
 
     def load_model(self, *args, **kwargs) -> None:
         if is_310p():
@@ -84,6 +81,8 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
             if callable(candidate):
                 override_fn = candidate
         self._sampled_token_ids_cpu_override = override_fn
+        self._snapshot_prefix_cache_model_policy(model)
+        self._pooler_payload_include_hidden_flag = bool(getattr(model, "omni_pooler_payload_include_hidden", True))
         self._omni_query_start_loc_model_kwarg = bool(getattr(model, "supports_omni_query_start_loc", False))
         self._maybe_enable_output_token_ids_for_model_sampler()
         self._init_talker_mtp()
diff --git a/vllm_omni/protocol/__init__.py b/vllm_omni/protocol/__init__.py
new file mode 100644
index 000000000..e241a7924
--- /dev/null
+++ b/vllm_omni/protocol/__init__.py
@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Wire protocols vLLM-Omni speaks, independent of who serves or runs them.
+
+A module under ``vllm_omni.protocol`` describes *what is on the wire*: how a
+client payload is parsed and validated, and what shape a server payload has.
+It never decides how a request is executed, which model answers it, or where
+the session state lives. That keeps one protocol implementation usable by more
+than one runtime (see ``vllm_omni.protocol.realtime``).
+
+Dependency rule, asserted by ``tests/protocol/realtime/test_protocol_import_boundary.py``:
+nothing here may import ``vllm_omni.engine``, ``vllm_omni.entrypoints``,
+``vllm_omni.model_executor``, ``vllm_omni.worker`` or ``vllm_omni.clients``.
+The arrows point inwards --- those packages import the protocol, never the
+other way round.
+"""
diff --git a/vllm_omni/protocol/duplex/__init__.py b/vllm_omni/protocol/duplex/__init__.py
new file mode 100644
index 000000000..d89a01322
--- /dev/null
+++ b/vllm_omni/protocol/duplex/__init__.py
@@ -0,0 +1,159 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""vLLM-Omni's full-duplex extension of the OpenAI Realtime wire protocol.
+
+OpenAI's Realtime API assumes one turn at a time: the client commits input, the
+server answers. A full-duplex session does not --- the model listens while it
+speaks, it decides when to take a turn, the client reports playback progress,
+and a dropped socket re-attaches to a session that kept running. Those need
+events and commands the GA vocabulary does not have.
+
+This package is that delta. It builds on ``vllm_omni.protocol.realtime`` (same
+base classes, same pure wire rendering, no duplication) and, like it, owns no
+session and imports no runtime: the duplex engine depends on this package, not
+the other way round.
+
+The one door
+------------
+It is also the *only* door a duplex consumer uses. ``protocol.duplex.commands``
+and ``protocol.duplex.events`` carry the complete vocabulary --- Tier 1 classes
+re-exported unchanged alongside the Tier 2 and Tier 3 ones --- and this module
+re-exports the Tier 1 helper functions. So the layering is a chain, not a mesh::
+
+    protocol.realtime   (OpenAI's surface)
+        ^
+        | imports
+        |
+    protocol.duplex     (this package: re-exports Tier 1, adds Tier 2 and 3)
+        ^
+        | imports
+        |
+    duplex engine / entrypoints / clients
+
+``tests/protocol/duplex/test_duplex_protocol_facade.py`` asserts that the last
+arrow is the only one: no duplex consumer imports ``protocol.realtime``
+directly. The payoff is that a helper which later needs a duplex-specific
+version --- ``convert_input_audio_with_rate`` is the standing example, it
+resamples to MiniCPM-o's 16 kHz rather than the client's rate --- is overridden
+in one file instead of at every call site.
+
+What stays outside
+------------------
+The *mailbox* half of a command does not live here. A duplex command carries
+two different things: the client event it decodes from (wire, this package) and
+the dictionary the session runner consumes (engine). They genuinely differ ---
+``session.update``, ``conversation.item.create`` / ``.delete`` / ``.truncate``
+all travel on the runner's ``turn.signal`` channel --- so ``payload()`` and its
+``type`` stay in ``vllm_omni.engine.duplex.commands``. Events have no such
+half, which is why :data:`~vllm_omni.protocol.duplex.events.DuplexEvent` can be
+a plain alias of ``RealtimeEvent`` while ``DuplexCommand`` cannot.
+"""
+
+from vllm_omni.protocol.duplex.errors import (
+    REALTIME_ERROR_TYPES_BY_CODE,
+    RealtimeProtocolError,
+    realtime_error_type,
+)
+from vllm_omni.protocol.realtime.audio import (
+    MAX_INPUT_SAMPLE_RATE_HZ,
+    MIN_INPUT_SAMPLE_RATE_HZ,
+    convert_input_audio_with_rate,
+    convert_output_audio,
+    decode_g711_alaw,
+    decode_g711_ulaw,
+    encode_float32_mono_wav_base64,
+    encode_g711_alaw,
+    encode_g711_ulaw,
+    resample_pcm16_mono,
+    validate_input_sample_rate_hz,
+    wav_payload_to_pcm16,
+)
+from vllm_omni.protocol.realtime.audio_input import (
+    REALTIME_INPUT_HINT_KEYS,
+    RealtimeAudioAppend,
+    copy_realtime_input_hints,
+    decode_audio_append,
+    input_explicitly_non_speech,
+    input_looks_like_speech,
+)
+from vllm_omni.protocol.realtime.capabilities import (
+    RealtimeProtocolCapabilities,
+    RealtimeSessionRejection,
+    validate_session_payload,
+)
+from vllm_omni.protocol.realtime.formats import (
+    REALTIME_INPUT_AUDIO_FORMATS,
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+    is_supported_realtime_input_format,
+    parse_realtime_audio_format,
+    realtime_audio_format_object,
+    realtime_output_format,
+    validate_conversation_item_audio_formats,
+    validate_realtime_response_audio_formats,
+    validate_realtime_session_audio_formats,
+)
+from vllm_omni.protocol.realtime.items import (
+    input_transcript_from_item,
+    normalize_conversation_item,
+    text_chars_for_audio_ms_from_marks,
+    truncate_realtime_item_content,
+    validate_realtime_item_truncate,
+    validate_realtime_video_frames,
+)
+from vllm_omni.protocol.realtime.session import (
+    RealtimeInputDefaults,
+    apply_realtime_session_defaults,
+    input_audio_transcription_config,
+    json_safe_realtime_payload,
+    realtime_max_output_tokens,
+    realtime_overlap_fields,
+)
+
+__all__ = [
+    "MAX_INPUT_SAMPLE_RATE_HZ",
+    "MIN_INPUT_SAMPLE_RATE_HZ",
+    "REALTIME_ERROR_TYPES_BY_CODE",
+    "REALTIME_INPUT_AUDIO_FORMATS",
+    "REALTIME_INPUT_HINT_KEYS",
+    "REALTIME_OUTPUT_AUDIO_FORMATS",
+    "RealtimeAudioAppend",
+    "RealtimeInputDefaults",
+    "RealtimeProtocolCapabilities",
+    "RealtimeProtocolError",
+    "RealtimeSessionRejection",
+    "apply_realtime_session_defaults",
+    "convert_input_audio_with_rate",
+    "convert_output_audio",
+    "copy_realtime_input_hints",
+    "decode_audio_append",
+    "decode_g711_alaw",
+    "decode_g711_ulaw",
+    "encode_float32_mono_wav_base64",
+    "encode_g711_alaw",
+    "encode_g711_ulaw",
+    "input_audio_transcription_config",
+    "input_explicitly_non_speech",
+    "input_looks_like_speech",
+    "input_transcript_from_item",
+    "is_supported_realtime_input_format",
+    "json_safe_realtime_payload",
+    "normalize_conversation_item",
+    "parse_realtime_audio_format",
+    "realtime_audio_format_object",
+    "realtime_error_type",
+    "realtime_max_output_tokens",
+    "realtime_output_format",
+    "realtime_overlap_fields",
+    "resample_pcm16_mono",
+    "text_chars_for_audio_ms_from_marks",
+    "truncate_realtime_item_content",
+    "validate_conversation_item_audio_formats",
+    "validate_input_sample_rate_hz",
+    "validate_realtime_item_truncate",
+    "validate_realtime_response_audio_formats",
+    "validate_realtime_session_audio_formats",
+    "validate_realtime_video_frames",
+    "validate_session_payload",
+    "wav_payload_to_pcm16",
+]
diff --git a/vllm_omni/protocol/duplex/commands.py b/vllm_omni/protocol/duplex/commands.py
new file mode 100644
index 000000000..1dbb9bf25
--- /dev/null
+++ b/vllm_omni/protocol/duplex/commands.py
@@ -0,0 +1,164 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The client-event vocabulary a full-duplex session accepts.
+
+Seven of the seventeen are events OpenAI's Realtime API has no equivalent for,
+because they only make sense when the model and the user can talk at the same
+time: the user cuts in (``barge_in``), the client reports how much audio it
+played (``playback.ack``), a turn transition is signalled locally
+(``turn.signal``), input is abandoned without committing (``input.cancel``),
+text is pushed into a live turn (``input.text.append``), and the session is
+kept alive or closed explicitly (``session.heartbeat`` / ``session.close``).
+Two more are OpenAI commands carrying duplex-only fields (Tier 2).
+
+The remaining eight are OpenAI's, unchanged, and re-exported from
+``vllm_omni.protocol.realtime.commands`` rather than redeclared --- they are
+the same objects. They are re-exported so this module is the *whole*
+vocabulary and a duplex consumer never has to import the Tier 1 package
+directly; keeping them declared there means a GA-only consumer is still not
+handed events its clients never send.
+
+None of these carries the engine's mailbox rendering: ``payload()`` and its
+channel live in ``vllm_omni.engine.duplex.commands``, because for four of the
+seventeen the runner's channel is not the client event type at all.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import ClassVar
+
+from vllm_omni.protocol.realtime import commands as realtime_commands
+from vllm_omni.protocol.realtime.commands import (
+    CancelResponse,
+    ClearInput,
+    ClearOutputAudio,
+    CreateItem,
+    CreateResponse,
+    DeleteItem,
+    RealtimeCommand,
+    TruncateItem,
+    UpdateSession,
+)
+
+# ---- Tier 2: OpenAI names carrying vLLM-Omni extensions ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AppendAudio(realtime_commands.AppendAudio):
+    """Tier 2: OpenAI's ``input_audio_buffer.append`` plus the duplex hints.
+
+    OpenAI's append is just base64 audio. The duplex lane also lets a client
+    declare this chunk's own format and rate, whether it believes the chunk is
+    speech, camera frames captured alongside it, and its timing --- all
+    additive, all ignored by a stock client.
+    """
+
+    #: Model-neutral hints carried through from the wire (rms, vad, transcript hints ...).
+    format: str = "pcm16"
+    sample_rate_hz: int | None = None
+    is_speech: bool | None = None
+    video_frames: tuple[str, ...] = ()
+    duration_ms: int | None = None
+    audio_end_ms: int | None = None
+    hints: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Commit(realtime_commands.Commit):
+    """Tier 2: OpenAI's ``input_audio_buffer.commit`` plus duplex turn control.
+
+    OpenAI's commit carries nothing and always produces an item. Here a commit
+    may be non-final, may decline to start a response, and may declare itself
+    silence --- the semantic divergence documented in
+    ``docs/serving/realtime_duplex_api.md`` ("Commit != response").
+    """
+
+    #: Realtime conversation item created for this commit (wire correlation only).
+    #: ``None`` means "no explicit request": the runner decides on commit (auto-response
+    #: sessions answer on their own); ``True`` / ``False`` force it.
+    create_response: bool | None = None
+    is_speech: bool | None = None
+    realtime_item_id: str | None = None
+
+
+# ---- Tier 3: vLLM-Omni only ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AppendText(RealtimeCommand):
+    wire_type: ClassVar[str] = "input.text.append"
+    text: str
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CancelInput(RealtimeCommand):
+    wire_type: ClassVar[str] = "input.cancel"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class BargeIn(RealtimeCommand):
+    wire_type: ClassVar[str] = "barge_in"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SignalTurn(RealtimeCommand):
+    """Generic ``turn.signal`` (local turn transitions such as ``user_started``)."""
+
+    wire_type: ClassVar[str] = "turn.signal"
+    event: str
+    signal_payload: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AckPlayback(RealtimeCommand):
+    wire_type: ClassVar[str] = "playback.ack"
+    played_ms: int
+    committed_ms: int | None = None
+    response_id: str | None = None
+    item_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Heartbeat(RealtimeCommand):
+    wire_type: ClassVar[str] = "session.heartbeat"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CloseSession(RealtimeCommand):
+    """Graceful close requested through the command stream (``session.close``)."""
+
+    wire_type: ClassVar[str] = "session.close"
+    reason: str = "client_close"
+
+
+#: The complete command vocabulary a duplex client may send: the eight Tier 1
+#: classes re-exported unchanged, the two Tier 2 classes defined above, and the
+#: seven Tier 3 ones. A duplex consumer imports from here and never reaches
+#: past this module into ``vllm_omni.protocol.realtime``, so a command that
+#: later grows a duplex extension changes only this file.
+__all__ = [
+    # Tier 1 --- re-exported from ``vllm_omni.protocol.realtime.commands``.
+    "CancelResponse",
+    "ClearInput",
+    "ClearOutputAudio",
+    "CreateItem",
+    "CreateResponse",
+    "DeleteItem",
+    "RealtimeCommand",
+    "TruncateItem",
+    "UpdateSession",
+    # Tier 2 --- an OpenAI command plus duplex-only fields.
+    "AppendAudio",
+    "Commit",
+    # Tier 3 --- vLLM-Omni only.
+    "AckPlayback",
+    "AppendText",
+    "BargeIn",
+    "CancelInput",
+    "CloseSession",
+    "Heartbeat",
+    "SignalTurn",
+]
diff --git a/vllm_omni/protocol/duplex/errors.py b/vllm_omni/protocol/duplex/errors.py
new file mode 100644
index 000000000..418c98712
--- /dev/null
+++ b/vllm_omni/protocol/duplex/errors.py
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""vLLM-Omni's Realtime error-code vocabulary.
+
+OpenAI's Realtime API standardises the ``error.type`` classes
+(``invalid_request_error`` / ``server_error`` / ``rate_limit_error``) but not
+the ``code`` values inside them. Ours are listed here --- Tier 3 in
+``docs/serving/realtime_duplex_api.md``, "the full error-code vocabulary" ---
+so ``protocol/realtime`` stays the OpenAI surface and nothing more.
+"""
+
+from __future__ import annotations
+
+from vllm_omni.protocol.realtime.errors import RealtimeProtocolError
+
+__all__ = ["REALTIME_ERROR_TYPES_BY_CODE", "RealtimeProtocolError", "realtime_error_type"]
+
+
+#: OpenAI Realtime ``error.type`` for each internal error code.
+REALTIME_ERROR_TYPES_BY_CODE: dict[str, str] = {
+    "bad_event": "invalid_request_error",
+    "bad_audio": "invalid_request_error",
+    "config_timeout": "invalid_request_error",
+    "invalid_json": "invalid_request_error",
+    "event_too_large": "invalid_request_error",
+    "unknown_event": "invalid_request_error",
+    "internal_error": "server_error",
+    "runtime_append_failed": "server_error",
+    "runtime_append_task_failed": "server_error",
+    "runtime_signal_failed": "server_error",
+    "runtime_abort_failed": "server_error",
+    "runtime_data_plane_stream_failed": "server_error",
+    "runtime_data_plane_text_without_audio": "server_error",
+    "resource_exhausted": "rate_limit_error",
+    "session_exists": "invalid_request_error",
+    "session_closed": "invalid_request_error",
+    "unknown_session": "invalid_request_error",
+    "invalid_duplex_runtime_config": "invalid_request_error",
+    "instructions_update_unsupported": "invalid_request_error",
+    "persona_update_unsupported": "invalid_request_error",
+    "voice_update_unsupported": "invalid_request_error",
+    "unsupported_nemotron_duplex_mode": "invalid_request_error",
+    "unsupported_native_response_options": "invalid_request_error",
+    "runtime_touch_failed": "server_error",
+    "engine_error": "server_error",
+    "input_backpressure": "rate_limit_error",
+    "response_already_active": "invalid_request_error",
+    "response_not_active": "invalid_request_error",
+    "response_create_without_input": "invalid_request_error",
+    "text_only_turn_unsupported": "invalid_request_error",
+    "commit_aborted": "server_error",
+    "input_audio_buffer_empty": "invalid_request_error",
+    "missing_item_id": "invalid_request_error",
+    "item_not_found": "invalid_request_error",
+    "playback_item_mismatch": "invalid_request_error",
+    "playback_item_not_found": "invalid_request_error",
+    "playback_ack_too_late": "invalid_request_error",
+    "unsupported_audio_format": "invalid_request_error",
+    "unsupported_turn_detection": "invalid_request_error",
+    "unsupported_ref_audio_path": "invalid_request_error",
+    "ref_audio_required": "invalid_request_error",
+    "model_update_unsupported": "invalid_request_error",
+    "voice_update_after_audio_unsupported": "invalid_request_error",
+    "ref_audio_update_unsupported": "invalid_request_error",
+    "native_text_append_unsupported": "invalid_request_error",
+    "invalid_video_frames": "invalid_request_error",
+    "invalid_function_call_output": "invalid_request_error",
+    "server_vad_unavailable": "server_error",
+}
+
+
+def realtime_error_type(code: str) -> str:
+    """The OpenAI ``error.type`` bucket for an internal error code."""
+    return REALTIME_ERROR_TYPES_BY_CODE.get(code, "invalid_request_error")
diff --git a/vllm_omni/protocol/duplex/events.py b/vllm_omni/protocol/duplex/events.py
new file mode 100644
index 000000000..f2abe748e
--- /dev/null
+++ b/vllm_omni/protocol/duplex/events.py
@@ -0,0 +1,419 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""vLLM-Omni's half of the Realtime server-event vocabulary.
+
+``docs/serving/realtime_duplex_api.md`` sorts every message into three tiers.
+Tier 1 --- identical to OpenAI --- is ``vllm_omni.protocol.realtime.events``.
+The other two are here:
+
+**Tier 2, OpenAI names carrying vLLM-Omni extensions.** Same wire type, same
+OpenAI fields, plus additive keys a stock client ignores. Each one subclasses
+its Tier 1 twin and declares only what it adds, so the OpenAI surface stays
+honest: a consumer that wants pure GA takes ``protocol/realtime`` and gets
+exactly OpenAI's fields.
+
+**Tier 3, vLLM-Omni only.** Events OpenAI has no equivalent for, because they
+only make sense when the model and the user can talk at the same time: the
+model decides when to listen and when to speak, the client reports how much
+audio it played, overlapping speech needs a recorded decision, and a dropped
+socket can re-attach to a live session.
+
+Same-named classes are deliberate --- ``duplex.events.SessionCreated`` *is*
+``realtime.events.SessionCreated`` with our extensions. Import whichever
+surface you mean.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import cast
+
+from vllm_omni.protocol.duplex.errors import REALTIME_ERROR_TYPES_BY_CODE
+from vllm_omni.protocol.realtime import events as realtime_events
+from vllm_omni.protocol.realtime.events import (
+    AudioDone,
+    ContentPartAdded,
+    ContentPartDone,
+    FunctionCallArgumentsDelta,
+    FunctionCallArgumentsDone,
+    InputCleared,
+    InputTranscriptionCompleted,
+    ItemAdded,
+    ItemCreated,
+    ItemDone,
+    ItemRetrieved,
+    OutputAudioCleared,
+    OutputItemAdded,
+    OutputItemDone,
+    RateLimitsUpdated,
+    RealtimeEvent,
+    ResponseScopedEvent,
+    SessionUpdated,
+    SpeechStarted,
+    SpeechStopped,
+    TextDelta,
+    TextDone,
+    TranscriptDelta,
+    TranscriptDone,
+    new_event_id,
+    wire_value,
+)
+
+#: The duplex event base class *is* the Realtime one: unlike a command, an
+#: event has no engine-internal half to carry --- what the session emits is
+#: exactly what the socket sends. Named here rather than in the engine so the
+#: duplex vocabulary is described in one place, and kept as an alias rather
+#: than an empty subclass so ``isinstance`` and the class identity tests in
+#: ``tests/protocol/`` stay meaningful.
+DuplexEvent = RealtimeEvent
+
+# ---- Tier 2: OpenAI names carrying vLLM-Omni extensions ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionCreated(realtime_events.SessionCreated):
+    """Tier 2: OpenAI's ``SessionCreated`` plus the resume credentials a reconnecting client needs."""
+
+    #: Transport resume credentials (set by the websocket handler when resume is supported).
+    optional_wire_fields = frozenset({"attachment_generation", "resume_token"})
+    attachment_generation: int | None = None
+    resume_token: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResponseCreated(realtime_events.ResponseCreated):
+    """Tier 2: OpenAI's ``ResponseCreated`` plus a top-level ``response_id``.
+
+    OpenAI carries the id nested as ``response.id``; the duplex lane also
+    reports it at the top level, where every other response-scoped event
+    already has one.
+    """
+
+    response_id: str | None = None  # type: ignore[assignment]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResponseDone(realtime_events.ResponseDone):
+    """Tier 2: OpenAI's ``ResponseDone`` plus a top-level ``response_id``.
+
+    OpenAI carries the id nested as ``response.id``; the duplex lane also
+    reports it at the top level, where every other response-scoped event
+    already has one.
+    """
+
+    response_id: str | None = None  # type: ignore[assignment]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AudioDelta(realtime_events.AudioDelta):
+    """Tier 2: OpenAI's ``AudioDelta`` plus the chunk's own format/rate and the duplex playback metadata."""
+
+    optional_wire_fields = frozenset({"sample_rate_hz", "metadata"})
+    format: str = "pcm16"
+    sample_rate_hz: int | None = None
+    metadata: Mapping[str, object] | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class InputCommitted(realtime_events.InputCommitted):
+    """Tier 2: OpenAI's ``InputCommitted`` plus the native ``input.committed`` event echoed under ``event``."""
+
+    #: The session-internal ``input.committed`` event.
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    def _wire_fields(self) -> dict[str, object]:
+        # Explicit parent call, not ``super()``: ``@dataclass(slots=True)``
+        # rebuilds the class, so the zero-argument form's ``__class__`` cell
+        # points at the pre-slots class and is no longer in the MRO.
+        base = realtime_events.__dict__[type(self).__name__]._wire_fields(self)
+        return {**base, "event": wire_value(self.details)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemDeleted(realtime_events.ItemDeleted):
+    """Tier 2: OpenAI's ``ItemDeleted`` plus the originating event echoed under ``event``."""
+
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    def _wire_fields(self) -> dict[str, object]:
+        # Explicit parent call, not ``super()``: ``@dataclass(slots=True)``
+        # rebuilds the class, so the zero-argument form's ``__class__`` cell
+        # points at the pre-slots class and is no longer in the MRO.
+        base = realtime_events.__dict__[type(self).__name__]._wire_fields(self)
+        return {**base, "event": wire_value(self.details)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemTruncated(realtime_events.ItemTruncated):
+    """Tier 2: OpenAI's ``ItemTruncated`` plus the originating event echoed under ``event``."""
+
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    def _wire_fields(self) -> dict[str, object]:
+        # Explicit parent call, not ``super()``: ``@dataclass(slots=True)``
+        # rebuilds the class, so the zero-argument form's ``__class__`` cell
+        # points at the pre-slots class and is no longer in the MRO.
+        base = realtime_events.__dict__[type(self).__name__]._wire_fields(self)
+        return {**base, "event": wire_value(self.details)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ErrorEvent(realtime_events.ErrorEvent):
+    """Tier 2: OpenAI's ``ErrorEvent`` plus vLLM-Omni's error codes and any extra keys merged into the envelope."""
+
+    #: Extra keys merged into the wire ``error`` object (``retryable`` ...).
+    extra: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def error_type(self) -> str:
+        return REALTIME_ERROR_TYPES_BY_CODE.get(self.code, "invalid_request_error")
+
+    @property
+    def error(self) -> dict[str, object]:
+        # Explicit parent call, not ``super()``: ``@dataclass(slots=True)``
+        # rebuilds the class, so the zero-argument form's ``__class__`` cell
+        # points at the pre-slots class and is no longer in the MRO. Reached
+        # through ``__dict__`` because attribute access on the class gives the
+        # getter function, not the ``property`` that owns it.
+        error = dict(realtime_events.ErrorEvent.__dict__["error"].fget(self))
+        error.update(cast("Mapping[str, object]", wire_value(self.extra)))
+        return error
+
+
+# ---- Tier 3: vLLM-Omni only ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionResumed(SessionCreated):
+    wire_type = "session.resumed"
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id, **RealtimeEvent._wire_fields(self)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionReplaced(RealtimeEvent):
+    """A newer connection took the session over (sent to the replaced socket)."""
+
+    wire_type = "session.replaced"
+
+    attachment_generation: int = 0
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id, **RealtimeEvent._wire_fields(self)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionResyncRequired(RealtimeEvent):
+    """The replay journal cannot bridge the gap; the client must start over."""
+
+    wire_type = "session.resync_required"
+
+    reason: str = "journal_gap"
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id, **RealtimeEvent._wire_fields(self)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionClosed(RealtimeEvent):
+    wire_type = "session.closed"
+
+    reason: str = "closed"
+    #: The session-internal close event (kept for clients that inspect it).
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def is_terminal(self) -> bool:
+        return True
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id, "reason": self.reason, "event": wire_value(self.details)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionExpired(SessionClosed):
+    wire_type = "session.expired"
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id, "reason": self.reason}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionHeartbeatAck(RealtimeEvent):
+    wire_type = "session.heartbeat_ack"
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TurnEvent(RealtimeEvent):
+    """Turn-state transition (``turn.event``)."""
+
+    wire_type = "turn.event"
+
+    event: str = ""
+    turn_state: str = ""
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"session_id": self.session_id, "event": self.event, "turn_state": self.turn_state, "epoch": self.epoch}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Listen(RealtimeEvent):
+    """The model decided to keep listening (no spoken response for this turn)."""
+
+    wire_type = "response.listen"
+    optional_wire_fields = frozenset({"response_id"})
+
+    response_id: str | None = None  # type: ignore[assignment]
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    def _wire_fields(self) -> dict[str, object]:
+        response: dict[str, object] = {
+            "object": "realtime.response",
+            "status": "listening",
+            "metadata": wire_value(self.details),
+        }
+        data: dict[str, object] = {"session_id": self.session_id, "epoch": self.epoch, "response": response}
+        if self.response_id:
+            response["id"] = self.response_id
+            data["response_id"] = self.response_id
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Speak(ResponseScopedEvent):
+    wire_type = "response.speak"
+
+    metadata: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class OverlapDecision(RealtimeEvent):
+    wire_type = "overlap.decision"
+
+    policy: str | None = None
+    action: str | None = None
+    reason: str | None = None
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {
+            "session_id": self.session_id,
+            "epoch": self.epoch,
+            "policy": self.policy,
+            "action": self.action,
+            "reason": self.reason,
+            "metadata": wire_value(self.details),
+        }
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class PlaybackAcknowledged(RealtimeEvent):
+    wire_type = "playback.acknowledged"
+
+    #: The session-internal ``playback.acknowledged`` event (cursor, committed_ms ...).
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"event": wire_value(self.details)}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DuplexRawEvent(RealtimeEvent):
+    """A session-internal event with no dedicated Realtime type (``duplex.<internal type>``)."""
+
+    wire_type = "duplex.raw"
+
+    internal_type: str = ""
+    details: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def type(self) -> str:
+        return f"duplex.{self.internal_type}"
+
+    def to_realtime(self) -> dict[str, object]:
+        return {"type": self.type, "event_id": self.event_id, "event": wire_value(self.details)}
+
+
+def error_event(
+    code: str,
+    message: str,
+    *,
+    event_id: object | None = None,
+    param: object | None = None,
+    extra: Mapping[str, object] | None = None,
+) -> ErrorEvent:
+    """Build the error event for an internal code; ``event_id`` is the *client* event id."""
+    return ErrorEvent(
+        code=code,
+        message=message,
+        related_event_id=event_id if isinstance(event_id, str) and event_id else None,
+        param=param if isinstance(param, str) and param else None,
+        extra=dict(extra or {}),
+    )
+
+
+#: The complete event vocabulary a duplex client may receive: 22 Tier 1
+#: classes re-exported unchanged, the 8 Tier 2 ones defined above, and 12
+#: Tier 3 ones. A duplex consumer imports from here and never reaches past
+#: this module into ``vllm_omni.protocol.realtime``.
+__all__ = [
+    # Tier 1 --- re-exported from ``vllm_omni.protocol.realtime.events``.
+    "AudioDone",
+    "ContentPartAdded",
+    "ContentPartDone",
+    "FunctionCallArgumentsDelta",
+    "FunctionCallArgumentsDone",
+    "InputCleared",
+    "InputTranscriptionCompleted",
+    "ItemAdded",
+    "ItemCreated",
+    "ItemDone",
+    "ItemRetrieved",
+    "OutputAudioCleared",
+    "OutputItemAdded",
+    "OutputItemDone",
+    "RateLimitsUpdated",
+    "SessionUpdated",
+    "SpeechStarted",
+    "SpeechStopped",
+    "TextDelta",
+    "TextDone",
+    "TranscriptDelta",
+    "TranscriptDone",
+    # Tier 2 --- an OpenAI event plus duplex-only fields.
+    "AudioDelta",
+    "ErrorEvent",
+    "InputCommitted",
+    "ItemDeleted",
+    "ItemTruncated",
+    "ResponseCreated",
+    "ResponseDone",
+    "SessionCreated",
+    # Tier 3 --- vLLM-Omni only.
+    "DuplexRawEvent",
+    "Listen",
+    "OverlapDecision",
+    "PlaybackAcknowledged",
+    "SessionClosed",
+    "SessionExpired",
+    "SessionHeartbeatAck",
+    "SessionReplaced",
+    "SessionResumed",
+    "SessionResyncRequired",
+    "Speak",
+    "TurnEvent",
+    # Bases and helpers shared with the Tier 1 surface.
+    "DuplexEvent",
+    "REALTIME_ERROR_TYPES_BY_CODE",
+    "RealtimeEvent",
+    "ResponseScopedEvent",
+    "error_event",
+    "new_event_id",
+    "wire_value",
+]
diff --git a/vllm_omni/protocol/realtime/__init__.py b/vllm_omni/protocol/realtime/__init__.py
new file mode 100644
index 000000000..af7194cb5
--- /dev/null
+++ b/vllm_omni/protocol/realtime/__init__.py
@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The OpenAI Realtime wire codec, shared by every vLLM-Omni Realtime surface.
+
+What this is
+------------
+The model-agnostic half of ``WS /v1/realtime``: how a client event is parsed,
+which audio formats and session fields are accepted, what a conversation item
+means, how audio is decoded and resampled, and the shape of the error envelope
+(the *codes* inside it are a consumer's own --- ours are in
+``vllm_omni.protocol.duplex.errors``). It is a library of pure functions and value objects.
+
+What it is not
+--------------
+It owns no session. It does not decide when a response starts, what a model is
+prompted with, whether a turn is over, or where committed audio goes. Those are
+runtime decisions, and after PR #7413 a duplex session's runtime decisions all
+belong to ``vllm_omni.engine.duplex`` --- the session runner, the typed
+``DuplexCommand`` / ``DuplexEvent`` boundary and the ``DuplexModelPlugin`` seam.
+This package sits *under* that: the duplex engine binds the codec to its own
+command and event vocabulary in
+``vllm_omni.engine.duplex.realtime_commands`` and
+``vllm_omni.engine.duplex.realtime_events``.
+
+Why it is separate (RFC #6592, P0a)
+-----------------------------------
+So that a second Realtime surface --- a Qwen3-Omni GA profile, say --- can reuse
+the parsing, validation, format negotiation and error envelope without adopting
+the duplex session control plane (lease manager, commit policy, model channel),
+and without a second copy of the codec drifting away from this one. A consumer
+states what it can serve through
+:class:`~vllm_omni.protocol.realtime.capabilities.RealtimeProtocolCapabilities`
+and keeps its own session state.
+
+Known duplex-shaped defaults
+----------------------------
+This package is model-agnostic in its *dependencies*, not yet in every
+*default*. Two constants still carry the assumptions of its first consumer and
+a second one will have to parameterize them:
+
+* :func:`~vllm_omni.protocol.realtime.audio.convert_input_audio_with_rate`
+  resamples to 16 kHz, which is MiniCPM-o's feature-extractor rate. A GA client
+  sending 24 kHz is converted down rather than served at its own rate.
+* :func:`~vllm_omni.protocol.realtime.items.validate_realtime_video_frames`
+  encodes the MiniCPM-o duplex camera contract (at most two frames per append,
+  ``max_slice_nums`` not selectable on the wire).
+
+Both are behaviour this extraction deliberately did **not** change (RFC #6592
+P0a is behaviour-preserving); making them per-consumer is P0b/P1 work.
+
+Dependency rule
+---------------
+Nothing here may import ``vllm_omni.engine``, ``vllm_omni.entrypoints``,
+``vllm_omni.model_executor``, ``vllm_omni.worker`` or ``vllm_omni.clients``;
+``tests/protocol/realtime/test_protocol_import_boundary.py`` asserts it.
+"""
+
+from vllm_omni.protocol.realtime.audio import (
+    MAX_INPUT_SAMPLE_RATE_HZ,
+    MIN_INPUT_SAMPLE_RATE_HZ,
+    convert_input_audio_with_rate,
+    convert_output_audio,
+    encode_float32_mono_wav_base64,
+    resample_pcm16_mono,
+    validate_input_sample_rate_hz,
+    wav_payload_to_pcm16,
+)
+from vllm_omni.protocol.realtime.audio_input import (
+    REALTIME_INPUT_HINT_KEYS,
+    RealtimeAudioAppend,
+    copy_realtime_input_hints,
+    decode_audio_append,
+    input_explicitly_non_speech,
+    input_looks_like_speech,
+)
+from vllm_omni.protocol.realtime.capabilities import (
+    RealtimeProtocolCapabilities,
+    RealtimeSessionRejection,
+    validate_session_payload,
+)
+from vllm_omni.protocol.realtime.commands import RealtimeCommand
+from vllm_omni.protocol.realtime.errors import RealtimeProtocolError
+from vllm_omni.protocol.realtime.events import (
+    RealtimeEvent,
+    ResponseScopedEvent,
+    new_event_id,
+    wire_value,
+)
+from vllm_omni.protocol.realtime.formats import (
+    REALTIME_INPUT_AUDIO_FORMATS,
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+    is_supported_realtime_input_format,
+    parse_realtime_audio_format,
+    realtime_audio_format_object,
+    realtime_output_format,
+    validate_conversation_item_audio_formats,
+    validate_realtime_response_audio_formats,
+    validate_realtime_session_audio_formats,
+)
+from vllm_omni.protocol.realtime.items import (
+    input_transcript_from_item,
+    normalize_conversation_item,
+    text_chars_for_audio_ms_from_marks,
+    truncate_realtime_item_content,
+    validate_realtime_item_truncate,
+    validate_realtime_video_frames,
+)
+from vllm_omni.protocol.realtime.session import (
+    RealtimeInputDefaults,
+    apply_realtime_session_defaults,
+    input_audio_transcription_config,
+    json_safe_realtime_payload,
+    realtime_max_output_tokens,
+    realtime_overlap_fields,
+)
+
+__all__ = [
+    "MAX_INPUT_SAMPLE_RATE_HZ",
+    "MIN_INPUT_SAMPLE_RATE_HZ",
+    "REALTIME_INPUT_AUDIO_FORMATS",
+    "REALTIME_INPUT_HINT_KEYS",
+    "REALTIME_OUTPUT_AUDIO_FORMATS",
+    "RealtimeAudioAppend",
+    "RealtimeCommand",
+    "RealtimeEvent",
+    "RealtimeInputDefaults",
+    "RealtimeProtocolCapabilities",
+    "RealtimeProtocolError",
+    "RealtimeSessionRejection",
+    "ResponseScopedEvent",
+    "apply_realtime_session_defaults",
+    "convert_input_audio_with_rate",
+    "convert_output_audio",
+    "copy_realtime_input_hints",
+    "decode_audio_append",
+    "encode_float32_mono_wav_base64",
+    "input_audio_transcription_config",
+    "input_explicitly_non_speech",
+    "input_looks_like_speech",
+    "input_transcript_from_item",
+    "is_supported_realtime_input_format",
+    "json_safe_realtime_payload",
+    "new_event_id",
+    "normalize_conversation_item",
+    "parse_realtime_audio_format",
+    "realtime_audio_format_object",
+    "realtime_max_output_tokens",
+    "realtime_output_format",
+    "realtime_overlap_fields",
+    "resample_pcm16_mono",
+    "text_chars_for_audio_ms_from_marks",
+    "truncate_realtime_item_content",
+    "validate_conversation_item_audio_formats",
+    "validate_input_sample_rate_hz",
+    "validate_realtime_item_truncate",
+    "validate_realtime_response_audio_formats",
+    "validate_realtime_session_audio_formats",
+    "validate_realtime_video_frames",
+    "validate_session_payload",
+    "wav_payload_to_pcm16",
+    "wire_value",
+]
diff --git a/vllm_omni/protocol/realtime/audio.py b/vllm_omni/protocol/realtime/audio.py
new file mode 100644
index 000000000..5f163826a
--- /dev/null
+++ b/vllm_omni/protocol/realtime/audio.py
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import math
+import wave
+
+import numpy as np
+
+from vllm_omni.utils.audio_resample import StreamingAudioResampler
+
+try:
+    from audioop import alaw2lin, lin2alaw, lin2ulaw, ulaw2lin
+except ImportError:  # pragma: no cover - audioop is removed in newer Python.
+    alaw2lin = lin2alaw = lin2ulaw = ulaw2lin = None
+
+
+MIN_INPUT_SAMPLE_RATE_HZ = 8_000
+MAX_INPUT_SAMPLE_RATE_HZ = 192_000
+
+
+def validate_input_sample_rate_hz(sample_rate_hz: object) -> int:
+    if (
+        isinstance(sample_rate_hz, bool)
+        or not isinstance(sample_rate_hz, int | float)
+        or (isinstance(sample_rate_hz, float) and not math.isfinite(sample_rate_hz))
+    ):
+        raise ValueError("sample_rate_hz must be a finite integer")
+    rate = int(sample_rate_hz)
+    if rate != sample_rate_hz:
+        raise ValueError("sample_rate_hz must be an integer")
+    if not MIN_INPUT_SAMPLE_RATE_HZ <= rate <= MAX_INPUT_SAMPLE_RATE_HZ:
+        raise ValueError(f"sample_rate_hz must be between {MIN_INPUT_SAMPLE_RATE_HZ} and {MAX_INPUT_SAMPLE_RATE_HZ}")
+    return rate
+
+
+def resample_pcm16_mono(raw: bytes, *, source_rate_hz: int, target_rate_hz: int) -> bytes:
+    if source_rate_hz <= 0 or target_rate_hz <= 0 or source_rate_hz == target_rate_hz:
+        return raw
+    samples = np.frombuffer(raw, dtype="<i2")
+    rate_gcd = math.gcd(source_rate_hz, target_rate_hz)
+    reduced_factor = max(source_rate_hz // rate_gcd, target_rate_hz // rate_gcd)
+    if reduced_factor > StreamingAudioResampler.max_polyphase_factor:
+        # The FIR size scales with the reduced ratio. Keep unusual client
+        # rates bounded while common audio rates use the high-quality path.
+        if samples.size <= 1:
+            return raw
+        target_size = max(1, int(round(samples.size * target_rate_hz / source_rate_hz)))
+        source_x = np.linspace(0.0, 1.0, num=samples.size, endpoint=True)
+        target_x = np.linspace(0.0, 1.0, num=target_size, endpoint=True)
+        resampled = np.interp(target_x, source_x, samples)
+        return np.clip(resampled, -32_768, 32_767).astype("<i2").tobytes()
+    resampler = StreamingAudioResampler(source_rate_hz, target_rate_hz)
+    normalized = samples.astype(np.float32) * np.float32(1.0 / 32768.0)
+    resampled = resampler.process(normalized, final=True)
+    return np.clip(np.rint(resampled * 32768.0), -32768, 32767).astype("<i2").tobytes()
+
+
+def decode_g711_ulaw(raw: bytes) -> bytes:
+    if ulaw2lin is not None:
+        return ulaw2lin(raw, 2)
+    data = np.frombuffer(raw, dtype=np.uint8)
+    value = np.bitwise_not(data).astype(np.int16)
+    sign = value & 0x80
+    exponent = (value >> 4) & 0x07
+    mantissa = value & 0x0F
+    sample = ((mantissa << 3) + 0x84) << exponent
+    return np.where(sign != 0, -(sample - 0x84), sample - 0x84).astype("<i2").tobytes()
+
+
+def decode_g711_alaw(raw: bytes) -> bytes:
+    if alaw2lin is not None:
+        return alaw2lin(raw, 2)
+    data = np.bitwise_xor(np.frombuffer(raw, dtype=np.uint8), 0x55).astype(np.int16)
+    sign = data & 0x80
+    exponent = (data >> 4) & 0x07
+    mantissa = data & 0x0F
+    sample = np.where(exponent == 0, (mantissa << 4) + 8, ((mantissa << 4) + 0x108) << (exponent - 1))
+    return np.where(sign != 0, sample, -sample).astype("<i2").tobytes()
+
+
+def encode_g711_ulaw(raw: bytes) -> bytes:
+    if lin2ulaw is not None:
+        return lin2ulaw(raw, 2)
+    pcm = np.clip(np.frombuffer(raw, dtype="<i2").astype(np.int32), -32635, 32635)
+    sign = np.where(pcm < 0, 0x80, 0)
+    magnitude = np.abs(pcm) + 0x84
+    exponent = np.zeros_like(magnitude)
+    for exp in range(7):
+        exponent = np.where(magnitude > (0xFF << exp), exp + 1, exponent)
+    mantissa = (magnitude >> (exponent + 3)) & 0x0F
+    return (np.bitwise_not(sign | (exponent << 4) | mantissa) & 0xFF).astype(np.uint8).tobytes()
+
+
+def encode_g711_alaw(raw: bytes) -> bytes:
+    if lin2alaw is not None:
+        return lin2alaw(raw, 2)
+    pcm = np.frombuffer(raw, dtype="<i2").astype(np.int32)
+    sign = np.where(pcm >= 0, 0x80, 0x00)
+    magnitude = np.abs(pcm)
+    exponent = np.zeros_like(magnitude)
+    for exp in range(1, 8):
+        exponent = np.where(magnitude >= (1 << (exp + 7)), exp, exponent)
+    mantissa = np.where(
+        exponent == 0,
+        (magnitude >> 4) & 0x0F,
+        (magnitude >> (exponent + 3)) & 0x0F,
+    )
+    return ((sign | (exponent << 4) | mantissa) ^ 0x55).astype(np.uint8).tobytes()
+
+
+def wav_payload_to_pcm16(raw: bytes) -> tuple[bytes | None, int | None]:
+    try:
+        with wave.open(io.BytesIO(raw), "rb") as wav_file:
+            channels = wav_file.getnchannels()
+            sample_width = wav_file.getsampwidth()
+            sample_rate_hz = wav_file.getframerate()
+            frames = wav_file.readframes(wav_file.getnframes())
+        if sample_width != 2:
+            return None, sample_rate_hz
+        if channels <= 1:
+            return frames, sample_rate_hz
+        pcm = np.frombuffer(frames, dtype="<i2").reshape(-1, channels)
+        mono = np.mean(pcm.astype(np.float32), axis=1)
+        return np.clip(mono, -32768, 32767).astype("<i2").tobytes(), sample_rate_hz
+    except (EOFError, ValueError, wave.Error):
+        return None, None
+
+
+def encode_float32_mono_wav_base64(
+    samples: np.ndarray,
+    *,
+    sample_rate_hz: int,
+) -> str:
+    """Package normalized mono float32 samples as a PCM16 WAV data payload."""
+    rate = validate_input_sample_rate_hz(sample_rate_hz)
+    normalized = np.ascontiguousarray(samples, dtype=np.float32).reshape(-1)
+    pcm16 = np.clip(np.rint(normalized * 32768.0), -32768, 32767).astype("<i2")
+    with io.BytesIO() as buffer:
+        with wave.open(buffer, "wb") as wav_file:
+            wav_file.setnchannels(1)
+            wav_file.setsampwidth(2)
+            wav_file.setframerate(rate)
+            wav_file.writeframes(pcm16.tobytes())
+        return base64.b64encode(buffer.getvalue()).decode("ascii")
+
+
+def convert_input_audio_with_rate(
+    audio: object,
+    fmt: object,
+    *,
+    sample_rate_hz: int | float | None = None,
+    target_sample_rate_hz: int = 16_000,
+) -> tuple[object, object, int | float | None]:
+    if not isinstance(audio, str) or not isinstance(fmt, str):
+        return audio, fmt, sample_rate_hz
+    normalized = fmt.lower()
+    if normalized not in {"pcm16", "pcm_s16le", "s16le", "g711_ulaw", "g711_alaw"}:
+        return audio, fmt, sample_rate_hz
+    if isinstance(sample_rate_hz, int | float):
+        sample_rate_hz = validate_input_sample_rate_hz(sample_rate_hz)
+    try:
+        raw = base64.b64decode(audio.strip(), validate=False)
+    except (binascii.Error, ValueError):
+        return audio, fmt, sample_rate_hz
+    if normalized == "g711_ulaw":
+        raw = decode_g711_ulaw(raw)
+        sample_rate_hz = sample_rate_hz if isinstance(sample_rate_hz, int | float) else 8_000
+    elif normalized == "g711_alaw":
+        raw = decode_g711_alaw(raw)
+        sample_rate_hz = sample_rate_hz if isinstance(sample_rate_hz, int | float) else 8_000
+    elif len(raw) % 2:
+        return audio, fmt, sample_rate_hz
+    if isinstance(sample_rate_hz, int | float) and int(sample_rate_hz) != target_sample_rate_hz:
+        raw = resample_pcm16_mono(
+            raw,
+            source_rate_hz=int(sample_rate_hz),
+            target_rate_hz=target_sample_rate_hz,
+        )
+        sample_rate_hz = target_sample_rate_hz
+    pcm = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
+    encoded = base64.b64encode(np.ascontiguousarray(pcm, dtype="<f4").tobytes()).decode("ascii")
+    return encoded, "pcm_f32le", sample_rate_hz
+
+
+def convert_output_audio(
+    audio: str,
+    *,
+    source_fmt: str,
+    target_fmt: str,
+    source_sample_rate_hz: int | None = None,
+    target_sample_rate_hz: int | None = None,
+) -> tuple[str, str, int | None]:
+    target = target_fmt.lower()
+    if target not in {"g711_ulaw", "g711_alaw"}:
+        return audio, source_fmt, source_sample_rate_hz
+    try:
+        raw = base64.b64decode(audio, validate=False)
+    except (binascii.Error, ValueError):
+        return audio, source_fmt, source_sample_rate_hz
+    source = source_fmt.lower()
+    if source == "wav":
+        pcm_raw, wav_rate = wav_payload_to_pcm16(raw)
+        if pcm_raw is None:
+            return audio, source_fmt, source_sample_rate_hz
+        raw = pcm_raw
+        source_sample_rate_hz = source_sample_rate_hz or wav_rate
+    elif source not in {"pcm", "pcm16", "pcm_s16le", "s16le"} or len(raw) % 2:
+        return audio, source_fmt, source_sample_rate_hz
+    target_rate = target_sample_rate_hz or 8_000
+    if source_sample_rate_hz is not None:
+        raw = resample_pcm16_mono(raw, source_rate_hz=source_sample_rate_hz, target_rate_hz=target_rate)
+    encoded = encode_g711_ulaw(raw) if target == "g711_ulaw" else encode_g711_alaw(raw)
+    return base64.b64encode(encoded).decode("ascii"), target, target_rate
diff --git a/vllm_omni/protocol/realtime/audio_input.py b/vllm_omni/protocol/realtime/audio_input.py
new file mode 100644
index 000000000..634d32c34
--- /dev/null
+++ b/vllm_omni/protocol/realtime/audio_input.py
@@ -0,0 +1,243 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Decoding one ``input_audio_buffer.append``.
+
+An append is the hottest client event on a Realtime connection and the one with
+the most wire surface: base64 audio in any accepted format, an optional rate,
+optional camera frames, and a set of optional hints (``duration_ms``,
+``is_speech``, a VAD probability, a transcript) that clients attach and servers
+are free to use or ignore.
+
+:func:`decode_audio_append` turns that into :class:`RealtimeAudioAppend`, a
+value object: bytes at 16 kHz ``pcm_f32le``, the surviving hints, and a speech
+verdict. It is a pure function of the event plus the session's
+:class:`~vllm_omni.protocol.realtime.session.RealtimeInputDefaults`, so any
+consumer decodes an append the same way. Building a consumer's own command
+object out of it is one constructor call --- see
+``vllm_omni.engine.duplex.realtime_commands.build_append_audio``, which wraps it
+for the duplex ``AppendAudio``.
+
+The speech verdict here is the *client-declared* one (explicit flags, a VAD
+probability the client sent, or an RMS floor as a last resort). It is not
+server-side VAD; that is a runtime concern and lives with whoever owns the
+session.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import cast
+
+import numpy as np
+
+from vllm_omni.protocol.realtime.audio import convert_input_audio_with_rate
+from vllm_omni.protocol.realtime.errors import RealtimeProtocolError
+from vllm_omni.protocol.realtime.formats import (
+    is_supported_realtime_input_format,
+    parse_realtime_audio_format,
+)
+from vllm_omni.protocol.realtime.items import validate_realtime_video_frames
+from vllm_omni.protocol.realtime.session import RealtimeInputDefaults
+
+__all__ = [
+    "REALTIME_INPUT_HINT_KEYS",
+    "RealtimeAudioAppend",
+    "copy_realtime_input_hints",
+    "decode_audio_append",
+    "input_explicitly_non_speech",
+    "input_looks_like_speech",
+]
+
+#: Wire hint keys copied verbatim from a client append onto the internal payload.
+REALTIME_INPUT_HINT_KEYS = (
+    "duration_ms",
+    "audio_duration_ms",
+    "audio_start_ms",
+    "audio_end_ms",
+    "is_speech",
+    "speech",
+    "speech_probability",
+    "vad",
+    "overlap_action",
+    "overlap",
+    "force_barge_in",
+    "force_listen",
+    "text",
+    "transcript",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RealtimeAudioAppend:
+    """One decoded ``input_audio_buffer.append``.
+
+    ``audio`` is raw bytes in ``format`` at ``sample_rate_hz`` --- after
+    :func:`decode_audio_append` that is 16 kHz ``pcm_f32le`` for every input
+    format the codec converts.
+    """
+
+    audio: bytes
+    format: str
+    sample_rate_hz: int | None = None
+    is_speech: bool | None = None
+    video_frames: tuple[str, ...] = ()
+    duration_ms: int | None = None
+    audio_end_ms: int | None = None
+    #: Model-neutral hints carried through from the wire (rms, vad, transcript hints ...).
+    hints: dict[str, object] = field(default_factory=dict)
+    #: Client correlation id (OpenAI ``event_id``), echoed on error events.
+    event_id: str | None = None
+
+
+# ---- speech hints ----
+
+
+def input_explicitly_non_speech(event: Mapping[str, object]) -> bool:
+    for key in ("is_speech", "speech"):
+        value = event.get(key)
+        if isinstance(value, bool):
+            return not value
+    vad = event.get("vad")
+    if isinstance(vad, dict):
+        value = vad.get("is_speech")
+        if isinstance(value, bool):
+            return not value
+        probability = vad.get("speech_probability", vad.get("probability"))
+        if isinstance(probability, int | float):
+            return float(probability) < 0.5
+    probability = event.get("speech_probability")
+    return isinstance(probability, int | float) and float(probability) < 0.5
+
+
+def input_looks_like_speech(
+    event: Mapping[str, object],
+    *,
+    audio: object,
+    fmt: object,
+    overlap_silence_rms: float,
+) -> bool:
+    if input_explicitly_non_speech(event):
+        return False
+    for key in ("is_speech", "speech"):
+        value = event.get(key)
+        if isinstance(value, bool):
+            return value
+    vad = event.get("vad")
+    if isinstance(vad, dict):
+        probability = vad.get("speech_probability", vad.get("probability"))
+        if isinstance(probability, int | float):
+            return float(probability) >= 0.5
+    probability = event.get("speech_probability")
+    if isinstance(probability, int | float):
+        return float(probability) >= 0.5
+    if fmt != "pcm_f32le":
+        return True
+    if isinstance(audio, bytes | bytearray):
+        raw = bytes(audio)
+    elif isinstance(audio, str):
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError):
+            return True
+    else:
+        return True
+    if len(raw) < 4 or len(raw) % 4 != 0:
+        return True
+    samples = np.frombuffer(raw, dtype=np.float32)
+    if samples.size == 0:
+        return False
+    rms = float(np.sqrt(np.mean(np.square(samples.astype(np.float32)))))
+    threshold = event.get("overlap_silence_rms")
+    if not isinstance(threshold, int | float):
+        vad = event.get("vad")
+        if isinstance(vad, dict):
+            threshold = vad.get("silence_rms")
+    silence_rms = float(threshold) if isinstance(threshold, int | float) else overlap_silence_rms
+    return rms >= max(0.0, silence_rms)
+
+
+def copy_realtime_input_hints(source: Mapping[str, object], target: dict[str, object]) -> None:
+    for key in REALTIME_INPUT_HINT_KEYS:
+        if key in source:
+            target[key] = source[key]
+
+
+# ---- append decoding ----
+
+
+def decode_audio_append(
+    event: Mapping[str, object],
+    *,
+    defaults: RealtimeInputDefaults,
+    hints_source: Mapping[str, object] | None = None,
+) -> RealtimeAudioAppend:
+    """Validate, convert (to 16 kHz ``pcm_f32le``) and pack one audio append.
+
+    ``hints_source`` is the enclosing payload when the audio arrives inside
+    something larger than a bare append --- a ``conversation.item.create``
+    audio part, say --- so its hints apply unless the part overrides them.
+
+    Raises :class:`RealtimeProtocolError` for an unsupported format, undecodable
+    audio or invalid camera frames.
+    """
+    event_id = cast("str", event.get("event_id")) if isinstance(event.get("event_id"), str) else None
+    audio = event.get("audio") or event.get("delta")
+    fmt, format_rate = parse_realtime_audio_format(
+        event.get("format") or event.get("input_audio_format") or defaults.input_audio_format
+    )
+    sample_rate_hz = (
+        event.get("sample_rate_hz") or event.get("sample_rate") or format_rate or defaults.input_sample_rate_hz
+    )
+    if not is_supported_realtime_input_format(fmt):
+        raise RealtimeProtocolError(
+            f"Unsupported input_audio_format: {fmt}",
+            code="unsupported_audio_format",
+            event_id=event_id,
+        )
+    try:
+        audio, fmt, sample_rate_hz = convert_input_audio_with_rate(
+            audio,
+            fmt,
+            sample_rate_hz=sample_rate_hz if isinstance(sample_rate_hz, int | float) else None,
+        )
+    except ValueError as exc:
+        raise RealtimeProtocolError(str(exc), code="bad_event", event_id=event_id) from exc
+    hints: dict[str, object] = {}
+    if hints_source is not None:
+        copy_realtime_input_hints(hints_source, hints)
+    copy_realtime_input_hints(event, hints)
+    looks_like_speech = input_looks_like_speech(
+        {**(hints_source or {}), **event},
+        audio=audio,
+        fmt=fmt,
+        overlap_silence_rms=defaults.overlap_silence_rms,
+    )
+    video_frames: tuple[str, ...] = ()
+    raw_frames = event.get("video_frames")
+    if raw_frames is not None:
+        frames_error = validate_realtime_video_frames(raw_frames, event.get("max_slice_nums"))
+        if frames_error is not None:
+            raise RealtimeProtocolError(frames_error, code="invalid_video_frames", event_id=event_id)
+        if isinstance(raw_frames, list):
+            video_frames = tuple(frame for frame in raw_frames if isinstance(frame, str) and frame)
+    duration_ms = hints.get("duration_ms", hints.get("audio_duration_ms"))
+    audio_end_ms = hints.get("audio_end_ms")
+    try:
+        audio_bytes = base64.b64decode(audio, validate=True) if isinstance(audio, str) and audio else b""
+    except (binascii.Error, ValueError) as exc:
+        raise RealtimeProtocolError("input audio is not valid base64", code="bad_audio", event_id=event_id) from exc
+    return RealtimeAudioAppend(
+        event_id=event_id,
+        audio=audio_bytes,
+        format=str(fmt),
+        sample_rate_hz=int(sample_rate_hz) if isinstance(sample_rate_hz, int | float) else None,
+        is_speech=looks_like_speech,
+        video_frames=video_frames,
+        duration_ms=int(duration_ms) if isinstance(duration_ms, int | float) else None,
+        audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else None,
+        hints=hints,
+    )
diff --git a/vllm_omni/protocol/realtime/capabilities.py b/vllm_omni/protocol/realtime/capabilities.py
new file mode 100644
index 000000000..658a57e56
--- /dev/null
+++ b/vllm_omni/protocol/realtime/capabilities.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""What a Realtime consumer can serve, and the session check that reads it.
+
+``session.update`` is the one client event whose acceptance depends on who is
+behind the socket. The audio formats a server can decode, and whether it can do
+server-side turn detection at all, are properties of the *consumer* --- the
+duplex engine, or some other runtime --- not of the protocol. The codec still
+has to do the checking, because it owns the error envelope and the order the
+checks run in.
+
+:class:`RealtimeProtocolCapabilities` is how a consumer states those answers.
+It is the post-#7413 form of the ``supports(turn_detection, formats)`` half of
+RFC #6592's proposed ``RealtimeModelAdapter``. The other three halves of that
+proposal --- building a prompt, starting a response, cancelling one --- are not
+here and must not come here: for a duplex model they are already owned by
+``DuplexModelPlugin`` together with ``DuplexSessionRunner``, and a second
+interface over the same responsibility is exactly the fork this layer exists to
+prevent.
+
+The duplex binding of this object is
+``vllm_omni.engine.duplex.realtime_commands.DUPLEX_REALTIME_CAPABILITIES``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+
+from vllm_omni.protocol.realtime.formats import (
+    REALTIME_INPUT_AUDIO_FORMATS,
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+    validate_realtime_session_audio_formats,
+)
+
+__all__ = [
+    "RealtimeProtocolCapabilities",
+    "RealtimeSessionRejection",
+    "validate_session_payload",
+]
+
+#: A consumer's answer to "can you do this turn detection?": an error message, or None.
+TurnDetectionValidator = Callable[[Mapping[str, object]], str | None]
+
+
+@dataclass(frozen=True, slots=True)
+class RealtimeProtocolCapabilities:
+    """One consumer's answer to what a ``session`` object may ask for.
+
+    The defaults are permissive, not restrictive: every format the codec can
+    decode, and **no turn-detection validation at all**. A consumer that leaves
+    ``validate_turn_detection`` at ``None`` therefore accepts whatever
+    ``turn_detection`` the session object carries --- including values it cannot
+    actually serve, such as ``semantic_vad``. A consumer that supports only some
+    turn-detection modes (or none) must supply its own validator; see
+    ``vllm_omni.engine.duplex.realtime_commands.DUPLEX_REALTIME_CAPABILITIES``.
+    """
+
+    input_audio_formats: frozenset[str] = field(default_factory=lambda: frozenset(REALTIME_INPUT_AUDIO_FORMATS))
+    output_audio_formats: frozenset[str] = field(default_factory=lambda: frozenset(REALTIME_OUTPUT_AUDIO_FORMATS))
+    #: Consumer-specific ``turn_detection`` validation. ``None`` means the
+    #: consumer takes whatever the session object says without a check of its own.
+    validate_turn_detection: TurnDetectionValidator | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class RealtimeSessionRejection:
+    """Why a session object was refused: the internal error code and the message.
+
+    ``param`` names the offending session field where there is one, for the
+    ``error.param`` slot of the OpenAI error envelope.
+    """
+
+    code: str
+    message: str
+    param: str | None = None
+
+
+def validate_session_payload(
+    session_payload: Mapping[str, object],
+    *,
+    capabilities: RealtimeProtocolCapabilities,
+) -> RealtimeSessionRejection | None:
+    """Check a ``session`` object against one consumer; ``None`` when it is acceptable.
+
+    Audio formats are checked before turn detection, so a session object that
+    is wrong in both ways reports the format problem --- keep that order, it is
+    what clients already see.
+    """
+    format_error = validate_realtime_session_audio_formats(
+        session_payload,
+        input_audio_formats=capabilities.input_audio_formats,
+        output_audio_formats=capabilities.output_audio_formats,
+    )
+    if format_error is not None:
+        return RealtimeSessionRejection(code="unsupported_audio_format", message=format_error)
+    validate_turn_detection = capabilities.validate_turn_detection
+    if validate_turn_detection is not None:
+        turn_detection_error = validate_turn_detection(session_payload)
+        if turn_detection_error is not None:
+            return RealtimeSessionRejection(
+                code="unsupported_turn_detection", message=turn_detection_error, param="turn_detection"
+            )
+    return None
diff --git a/vllm_omni/protocol/realtime/commands.py b/vllm_omni/protocol/realtime/commands.py
new file mode 100644
index 000000000..590f3ee93
--- /dev/null
+++ b/vllm_omni/protocol/realtime/commands.py
@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OpenAI Realtime client events as typed commands.
+
+A Realtime server's first job is turning a client JSON event into something
+typed. These are the 10 client events OpenAI's Realtime API defines, as frozen
+dataclasses carrying the fields that survive decoding.
+
+vLLM-Omni's own client events (barge-in, playback acknowledgement, text append,
+heartbeat, explicit close, generic turn signals) are a separate vocabulary in
+``vllm_omni.protocol.duplex.commands``.
+
+Decoding a payload *into* these stays with the consumer, because which command
+a given event becomes can depend on what that consumer supports --- see
+``vllm_omni.engine.duplex.realtime_commands.translate_realtime_command``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import ClassVar
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RealtimeCommand:
+    """One decoded OpenAI Realtime client event.
+
+    ``wire_type`` is the event type the client sent; the typed fields are what
+    survived decoding, so a consumer reads them instead of re-parsing JSON.
+
+    There is deliberately no rendering method here. A server receives commands,
+    it does not emit them, and how a runtime represents one internally is its
+    own business --- the duplex engine renders its mailbox dictionary in
+    ``vllm_omni.engine.duplex.commands``.
+    """
+
+    #: OpenAI Realtime client event this command decodes from.
+    wire_type: ClassVar[str] = ""
+    #: Client correlation id (OpenAI ``event_id``), echoed on error events.
+    event_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateSession(RealtimeCommand):
+    """``session.update``: a Realtime ``session`` object patch."""
+
+    wire_type: ClassVar[str] = "session.update"
+    patch: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AppendAudio(RealtimeCommand):
+    wire_type: ClassVar[str] = "input_audio_buffer.append"
+    #: Raw audio bytes in ``format`` at ``sample_rate_hz`` (base64 only on the wire).
+    audio: bytes
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Commit(RealtimeCommand):
+    wire_type: ClassVar[str] = "input_audio_buffer.commit"
+    final: bool = True
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ClearInput(RealtimeCommand):
+    wire_type: ClassVar[str] = "input_audio_buffer.clear"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ClearOutputAudio(RealtimeCommand):
+    wire_type: ClassVar[str] = "output_audio_buffer.clear"
+    #: Explicit response to clear; ``None`` targets the active/last response.
+    response_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateResponse(RealtimeCommand):
+    wire_type: ClassVar[str] = "response.create"
+    #: Raw Realtime ``response`` object (instructions, voice, modalities, ...).
+    options: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CancelResponse(RealtimeCommand):
+    wire_type: ClassVar[str] = "response.cancel"
+    response_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateItem(RealtimeCommand):
+    """``conversation.item.create`` (history injection or function-call output)."""
+
+    wire_type: ClassVar[str] = "conversation.item.create"
+    item: Mapping[str, object]
+    previous_item_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteItem(RealtimeCommand):
+    wire_type: ClassVar[str] = "conversation.item.delete"
+    item_id: str
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TruncateItem(RealtimeCommand):
+    wire_type: ClassVar[str] = "conversation.item.truncate"
+    item_id: str
+    audio_end_ms: int
+    content_index: int = 0
+
+
+__all__ = [
+    "AppendAudio",
+    "CancelResponse",
+    "ClearInput",
+    "ClearOutputAudio",
+    "Commit",
+    "CreateItem",
+    "CreateResponse",
+    "DeleteItem",
+    "RealtimeCommand",
+    "TruncateItem",
+    "UpdateSession",
+]
diff --git a/vllm_omni/protocol/realtime/errors.py b/vllm_omni/protocol/realtime/errors.py
new file mode 100644
index 000000000..f9ba67bf4
--- /dev/null
+++ b/vllm_omni/protocol/realtime/errors.py
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The OpenAI Realtime error envelope.
+
+A Realtime server reports a rejected client event as one ``error`` event whose
+``error`` object carries ``type`` / ``code`` / ``message`` (plus the client's
+``event_id`` and an optional ``param``). ``type`` is not free-form: it is one
+of OpenAI's four buckets, derived from our internal code by
+:data:`REALTIME_ERROR_TYPES_BY_CODE`.
+
+OpenAI standardises the three ``type`` classes but not the *codes*, so the code
+vocabulary is a consumer's own. vLLM-Omni's lives in
+``vllm_omni.protocol.duplex.errors`` (Tier 3 in
+``docs/serving/realtime_duplex_api.md``); what stays here is the exception type
+every consumer raises, so the envelope is rendered identically whoever built it.
+"""
+
+from __future__ import annotations
+
+__all__ = ["RealtimeProtocolError"]
+
+
+class RealtimeProtocolError(ValueError):
+    """A client payload could not be decoded into a valid Realtime intent.
+
+    ``code`` is the internal error code that :data:`REALTIME_ERROR_TYPES_BY_CODE`
+    maps to an OpenAI ``error.type``; ``event_id`` is the *client* event id the
+    error answers. ``vllm_omni.engine.duplex.commands.DuplexCommandError`` is
+    the duplex specialization, so a consumer catching either sees the same
+    three attributes.
+    """
+
+    def __init__(self, message: str, *, code: str = "bad_event", event_id: str | None = None) -> None:
+        super().__init__(message)
+        self.code = code
+        self.event_id = event_id
diff --git a/vllm_omni/protocol/realtime/events.py b/vllm_omni/protocol/realtime/events.py
new file mode 100644
index 000000000..47bab6372
--- /dev/null
+++ b/vllm_omni/protocol/realtime/events.py
@@ -0,0 +1,467 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OpenAI Realtime server events: typed classes and their wire rendering.
+
+Every event is a frozen dataclass with explicit fields, and the Realtime wire
+JSON is *derived* from those fields by :meth:`RealtimeEvent.to_realtime`. That
+rendering is pure --- it never consults session state --- which is why it can
+live here, away from whoever owns the session. The stateful part (response and
+item ids, content-part bookkeeping) is consumed when the events are
+*constructed*, by the consumer.
+
+This module holds the 30 events OpenAI's Realtime API defines. vLLM-Omni's own
+additions to the wire (listen/speak turn-taking, playback acknowledgement,
+session resume) are a separate vocabulary in
+``vllm_omni.protocol.duplex.events``, so a consumer that only speaks GA does
+not inherit them.
+
+``session_id`` / ``epoch`` are bound by the consumer when an event leaves it;
+producers build events with the defaults.
+"""
+
+from __future__ import annotations
+
+import base64
+from collections.abc import Mapping
+from dataclasses import dataclass, field, fields
+from typing import ClassVar
+from uuid import uuid4
+
+
+def new_event_id() -> str:
+    return f"event_{uuid4().hex}"
+
+
+_IDENTITY_FIELDS = frozenset({"session_id", "epoch", "event_id"})
+
+
+def wire_value(value: object) -> object:
+    if isinstance(value, Mapping):
+        return {str(k): wire_value(v) for k, v in value.items()}
+    if isinstance(value, tuple | list):
+        return [wire_value(v) for v in value]
+    return value
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RealtimeEvent:
+    """Base of every public session event."""
+
+    #: Realtime ``type`` this class renders to.
+    wire_type: ClassVar[str] = ""
+    #: Fields that are omitted from the wire object when ``None``.
+    optional_wire_fields: ClassVar[frozenset[str]] = frozenset()
+
+    session_id: str = ""
+    epoch: int | None = None
+    #: Server event id (OpenAI ``event_id``); generated at construction.
+    event_id: str = field(default_factory=new_event_id)
+
+    # ---- identity ----
+
+    @property
+    def type(self) -> str:
+        return self.wire_type
+
+    @property
+    def is_terminal(self) -> bool:
+        return False
+
+    # ---- generic accessors (None when the class has no such field) ----
+
+    @property
+    def response_id(self) -> str | None:
+        return None
+
+    @property
+    def item_id(self) -> str | None:
+        return None
+
+    @property
+    def text(self) -> str | None:
+        return None
+
+    @property
+    def audio(self) -> bytes | None:
+        return None
+
+    # ---- wire rendering (pure) ----
+
+    def _wire_fields(self) -> dict[str, object]:
+        data: dict[str, object] = {}
+        for f in fields(self):
+            if f.name in _IDENTITY_FIELDS:
+                continue
+            value = getattr(self, f.name)
+            if value is None and f.name in self.optional_wire_fields:
+                continue
+            data[f.name] = wire_value(value)
+        return data
+
+    def to_realtime(self) -> dict[str, object]:
+        """The Realtime wire JSON object for this event (derived from the fields)."""
+        return {"type": self.wire_type, "event_id": self.event_id, **self._wire_fields()}
+
+    def __repr__(self) -> str:  # pragma: no cover - debugging aid
+        return f"{type(self).__name__}(type={self.wire_type!r}, session_id={self.session_id!r}, epoch={self.epoch!r})"
+
+
+# ---- shared bases ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResponseScopedEvent(RealtimeEvent):
+    """Events addressed to one response (and usually one output item / content part)."""
+
+    response_id: str | None = None  # type: ignore[assignment]
+    item_id: str | None = None  # type: ignore[assignment]
+    output_index: int = 0
+    content_index: int = 0
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _ItemEvent(RealtimeEvent):
+    previous_item_id: str | None = None
+    item: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def item_id(self) -> str | None:
+        value = self.item.get("id")
+        return value if isinstance(value, str) else None
+
+
+# ---- GA server events ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionCreated(RealtimeEvent):
+    wire_type = "session.created"
+
+    session: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SessionUpdated(RealtimeEvent):
+    wire_type = "session.updated"
+
+    session: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResponseCreated(RealtimeEvent):
+    wire_type = "response.created"
+
+    response: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class OutputItemAdded(RealtimeEvent):
+    wire_type = "response.output_item.added"
+
+    response_id: str | None = None  # type: ignore[assignment]
+    output_index: int = 0
+    item: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def item_id(self) -> str | None:
+        value = self.item.get("id")
+        return value if isinstance(value, str) else None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class OutputItemDone(OutputItemAdded):
+    wire_type = "response.output_item.done"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ContentPartAdded(ResponseScopedEvent):
+    wire_type = "response.content_part.added"
+
+    part: Mapping[str, object] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ContentPartDone(ContentPartAdded):
+    wire_type = "response.content_part.done"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AudioDelta(ResponseScopedEvent):
+    wire_type = "response.output_audio.delta"
+
+    #: Base64 audio in ``format``.
+    delta: str = ""
+
+    @property
+    def audio(self) -> bytes | None:
+        try:
+            return base64.b64decode(self.delta)
+        except (ValueError, TypeError):
+            return None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AudioDone(ResponseScopedEvent):
+    wire_type = "response.output_audio.done"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TranscriptDelta(ResponseScopedEvent):
+    wire_type = "response.output_audio_transcript.delta"
+
+    delta: str = ""
+
+    @property
+    def text(self) -> str | None:
+        return self.delta
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TranscriptDone(ResponseScopedEvent):
+    wire_type = "response.output_audio_transcript.done"
+
+    transcript: str = ""
+
+    @property
+    def text(self) -> str | None:
+        return self.transcript
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TextDelta(ResponseScopedEvent):
+    wire_type = "response.output_text.delta"
+
+    delta: str = ""
+
+    @property
+    def text(self) -> str | None:
+        return self.delta
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TextDone(ResponseScopedEvent):
+    wire_type = "response.output_text.done"
+
+    text: str = ""  # type: ignore[assignment]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FunctionCallArgumentsDelta(RealtimeEvent):
+    wire_type = "response.function_call_arguments.delta"
+
+    response_id: str | None = None  # type: ignore[assignment]
+    item_id: str | None = None  # type: ignore[assignment]
+    output_index: int = 0
+    call_id: str = ""
+    delta: str = ""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FunctionCallArgumentsDone(RealtimeEvent):
+    wire_type = "response.function_call_arguments.done"
+
+    response_id: str | None = None  # type: ignore[assignment]
+    item_id: str | None = None  # type: ignore[assignment]
+    output_index: int = 0
+    call_id: str = ""
+    arguments: str = ""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResponseDone(RealtimeEvent):
+    wire_type = "response.done"
+
+    response: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def status(self) -> str | None:
+        value = self.response.get("status")
+        return value if isinstance(value, str) else None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RateLimitsUpdated(RealtimeEvent):
+    wire_type = "rate_limits.updated"
+
+    rate_limits: tuple[Mapping[str, object], ...] = ()
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class InputCommitted(RealtimeEvent):
+    wire_type = "input_audio_buffer.committed"
+
+    previous_item_id: str | None = None
+    item_id: str | None = None  # type: ignore[assignment]
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"previous_item_id": self.previous_item_id, "item_id": self.item_id}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class InputCleared(RealtimeEvent):
+    wire_type = "input_audio_buffer.cleared"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SpeechStarted(RealtimeEvent):
+    wire_type = "input_audio_buffer.speech_started"
+
+    audio_start_ms: int = 0
+    item_id: str | None = None  # type: ignore[assignment]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SpeechStopped(RealtimeEvent):
+    wire_type = "input_audio_buffer.speech_stopped"
+
+    audio_end_ms: int = 0
+    item_id: str | None = None  # type: ignore[assignment]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemAdded(_ItemEvent):
+    wire_type = "conversation.item.added"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemCreated(_ItemEvent):
+    wire_type = "conversation.item.created"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemDone(_ItemEvent):
+    wire_type = "conversation.item.done"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemRetrieved(RealtimeEvent):
+    wire_type = "conversation.item.retrieved"
+
+    item: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def item_id(self) -> str | None:
+        value = self.item.get("id")
+        return value if isinstance(value, str) else None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemDeleted(RealtimeEvent):
+    wire_type = "conversation.item.deleted"
+
+    item_id: str | None = None  # type: ignore[assignment]
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"item_id": self.item_id}
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ItemTruncated(RealtimeEvent):
+    wire_type = "conversation.item.truncated"
+
+    item_id: str | None = None  # type: ignore[assignment]
+    content_index: int = 0
+    audio_end_ms: int = 0
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {
+            "item_id": self.item_id,
+            "content_index": self.content_index,
+            "audio_end_ms": self.audio_end_ms,
+        }
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class InputTranscriptionCompleted(RealtimeEvent):
+    wire_type = "conversation.item.input_audio_transcription.completed"
+
+    item_id: str | None = None  # type: ignore[assignment]
+    content_index: int = 0
+    transcript: str = ""
+
+    @property
+    def text(self) -> str | None:
+        return self.transcript
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class OutputAudioCleared(RealtimeEvent):
+    wire_type = "output_audio_buffer.cleared"
+
+    response_id: str | None = None  # type: ignore[assignment]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ErrorEvent(RealtimeEvent):
+    wire_type = "error"
+
+    code: str = "internal_error"
+    message: str = ""
+    #: Client ``event_id`` this error answers (OpenAI ``error.event_id``).
+    related_event_id: str | None = None
+    param: str | None = None
+
+    @property
+    def error_type(self) -> str:
+        """OpenAI's error class for this error.
+
+        OpenAI standardises only the three classes, not the codes, so the base
+        reports the default. A consumer with its own code vocabulary overrides
+        this --- see ``vllm_omni.protocol.duplex.events.ErrorEvent``.
+        """
+        return "invalid_request_error"
+
+    @property
+    def error(self) -> dict[str, object]:
+        error: dict[str, object] = {"type": self.error_type, "code": self.code, "message": self.message}
+        if self.related_event_id:
+            error["event_id"] = self.related_event_id
+        if self.param:
+            error["param"] = self.param
+        return error
+
+    @property
+    def text(self) -> str | None:
+        return self.message
+
+    def _wire_fields(self) -> dict[str, object]:
+        return {"error": self.error}
+
+
+__all__ = [
+    "AudioDelta",
+    "AudioDone",
+    "ContentPartAdded",
+    "ContentPartDone",
+    "ErrorEvent",
+    "FunctionCallArgumentsDelta",
+    "FunctionCallArgumentsDone",
+    "InputCleared",
+    "InputCommitted",
+    "InputTranscriptionCompleted",
+    "ItemAdded",
+    "ItemCreated",
+    "ItemDeleted",
+    "ItemDone",
+    "ItemRetrieved",
+    "ItemTruncated",
+    "OutputAudioCleared",
+    "OutputItemAdded",
+    "OutputItemDone",
+    "RateLimitsUpdated",
+    "RealtimeEvent",
+    "ResponseCreated",
+    "ResponseDone",
+    "ResponseScopedEvent",
+    "SessionCreated",
+    "SessionUpdated",
+    "SpeechStarted",
+    "SpeechStopped",
+    "TextDelta",
+    "TextDone",
+    "TranscriptDelta",
+    "TranscriptDone",
+    "new_event_id",
+    "wire_value",
+]
diff --git a/vllm_omni/protocol/realtime/formats.py b/vllm_omni/protocol/realtime/formats.py
new file mode 100644
index 000000000..161aab11b
--- /dev/null
+++ b/vllm_omni/protocol/realtime/formats.py
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Realtime audio-format negotiation: what a client may declare and how it is read.
+
+A Realtime client declares audio formats in three places --- the session object
+(``session.audio.input.format`` and the older flat ``input_audio_format``), a
+``response.create`` override, and a ``conversation.item.create`` audio part ---
+and may spell one format several ways (``audio/pcm``, ``pcm16``, ``s16le``).
+This module is the single place that normalizes those spellings and says which
+are supported. Folding a session's declaration into the per-connection append
+defaults is the job of ``session.py``, which builds on this module.
+
+Everything here is a pure function of wire payloads: no session state, no model,
+no engine.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Collection, Mapping
+
+__all__ = [
+    "REALTIME_INPUT_AUDIO_FORMATS",
+    "REALTIME_OUTPUT_AUDIO_FORMATS",
+    "is_supported_realtime_input_format",
+    "parse_realtime_audio_format",
+    "realtime_audio_format_object",
+    "realtime_output_format",
+    "validate_conversation_item_audio_formats",
+    "validate_realtime_response_audio_formats",
+    "validate_realtime_session_audio_formats",
+]
+
+REALTIME_INPUT_AUDIO_FORMATS = {
+    "pcm16",
+    "pcm_s16le",
+    "s16le",
+    "pcm_f32le",
+    "g711_ulaw",
+    "g711_alaw",
+}
+REALTIME_OUTPUT_AUDIO_FORMATS = {
+    "pcm16",
+    "pcm_s16le",
+    "s16le",
+    "wav",
+    "pcm",
+    "g711_ulaw",
+    "g711_alaw",
+}
+
+
+def parse_realtime_audio_format(raw_format: object) -> tuple[object, int | None]:
+    def normalize_format(fmt: str) -> str:
+        normalized = fmt.lower()
+        if normalized in {"audio/pcm", "pcm"}:
+            return "pcm16"
+        if normalized in {"audio/wav", "wav"}:
+            return "wav"
+        if normalized in {"audio/pcm16", "pcm16", "pcm_s16le", "s16le"}:
+            return "pcm16"
+        if normalized in {"audio/pcm_f32le", "pcm_f32le", "f32le"}:
+            return "pcm_f32le"
+        if normalized in {"audio/g711_ulaw", "g711_ulaw", "g711-ulaw", "ulaw", "mulaw"}:
+            return "g711_ulaw"
+        if normalized in {"audio/g711_alaw", "g711_alaw", "g711-alaw", "alaw"}:
+            return "g711_alaw"
+        return fmt
+
+    if isinstance(raw_format, str):
+        return normalize_format(raw_format), None
+    if not isinstance(raw_format, dict):
+        return raw_format, None
+    rate = raw_format.get("rate") or raw_format.get("sample_rate_hz") or raw_format.get("sample_rate")
+    sample_rate_hz = int(rate) if isinstance(rate, int | float) and rate > 0 else None
+    fmt = raw_format.get("type") or raw_format.get("format")
+    if not isinstance(fmt, str):
+        return raw_format, sample_rate_hz
+    return normalize_format(fmt), sample_rate_hz
+
+
+def realtime_output_format(duplex_format: object) -> str:
+    if isinstance(duplex_format, str) and duplex_format.lower() in {"g711_ulaw", "g711_alaw"}:
+        return duplex_format.lower()
+    if isinstance(duplex_format, str) and duplex_format.lower() == "pcm":
+        return "pcm16"
+    return str(duplex_format or "wav")
+
+
+def is_supported_realtime_input_format(fmt: object) -> bool:
+    return isinstance(fmt, str) and fmt.lower() in REALTIME_INPUT_AUDIO_FORMATS
+
+
+def realtime_audio_format_object(fmt: object, *, sample_rate_hz: int | None = None) -> dict[str, object]:
+    if isinstance(fmt, str) and fmt.lower() in {"pcm16", "pcm_s16le", "s16le", "pcm"}:
+        payload: dict[str, object] = {"type": "audio/pcm"}
+    elif isinstance(fmt, str) and fmt.lower() == "pcm_f32le":
+        payload = {"type": "audio/pcm_f32le"}
+    elif isinstance(fmt, str) and fmt.lower() == "g711_ulaw":
+        payload = {"type": "audio/g711_ulaw"}
+    elif isinstance(fmt, str) and fmt.lower() == "g711_alaw":
+        payload = {"type": "audio/g711_alaw"}
+    else:
+        payload = {"type": "audio/wav"}
+    if sample_rate_hz is not None:
+        payload["rate"] = int(sample_rate_hz)
+    return payload
+
+
+def validate_realtime_session_audio_formats(
+    session_payload: Mapping[str, object],
+    *,
+    input_audio_formats: Collection[str] | None = None,
+    output_audio_formats: Collection[str] | None = None,
+) -> str | None:
+    """Reject a session object that declares an audio format we cannot serve.
+
+    The format sets default to everything the codec can decode; a consumer that
+    serves a narrower set passes its own (see
+    ``vllm_omni.protocol.realtime.capabilities``).
+    """
+    supported_input = REALTIME_INPUT_AUDIO_FORMATS if input_audio_formats is None else input_audio_formats
+    supported_output = REALTIME_OUTPUT_AUDIO_FORMATS if output_audio_formats is None else output_audio_formats
+    audio_config = session_payload.get("audio")
+    input_format: object = session_payload.get("input_audio_format")
+    if input_format is None and isinstance(audio_config, dict):
+        audio_input = audio_config.get("input")
+        if isinstance(audio_input, dict):
+            input_format = audio_input.get("format")
+    parsed_input, _ = parse_realtime_audio_format(input_format)
+    if input_format is not None and not (isinstance(parsed_input, str) and parsed_input.lower() in supported_input):
+        return f"Unsupported input_audio_format: {input_format}"
+
+    output_format: object = session_payload.get("output_audio_format") or session_payload.get("response_format")
+    if output_format is None and isinstance(audio_config, dict):
+        audio_output = audio_config.get("output")
+        if isinstance(audio_output, dict):
+            output_format = audio_output.get("format")
+    parsed_output, _ = parse_realtime_audio_format(output_format)
+    if output_format is not None and not (isinstance(parsed_output, str) and parsed_output.lower() in supported_output):
+        return f"Unsupported output_audio_format: {output_format}"
+    return None
+
+
+def validate_realtime_response_audio_formats(response_payload: Mapping[str, object]) -> str | None:
+    output_format: object = response_payload.get("output_audio_format") or response_payload.get("response_format")
+    audio_config = response_payload.get("audio")
+    if output_format is None and isinstance(audio_config, dict):
+        audio_output = audio_config.get("output")
+        if isinstance(audio_output, dict):
+            output_format = audio_output.get("format")
+    parsed_output, _ = parse_realtime_audio_format(output_format)
+    if output_format is not None and not (
+        isinstance(parsed_output, str) and parsed_output.lower() in REALTIME_OUTPUT_AUDIO_FORMATS
+    ):
+        return f"Unsupported output_audio_format: {output_format}"
+    return None
+
+
+def validate_conversation_item_audio_formats(item: object) -> str | None:
+    if not isinstance(item, dict):
+        return None
+    content = item.get("content")
+    if not isinstance(content, list):
+        return None
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        if part.get("type") not in {"input_audio", "audio"}:
+            continue
+        raw_format = part.get("format")
+        parsed_format, _ = parse_realtime_audio_format(raw_format)
+        if raw_format is not None and not (
+            isinstance(parsed_format, str) and parsed_format.lower() in REALTIME_INPUT_AUDIO_FORMATS
+        ):
+            return f"Unsupported input_audio format in conversation.item.create: {raw_format}"
+    return None
diff --git a/vllm_omni/protocol/realtime/items.py b/vllm_omni/protocol/realtime/items.py
new file mode 100644
index 000000000..cbcb9c652
--- /dev/null
+++ b/vllm_omni/protocol/realtime/items.py
@@ -0,0 +1,197 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Realtime conversation items: shape, truncation and the transcript inside one.
+
+A Realtime conversation is a list of *items* --- a user message, an assistant
+message, a function call --- each with a ``content`` list of typed parts. The
+client creates them (``conversation.item.create``), truncates an assistant
+item's audio after a barge-in (``conversation.item.truncate``), and the server
+echoes them back inside ``conversation.item.*`` and ``response.done`` events.
+
+The rules in this module are the ones both sides have to agree on: which
+defaults a bare item gets, how far a transcript is cut when the client says it
+only heard N milliseconds of audio, and what makes a truncate request invalid.
+Item *storage* --- which items a session currently holds, in what order --- is
+the consumer's state, not this module's.
+
+``validate_realtime_video_frames`` sits here too: camera frames ride along an
+``input_audio_buffer.append`` in the vLLM-Omni extension of the protocol, and
+validating them is the same kind of wire-shape check.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+from collections.abc import Mapping
+from uuid import uuid4
+
+__all__ = [
+    "input_transcript_from_item",
+    "normalize_conversation_item",
+    "text_chars_for_audio_ms_from_marks",
+    "truncate_realtime_item_content",
+    "validate_realtime_item_truncate",
+    "validate_realtime_video_frames",
+]
+
+
+def validate_realtime_video_frames(video_frames: object, max_slice_nums: object) -> str | None:
+    """Validate omni-duplex camera frames on input_audio_buffer.append.
+
+    Wire contract matches the official MiniCPM-o duplex loop: one base
+    base64 JPEG per ~1 s audio chunk, optionally followed by that unit's
+    stacked composite tiling the sub-frames captured inside it (at most 2
+    images either way). A caller-supplied ``max_slice_nums`` is rejected rather
+    than silently ignored: slicing is Stage 0's decision here, and Stage 0
+    already applies the official HD suggestion for a stacked unit
+    (``max_slice_nums=[2, 1]``). The wire simply does not let the client choose
+    it.
+    """
+    if max_slice_nums not in (None, 1):
+        return "max_slice_nums is not selectable on the wire; Stage0 slices stacked units itself"
+    if not isinstance(video_frames, list):
+        return "video_frames must be a list of base64-encoded images"
+    frames = [frame for frame in video_frames if frame is not None]
+    if len(frames) > 2:
+        return "video_frames carries more than 2 frames for one append; send ~1 frame per 1 s chunk"
+    for frame in frames:
+        if not isinstance(frame, str) or not frame:
+            return "video_frames entries must be non-empty base64 strings"
+        if len(frame) > 4_000_000:
+            return "video_frames entry exceeds 4MB base64; reduce capture resolution or JPEG quality"
+        try:
+            header = base64.b64decode(frame[:64] + "=" * (-len(frame[:64]) % 4))
+        except (binascii.Error, ValueError):
+            return "video_frames entries must be valid base64"
+        if not (header.startswith(b"\xff\xd8") or header.startswith(b"\x89PNG")):
+            return "video_frames entries must be JPEG or PNG images"
+    return None
+
+
+def normalize_conversation_item(item: Mapping[str, object]) -> dict[str, object]:
+    normalized = dict(item)
+    normalized.setdefault("id", f"item_{uuid4().hex}")
+    normalized.setdefault("object", "realtime.item")
+    normalized.setdefault("type", "message")
+    normalized.setdefault("status", "completed")
+    if "role" not in normalized and normalized.get("type") == "message":
+        normalized["role"] = "user"
+    if not isinstance(normalized.get("content"), list):
+        normalized["content"] = []
+    return normalized
+
+
+def text_chars_for_audio_ms_from_marks(
+    audio_end_ms: int,
+    text_len: int,
+    marks: list[object],
+    *,
+    final_ms: object | None = None,
+) -> int:
+    if text_len <= 0:
+        return 0
+    clean_marks: list[tuple[int, int]] = []
+    for mark in marks:
+        if not isinstance(mark, dict):
+            continue
+        raw_text_chars = mark.get("text_chars")
+        raw_audio_end_ms = mark.get("audio_end_ms", mark.get("audio_ms"))
+        if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
+            continue
+        clean_marks.append((max(0, int(raw_audio_end_ms)), min(text_len, max(0, int(raw_text_chars)))))
+    if not clean_marks:
+        return 0 if audio_end_ms <= 0 else text_len
+    clean_marks.sort(key=lambda item: item[0])
+    audio_end_ms = max(0, int(audio_end_ms))
+    if audio_end_ms <= 0:
+        return 0
+    previous_ms = 0
+    previous_chars = 0
+    for mark_ms, mark_chars in clean_marks:
+        mark_ms = max(previous_ms, mark_ms)
+        mark_chars = max(previous_chars, min(text_len, mark_chars))
+        if audio_end_ms <= mark_ms:
+            if mark_ms <= previous_ms:
+                return mark_chars
+            ratio = (audio_end_ms - previous_ms) / max(1, mark_ms - previous_ms)
+            return int(previous_chars + (mark_chars - previous_chars) * max(0.0, min(1.0, ratio)))
+        previous_ms = mark_ms
+        previous_chars = mark_chars
+    if isinstance(final_ms, int | float) and int(final_ms) > previous_ms:
+        if audio_end_ms >= int(final_ms):
+            return text_len
+        ratio = (audio_end_ms - previous_ms) / max(1, int(final_ms) - previous_ms)
+        return int(previous_chars + (text_len - previous_chars) * max(0.0, min(1.0, ratio)))
+    return text_len if audio_end_ms >= previous_ms else previous_chars
+
+
+def truncate_realtime_item_content(item: dict[str, object], *, content_index: int, audio_end_ms: int) -> None:
+    content = item.get("content")
+    if not isinstance(content, list) or not content:
+        return
+    index = max(0, int(content_index))
+    if index >= len(content):
+        return
+    part = content[index]
+    if not isinstance(part, dict):
+        return
+    transcript = part.get("transcript")
+    if not isinstance(transcript, str) or not transcript:
+        return
+    marks = part.get("audio_text_marks")
+    if isinstance(marks, list):
+        keep_chars = text_chars_for_audio_ms_from_marks(
+            audio_end_ms,
+            len(transcript),
+            marks,
+            final_ms=part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms"),
+        )
+        part["transcript"] = transcript[:keep_chars].rstrip()
+        return
+    duration_ms = part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms")
+    if isinstance(duration_ms, int | float) and duration_ms > 0:
+        keep_chars = int(len(transcript) * max(0.0, min(1.0, int(audio_end_ms) / float(duration_ms))))
+        part["transcript"] = transcript[:keep_chars].rstrip()
+    elif audio_end_ms <= 0:
+        part["transcript"] = ""
+
+
+def validate_realtime_item_truncate(item: Mapping[str, object], *, content_index: int, audio_end_ms: int) -> str | None:
+    if item.get("type") != "message" or item.get("role") != "assistant":
+        return "conversation.item.truncate only supports assistant message items"
+    if audio_end_ms < 0:
+        return "conversation.item.truncate requires non-negative audio_end_ms"
+    content = item.get("content")
+    if not isinstance(content, list) or not content:
+        return None
+    index = max(0, int(content_index))
+    if index >= len(content):
+        return f"conversation.item.truncate content_index out of range: {content_index}"
+    part = content[index]
+    if not isinstance(part, dict):
+        return "conversation.item.truncate target content part is invalid"
+    if part.get("type") not in {"audio", "output_audio"}:
+        return "conversation.item.truncate target content part must be audio"
+    duration_ms = part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms")
+    if isinstance(duration_ms, int | float) and int(duration_ms) >= 0 and audio_end_ms > int(duration_ms):
+        return "conversation.item.truncate audio_end_ms exceeds item audio duration"
+    return None
+
+
+def input_transcript_from_item(item: Mapping[str, object]) -> str:
+    content = item.get("content")
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        for key in ("transcript", "text"):
+            value = part.get(key)
+            if isinstance(value, str) and value:
+                if part.get("type") in {"input_audio", "audio", "audio_transcript", "transcript"}:
+                    parts.append(value)
+                    break
+    return "".join(parts).strip()
diff --git a/vllm_omni/protocol/realtime/session.py b/vllm_omni/protocol/realtime/session.py
new file mode 100644
index 000000000..1c73ea926
--- /dev/null
+++ b/vllm_omni/protocol/realtime/session.py
@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Reading the Realtime ``session`` object.
+
+``session.update`` carries one JSON object that a client may spell in either of
+two shapes: the GA nest (``session.audio.input.format``,
+``session.audio.output.sample_rate_hz``) or the older flat beta keys
+(``input_audio_format``, ``sample_rate_hz``). Everything downstream --- the
+append decoder, the projection that renders ``session.created`` back out, a
+model's runtime configuration --- has to agree on what a given session object
+means, so the readers live here once.
+
+:class:`RealtimeInputDefaults` is the resolved answer for the input path: the
+format, sample rate and silence threshold an ``input_audio_buffer.append``
+inherits when it omits them. A connection keeps one of these and re-derives it
+on every ``session.update``.
+
+``overlap_policy`` / ``playback_commit_policy`` are vLLM-Omni extension fields
+on the session object rather than GA OpenAI fields. They are read here because
+this module owns what the wire may say; what a server *does* with them is the
+consumer's business.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+from typing import Any
+
+from vllm_omni.protocol.realtime.formats import (
+    REALTIME_INPUT_AUDIO_FORMATS,
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+    parse_realtime_audio_format,
+    realtime_output_format,
+)
+
+__all__ = [
+    "RealtimeInputDefaults",
+    "apply_realtime_session_defaults",
+    "input_audio_transcription_config",
+    "json_safe_realtime_payload",
+    "realtime_max_output_tokens",
+    "realtime_overlap_fields",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class RealtimeInputDefaults:
+    """Session-level wire defaults an append may omit (derived from the session object)."""
+
+    input_audio_format: str = "pcm16"
+    input_sample_rate_hz: int = 16000
+    output_audio_format: str = "pcm16"
+    output_sample_rate_hz: int | None = None
+    overlap_silence_rms: float = 0.003
+
+    def with_session_payload(self, session_payload: Mapping[str, object]) -> RealtimeInputDefaults:
+        """Return defaults updated from a Realtime ``session`` object (session.update)."""
+        values = apply_realtime_session_defaults(self, session_payload)
+        return values
+
+
+def apply_realtime_session_defaults(
+    defaults: RealtimeInputDefaults,
+    session_payload: Mapping[str, object],
+) -> RealtimeInputDefaults:
+    """Derive the wire defaults a Realtime ``session`` object declares."""
+    input_format: object = session_payload.get("input_audio_format")
+    audio_config = session_payload.get("audio")
+    if input_format is None and isinstance(audio_config, dict):
+        audio_input = audio_config.get("input")
+        if isinstance(audio_input, dict):
+            input_format = audio_input.get("format")
+    input_format, input_rate = parse_realtime_audio_format(input_format)
+    # Any: heterogeneous field values splatted into ``dataclasses.replace`` below.
+    updates: dict[str, Any] = {}
+    if isinstance(input_format, str) and input_format.lower() in REALTIME_INPUT_AUDIO_FORMATS:
+        updates["input_audio_format"] = input_format
+    output_format: object = session_payload.get("output_audio_format") or session_payload.get("response_format")
+    output_rate_raw: object | None = None
+    if output_format is None and isinstance(audio_config, dict):
+        audio_output = audio_config.get("output")
+        if isinstance(audio_output, dict):
+            output_format = audio_output.get("format")
+            output_rate_raw = audio_output.get("sample_rate_hz") or audio_output.get("sample_rate")
+    output_format, output_rate = parse_realtime_audio_format(output_format)
+    if output_rate is None and isinstance(output_rate_raw, int | float) and output_rate_raw > 0:
+        output_rate = int(output_rate_raw)
+    if isinstance(output_format, str) and output_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
+        updates["output_audio_format"] = realtime_output_format(output_format)
+    sample_rate = session_payload.get("sample_rate_hz") or session_payload.get("sample_rate")
+    if sample_rate is None and isinstance(audio_config, dict):
+        audio_input = audio_config.get("input")
+        if isinstance(audio_input, dict):
+            sample_rate = audio_input.get("sample_rate_hz") or audio_input.get("sample_rate")
+    if sample_rate is None:
+        sample_rate = input_rate
+    if isinstance(sample_rate, int | float) and sample_rate > 0:
+        updates["input_sample_rate_hz"] = int(sample_rate)
+    if isinstance(output_rate, int | float) and output_rate > 0:
+        updates["output_sample_rate_hz"] = int(output_rate)
+    overlap_fields = realtime_overlap_fields(session_payload)
+    overlap_silence_rms = overlap_fields.get("overlap_silence_rms")
+    if isinstance(overlap_silence_rms, int | float):
+        updates["overlap_silence_rms"] = max(0.0, float(overlap_silence_rms))
+    return replace(defaults, **updates) if updates else defaults
+
+
+def realtime_overlap_fields(session_payload: Mapping[str, object]) -> dict[str, object]:
+    fields: dict[str, object] = {}
+    if isinstance(session_payload.get("overlap_policy"), str):
+        fields["overlap_policy"] = session_payload["overlap_policy"]
+    for key in ("overlap_short_ack_ms", "overlap_barge_in_ms", "overlap_silence_rms"):
+        value = session_payload.get(key)
+        if isinstance(value, int | float):
+            fields[key] = value
+    if isinstance(session_payload.get("playback_commit_policy"), str):
+        fields["playback_commit_policy"] = session_payload["playback_commit_policy"]
+    return fields
+
+
+def json_safe_realtime_payload(payload: Mapping[str, object]) -> dict[str, object]:
+    clean: dict[str, object] = {}
+    for key, value in payload.items():
+        if key == "extra_body":
+            continue
+        if isinstance(value, str | int | float | bool) or value is None:
+            clean[key] = value
+        elif isinstance(value, dict):
+            clean[key] = json_safe_realtime_payload(value)
+        elif isinstance(value, list):
+            clean[key] = [
+                (json_safe_realtime_payload(item) if isinstance(item, dict) else item)
+                for item in value
+                if isinstance(item, str | int | float | bool | dict) or item is None
+            ]
+    return clean
+
+
+def input_audio_transcription_config(session_payload: Mapping[str, object]) -> dict[str, object] | None:
+    transcription = session_payload.get("input_audio_transcription")
+    if isinstance(transcription, dict):
+        return transcription
+    audio_config = session_payload.get("audio")
+    if not isinstance(audio_config, dict):
+        return None
+    audio_input = audio_config.get("input")
+    if not isinstance(audio_input, dict):
+        return None
+    transcription = audio_input.get("transcription")
+    return transcription if isinstance(transcription, dict) else None
+
+
+def realtime_max_output_tokens(value: object) -> int | None:
+    """Normalize Realtime max output tokens (``"inf"`` -> ``None``)."""
+    if value is None:
+        return None
+    if isinstance(value, str) and value.strip().lower() in {"inf", "infinity", "unlimited"}:
+        return None
+    if isinstance(value, int) and value > 0:
+        return int(value)
+    return None
diff --git a/vllm_omni/quantization/factory.py b/vllm_omni/quantization/factory.py
index 8f15aaf50..c0975f651 100644
--- a/vllm_omni/quantization/factory.py
+++ b/vllm_omni/quantization/factory.py
@@ -446,6 +446,33 @@ def _disk_marks_serialized(qc_kwargs: dict[str, Any], quant_config: object) -> b
     return False
 
 
+_MXFP4_SERIALIZED_FLAGS = {
+    "mxfp4": "is_checkpoint_mxfp4_serialized",
+    "mxfp4_dualscale": "is_checkpoint_serialized",
+}
+
+
+def _normalize_serialized_mxfp4_layer_policy(qc_method: str, qc_kwargs: dict[str, Any]) -> None:
+    """Canonicalize the BF16 layer policy owned by serialized MXFP4 metadata.
+
+    A serialized checkpoint config is a complete storage contract: an omitted
+    layer list means no explicit BF16 layers. Method-only online metadata does
+    not carry that contract and must leave caller-provided layer policy intact.
+    """
+    method = _normalize_quant_method_alias(qc_method)
+    if method is None:
+        return
+    serialized_flag = _MXFP4_SERIALIZED_FLAGS.get(method)
+    if serialized_flag is None or not qc_kwargs.get(serialized_flag):
+        return
+
+    ignored_layers = qc_kwargs.get("ignored_layers")
+    if not ignored_layers:
+        ignored_layers = qc_kwargs.get("modules_to_not_convert")
+    qc_kwargs["ignored_layers"] = ignored_layers or []
+    qc_kwargs.pop("modules_to_not_convert", None)
+
+
 def resolve_quant_config_from_disk(
     quant_config: QuantizationConfig | None,
     disk_qc: dict[str, Any] | str | None,
@@ -460,22 +487,24 @@ def resolve_quant_config_from_disk(
       - quant_config is None: auto-detect from disk_qc (full build).
       - Methods mismatch: raise ValueError — prevents silent weight corruption.
       - Disk marks serialized but quant_config is online: rebuild from disk.
-      - ignored_layers differ: rebuild from disk (per-transformer BF16 routing).
+      - Serialized MXFP4 metadata owns the complete BF16 layer policy; omitted
+        ignored_layers means the checkpoint default (no explicit BF16 layers).
+      - Method-only metadata carries no storage policy and preserves caller
+        ignored_layers and runtime fallback policies.
     """
     if disk_qc is None:
         return quant_config
 
     if isinstance(disk_qc, str):
-        if quant_config is None:
-            logger.info("Auto-detected quantization from config.json: method=%s", disk_qc)
-            return build_quant_config(disk_qc)
-        return quant_config
+        qc_method = disk_qc
+        qc_kwargs: dict[str, Any] = {}
+    else:
+        if not isinstance(disk_qc, Mapping) or "quant_method" not in disk_qc:
+            return quant_config
+        qc_method = disk_qc["quant_method"]
+        qc_kwargs = {k: v for k, v in disk_qc.items() if k != "quant_method"}
 
-    if not isinstance(disk_qc, Mapping) or "quant_method" not in disk_qc:
-        return quant_config
-
-    qc_method: str = disk_qc["quant_method"]
-    qc_kwargs: dict[str, Any] = {k: v for k, v in disk_qc.items() if k != "quant_method"}
+    _normalize_serialized_mxfp4_layer_policy(qc_method, qc_kwargs)
 
     if quant_config is None:
         logger.info(
@@ -494,6 +523,26 @@ def resolve_quant_config_from_disk(
             "Pass a matching --quantization flag or omit it for auto-detection."
         )
 
+    if isinstance(disk_qc, str):
+        return quant_config
+
+    # Serialized checkpoint metadata owns storage and BF16 layer routing. The
+    # active config owns runtime step/layer policies, including explicit empty
+    # lists. Preserve them when each cascade transformer rebuilds from disk.
+    for policy in ("w4a8_fallback_steps", "w4a8_fallback_layers"):
+        if hasattr(quant_config, policy):
+            qc_kwargs[policy] = list(getattr(quant_config, policy))
+    if hasattr(quant_config, "mxfp4_scale_alg"):
+        # Runtime activation policy is independent of how offline W4 was made.
+        qc_kwargs["mxfp4_scale_alg"] = quant_config.mxfp4_scale_alg
+    if hasattr(quant_config, "require_smooth_scale"):
+        disk_requires_smooth = qc_kwargs.get("require_smooth_scale", False)
+        if not isinstance(disk_requires_smooth, bool):
+            raise ValueError("require_smooth_scale must be a boolean")
+        # Either a calibrated checkpoint or an explicit caller can require
+        # Smooth. Per-expert rebuilds must never weaken that requirement.
+        qc_kwargs["require_smooth_scale"] = quant_config.require_smooth_scale or disk_requires_smooth
+
     if _disk_marks_serialized(qc_kwargs, quant_config):
         logger.info(
             "config.json marks checkpoint as serialized; switching to offline %s mode.",
@@ -501,6 +550,14 @@ def resolve_quant_config_from_disk(
         )
         return build_quant_config(qc_method, **qc_kwargs)
 
+    if (
+        "require_smooth_scale" in qc_kwargs
+        and hasattr(quant_config, "require_smooth_scale")
+        and qc_kwargs["require_smooth_scale"] != quant_config.require_smooth_scale
+    ):
+        logger.info("config.json Smooth requirement differs from active config; rebuilding quant_config.")
+        return build_quant_config(qc_method, **qc_kwargs)
+
     # AutoRound MXFP checkpoints use data_type="mx_fp" instead of
     # is_checkpoint_*_serialized; rebuild so the offline MXFP4/MXFP8 path is
     # selected according to the checkpoint's bit width.
diff --git a/vllm_omni/quantization/int8_config.py b/vllm_omni/quantization/int8_config.py
index de31fbc3a..c7abe209f 100644
--- a/vllm_omni/quantization/int8_config.py
+++ b/vllm_omni/quantization/int8_config.py
@@ -7,6 +7,8 @@ on CUDA and NPU platforms.
 """
 
 from collections.abc import Callable
+from contextlib import contextmanager
+from contextvars import ContextVar
 from typing import TYPE_CHECKING, Any, Optional
 
 import torch
@@ -62,6 +64,32 @@ NPU_QUANT_MATMUL_MAX_OUT_FEATURES = 65535
 
 logger = init_logger(__name__)
 
+# Set by the diffusion loader while it constructs a model whose weights will be
+# offloaded back to host memory after online quantization (DLO). Over-wide
+# layers that npu_quant_matmul cannot run then load straight into host memory
+# instead of being built on the accelerator and moved off at the end of
+# loading — on MiniMax H3 the 50 fallback adaln layers are ~24 GiB of bf16,
+# which is the dominant startup memory peak.
+_LOAD_UNQUANTIZABLE_FALLBACK_ON_CPU: ContextVar[bool] = ContextVar(
+    "int8_load_unquantizable_fallback_on_cpu", default=False
+)
+
+
+@contextmanager
+def load_unquantizable_fallback_on_cpu():
+    """Create npu_quant_matmul-incompatible fallback weights on meta and load
+    them straight into host memory.
+
+    Only valid when the whole model returns to the host after loading (the
+    loader's offload-after-quant path); otherwise the fallback weights would
+    stay on CPU while the rest of the model runs on the accelerator.
+    """
+    token = _LOAD_UNQUANTIZABLE_FALLBACK_ON_CPU.set(True)
+    try:
+        yield
+    finally:
+        _LOAD_UNQUANTIZABLE_FALLBACK_ON_CPU.reset(token)
+
 
 def _fell_back_to_unquantized_npu(
     layer: torch.nn.Module,
@@ -90,7 +118,15 @@ def _fell_back_to_unquantized_npu(
         output_size_per_partition,
         NPU_QUANT_MATMUL_MAX_OUT_FEATURES,
     )
-    fallback = UnquantizedLinearMethod()
+    if _LOAD_UNQUANTIZABLE_FALLBACK_ON_CPU.get():
+        logger.info_once(
+            "Loading over-wide unquantized fallback weights straight into host memory "
+            "(offload-after-quant is active); they only reach the accelerator via "
+            "the offload backend's runtime prefetch."
+        )
+        fallback: LinearMethodBase = UnquantizedHostLinearMethod()
+    else:
+        fallback = UnquantizedLinearMethod()
     layer.quant_method = fallback
     fallback.create_weights(
         layer,
@@ -297,6 +333,14 @@ class LazyWeightMixin:
         """
         self._offload_after_quant = True
 
+    def _lazy_load_device(self) -> torch.device:
+        """Device the meta weight materializes on at first load.
+
+        Subclasses that never want the accelerator involved (e.g. the
+        over-wide host fallback) override this to return host memory.
+        """
+        return torch.get_default_device()
+
     def create_weights(
         self,
         layer: torch.nn.Module,
@@ -347,7 +391,7 @@ class LazyWeightMixin:
             # process_weights_after_loading
             target_loaded_numel = layer.weight.numel()
             if layer._loaded_numel == target_loaded_numel:
-                self.process_weights_after_loading(layer)
+                self.process_weights_after_loading(layer)  # type: ignore[attr-defined]
 
                 # Prevent the usual `process_weights_after_loading` call from doing
                 # anything
@@ -378,10 +422,46 @@ class LazyWeightMixin:
             weight_loader=patched_weight_loader,
         )
         # stash the correct device for `patched_weight_loader`
-        layer._load_device = torch.get_default_device()
+        layer._load_device = self._lazy_load_device()
         layer.register_parameter("weight", weight)
 
 
+class UnquantizedHostLinearMethod(LazyWeightMixin, UnquantizedLinearMethod):
+    """Unquantized linear method whose weight loads straight into host memory.
+
+    Layers wider than ``NPU_QUANT_MATMUL_MAX_OUT_FEATURES`` cannot be quantized,
+    so under the ordinary path their bf16 weights materialize on the accelerator
+    at construction time and stay there until the whole model is moved off after
+    loading. When the loader has entered ``load_unquantizable_fallback_on_cpu()``
+    (offload-after-quant, i.e. DLO), that round trip is pure startup peak — the
+    weights end up pinned on the host either way and only visit the accelerator
+    through the offload backend's runtime prefetch.
+
+    This method reuses ``LazyWeightMixin``'s meta + just-in-time materialization
+    wholesale (the weight really is deferred on meta until loading, like the
+    online quant methods, so the loader's meta-aware bookkeeping treats the
+    layer correctly) and only overrides the materialization target to host
+    memory: checkpoint chunks are CPU tensors, so loading stays CPU->CPU with
+    no accelerator round trip.
+    """
+
+    # Offload-after-quant marking is deliberately not advertised even though
+    # the mixin provides the hook: the weight never visits the accelerator,
+    # so there is nothing to return to host.
+    supports_offload_after_quant: bool = False
+
+    def _lazy_load_device(self) -> torch.device:
+        return torch.device("cpu")
+
+    def process_weights_after_loading(self, layer: torch.nn.Module) -> None:
+        """Unquantized weights need no post-load transform.
+
+        The mixin calls this when the weight is fully loaded, right before it
+        flags the layer — and the flag is what keeps the loader's post-load
+        sweep from bouncing the host tensor to the accelerator and back.
+        """
+
+
 class Int8LinearMethod(BaseInt8LinearMethod):
     """
     Linear method for Int8
diff --git a/vllm_omni/quantization/mxfp4_config.py b/vllm_omni/quantization/mxfp4_config.py
index ac93eaa00..43f3efa9d 100644
--- a/vllm_omni/quantization/mxfp4_config.py
+++ b/vllm_omni/quantization/mxfp4_config.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """W4A4 MXFP4 (Microscaling FP4) online/offline quantization for diffusion transformers.
 
 Architecture mirrors mxfp8_config.py:
@@ -41,7 +41,7 @@ Dual-scale (W4A4_MXFP4_DUALSCALE):
   and npu_dual_level_quant_matmul. Weight stored in NZ hardware format via npu_format_cast.
 
   Checkpoint tensor shapes for dual-scale:
-    weight            : (N, K)          float8_e4m3fn     – FP4 packed
+    weight            : (N, K)         float8_e4m3fn     – numeric FP4 values (packed after loading)
     weight_scale      : (N, K//32)      uint8    – fine scale (float8_e8m0fnu bits)
     weight_dual_scale : (N, K//512, 1)  float32  – coarse scale (extra dim avoids shape assert)
     mul_scale         : (K,)            float32  – per-input-channel activation pre-scale
@@ -51,9 +51,9 @@ Reference: MindIE-SD W4A4MXFP4QuantLinear / W4A4MXFP4DualQuantLinear (mindiesd/q
 
 from __future__ import annotations
 
-import re
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
+import regex as re
 import torch
 from torch.nn import Module
 from vllm.logger import init_logger
@@ -83,9 +83,54 @@ from vllm_omni.quantization.mxfp8_config import (
 if TYPE_CHECKING:
     from vllm.model_executor.models.utils import WeightsMapper
 
+
 logger = init_logger(__name__)
 
 
+def _validate_w4a8_fallback_steps(steps: list[int] | None) -> list[int]:
+    if steps is None:
+        return []
+    if not isinstance(steps, list) or any(type(step) is not int or step < 0 for step in steps):
+        raise ValueError("w4a8_fallback_steps must be a list of non-negative integer denoise step indices.")
+    return sorted(set(steps))
+
+
+def _validate_w4a8_fallback_layers(layers: list[str] | None) -> list[str]:
+    """Names are exact runtime Linear paths, not checkpoint aliases or patterns."""
+    if layers is None:
+        return []
+    if not isinstance(layers, list) or any(
+        not isinstance(name, str) or re.fullmatch(r"[A-Za-z_][A-Za-z_0-9]*(?:\.[A-Za-z_0-9]+)*", name) is None
+        for name in layers
+    ):
+        raise ValueError("w4a8_fallback_layers must be a list of non-empty exact runtime Linear paths.")
+    return sorted(set(layers))
+
+
+def _is_w4a8_fallback_step(steps: list[int]) -> bool:
+    """Read the request's zero-based denoise index; never keep state on a Linear."""
+    if not steps:
+        return False
+
+    from vllm_omni.diffusion.forward_context import (
+        get_forward_context,
+        is_forward_context_available,
+    )
+
+    step = get_forward_context().denoise_step_idx if is_forward_context_available() else None
+    if step is None:
+        raise RuntimeError("W4A8 step fallback requires a pipeline that publishes its denoise step in ForwardContext.")
+    return step in steps
+
+
+def _validate_smooth_scale(scale: torch.Tensor) -> None:
+    """Reject malformed calibration before loading or activation dtype conversion."""
+    if scale.ndim != 1 or not scale.is_floating_point():
+        raise ValueError("MXFP4 mul_scale must be a one-dimensional floating-point Smooth tensor.")
+    if not bool(torch.isfinite(scale).all()) or not bool((scale > 0).all()):
+        raise ValueError("MXFP4 mul_scale must contain finite, strictly positive Smooth values.")
+
+
 # ---------------------------------------------------------------------------
 # Config
 # ---------------------------------------------------------------------------
@@ -105,10 +150,24 @@ class DiffusionMXFP4Config(QuantizationConfig):
         self,
         is_checkpoint_mxfp4_serialized: bool = False,
         ignored_layers: list[str] | None = None,
+        w4a8_fallback_steps: list[int] | None = None,
+        require_smooth_scale: bool = False,
+        w4a8_fallback_layers: list[str] | None = None,
+        mxfp4_scale_alg: int = 0,
     ) -> None:
         super().__init__()
         self.is_checkpoint_mxfp4_serialized = is_checkpoint_mxfp4_serialized
         self.ignored_layers = ignored_layers or []
+        self.w4a8_fallback_steps = _validate_w4a8_fallback_steps(w4a8_fallback_steps)
+        self.w4a8_fallback_layers = _validate_w4a8_fallback_layers(w4a8_fallback_layers)
+        if not isinstance(require_smooth_scale, bool):
+            raise ValueError("require_smooth_scale must be a boolean")
+        if require_smooth_scale and not self.is_checkpoint_mxfp4_serialized:
+            raise ValueError("require_smooth_scale requires an offline MXFP4 checkpoint")
+        self.require_smooth_scale = require_smooth_scale
+        if type(mxfp4_scale_alg) is not int or mxfp4_scale_alg not in (0, 2):
+            raise ValueError("mxfp4_scale_alg must be 0 (OCP MX) or 2 (UOS with dst_type_max=7.25).")
+        self.mxfp4_scale_alg = mxfp4_scale_alg
 
     @classmethod
     def get_name(cls) -> QuantizationMethods:
@@ -139,6 +198,10 @@ class DiffusionMXFP4Config(QuantizationConfig):
         return cls(
             is_checkpoint_mxfp4_serialized=is_serialized,
             ignored_layers=ignored_layers,
+            w4a8_fallback_steps=config.get("w4a8_fallback_steps"),
+            w4a8_fallback_layers=config.get("w4a8_fallback_layers"),
+            require_smooth_scale=config.get("require_smooth_scale", False),
+            mxfp4_scale_alg=config.get("mxfp4_scale_alg", 0),
         )
 
     def get_quant_method(
@@ -155,9 +218,15 @@ class DiffusionMXFP4Config(QuantizationConfig):
                 return UnquantizedLinearMethod()
             if current_omni_platform.is_npu():
                 if self.is_checkpoint_mxfp4_serialized:
-                    return NPUMxfp4LinearMethod(self)
-                return NPUMxfp4OnlineLinearMethod(self)
+                    return NPUMxfp4LinearMethod(self, prefix=prefix)
+                return NPUMxfp4OnlineLinearMethod(self, prefix=prefix)
             if current_omni_platform.is_rocm():
+                if self.mxfp4_scale_alg != 0:
+                    raise NotImplementedError("MXFP4 UOS quantization is currently only supported on NPU (Ascend).")
+                if self.w4a8_fallback_steps or self.w4a8_fallback_layers:
+                    raise NotImplementedError(
+                        "MXFP4 W4A8 step/layer fallback is currently only supported on NPU (Ascend)."
+                    )
                 gcn_arch = torch.cuda.get_device_properties(torch.accelerator.current_device_index()).gcnArchName
                 if "gfx950" not in gcn_arch:
                     raise NotImplementedError(f"MXFP4 on ROCm requires gfx950 (MI355X). Detected: {gcn_arch}")
@@ -176,6 +245,56 @@ class DiffusionMXFP4Config(QuantizationConfig):
 # ---------------------------------------------------------------------------
 
 
+def _npu_quantize_mxfp4(x: torch.Tensor, scale_alg: int) -> tuple[torch.Tensor, torch.Tensor]:
+    """Quantize weight or activation using the same explicit FP4 algorithm."""
+    import torch_npu
+
+    # Universal Optimal Scaling (Qmax=7.25), MXAttention Section 4.1:
+    # https://arxiv.org/abs/2607.24377
+    scale_kwargs = {"dst_type_max": 7.25} if scale_alg == 2 else {}
+    return torch_npu.npu_dynamic_mx_quant(
+        x,
+        dst_type=torch_npu.float4_e2m1fn_x2,
+        axis=-1,
+        block_size=32,
+        round_mode="rint",
+        scale_alg=scale_alg,
+        **scale_kwargs,
+    )
+
+
+def _npu_w4a8_matmul(
+    x: torch.Tensor,
+    weight: torch.Tensor,
+    weight_scale: torch.Tensor,
+    bias: torch.Tensor | None,
+    output_dtype: torch.dtype,
+) -> torch.Tensor:
+    """MXFP8 activations with prepared single-scale MXFP4 weights (N, K)."""
+    import torch_npu
+
+    x_q, x_scale = torch_npu.npu_dynamic_mx_quant(
+        x, dst_type=torch_npu.float8_e4m3fn, axis=-1, block_size=32, round_mode="rint", scale_alg=0
+    )
+    # Use the BF16 output/bias pair supported by the mixed FP8/FP4 kernel
+    # in the target A5 runtime. Restore the caller's dtype afterwards.
+    if bias is not None:
+        bias = bias.to(torch.bfloat16).reshape(1, -1)
+    output = torch_npu.npu_quant_matmul(
+        x_q,
+        weight.transpose(0, 1),
+        weight_scale.transpose(0, 1),
+        scale_dtype=torch_npu.float8_e8m0fnu,
+        x2_dtype=torch_npu.float4_e2m1fn_x2,
+        pertoken_scale=x_scale,
+        pertoken_scale_dtype=torch_npu.float8_e8m0fnu,
+        bias=bias,
+        output_dtype=torch.bfloat16,
+        group_sizes=[0, 0, 32],
+    )
+    return output.to(output_dtype)
+
+
 class NPUMxfp4LinearMethod(MXFPLinearMethodBase):
     """NPU W4A4 MXFP4 offline linear method for pre-quantized checkpoints.
 
@@ -187,7 +306,8 @@ class NPUMxfp4LinearMethod(MXFPLinearMethodBase):
     NPUMxfp4OnlineLinearMethod normalizes to the same layout so apply() is shared.
     """
 
-    def __init__(self, quant_config: DiffusionMXFP4Config) -> None:
+    def __init__(self, quant_config: DiffusionMXFP4Config, *, prefix: str = "") -> None:
+        self.is_w4a8_fallback_layer = prefix in quant_config.w4a8_fallback_layers
         self.quant_config = quant_config
         self.out_dtype = torch.get_default_dtype()
 
@@ -210,11 +330,14 @@ class NPUMxfp4LinearMethod(MXFPLinearMethodBase):
         layer.orig_dtype = params_dtype
         layer.weight_block_size = None
 
-        # BF16 placeholder; cast to float4_e2m1fn_x2 in process_weights.
         layer.register_parameter(
             "weight",
             ModelWeightParameter(
-                data=torch.empty(output_size_per_partition, input_size_per_partition, dtype=params_dtype),
+                data=torch.empty(
+                    output_size_per_partition,
+                    input_size_per_partition,
+                    dtype=params_dtype,
+                ),
                 input_dim=1,
                 output_dim=0,
                 weight_loader=weight_loader,
@@ -234,12 +357,42 @@ class NPUMxfp4LinearMethod(MXFPLinearMethodBase):
             ),
         )
 
+        # Older single-scale checkpoints have no Smooth tensor. Keep their
+        # identity transform while allowing calibrated checkpoints to load it.
+        def smooth_weight_loader(
+            param: ModelWeightParameter, loaded_weight: torch.Tensor, *args: Any, **kwargs: Any
+        ) -> None:
+            _validate_smooth_scale(loaded_weight)
+            if not callable(weight_loader):
+                raise ValueError("Loading MXFP4 Smooth requires a callable weight_loader")
+            weight_loader(param, loaded_weight, *args, **kwargs)
+
+        layer.register_parameter(
+            "mul_scale",
+            ModelWeightParameter(
+                data=torch.ones(input_size_per_partition, dtype=torch.float32),
+                input_dim=0,
+                output_dim=None,
+                weight_loader=smooth_weight_loader,
+            ),
+        )
+        setattr(layer.mul_scale, "ignore_warning", True)
+        setattr(layer.mul_scale, "is_checkpoint_optional", not self.quant_config.require_smooth_scale)
+        if self.quant_config.is_checkpoint_mxfp4_serialized:
+            setattr(layer.weight_scale, "is_checkpoint_required", True)
+
     def process_weights_after_loading(self, layer: Module) -> None:
         if getattr(layer, "_already_called_process_weights_after_loading", False):
             return
 
         import torch_npu
 
+        smooth_param = cast(torch.Tensor, layer.mul_scale)
+        _validate_smooth_scale(smooth_param)
+        smooth = smooth_param.data.to(dtype=cast(torch.dtype, layer.orig_dtype)).contiguous()
+        # Finite FP32 values can overflow or underflow in the activation dtype.
+        _validate_smooth_scale(smooth)
+
         # NPU: cast to float4_e2m1fn_x2. Weight stays (N, K) — no pre-transpose.
         w = layer.weight
         if w.dtype != torch_npu.float4_e2m1fn_x2:
@@ -258,15 +411,31 @@ class NPUMxfp4LinearMethod(MXFPLinearMethodBase):
 
         replace_parameter(layer, "weight", w)
         replace_parameter(layer, "weight_scale", s)
+        # Keep loader metadata while converting the calibration tensor once.
+        layer.mul_scale.data = smooth.to(device=cast(torch.Tensor, w).device)
         layer._already_called_process_weights_after_loading = True
 
     # --- NPU MXFP4 ops — shared with online path via inheritance ---
 
-    def _quantize_activation(self, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        import torch_npu
+    def _apply_inner(
+        self,
+        layer: torch.nn.Module,
+        x: torch.Tensor,
+        bias: torch.Tensor | None,
+        ori_dtype: torch.dtype,
+    ) -> torch.Tensor:
+        # Online quantization has no calibrated Smooth tensor. For offline
+        # weights the same pre-scale must precede both A4 and A8 quantization.
+        if (mul_scale := getattr(layer, "mul_scale", None)) is not None:
+            x = x * mul_scale.to(x.dtype)
+        if self.is_w4a8_fallback_layer or _is_w4a8_fallback_step(self.quant_config.w4a8_fallback_steps):
+            return _npu_w4a8_matmul(
+                x, cast(torch.Tensor, layer.weight), cast(torch.Tensor, layer.weight_scale), bias, ori_dtype
+            )
+        return super()._apply_inner(layer, x, bias, ori_dtype)
 
-        # No dst_type: npu_dynamic_mx_quant defaults to float4_e2m1fn_x2.
-        return torch_npu.npu_dynamic_mx_quant(x)
+    def _quantize_activation(self, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        return _npu_quantize_mxfp4(x, self.quant_config.mxfp4_scale_alg)
 
     def _quant_matmul(
         self,
@@ -318,8 +487,6 @@ class NPUMxfp4OnlineLinearMethod(_LazyWeightMixin, NPUMxfp4LinearMethod):
         if getattr(layer, "_already_called_process_weights_after_loading", False):
             return
 
-        import torch_npu
-
         if layer.weight.device == torch.device("meta"):
             weight = ModelWeightParameter(
                 data=torch.empty_like(layer.weight, device=layer._load_device),
@@ -331,8 +498,10 @@ class NPUMxfp4OnlineLinearMethod(_LazyWeightMixin, NPUMxfp4LinearMethod):
             layer.register_parameter("weight", weight)
             initialize_single_dummy_weight(layer.weight)
 
-        # NPU: quantize BF16/FP16 (N, K) → FP4. No dst_type → float4_e2m1fn_x2.
-        weight_fp4, weight_scale_raw = torch_npu.npu_dynamic_mx_quant(layer.weight)
+        # Prepare once; offline checkpoints keep their existing weight algorithm.
+        weight_fp4, weight_scale_raw = _npu_quantize_mxfp4(
+            cast(torch.Tensor, layer.weight), self.quant_config.mxfp4_scale_alg
+        )
 
         # Weight stays (N, K) — no pre-transpose for FP4 packed format.
         # Scale: (N, S) → (N, S/2, 2). Not pre-transposed; done inline in _quant_matmul.
@@ -497,7 +666,7 @@ class NPUMxfp4DualScaleLinearMethod(MXFPLinearMethodBase):
     """NPU W4A4 MXFP4 dual-scale offline method for pre-quantized checkpoints.
 
     Checkpoint tensors and their canonical post-load shapes:
-      weight            : (N, K) float8_e4m3fn       – FP4 packed (2 values per byte)
+      weight            : (N, K) float8_e4m3fn – numeric FP4 values; packed into NZ after loading
       weight_scale      : (N, K//32) uint8  – fine scale (float8_e8m0fnu bits); reshaped to (N, K//64, 2)
       weight_dual_scale : (N, K//512, 1) float32 – coarse scale; transposed to (K//512, N)
       mul_scale         : (K,) float32      – per-input-channel activation pre-scale (from calibration)
@@ -509,7 +678,7 @@ class NPUMxfp4DualScaleLinearMethod(MXFPLinearMethodBase):
     Reference: MindIE-SD W4A4MXFP4DualQuantLinear.
     """
 
-    def __init__(self, quant_config: Any) -> None:
+    def __init__(self, quant_config: DiffusionMXFP4DualScaleMixedConfig) -> None:
         self.quant_config = quant_config
         self.out_dtype = torch.get_default_dtype()
 
@@ -532,7 +701,7 @@ class NPUMxfp4DualScaleLinearMethod(MXFPLinearMethodBase):
         layer.orig_dtype = params_dtype
         layer.weight_block_size = None
 
-        # FP4 packed: 2 values per float8_e4m3fn byte → checkpoint stores as float8_e4m3fn; register as BF16
+        # Checkpoint FP4 values are stored numerically in FP8; BF16 preserves them exactly.
         layer.register_parameter(
             "weight",
             ModelWeightParameter(
@@ -587,6 +756,7 @@ class NPUMxfp4DualScaleLinearMethod(MXFPLinearMethodBase):
             ),
         )
         setattr(layer.mul_scale, "ignore_warning", True)
+        setattr(layer.weight_scale, "is_checkpoint_required", True)
 
     def process_weights_after_loading(self, layer: Module) -> None:
         if getattr(layer, "_already_called_process_weights_after_loading", False):
@@ -594,7 +764,7 @@ class NPUMxfp4DualScaleLinearMethod(MXFPLinearMethodBase):
 
         import torch_npu
 
-        # float8_e4m3fn (FP4 packed) → float4_e2m1fn_x2 → NZ hardware format (format ID 29).
+        # Numeric FP4 values → packed float4_e2m1fn_x2 → NZ hardware format (format ID 29).
         # NZ layout is required by npu_dual_level_quant_matmul for FP4 weight matrices.
         w = torch_npu.npu_dtype_cast(layer.weight.data.npu(), torch_npu.float4_e2m1fn_x2)
         w = torch_npu.npu_format_cast(w.view(torch.int8), 29, customize_dtype=torch.int8)
@@ -631,7 +801,10 @@ class NPUMxfp4DualScaleLinearMethod(MXFPLinearMethodBase):
         """
         if ori_dtype not in (torch.bfloat16, torch.float16):
             x = x.to(torch.bfloat16)
-        x_q, l0_scale, l1_scale = self._quantize_activation(x, layer.mul_scale)
+        # The dual-level activation kernel requires x and Smooth to have the
+        # same dtype. Prepared calibration scales are BF16, including online.
+        smooth_scale = cast(torch.Tensor, layer.mul_scale).to(x.dtype)
+        x_q, l0_scale, l1_scale = self._quantize_activation(x, smooth_scale)
         return self._quant_matmul(x_q, l0_scale, l1_scale, layer, bias, ori_dtype)
 
     def _quantize_activation(  # type: ignore[override]
@@ -785,11 +958,20 @@ class DiffusionMXFP4DualScaleMixedConfig(QuantizationConfig):
         is_checkpoint_serialized: bool = False,
         ignored_layers: list[str] | None = None,
         num_bf16_fallback_layers: int = 5,
+        w4a8_fallback_steps: list[int] | None = None,
+        w4a8_fallback_layers: list[str] | None = None,
     ) -> None:
         super().__init__()
         self.is_checkpoint_serialized = is_checkpoint_serialized
         self.ignored_layers = ignored_layers or []
         self.num_bf16_fallback_layers = num_bf16_fallback_layers
+        self.w4a8_fallback_steps = _validate_w4a8_fallback_steps(w4a8_fallback_steps)
+        self.w4a8_fallback_layers = _validate_w4a8_fallback_layers(w4a8_fallback_layers)
+        if self.w4a8_fallback_steps or self.w4a8_fallback_layers:
+            raise ValueError(
+                "mxfp4_dualscale does not support W4A8 fallback. Use mxfp4 with single-scale weights; "
+                "changing a DualScale checkpoint's method name does not convert its storage format."
+            )
 
     @classmethod
     def get_name(cls) -> QuantizationMethods:
@@ -822,6 +1004,8 @@ class DiffusionMXFP4DualScaleMixedConfig(QuantizationConfig):
             is_checkpoint_serialized=is_serialized,
             ignored_layers=ignored_layers,
             num_bf16_fallback_layers=num_bf16_fallback_layers,
+            w4a8_fallback_steps=config.get("w4a8_fallback_steps"),
+            w4a8_fallback_layers=config.get("w4a8_fallback_layers"),
         )
 
     def get_quant_method(
diff --git a/vllm_omni/quantization/mxfp8_config.py b/vllm_omni/quantization/mxfp8_config.py
index 69e51dc6b..28a91574b 100644
--- a/vllm_omni/quantization/mxfp8_config.py
+++ b/vllm_omni/quantization/mxfp8_config.py
@@ -167,6 +167,21 @@ class _LazyWeightMixin:
 
     uses_meta_device: bool = True
 
+    # This mixin knows when a layer's weight is final, so it can hand the layer
+    # back to the host right there. Loaders that intend to offload the whole
+    # model after loading opt in per layer via ``enable_offload_after_quant``.
+    supports_offload_after_quant: bool = True
+    _offload_after_quant: bool = False
+
+    def enable_offload_after_quant(self) -> None:
+        """Return each layer to host memory as soon as it has been quantized.
+
+        Caps the load-time device footprint at one layer instead of the whole
+        model. A quant method instance belongs to a single layer, so this is not
+        a global switch.
+        """
+        self._offload_after_quant = True
+
     def create_weights(
         self,
         layer: torch.nn.Module,
@@ -202,12 +217,17 @@ class _LazyWeightMixin:
             param = layer.weight
             counter = CopyNumelCounter()
             with counter:
-                res = weight_loader(param, loaded_weight, *args, **kwargs)
+                res = weight_loader(param, loaded_weight, *args, **kwargs)  # type: ignore[misc]
             layer._loaded_numel += counter.copied_numel
 
             if layer._loaded_numel == layer.weight.numel():
-                self.process_weights_after_loading(layer)
+                self.process_weights_after_loading(layer)  # type: ignore[attr-defined]
                 layer._already_called_process_weights_after_loading = True
+
+                # This layer's weight is final, so nothing needs it on the
+                # accelerator until inference.
+                if self._offload_after_quant:
+                    layer.to("cpu")
             return res
 
         weight = ModelWeightParameter(
diff --git a/vllm_omni/transformers_utils/configs/__init__.py b/vllm_omni/transformers_utils/configs/__init__.py
index fdbfb4b60..63e38b01e 100644
--- a/vllm_omni/transformers_utils/configs/__init__.py
+++ b/vllm_omni/transformers_utils/configs/__init__.py
@@ -23,7 +23,6 @@ _CLASS_TO_MODULE: dict[str, str] = {
     "FishSpeechFastARConfig": "vllm_omni.transformers_utils.configs.fish_speech",
     "GLMTTSConfig": "vllm_omni.transformers_utils.configs.glm_tts",
     "VoxCPM2Config": "vllm_omni.transformers_utils.configs.voxcpm2",
-    "DotsTTSConfig": "vllm_omni.transformers_utils.configs.dots_tts",
     "VoxtralTTSConfig": "vllm_omni.transformers_utils.configs.voxtral_tts",
     "CosyVoice3Config": "vllm_omni.transformers_utils.configs.cosyvoice3",
     "MiniMaxMusic3Config": "vllm_omni.transformers_utils.configs.minimax_music3",
@@ -53,7 +52,6 @@ __all__ = [
     "FishSpeechFastARConfig",
     "GLMTTSConfig",
     "VoxCPM2Config",
-    "DotsTTSConfig",
     "VoxtralTTSConfig",
     "CosyVoice3Config",
     "MiniMaxMusic3Config",
@@ -86,7 +84,6 @@ def __dir__():
 from vllm_omni.transformers_utils.configs import audio8_tts as _audio8_tts  # noqa: F401, E402
 from vllm_omni.transformers_utils.configs import auk as _auk  # noqa: F401, E402
 from vllm_omni.transformers_utils.configs import cosyvoice3 as _cosyvoice3  # noqa: F401, E402
-from vllm_omni.transformers_utils.configs import dots_tts as _dots_tts  # noqa: F401, E402
 from vllm_omni.transformers_utils.configs import fish_speech as _fish_speech  # noqa: F401, E402
 from vllm_omni.transformers_utils.configs import glm_tts as _glm_tts  # noqa: F401, E402
 from vllm_omni.transformers_utils.configs import higgs_audio_v3 as _higgs_audio_v3  # noqa: F401, E402
diff --git a/vllm_omni/transformers_utils/configs/dots_tts.py b/vllm_omni/transformers_utils/configs/dots_tts.py
deleted file mode 100644
index 185d23ad7..000000000
--- a/vllm_omni/transformers_utils/configs/dots_tts.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""HF config for dots.tts.
-
-dots.tts splits its config across two files in the HF checkpoint:
-  * ``config.json``      — top-level dots.tts fields (latent_dim / patch_size
-                            / PatchEncoder / DiT / vocoder / etc.).
-  * ``llm_config.json``  — full Qwen2 LM config (vocab_size / hidden_size /
-                            num_hidden_layers / rope_theta / etc.).
-
-``AutoConfig.from_pretrained`` only consumes ``config.json``: its dots.tts
-sub-blocks (``vocoder`` / ``DiT`` / ``PatchEncoder``) arrive through
-``**kwargs`` and land as attributes, which the talker's config factories
-consume directly.  The Qwen2 LM fields live in ``llm_config.json``, which
-AutoConfig never reads — this class hoists them to top-level attributes
-with defaults matching the released checkpoints (soar / base / mf all ship
-the same Qwen2.5-1.5B backbone).  vLLM's ``Qwen2Model.__init__`` then reads
-``config.hidden_size`` / ``config.vocab_size`` / etc. through
-``get_text_config()``, the same pattern voxcpm2 follows.
-
-Future work: read ``llm_config.json`` during ``from_pretrained`` so a
-checkpoint with a different LM shape works without editing this file.
-
-Upstream reference:
-  https://huggingface.co/dots-studio/dots.tts-soar/blob/main/llm_config.json
-"""
-
-from __future__ import annotations
-
-from transformers import AutoConfig
-from transformers.configuration_utils import PretrainedConfig
-
-
-class DotsTTSConfig(PretrainedConfig):
-    """Configuration for dots.tts integration (Qwen2.5-1.5B-Base AR backbone)."""
-
-    model_type = "dots_tts"
-    keys_to_ignore_at_inference = ["past_key_values"]
-
-    def __init__(
-        self,
-        # -- top-level dots.tts params --
-        lm_config: dict | None = None,
-        # -- LM defaults (overridden by lm_config dict if present) --
-        # All values match dots.tts-soar's llm_config.json.
-        vocab_size: int = 151672,
-        hidden_size: int = 1536,
-        intermediate_size: int = 8960,
-        num_hidden_layers: int = 28,
-        num_attention_heads: int = 12,
-        num_key_value_heads: int = 2,
-        max_position_embeddings: int = 131072,
-        rms_norm_eps: float = 1e-6,
-        rope_theta: float = 1_000_000.0,
-        tie_word_embeddings: bool = True,
-        hidden_act: str = "silu",
-        bos_token_id: int = 151643,
-        eos_token_id: int = 151643,
-        **kwargs,
-    ):
-        super().__init__(
-            bos_token_id=bos_token_id,
-            eos_token_id=eos_token_id,
-            tie_word_embeddings=tie_word_embeddings,
-            **kwargs,
-        )
-        # The dots.tts sub-blocks (vocoder / DiT / PatchEncoder / latent_dim
-        # / patch_size / ...) arrive via **kwargs and are stored as
-        # attributes by PretrainedConfig; the talker's config factories
-        # read them from there.
-        self.lm_config = lm_config or {}
-
-        # -- Hoist LM parameters to top-level for vLLM's Qwen2Model --
-        lm = self.lm_config
-        self.vocab_size = lm.get("vocab_size", vocab_size)
-        self.hidden_size = lm.get("hidden_size", hidden_size)
-        self.intermediate_size = lm.get("intermediate_size", intermediate_size)
-        self.num_hidden_layers = lm.get("num_hidden_layers", num_hidden_layers)
-        self.num_attention_heads = lm.get("num_attention_heads", num_attention_heads)
-        self.num_key_value_heads = lm.get("num_key_value_heads", num_key_value_heads)
-        self.max_position_embeddings = lm.get("max_position_embeddings", max_position_embeddings)
-        self.rms_norm_eps = lm.get("rms_norm_eps", rms_norm_eps)
-        self.rope_theta = lm.get("rope_theta", rope_theta)
-        self.hidden_act = lm.get("hidden_act", hidden_act)
-        self.head_dim = self.hidden_size // self.num_attention_heads
-
-        # vLLM's Qwen2Model reads ``max_window_layers`` and checks against
-        # ``num_hidden_layers`` only when ``use_sliding_window`` is true.
-        # soar disables sliding window — set both to the same value so the
-        # assertion (if executed) stays vacuous.
-        self.use_sliding_window = lm.get("use_sliding_window", False)
-        self.sliding_window = lm.get("sliding_window", None)
-        self.max_window_layers = lm.get("max_window_layers", self.num_hidden_layers)
-
-    def get_text_config(self, **kwargs):
-        """Return self — LM fields are hoisted to top-level attributes."""
-        return self
-
-
-AutoConfig.register("dots_tts", DotsTTSConfig)
-
-__all__ = ["DotsTTSConfig"]
diff --git a/vllm_omni/utils/forced_aligner.py b/vllm_omni/utils/forced_aligner.py
index 3b578ee51..e6dcecb57 100644
--- a/vllm_omni/utils/forced_aligner.py
+++ b/vllm_omni/utils/forced_aligner.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Forced-aligner config + word-timestamp decoding for TTS.
 
 The aligner runs as a pooling stage appended to the pipeline by
@@ -153,6 +153,7 @@ def inject_forced_aligner_stage(
         # Pooling is one-shot -> sync AR scheduler (the async one assumes
         # token-by-token generation).
         async_scheduling=False,
+        async_chunk=False,
     )
     deploy = replace(deploy, stages=list(deploy.stages) + [aligner_ds])
     logger.info("[stage_init] Injected forced-aligner stage %d (model=%s)", new_id, fa.model)
diff --git a/vllm_omni/utils/tracking_parser.py b/vllm_omni/utils/tracking_parser.py
index 64849a5aa..8e5f5832a 100644
--- a/vllm_omni/utils/tracking_parser.py
+++ b/vllm_omni/utils/tracking_parser.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import argparse
 from typing import Any
@@ -52,12 +52,28 @@ class TrackingNamespace(argparse.Namespace):
         else:
             setattr(self.unfiltered_ns, name, value)
 
+    def __getstate__(self) -> dict[str, Any]:
+        """Preserve wrapper state when API workers use ``spawn``.
+
+        Our __dict__ property exposes the inner namespace, so default state
+        serialization would lose unfiltered_ns and explicit_keys.
+        """
+        return {
+            "unfiltered_ns": self.unfiltered_ns,
+            "explicit_keys": self.explicit_keys,
+        }
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        object.__setattr__(self, "unfiltered_ns", state["unfiltered_ns"])
+        object.__setattr__(self, "explicit_keys", state["explicit_keys"])
+
     def get_explicit_kwargs_dict(self):
         """Return a dict containing only the explicitly passed key-value pairs."""
         return {k: v for k, v in vars(self.unfiltered_ns).items() if k in self.explicit_keys}
 
     def __getattr__(self, name: str) -> Any:
-        return getattr(self.unfiltered_ns, name)
+        namespace = object.__getattribute__(self, "unfiltered_ns")
+        return getattr(namespace, name)
 
     @property
     def __dict__(self):
diff --git a/vllm_omni/worker/gpu_ar_model_runner.py b/vllm_omni/worker/gpu_ar_model_runner.py
index 06fdfa18b..0dd393ac6 100644
--- a/vllm_omni/worker/gpu_ar_model_runner.py
+++ b/vllm_omni/worker/gpu_ar_model_runner.py
@@ -59,7 +59,11 @@ from vllm_omni.worker.omni_connector_model_runner_mixin import (
 )
 from vllm_omni.worker.output.payload_build import build_omni_mm_payload
 from vllm_omni.worker.runner_assisted_metadata import RunnerAssistedFullAttentionMetadataRequest
-from vllm_omni.worker.sampling_utils import clamp_prompt_ids_to_penalty_padding, sanitize_min_tokens_stop_ids
+from vllm_omni.worker.sampling_utils import (
+    call_model_sampler,
+    clamp_prompt_ids_to_penalty_padding,
+    sanitize_min_tokens_stop_ids,
+)
 from vllm_omni.worker.sparse_audio import resolve_sparse_mm_routing
 
 logger = init_logger(__name__)
@@ -342,6 +346,9 @@ class ExecuteModelState(NamedTuple):
     multimodal_outputs: Any
     # slot_mappings for attention/drafter (aligned with upstream v1 API)
     slot_mappings: dict[str, torch.Tensor] | list[dict[str, torch.Tensor]] | None = None
+    # OMNI: prefix-cache step id; the step context saved under it must be
+    # consumed exactly once (materialize or discard_step) in sample_tokens.
+    prefix_cache_step_id: int | None = None
 
 
 class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, DuplexSamplingRunnerMixin):
@@ -565,7 +572,14 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         CUDAGraphWrapper.clear_all_graphs()
         BreakableCUDAGraphWrapper.clear_all_graphs()
 
-        # 6. Delegate to upstream shutdown (model = None, KV caches, workspace).
+        # 6. Stop the prefix-cache committer before the CUDA context and the
+        # tensors it copies from are torn down.
+        cache = self.omni_prefix_cache
+        if cache is not None:
+            cache.shutdown()
+            self.omni_prefix_cache = None
+
+        # 7. Delegate to upstream shutdown (model = None, KV caches, workspace).
         super().shutdown()
 
     def _capture_talker_mtp_graphs(self) -> None:
@@ -625,18 +639,6 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         finally:
             set_cudagraph_capturing_enabled(False)
 
-    def _model_needs_full_prefix_hidden_states(self) -> bool:
-        """Opt-out hook for models whose postprocess only consumes the tail.
-
-        When False, we skip both the per-step GPU->CPU hidden-state write into
-        OmniTensorPrefixCache and the merged-tensor reconstruction on hits;
-        postprocess receives the normal scheduled-token slice instead. Models
-        that need the full cached_prefix + new_tail span (default) are not
-        affected.
-        """
-        model = getattr(self, "model", None)
-        return bool(getattr(model, "requires_full_prefix_cached_hidden_states", True))
-
     def _get_runner_assisted_full_attention_metadata_request(
         self,
         *,
@@ -724,132 +726,34 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         )
         return True
 
-    def _deferred_prefix_cache_mm_keys(self) -> set[str]:
-        """Model-declared multimodal keys whose prefix-cache writes are deferred."""
-        model = getattr(self, "model", None)
-        keys = getattr(model, "deferred_prefix_cache_mm_keys", ())
-        return set(keys or ())
-
-    def _maybe_update_prefix_cache(
-        self,
-        hidden_states: torch.Tensor,
-        hidden_states_cpu: torch.Tensor | None,
-        multimodal_outputs: dict,
-        num_tokens_unpadded: int,
-        num_tokens_padded: int,
-    ):
-        """If prefix caching is enabled and it's the last pipeline parallelism rank,
-        retrieve the hidden states & multimodal outputs from the prefix cache based
-        on our batch slot mappings.
-        """
-        # Cache hidden states if we've enabled hidden state prefix caching
-        # unless this isn't the last pipeline parallelism rank.
-        is_last_pp_rank = get_pp_group().is_last_rank
-        if hidden_states_cpu is not None and not is_last_pp_rank:
-            raise RuntimeError("hidden_states_cpu staging is only valid on the last pipeline parallel rank.")
-        if self.omni_prefix_cache is not None and is_last_pp_rank:
-            # If this happens, it generally means the model is not following the correct
-            # interface yet and is therefore currently not compatible with prefix cache.
-            hs_for_cache = hidden_states if self._model_needs_full_prefix_hidden_states() else None
-            # FIX: The .cpu attribute of slot_mapping is stale (not updated by the Triton
-            # _compute_slot_mapping_kernel which only writes to .gpu). We must use .gpu and
-            # sync back to CPU to get the correctly computed slot mapping.
-            slot_mapping_gpu = self.input_batch.block_table[0].slot_mapping.gpu
-            slot_mapping_cpu = slot_mapping_gpu[:num_tokens_padded].cpu()
-            self.omni_prefix_cache.update_omni_tensor_prefix_cache(
-                hidden_states=hs_for_cache,
-                multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
-                num_tokens_unpadded=num_tokens_unpadded,
-                slot_mapping=slot_mapping_cpu,
-                num_tokens_padded=num_tokens_padded,
-                skip_mm_cache_keys=self._deferred_prefix_cache_mm_keys(),
-                hidden_states_cpu=hidden_states_cpu,
-            )
-
-    def _maybe_get_combined_prefix_cache_tensors(
-        self,
-        hidden_states: torch.Tensor,
-        hidden_states_cpu: torch.Tensor | None,
-        multimodal_outputs: dict,
-        num_scheduled_tokens: dict[str, int],
-    ) -> tuple[dict[str, torch.Tensor] | None, dict | None]:
-        """If prefix caching is enabled, extract the merged hidden states and multimodal outputs for
-        all requests in the batch (including those that aren't a hit on Prefix cache).
-        """
-        # Prior to applying the post-processing func, extract
-        # the prefix cached hidden states and multimodal states.
-        combined_hidden_states, combined_multimodal_outputs = None, None
-        is_last_pp_rank = get_pp_group().is_last_rank
-        if hidden_states_cpu is not None and not is_last_pp_rank:
-            raise RuntimeError("hidden_states_cpu staging is only valid on the last pipeline parallel rank.")
-        if self.omni_prefix_cache is not None:
-            if not is_last_pp_rank:
-                raise RuntimeError("Omni prefix-cache tensor merge is only valid on the last pipeline parallel rank.")
-            if (
-                not self._model_needs_full_prefix_hidden_states()
-                and not self.omni_prefix_cache.has_prefix_cached_new_req_ids()
-            ):
-                return None, None
-            if self._model_needs_full_prefix_hidden_states():
-                combined_hidden_states = self.omni_prefix_cache.get_merged_hidden_states(
-                    query_start_loc=self.query_start_loc.cpu,
-                    input_batch=self.input_batch,
-                    hidden_states=hidden_states,
-                    hidden_states_cpu=hidden_states_cpu,
-                    num_scheduled_tokens=num_scheduled_tokens,
-                )
-            combined_multimodal_outputs = self.omni_prefix_cache.get_merged_multimodal_states(
-                query_start_loc=self.query_start_loc.cpu,
-                input_batch=self.input_batch,
-                multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
-                num_scheduled_tokens=num_scheduled_tokens,
-            )
-        return combined_hidden_states, combined_multimodal_outputs
-
-    def _stage_deferred_prefix_cache_mm_outputs(
-        self,
-        *,
-        scheduler_output: SchedulerOutput,
-        multimodal_outputs: Any,
-        query_start_loc_cpu: Any,
-    ) -> None:
-        if self.omni_prefix_cache is None:
-            return
-
-        deferred_mm_cache_keys = self._deferred_prefix_cache_mm_keys()
-        if not deferred_mm_cache_keys:
-            return
-
-        self.omni_prefix_cache.stage_deferred_mm_outputs(
-            query_start_loc=query_start_loc_cpu,
-            input_batch=self.input_batch,
-            multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
-            num_scheduled_tokens=scheduler_output.num_scheduled_tokens,
-            deferred_mm_cache_keys=deferred_mm_cache_keys,
-        )
-
     def _prepare_prefix_cache_pooler_payload_sources(
         self,
         *,
-        hidden_states: torch.Tensor,
         staged_hidden_states_cpu: torch.Tensor | None,
-        multimodal_outputs: Any,
-        scheduler_output: SchedulerOutput,
         needs_scheduled_hidden_payload: bool,
+        req_ids: list[str],
+        step_id: int | None,
     ) -> tuple[torch.Tensor | None, dict[str, torch.Tensor] | None, dict | None]:
+        """Prefix-cache payload sources for the pooler payload build.
+
+        req_ids must be the step's snapshot, not ``input_batch.req_ids``: under
+        async omni output this runs a step late, when the live batch has moved on.
+        """
+        if not get_pp_group().is_last_rank:
+            raise RuntimeError("Omni prefix-cache merge is only valid on the last pipeline parallel rank.")
         hidden_states_cpu = None
         if needs_scheduled_hidden_payload:
             if staged_hidden_states_cpu is None:
                 raise RuntimeError("Prefix-cache hidden-state payload requires staged CPU hidden states.")
             hidden_states_cpu = staged_hidden_states_cpu
-
-        combined_hidden_states, combined_multimodal_outputs = self._maybe_get_combined_prefix_cache_tensors(
-            hidden_states,
-            staged_hidden_states_cpu,
-            multimodal_outputs,
-            scheduler_output.num_scheduled_tokens,
-        )
-        return hidden_states_cpu, combined_hidden_states, combined_multimodal_outputs
+        if step_id is None:
+            # save_outputs did not run this step (no last-rank AR output), so
+            # there is no step context to consume; serve the fresh slice.
+            if hidden_states_cpu is None and staged_hidden_states_cpu is not None:
+                hidden_states_cpu = staged_hidden_states_cpu
+            return hidden_states_cpu, None, None
+        combined_hidden, combined_mm = self._prefix_cache_materialize(step_id, list(req_ids))
+        return hidden_states_cpu, combined_hidden, combined_mm
 
     def _build_omni_pooler_payload(
         self,
@@ -956,15 +860,9 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             if hasattr(self.model, "_clear_warmup_state"):
                 self.model._clear_warmup_state()
 
-        # Async-write pipeline: apply any pending GPU->CPU prefix-cache writes
-        # whose copy event has already fired. Non-blocking — entries whose D2H
-        # is still in flight stay queued and will be picked up on the next
-        # step's drain. This guarantees any downstream read of
-        # ``omni_prefix_cache.hidden_states_cache`` /
-        # ``omni_prefix_cache.mm_outputs_cache`` in this step sees the
-        # state produced no later than the previous forward step.
-        if self.omni_prefix_cache is not None:
-            self.omni_prefix_cache.drain_ready_async_writes()
+        # Exactly once per real scheduler_output, before _update_states
+        # (dummy/warmup runs never reach execute_model).
+        self._prefix_cache_step_begin(scheduler_output)
 
         # [Omni] Handle KV transfer BEFORE updating states (which removes finished requests)
         finished_reqs = getattr(scheduler_output, "finished_requests_needing_kv_transfer", {})
@@ -988,12 +886,6 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                 if flush_ids:
                     self.flush_full_payload_outputs(flush_ids)
 
-        if self.omni_prefix_cache is not None and scheduler_output.finished_req_ids:
-            self.omni_prefix_cache.commit_deferred_mm_outputs(
-                set(scheduler_output.finished_req_ids),
-                self.input_batch,
-            )
-
         if self.routed_experts_initialized:
             capturer = self.routed_experts_capturer
             if capturer is not None and hasattr(capturer, "finalize_pending_copy"):
@@ -1294,30 +1186,22 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             else:
                 hidden_states, multimodal_outputs = self.extract_multimodal_outputs(model_output)
             hidden_states_cpu = None
-
-            # Async-write pipeline (replaces the per-step blocking
-            # ``.to("cpu")`` + ``aten::index_put_`` on pageable host memory).
-            # Schedules non-blocking GPU->CPU copies on a dedicated stream;
-            # the actual CPU scatter into ``hidden_states_cache`` /
-            # ``mm_outputs_cache`` happens in ``drain_ready_async_writes``
-            # at the top of subsequent execute_model() calls.
-            if not self.is_pooling_model and self.omni_prefix_cache is not None and get_pp_group().is_last_rank:
-                hs_for_cache = hidden_states if self._model_needs_full_prefix_hidden_states() else None
-                # Some models (e.g. qwen3-tts-talker) opt out of full-hidden-state
-                # prefix caching but the downstream pooler payload path still
-                # needs a CPU hidden-states view. Materialize it synchronously
-                # in that case; the legacy behavior is preserved.
-                if hs_for_cache is None and self._model_omni_pooler_payload_include_hidden():
-                    hidden_states_cpu = hidden_states[:num_tokens_unpadded].detach().to("cpu").contiguous()
-                slot_mapping_gpu = self.input_batch.block_table[0].slot_mapping.gpu
-                self.omni_prefix_cache.schedule_async_write(
-                    hidden_states_gpu=hs_for_cache,
-                    multimodal_outputs_gpu=(flatten_payload(multimodal_outputs) if multimodal_outputs else None),
-                    slot_mapping_gpu=slot_mapping_gpu,
-                    num_tokens_unpadded=num_tokens_unpadded,
-                    num_tokens_padded=num_tokens_padded,
-                    skip_mm_cache_keys=self._deferred_prefix_cache_mm_keys(),
-                )
+            # Prefix-cache write: freeze + submit; policy gating (full
+            # hidden, skip/deferred keys) happens inside the manager.
+            prefix_cache_step_id = self._prefix_cache_save_step(
+                hidden_states,
+                multimodal_outputs,
+                num_tokens_unpadded=num_tokens_unpadded,
+                num_tokens_padded=num_tokens_padded,
+            )
+            if (
+                prefix_cache_step_id is not None
+                and not self._model_needs_full_prefix_hidden_states()
+                and self._model_omni_pooler_payload_include_hidden()
+            ):
+                # Opt-out models keep the scheduled-slice CPU view for the
+                # pooler payload (runner-side bypass, legacy parity).
+                hidden_states_cpu = hidden_states[:num_tokens_unpadded].detach().to("cpu").contiguous()
 
             if not self.broadcast_pp_output:
                 # Common case.
@@ -1391,6 +1275,7 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             cudagraph_stats,
             multimodal_outputs,
             slot_mappings,  # OMNI: pass slot_mappings for drafter
+            prefix_cache_step_id,
         )
         self.kv_connector_output = kv_connector_output
 
@@ -1434,7 +1319,14 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                     )
                 prepared_sampling_metadata = self._sampling_metadata_for_model_sampler(sampling_metadata)
                 self._apply_duplex_sampling(logits, prepared_sampling_metadata)
-                sampler_output = model_sample(logits, prepared_sampling_metadata)
+                sampler_output = call_model_sampler(
+                    self.model,
+                    model_sample,
+                    logits,
+                    prepared_sampling_metadata,
+                    input_batch=self.input_batch,
+                    requests=getattr(self, "requests", None),
+                )
                 if sampler_output is not None:
                     return sampler_output
                 # Contract: None => fall back to the default sampler (see
@@ -1673,12 +1565,12 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         return raw
 
     def _model_omni_pooler_payload_include_hidden(self) -> bool:
-        return self._runner_model_omni_flag("omni_pooler_payload_include_hidden", default=True)
+        return self._pooler_payload_include_hidden_flag
 
     def _should_defer_full_payload_d2h(self) -> bool:
         """Keep opted-in full payloads on device until request completion."""
         return (
-            getattr(self, "omni_prefix_cache", None) is None
+            self.omni_prefix_cache is None
             and self._runner_model_omni_flag("omni_payload_at_request_end")
             and self._should_accumulate_full_payload_output()
         )
@@ -1707,8 +1599,6 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
     def _should_use_async_omni_output(self) -> bool:
         if not self.use_async_scheduling:
             return False
-        if self.omni_prefix_cache is not None:
-            return False
         if self.speculative_config is not None:
             return False
 
@@ -1854,6 +1744,7 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         num_scheduled_tokens_np: np.ndarray,
         query_start_loc_cpu: Any,
         postprocess_already_applied: bool = False,
+        prefix_cache_step_id: int | None = None,
     ) -> OmniModelRunnerOutput:
         combined_hidden_states = None
         combined_multimodal_outputs = None
@@ -1877,12 +1768,11 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             and needs_pooler_payload
             and (self.omni_prefix_cache is None or not self._model_needs_full_prefix_hidden_states())
         )
-        self._stage_deferred_prefix_cache_mm_outputs(
-            scheduler_output=scheduler_output,
-            multimodal_outputs=multimodal_outputs,
-            query_start_loc_cpu=query_start_loc_cpu,
-        )
-
+        if not needs_pooler_payload and prefix_cache_step_id is not None:
+            # No consumer for this step's merge: consume the step context by
+            # id (exactly-once contract). The cache write still lands.
+            self.omni_prefix_cache.discard_step(prefix_cache_step_id)
+            prefix_cache_step_id = None
         if self.omni_prefix_cache is None and needs_scheduled_hidden_payload and not audio_sparse_output:
             num_valid_tokens = min(
                 int(scheduler_output.total_num_scheduled_tokens),
@@ -1916,11 +1806,10 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                     combined_hidden_states,
                     combined_multimodal_outputs,
                 ) = self._prepare_prefix_cache_pooler_payload_sources(
-                    hidden_states=hidden_states,
                     staged_hidden_states_cpu=staged_hidden_states_cpu,
-                    multimodal_outputs=multimodal_outputs,
-                    scheduler_output=scheduler_output,
                     needs_scheduled_hidden_payload=needs_scheduled_hidden_payload,
+                    step_id=prefix_cache_step_id,
+                    req_ids=req_ids_output_copy,
                 )
             if combined_multimodal_outputs is None:
                 flat_mm = flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs
@@ -2060,6 +1949,7 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             cudagraph_stats,
             multimodal_outputs,
             slot_mappings,  # OMNI: unpack slot_mappings for drafter
+            prefix_cache_step_id,
         ) = self.execute_model_state
         self.execute_model_state = None
 
@@ -2259,6 +2149,7 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                     num_scheduled_tokens_np=num_scheduled_tokens_np,
                     query_start_loc_cpu=query_start_loc_cpu,
                     postprocess_already_applied=omni_postprocess_already_applied,
+                    prefix_cache_step_id=prefix_cache_step_id,
                 )
 
         if not use_async_omni_output:
diff --git a/vllm_omni/worker/gpu_ar_worker.py b/vllm_omni/worker/gpu_ar_worker.py
index 654cd4dc5..7ee43a05b 100644
--- a/vllm_omni/worker/gpu_ar_worker.py
+++ b/vllm_omni/worker/gpu_ar_worker.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import gc
 import os
 
@@ -75,7 +78,6 @@ class GPUARWorker(OmniWorkerMixin, OmniGPUWorkerBase):
                     f"DP adjusted local rank {self.local_rank} is out of "
                     f"bounds for {torch.accelerator.device_count()} devices."
                 )
-
             visible_device_index = current_platform.logical_device_id_to_visible_device_id(self.local_rank)
             self.device = current_omni_platform.get_torch_device(visible_device_index)
             torch.accelerator.set_device_index(self.device)
@@ -113,13 +115,24 @@ class GPUARWorker(OmniWorkerMixin, OmniGPUWorkerBase):
         num_ubatches = 2 if self.vllm_config.parallel_config.enable_dbo else 1
         init_workspace_manager(self.device, num_ubatches)
 
-        if self.use_v2_model_runner:
-            # OMNI: v2 model runner does not yet include omni hooks.
-            logger.warning("OMNI GPUARWorker forces v1 model runner for omni hooks.")
-            self.use_v2_model_runner = False
+        model_stage = getattr(self.model_config, "model_stage", None)
+        stage_id = getattr(self.model_config, "stage_id", None)
 
-        # Construct the model runner
-        self.model_runner = self.model_runner_cls(self.vllm_config, self.device)
+        self.use_v2_model_runner = bool(getattr(self.model_config, "use_v2_model_runner", False))
+        if self.use_v2_model_runner:
+            from vllm_omni.worker_v2.omni_ar_model_runner import (
+                OmniARModelRunner,
+            )
+
+            logger.info(
+                "Using MR v2 OmniARModelRunner for omni AR stage (stage_id=%s model_stage=%s).",
+                stage_id,
+                model_stage,
+            )
+            self.model_runner = OmniARModelRunner(self.vllm_config, self.device)
+        else:
+            self.use_v2_model_runner = False
+            self.model_runner = self.model_runner_cls(self.vllm_config, self.device)
 
         if self.rank == 0:
             # If usage stat is enabled, collect relevant info.
diff --git a/vllm_omni/worker/gpu_generation_model_runner.py b/vllm_omni/worker/gpu_generation_model_runner.py
index e43c6f608..6d780925c 100644
--- a/vllm_omni/worker/gpu_generation_model_runner.py
+++ b/vllm_omni/worker/gpu_generation_model_runner.py
@@ -407,6 +407,7 @@ class GPUGenerationModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin
             cudagraph_stats,
             multimodal_outputs_raw,
             slot_mappings,  # OMNI: unpack slot_mappings for upstream v1 API compatibility
+            _prefix_cache_step_id,  # generation stages never save to the prefix cache
         ) = self.execute_model_state
         self.execute_model_state = None
 
@@ -812,7 +813,7 @@ class GPUGenerationModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin
 
             if self.uses_mrope:
                 positions = self.mrope_positions.gpu[:, :num_tokens_padded]
-            elif self.uses_xdrope_dim > 0:
+            elif getattr(self, "uses_xdrope_dim", 0) > 0:
                 positions = self.xdrope_positions.gpu[:, :num_tokens_padded]
             else:
                 positions = self.positions[:num_tokens_padded]
diff --git a/vllm_omni/worker/gpu_generation_worker.py b/vllm_omni/worker/gpu_generation_worker.py
index d6a8d6c8e..0e939957e 100644
--- a/vllm_omni/worker/gpu_generation_worker.py
+++ b/vllm_omni/worker/gpu_generation_worker.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import gc
 import os
 
@@ -8,7 +11,10 @@ from vllm.tracing import instrument
 from vllm.utils.mem_utils import MemorySnapshot, format_gib
 from vllm.utils.torch_utils import set_random_seed
 from vllm.v1.utils import report_usage_stats
-from vllm.v1.worker.gpu_worker import init_worker_distributed_environment
+from vllm.v1.worker.gpu_worker import (
+    CompilationTimes,
+    init_worker_distributed_environment,
+)
 from vllm.v1.worker.workspace import init_workspace_manager
 
 from vllm_omni.platforms import current_omni_platform
@@ -96,13 +102,28 @@ class GPUGenerationWorker(OmniWorkerMixin, OmniGPUWorkerBase):
         num_ubatches = 2 if self.vllm_config.parallel_config.enable_dbo else 1
         init_workspace_manager(self.device, num_ubatches)
 
+        self.use_v2_model_runner = bool(getattr(self.model_config, "use_v2_model_runner", False))
         if self.use_v2_model_runner:
-            # OMNI: v2 model runner does not yet include omni hooks.
-            logger.warning("OMNI GPUGenerationWorker forces v1 model runner for omni hooks.")
-            self.use_v2_model_runner = False
+            from vllm_omni.worker_v2.omni_generation_model_runner import (
+                OmniGenerationModelRunner,
+            )
 
-        self.model_runner = self.model_runner_cls(self.vllm_config, self.device)
+            logger.info("Using MR v2 OmniGenerationModelRunner for generation stage.")
+            self.model_runner = OmniGenerationModelRunner(self.vllm_config, self.device)
+        else:
+            self.model_runner = self.model_runner_cls(self.vllm_config, self.device)
 
         if self.rank == 0:
             # If usage stat is enabled, collect relevant info.
             report_usage_stats(self.vllm_config)
+
+    @instrument(span_name="Compile/warmup")
+    def compile_or_warm_up_model(self) -> CompilationTimes:
+        """Generation stages have no KV cache or sampler — skip warmup_kernels."""
+        if not self.use_v2_model_runner:
+            return super().compile_or_warm_up_model()
+        import time
+
+        start = time.perf_counter()
+        self.model_runner.profile_run()
+        return CompilationTimes(language_model=time.perf_counter() - start, encoder=0.0)
diff --git a/vllm_omni/worker/gpu_model_runner.py b/vllm_omni/worker/gpu_model_runner.py
index d3ee8de02..1664df24b 100644
--- a/vllm_omni/worker/gpu_model_runner.py
+++ b/vllm_omni/worker/gpu_model_runner.py
@@ -33,7 +33,8 @@ from vllm.v1.worker.gpu_input_batch import CachedRequestState
 from vllm.v1.worker.gpu_model_runner import GPUModelRunner, PerLayerAttnMetadata
 from vllm.v1.worker.ubatch_utils import maybe_create_ubatch_slices
 
-from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
+from vllm_omni.core.prefix_cache import stage_prefix_cache_config
+from vllm_omni.core.prefix_cache.runner_mixin import PrefixCacheRunnerMixin
 from vllm_omni.data_entry_keys import OmniPayload
 from vllm_omni.engine.serialization import deserialize_additional_information
 from vllm_omni.model_executor.layers.rotary_embedding.mrope import OmniMRotaryEmbedding as MRotaryEmbedding
@@ -79,7 +80,7 @@ def _filter_mrope_kwargs_for_model(model: object, kwargs: dict[str, Any]) -> dic
     return {key: value for key, value in kwargs.items() if key in accepted}
 
 
-class OmniGPUModelRunner(GPUModelRunner):
+class OmniGPUModelRunner(PrefixCacheRunnerMixin, GPUModelRunner):
     intermediate_tensors: IntermediateTensors | None
 
     def __init__(self, *args, **kwargs):
@@ -87,11 +88,16 @@ class OmniGPUModelRunner(GPUModelRunner):
         self.model_intermediate_buffer: dict[str, dict[str, Any]] = {}
         self._omni_num_scheduled_tokens_np: np.ndarray | None = None
         self._omni_last_model_output: object | None = None
-        # The Omni tensor prefix cache will be allocated
-        # when we initialize the metadata builders if enabled
+        # Omni prefix cache (hidden / per-token mm tensors reused on prefix
+        # hits). Built once, on the first real step after load_model: the
+        # config is staged at kv-cache init and cleared after construction.
         self.omni_prefix_cache = None
+        self._omni_prefix_cache_cfg = None
         self._sampled_token_ids_cpu_override = None
         self._omni_query_start_loc_model_kwarg = False
+        # Output-payload constant snapshotted once in load_model; the cache
+        # policy counterpart lives on PrefixCacheRunnerMixin.
+        self._pooler_payload_include_hidden_flag = True
 
     def _to_list(self, sampled_token_ids: torch.Tensor) -> list[list[int]]:
         override_fn = self._sampled_token_ids_cpu_override
@@ -172,15 +178,20 @@ class OmniGPUModelRunner(GPUModelRunner):
                                 device=sm.device,
                             )
 
-        # Initialize the wrapper for both multimodal output tensors
-        # and for hidden states to be passed between stages
-        if self.cache_config.enable_prefix_caching:
-            self.omni_prefix_cache = OmniTensorPrefixCache(
-                num_blocks=kv_cache_config.num_blocks,
-                block_size=self.cache_config.block_size,
-                hidden_size=self.model_config.get_hidden_size(),
-                hs_dtype=self.dtype,
-            )
+        # Stage the config; the manager is built on the first step once
+        # input_batch exists. The gate (pooling stage, kv_consumer, hybrid
+        # kv groups) is shared with the NPU runner.
+        cfg = stage_prefix_cache_config(
+            kv_cache_config=kv_cache_config,
+            cache_config=self.cache_config,
+            kv_transfer_config=getattr(self.vllm_config, "kv_transfer_config", None),
+            scheduler_config=self.scheduler_config,
+            model_config=self.model_config,
+            is_pooling_model=self.is_pooling_model,
+            speculative_config=self.speculative_config,
+        )
+        if cfg is not None:
+            self._omni_prefix_cache_cfg = cfg
 
     @instrument(span_name="Loading (GPU)")
     def load_model(self, *args, **kwargs) -> None:
@@ -192,6 +203,8 @@ class OmniGPUModelRunner(GPUModelRunner):
             if callable(candidate):
                 override_fn = candidate
         self._sampled_token_ids_cpu_override = override_fn
+        self._snapshot_prefix_cache_model_policy(model)
+        self._pooler_payload_include_hidden_flag = bool(getattr(model, "omni_pooler_payload_include_hidden", True))
         self._omni_query_start_loc_model_kwarg = bool(getattr(model, "supports_omni_query_start_loc", False))
         self._maybe_enable_output_token_ids_for_model_sampler()
         self._init_talker_mtp()
@@ -515,10 +528,6 @@ class OmniGPUModelRunner(GPUModelRunner):
         The SamplingMetadata is updated and copied to the GPU if there is a
         new/resumed/paused/finished request in the batch.
         """
-        # Used for prefix cache
-        if self.omni_prefix_cache is not None:
-            self.omni_prefix_cache.reset_prefix_cached_new_req_ids()
-
         # Remove finished requests from the cached states.
         # cleanup_finished_request lives on OmniConnectorModelRunnerMixin and
         # is only safe to call once init_omni_connectors() has finished
@@ -535,8 +544,6 @@ class OmniGPUModelRunner(GPUModelRunner):
             self.requests.pop(req_id, None)
             self.model_intermediate_buffer.pop(req_id, None)
             self.num_prompt_logprobs.pop(req_id, None)
-            if self.omni_prefix_cache is not None:
-                self.omni_prefix_cache.discard_deferred_mm_outputs(req_id)
             if hasattr(self, "_downstream_payload_cache"):
                 self._downstream_payload_cache.pop(req_id, None)
             if hasattr(self, "_talker_mtp_generators"):
@@ -600,13 +607,6 @@ class OmniGPUModelRunner(GPUModelRunner):
                 reqs_to_add.append(req_state)
                 continue
 
-            # Since this is the first time the request has been scheduled,
-            # num_computed_tokens > 0 means that we have a hit in prefix
-            # caching; mark it so that we can manage the hidden states
-            # later on as needed.
-            if self.omni_prefix_cache is not None and new_req_data.num_computed_tokens > 0:
-                self.omni_prefix_cache.add_prefix_cached_new_req_id(req_id)
-
             sampling_params = new_req_data.sampling_params
             pooling_params = new_req_data.pooling_params
 
@@ -690,7 +690,7 @@ class OmniGPUModelRunner(GPUModelRunner):
                 self._init_mrope_positions(req_state)
 
             # Only relevant for models using XD-RoPE (e.g, HunYuan-VL)
-            if self.uses_xdrope_dim > 0:
+            if getattr(self, "uses_xdrope_dim", 0) > 0:
                 self._init_xdrope_positions(req_state)
 
             reqs_to_add.append(self.requests[req_id])
@@ -1164,7 +1164,7 @@ class OmniGPUModelRunner(GPUModelRunner):
 
             if self.uses_mrope:
                 positions = self.mrope_positions.gpu[:, :num_tokens_padded]
-            elif self.uses_xdrope_dim > 0:
+            elif getattr(self, "uses_xdrope_dim", 0) > 0:
                 positions = self.xdrope_positions.gpu[:, :num_tokens_padded]
             else:
                 positions = self.positions[:num_tokens_padded]
@@ -1701,7 +1701,7 @@ class OmniGPUModelRunner(GPUModelRunner):
 
         if self.uses_mrope:
             positions = self.mrope_positions.gpu[:, :num_input_tokens]
-        elif self.uses_xdrope_dim > 0:
+        elif getattr(self, "uses_xdrope_dim", 0) > 0:
             positions = self.xdrope_positions.gpu[:, :num_input_tokens]
         else:
             positions = self.positions[:num_input_tokens]
@@ -2042,10 +2042,20 @@ class OmniGPUModelRunner(GPUModelRunner):
                     if req_state is not None:
                         existing = self.model_intermediate_buffer.setdefault(req_id, {})
                         existing.setdefault(out_key[0], {})[out_key[1]] = row
+                        validity_key = getattr(self.model, "talker_mtp_validity_key", None)
+                        if validity_key is not None:
+                            existing.setdefault(validity_key[0], {})[validity_key[1]] = torch.ones(
+                                (), dtype=torch.bool, device=code_predictor_codes.device
+                            )
                         req_state.additional_information_cpu = existing
             else:
                 for idx, req_id in enumerate(decode_req_ids):
                     update_dict = {out_key[0]: {out_key[1]: code_predictor_codes[idx : idx + 1]}}
+                    validity_key = getattr(self.model, "talker_mtp_validity_key", None)
+                    if validity_key is not None:
+                        update_dict.setdefault(validity_key[0], {})[validity_key[1]] = torch.ones(
+                            (), dtype=torch.bool, device=code_predictor_codes.device
+                        )
                     self._update_intermediate_buffer(req_id, update_dict)
 
     def _model_forward(
diff --git a/vllm_omni/worker/mixins.py b/vllm_omni/worker/mixins.py
index 5f0fd8300..724cc87be 100644
--- a/vllm_omni/worker/mixins.py
+++ b/vllm_omni/worker/mixins.py
@@ -7,7 +7,7 @@ from typing import Any
 
 
 class OmniWorkerMixin:
-    """Mixin to ensure Omni plugins are loaded in worker processes."""
+    """Shared Omni plugin and native KV connector setup for workers."""
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
@@ -15,6 +15,16 @@ class OmniWorkerMixin:
 
         load_omni_general_plugins()
 
+    def initialize_from_config(self, kv_cache_config) -> None:
+        # The concrete GPU/NPU/XPU worker supplies this method through the MRO.
+        super().initialize_from_config(kv_cache_config)  # type: ignore[misc]
+        from vllm.distributed.kv_transfer import get_kv_transfer_group, has_kv_transfer_group
+
+        if has_kv_transfer_group():
+            from vllm_omni.diffusion.diffusion_kv.kv_connector import install_mooncake_cfg_fanout
+
+            install_mooncake_cfg_fanout(get_kv_transfer_group())
+
 
 def maybe_unpad_input_ids(model, input_ids, num_tokens_unpadded):
     """Trim cudagraph-bucket padding for models that split a flat ``input_ids``
diff --git a/vllm_omni/worker/payload_span.py b/vllm_omni/worker/payload_span.py
new file mode 100644
index 000000000..c16126468
--- /dev/null
+++ b/vllm_omni/worker/payload_span.py
@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Helpers for explicit thinker decode span metadata."""
+
+from collections.abc import Mapping
+from typing import Any
+
+import torch
+
+TensorSpan = tuple[torch.Tensor, int, int]
+
+
+def get_tensor_span(payload: Mapping[str, Any], *, tensor_key: str, start_key: str, end_key: str) -> TensorSpan | None:
+    tensor = payload.get(tensor_key)
+    start = payload.get(start_key)
+    end = payload.get(end_key)
+    if not isinstance(tensor, torch.Tensor):
+        return None
+    if not isinstance(start, int) or not isinstance(end, int):
+        return None
+    if start < 0 or end < start or (end - start) != int(tensor.shape[0]):
+        return None
+    return tensor, start, end
+
+
+def merge_tensor_spans(existing_span: TensorSpan | None, incoming_span: TensorSpan | None) -> TensorSpan | None:
+    if existing_span is None or incoming_span is None:
+        return None
+
+    existing_tensor, existing_start, existing_end = existing_span
+    incoming_tensor, incoming_start, incoming_end = incoming_span
+    if incoming_tensor.device != existing_tensor.device or incoming_tensor.dtype != existing_tensor.dtype:
+        incoming_tensor = incoming_tensor.to(device=existing_tensor.device, dtype=existing_tensor.dtype)
+    if incoming_start == existing_end:
+        if existing_start == existing_end:
+            return incoming_tensor, incoming_start, incoming_end
+        return torch.cat([existing_tensor, incoming_tensor], dim=0), existing_start, incoming_end
+    if incoming_start < existing_end:
+        overlap = existing_end - incoming_start
+        if overlap >= int(incoming_tensor.shape[0]):
+            return existing_tensor, existing_start, existing_end
+        trimmed_tensor = incoming_tensor[overlap:]
+        return (
+            torch.cat([existing_tensor, trimmed_tensor], dim=0),
+            existing_start,
+            existing_end + int(trimmed_tensor.shape[0]),
+        )
+    return None
diff --git a/vllm_omni/worker/sampling_utils.py b/vllm_omni/worker/sampling_utils.py
index 39ecae469..00e19024d 100644
--- a/vllm_omni/worker/sampling_utils.py
+++ b/vllm_omni/worker/sampling_utils.py
@@ -1,14 +1,109 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Sampling-state guards shared by the GPU and NPU AR model runners."""
+"""Sampling helpers shared by the GPU and NPU AR model runners."""
+
+from typing import Any
 
 import torch
 from vllm.logger import init_logger
+from vllm.sampling_params import SamplingParams
 from vllm.v1.sample.logits_processor import LogitsProcessors, MinTokensLogitsProcessor
 
 logger = init_logger(__name__)
 
-__all__ = ["clamp_prompt_ids_to_penalty_padding", "sanitize_min_tokens_stop_ids"]
+__all__ = [
+    "apply_fixed_seed_to_sampling_params",
+    "get_tts_local_seed",
+    "clamp_prompt_ids_to_penalty_padding",
+    "sanitize_min_tokens_stop_ids",
+    "sanitize_sampling_params_min_tokens_stop_ids",
+    "build_model_sampler_extra_args",
+    "call_model_sampler",
+]
+
+
+def get_tts_local_seed(sampling_params: Any) -> int | None:
+    """Return the explicit per-request Talker MTP seed, if configured."""
+    extra_args = getattr(sampling_params, "extra_args", None) if sampling_params is not None else None
+    seed = extra_args.get("tts_local_seed") if isinstance(extra_args, dict) else None
+    return int(seed) if seed is not None else None
+
+
+def apply_fixed_seed_to_sampling_params(
+    sampling_params: Any,
+    seed: int,
+    *,
+    seed_talker_mtp: bool,
+) -> None:
+    """Apply one request seed to a stage sampler and, for Talkers, its MTP RNG."""
+    seed = int(seed)
+    sampling_params.seed = seed
+    if not seed_talker_mtp:
+        return
+    extra_args = dict(getattr(sampling_params, "extra_args", None) or {})
+    extra_args["tts_local_seed"] = seed
+    sampling_params.extra_args = extra_args
+
+
+def sanitize_sampling_params_min_tokens_stop_ids(
+    sampling_params: SamplingParams,
+    logits_vocab: int,
+) -> None:
+    """Remove unreachable ids before MRv2 builds persistent min-token state.
+
+    MRv2 copies ``SamplingParams.all_stop_token_ids`` into GPU-resident
+    ``LogitBiasState`` when a request is registered. Narrow codec heads cannot
+    safely carry the text tokenizer EOS in that state. The engine-facing EOS
+    and explicit ``stop_token_ids`` fields remain unchanged; only the set used
+    by the sampler's min-token mask is normalized.
+    """
+    if sampling_params.min_tokens <= 0:
+        return
+    stop_token_ids = sampling_params.all_stop_token_ids
+    unreachable = {token_id for token_id in stop_token_ids if token_id < 0 or token_id >= logits_vocab}
+    if not unreachable:
+        return
+    stop_token_ids.difference_update(unreachable)
+    logger.warning_once(
+        "min_tokens: dropped stop token ids %s that exceed the logits vocabulary (%d); "
+        "the model head cannot emit them.",
+        str(sorted(unreachable)),
+        logits_vocab,
+    )
+
+
+def build_model_sampler_extra_args(input_batch: Any, requests: Any) -> list[dict | None]:
+    """Return per-request ``SamplingParams.extra_args`` in batch-row order."""
+    request_states = requests or {}
+    per_req_extra_args: list[dict | None] = []
+    for req_id in getattr(input_batch, "req_ids", []):
+        state = request_states.get(req_id)
+        params = getattr(state, "sampling_params", None)
+        per_req_extra_args.append(getattr(params, "extra_args", None))
+    return per_req_extra_args
+
+
+def call_model_sampler(
+    model: Any,
+    model_sample: Any,
+    logits: torch.Tensor,
+    sampling_metadata: Any,
+    *,
+    input_batch: Any,
+    requests: Any,
+) -> Any:
+    """Call an opted-in model sampler with per-request extra arguments.
+
+    The opt-in keeps the existing two-argument sampler contract unchanged for
+    every other model while allowing custom samplers to make row-local choices.
+    """
+    if not getattr(model, "model_sampler_wants_extra_args", False):
+        return model_sample(logits, sampling_metadata)
+    return model_sample(
+        logits,
+        sampling_metadata,
+        per_req_extra_args=build_model_sampler_extra_args(input_batch, requests),
+    )
 
 
 def clamp_prompt_ids_to_penalty_padding(prompt_token_ids: torch.Tensor, logits_vocab: int) -> torch.Tensor:
diff --git a/vllm_omni/worker_v2/__init__.py b/vllm_omni/worker_v2/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/vllm_omni/worker_v2/delivery.py b/vllm_omni/worker_v2/delivery.py
new file mode 100644
index 000000000..e84ed28c0
--- /dev/null
+++ b/vllm_omni/worker_v2/delivery.py
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import threading
+import time
+from enum import Enum, auto
+
+
+class DeliveryState(Enum):
+    QUEUED = auto()
+    IN_FLIGHT = auto()
+    DELIVERED = auto()
+    FAILED = auto()
+    CANCELLED = auto()
+
+
+class DeliveryTimeoutError(TimeoutError):
+    pass
+
+
+class DeliveryCancelledError(RuntimeError):
+    pass
+
+
+_TERMINAL_STATES = {
+    DeliveryState.DELIVERED,
+    DeliveryState.FAILED,
+    DeliveryState.CANCELLED,
+}
+
+
+class DeliveryTicket:
+    """Exactly-once completion for one MRv2 connector delivery."""
+
+    def __init__(
+        self,
+        manager: OmniDeliveryManager,
+        *,
+        request_id: str,
+        put_key: str,
+        deadline: float,
+    ) -> None:
+        self._manager = manager
+        self.request_id = request_id
+        self.put_key = put_key
+        self.deadline = deadline
+        self._state = DeliveryState.QUEUED
+        self._error: BaseException | None = None
+        self._event = threading.Event()
+
+    @property
+    def state(self) -> DeliveryState:
+        with self._manager._lock:
+            return self._state
+
+    def mark_in_flight(self) -> bool:
+        return self._manager._mark_in_flight(self)
+
+    def set_delivered(self) -> bool:
+        return self._manager._set_delivered(self)
+
+    def set_failed(self, error: BaseException) -> bool:
+        return self._manager._set_failed(self, error)
+
+    # Compatibility with the connector mixin's completion interface.
+    def set_result(self) -> bool:
+        return self.set_delivered()
+
+    def set_error(self, error: BaseException) -> bool:
+        return self.set_failed(error)
+
+    def wait(self) -> None:
+        while True:
+            with self._manager._lock:
+                state = self._state
+                error = self._error
+                remaining = self.deadline - time.monotonic()
+            if state is DeliveryState.DELIVERED:
+                return
+            if state in (DeliveryState.FAILED, DeliveryState.CANCELLED):
+                assert error is not None
+                raise error
+            if remaining <= 0:
+                self._manager._timeout(self)
+                continue
+            self._event.wait(timeout=remaining)
+
+
+class OmniDeliveryManager:
+    """MRv2-only connector delivery state machine.
+
+    A timeout or permanent delivery failure quarantines the whole manager.
+    This is a stage-fatal condition: no new payload may be accepted after the
+    transport can no longer prove ordered, exactly-once completion.
+    """
+
+    def __init__(
+        self,
+        *,
+        delivery_timeout_s: float,
+        shutdown_timeout_s: float = 5.0,
+    ) -> None:
+        if delivery_timeout_s <= 0:
+            raise ValueError("delivery_timeout_s must be positive")
+        if shutdown_timeout_s <= 0:
+            raise ValueError("shutdown_timeout_s must be positive")
+        self.delivery_timeout_s = float(delivery_timeout_s)
+        self.shutdown_timeout_s = float(shutdown_timeout_s)
+        self._lock = threading.Lock()
+        self._tickets: set[DeliveryTicket] = set()
+        self._quarantine_error: BaseException | None = None
+        self._closed = False
+
+    @property
+    def is_quarantined(self) -> bool:
+        with self._lock:
+            return self._quarantine_error is not None
+
+    def create_ticket(self, *, request_id: str, put_key: str) -> DeliveryTicket:
+        with self._lock:
+            if self._closed:
+                raise RuntimeError("MRv2 delivery manager is closed")
+            if self._quarantine_error is not None:
+                raise RuntimeError("MRv2 delivery manager is quarantined") from self._quarantine_error
+            ticket = DeliveryTicket(
+                self,
+                request_id=request_id,
+                put_key=put_key,
+                deadline=time.monotonic() + self.delivery_timeout_s,
+            )
+            self._tickets.add(ticket)
+            return ticket
+
+    def quarantine(self, error: BaseException) -> None:
+        with self._lock:
+            self._quarantine_locked(error, primary_ticket=None)
+
+    def shutdown(self, cause: BaseException | None = None) -> None:
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            if self._quarantine_error is None:
+                self._quarantine_error = cause or RuntimeError("MRv2 stage shutdown")
+            for ticket in tuple(self._tickets):
+                if ticket._state in _TERMINAL_STATES:
+                    continue
+                message = f"connector delivery cancelled for request {ticket.request_id!r}, key {ticket.put_key!r}"
+                if cause is not None:
+                    message += f": {cause}"
+                self._finish_locked(
+                    ticket,
+                    DeliveryState.CANCELLED,
+                    DeliveryCancelledError(message),
+                )
+
+    def _mark_in_flight(self, ticket: DeliveryTicket) -> bool:
+        with self._lock:
+            if ticket._state is not DeliveryState.QUEUED:
+                return False
+            ticket._state = DeliveryState.IN_FLIGHT
+            return True
+
+    def _set_delivered(self, ticket: DeliveryTicket) -> bool:
+        with self._lock:
+            if ticket._state in _TERMINAL_STATES:
+                return False
+            return self._finish_locked(ticket, DeliveryState.DELIVERED, None)
+
+    def _set_failed(self, ticket: DeliveryTicket, error: BaseException) -> bool:
+        with self._lock:
+            if ticket._state in _TERMINAL_STATES:
+                return False
+            self._quarantine_locked(error, primary_ticket=ticket)
+            return True
+
+    def _timeout(self, ticket: DeliveryTicket) -> bool:
+        error = DeliveryTimeoutError(
+            "connector delivery timed out after "
+            f"{self.delivery_timeout_s:.3f}s for request "
+            f"{ticket.request_id!r}, key {ticket.put_key!r}"
+        )
+        with self._lock:
+            if ticket._state in _TERMINAL_STATES:
+                return False
+            self._quarantine_locked(error, primary_ticket=ticket)
+            return True
+
+    def _quarantine_locked(
+        self,
+        error: BaseException,
+        *,
+        primary_ticket: DeliveryTicket | None,
+    ) -> None:
+        if self._quarantine_error is None:
+            self._quarantine_error = error
+        stage_error = self._quarantine_error
+        for ticket in tuple(self._tickets):
+            if ticket._state in _TERMINAL_STATES:
+                continue
+            ticket_error = error if ticket is primary_ticket else stage_error
+            self._finish_locked(ticket, DeliveryState.FAILED, ticket_error)
+
+    def _finish_locked(
+        self,
+        ticket: DeliveryTicket,
+        state: DeliveryState,
+        error: BaseException | None,
+    ) -> bool:
+        if ticket._state in _TERMINAL_STATES:
+            return False
+        ticket._state = state
+        ticket._error = error
+        self._tickets.discard(ticket)
+        ticket._event.set()
+        return True
diff --git a/vllm_omni/worker_v2/model_states/__init__.py b/vllm_omni/worker_v2/model_states/__init__.py
new file mode 100644
index 000000000..df327a129
--- /dev/null
+++ b/vllm_omni/worker_v2/model_states/__init__.py
@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Omni-aware ``init_model_state`` factory.
+
+Extends the upstream v2 factory with Omni architecture dispatch.
+Non-Omni architectures fall through to the upstream ``init_model_state``.
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+from vllm.config import VllmConfig
+from vllm.v1.worker.gpu.mm.encoder_cache import EncoderCache
+from vllm.v1.worker.gpu.model_states import (
+    init_model_state as _upstream_init_model_state,
+)
+from vllm.v1.worker.gpu.model_states.interface import ModelState
+
+
+def init_omni_model_state(
+    vllm_config: VllmConfig,
+    model: nn.Module,
+    encoder_cache: EncoderCache | None,
+    device: torch.device,
+) -> ModelState:
+    """Create the appropriate ``ModelState`` for *model*.
+
+    Returns an ``OmniModelState`` when the model declares Omni lifecycle
+    capabilities; otherwise
+    delegates to the upstream v2 factory.
+    """
+    uses_omni_lifecycle = any(
+        getattr(model, flag, False) is True for flag in ("has_preprocess", "has_postprocess", "have_multimodal_outputs")
+    )
+    if uses_omni_lifecycle:
+        from vllm_omni.worker_v2.model_states.omni_model_state import (
+            OmniModelState,
+        )
+
+        return OmniModelState(vllm_config, model, encoder_cache, device)
+    return _upstream_init_model_state(vllm_config, model, encoder_cache, device)
diff --git a/vllm_omni/worker_v2/model_states/intermediate_buffer.py b/vllm_omni/worker_v2/model_states/intermediate_buffer.py
new file mode 100644
index 000000000..b9614a729
--- /dev/null
+++ b/vllm_omni/worker_v2/model_states/intermediate_buffer.py
@@ -0,0 +1,265 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OmniIntermediateBuffer — per-request cross-stage state for Omni pipelines.
+
+Uses ``req_index`` (not ``req_id``) for O(1) access, aligned with v2's
+``RequestState`` slot management.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import torch
+from vllm.v1.core.sched.output import NewRequestData
+from vllm.v1.worker.gpu.input_batch import InputBatch
+
+from vllm_omni.worker.payload_span import get_tensor_span, merge_tensor_spans
+
+
+def _resolve_prompt_embeds(pe: Any) -> torch.Tensor | None:
+    """Convert a prompt_embeds payload to a contiguous CPU tensor."""
+    if pe is None:
+        return None
+    if isinstance(pe, torch.Tensor):
+        return pe.detach().cpu().contiguous()
+    try:
+        data = getattr(pe, "data", None)
+        shape = getattr(pe, "shape", None)
+        if data is not None and shape is not None:
+            dt = np.dtype(getattr(pe, "dtype", "float32"))
+            arr = np.frombuffer(data, dtype=dt).reshape(shape)
+            return torch.from_numpy(arr.copy())
+    except Exception as exc:
+        raise ValueError("Failed to decode prompt_embeds payload") from exc
+    raise TypeError(f"Unsupported prompt_embeds payload type: {type(pe).__name__}")
+
+
+def _resolve_additional_information(payload: Any) -> dict[str, Any]:
+    """Convert an additional_information payload to a plain dict."""
+    if payload is None:
+        return {}
+    try:
+        from vllm_omni.data_entry_keys import unflatten_payload
+        from vllm_omni.engine.serialization import deserialize_additional_information
+
+        info = deserialize_additional_information(payload)
+        if isinstance(info, dict) and any(isinstance(key, str) and "." in key for key in info):
+            info = unflatten_payload(info)
+    except Exception as exc:
+        raise ValueError("Failed to decode additional_information payload") from exc
+    if not isinstance(info, dict):
+        raise TypeError(f"Decoded additional_information must be a dict, got {type(info).__name__}")
+    return info
+
+
+class OmniIntermediateBuffer:
+    """Per-request intermediate state for multi-stage Omni pipelines.
+
+    Stores ``prompt_embeds``, ``additional_information``, ``mm_features``,
+    ``req_id`` and any runtime updates written back by model postprocess.
+    """
+
+    def __init__(self, max_num_reqs: int):
+        self.buffers: list[dict[str, Any]] = [{} for _ in range(max_num_reqs)]
+        self.req_id_to_index: dict[str, int] = {}
+
+    def add_request(self, req_index: int, new_req_data: NewRequestData) -> None:
+        info: dict[str, Any] = {}
+
+        pe = getattr(new_req_data, "prompt_embeds", None)
+        if pe is not None:
+            pe_cpu = _resolve_prompt_embeds(pe)
+            if pe_cpu is not None:
+                info["prompt_embeds_cpu"] = pe_cpu
+
+        ai = getattr(new_req_data, "additional_information", None)
+        if ai is not None:
+            info.update(_resolve_additional_information(ai))
+
+        if new_req_data.mm_features:
+            info["mm_features"] = new_req_data.mm_features
+
+        sampling_params = getattr(new_req_data, "sampling_params", None)
+        if sampling_params is not None:
+            info["sampling_params"] = sampling_params
+
+        info["req_id"] = new_req_data.req_id
+        previous_id = self.buffers[req_index].get("req_id")
+        if previous_id is not None and self.req_id_to_index.get(previous_id) == req_index:
+            self.req_id_to_index.pop(previous_id, None)
+        self.buffers[req_index] = info
+        self.req_id_to_index[new_req_data.req_id] = req_index
+
+    def remove_request(self, req_index: int) -> None:
+        req_id = self.buffers[req_index].get("req_id")
+        if req_id is not None and self.req_id_to_index.get(req_id) == req_index:
+            self.req_id_to_index.pop(req_id)
+        self.buffers[req_index] = {}
+
+    def gather(self, input_batch: InputBatch) -> list[dict[str, Any]]:
+        """Return buffer dicts in current batch order (via ``idx_mapping_np``)."""
+        return [self.buffers[idx] for idx in input_batch.idx_mapping_np]
+
+    @staticmethod
+    def _split_gpu_keys(gpu_resident_keys: set[Any] | None) -> tuple[set[Any], dict[Any, set[Any]]]:
+        top_level: set[Any] = set()
+        nested: dict[Any, set[Any]] = {}
+        for key in gpu_resident_keys or set():
+            if isinstance(key, tuple) and len(key) == 2:
+                nested.setdefault(key[0], set()).add(key[1])
+            else:
+                top_level.add(key)
+        return top_level, nested
+
+    @staticmethod
+    def _store_value(dest: dict[Any, Any], key: Any, value: Any, gpu_keys: set[Any]) -> None:
+        if isinstance(value, torch.Tensor):
+            if key in gpu_keys:
+                dest[key] = value.detach().clone()
+            else:
+                dest[key] = value.detach().cpu().contiguous()
+        elif isinstance(value, list):
+            dest[key] = [
+                (
+                    item.detach().clone()
+                    if key in gpu_keys and isinstance(item, torch.Tensor)
+                    else item.detach().cpu().contiguous()
+                    if isinstance(item, torch.Tensor)
+                    else item
+                )
+                for item in value
+            ]
+        else:
+            dest[key] = value
+
+    def update(
+        self,
+        req_index: int,
+        updates: dict[Any, Any],
+        gpu_resident_keys: set[Any] | None = None,
+    ) -> None:
+        """Merge *updates* into the buffer at *req_index*.
+
+        Tensors are detached; those whose key is **not** in
+        *gpu_resident_keys* are moved to CPU.
+        """
+        if not updates:
+            return
+        top_gpu_keys, nested_gpu_keys = self._split_gpu_keys(gpu_resident_keys)
+        existing = self.buffers[req_index]
+        for k, v in updates.items():
+            if isinstance(k, tuple) and len(k) == 2:
+                type_key, qualifier = k
+                existing_sub = existing.setdefault(type_key, {})
+                if not isinstance(existing_sub, dict):
+                    existing_sub = {}
+                    existing[type_key] = existing_sub
+                self._store_value(existing_sub, qualifier, v, nested_gpu_keys.get(type_key, set()))
+            elif isinstance(v, dict):
+                existing_sub = existing.setdefault(k, {})
+                if not isinstance(existing_sub, dict):
+                    existing_sub = {}
+                    existing[k] = existing_sub
+                merged_qualifiers: set[str] = set()
+                if k == "embed" and isinstance(v.get("decode"), torch.Tensor):
+                    span_keys = {"decode_token_start", "decode_token_end"}
+                    if span_keys.intersection(v):
+                        incoming_span = get_tensor_span(
+                            v,
+                            tensor_key="decode",
+                            start_key="decode_token_start",
+                            end_key="decode_token_end",
+                        )
+                        if incoming_span is None:
+                            raise RuntimeError("Incoming Thinker decode delta has an invalid absolute span")
+                        existing_span = get_tensor_span(
+                            existing_sub,
+                            tensor_key="decode",
+                            start_key="decode_token_start",
+                            end_key="decode_token_end",
+                        )
+                        merged_span: tuple[Any, int, int] | None = incoming_span
+                        if existing_span is not None:
+                            merged_span = merge_tensor_spans(existing_span, incoming_span)
+                            if merged_span is None:
+                                raise RuntimeError(
+                                    "Non-contiguous pending Thinker decode spans in model buffer: "
+                                    f"existing=[{existing_span[1]}, {existing_span[2]}) "
+                                    f"incoming=[{incoming_span[1]}, {incoming_span[2]})"
+                                )
+                        assert merged_span is not None
+                        merged_tensor, merged_start, merged_end = merged_span
+                        self._store_value(
+                            existing_sub,
+                            "decode",
+                            merged_tensor,
+                            nested_gpu_keys.get(k, set()),
+                        )
+                        existing_sub["decode_token_start"] = merged_start
+                        existing_sub["decode_token_end"] = merged_end
+                        merged_qualifiers.update({"decode", "decode_token_start", "decode_token_end"})
+                for qualifier, value in v.items():
+                    if qualifier in merged_qualifiers:
+                        continue
+                    self._store_value(existing_sub, qualifier, value, nested_gpu_keys.get(k, set()))
+            else:
+                self._store_value(existing, k, v, top_gpu_keys)
+
+    def update_gpu_tensor_rows(
+        self,
+        req_indices: list[int],
+        key: Any,
+        values: torch.Tensor,
+        *,
+        keepdim: bool = True,
+    ) -> None:
+        """Snapshot a batch-first tensor once and retain owned row views."""
+        self._store_gpu_tensor_rows(req_indices, key, values.detach().clone(), keepdim=keepdim)
+
+    def update_owned_gpu_tensor_rows(
+        self,
+        req_indices: list[int],
+        key: Any,
+        owned_values: torch.Tensor,
+        *,
+        keepdim: bool = True,
+    ) -> None:
+        """Store row views of an already-owned batch tensor without cloning.
+
+        The caller must guarantee ``owned_values`` is not written after this
+        call (the model output ownership contract). Row views keep the owned storage
+        alive until each request row is replaced or the slot is freed.
+        """
+        self._store_gpu_tensor_rows(req_indices, key, owned_values, keepdim=keepdim)
+
+    def _store_gpu_tensor_rows(
+        self,
+        req_indices: list[int],
+        key: Any,
+        owned: torch.Tensor,
+        *,
+        keepdim: bool,
+    ) -> None:
+        num_rows = len(req_indices)
+        if owned.ndim == 0 or owned.shape[0] != num_rows:
+            raise ValueError(
+                "Batched GPU state update changed the request axis: "
+                f"key={key!r} expected={num_rows} "
+                f"actual={owned.shape[0] if owned.ndim else 0}"
+            )
+
+        for row, req_index in enumerate(req_indices):
+            existing = self.buffers[req_index]
+            row_value = owned[row : row + 1] if keepdim else owned[row]
+            if isinstance(key, tuple) and len(key) == 2:
+                type_key, qualifier = key
+                existing_sub = existing.setdefault(type_key, {})
+                if not isinstance(existing_sub, dict):
+                    existing_sub = {}
+                    existing[type_key] = existing_sub
+                existing_sub[qualifier] = row_value
+            else:
+                existing[key] = row_value
diff --git a/vllm_omni/worker_v2/model_states/omni_model_state.py b/vllm_omni/worker_v2/model_states/omni_model_state.py
new file mode 100644
index 000000000..48515b4f5
--- /dev/null
+++ b/vllm_omni/worker_v2/model_states/omni_model_state.py
@@ -0,0 +1,1223 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OmniModelState — generic ModelState base for all Omni model stages.
+
+Extends ``DefaultModelState`` with:
+
+* Cross-stage intermediate buffer (``OmniIntermediateBuffer``)
+* ``model_intermediate_buffer`` / ``runtime_additional_information`` injection
+  into ``model_inputs`` via ``prepare_inputs()``
+* ``OmniOutput`` → ``(text_hidden, multimodal_outputs)`` post-processing
+"""
+
+from __future__ import annotations
+
+import inspect
+import threading
+import types
+from collections.abc import Callable
+from typing import Any, cast
+
+import torch
+import torch.nn as nn
+from vllm.config import VllmConfig
+from vllm.config.compilation import CUDAGraphMode
+from vllm.logger import init_logger
+from vllm.v1.core.sched.output import NewRequestData
+from vllm.v1.worker.gpu.input_batch import InputBatch
+from vllm.v1.worker.gpu.mm.encoder_cache import EncoderCache
+from vllm.v1.worker.gpu.model_states.default import DefaultModelState
+from vllm.v1.worker.gpu.states import RequestState
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput, OwnedBatchTensor
+from vllm_omni.platforms import current_omni_platform
+from vllm_omni.worker_v2.model_states.intermediate_buffer import (
+    OmniIntermediateBuffer,
+)
+
+logger = init_logger(__name__)
+
+
+_rope_patch_lock = threading.Lock()
+
+
+def _default_mrope_positions(
+    self_model: Any,
+    input_tokens: list[int],
+    mm_features: list,
+) -> tuple[torch.Tensor, int]:
+    """Return 3D sequential positions with zero delta.
+
+    For non-vision Omni models (e.g. TTS Talker), all 3 M-RoPE
+    dimensions use the same sequential positions. Delta=0 keeps decode
+    positions sequential, identical to the 1D case but broadcast to 3 dims.
+    """
+    n = len(input_tokens)
+    pos = torch.arange(n, dtype=torch.long)
+    return pos.unsqueeze(0).expand(3, -1), 0
+
+
+def _make_safe_get_rope(orig_get_rope):
+    from vllm.v1.worker.gpu.mm.rope import RopeState
+
+    def _safe_get_rope(model_config: Any, mdl: Any, **kwargs: Any) -> Any:
+        try:
+            result = orig_get_rope(model_config, mdl, **kwargs)
+        except AssertionError:
+            result = None
+
+        needs_mrope = bool(getattr(model_config, "uses_mrope", False))
+        if result is not None and (not needs_mrope or getattr(result, "num_dims", 0) >= 3):
+            return result
+        if not needs_mrope:
+            return None
+        if not hasattr(mdl, "get_mrope_input_positions"):
+            mdl.get_mrope_input_positions = types.MethodType(_default_mrope_positions, mdl)
+        return RopeState(num_dims=3, has_delta=True, **kwargs)
+
+    return _safe_get_rope
+
+
+class OmniModelState(DefaultModelState):
+    """Generic Omni ``ModelState`` — works for **all** Omni model stages.
+
+    Model-owned preprocess and postprocess hooks supply stage-specific behavior.
+    """
+
+    def __init__(
+        self,
+        vllm_config: VllmConfig,
+        model: nn.Module,
+        encoder_cache: EncoderCache | None,
+        device: torch.device,
+    ) -> None:
+        # DefaultModelState.__init__ calls get_rope_state() which asserts
+        # isinstance(model, SupportsMRoPE).  Two categories of Omni models:
+        #
+        # 1. Models that implement SupportsMRoPE (e.g. Qwen3-Omni Thinker):
+        #    get_rope_state() succeeds normally, _safe_get_rope is a no-op.
+        #    These models get correct 3D M-RoPE positions from the runner.
+        #
+        # 2. Models that do NOT implement SupportsMRoPE (e.g. Qwen3-TTS
+        #    Talker, Code2Wav, FishSpeech): get_rope_state() would assert.
+        #    These models compute their own position encoding internally
+        #    (via model.forward kwargs or fixed 1D positions from
+        #    InputBatch.positions), so rope_state = None is correct —
+        #    DefaultModelState.prepare_inputs returns {} when rope_state
+        #    is None, and upstream execute_model falls back to
+        #    InputBatch.positions (1D sequential).
+        # Patch get_rope_state to handle Omni models that declare
+        # M-RoPE in config (mrope_section) but do not implement the
+        # SupportsMRoPE interface.  For these models we create a
+        # RopeState with 3D sequential positions (matching V1 MR).
+        #
+        # The patch is applied via a class-level lock to prevent
+        # concurrent OmniModelState instances (e.g. different stages
+        # in a thread pool) from overwriting each other's patch.
+        from vllm.v1.worker.gpu.model_states import default as _default_mod
+
+        with _rope_patch_lock:
+            orig_get_rope = _default_mod.get_rope_state
+            _default_mod.get_rope_state = _make_safe_get_rope(orig_get_rope)
+            try:
+                super().__init__(vllm_config, model, encoder_cache, device)
+            finally:
+                _default_mod.get_rope_state = orig_get_rope
+        max_num_reqs = self.scheduler_config.max_num_seqs
+        self.intermediate_buffer = OmniIntermediateBuffer(max_num_reqs)
+        self.has_preprocess: bool = getattr(model, "has_preprocess", False)
+        self.has_postprocess: bool = getattr(model, "has_postprocess", False)
+        self.have_multimodal_outputs: bool = getattr(model, "have_multimodal_outputs", False)
+        self._decode_preprocess = self._resolve_decode_preprocess(model)
+        self._mtp_generators: dict[str, torch.Generator] = {}
+        # Talker's codec_embedding dim may differ from hf_text_config.hidden_size; probe real dim.
+        self._embed_dim = self._get_embed_dim(model, device) if self.has_preprocess else 0
+
+        # Static inputs_embeds buffer for FULL CUDA graph — preprocess fills it in-place each step.
+        self._static_inputs_embeds: torch.Tensor | None = None
+        if self._embed_dim > 0:
+            self._static_inputs_embeds = torch.zeros(
+                (self.max_num_tokens, self._embed_dim),
+                dtype=self.dtype,
+                device=device,
+            )
+
+        # Static MTP buffers so _run_batched_mtp uses .copy_() instead of torch.cat().
+        self._mtp_input_ids: torch.Tensor | None = None
+        self._mtp_input_embeds: torch.Tensor | None = None
+        self._mtp_hidden: torch.Tensor | None = None
+        self._mtp_text_step: torch.Tensor | None = None
+        self._mtp_offsets: torch.Tensor | None = None
+        self._mtp_sample_uniforms: torch.Tensor | None = None
+        self._mtp_runner: Any | None = None
+        if self._embed_dim > 0 and hasattr(model, "mtp"):
+            max_bs = max_num_reqs
+            self._mtp_input_ids = torch.zeros(max_bs, dtype=torch.long, device=device)
+            self._mtp_input_embeds = torch.zeros((max_bs, self._embed_dim), dtype=self.dtype, device=device)
+            self._mtp_hidden = torch.zeros((max_bs, self._embed_dim), dtype=self.dtype, device=device)
+            self._mtp_text_step = torch.zeros((max_bs, self._embed_dim), dtype=self.dtype, device=device)
+            self._mtp_offsets = torch.zeros(max_bs, dtype=torch.long, device=device)
+            sample_steps = int(getattr(model, "mtp_sample_steps", 0))
+            sample_vocab_size = int(getattr(model, "mtp_sample_vocab_size", 0))
+            if bool(getattr(model, "mtp_sample_uniforms", False)) and sample_steps > 0 and sample_vocab_size > 0:
+                self._mtp_sample_uniforms = torch.empty(
+                    (max_bs, sample_steps, sample_vocab_size),
+                    dtype=torch.float32,
+                    device=device,
+                )
+            self._mtp_runner = self._init_mtp_runner(model)
+
+    @staticmethod
+    def _resolve_decode_preprocess(model: nn.Module) -> Callable | None:
+        """Adapt existing V1 hooks once, outside the per-step hot path.
+
+        Keep the V2 hook precedence for models with an optimized implementation.
+        Both hooks return the same five values; only the embedding argument is
+        optional in the original contract. Errors inside a hook propagate.
+        """
+        hook = getattr(model, "preprocess_decode_batch_mrv2", None)
+        if not callable(hook):
+            hook = getattr(model, "preprocess_decode_batch", None)
+        if not callable(hook):
+            return None
+        parameters = inspect.signature(hook).parameters
+        if "input_embeds" in parameters or any(p.kind == inspect.Parameter.VAR_KEYWORD for p in parameters.values()):
+            return hook
+
+        def decode_preprocess(*, input_ids, input_embeds, req_infos):
+            return hook(input_ids=input_ids, req_infos=req_infos)
+
+        return decode_preprocess
+
+    def _init_mtp_runner(self, model: nn.Module) -> Any:
+        mtp = getattr(model, "mtp", None)
+        if mtp is None:
+            return None
+        output_key = getattr(model, "mtp_output_key", None)
+        if not (isinstance(output_key, str) or (isinstance(output_key, tuple) and len(output_key) == 2)):
+            raise TypeError("Models with an mtp hook must declare mtp_output_key as a string or 2-tuple")
+
+        compilation_config = self.vllm_config.compilation_config
+        cudagraph_mode = getattr(compilation_config, "cudagraph_mode", CUDAGraphMode.NONE)
+        if bool(getattr(model, "mtp_disable_graph", False)):
+            logger.info("Skipping mtp graph wrapper because the model marks it graph-unsafe.")
+            return mtp
+        graph_safe = bool(getattr(model, "mtp_graph_safe", False))
+        if cudagraph_mode is not None and cudagraph_mode.has_full_cudagraphs() and graph_safe:
+            graph_wrapper_cls = current_omni_platform.get_graph_wrapper_cls()
+            return graph_wrapper_cls(mtp, self.vllm_config, runtime_mode=CUDAGraphMode.FULL)
+        return mtp
+
+    def _is_mtp_graph_runner(self) -> bool:
+        runner = getattr(self, "_mtp_runner", None)
+        if runner is None:
+            return False
+        graph_wrapper_cls = current_omni_platform.get_graph_wrapper_cls()
+        return isinstance(runner, graph_wrapper_cls)
+
+    def capture_mtp_graphs(self, dispatch_batch_descriptor: Callable[[int], Any]) -> None:
+        if not self._is_mtp_graph_runner():
+            return
+        if (
+            self._mtp_input_ids is None
+            or self._mtp_input_embeds is None
+            or self._mtp_hidden is None
+            or self._mtp_text_step is None
+        ):
+            return
+        if getattr(self.model, "mtp_accepts_req_infos", False):
+            logger.warning("Skipping mtp graph capture because this model requires per-request req_infos.")
+            return
+
+        from vllm.compilation.monitor import set_cudagraph_capturing_enabled
+        from vllm.distributed.parallel_state import graph_capture
+        from vllm.forward_context import set_forward_context
+
+        compilation_config = self.vllm_config.compilation_config
+        capture_sizes = self._get_mtp_capture_sizes()
+        num_warmups = compilation_config.cudagraph_num_of_warmups
+        capture_kwargs = self._get_mtp_base_sampling_kwargs()
+        logger.info("Capturing MRv2 mtp graphs for sizes %s", capture_sizes)
+
+        set_cudagraph_capturing_enabled(True)
+        try:
+            with torch.inference_mode(), graph_capture(device=self.device):
+                for bsz in capture_sizes:
+                    batch_descriptor = dispatch_batch_descriptor(int(bsz))
+                    num_tokens = int(getattr(batch_descriptor, "num_tokens", bsz))
+                    ids = self._mtp_input_ids[:num_tokens]
+                    emb = self._mtp_input_embeds[:num_tokens]
+                    hidden = self._mtp_hidden[:num_tokens]
+                    text_step = self._mtp_text_step[:num_tokens]
+
+                    for _ in range(num_warmups):
+                        with set_forward_context(
+                            None,
+                            self.vllm_config,
+                            cudagraph_runtime_mode=CUDAGraphMode.NONE,
+                            batch_descriptor=batch_descriptor,
+                        ):
+                            self._call_mtp_runner(ids, emb, hidden, text_step, **capture_kwargs)
+
+                    with set_forward_context(
+                        None,
+                        self.vllm_config,
+                        cudagraph_runtime_mode=CUDAGraphMode.FULL,
+                        batch_descriptor=batch_descriptor,
+                    ):
+                        sample_uniforms = None
+                        if self._mtp_sample_uniforms is not None:
+                            sample_uniforms = self._mtp_sample_uniforms[:num_tokens]
+                            sample_uniforms.fill_(0.5)
+                        self._call_mtp_runner(
+                            ids,
+                            emb,
+                            hidden,
+                            text_step,
+                            sample_uniforms=sample_uniforms,
+                            **capture_kwargs,
+                        )
+                    torch.accelerator.synchronize()
+
+            logger.info("Captured MRv2 mtp graphs for %d sizes", len(capture_sizes))
+        except RuntimeError as e:
+            raise RuntimeError(f"MRv2 mtp graph capture failed: {e}") from e
+        finally:
+            set_cudagraph_capturing_enabled(False)
+
+    def _get_mtp_capture_sizes(self) -> list[int]:
+        """Return graph buckets that a request-batched Talker can reach."""
+        max_num_reqs = int(self.scheduler_config.max_num_seqs)
+        return sorted(
+            {
+                int(size)
+                for size in self.vllm_config.compilation_config.cudagraph_capture_sizes
+                if 0 < int(size) <= max_num_reqs
+            },
+            reverse=True,
+        )
+
+    @staticmethod
+    def _get_embed_dim(model: nn.Module, device: torch.device) -> int:
+        """Return the embedding dim that ``embed_input_ids`` produces (may differ from hf_text_config)."""
+        if hasattr(model, "embed_input_ids"):
+            dummy = torch.zeros(1, dtype=torch.long, device=device)
+            with torch.no_grad():
+                out = model.embed_input_ids(dummy)
+            return out.shape[-1]
+        return 0
+
+    # ------------------------------------------------------------------
+    # Request lifecycle
+    # ------------------------------------------------------------------
+
+    def add_request(self, req_index: int, new_req_data: NewRequestData) -> None:
+        super().add_request(req_index, new_req_data)
+        self.intermediate_buffer.add_request(req_index, new_req_data)
+        self._initialize_upstream_warmup_buffer(req_index, new_req_data.req_id)
+
+    def _initialize_upstream_warmup_buffer(self, req_index: int, req_id: str) -> None:
+        """Satisfy model-declared output contracts for vLLM warmup requests."""
+        if not str(req_id).startswith("_warmup_"):
+            return
+
+        validity_key = getattr(self.model, "mtp_validity_key", None)
+        if validity_key is None:
+            return
+
+        validity = torch.zeros((), dtype=torch.bool)
+        buffer = self.intermediate_buffer.buffers[req_index]
+        if isinstance(validity_key, tuple) and len(validity_key) == 2:
+            buffer.setdefault(validity_key[0], {})[validity_key[1]] = validity
+        elif isinstance(validity_key, str):
+            buffer[validity_key] = validity
+        else:
+            raise TypeError(
+                f"mtp_validity_key must be a string or 2-tuple, got {type(validity_key).__name__}: {validity_key!r}"
+            )
+
+    def _resolve_req_index(self, req_index_or_id: int | str) -> int | None:
+        if isinstance(req_index_or_id, int):
+            return req_index_or_id
+
+        return self.intermediate_buffer.req_id_to_index.get(req_index_or_id)
+
+    def remove_request(self, req_index_or_id: int | str) -> None:
+        req_index = self._resolve_req_index(req_index_or_id)
+        if req_index is None:
+            return
+        req_id = self.intermediate_buffer.buffers[req_index].get("req_id")
+        if req_id is not None:
+            getattr(self, "_mtp_generators", {}).pop(req_id, None)
+        self.intermediate_buffer.remove_request(req_index)
+
+    # ------------------------------------------------------------------
+    # Input preparation
+    # ------------------------------------------------------------------
+
+    def prepare_inputs(self, input_batch: InputBatch, req_states: RequestState) -> dict[str, Any]:
+        # Forward-only stages have no preprocess hook. Honor their declared
+        # GPU inputs before gathering the model's runtime view, so payload
+        # tensors do not fall back to per-request blocking device copies.
+        if not self.has_preprocess and getattr(self.model, "batched_gpu_staging_keys", None):
+            self._stage_batched_preprocess_inputs(
+                [int(input_batch.idx_mapping_np[i]) for i in range(input_batch.num_reqs)],
+                input_batch.input_ids.device,
+            )
+        base = super().prepare_inputs(input_batch, req_states)
+        buffer_list = self.intermediate_buffer.gather(input_batch)
+        base["model_intermediate_buffer"] = buffer_list
+        base["runtime_additional_information"] = buffer_list
+        base["seq_token_counts"] = [int(input_batch.num_scheduled_tokens[i]) for i in range(input_batch.num_reqs)]
+        # Return static inputs_embeds so FULL graph replay uses the same
+        # tensor address that was captured.  Preprocess fills it in-place.
+        if self._static_inputs_embeds is not None:
+            base["inputs_embeds"] = self._static_inputs_embeds[: input_batch.num_tokens_after_padding]
+        return base
+
+    def prepare_dummy_inputs(self, num_reqs: int, num_tokens: int) -> dict[str, Any]:
+        base = super().prepare_dummy_inputs(num_reqs, num_tokens)
+        dummy_buffer: list[dict[str, Any]] = [{} for _ in range(num_reqs)]
+        base["model_intermediate_buffer"] = dummy_buffer
+        base["runtime_additional_information"] = dummy_buffer
+        if num_reqs > 0:
+            per_req = num_tokens // num_reqs
+            remainder = num_tokens % num_reqs
+            counts = [per_req] * num_reqs
+            counts[-1] += remainder
+            base["seq_token_counts"] = counts
+        else:
+            base["seq_token_counts"] = []
+        # Return static inputs_embeds for FULL graph capture so the graph
+        # captures this tensor's address.
+        if self._static_inputs_embeds is not None:
+            base["inputs_embeds"] = self._static_inputs_embeds[:num_tokens]
+        return base
+
+    # ------------------------------------------------------------------
+    # Pre-forward: per-request preprocess + batched MTP
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _get_req_state_value(field: Any, req_idx: int) -> int | None:
+        values = getattr(field, "np", field)
+        try:
+            return int(values[req_idx])
+        except Exception:
+            return None
+
+    @staticmethod
+    def _get_input_batch_num_computed(input_batch: InputBatch, req_idx: int, batch_idx: int) -> int | None:
+        for attr in ("num_computed_tokens_cpu", "num_computed_tokens_np"):
+            values = getattr(input_batch, attr, None)
+            if values is None:
+                continue
+            try:
+                if len(values) == getattr(input_batch, "num_reqs", len(values)):
+                    return int(values[batch_idx])
+                return int(values[req_idx])
+            except Exception:
+                continue
+        return None
+
+    @staticmethod
+    def _preprocess_result_needs_writeback(original: torch.Tensor, updated: torch.Tensor) -> bool:
+        return updated is not original
+
+    @staticmethod
+    def _batch_move_tensor_rows(
+        tensors: list[torch.Tensor],
+        device: torch.device,
+    ) -> list[torch.Tensor]:
+        """Move compatible variable-length rows with one device transfer."""
+        lengths = [int(tensor.shape[0]) for tensor in tensors]
+        staged = torch.cat(tensors, dim=0).to(device=device, non_blocking=True)
+        return list(staged.split(lengths, dim=0))
+
+    def _stage_batched_preprocess_inputs(
+        self,
+        req_indices: list[int],
+        device: torch.device,
+    ) -> None:
+        staging_keys: set[tuple[str, str]] = getattr(self.model, "batched_gpu_staging_keys", set())
+        for key in staging_keys:
+            if not isinstance(key, tuple) or len(key) != 2:
+                raise TypeError(f"batched_gpu_staging_keys entries must be 2-tuples, got {key!r}")
+            type_key, qualifier = key
+            groups: dict[
+                tuple[torch.device, torch.dtype, tuple[int, ...]], list[tuple[dict[str, Any], torch.Tensor]]
+            ] = {}
+            for req_idx in req_indices:
+                nested = self.intermediate_buffer.buffers[req_idx].get(type_key)
+                if not isinstance(nested, dict):
+                    continue
+                tensor = nested.get(qualifier)
+                if not isinstance(tensor, torch.Tensor) or tensor.device == device:
+                    continue
+                group_key = tensor.device, tensor.dtype, tuple(tensor.shape[1:])
+                groups.setdefault(group_key, []).append((nested, tensor))
+
+            for group in groups.values():
+                staged_rows = self._batch_move_tensor_rows([tensor for _nested, tensor in group], device)
+                for (nested, _tensor), staged in zip(group, staged_rows, strict=True):
+                    nested[qualifier] = staged
+
+    def _write_batched_gpu_preprocess_updates(
+        self,
+        req_indices: list[int],
+        updates_by_req: list[dict[str, Any]],
+        gpu_keys: set[Any],
+    ) -> None:
+        """Snapshot compatible resident preprocess values once per cohort."""
+        if not req_indices or len(req_indices) != len(updates_by_req):
+            return
+
+        for key in gpu_keys:
+            nested_key = isinstance(key, tuple) and len(key) == 2
+            values: list[torch.Tensor] = []
+            for updates in updates_by_req:
+                if nested_key:
+                    type_key, qualifier = key
+                    nested = updates.get(type_key)
+                    value = nested.get(qualifier) if isinstance(nested, dict) else None
+                else:
+                    value = updates.get(key)
+                if not isinstance(value, torch.Tensor):
+                    break
+                values.append(value)
+            if len(values) != len(updates_by_req):
+                continue
+
+            first = values[0]
+            if any(
+                value.shape != first.shape or value.dtype != first.dtype or value.device != first.device
+                for value in values[1:]
+            ):
+                continue
+
+            stacked = torch.stack(values, dim=0)
+            self.intermediate_buffer.update_gpu_tensor_rows(
+                req_indices,
+                key,
+                stacked,
+                keepdim=False,
+            )
+
+            for updates in updates_by_req:
+                if nested_key:
+                    type_key, qualifier = key
+                    nested = updates[type_key]
+                    del nested[qualifier]
+                    if not nested:
+                        del updates[type_key]
+                else:
+                    del updates[key]
+
+    def run_preprocess(
+        self,
+        input_batch: InputBatch,
+        model_inputs: dict[str, Any],
+        req_states: RequestState | None = None,
+        mtp_batch_descriptor_dispatcher: Callable[[int], Any] | None = None,
+    ) -> None:
+        """Per-request preprocess + MTP before model forward.
+
+        Modifies ``model_inputs["input_ids"]`` and ``model_inputs["inputs_embeds"]``
+        in-place.  Collects decode-step MTP inputs and runs a single batched MTP
+        forward at the end.
+        """
+        if not self.has_preprocess:
+            return
+
+        input_ids = model_inputs.get("input_ids")
+        if input_ids is None:
+            input_ids = input_batch.input_ids
+
+        embeds = model_inputs.get("inputs_embeds")
+        if embeds is None:
+            embeds = self.model.embed_input_ids(input_batch.input_ids[: input_batch.num_tokens])
+            model_inputs["inputs_embeds"] = embeds
+        elif self._static_inputs_embeds is not None and embeds.data_ptr() == self._static_inputs_embeds.data_ptr():
+            # FULL graph replay requires a stable inputs_embeds address. Refresh
+            # the active rows from the current token ids before model-specific
+            # preprocessing; otherwise decode reuses embeddings left by the
+            # previous step at the same static address.
+            num_active_tokens = int(getattr(input_batch, "num_tokens", input_ids.shape[0]))
+            token_embeds = self.model.embed_input_ids(input_ids[:num_active_tokens])
+            embeds[:num_active_tokens].copy_(token_embeds)
+
+        gpu_keys: set[str] = getattr(self.model, "gpu_resident_buffer_keys", set())
+        mtp_batches: list[tuple[int, int, tuple[torch.Tensor, torch.Tensor]]] = []
+        prepacked_mtp_inputs: tuple[torch.Tensor, torch.Tensor] | None = None
+
+        req_indices = [int(input_batch.idx_mapping_np[i]) for i in range(input_batch.num_reqs)]
+        self._stage_batched_preprocess_inputs(req_indices, embeds.device)
+
+        preprocess_entries: list[tuple[int, int, int, int, dict[str, Any], bool]] = []
+        for i, req_idx in enumerate(req_indices):
+            buf = self.intermediate_buffer.buffers[req_idx]
+            if not buf or "req_id" not in buf:
+                continue
+            if str(buf["req_id"]).startswith("_warmup_"):
+                continue
+
+            start = int(input_batch.query_start_loc_np[i])
+            n_tok = int(input_batch.num_scheduled_tokens[i])
+
+            info = {key: value for key, value in buf.items() if isinstance(key, str)}
+            prompt_len = None
+            num_computed_tokens = None
+            if req_states is not None:
+                prompt_len = self._get_req_state_value(getattr(req_states, "prompt_len", None), req_idx)
+                num_computed_tokens = self._get_req_state_value(
+                    getattr(req_states, "num_computed_tokens", None),
+                    req_idx,
+                )
+            if num_computed_tokens is None:
+                num_computed_tokens = self._get_input_batch_num_computed(input_batch, req_idx, i)
+            if prompt_len is not None:
+                info["_omni_prompt_len"] = int(prompt_len)
+            if num_computed_tokens is not None:
+                info["_omni_num_computed_tokens"] = int(num_computed_tokens)
+            if prompt_len is not None and num_computed_tokens is not None:
+                info["_omni_is_prefill"] = int(num_computed_tokens) < int(prompt_len)
+
+            is_prefill = (
+                int(num_computed_tokens) < int(prompt_len)
+                if prompt_len is not None and num_computed_tokens is not None
+                else n_tok > 1
+            )
+            preprocess_entries.append((i, req_idx, start, n_tok, info, is_prefill))
+
+        preprocess_batch_mrv2 = getattr(self.model, "preprocess_batch_mrv2", None)
+        if callable(preprocess_batch_mrv2):
+            prefill_infos = [
+                self.intermediate_buffer.buffers[req_idx]
+                for _i, req_idx, _start, _n_tok, _info, is_prefill in preprocess_entries
+                if is_prefill
+            ]
+            if prefill_infos:
+                preprocess_batch_mrv2(req_infos=prefill_infos, device=embeds.device)
+                for _i, req_idx, _start, _n_tok, info, is_prefill in preprocess_entries:
+                    if not is_prefill:
+                        continue
+                    runtime_info = {key: value for key, value in info.items() if key.startswith("_omni_")}
+                    info.update(self.intermediate_buffer.buffers[req_idx])
+                    info.update(runtime_info)
+
+        if not hasattr(self, "_decode_preprocess"):
+            self._decode_preprocess = self._resolve_decode_preprocess(self.model)
+        batch_decode_preprocess = self._decode_preprocess
+        decode_entries = [entry for entry in preprocess_entries if entry[3] == 1 and not entry[5]]
+        batched_decode_indices: set[int] = set()
+        if callable(batch_decode_preprocess) and decode_entries:
+            batch_size = len(decode_entries)
+            starts = [entry[2] for entry in decode_entries]
+            is_contiguous_cohort = all(entry[0] == row and entry[2] == row for row, entry in enumerate(decode_entries))
+            if is_contiguous_cohort:
+                batch_ids = input_ids[:batch_size]
+                batch_embeds = embeds[:batch_size]
+                batch_offsets = None
+            else:
+                batch_offsets = torch.as_tensor(starts, device=input_ids.device, dtype=torch.long)
+                batch_ids = input_ids.index_select(0, batch_offsets)
+                batch_embeds = embeds.index_select(0, batch_offsets)
+
+            new_ids, new_embeds, batch_hidden, batch_text_step, updates_by_req = batch_decode_preprocess(
+                input_ids=batch_ids,
+                input_embeds=batch_embeds,
+                req_infos=[entry[4] for entry in decode_entries],
+            )
+            if len(updates_by_req) != batch_size:
+                raise RuntimeError(
+                    "Batched Omni preprocess returned the wrong update count: "
+                    f"expected={batch_size} actual={len(updates_by_req)}"
+                )
+            if batch_hidden.shape[0] != batch_size or batch_text_step.shape[0] != batch_size:
+                raise RuntimeError(
+                    "Batched Omni preprocess changed the request axis: "
+                    f"expected={batch_size} hidden={batch_hidden.shape[0]} text_step={batch_text_step.shape[0]}"
+                )
+
+            if self._preprocess_result_needs_writeback(batch_ids, new_ids):
+                if batch_offsets is None:
+                    input_ids[:batch_size].copy_(new_ids.reshape(-1)[:batch_size])
+                else:
+                    input_ids.index_copy_(0, batch_offsets, new_ids.reshape(-1)[:batch_size])
+            if self._preprocess_result_needs_writeback(batch_embeds, new_embeds):
+                reshaped_embeds = new_embeds.reshape(batch_size, -1)
+                if batch_offsets is None:
+                    embeds[:batch_size].copy_(reshaped_embeds)
+                else:
+                    embeds.index_copy_(0, batch_offsets, reshaped_embeds)
+
+            self._write_batched_gpu_preprocess_updates(
+                [entry[1] for entry in decode_entries],
+                updates_by_req,
+                gpu_keys,
+            )
+            for row, (entry, updates) in enumerate(zip(decode_entries, updates_by_req, strict=True)):
+                i, req_idx, start, _n_tok, _info, _is_prefill = entry
+                mtp_batches.append(
+                    (
+                        i,
+                        start,
+                        (batch_hidden[row : row + 1], batch_text_step[row : row + 1]),
+                    )
+                )
+                batched_decode_indices.add(i)
+            state_updates = [(entry[1], updates) for entry, updates in zip(decode_entries, updates_by_req, strict=True)]
+            for req_idx, updates in state_updates:
+                self.intermediate_buffer.update(req_idx, updates, gpu_keys)
+            prepacked_mtp_inputs = batch_hidden, batch_text_step
+
+        for i, req_idx, start, n_tok, info, _is_prefill in preprocess_entries:
+            if i in batched_decode_indices:
+                continue
+
+            ids_slice = input_ids[start : start + n_tok]
+            emb_slice = embeds[start : start + n_tok]
+            new_ids, new_emb, updates = self.model.preprocess(ids_slice, emb_slice, **info)
+
+            # Write back in-place
+            seg = min(n_tok, new_ids.shape[0])
+            if self._preprocess_result_needs_writeback(ids_slice, new_ids):
+                input_ids[start : start + seg] = new_ids[:seg]
+            if self._preprocess_result_needs_writeback(emb_slice, new_emb):
+                embeds[start : start + seg] = new_emb[:seg]
+
+            # Collect MTP inputs for decode steps (n_tok == 1 with mtp_inputs)
+            mtp_inputs = updates.pop("mtp_inputs", None)
+            if mtp_inputs is not None and n_tok == 1:
+                mtp_batches.append((i, start, mtp_inputs))
+
+            self.intermediate_buffer.update(req_idx, updates, gpu_keys)
+
+        if mtp_batches and hasattr(self.model, "mtp"):
+            if prepacked_mtp_inputs is None:
+                self._run_batched_mtp(
+                    mtp_batches,
+                    input_ids,
+                    embeds,
+                    input_batch,
+                    gpu_keys,
+                    mtp_batch_descriptor_dispatcher,
+                )
+            else:
+                self._run_batched_mtp(
+                    mtp_batches,
+                    input_ids,
+                    embeds,
+                    input_batch,
+                    gpu_keys,
+                    mtp_batch_descriptor_dispatcher,
+                    prepacked_mtp_inputs=prepacked_mtp_inputs,
+                )
+
+    def _pack_mtp_batch(
+        self,
+        mtp_batches: list[tuple[int, int, tuple[torch.Tensor, torch.Tensor]]],
+        input_ids: torch.Tensor,
+        embeds: torch.Tensor,
+        offsets: torch.Tensor | None = None,
+        prepacked_mtp_inputs: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Pack per-request Talker state with a bounded number of GPU ops."""
+        bsz = len(mtp_batches)
+        if offsets is None:
+            offsets = torch.as_tensor(
+                [start for _i, start, _mtp in mtp_batches],
+                device=input_ids.device,
+                dtype=torch.long,
+            )
+        if prepacked_mtp_inputs is None:
+            hidden_rows = [past_hidden.reshape(1, -1) for _i, _start, (past_hidden, _step) in mtp_batches]
+            text_step_rows = [text_step.reshape(1, -1) for _i, _start, (_hidden, text_step) in mtp_batches]
+            packed_hidden = None
+            packed_text_step = None
+        else:
+            packed_hidden, packed_text_step = prepacked_mtp_inputs
+            packed_hidden = packed_hidden.reshape(bsz, -1)
+            packed_text_step = packed_text_step.reshape(bsz, -1)
+
+        if self._mtp_input_ids is not None and bsz <= self._mtp_input_ids.shape[0]:
+            assert self._mtp_input_embeds is not None
+            assert self._mtp_hidden is not None
+            assert self._mtp_text_step is not None
+            batch_ids = self._mtp_input_ids[:bsz]
+            batch_embeds = self._mtp_input_embeds[:bsz]
+            batch_hidden = self._mtp_hidden[:bsz]
+            batch_text_step = self._mtp_text_step[:bsz]
+            if input_ids.dtype == batch_ids.dtype:
+                torch.index_select(input_ids, 0, offsets, out=batch_ids)
+            else:
+                batch_ids.copy_(input_ids.index_select(0, offsets))
+            torch.index_select(embeds, 0, offsets, out=batch_embeds)
+            if prepacked_mtp_inputs is None:
+                torch.cat(hidden_rows, dim=0, out=batch_hidden)
+                torch.cat(text_step_rows, dim=0, out=batch_text_step)
+            else:
+                batch_hidden.copy_(packed_hidden)
+                batch_text_step.copy_(packed_text_step)
+            return batch_ids, batch_embeds, batch_hidden, batch_text_step, offsets
+
+        if prepacked_mtp_inputs is None:
+            packed_hidden = torch.cat(hidden_rows, dim=0)
+            packed_text_step = torch.cat(text_step_rows, dim=0)
+        return (
+            input_ids.index_select(0, offsets),
+            embeds.index_select(0, offsets),
+            packed_hidden,
+            packed_text_step,
+            offsets,
+        )
+
+    def _mtp_batch_offsets(
+        self,
+        mtp_batches: list[tuple[int, int, tuple[torch.Tensor, torch.Tensor]]],
+        input_batch: InputBatch,
+        device: torch.device,
+    ) -> torch.Tensor:
+        """Reuse MRv2's device query offsets for a contiguous decode prefix.
+
+        The steady-state Talker batch contains one decode token from every
+        scheduled request, in scheduler order. ``InputBatch.query_start_loc``
+        already contains the exact device-side gather offsets for that shape;
+        rebuilding it from a Python list creates a small synchronous H2D
+        transfer on every decode step.
+        """
+        bsz = len(mtp_batches)
+        query_start_loc = getattr(input_batch, "query_start_loc", None)
+        static_offsets = self._mtp_offsets
+        if (
+            isinstance(query_start_loc, torch.Tensor)
+            and query_start_loc.device == device
+            and isinstance(static_offsets, torch.Tensor)
+            and static_offsets.device == device
+            and bsz <= static_offsets.shape[0]
+            and all(batch_index == expected for expected, (batch_index, _start, _mtp) in enumerate(mtp_batches))
+        ):
+            offsets = static_offsets[:bsz]
+            offsets.copy_(query_start_loc[:bsz], non_blocking=True)
+            return offsets
+
+        return torch.as_tensor(
+            [start for _i, start, _mtp in mtp_batches],
+            device=device,
+            dtype=torch.long,
+        )
+
+    def _run_batched_mtp(
+        self,
+        mtp_batches: list[tuple[int, int, tuple[torch.Tensor, torch.Tensor]]],
+        input_ids: torch.Tensor,
+        embeds: torch.Tensor,
+        input_batch: InputBatch,
+        gpu_keys: set[str],
+        mtp_batch_descriptor_dispatcher: Callable[[int], Any] | None = None,
+        prepacked_mtp_inputs: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> None:
+        """Batch MTP forward for all decode-step requests.
+
+        Uses pre-allocated static buffers to avoid per-step torch.cat
+        memory allocations.
+        """
+        from vllm.forward_context import set_forward_context
+
+        bsz = len(mtp_batches)
+        batch_offsets = self._mtp_batch_offsets(
+            mtp_batches,
+            input_batch,
+            input_ids.device,
+        )
+        batch_ids, batch_emb, batch_hidden, batch_step, batch_offsets = self._pack_mtp_batch(
+            mtp_batches,
+            input_ids,
+            embeds,
+            batch_offsets,
+            prepacked_mtp_inputs,
+        )
+
+        req_indices = [int(input_batch.idx_mapping_np[i]) for i, _start, _mtp in mtp_batches]
+        buffers = [self.intermediate_buffer.buffers[req_idx] for req_idx in req_indices]
+        req_ids = [str(buffer.get("req_id")) for buffer in buffers]
+        generators = [
+            self._get_mtp_generator(
+                req_id,
+                buffer.get("sampling_params"),
+                batch_ids.device,
+            )
+            for req_id, buffer in zip(req_ids, buffers, strict=True)
+        ]
+
+        use_graph_runner = self._is_mtp_graph_runner()
+        has_explicit_generator = any(generator is not None for generator in generators)
+        sample_uniform_buffer = getattr(self, "_mtp_sample_uniforms", None)
+        can_use_graph = use_graph_runner and (not has_explicit_generator or sample_uniform_buffer is not None)
+        sample_uniforms = None
+        batch_descriptor = None
+        cudagraph_mode = CUDAGraphMode.NONE
+        num_tokens = bsz
+        if can_use_graph and mtp_batch_descriptor_dispatcher is not None:
+            batch_descriptor = mtp_batch_descriptor_dispatcher(bsz)
+            cudagraph_mode = getattr(batch_descriptor, "cg_mode", CUDAGraphMode.FULL)
+            num_tokens = int(getattr(batch_descriptor, "num_tokens", bsz))
+            assert self._mtp_input_ids is not None
+            assert self._mtp_input_embeds is not None
+            assert self._mtp_hidden is not None
+            assert self._mtp_text_step is not None
+            batch_ids = self._mtp_input_ids[:num_tokens]
+            batch_emb = self._mtp_input_embeds[:num_tokens]
+            batch_hidden = self._mtp_hidden[:num_tokens]
+            batch_step = self._mtp_text_step[:num_tokens]
+            if sample_uniform_buffer is not None:
+                sample_uniforms = self._prepare_mtp_sample_uniforms(generators, num_tokens)
+        elif can_use_graph:
+            cudagraph_mode = CUDAGraphMode.FULL
+            if sample_uniform_buffer is not None:
+                sample_uniforms = self._prepare_mtp_sample_uniforms(generators, bsz)
+        with set_forward_context(
+            None,
+            self.vllm_config,
+            num_tokens=num_tokens,
+            cudagraph_runtime_mode=cudagraph_mode,
+            batch_descriptor=batch_descriptor,
+        ):
+            new_emb, codes = self._call_mtp_with_sampling(
+                batch_ids,
+                batch_emb,
+                batch_hidden,
+                batch_step,
+                buffers=buffers,
+                req_ids=req_ids,
+                generators=generators,
+                sample_uniforms=sample_uniforms,
+            )
+
+        embeds.index_copy_(0, batch_offsets, new_emb[:bsz].reshape(bsz, -1))
+        audio_key = getattr(self.model, "mtp_output_key", None)
+        validity_key = getattr(self.model, "mtp_validity_key", None)
+        valid_rows = None
+        if codes is not None and validity_key is not None:
+            valid_rows = torch.ones((bsz,), dtype=torch.bool, device=codes.device)
+        if codes is not None and audio_key in gpu_keys:
+            self.intermediate_buffer.update_gpu_tensor_rows(
+                req_indices,
+                audio_key,
+                codes[:bsz],
+            )
+            if valid_rows is not None:
+                self.intermediate_buffer.update_gpu_tensor_rows(
+                    req_indices,
+                    validity_key,
+                    valid_rows,
+                    keepdim=False,
+                )
+            return
+        for j, (i, _start, _) in enumerate(mtp_batches):
+            if codes is None:
+                continue
+            req_idx = int(input_batch.idx_mapping_np[i])
+            if isinstance(audio_key, tuple) and len(audio_key) == 2:
+                updates = {audio_key[0]: {audio_key[1]: codes[j : j + 1]}}
+            elif isinstance(audio_key, str):
+                updates = {audio_key: codes[j : j + 1]}
+            else:
+                raise TypeError(
+                    f"mtp_output_key must be a string or 2-tuple, got {type(audio_key).__name__}: {audio_key!r}"
+                )
+            if valid_rows is not None:
+                if isinstance(validity_key, tuple) and len(validity_key) == 2:
+                    updates.setdefault(validity_key[0], {})[validity_key[1]] = valid_rows[j]
+                elif isinstance(validity_key, str):
+                    updates[validity_key] = valid_rows[j]
+                else:
+                    raise TypeError(
+                        "mtp_validity_key must be a string or 2-tuple, "
+                        f"got {type(validity_key).__name__}: {validity_key!r}"
+                    )
+            self.intermediate_buffer.update(req_idx, updates, gpu_keys)
+
+    def _get_mtp_base_sampling_kwargs(self) -> dict[str, Any]:
+        sampling_params = getattr(self.model, "mtp_sampling_params", None)
+        if not isinstance(sampling_params, dict):
+            sampling_params = {}
+        return {
+            "do_sample": sampling_params.get("do_sample"),
+            "temperature": sampling_params.get("temperature"),
+            "top_k": sampling_params.get("top_k"),
+            "top_p": sampling_params.get("top_p"),
+        }
+
+    def _get_mtp_sampling_kwargs(
+        self,
+        buffers: list[dict[str, Any]],
+        req_ids: list[str],
+        generators: list[torch.Generator | None],
+    ) -> dict[str, Any]:
+        kwargs = self._get_mtp_base_sampling_kwargs()
+
+        if len(generators) == 1:
+            if generators[0] is not None:
+                kwargs["generator"] = generators[0]
+        elif any(generator is not None for generator in generators):
+            kwargs["generators"] = generators
+
+        if getattr(self.model, "mtp_accepts_req_infos", False):
+            kwargs["req_ids"] = req_ids
+            kwargs["req_infos"] = buffers
+
+        return kwargs
+
+    def _get_mtp_generator(
+        self,
+        req_id: str,
+        sampling_params: Any,
+        device: torch.device,
+    ) -> torch.Generator | None:
+        resolve_seed = getattr(self.model, "get_mtp_seed", None)
+        seed = resolve_seed(sampling_params) if resolve_seed is not None else None
+        if seed is None:
+            return None
+
+        cache = getattr(self, "_mtp_generators", None)
+        if cache is None:
+            cache = {}
+            self._mtp_generators = cache
+        generator = cache.get(req_id)
+        if generator is None or generator.device != device:
+            generator = torch.Generator(device=device)
+            generator.manual_seed(seed)
+            cache[req_id] = generator
+        return generator
+
+    def _prepare_mtp_sample_uniforms(
+        self,
+        generators: list[torch.Generator | None],
+        num_tokens: int,
+    ) -> torch.Tensor | None:
+        sample_uniforms = self._mtp_sample_uniforms
+        if sample_uniforms is None:
+            return None
+        bsz = len(generators)
+        if not 0 < bsz <= num_tokens <= sample_uniforms.shape[0]:
+            raise ValueError(
+                f"invalid Talker-MTP sampling buffer shape: bsz={bsz} num_tokens={num_tokens} "
+                f"capacity={sample_uniforms.shape[0]}"
+            )
+
+        active = sample_uniforms[:bsz]
+        if any(generator is not None for generator in generators):
+            # Consume one request-local stream for the whole residual span so the
+            # outer MTP graph can treat sampling noise as a stable tensor input.
+            # The draw granularity differs from the legacy per-step path, but
+            # request-local determinism and batch-order independence are kept.
+            for row, generator in enumerate(generators):
+                active[row : row + 1].uniform_(1e-20, 1.0 - 1e-20, generator=generator)
+        else:
+            active.uniform_(1e-20, 1.0 - 1e-20)
+        if num_tokens > bsz:
+            sample_uniforms[bsz:num_tokens].uniform_(1e-20, 1.0 - 1e-20)
+        return sample_uniforms[:num_tokens]
+
+    def _call_mtp_with_sampling(
+        self,
+        batch_ids: torch.Tensor,
+        batch_emb: torch.Tensor,
+        batch_hidden: torch.Tensor,
+        batch_step: torch.Tensor,
+        *,
+        buffers: list[dict[str, Any]],
+        req_ids: list[str],
+        generators: list[torch.Generator | None],
+        sample_uniforms: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        if sample_uniforms is None:
+            kwargs = self._get_mtp_sampling_kwargs(buffers, req_ids, generators)
+        else:
+            kwargs = self._get_mtp_base_sampling_kwargs()
+            kwargs["sample_uniforms"] = sample_uniforms
+            if getattr(self.model, "mtp_accepts_req_infos", False):
+                kwargs["req_ids"] = req_ids
+                kwargs["req_infos"] = buffers
+
+        if (
+            len(req_ids) > 1
+            and "generators" in kwargs
+            and "sample_uniforms" not in kwargs
+            and not getattr(self.model, "mtp_accepts_per_row_generators", False)
+        ):
+            emb_chunks = []
+            code_chunks = []
+            for row, (req_id, buffer, generator) in enumerate(zip(req_ids, buffers, generators, strict=True)):
+                row_kwargs = self._get_mtp_sampling_kwargs(
+                    [buffer],
+                    [req_id],
+                    [generator],
+                )
+                row_emb, row_codes = self._call_mtp_runner(
+                    batch_ids[row : row + 1],
+                    batch_emb[row : row + 1],
+                    batch_hidden[row : row + 1],
+                    batch_step[row : row + 1],
+                    **row_kwargs,
+                )
+                emb_chunks.append(row_emb)
+                if row_codes is not None:
+                    code_chunks.append(row_codes)
+            new_emb = torch.cat(emb_chunks)
+            codes = torch.cat(code_chunks) if code_chunks else None
+            return new_emb, codes
+
+        return self._call_mtp_runner(
+            batch_ids,
+            batch_emb,
+            batch_hidden,
+            batch_step,
+            **kwargs,
+        )
+
+    def _call_mtp_runner(
+        self,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor,
+        last_hidden: torch.Tensor,
+        text_step: torch.Tensor,
+        **kwargs: Any,
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        # Explicit generators are request state, while the outer whole-MTP
+        # graph owns one captured RNG stream. Keep the transformer/code-
+        # predictor graphs, but call the raw MTP function so per-row streams
+        # remain deterministic and independent of scheduler batch makeup.
+        has_explicit_generator = kwargs.get("generator") is not None or kwargs.get("generators") is not None
+        runner = self.model.mtp if has_explicit_generator else getattr(self, "_mtp_runner", None)
+        runner = runner or self.model.mtp
+        return runner(input_ids, input_embeds, last_hidden, text_step, **kwargs)
+
+    # ------------------------------------------------------------------
+    # Post-forward: per-request postprocess
+    # ------------------------------------------------------------------
+
+    def run_postprocess(self, hidden_states: torch.Tensor, input_batch: InputBatch) -> None:
+        """Per-request postprocess after model forward.
+
+        Extracts per-request updates from hidden_states and writes them
+        back to the intermediate buffer (e.g. ``last_talker_hidden``).
+        """
+        if not self.has_postprocess:
+            return
+        gpu_keys: set[str] = getattr(self.model, "gpu_resident_buffer_keys", set())
+        batch_postprocess = getattr(self.model, "postprocess_batch_mrv2", None)
+        if callable(batch_postprocess) and input_batch.num_reqs:
+            req_indices = [int(input_batch.idx_mapping_np[i]) for i in range(input_batch.num_reqs)]
+            buffers = [self.intermediate_buffer.buffers[req_idx] for req_idx in req_indices]
+            if all(buf and "req_id" in buf and not str(buf["req_id"]).startswith("_warmup_") for buf in buffers):
+                query_start_loc = getattr(input_batch, "query_start_loc", None)
+                if (
+                    isinstance(query_start_loc, torch.Tensor)
+                    and query_start_loc.device == hidden_states.device
+                    and query_start_loc.shape[0] >= input_batch.num_reqs + 1
+                ):
+                    last_token_indices = query_start_loc[1 : input_batch.num_reqs + 1] - 1
+                else:
+                    last_token_indices = torch.as_tensor(
+                        [
+                            int(input_batch.query_start_loc_np[i]) + int(input_batch.num_scheduled_tokens[i]) - 1
+                            for i in range(input_batch.num_reqs)
+                        ],
+                        device=hidden_states.device,
+                        dtype=torch.long,
+                    )
+                output_key, values = batch_postprocess(
+                    hidden_states=hidden_states,
+                    last_token_indices=last_token_indices,
+                )
+                if output_key not in gpu_keys:
+                    raise RuntimeError(f"Batched Omni postprocess output must be GPU-resident: key={output_key!r}")
+                owned_rows = isinstance(values, OwnedBatchTensor)
+                raw_values = values.tensor if owned_rows else values
+                if (
+                    not isinstance(raw_values, torch.Tensor)
+                    or raw_values.ndim == 0
+                    or raw_values.shape[0] != input_batch.num_reqs
+                ):
+                    actual = raw_values.shape[0] if isinstance(raw_values, torch.Tensor) and raw_values.ndim else 0
+                    raise RuntimeError(
+                        "Batched Omni postprocess changed the request axis: "
+                        f"expected={input_batch.num_reqs} actual={actual}"
+                    )
+                if owned_rows:
+                    # Owned batch: share row views, no second snapshot.
+                    self.intermediate_buffer.update_owned_gpu_tensor_rows(
+                        req_indices,
+                        output_key,
+                        raw_values,
+                        keepdim=False,
+                    )
+                else:
+                    # Borrowed output (graph buffer or shared scratch): snapshot once.
+                    self.intermediate_buffer.update_gpu_tensor_rows(
+                        req_indices,
+                        output_key,
+                        raw_values,
+                        keepdim=False,
+                    )
+                return
+        for i in range(input_batch.num_reqs):
+            req_idx = int(input_batch.idx_mapping_np[i])
+            buf = self.intermediate_buffer.buffers[req_idx]
+            if not buf or "req_id" not in buf:
+                continue
+            if str(buf["req_id"]).startswith("_warmup_"):
+                continue
+            start = int(input_batch.query_start_loc_np[i])
+            n_tok = int(input_batch.num_scheduled_tokens[i])
+            h_slice = hidden_states[start : start + n_tok]
+            info = {key: value for key, value in buf.items() if isinstance(key, str) and key != "hidden_states"}
+            updates = self.model.postprocess(h_slice, **info)
+            if updates:
+                self.intermediate_buffer.update(req_idx, updates, gpu_keys)
+
+    # ------------------------------------------------------------------
+    # Output post-processing
+    # ------------------------------------------------------------------
+
+    def postprocess_model_output(
+        self,
+        model_output: Any,
+        input_batch: InputBatch,
+        req_states: RequestState,
+    ) -> tuple[torch.Tensor, dict]:
+        """Convert raw model output to ``(text_hidden, multimodal_outputs)``.
+
+        Handles ``OmniOutput`` unwrapping and ``make_omni_output``
+        conversion.
+        """
+        if not isinstance(model_output, OmniOutput) and hasattr(self.model, "make_omni_output"):
+            if isinstance(model_output, (list, tuple)) or self.have_multimodal_outputs:
+                buffer_list = self.intermediate_buffer.gather(input_batch)
+                make_output_kwargs = {
+                    "model_intermediate_buffer": buffer_list,
+                    "request_token_spans": [
+                        (
+                            int(input_batch.query_start_loc_np[i]),
+                            int(input_batch.query_start_loc_np[i]) + int(input_batch.num_scheduled_tokens[i]),
+                        )
+                        for i in range(input_batch.num_reqs)
+                    ],
+                }
+                make_output_kwargs["runtime_additional_information"] = buffer_list
+                model_output = self.model.make_omni_output(model_output, **make_output_kwargs)
+
+        if isinstance(model_output, OmniOutput):
+            text_hidden = model_output.text_hidden_states
+            multimodal_outputs = cast(dict[str, Any], model_output.multimodal_outputs or {})
+        elif isinstance(model_output, (list, tuple)):
+            text_hidden = model_output[0]
+            multimodal_outputs = {}
+        else:
+            text_hidden = model_output
+            multimodal_outputs = {}
+
+        return text_hidden, multimodal_outputs
diff --git a/vllm_omni/worker_v2/native_output_worker.py b/vllm_omni/worker_v2/native_output_worker.py
new file mode 100644
index 000000000..3d6b7ad47
--- /dev/null
+++ b/vllm_omni/worker_v2/native_output_worker.py
@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Materialize native producer output independently of scheduler consumption."""
+
+from concurrent.futures import Future, ThreadPoolExecutor
+from threading import BoundedSemaphore, Lock
+from typing import Any
+
+from vllm.v1.outputs import AsyncModelRunnerOutput
+
+
+class NativeAsyncOutput(AsyncModelRunnerOutput):
+    """Consume an ordered publication on the engine's owner thread."""
+
+    def __init__(self, future: Future, plane: Any, copy_event: Any) -> None:
+        self._future: Future | None = future
+        self._plane = plane
+        self.copy_event = copy_event
+        self._resolved: Future = Future()
+
+    def get_output(self) -> Any:
+        # Like the upstream lazy AsyncOutputFuture, consumption belongs to one
+        # engine thread. Cache finalization and errors for repeated consumption.
+        if not self._resolved.done():
+            try:
+                assert self._future is not None
+                output = self._future.result()
+                output.omni_connector_output = self._plane.get_omni_connector_output()
+                self._resolved.set_result(output)
+            except Exception as error:
+                self._resolved.set_exception(error)
+            finally:
+                if self._resolved.done():
+                    # Do not retain raw snapshots or a callback bound to self.
+                    self._future = None
+                    self._plane = None
+        return self._resolved.result()
+
+
+class NativeOutputWorker:
+    """Bounded FIFO CPU materialization and native-queue publication.
+
+    Input outputs must have no owner-thread finalizer installed. Reservations
+    and metadata writes must be complete before submit. This worker never
+    updates scheduler state or drains connector notifications.
+    """
+
+    def __init__(self, capacity: int, device: Any | None = None) -> None:
+        if capacity < 1:
+            raise ValueError("Native output capacity must be positive")
+        self._slots = BoundedSemaphore(capacity)
+        self._lock = Lock()
+        self._closed = False
+        self._executor = ThreadPoolExecutor(
+            max_workers=1,
+            thread_name_prefix="omni-native-materialize",
+            initializer=self._initialize_device,
+            initargs=(device,),
+        )
+
+    @staticmethod
+    def _initialize_device(device: Any | None) -> None:
+        if device is not None:
+            from vllm.platforms import current_platform
+
+            current_platform.set_device(device)
+
+    @staticmethod
+    def _materialize(output: AsyncModelRunnerOutput, plane: Any) -> Any:
+        result = output.get_output()
+        plane.enqueue_outputs(
+            req_ids=list(result.req_ids),
+            inter_stage_outputs=getattr(result, "inter_stage_outputs", None),
+            sampled_token_ids=getattr(result, "sampled_token_ids", None),
+        )
+        result.inter_stage_outputs = None
+        return result
+
+    def submit(self, output: AsyncModelRunnerOutput, plane: Any) -> NativeAsyncOutput:
+        with self._lock:
+            if self._closed:
+                raise RuntimeError("Native output worker is closed")
+        self._slots.acquire()
+        try:
+            with self._lock:
+                if self._closed:
+                    raise RuntimeError("Native output worker is closed")
+                future = self._executor.submit(self._materialize, output, plane)
+        except BaseException:
+            self._slots.release()
+            raise
+        future.add_done_callback(lambda _: self._slots.release())
+        return NativeAsyncOutput(future, plane, output.copy_event)
+
+    def close(self) -> None:
+        with self._lock:
+            self._closed = True
+        # Drain submitted publications before the native data plane is closed.
+        self._executor.shutdown(wait=True)
diff --git a/vllm_omni/worker_v2/omni_ar_model_runner.py b/vllm_omni/worker_v2/omni_ar_model_runner.py
new file mode 100644
index 000000000..23cc84f85
--- /dev/null
+++ b/vllm_omni/worker_v2/omni_ar_model_runner.py
@@ -0,0 +1,818 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OmniARModelRunner — autoregressive stage runner on MR V2.
+
+Extends ``OmniGPUModelRunner`` with:
+
+* ``OmniOutput`` post-processing in ``sample_tokens``
+* Per-request ``pooler_output`` construction (hidden + multimodal slices)
+* Async D2H copy via ``OmniAsyncOutput`` for non-blocking output transfer
+* Cross-stage KV extraction before state cleanup
+"""
+
+from __future__ import annotations
+
+from contextlib import nullcontext
+from typing import Any, cast
+
+import numpy as np
+import torch
+from vllm.logger import init_logger
+from vllm.model_executor.layers.fused_moe.all2all_utils import (
+    get_ep_all2all_manager,
+)
+from vllm.utils.torch_utils import PIN_MEMORY
+from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput
+from vllm.v1.outputs import AsyncModelRunnerOutput, ModelRunnerOutput, RoutedExpertsTensors
+from vllm.v1.worker.gpu.eplb_utils import step_eplb_after
+
+from vllm_omni.data_entry_keys import OmniPayload, flatten_payload
+from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
+    OmniKVTransferManager,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.outputs import OmniModelRunnerOutput
+from vllm_omni.utils.mm_outputs import partition_flat_payload
+from vllm_omni.worker_v2.omni_model_runner import OmniGPUModelRunner
+from vllm_omni.worker_v2.output_snapshot import PackedOutputSnapshot, pack_output_snapshot
+
+logger = init_logger(__name__)
+_ASYNC_MM_SNAPSHOT_MAX_BUCKETS_PER_SLOT = 64
+
+
+def _copy_mm_to_snapshot_slot(value: Any, slot: dict[tuple[Any, ...], torch.Tensor], path: tuple[Any, ...] = ()) -> Any:
+    if not path and isinstance(value, dict):
+        packed = pack_output_snapshot(value, slot, max_buckets=_ASYNC_MM_SNAPSHOT_MAX_BUCKETS_PER_SLOT)
+        if packed is not None:
+            return packed
+    if isinstance(value, torch.Tensor):
+        bucket_key = path + (tuple(value.shape), value.dtype, value.device)
+        cached = slot.get(bucket_key)
+        if cached is None:
+            if len(slot) >= _ASYNC_MM_SNAPSHOT_MAX_BUCKETS_PER_SLOT:
+                return value.detach().clone()
+            cached = torch.empty_like(value)
+            slot[bucket_key] = cached
+        cached.copy_(value)
+        return cached
+    if isinstance(value, dict):
+        return {key: _copy_mm_to_snapshot_slot(item, slot, path + (key,)) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_copy_mm_to_snapshot_slot(item, slot, path + (index,)) for index, item in enumerate(value)]
+    if isinstance(value, tuple):
+        return tuple(_copy_mm_to_snapshot_slot(item, slot, path + (index,)) for index, item in enumerate(value))
+    return value
+
+
+def _has_cuda_tensor(value: Any) -> bool:
+    if isinstance(value, torch.Tensor):
+        return value.device.type == "cuda"
+    if isinstance(value, dict):
+        return any(_has_cuda_tensor(item) for item in value.values())
+    if isinstance(value, (list, tuple)):
+        return any(_has_cuda_tensor(item) for item in value)
+    return False
+
+
+def _guard_graph_replay_for_pooler_copy(
+    main_stream: Any,
+    copy_event: Any,
+    *,
+    need_pooler: bool,
+    async_chunk: bool,
+) -> None:
+    """Keep static graph outputs alive until non-snapshotted D2H completes."""
+    if need_pooler and not async_chunk:
+        main_stream.wait_event(copy_event)
+
+
+class OmniARModelRunner(OmniGPUModelRunner):
+    """AR stage runner. Produces per-request hidden states + multimodal outputs."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.kv_transfer_manager: OmniKVTransferManager | None = None
+        self._kv_extracted_req_ids: list[str] | None = None
+        self._async_mm_snapshot_slots: list[dict[tuple[Any, ...], torch.Tensor]] = [{} for _ in range(4)]
+        self._async_mm_snapshot_events: list[torch.cuda.Event | None] = [None] * 4
+        self._async_mm_snapshot_pending = [False] * 4
+        self._async_mm_snapshot_cursor = 0
+        self._last_multimodal_snapshot_slot: int | None = None
+
+    def _ensure_kv_transfer_manager(self) -> OmniKVTransferManager:
+        if self.kv_transfer_manager is None:
+            self.kv_transfer_manager = OmniKVTransferManager.from_vllm_config(self.vllm_config, self.model_config)
+        return self.kv_transfer_manager
+
+    # ------------------------------------------------------------------
+    # execute_model: KV transfer pre-hook + delegate to super
+    # ------------------------------------------------------------------
+
+    def execute_model(
+        self,
+        scheduler_output: SchedulerOutput,
+        intermediate_tensors: Any | None = None,
+        dummy_run: bool = False,
+        skip_attn_for_dummy_run: bool = False,
+        is_profile: bool = False,
+        context_len: int = 0,
+    ) -> Any:
+        if not dummy_run:
+            self._handle_kv_transfer_pre(scheduler_output)
+        return super().execute_model(
+            scheduler_output,
+            intermediate_tensors,
+            dummy_run=dummy_run,
+            skip_attn_for_dummy_run=skip_attn_for_dummy_run,
+            is_profile=is_profile,
+            context_len=context_len,
+        )
+
+    # ------------------------------------------------------------------
+    # sample_tokens: OmniOutput handling + pooler_output + async D2H
+    # ------------------------------------------------------------------
+
+    @torch.inference_mode()
+    @step_eplb_after()
+    def sample_tokens(
+        self, grammar_output: GrammarOutput | None
+    ) -> OmniAsyncOutput | OmniModelRunnerOutput | ModelRunnerOutput | None:
+        kv_extracted = self._kv_extracted_req_ids
+        self._kv_extracted_req_ids = None
+
+        if self.execute_model_state is None:
+            return None
+
+        input_batch = self.execute_model_state.input_batch
+        hidden_states = self.execute_model_state.hidden_states
+        finished_req_ids = self.execute_model_state.finished_req_ids
+        ec_connector_output = self.execute_model_state.ec_connector_output
+        routed_experts = self.execute_model_state.routed_experts
+        self.execute_model_state = None
+
+        # --- Omni: reconstruct raw model output and post-process ---
+        aux = self._last_aux_output
+        self._last_aux_output = None
+        multimodal_outputs = self._last_multimodal_outputs
+        self._last_multimodal_outputs = None
+        snapshot_slot = None
+        self._last_multimodal_snapshot_slot = None
+        raw_output = self._reconstruct_raw_model_output(
+            hidden_states=hidden_states,
+            multimodal_outputs=multimodal_outputs,
+            aux=aux,
+        )
+        text_hidden, multimodal_outputs = self.model_state.postprocess_model_output(
+            raw_output, input_batch, self.req_states
+        )
+        if bool(getattr(self.model_config, "async_chunk", False)) and multimodal_outputs:
+            multimodal_outputs = self._retain_multimodal_outputs(multimodal_outputs)
+            snapshot_slot = self._last_multimodal_snapshot_slot
+            self._last_multimodal_snapshot_slot = None
+
+        # --- Standard v2 sampling ---
+        sampling_context = nullcontext()
+        model_sampling_context = getattr(self.model, "mrv2_sampling_context", None)
+        if callable(model_sampling_context) and getattr(self.model, "logitsprocs_need_output_token_ids", False):
+            # seq_lens includes this forward's input, but not its sampled token:
+            # final prefill has zero prior outputs; the first decode has one.
+            sampling_context = model_sampling_context(
+                req_ids=input_batch.req_ids,
+                num_output_tokens=(
+                    input_batch.seq_lens[: input_batch.num_reqs]
+                    - self.req_states.prompt_len.gpu[input_batch.idx_mapping]
+                ),
+            )
+        with sampling_context:
+            sampler_output, num_sampled, num_rejected = self.sample(
+                text_hidden,
+                input_batch,
+                grammar_output,
+            )
+        if self.pp_handler is not None:
+            self.pp_handler.broadcast(
+                sampler_output.sampled_token_ids,
+                num_sampled,
+                num_rejected,
+                input_batch,
+            )
+
+        # --- Omni: prompt logprobs ---
+        assert self.prompt_logprobs_worker is not None
+        # Mirror the current parent GPUModelRunner call exactly.
+        prompt_logprobs_dict = self.prompt_logprobs_worker.compute_prompt_logprobs(
+            self.model.compute_logits,
+            text_hidden,
+            input_batch,
+            self.req_states.all_token_ids.gpu,
+            self.req_states.num_computed_tokens.gpu,
+            self.req_states.prompt_len.np,
+        )
+
+        # --- Omni: pooler_output ---
+        engine_output_type = getattr(self.vllm_config.model_config, "engine_output_type", "text")
+        need_pooler = engine_output_type != "text"
+
+        # --- Build base output ---
+        model_runner_output = OmniModelRunnerOutput(
+            req_ids=input_batch.req_ids,
+            req_id_to_index={rid: i for i, rid in enumerate(input_batch.req_ids)},
+            sampled_token_ids=None,  # type: ignore[arg-type]
+            prompt_logprobs_dict=prompt_logprobs_dict,
+            kv_connector_output=None,
+        )
+        model_runner_output.kv_extracted_req_ids = kv_extracted
+        model_runner_output._async_chunk = bool(getattr(self.model_config, "async_chunk", False))
+
+        # --- Async D2H via OmniAsyncOutput ---
+        materialize_native = self._uses_native_output_materializer()
+        async_output = OmniAsyncOutput(
+            model_runner_output=model_runner_output,
+            sampler_output=sampler_output,
+            num_sampled_tokens=num_sampled,
+            main_stream=self.main_stream,
+            copy_stream=self.output_copy_stream,
+            text_hidden=text_hidden if need_pooler else None,
+            multimodal_outputs=multimodal_outputs if need_pooler else None,
+            input_batch=input_batch if need_pooler else None,
+            async_chunk=bool(getattr(self.model_config, "async_chunk", False)),
+            finalize_output=(None if materialize_native else self._finalize_native_data_plane_output),
+            check_ep_fault=self.check_ep_fault,
+            routed_experts=routed_experts,
+        )
+        self._release_multimodal_snapshot(snapshot_slot, async_output.copy_event)
+        _guard_graph_replay_for_pooler_copy(
+            self.main_stream,
+            async_output.copy_event,
+            need_pooler=need_pooler,
+            async_chunk=bool(getattr(self.model_config, "async_chunk", False)),
+        )
+
+        # Postprocess AFTER creating async output (so copy_event is
+        # recorded before postprocess, matching upstream pattern).
+        self.postprocess_sampled(
+            input_batch.idx_mapping,
+            sampler_output.sampled_token_ids,
+            num_sampled,
+            num_rejected,
+            input_batch.query_start_loc,
+        )
+        model_runner_output.kv_connector_output = self.kv_connector.post_forward(finished_req_ids)
+        model_runner_output.ec_connector_output = ec_connector_output
+
+        self._reserve_native_data_plane_outputs(list(model_runner_output.req_ids))
+        if materialize_native:
+            return self._materialize_native_output(async_output)
+        return async_output
+
+    def _retain_multimodal_outputs(self, outputs: dict[str, Any]) -> dict[str, Any]:
+        if not bool(getattr(self.model_config, "async_chunk", False)) or not outputs:
+            return outputs
+        slot_index = self._async_mm_snapshot_cursor
+        if self._async_mm_snapshot_pending[slot_index]:
+            raise RuntimeError("Async multimodal snapshot ring exhausted before sample_tokens().")
+        event = self._async_mm_snapshot_events[slot_index]
+        if event is not None:
+            self.main_stream.wait_event(event)
+        if _has_cuda_tensor(outputs):
+            with torch.cuda.stream(self.main_stream):
+                snapshot = _copy_mm_to_snapshot_slot(outputs, self._async_mm_snapshot_slots[slot_index])
+        else:
+            snapshot = _copy_mm_to_snapshot_slot(outputs, self._async_mm_snapshot_slots[slot_index])
+        self._async_mm_snapshot_pending[slot_index] = True
+        self._last_multimodal_snapshot_slot = slot_index
+        self._async_mm_snapshot_cursor = (slot_index + 1) % len(self._async_mm_snapshot_slots)
+        return snapshot
+
+    def _release_multimodal_snapshot(self, slot_index: int | None, copy_event: torch.cuda.Event) -> None:
+        if slot_index is None:
+            return
+        self._async_mm_snapshot_events[slot_index] = copy_event
+        self._async_mm_snapshot_pending[slot_index] = False
+
+    # ------------------------------------------------------------------
+    # pooler_output construction
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _reconstruct_raw_model_output(
+        *,
+        hidden_states: torch.Tensor,
+        multimodal_outputs: dict[str, Any] | None,
+        aux: Any | None,
+    ) -> Any:
+        if multimodal_outputs:
+            return OmniOutput(
+                text_hidden_states=hidden_states,
+                multimodal_outputs=cast(OmniPayload, multimodal_outputs),
+            )
+        if aux is not None:
+            return (hidden_states, aux)
+        return hidden_states
+
+    @staticmethod
+    def _build_pooler_output_from_cpu(
+        hidden_cpu: torch.Tensor,
+        mm_cpu: dict[str, Any],
+        query_start_loc_np: np.ndarray,
+        num_scheduled_tokens: np.ndarray,
+        num_reqs: int,
+    ) -> list[dict[str, Any]]:
+        """Build pooler_output from already-CPU tensors."""
+        total = hidden_cpu.shape[0]
+        pooler: list[dict[str, Any]] = []
+        for i in range(num_reqs):
+            start = int(query_start_loc_np[i])
+            end = start + int(num_scheduled_tokens[i])
+            payload: dict[str, Any] = {"hidden": hidden_cpu[start:end].clone()}
+            for k, v in mm_cpu.items():
+                payload[k] = _slice_pooler_value(
+                    v,
+                    req_index=i,
+                    start=start,
+                    end=end,
+                    total_tokens=total,
+                )
+            pooler.append(flatten_payload(payload))
+        return pooler
+
+    @staticmethod
+    def _build_async_chunk_outputs_from_mm(
+        mm_outputs: dict[str, Any],
+        query_start_loc_np: np.ndarray,
+        num_scheduled_tokens: np.ndarray,
+        num_reqs: int,
+        total_tokens: int,
+        padded_total_tokens: int | None = None,
+    ) -> tuple[list[dict[str, Any] | None] | None, list[dict[str, Any] | None] | None]:
+        """Build async-chunk payloads without materializing hidden on CPU."""
+        if not mm_outputs:
+            return None, None
+
+        inter_stage_list: list[dict[str, Any] | None] = []
+        client_mm_list: list[dict[str, Any] | None] = []
+        for i in range(num_reqs):
+            start = int(query_start_loc_np[i])
+            end = start + int(num_scheduled_tokens[i])
+            payload = {
+                key: _slice_pooler_value(
+                    value,
+                    req_index=i,
+                    start=start,
+                    end=end,
+                    total_tokens=total_tokens,
+                    padded_total_tokens=padded_total_tokens,
+                )
+                for key, value in mm_outputs.items()
+            }
+            inter_stage, client_mm = partition_flat_payload(flatten_payload(payload))
+            inter_stage_list.append(inter_stage or None)
+            client_mm_list.append(client_mm or None)
+
+        return (
+            None if all(item is None for item in inter_stage_list) else inter_stage_list,
+            None if all(item is None for item in client_mm_list) else client_mm_list,
+        )
+
+    # ------------------------------------------------------------------
+    # KV transfer
+    # ------------------------------------------------------------------
+
+    def _handle_kv_transfer_pre(self, scheduler_output: SchedulerOutput) -> None:
+        finished: dict = getattr(scheduler_output, "finished_requests_needing_kv_transfer", {})
+        if not finished:
+            return
+
+        kv_caches = getattr(self, "kv_caches", None)
+        if kv_caches is None:
+            return
+
+        if hasattr(self.model, "get_kv_transfer_metadata"):
+            for req_id, data in finished.items():
+                try:
+                    meta = self.model.get_kv_transfer_metadata(req_id)
+                    if meta:
+                        existing = data.get("custom_metadata") or {}
+                        existing.update(meta)
+                        data["custom_metadata"] = existing
+                except Exception:
+                    logger.warning(
+                        "Failed to get KV transfer metadata for %s",
+                        req_id,
+                        exc_info=True,
+                    )
+
+        mgr = self._ensure_kv_transfer_manager()
+        self._kv_extracted_req_ids = mgr.handle_finished_requests_kv_transfer(
+            finished_reqs=finished,
+            kv_caches=kv_caches,
+            block_size=self.cache_config.block_size,
+            cache_dtype=str(self.cache_config.cache_dtype),
+            request_id_resolver=self._resolve_global_request_id,
+        )
+
+    def _resolve_global_request_id(self, req_id: str) -> str:
+        req_idx = self.req_states.req_id_to_index.get(req_id)
+        if req_idx is None:
+            return req_id
+        info = self.model_state.intermediate_buffer.buffers[req_idx]
+        global_id = info.get("global_request_id")
+        if isinstance(global_id, list):
+            global_id = global_id[0] if global_id else None
+        if isinstance(global_id, bytes):
+            return global_id.decode("utf-8")
+        return str(global_id) if global_id else req_id
+
+
+# ======================================================================
+# OmniAsyncOutput — async D2H for Omni AR outputs
+# ======================================================================
+
+
+def _async_copy_to_np(
+    x: torch.Tensor,
+    *,
+    copy_stream: torch.cuda.Stream | None = None,
+    pin_memory: bool | None = None,
+) -> np.ndarray:
+    return _async_copy_tensor(
+        x,
+        copy_stream=copy_stream,
+        pin_memory=pin_memory,
+    ).numpy()
+
+
+def _async_copy_tensor(
+    x: torch.Tensor,
+    *,
+    copy_stream: torch.cuda.Stream | None = None,
+    pin_memory: bool | None = None,
+) -> torch.Tensor:
+    x = x.detach()
+    if x.device.type == "cpu":
+        return x.clone()
+    if pin_memory is None:
+        pin_memory = PIN_MEMORY
+    cpu = torch.empty_like(x, device="cpu", pin_memory=pin_memory)
+    cpu.copy_(x, non_blocking=pin_memory)
+    if copy_stream is None:
+        copy_stream = torch.cuda.current_stream()
+    x.record_stream(copy_stream)
+    return cpu
+
+
+def _async_copy_mm_value(
+    value: Any,
+    *,
+    copy_stream: torch.cuda.Stream | None = None,
+    pin_memory: bool | None = None,
+) -> Any:
+    if isinstance(value, torch.Tensor):
+        return _async_copy_tensor(
+            value,
+            copy_stream=copy_stream,
+            pin_memory=pin_memory,
+        )
+    if isinstance(value, dict):
+        return {
+            key: _async_copy_mm_value(
+                val,
+                copy_stream=copy_stream,
+                pin_memory=pin_memory,
+            )
+            for key, val in value.items()
+        }
+    if isinstance(value, list):
+        return [
+            _async_copy_mm_value(
+                val,
+                copy_stream=copy_stream,
+                pin_memory=pin_memory,
+            )
+            for val in value
+        ]
+    if isinstance(value, tuple):
+        return tuple(
+            _async_copy_mm_value(
+                val,
+                copy_stream=copy_stream,
+                pin_memory=pin_memory,
+            )
+            for val in value
+        )
+    return value
+
+
+def _async_copy_mm(
+    mm_outputs: dict | None,
+    total_tokens: int,
+    *,
+    copy_stream: torch.cuda.Stream | None = None,
+    pin_memory: bool | None = None,
+) -> dict[str, Any]:
+    """Non-blocking D2H copy of multimodal output tensors."""
+    if not mm_outputs:
+        return {}
+    if isinstance(mm_outputs, PackedOutputSnapshot):
+        return mm_outputs.copy_to_cpu(
+            lambda tensor: _async_copy_tensor(tensor, copy_stream=copy_stream, pin_memory=pin_memory)
+        )
+    return {
+        key: _async_copy_mm_value(
+            value,
+            copy_stream=copy_stream,
+            pin_memory=pin_memory,
+        )
+        for key, value in mm_outputs.items()
+    }
+
+
+def _slice_pooler_value(
+    value: Any,
+    *,
+    req_index: int,
+    start: int,
+    end: int,
+    total_tokens: int,
+    padded_total_tokens: int | None = None,
+    request_scoped: bool = False,
+) -> Any:
+    if isinstance(value, torch.Tensor):
+        token_axis_sizes = {total_tokens}
+        if padded_total_tokens is not None:
+            token_axis_sizes.add(padded_total_tokens)
+        if not request_scoped and value.dim() > 0 and value.shape[0] in token_axis_sizes:
+            return value[start:end].contiguous()
+        return value.clone()
+    if isinstance(value, dict):
+        return {
+            key: _slice_pooler_value(
+                val,
+                req_index=req_index,
+                start=start,
+                end=end,
+                total_tokens=total_tokens,
+                padded_total_tokens=padded_total_tokens,
+                request_scoped=request_scoped,
+            )
+            for key, val in value.items()
+        }
+    if isinstance(value, list):
+        if not value:
+            return []
+        # Lists at the batch level contain request-owned payloads. Their
+        # tensors use local axes even when a size coincides with batch tokens.
+        values = value if request_scoped else [value[req_index] if req_index < len(value) else value[0]]
+        owned = [
+            _slice_pooler_value(
+                item,
+                req_index=req_index,
+                start=start,
+                end=end,
+                total_tokens=total_tokens,
+                request_scoped=True,
+            )
+            for item in values
+        ]
+        return owned if request_scoped else owned[0]
+    return value
+
+
+def _ensure_tensor_values(payload: dict[str, Any]) -> dict[str, torch.Tensor]:
+    """Convert a flattened payload to strictly ``dict[str, torch.Tensor]``.
+
+    Non-tensor scalars (int/float/bool) are wrapped with ``torch.tensor()``;
+    values that cannot be safely converted are dropped. Enforces the tensor-only
+    invariant required by ``OmniEngineCoreOutput.multimodal_output`` (the channel
+    the async_chunk stage-input processor reads). Mirrors the V1 runner helper.
+    """
+    result: dict[str, torch.Tensor] = {}
+    for key, val in payload.items():
+        if isinstance(val, torch.Tensor):
+            result[key] = val
+        elif isinstance(val, (int, float, bool)):
+            result[key] = torch.tensor(val)
+        elif isinstance(val, (list, tuple)):
+            try:
+                result[key] = torch.tensor(val)
+            except (ValueError, TypeError, RuntimeError):
+                logger.warning(
+                    "Dropping non-tensorizable multimodal output key '%s' (type=%s).",
+                    key,
+                    type(val).__name__,
+                )
+        else:
+            logger.warning(
+                "Dropping non-tensor multimodal output key '%s' (type=%s).",
+                key,
+                type(val).__name__,
+            )
+    return result
+
+
+class OmniAsyncOutput(AsyncModelRunnerOutput):
+    """Async D2H copy for Omni AR model outputs.
+
+    Mirrors upstream ``AsyncOutput`` but additionally handles
+    ``pooler_output`` (hidden states + multimodal outputs) via
+    non-blocking copies on the copy stream.
+    """
+
+    def __init__(
+        self,
+        model_runner_output: OmniModelRunnerOutput,
+        sampler_output: Any,
+        num_sampled_tokens: torch.Tensor,
+        main_stream: torch.cuda.Stream,
+        copy_stream: torch.cuda.Stream,
+        copy_event: torch.cuda.Event | None = None,
+        text_hidden: torch.Tensor | None = None,
+        multimodal_outputs: dict | None = None,
+        input_batch: Any | None = None,
+        async_chunk: bool = False,
+        finalize_output: Any | None = None,
+        check_ep_fault: bool = False,
+        routed_experts: RoutedExpertsTensors | None = None,
+    ):
+        self.model_runner_output = model_runner_output
+        self.sampler_output = sampler_output
+        self.num_sampled_tokens = num_sampled_tokens
+        self.routed_experts = routed_experts
+        self.copy_event = copy_event if copy_event is not None else torch.cuda.Event(blocking=True)
+        self._async_chunk = bool(async_chunk)
+        self._finalize_output = finalize_output
+        self._has_fault: torch.Tensor | None = None
+
+        # Snapshot input_batch metadata needed for pooler_output slicing
+        self._need_pooler = text_hidden is not None or (self._async_chunk and bool(multimodal_outputs))
+        self._query_start_loc_np: np.ndarray | None = None
+        self._num_scheduled_tokens: np.ndarray | None = None
+        self._num_reqs: int = 0
+        self._total_tokens: int = 0
+        self._padded_total_tokens: int = 0
+        if self._need_pooler and input_batch is not None:
+            self._query_start_loc_np = input_batch.query_start_loc_np.copy()
+            self._num_scheduled_tokens = np.array(input_batch.num_scheduled_tokens, dtype=np.int32)
+            self._num_reqs = input_batch.num_reqs
+            if self._query_start_loc_np.shape[0] > self._num_reqs:
+                self._total_tokens = int(self._query_start_loc_np[self._num_reqs])
+            else:
+                self._total_tokens = int(self._num_scheduled_tokens[: self._num_reqs].sum())
+            self._padded_total_tokens = int(getattr(input_batch, "num_tokens_after_padding", self._total_tokens))
+
+        # Perform all D2H copies on the copy stream (non-blocking).
+        import contextlib
+
+        @contextlib.contextmanager
+        def _stream(to_stream, from_stream):
+            try:
+                torch.cuda.set_stream(to_stream)
+                yield
+            finally:
+                torch.cuda.set_stream(from_stream)
+
+        with _stream(copy_stream, main_stream):
+            copy_stream.wait_stream(main_stream)
+            pin_memory = PIN_MEMORY
+
+            # Sampled token ids
+            self.sampled_token_ids_np = _async_copy_to_np(
+                sampler_output.sampled_token_ids,
+                copy_stream=copy_stream,
+                pin_memory=pin_memory,
+            )
+            self.num_sampled_tokens_np = _async_copy_to_np(
+                num_sampled_tokens,
+                copy_stream=copy_stream,
+                pin_memory=pin_memory,
+            )
+            self.sampling_mask_tensors = None
+            if sampler_output.sampling_mask_tensors is not None:
+                self.sampling_mask_tensors = sampler_output.sampling_mask_tensors.to_cpu_nonblocking()
+            self.routed_experts_cpu = None
+            if routed_experts is not None:
+                self.routed_experts_cpu = routed_experts.to_cpu_nonblocking()
+
+            # Logprobs
+            self.logprobs_tensors = None
+            if sampler_output.logprobs_tensors is not None:
+                self.logprobs_tensors = sampler_output.logprobs_tensors.to_cpu_nonblocking()
+            self.num_nans: np.ndarray | None = None
+            if sampler_output.num_nans is not None:
+                self.num_nans = _async_copy_to_np(
+                    sampler_output.num_nans,
+                    copy_stream=copy_stream,
+                    pin_memory=pin_memory,
+                )
+
+            # Prompt logprobs
+            self.prompt_logprobs_dict = {
+                k: v.to_cpu_nonblocking() if v is not None else None
+                for k, v in self.model_runner_output.prompt_logprobs_dict.items()
+            }
+            if check_ep_fault:
+                has_fault = get_ep_all2all_manager().query_fault()
+                self._has_fault = has_fault.to("cpu", non_blocking=True)
+
+            # Pooler output (hidden + multimodal) — async D2H
+            self._hidden_cpu: torch.Tensor | None = None
+            self._mm_cpu: dict[str, Any] = {}
+            self._mm_snapshot: dict[str, Any] = {}
+            if self._need_pooler and self._async_chunk:
+                # CUDA graph replay reuses the model's output buffers. Take
+                # ownership directly in pinned host memory on the output copy
+                # stream so deferred finalization never performs a blocking
+                # D2H copy on the runner thread.
+                self._mm_snapshot = _async_copy_mm(
+                    multimodal_outputs,
+                    self._total_tokens,
+                    copy_stream=copy_stream,
+                    pin_memory=pin_memory,
+                )
+            elif self._need_pooler and text_hidden is not None:
+                self._hidden_cpu = _async_copy_tensor(
+                    text_hidden,
+                    copy_stream=copy_stream,
+                    pin_memory=pin_memory,
+                )
+                total_tokens = text_hidden.shape[0]
+                self._mm_cpu = _async_copy_mm(
+                    multimodal_outputs,
+                    total_tokens,
+                    copy_stream=copy_stream,
+                    pin_memory=pin_memory,
+                )
+
+            self.copy_event.record(copy_stream)
+
+    def get_output(self) -> OmniModelRunnerOutput:
+        self.copy_event.synchronize()
+
+        # Sampled token ids
+        sampled_token_ids: list[list[int]] = self.sampled_token_ids_np.tolist()
+        num_sampled_tokens: list[int] = self.num_sampled_tokens_np.tolist()
+        for token_ids, num_tokens in zip(sampled_token_ids, num_sampled_tokens):
+            del token_ids[num_tokens:]
+        self.model_runner_output.sampled_token_ids = sampled_token_ids
+        if self.sampling_mask_tensors is not None:
+            self.model_runner_output.sampling_masks = self.sampling_mask_tensors.tolists(self.num_sampled_tokens_np)
+        if self.routed_experts_cpu is not None:
+            self.model_runner_output.routed_experts = self.routed_experts_cpu.tolists()
+        self.model_runner_output.sampled_token_ids_materialized = True
+
+        # Logprobs
+        if self.num_nans is not None:
+            self.model_runner_output.num_nans_in_logits = dict(
+                zip(self.model_runner_output.req_ids, self.num_nans.tolist())
+            )
+        if self.logprobs_tensors is not None:
+            self.model_runner_output.logprobs = self.logprobs_tensors.tolists()
+        self.model_runner_output.prompt_logprobs_dict = self.prompt_logprobs_dict
+
+        if self._has_fault is not None and self._has_fault.item():
+            mask = get_ep_all2all_manager().query_active_mask()
+            raise RuntimeError(
+                "Fault detected in EP all2all communication: one or more ranks "
+                f"timed out during dispatch/combine. Mask: {mask.cpu().tolist()}"
+            )
+
+        # Pooler output. Populate two channels from the same per-request payloads,
+        # mirroring the V1 runner:
+        #   * pooler_output  -> sync/full-payload path (inline pooling_output bridge)
+        #   * multimodal_outputs -> wire multimodal_output, which the async_chunk
+        #     stage-input processor (talker2code2wav_async_chunk) reads for codes.
+        if self._need_pooler and self._async_chunk:
+            pooler_inter, pooler_client = OmniARModelRunner._build_async_chunk_outputs_from_mm(
+                self._mm_snapshot,
+                self._query_start_loc_np,
+                self._num_scheduled_tokens,
+                self._num_reqs,
+                self._total_tokens,
+                self._padded_total_tokens,
+            )
+            self.model_runner_output.pooler_output = None
+            self.model_runner_output.inter_stage_outputs = pooler_inter
+            self.model_runner_output.multimodal_outputs = (
+                [_ensure_tensor_values(_async_copy_mm_value(p)) if p else {} for p in pooler_client]
+                if pooler_client
+                else None
+            )
+        elif self._need_pooler and self._hidden_cpu is not None:
+            pooler_output = OmniARModelRunner._build_pooler_output_from_cpu(
+                self._hidden_cpu,
+                self._mm_cpu,
+                self._query_start_loc_np,
+                self._num_scheduled_tokens,
+                self._num_reqs,
+            )
+            pooler_payload = cast(list[dict[str, Any] | None], pooler_output) if pooler_output else None
+            self.model_runner_output.pooler_output = pooler_payload
+            self.model_runner_output.inter_stage_outputs = pooler_payload
+            self.model_runner_output.multimodal_outputs = (
+                [_ensure_tensor_values(p) if p else {} for p in pooler_payload] if pooler_payload else None
+            )
+
+        if self._finalize_output is not None:
+            return self._finalize_output(self.model_runner_output)
+        return self.model_runner_output
diff --git a/vllm_omni/worker_v2/omni_data_plane.py b/vllm_omni/worker_v2/omni_data_plane.py
new file mode 100644
index 000000000..c8e5e57cb
--- /dev/null
+++ b/vllm_omni/worker_v2/omni_data_plane.py
@@ -0,0 +1,604 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import defaultdict
+from contextlib import AbstractContextManager, nullcontext
+from dataclasses import dataclass, field
+from queue import Full, Queue
+from types import SimpleNamespace
+from typing import Any, cast
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.data_entry_keys import OmniPayload, unflatten_payload
+from vllm_omni.worker.omni_connector_model_runner_mixin import (
+    OmniConnectorModelRunnerMixin,
+)
+from vllm_omni.worker.payload_span import get_tensor_span, merge_tensor_spans
+from vllm_omni.worker_v2.delivery import (
+    DeliveryTimeoutError,
+    OmniDeliveryManager,
+)
+
+
+@dataclass
+class _NativeRequestState:
+    request_id: str
+    external_req_id: str
+    prompt_token_ids: list[int]
+    additional_information: Any = None
+    sampling_params: Any = None
+    num_computed_tokens: int = 0
+    resumable: bool = False
+    output_token_ids: list[int] = field(default_factory=list)
+    finished: bool = False
+
+    def snapshot(self, *, include_token_history: bool) -> SimpleNamespace:
+        prompt = list(self.prompt_token_ids) if include_token_history else []
+        output = list(self.output_token_ids) if include_token_history else []
+        finished = self.finished
+        request = SimpleNamespace(
+            request_id=self.request_id,
+            req_id=self.request_id,
+            external_req_id=self.external_req_id,
+            prompt_token_ids=prompt,
+            output_token_ids=output,
+            all_token_ids=prompt + output,
+            output_token_count=len(self.output_token_ids),
+            additional_information=self.additional_information,
+            sampling_params=self.sampling_params,
+            num_computed_tokens=self.num_computed_tokens,
+            resumable=self.resumable,
+        )
+        request.is_finished = lambda: finished
+        return request
+
+
+@dataclass(frozen=True)
+class _NativeOutputBatch:
+    req_ids: list[str]
+    inter_stage_outputs: list[Any | None] | None
+    sampled_token_ids: list[list[int]] | None
+
+
+_NATIVE_OUTPUT_STOP = object()
+_NATIVE_OUTPUT_QUEUE_DEPTH = 8
+_DEFAULT_DELIVERY_TIMEOUT_S = 30.0
+_DEFAULT_SHUTDOWN_TIMEOUT_S = 5.0
+logger = init_logger(__name__)
+
+
+class OmniRunnerDataPlane(OmniConnectorModelRunnerMixin):
+    """MRv2-owned stage transport and request-side payload state."""
+
+    def __init__(self, vllm_config: Any, model_config: Any) -> None:
+        self._native_requests: dict[str, _NativeRequestState] = {}
+        self._native_output_lock = threading.RLock()
+        self._native_send_lock = threading.Lock()
+        self._native_outputs_in_flight: dict[str, int] = defaultdict(int)
+        self._native_terminal_pending: set[str] = set()
+        self.init_omni_connectors(model_config=model_config)
+        self._delivery_manager = OmniDeliveryManager(
+            delivery_timeout_s=self._connector_delivery_timeout(),
+            shutdown_timeout_s=_DEFAULT_SHUTDOWN_TIMEOUT_S,
+        )
+        self._can_send = self._custom_process_func is not None
+        self._start_output_worker(max_pending_batches=_NATIVE_OUTPUT_QUEUE_DEPTH)
+
+    def _connector_delivery_timeout(self) -> float:
+        config = getattr(getattr(self, "_omni_connector", None), "config", None)
+        extra = config.get("extra", {}) if isinstance(config, dict) else {}
+        value = extra.get("delivery_timeout_s", _DEFAULT_DELIVERY_TIMEOUT_S)
+        try:
+            timeout = float(value)
+        except (TypeError, ValueError) as error:
+            raise ValueError(f"invalid connector delivery_timeout_s: {value!r}") from error
+        if timeout <= 0:
+            raise ValueError("connector delivery_timeout_s must be positive")
+        return timeout
+
+    def _create_send_completion(self, *, request_id: str, put_key: str) -> Any:
+        return self._delivery_manager.create_ticket(
+            request_id=request_id,
+            put_key=put_key,
+        )
+
+    def _start_output_worker(self, *, max_pending_batches: int) -> None:
+        if max_pending_batches <= 0:
+            raise ValueError("max_pending_batches must be positive")
+        self._native_output_queue: Queue[_NativeOutputBatch | object] = Queue(maxsize=max_pending_batches)
+        self._native_output_error_lock = threading.Lock()
+        self._native_output_error: BaseException | None = None
+        self._connector_send_error_sink = self._record_output_error
+        self._native_output_closed = False
+        stage_id = getattr(self, "_stage_id", "unknown")
+        self._native_output_worker: threading.Thread | None = threading.Thread(
+            target=self._output_worker_loop,
+            name=f"omni-native-output-{stage_id}",
+            daemon=True,
+        )
+        self._native_output_worker.start()
+
+    def _record_output_error(self, error: BaseException) -> None:
+        first_error = False
+        with self._native_output_error_lock:
+            if self._native_output_error is None:
+                self._native_output_error = error
+                first_error = True
+        if first_error:
+            manager = getattr(self, "_delivery_manager", None)
+            if manager is not None:
+                manager.quarantine(error)
+
+    def _raise_output_error(self) -> None:
+        with self._native_output_error_lock:
+            error = self._native_output_error
+        if error is not None:
+            raise RuntimeError(f"native output worker failed: {error}") from error
+
+    def _output_worker_loop(self) -> None:
+        while True:
+            batch = self._native_output_queue.get()
+            try:
+                if batch is _NATIVE_OUTPUT_STOP:
+                    return
+                if self._native_output_error is not None:
+                    continue
+                assert isinstance(batch, _NativeOutputBatch)
+                self.complete_outputs(
+                    req_ids=batch.req_ids,
+                    inter_stage_outputs=batch.inter_stage_outputs,
+                    sampled_token_ids=batch.sampled_token_ids,
+                )
+            except BaseException as error:
+                self._record_output_error(error)
+            finally:
+                self._native_output_queue.task_done()
+
+    def enqueue_outputs(
+        self,
+        *,
+        req_ids: list[str],
+        inter_stage_outputs: list[Any | None] | None,
+        sampled_token_ids: list[list[int]] | None,
+    ) -> None:
+        """Transfer one completed model batch to the ordered output worker."""
+        self._raise_output_error()
+        if self._native_output_closed:
+            raise RuntimeError("native output worker is closed")
+        batch = _NativeOutputBatch(
+            req_ids=req_ids,
+            inter_stage_outputs=inter_stage_outputs,
+            sampled_token_ids=sampled_token_ids,
+        )
+        while True:
+            try:
+                self._native_output_queue.put(batch, timeout=0.1)
+                break
+            except Full:
+                self._raise_output_error()
+        self._raise_output_error()
+
+    def drain_outputs(self) -> None:
+        queue = self._native_output_queue
+        pending_batches = max(1, queue.qsize() + 1)
+        timeout_s = self._delivery_manager.delivery_timeout_s * pending_batches
+        deadline = time.monotonic() + timeout_s
+        while queue.unfinished_tasks:
+            self._raise_output_error()
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                error = DeliveryTimeoutError(
+                    "native output queue drain timed out after "
+                    f"{timeout_s:.3f}s with {queue.unfinished_tasks} "
+                    "unfinished batch(es)"
+                )
+                self._record_output_error(error)
+                self._raise_output_error()
+            with queue.all_tasks_done:
+                if queue.unfinished_tasks:
+                    queue.all_tasks_done.wait(timeout=min(0.05, remaining))
+        self._raise_output_error()
+
+    def _stop_output_worker(self) -> None:
+        worker = getattr(self, "_native_output_worker", None)
+        if worker is None:
+            return
+        self._native_output_closed = True
+        self._delivery_manager.shutdown(RuntimeError("MRv2 output worker shutdown"))
+        deadline = time.monotonic() + self._delivery_manager.shutdown_timeout_s
+        while worker.is_alive():
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            try:
+                self._native_output_queue.put(
+                    _NATIVE_OUTPUT_STOP,
+                    timeout=min(0.05, remaining),
+                )
+                break
+            except Full:
+                continue
+        worker.join(timeout=max(0.0, deadline - time.monotonic()))
+        if worker.is_alive():
+            raise RuntimeError("MRv2 output worker did not stop within its shutdown deadline")
+        self._native_output_worker = None
+
+    def register_request(self, request_data: Any) -> None:
+        self._raise_output_error()
+        req_id = str(request_data.req_id)
+        external_req_id = str(getattr(request_data, "external_req_id", None) or req_id)
+        with self._native_output_lock:
+            self._native_outputs_in_flight.pop(req_id, None)
+            self._native_terminal_pending.discard(req_id)
+            self._native_requests[req_id] = _NativeRequestState(
+                request_id=req_id,
+                external_req_id=external_req_id,
+                prompt_token_ids=list(getattr(request_data, "prompt_token_ids", None) or []),
+                additional_information=getattr(request_data, "additional_information", None),
+                sampling_params=getattr(request_data, "sampling_params", None),
+                num_computed_tokens=int(getattr(request_data, "num_computed_tokens", 0) or 0),
+                resumable=bool(getattr(request_data, "resumable", False)),
+            )
+
+    def reserve_outputs(self, req_ids: list[str]) -> None:
+        """Keep request state alive until deferred runner outputs are consumed."""
+        self._raise_output_error()
+        with self._native_output_lock:
+            for req_id in dict.fromkeys(req_ids):
+                if req_id in self._native_requests:
+                    self._native_outputs_in_flight[req_id] += 1
+
+    def _ready_terminal_requests(self) -> set[str]:
+        return {
+            req_id for req_id in self._native_terminal_pending if self._native_outputs_in_flight.get(req_id, 0) == 0
+        }
+
+    def _emit_ready_terminals(self) -> int:
+        ready = self._ready_terminal_requests()
+        if not ready:
+            return 0
+        emitted = self.emit_chunks(
+            req_ids=[],
+            inter_stage_outputs=None,
+            sampled_token_ids=None,
+            terminal_req_ids=ready,
+        )
+        self._native_terminal_pending.difference_update(ready)
+        for req_id in ready:
+            self._native_outputs_in_flight.pop(req_id, None)
+        return emitted
+
+    def request_terminal(self, req_ids: set[str]) -> int:
+        """Emit terminal markers only after all deferred outputs are enqueued."""
+        self._raise_output_error()
+        with self._native_output_lock:
+            self._native_terminal_pending.update(req_id for req_id in req_ids if req_id in self._native_requests)
+            return self._emit_ready_terminals()
+
+    def abort_requests(self, req_ids: set[str]) -> int:
+        """Cancel deferred outputs and terminate each live request once."""
+        with self._native_output_lock:
+            active_req_ids = {req_id for req_id in req_ids if req_id in self._native_requests}
+            # Receivers are registered before requests acquire model slots.
+            # Cancelling during that interval must still stop recv polling.
+            for req_id in req_ids - active_req_ids:
+                self.cleanup_finished_request(req_id)
+            if not active_req_ids:
+                return 0
+            for req_id in active_req_ids:
+                self._native_outputs_in_flight.pop(req_id, None)
+                self._native_terminal_pending.discard(req_id)
+            return self.emit_chunks(
+                req_ids=[],
+                inter_stage_outputs=None,
+                sampled_token_ids=None,
+                terminal_req_ids=active_req_ids,
+            )
+
+    def complete_outputs(
+        self,
+        *,
+        req_ids: list[str],
+        inter_stage_outputs: list[Any | None] | None,
+        sampled_token_ids: list[list[int]] | None,
+    ) -> int:
+        """Commit one deferred output batch, then release its lifecycle holds."""
+        send_lock_held = False
+        with self._native_output_lock:
+            entries, finished_req_ids = self._build_chunk_entries(
+                req_ids=req_ids,
+                inter_stage_outputs=inter_stage_outputs,
+                sampled_token_ids=sampled_token_ids,
+                terminal_req_ids=set(),
+            )
+            # Claim connector ordering before publishing the updated request
+            # state. request_terminal() can still register a pending terminal
+            # while the enqueue runs, but abort cannot overtake this output.
+            if entries:
+                self._native_send_lock.acquire()
+                send_lock_held = True
+        try:
+            emitted = self._send_chunk_entries(
+                entries,
+                send_lock_held=send_lock_held,
+            )
+        finally:
+            if send_lock_held:
+                self._native_send_lock.release()
+        with self._native_output_lock:
+            self._cleanup_finished_entries(finished_req_ids)
+            for req_id in dict.fromkeys(req_ids):
+                in_flight = self._native_outputs_in_flight.get(req_id, 0)
+                if in_flight > 1:
+                    self._native_outputs_in_flight[req_id] = in_flight - 1
+                elif in_flight == 1:
+                    self._native_outputs_in_flight.pop(req_id, None)
+            return emitted + self._emit_ready_terminals()
+
+    def register_receivers(self, handles: list[Any]) -> None:
+        for handle in handles:
+            self.register_chunk_recv(handle)
+
+    @classmethod
+    def _copy_payload_structure(cls, value: Any) -> Any:
+        if isinstance(value, dict):
+            return {key: cls._copy_payload_structure(item) for key, item in value.items()}
+        if isinstance(value, list):
+            return list(value)
+        return value
+
+    def _accumulate_payload(self, req_id: str, payload_data: OmniPayload) -> OmniPayload:
+        """Accumulate chunk payloads (concat tensors, extend lists)."""
+        if req_id not in self._send_side_request_payload:
+            self._send_side_request_payload[req_id] = dict(payload_data)
+            return cast(OmniPayload, dict(self._send_side_request_payload[req_id]))
+
+        origin = self._send_side_request_payload[req_id]
+        merged = dict(origin)
+        raw_ok = payload_data.get("meta", {}).get("override_keys", []) if isinstance(payload_data, dict) else []
+        override_keys = {tuple(k) if isinstance(k, list) else k for k in raw_ok}
+
+        for key, value in payload_data.items():
+            if isinstance(value, dict):
+                origin_sub = origin.get(key)
+                merged_sub = dict(origin_sub) if isinstance(origin_sub, dict) else {}
+                span_handled: set[str] = set()
+                if key == "embed" and isinstance(origin_sub, dict):
+                    for tk, sk, ek in (("decode", "decode_token_start", "decode_token_end"),):
+                        if tk not in value or (key, tk) in override_keys:
+                            continue
+                        span = merge_tensor_spans(
+                            get_tensor_span(origin_sub, tensor_key=tk, start_key=sk, end_key=ek),
+                            get_tensor_span(value, tensor_key=tk, start_key=sk, end_key=ek),
+                        )
+                        if span is None:
+                            continue
+                        t, s, e = span
+                        merged_sub[tk] = t
+                        merged_sub[sk] = s
+                        merged_sub[ek] = e
+                        span_handled |= {tk, sk, ek}
+                for qual, qval in value.items():
+                    if qual in span_handled:
+                        continue
+                    if key == "meta" and qual == "finished":
+                        merged_sub[qual] = qval
+                        continue
+                    if (key, qual) in override_keys:
+                        merged_sub[qual] = qval
+                        continue
+                    osv = merged_sub.get(qual)
+                    if isinstance(qval, torch.Tensor) and isinstance(osv, torch.Tensor):
+                        merged_sub[qual] = torch.cat([osv, qval], dim=0)
+                    elif isinstance(qval, list) and isinstance(osv, list):
+                        merged_sub[qual] = osv + qval
+                    else:
+                        merged_sub[qual] = qval
+                merged[key] = merged_sub
+            else:
+                if key in override_keys:
+                    merged[key] = value
+                    continue
+                ov = origin.get(key)
+                if isinstance(value, torch.Tensor) and isinstance(ov, torch.Tensor):
+                    merged[key] = torch.cat([ov, value], dim=0)
+                elif isinstance(value, list) and isinstance(ov, list):
+                    merged[key] = ov + value
+                else:
+                    merged[key] = value
+
+        self._send_side_request_payload[req_id] = merged
+        return cast(OmniPayload, dict(merged))
+
+    def pop_local_stage_payload(self, req_id: str) -> Any:
+        """Hand one accumulated delta to the model and acknowledge its rows.
+
+        Connector accumulation and ``model_intermediate_buffer`` are separate
+        ownership domains. Once decode rows are handed to the model, remove
+        them from connector accumulation so the next chunk cannot replay the
+        same rows into Talker's ``cached_decode``.
+        """
+        with self._lock:
+            payload = self._local_stage_payload_cache.pop(req_id, None)
+            if payload is None:
+                return None
+            delivered = self._copy_payload_structure(payload)
+            external_req_id = self._request_ids_mapping.get(req_id, req_id)
+            accumulated = self._send_side_request_payload.get(external_req_id)
+            if isinstance(accumulated, dict):
+                embed = accumulated.get("embed")
+                if isinstance(embed, dict):
+                    embed.pop("decode", None)
+                    embed.pop("decode_token_start", None)
+                    embed.pop("decode_token_end", None)
+                hidden_states = accumulated.get("hidden_states")
+                if isinstance(hidden_states, dict):
+                    hidden_states.pop("output", None)
+                ids = accumulated.get("ids")
+                if isinstance(ids, dict):
+                    ids.pop("output", None)
+            return delivered
+
+    def emit_chunks(
+        self,
+        *,
+        req_ids: list[str],
+        inter_stage_outputs: list[Any | None] | None,
+        sampled_token_ids: list[list[int]] | None,
+        terminal_req_ids: set[str],
+    ) -> int:
+        with self._native_output_lock:
+            entries, finished_req_ids = self._build_chunk_entries(
+                req_ids=req_ids,
+                inter_stage_outputs=inter_stage_outputs,
+                sampled_token_ids=sampled_token_ids,
+                terminal_req_ids=terminal_req_ids,
+            )
+            emitted = self._send_chunk_entries(entries)
+            self._cleanup_finished_entries(finished_req_ids)
+            return emitted
+
+    def _build_chunk_entries(
+        self,
+        *,
+        req_ids: list[str],
+        inter_stage_outputs: list[Any | None] | None,
+        sampled_token_ids: list[list[int]] | None,
+        terminal_req_ids: set[str],
+    ) -> tuple[list[tuple[Any, Any | None]], list[str]]:
+        if not getattr(self, "_can_send", True):
+            receive_finished_ids = [req_id for req_id in sorted(terminal_req_ids) if req_id in self._native_requests]
+            return [], receive_finished_ids
+        payload_by_req = {
+            req_id: inter_stage_outputs[index]
+            for index, req_id in enumerate(req_ids)
+            if inter_stage_outputs is not None and index < len(inter_stage_outputs)
+        }
+        sampled_by_req = {
+            req_id: sampled_token_ids[index]
+            for index, req_id in enumerate(req_ids)
+            if sampled_token_ids is not None and index < len(sampled_token_ids)
+        }
+        entries: list[tuple[Any, Any | None]] = []
+        finished_req_ids: list[str] = []
+        for req_id in dict.fromkeys([*req_ids, *sorted(terminal_req_ids)]):
+            state = self._native_requests.get(req_id)
+            if state is None:
+                continue
+            state.output_token_ids.extend(int(token_id) for token_id in sampled_by_req.get(req_id, []))
+            state.finished = req_id in terminal_req_ids
+            payload = payload_by_req.get(req_id)
+            if isinstance(payload, dict):
+                payload = unflatten_payload(payload)
+            if payload is None and not state.finished:
+                continue
+            include_token_history = bool(state.resumable or self._put_req_chunk.get(state.external_req_id, 0) == 0)
+            entries.append(
+                (
+                    state.snapshot(include_token_history=include_token_history),
+                    payload,
+                )
+            )
+            if state.finished:
+                finished_req_ids.append(req_id)
+        return entries, finished_req_ids
+
+    def _send_chunk_entries(
+        self,
+        entries: list[tuple[Any, Any | None]],
+        *,
+        send_lock_held: bool = False,
+    ) -> int:
+        if not entries:
+            return 0
+        context: AbstractContextManager
+        if send_lock_held:
+            context = nullcontext()
+        else:
+            context = self._native_send_lock
+        with context:
+            return self.send_chunks(entries, propagate_errors=True, wait_for_delivery=True)
+
+    def _cleanup_finished_entries(self, finished_req_ids: list[str]) -> None:
+        for req_id in finished_req_ids:
+            self._native_requests.pop(req_id, None)
+            self.cleanup_finished_request(req_id)
+
+    def shutdown_omni_connectors(self) -> None:
+        """Bound MRv2 shutdown even if a connector call cannot be cancelled.
+
+        Connector ``close()`` runs concurrently with the I/O threads so a
+        backend that supports cancellation can release a blocked ``put()``.
+        Backends that do not support it are quarantined and left only on
+        daemon threads after the bounded deadline; V1 keeps its existing
+        shutdown implementation in the shared mixin.
+        """
+        timeout_s = self._delivery_manager.shutdown_timeout_s
+        deadline = time.monotonic() + timeout_s
+        self._delivery_manager.shutdown(RuntimeError("MRv2 connector shutdown"))
+        self._stop_event.set()
+        self._work_available.set()
+
+        close_errors: list[BaseException] = []
+        connector = getattr(self, "_omni_connector", None)
+
+        def close_connector() -> None:
+            if connector is None:
+                return
+            try:
+                connector.close()
+            except BaseException as error:
+                close_errors.append(error)
+
+        close_thread = threading.Thread(
+            target=close_connector,
+            name=f"omni-native-connector-close-{getattr(self, '_stage_id', 'unknown')}",
+            daemon=True,
+        )
+        close_thread.start()
+
+        live_threads: list[str] = []
+        for name, thread in (
+            ("recv", getattr(self, "_recv_thread", None)),
+            ("save", getattr(self, "_save_thread", None)),
+            ("connector-close", close_thread),
+        ):
+            if thread is None:
+                continue
+            thread.join(timeout=max(0.0, deadline - time.monotonic()))
+            if thread.is_alive():
+                live_threads.append(name)
+
+        if close_errors:
+            raise RuntimeError("MRv2 connector close failed") from close_errors[0]
+        if live_threads:
+            raise RuntimeError(
+                f"MRv2 connector shutdown exceeded {timeout_s:.3f}s; blocked thread(s): {', '.join(live_threads)}"
+            )
+
+    def close(self) -> None:
+        error: BaseException | None = None
+        try:
+            self.drain_outputs()
+        except BaseException as exc:
+            error = exc
+        finally:
+            self._delivery_manager.shutdown(error or RuntimeError("MRv2 data plane close"))
+            try:
+                self._stop_output_worker()
+            except BaseException as exc:
+                if error is None:
+                    error = exc
+            try:
+                self.shutdown_omni_connectors()
+            except BaseException as exc:
+                if error is None:
+                    error = exc
+        if error is not None:
+            raise error
diff --git a/vllm_omni/worker_v2/omni_generation_model_runner.py b/vllm_omni/worker_v2/omni_generation_model_runner.py
new file mode 100644
index 000000000..7c024f675
--- /dev/null
+++ b/vllm_omni/worker_v2/omni_generation_model_runner.py
@@ -0,0 +1,582 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OmniGenerationModelRunner — non-autoregressive stage runner on MR V2.
+
+Used for stages like Code2Wav that convert codec codes to audio waveforms.
+No token sampling or logits computation — model output goes directly into
+``pooler_output``.  Inherits from ``OmniGPUModelRunner`` for intermediate
+buffer and lifecycle hooks.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import Any
+
+import torch
+from vllm.config.compilation import CUDAGraphMode
+from vllm.forward_context import set_forward_context
+from vllm.logger import init_logger
+from vllm.model_executor.layers.fused_moe.all2all_utils import (
+    get_ep_all2all_manager,
+)
+from vllm.utils.torch_utils import PIN_MEMORY
+from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput
+from vllm.v1.outputs import AsyncModelRunnerOutput, ModelRunnerOutput
+from vllm.v1.worker.gpu.model_runner import (
+    BatchDescriptor,
+    ExecuteModelState,
+    IntermediateTensors,
+)
+
+from vllm_omni.core.sched.output import OmniCachedRequestData, OmniNewRequestData
+from vllm_omni.data_entry_keys import flatten_payload
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.outputs import OmniModelRunnerOutput
+from vllm_omni.worker_v2.omni_ar_model_runner import (
+    _async_copy_mm,
+    _ensure_tensor_values,
+)
+from vllm_omni.worker_v2.omni_model_runner import (
+    OmniGPUModelRunner,
+)
+
+logger = init_logger(__name__)
+
+
+def _contains_cuda_tensor(value: Any) -> bool:
+    """Return whether a nested output payload still owns CUDA storage."""
+    if isinstance(value, torch.Tensor):
+        return value.is_cuda
+    if isinstance(value, dict):
+        return any(_contains_cuda_tensor(v) for v in value.values())
+    if isinstance(value, (list, tuple)):
+        return any(_contains_cuda_tensor(v) for v in value)
+    return False
+
+
+def _materialize_generation_value(
+    value: Any,
+    req_index: int,
+    num_reqs: int,
+    *,
+    top_level: bool = True,
+    copy_cpu: bool = True,
+) -> Any:
+    """Recursively select and own one request's generation payload."""
+    if isinstance(value, torch.Tensor):
+        if value.ndim > 0 and value.shape[0] == num_reqs:
+            value = value[req_index]
+        return value.detach().to(device="cpu", copy=copy_cpu and value.device.type == "cpu").contiguous()
+    if isinstance(value, dict):
+        return {
+            key: _materialize_generation_value(item, req_index, num_reqs, top_level=False, copy_cpu=copy_cpu)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        # Tensor lists (e.g. variable-length waveforms) carry one item per
+        # request even inside a dict. Scalar lists remain payload metadata.
+        per_request = top_level or all(item is None or isinstance(item, torch.Tensor) for item in value)
+        if per_request and len(value) == num_reqs:
+            # The selected item no longer has a batch axis.
+            return _materialize_generation_value(value[req_index], 0, -1, top_level=False, copy_cpu=copy_cpu)
+        return [
+            _materialize_generation_value(item, req_index, num_reqs, top_level=False, copy_cpu=copy_cpu)
+            for item in value
+        ]
+    if isinstance(value, tuple):
+        return tuple(
+            _materialize_generation_value(item, req_index, num_reqs, top_level=False, copy_cpu=copy_cpu)
+            for item in value
+        )
+    return value
+
+
+class OmniGenerationAsyncOutput(AsyncModelRunnerOutput):
+    """Overlap generation-stage D2H copies with the next model step."""
+
+    def __init__(
+        self,
+        *,
+        model_runner_output: OmniModelRunnerOutput,
+        multimodal_outputs: dict[str, Any] | None,
+        num_reqs: int,
+        main_stream: torch.cuda.Stream,
+        copy_stream: torch.cuda.Stream,
+        finalize_output: Any | None = None,
+        check_ep_fault: bool = False,
+    ) -> None:
+        self.model_runner_output = model_runner_output
+        self.num_reqs = num_reqs
+        self.finalize_output = finalize_output
+        self.copy_event = torch.cuda.Event(blocking=True)
+        self._has_fault: torch.Tensor | None = None
+
+        with torch.cuda.stream(copy_stream):
+            copy_stream.wait_stream(main_stream)
+            self.multimodal_outputs_cpu = _async_copy_mm(
+                multimodal_outputs,
+                total_tokens=0,
+                copy_stream=copy_stream,
+                pin_memory=PIN_MEMORY,
+            )
+            if check_ep_fault:
+                has_fault = get_ep_all2all_manager().query_fault()
+                self._has_fault = has_fault.to("cpu", non_blocking=True)
+            self.copy_event.record(copy_stream)
+
+    def get_output(self) -> OmniModelRunnerOutput:
+        self.copy_event.synchronize()
+        if self._has_fault is not None and self._has_fault.item():
+            mask = get_ep_all2all_manager().query_active_mask()
+            raise RuntimeError(
+                "Fault detected in EP all2all communication: one or more ranks "
+                f"timed out during dispatch/combine. Mask: {mask.cpu().tolist()}"
+            )
+        payloads = OmniGenerationModelRunner._build_pooler_output_from_cpu(
+            self.multimodal_outputs_cpu,
+            self.num_reqs,
+        )
+        self.model_runner_output.multimodal_outputs = [
+            _ensure_tensor_values(payload) if payload else {} for payload in payloads
+        ]
+        if self.finalize_output is not None:
+            return self.finalize_output(self.model_runner_output)
+        return self.model_runner_output
+
+
+class OmniGenerationModelRunner(OmniGPUModelRunner):
+    """Non-autoregressive generation runner (e.g. Code2Wav).
+
+    Overrides ``execute_model`` to skip the tensor-only assertion and
+    ``sample_tokens`` to construct ``pooler_output`` from multimodal
+    model outputs without performing token sampling.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._gen_model_output: Any = None
+        self._gen_input_batch: Any = None
+        # Placeholder for ExecuteModelState.hidden_states — allocated
+        # once and reused every step to avoid per-forward allocation.
+        self._dummy_hidden = torch.zeros(1, dtype=self.dtype, device=self.device)
+
+    # ------------------------------------------------------------------
+    # Async-chunk support: replace prompt_token_ids for cached requests
+    # ------------------------------------------------------------------
+
+    def _handle_async_chunk_updates(self, scheduler_output: SchedulerOutput) -> None:
+        """In-place update cached requests whose prompt_token_ids changed.
+
+        In async_chunk mode, the ``ChunkTransferAdapter`` replaces
+        ``Request.prompt_token_ids`` with new codec frames for each
+        chunk and resets ``num_computed_tokens`` to 0.  The scheduler
+        propagates the new ``prompt_token_ids`` via
+        ``OmniCachedRequestData``.
+
+        Instead of remove + re-add (which involves free_indices churn
+        and redundant model_state init), we update the existing slot
+        in-place.  This is safe for Code2Wav because:
+        - No KV cache / rope state to reinitialize
+        - staged writes are applied once at the end
+
+        The old intermediate buffer for this slot is cleared here; the
+        inherited ``OmniGPUModelRunner.update_requests`` (called right after
+        this method in ``execute_model``) writes the current chunk state.
+        """
+        cached = scheduler_output.scheduled_cached_reqs
+        if not cached.req_ids:
+            return
+
+        if not isinstance(cached, OmniCachedRequestData):
+            return
+
+        new_prompt_ids = cached.prompt_token_ids
+        if not new_prompt_ids:
+            return
+
+        updated = False
+        released_chunks: list[OmniNewRequestData] = []
+
+        for i, req_id in enumerate(cached.req_ids):
+            new_ids = new_prompt_ids.get(req_id)
+            if new_ids is None:
+                continue
+
+            req_idx = self.req_states.req_id_to_index.get(req_id)
+            if req_idx is None:
+                block_ids = cached.new_block_ids[i]
+                released_chunks.append(
+                    OmniNewRequestData(
+                        req_id=req_id,
+                        prompt_token_ids=new_ids,
+                        mm_features=[],
+                        sampling_params=None,
+                        pooling_params=None,
+                        block_ids=block_ids if block_ids is not None else tuple(),
+                        num_computed_tokens=0,
+                        lora_request=None,
+                        prompt_embeds=None,
+                        prefill_token_ids=new_ids,
+                        additional_information=cached.additional_information.get(req_id),
+                    )
+                )
+                continue
+
+            self.model_state.remove_request(req_idx)
+
+            # In-place update token state — same slot, no remove/re-add.
+            # .np[] = direct write (no GPU buffer); stage_write = GPU-synced.
+            n = len(new_ids)
+            self.req_states.prompt_len.np[req_idx] = n
+            self.req_states.prefill_len.np[req_idx] = n
+            self.req_states.total_len.stage_write_elem(req_idx, n)
+            self.req_states.all_token_ids.stage_write(req_idx, 0, new_ids)
+            self.req_states.num_computed_tokens.stage_write_elem(req_idx, 0)
+            self.req_states.num_computed_prefill_tokens[req_idx] = 0
+
+            updated = True
+
+        if released_chunks:
+            self.add_requests(
+                replace(
+                    scheduler_output,
+                    scheduled_new_reqs=released_chunks,
+                )
+            )
+        if updated:
+            self.req_states.apply_staged_writes()
+
+    def _release_generation_slots(self, input_batch: Any) -> None:
+        if not getattr(self.model_config, "async_chunk", False):
+            return
+        model_state = getattr(self, "model_state", None)
+        remove_request = getattr(self, "_remove_request", None)
+        if model_state is None or remove_request is None:
+            return
+        for i in range(input_batch.num_reqs):
+            req_id = input_batch.req_ids[i]
+            req_idx = int(input_batch.idx_mapping_np[i])
+            model_state.remove_request(req_idx)
+            remove_request(req_id)
+
+    # ------------------------------------------------------------------
+    # profile / warmup — skip sampler since there are no logits
+    # ------------------------------------------------------------------
+
+    @torch.inference_mode()
+    def profile_run(self) -> None:
+        """Generation models have no KV cache — skip profiling.
+
+        Code2Wav shares GPU memory with the Talker stage (same device);
+        its memory footprint is managed via ``gpu_memory_utilization``
+        config, not profiled dynamically.  Running the real model with
+        random input_ids causes out-of-bounds indexing in codec lookup
+        tables.
+        """
+        torch.accelerator.synchronize()
+
+    # ------------------------------------------------------------------
+    # execute_model — run the generation model, store raw output
+    # ------------------------------------------------------------------
+
+    @torch.inference_mode()
+    def execute_model(
+        self,
+        scheduler_output: SchedulerOutput,
+        intermediate_tensors: IntermediateTensors | None = None,
+        dummy_run: bool = False,
+        skip_attn_for_dummy_run: bool = False,
+        is_profile: bool = False,
+        context_len: int = 0,
+    ) -> ModelRunnerOutput | IntermediateTensors | None:
+        if not dummy_run:
+            self._prepare_native_data_plane(scheduler_output)
+            self.finish_requests(scheduler_output)
+            self.free_states(scheduler_output)
+            if (
+                scheduler_output.total_num_scheduled_tokens == 0
+                and not scheduler_output.scheduled_new_reqs
+                and not scheduler_output.scheduled_cached_reqs.req_ids
+            ):
+                # Registration/terminal/abort work has been applied above.
+                # There is no new or cached request state to add or update.
+                self._apply_block_table_staged_writes_if_available()
+                empty_output = self.kv_connector.no_forward(scheduler_output)
+                return self._attach_native_data_plane_signals(
+                    self._merge_ec_connector_no_forward(scheduler_output, empty_output)
+                )
+            # Handle async_chunk prompt_token_ids replacement for cached
+            # requests BEFORE add/update — update the existing slot
+            # in-place with the new chunk's tokens.
+            self._handle_async_chunk_updates(scheduler_output)
+            self.add_requests(scheduler_output)
+            self.update_requests(scheduler_output)
+            self._sync_native_data_plane_payloads(scheduler_output)
+            self._apply_block_table_staged_writes_if_available()
+            if scheduler_output.total_num_scheduled_tokens == 0:
+                empty_output = self.kv_connector.no_forward(scheduler_output)
+                return self._attach_native_data_plane_signals(
+                    self._merge_ec_connector_no_forward(scheduler_output, empty_output)
+                )
+
+        num_reqs = len(scheduler_output.num_scheduled_tokens)
+        num_toks = scheduler_output.total_num_scheduled_tokens
+        max_query_len = max(scheduler_output.num_scheduled_tokens.values())
+        batch_req_state, uniform_tok_count = self.gather_batch_req_state(scheduler_output, dummy_run)
+        if batch_req_state is not None:
+            num_toks = batch_req_state.num_tokens
+        batch_desc, dp_sync = self._dispatch_batch_descriptor(
+            num_reqs=num_reqs,
+            num_toks=num_toks,
+            uniform_tok_count=uniform_tok_count,
+            num_active_loras=0,
+            # Generation stages return structured OmniOutput payloads and do
+            # not expose the tensor-only outer graph contract. Their model may
+            # still use an internal decoder graph, but the vLLM outer runner
+            # always uses eager dispatch here.
+            use_eager=True,
+            max_query_len=max_query_len,
+        )
+
+        if batch_desc.num_tokens == 0:
+            empty_output = self.kv_connector.no_forward(scheduler_output)
+            return self._attach_native_data_plane_signals(
+                self._merge_ec_connector_no_forward(scheduler_output, empty_output)
+            )
+
+        if not dummy_run:
+            assert batch_req_state is not None
+            input_batch = self.prepare_inputs(scheduler_output, batch_req_state, batch_desc)
+        else:
+            from vllm.v1.worker.gpu.input_batch import InputBatch
+
+            input_batch = InputBatch.make_dummy(
+                batch_desc.num_reqs or num_reqs,
+                batch_desc.num_tokens,
+                self.input_buffers,
+                max_query_len=batch_desc.max_query_len,
+            )
+
+        attn_metadata = None
+        slot_mappings_by_layer = None
+
+        input_ids, inputs_embeds, ec_connector_output = self._prepare_mm_inputs(
+            scheduler_output,
+            input_batch,
+            dummy_run=dummy_run,
+        )
+
+        model_inputs = {
+            "input_ids": input_ids,
+            "positions": input_batch.positions,
+            "inputs_embeds": inputs_embeds,
+            "intermediate_tensors": intermediate_tensors,
+            **self.model_state.prepare_inputs(input_batch, self.req_states),
+        }
+        self._add_legacy_forward_inputs(model_inputs, input_batch)
+
+        eplb = getattr(self, "eplb", None)
+        if eplb is not None:
+            eplb.prepare_forward(self.model_config, input_batch.num_tokens)
+
+        batch_descriptor = BatchDescriptor(
+            num_tokens=input_batch.num_tokens_after_padding,
+            has_lora=self.lora_config is not None,
+            num_active_loras=batch_desc.num_active_loras,
+        )
+        with set_forward_context(
+            attn_metadata,
+            self.vllm_config,
+            num_tokens=input_batch.num_tokens_after_padding,
+            cudagraph_runtime_mode=batch_desc.cg_mode,
+            batch_descriptor=batch_descriptor,
+            slot_mapping=slot_mappings_by_layer,
+            is_padding=input_batch.is_padding,
+        ):
+            self.kv_connector.pre_forward(scheduler_output)
+            if batch_desc.cg_mode == CUDAGraphMode.PIECEWISE:
+                assert self.cudagraph_manager is not None
+                model_output = self.cudagraph_manager.run_pw_graph(
+                    self.model,
+                    model_inputs,
+                )
+            else:
+                model_output = self.model(**model_inputs)
+
+        # Convert raw model output to OmniOutput.
+        if not isinstance(model_output, OmniOutput):
+            buffer_list = self.model_state.intermediate_buffer.gather(input_batch)
+            make_output_kwargs = {"model_intermediate_buffer": buffer_list}
+            make_output_kwargs["runtime_additional_information"] = buffer_list
+            model_output = self.model.make_omni_output(model_output, **make_output_kwargs)
+
+        self._gen_model_output = model_output
+        self._gen_input_batch = input_batch
+
+        # ExecuteModelState is required by the upstream engine loop
+        # (EngineCore checks execute_model_state is not None before
+        # calling sample_tokens).
+        self.execute_model_state = ExecuteModelState(
+            input_batch=input_batch,
+            attn_metadata=None,
+            slot_mappings_by_layer=None,
+            hidden_states=self._dummy_hidden,
+            aux_hidden_states=None,
+            finished_req_ids=scheduler_output.finished_req_ids,
+            dp_sync=dp_sync,
+            ec_connector_output=ec_connector_output,
+            routed_experts=None,
+        )
+        return None
+
+    # ------------------------------------------------------------------
+    # sample_tokens — build pooler_output, no actual sampling
+    # ------------------------------------------------------------------
+
+    @torch.inference_mode()
+    def sample_tokens(
+        self,
+        grammar_output: GrammarOutput | None = None,
+    ) -> OmniModelRunnerOutput | AsyncModelRunnerOutput | None:
+        model_output = self._gen_model_output
+        input_batch = self._gen_input_batch
+        execute_model_state = self.execute_model_state
+        self._gen_model_output = None
+        self._gen_input_batch = None
+        self.execute_model_state = None
+
+        if model_output is None or input_batch is None or execute_model_state is None:
+            return None
+
+        num_reqs = input_batch.num_reqs
+
+        # Mark all scheduled tokens as computed so the scheduler does
+        # not re-schedule them.  Unlike AR stages we do NOT call
+        # self.postprocess() — that kernel advances num_computed_tokens
+        # by 1 and emits sampled tokens, which would cause check_stop
+        # to fire.  Instead, set num_computed_tokens = prompt_len
+        # directly, matching V1's behavior.
+        for i in range(num_reqs):
+            req_idx = int(input_batch.idx_mapping_np[i])
+            prompt_len = int(self.req_states.prompt_len.np[req_idx])
+            self.req_states.num_computed_tokens.stage_write_elem(req_idx, prompt_len)
+        self.req_states.num_computed_tokens.apply_write()
+        kv_connector_output = self.kv_connector.post_forward(execute_model_state.finished_req_ids)
+
+        # Async finalization can run after the input batch is reused for the
+        # next scheduler step, so output metadata must not alias the batch.
+        req_ids = list(input_batch.req_ids)
+
+        # Generation models don't do token sampling.  Return one empty
+        # list per request so the scheduler does NOT trigger check_stop
+        # (which would prematurely finish the request).  The request
+        # stays RUNNING until the orchestrator marks it done via
+        # chunk_transfer_adapter.finished_requests.
+        sampled_token_ids: list[list[int]] = [[] for _ in range(len(req_ids))]
+        output = OmniModelRunnerOutput(
+            req_ids=req_ids,
+            req_id_to_index={rid: i for i, rid in enumerate(req_ids)},
+            sampled_token_ids=sampled_token_ids,
+            # Match the V1 generation runner contract: final generation stages
+            # publish audio only through multimodal_outputs.  If the same
+            # payload is also exposed as pooling_output, OutputProcessor routes
+            # it through the pooling path and can duplicate accumulated audio.
+            pooler_output=None,
+            multimodal_outputs=None,
+            kv_connector_output=kv_connector_output,
+            ec_connector_output=execute_model_state.ec_connector_output,
+            sampled_token_ids_materialized=True,
+        )
+
+        raw_multimodal_outputs = model_output.multimodal_outputs
+        can_copy_async = getattr(getattr(self, "device", None), "type", "cpu") == "cuda" and (
+            self.check_ep_fault or _contains_cuda_tensor(raw_multimodal_outputs)
+        )
+        if can_copy_async:
+            async_output = OmniGenerationAsyncOutput(
+                model_runner_output=output,
+                multimodal_outputs=raw_multimodal_outputs,
+                num_reqs=num_reqs,
+                main_stream=self.main_stream,
+                copy_stream=self.output_copy_stream,
+                finalize_output=self._finalize_native_data_plane_output,
+                check_ep_fault=self.check_ep_fault,
+            )
+            self._reserve_native_data_plane_outputs(list(req_ids))
+            self._release_generation_slots(input_batch)
+            return async_output
+
+        # CPU execution keeps the synchronous materialization path. Final
+        # generation stages publish audio only through multimodal_outputs,
+        # matching the V1 generation-runner contract.
+        self._reserve_native_data_plane_outputs(list(req_ids))
+        multimodal_outputs = self._build_pooler_output(model_output, num_reqs)
+        output.multimodal_outputs = [
+            _ensure_tensor_values(payload) if payload else {} for payload in multimodal_outputs
+        ]
+        self._release_generation_slots(input_batch)
+        return self._finalize_native_data_plane_output(output)
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _apply_block_table_staged_writes_if_available(self) -> None:
+        """Flush block-table writes only when this stage has a writer.
+
+        Generation stages such as Code2Wav do not use KV cache or attention
+        metadata. Newer vLLM BlockTable implementations assert that a fused
+        writer exists before applying staged writes; no-KV generation stages
+        legitimately do not have one.
+        """
+        block_tables = getattr(self, "block_tables", None)
+        if block_tables is None:
+            return
+        if getattr(block_tables, "fused_writer", None) is None:
+            return
+        block_tables.apply_staged_writes()
+
+    @staticmethod
+    def _build_pooler_output(
+        model_output: OmniOutput,
+        num_reqs: int,
+    ) -> list[dict[str, Any] | None]:
+        """Extract per-request pooler payloads from model output.
+
+        Code2Wav's ``make_omni_output`` returns
+        ``{"model_outputs": [tensor_per_req, ...], "sr": [...]}``,
+        so each value is a ``list`` with ``len == num_reqs``.
+        """
+        mm = model_output.multimodal_outputs
+        if not isinstance(mm, dict):
+            logger.warning(
+                "Unexpected multimodal_outputs type: %s; returning empty pooler_output",
+                type(mm).__name__ if mm is not None else "None",
+            )
+            return [None] * num_reqs
+
+        pooler: list[dict[str, Any] | None] = []
+        for i in range(num_reqs):
+            payload = {key: _materialize_generation_value(value, i, num_reqs) for key, value in mm.items()}
+            pooler.append(flatten_payload(payload) if isinstance(payload, dict) else payload)
+        return pooler
+
+    @staticmethod
+    def _build_pooler_output_from_cpu(
+        multimodal_outputs: dict[str, Any] | None,
+        num_reqs: int,
+    ) -> list[dict[str, Any] | None]:
+        """Build per-request payloads after an async whole-batch D2H copy."""
+        if not isinstance(multimodal_outputs, dict):
+            return [None] * num_reqs
+
+        pooler: list[dict[str, Any] | None] = []
+        for i in range(num_reqs):
+            payload = {
+                key: _materialize_generation_value(value, i, num_reqs, copy_cpu=False)
+                for key, value in multimodal_outputs.items()
+            }
+            pooler.append(flatten_payload(payload) if isinstance(payload, dict) else payload)
+        return pooler
diff --git a/vllm_omni/worker_v2/omni_model_runner.py b/vllm_omni/worker_v2/omni_model_runner.py
new file mode 100644
index 000000000..20337fc91
--- /dev/null
+++ b/vllm_omni/worker_v2/omni_model_runner.py
@@ -0,0 +1,666 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Omni v2 GPU model runner hooks."""
+
+from __future__ import annotations
+
+import threading
+from typing import TYPE_CHECKING, Any, cast
+
+import torch
+from vllm.config.compilation import CUDAGraphMode
+from vllm.forward_context import (
+    set_forward_context,
+)
+from vllm.logger import init_logger
+from vllm.v1.core.sched.output import SchedulerOutput
+from vllm.v1.worker.gpu.dp_utils import dispatch_cg_and_sync_dp
+from vllm.v1.worker.gpu.input_batch import set_dummy_context
+from vllm.v1.worker.gpu.lora_utils import get_num_active_loras_for_dispatch
+from vllm.v1.worker.gpu.mm.lora import set_active_mm_loras
+from vllm.v1.worker.gpu.model_runner import (
+    BatchDescriptor,
+    BatchExecutionDescriptor,
+    ExecuteModelState,
+    GPUModelRunner,
+    IntermediateTensors,
+    build_slot_mappings_by_layer,
+)
+from vllm.v1.worker.gpu.sample.sampler import Sampler
+
+from vllm_omni.core.sched.omni_scheduling_coordinator import (
+    uses_native_mrv2_data_plane,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.worker.sampling_utils import sanitize_sampling_params_min_tokens_stop_ids
+from vllm_omni.worker_v2.model_states import init_omni_model_state
+from vllm_omni.worker_v2.model_states.intermediate_buffer import (
+    _resolve_additional_information,
+)
+from vllm_omni.worker_v2.model_states.omni_model_state import OmniModelState
+from vllm_omni.worker_v2.omni_data_plane import OmniRunnerDataPlane
+
+if TYPE_CHECKING:
+    from vllm.v1.worker.gpu.mm.encoder_cache import EncoderCache
+
+    from vllm_omni.worker_v2.native_output_worker import NativeOutputWorker
+
+logger = init_logger(__name__)
+
+_model_state_patch_lock = threading.RLock()
+
+
+def _needs_capture_tensor_unwrap(model: Any) -> bool:
+    return bool(getattr(model, "_returns_tuple", False))
+
+
+class OmniGPUModelRunner(GPUModelRunner):
+    """Thin layer over v2 ``GPUModelRunner`` for Omni lifecycle hooks."""
+
+    supports_mm_inputs: bool
+    encoder_cache: EncoderCache | None
+    _native_output_materializer: NativeOutputWorker | None
+    model_state: OmniModelState
+    _last_aux_output: Any
+    _last_multimodal_outputs: dict[str, Any] | None
+    _model_returns_tuple: bool
+
+    def _configure_cudagraph_output_contract(self) -> None:
+        """Select the CUDA graph output contract declared by the model."""
+        self._model_returns_tuple = _needs_capture_tensor_unwrap(self.model)
+        self._exclude_full_graph = self._model_returns_tuple or hasattr(self.model, "_last_captured_layers")
+
+    @staticmethod
+    def _prepare_cudagraph_capture_output(model_output: Any) -> Any:
+        """Unwrap model outputs for the upstream PIECEWISE capture warmup."""
+        if isinstance(model_output, OmniOutput):
+            return model_output.text_hidden_states
+        if isinstance(model_output, tuple) and len(model_output) == 2:
+            return model_output[0]
+        return model_output
+
+    def _add_legacy_forward_inputs(self, model_inputs: dict[str, Any], input_batch: Any) -> None:
+        """Supply forward-only metadata for pipelines not on the native plane."""
+        if self._omni_data_plane is not None:
+            return
+        model_inputs.setdefault("sampling_metadata", getattr(input_batch, "sampling_metadata", None))
+        logits_index = getattr(
+            input_batch,
+            "logits_indices",
+            getattr(input_batch, "logits_index", None),
+        )
+        model_inputs.setdefault("logits_index", logits_index)
+        model_inputs.setdefault("sampler", self.sampler)
+
+    def _get_mm_embeddings(
+        self,
+        scheduled_encoder_inputs: dict[str, list[int]],
+        input_batch: Any,
+    ) -> torch.Tensor:
+        """Call the native vLLM multimodal embedding contract."""
+        return self.model_state.prepare_inputs_embeds(
+            scheduled_encoder_inputs,
+            input_batch,
+            self.req_states,
+        )
+
+    def _prepare_mm_inputs(
+        self,
+        scheduler_output: SchedulerOutput,
+        input_batch: Any,
+        *,
+        dummy_run: bool,
+    ) -> tuple[Any, torch.Tensor | None, Any]:
+        """Prepare native vLLM multimodal model inputs."""
+        input_ids = input_batch.input_ids
+        inputs_embeds = None
+        ec_connector_output = None
+        if not self.supports_mm_inputs or not self.is_first_pp_rank:
+            return input_ids, inputs_embeds, ec_connector_output
+
+        if dummy_run:
+            inputs_embeds = self.model_state.dummy_inputs_embeds(input_batch.num_tokens_after_padding)
+        else:
+            scheduled_encoder_inputs = scheduler_output.scheduled_encoder_inputs
+            if self.lora_config is not None:
+                set_active_mm_loras(
+                    model=self.model,
+                    lora_manager=self.lora_manager,
+                    encoder_cache=self.encoder_cache,
+                    req_id_to_index=self.req_states.req_id_to_index,
+                    lora_state=self.lora_state,
+                    scheduled_encoder_inputs=scheduled_encoder_inputs,
+                )
+            with self.ec_connector.maybe_get_output(scheduler_output) as ec_connector_output:
+                inputs_embeds = self._get_mm_embeddings(
+                    scheduled_encoder_inputs,
+                    input_batch,
+                )
+        if inputs_embeds is not None and not self.model.requires_raw_input_tokens:
+            input_ids = None
+        return input_ids, inputs_embeds, ec_connector_output
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._validate_parallel_support()
+        self._omni_data_plane = (
+            OmniRunnerDataPlane(self.vllm_config, self.model_config)
+            if uses_native_mrv2_data_plane(
+                self.model_config,
+                use_v2_model_runner=True,
+            )
+            else None
+        )
+
+    def _validate_parallel_support(self) -> None:
+        parallel_config = self.vllm_config.parallel_config
+        if parallel_config.pipeline_parallel_size > 1:
+            raise NotImplementedError(
+                "Omni Model Runner V2 does not support pipeline parallel; "
+                "use model_runner: v1 when pipeline_parallel_size > 1"
+            )
+        if getattr(parallel_config, "prefill_context_parallel_size", 1) > 1:
+            raise NotImplementedError(
+                "Omni Model Runner V2 does not support prefill context parallelism; "
+                "use model_runner: v1 when prefill_context_parallel_size > 1"
+            )
+
+    def add_requests(self, scheduler_output: SchedulerOutput) -> None:
+        # The upstream Sampler stages static parameters only in add_request.
+        # With no new requests, its UVA snapshots remain valid and immutable.
+        # Keep the upstream path for custom/speculative samplers, whose staged
+        # writes may have a different lifecycle.
+        if not scheduler_output.scheduled_new_reqs and type(getattr(self, "sampler", None)) is Sampler:
+            return
+        logits_processor = getattr(self.model, "logits_processor", None)
+        logits_vocab = getattr(logits_processor, "vocab_size", None)
+        if isinstance(logits_vocab, int) and logits_vocab > 0:
+            for request_data in scheduler_output.scheduled_new_reqs:
+                sampling_params = request_data.sampling_params
+                if sampling_params is not None:
+                    sanitize_sampling_params_min_tokens_stop_ids(
+                        sampling_params,
+                        logits_vocab,
+                    )
+        super().add_requests(scheduler_output)
+
+    def shutdown(self) -> None:
+        # Every owner must release its resources even if an earlier drain fails.
+        try:
+            worker = getattr(self, "_native_output_materializer", None)
+            if worker is not None:
+                worker.close()
+        finally:
+            self._native_output_materializer = None
+            try:
+                if self._omni_data_plane is not None:
+                    self._omni_data_plane.close()
+            finally:
+                super().shutdown()
+
+    def _prepare_native_data_plane(self, scheduler_output: SchedulerOutput) -> None:
+        plane = getattr(self, "_omni_data_plane", None)
+        if plane is None:
+            return
+        for request_data in getattr(scheduler_output, "scheduled_new_reqs", []):
+            if str(getattr(request_data, "req_id", "")).startswith("_warmup_"):
+                continue
+            plane.register_request(request_data)
+        plane.register_receivers(list(getattr(scheduler_output, "pending_input_registrations", [])))
+        natural_terminal_req_ids = set(getattr(scheduler_output, "data_plane_terminal_req_ids", set()))
+        aborted_req_ids = set(getattr(scheduler_output, "finished_req_ids", set())).difference(natural_terminal_req_ids)
+        if natural_terminal_req_ids:
+            plane.request_terminal(natural_terminal_req_ids)
+        if aborted_req_ids:
+            plane.abort_requests(aborted_req_ids)
+
+    def _sync_native_data_plane_payloads(
+        self,
+        scheduler_output: SchedulerOutput,
+    ) -> None:
+        plane = getattr(self, "_omni_data_plane", None)
+        if plane is None:
+            return
+        gpu_keys: set[tuple[str, str]] = getattr(self.model, "gpu_resident_buffer_keys", set())
+        for req_id in scheduler_output.num_scheduled_tokens:
+            req_idx = self.req_states.req_id_to_index.get(req_id)
+            if req_idx is None:
+                continue
+            payload = plane.pop_local_stage_payload(req_id)
+            if isinstance(payload, dict) and payload:
+                self.model_state.intermediate_buffer.update(
+                    req_idx,
+                    payload,
+                    gpu_keys,
+                )
+
+    def _uses_native_output_materializer(self) -> bool:
+        parallel = getattr(getattr(self, "vllm_config", None), "parallel_config", None)
+        # Multi-rank executors already consume outputs asynchronously and choose
+        # the replying rank themselves. Preserve that ownership contract.
+        return getattr(parallel, "tensor_parallel_size", 1) == 1 and getattr(self, "_omni_data_plane", None) is not None
+
+    def _materialize_native_output(self, output: Any) -> Any:
+        from vllm_omni.worker_v2.native_output_worker import NativeOutputWorker
+
+        worker = getattr(self, "_native_output_materializer", None)
+        if worker is None:
+            worker = NativeOutputWorker(getattr(self.vllm_config, "max_concurrent_batches", 2), self.device)
+            self._native_output_materializer = worker
+        return worker.submit(output, self._omni_data_plane)
+
+    def _finalize_native_data_plane_output(self, output: Any) -> Any:
+        plane = getattr(self, "_omni_data_plane", None)
+        if plane is None or output is None:
+            return output
+        # MRv2's data plane consumes the host-materialized token lists from
+        # the runner output.  Do not let a future connector path fall back to
+        # reading sampler tensors and synchronizing the device here.
+        if hasattr(output, "sampled_token_ids_materialized") and getattr(output, "sampled_token_ids", None) is not None:
+            if not output.sampled_token_ids_materialized:
+                raise RuntimeError("MRv2 native data plane received non-materialized sampled_token_ids")
+        inter_stage_outputs = getattr(output, "inter_stage_outputs", None)
+        plane.enqueue_outputs(
+            req_ids=list(getattr(output, "req_ids", [])),
+            inter_stage_outputs=inter_stage_outputs,
+            sampled_token_ids=getattr(output, "sampled_token_ids", None),
+        )
+        output.inter_stage_outputs = None
+        output.omni_connector_output = plane.get_omni_connector_output()
+        return output
+
+    def _reserve_native_data_plane_outputs(self, req_ids: list[str]) -> None:
+        plane = getattr(self, "_omni_data_plane", None)
+        if plane is not None:
+            plane.reserve_outputs(req_ids)
+
+    def _attach_native_data_plane_signals(self, output: Any) -> Any:
+        plane = getattr(self, "_omni_data_plane", None)
+        if plane is None:
+            return output
+        return plane.attach_omni_connector_output(output)
+
+    def load_model(self, *args: Any, **kwargs: Any) -> None:
+        import vllm.v1.worker.gpu.model_runner as _mr_module
+
+        with _model_state_patch_lock:
+            _orig = _mr_module.init_model_state
+            _mr_module.init_model_state = init_omni_model_state
+            try:
+                super().load_model(*args, **kwargs)
+            finally:
+                _mr_module.init_model_state = _orig
+        self._last_aux_output = None
+        self._last_multimodal_outputs = None
+        self._configure_cudagraph_output_contract()
+
+        # Preprocess models own embedding buffers; encoder_runner sizing would mismatch.
+        if getattr(self.model, "has_preprocess", False) and self.supports_mm_inputs:
+            self.supports_mm_inputs = False
+            self.encoder_cache = None
+
+    # ------------------------------------------------------------------
+    # CUDA Graph: conditionally exclude FULL mode
+    # ------------------------------------------------------------------
+
+    def _exclude_unsupported_full_graphs(self) -> None:
+        # vLLM 0.29 keys dispatch candidates by (uniform token count, LoRA count).
+        manager = self.cudagraph_manager
+        assert manager is not None
+        manager._capture_descs.pop(CUDAGraphMode.FULL, None)
+        manager._candidates = {
+            key: [desc for desc in candidates if desc.cg_mode != CUDAGraphMode.FULL]
+            for key, candidates in manager._candidates.items()
+        }
+        logger.info("Excluded FULL CUDA graph capture for Omni model. PIECEWISE graphs will still be captured.")
+
+    def capture_model(self) -> int:
+        """Handle CUDA graph capture for Omni models.
+
+        Tuple-returning models use PIECEWISE graphs; FULL replay requires
+        a tensor output.
+
+        For PIECEWISE capture, the warmup pass runs with
+        ``CUDAGraphMode.NONE`` which hits ``torch.empty_like(hidden_states)``
+        in the cudagraph framework.  If the model returns a tuple, that call
+        crashes.  We temporarily wrap the model's forward to extract only the
+        tensor part during capture, then restore the original forward.
+        """
+        if self._exclude_full_graph:
+            self._exclude_unsupported_full_graphs()
+
+        # Wrap model forward during capture so tuple returns don't crash
+        # torch.empty_like() in the PIECEWISE warmup pass.
+        if self._model_returns_tuple:
+            original_forward = self.model.forward
+
+            def _capture_forward(*args: Any, **kwargs: Any) -> Any:
+                output = original_forward(*args, **kwargs)
+                return self._prepare_cudagraph_capture_output(output)
+
+            self.model.forward = _capture_forward  # type: ignore[assignment]
+            try:
+                result = super().capture_model()
+            finally:
+                self.model.forward = original_forward  # type: ignore[assignment]
+        else:
+            result = super().capture_model()
+
+        capture_mtp = getattr(getattr(self, "model_state", None), "capture_mtp_graphs", None)
+        if callable(capture_mtp):
+            capture_mtp(self._dispatch_mtp_batch_descriptor)
+        return result
+
+    def _dispatch_mtp_batch_descriptor(self, num_mtp_reqs: int) -> Any:
+        capture_sizes = self.model_state._get_mtp_capture_sizes()
+        captured_bucket = next(
+            (size for size in sorted(capture_sizes) if num_mtp_reqs <= size <= self.scheduler_config.max_num_seqs),
+            None,
+        )
+        if captured_bucket is None:
+            return BatchExecutionDescriptor(
+                cg_mode=CUDAGraphMode.NONE,
+                num_tokens=num_mtp_reqs,
+                num_reqs=num_mtp_reqs,
+            )
+        return self.cudagraph_manager.dispatch(
+            captured_bucket,
+            captured_bucket,
+            1,
+            0,
+        )
+
+    def _dispatch_batch_descriptor(
+        self,
+        *,
+        num_reqs: int,
+        num_toks: int,
+        uniform_tok_count: int | None,
+        num_active_loras: int,
+        use_eager: bool,
+        max_query_len: int,
+    ):
+        return dispatch_cg_and_sync_dp(
+            self.cudagraph_manager,
+            num_reqs,
+            num_toks,
+            uniform_tok_count,
+            self.dp_size,
+            self.dp_rank,
+            max_query_len=max_query_len,
+            need_eager=use_eager,
+            num_active_loras=num_active_loras,
+        )
+
+    @torch.inference_mode()
+    def execute_model(
+        self,
+        scheduler_output: SchedulerOutput,
+        intermediate_tensors: IntermediateTensors | None = None,
+        dummy_run: bool = False,
+        skip_attn_for_dummy_run: bool = False,
+        is_profile: bool = False,
+        context_len: int = 0,
+    ) -> Any:
+        if not dummy_run:
+            self._prepare_native_data_plane(scheduler_output)
+            self.finish_requests(scheduler_output)
+            self.free_states(scheduler_output)
+            self.add_requests(scheduler_output)
+            self.update_requests(scheduler_output)
+            self._sync_native_data_plane_payloads(scheduler_output)
+            self.block_tables.apply_staged_writes()
+            if scheduler_output.total_num_scheduled_tokens == 0:
+                empty_output = self.kv_connector.no_forward(scheduler_output)
+                return self._attach_native_data_plane_signals(
+                    self._merge_ec_connector_no_forward(scheduler_output, empty_output)
+                )
+
+        num_reqs = len(scheduler_output.num_scheduled_tokens)
+        num_toks = scheduler_output.total_num_scheduled_tokens
+        max_query_len = max(scheduler_output.num_scheduled_tokens.values())
+        batch_req_state, uniform_tok_count = self.gather_batch_req_state(scheduler_output, dummy_run)
+        if batch_req_state is not None:
+            num_toks = batch_req_state.num_tokens
+        num_active_loras = 0
+        if self.lora_config:
+            req_ids = list(scheduler_output.num_scheduled_tokens.keys())
+            num_active_loras = get_num_active_loras_for_dispatch(
+                self.lora_config,
+                self.lora_state,
+                req_ids,
+                dummy_run,
+            )
+        # Encoder-decoder models: disable compilation when encoder inputs
+        # are scheduled (dynamic cross-attention cache updates).
+        skip_compiled = self.is_encoder_decoder and bool(scheduler_output.scheduled_encoder_inputs)
+        batch_desc, dp_sync = self._dispatch_batch_descriptor(
+            num_reqs=num_reqs,
+            num_toks=num_toks,
+            uniform_tok_count=uniform_tok_count,
+            num_active_loras=num_active_loras,
+            use_eager=is_profile or skip_compiled,
+            max_query_len=max_query_len,
+        )
+
+        if batch_desc.num_tokens == 0:
+            empty_output = self.kv_connector.no_forward(scheduler_output)
+            return self._attach_native_data_plane_signals(
+                self._merge_ec_connector_no_forward(scheduler_output, empty_output)
+            )
+
+        if not dummy_run:
+            assert batch_req_state is not None
+            input_batch = self.prepare_inputs(scheduler_output, batch_req_state, batch_desc)
+            block_tables, slot_mappings = self.prepare_attn(input_batch)
+            self.model_state.preprocess_state(
+                input_batch,
+                block_tables,
+                self.kv_cache_config,
+                self.req_states.num_computed_tokens.gpu,
+            )
+
+            if self.lora_config:
+                lora_inputs = self.lora_state.make_lora_inputs(
+                    input_batch.req_ids,
+                    input_batch.idx_mapping_np,
+                    input_batch.num_scheduled_tokens,
+                )
+                self._set_active_loras(*lora_inputs)
+        else:
+            from vllm.v1.worker.gpu.input_batch import InputBatch
+
+            input_batch = InputBatch.make_dummy(
+                batch_desc.num_reqs or num_reqs,
+                batch_desc.num_tokens,
+                self.input_buffers,
+                max_query_len=batch_desc.max_query_len,
+            )
+            if not skip_attn_for_dummy_run:
+                block_tables, slot_mappings = self.prepare_dummy_attn(input_batch)
+                if context_len:
+                    set_dummy_context(
+                        input_batch,
+                        self.block_tables,
+                        context_len,
+                        self.kv_cache_config.num_blocks,
+                        self.max_model_len,
+                    )
+            else:
+                assert batch_desc.cg_mode != CUDAGraphMode.FULL, (
+                    "Attention metadata is required for FULL CUDA graph dummy runs"
+                )
+                block_tables = None
+                slot_mappings = None
+
+        attn_metadata = None
+        slot_mappings_by_layer = None
+        if not (dummy_run and skip_attn_for_dummy_run):
+            assert slot_mappings is not None
+            slot_mappings_by_layer = build_slot_mappings_by_layer(slot_mappings, self.kv_cache_config)
+            assert block_tables is not None
+            attn_metadata = self.model_state.prepare_attn(
+                input_batch,
+                batch_desc.cg_mode,
+                block_tables,
+                slot_mappings,
+                self.attn_groups,
+                self.kv_cache_config,
+                for_capture=dummy_run and batch_desc.cg_mode == CUDAGraphMode.FULL,
+            )
+        input_ids, inputs_embeds, ec_connector_output = self._prepare_mm_inputs(
+            scheduler_output,
+            input_batch,
+            dummy_run=dummy_run,
+        )
+
+        model_inputs: dict[str, Any] = {
+            "input_ids": input_ids,
+            "positions": input_batch.positions,
+            "inputs_embeds": inputs_embeds,
+            "intermediate_tensors": intermediate_tensors,
+            **self.model_state.prepare_inputs(input_batch, self.req_states),
+        }
+        self._add_legacy_forward_inputs(model_inputs, input_batch)
+        # ★ PRE-FORWARD: per-request preprocess + batched MTP.
+        # Runs for ALL graph modes (FULL, PIECEWISE, NONE).
+        # For FULL graph: OmniModelState provides a static inputs_embeds
+        # buffer that was captured by the graph.  Preprocess writes
+        # in-place to this buffer, and FULL graph replay reads the
+        # updated values from the same tensor address.
+        if not dummy_run:
+            self.model_state.run_preprocess(
+                input_batch,
+                model_inputs,
+                self.req_states,
+                self._dispatch_mtp_batch_descriptor,
+            )
+
+        self.eplb.prepare_forward(self.model_config, input_batch.num_tokens)
+
+        # --- Model forward ---
+        if batch_desc.cg_mode == CUDAGraphMode.FULL:
+            # FULL graph replay.  Preprocess already wrote to the static
+            # inputs_embeds buffer above.
+            assert self.cudagraph_manager is not None
+            self.kv_connector.pre_forward(scheduler_output)
+            hidden_states = self.cudagraph_manager.run_fullgraph(batch_desc)
+            self._last_aux_output = None
+            self._last_multimodal_outputs = None
+            if hasattr(self.model, "_last_captured_layers"):
+                self.model._last_captured_layers = self._last_aux_output
+        else:
+            batch_descriptor = BatchDescriptor(
+                num_tokens=input_batch.num_tokens_after_padding,
+                has_lora=self.lora_config is not None,
+                num_active_loras=batch_desc.num_active_loras,
+            )
+            with set_forward_context(
+                attn_metadata,
+                self.vllm_config,
+                num_tokens=input_batch.num_tokens_after_padding,
+                cudagraph_runtime_mode=batch_desc.cg_mode,
+                num_tokens_across_dp=dp_sync.num_tokens_across_dp if dp_sync is not None else None,
+                batch_descriptor=batch_descriptor,
+                slot_mapping=slot_mappings_by_layer,
+                skip_compiled=skip_compiled,
+                is_padding=input_batch.is_padding,
+            ):
+                self.kv_connector.pre_forward(scheduler_output)
+                if batch_desc.cg_mode == CUDAGraphMode.PIECEWISE:
+                    assert self.cudagraph_manager is not None
+                    model_output = self.cudagraph_manager.run_pw_graph(
+                        self.model,
+                        model_inputs,
+                    )
+                else:
+                    model_output = self.model(**model_inputs)
+
+            # Extract hidden_states from model output.
+            self._last_aux_output = None
+            self._last_multimodal_outputs = None
+            if isinstance(model_output, OmniOutput):
+                hidden_states = model_output.text_hidden_states
+                if model_output.multimodal_outputs:
+                    self._last_multimodal_outputs = cast(dict[str, Any], model_output.multimodal_outputs)
+            elif isinstance(model_output, tuple) and len(model_output) == 2:
+                hidden_states, self._last_aux_output = model_output
+                if hasattr(self.model, "_last_captured_layers"):
+                    self.model._last_captured_layers = self._last_aux_output
+            else:
+                hidden_states = model_output
+        if not dummy_run and isinstance(hidden_states, torch.Tensor):
+            self.model_state.run_postprocess(hidden_states, input_batch)
+
+        routed_experts = None
+        if not dummy_run and (capturer := self.routed_experts_capturer) is not None:
+            assert slot_mappings is not None
+            routed_experts = capturer.get_routed_experts(slot_mappings, num_toks)
+
+        self.execute_model_state = ExecuteModelState(
+            input_batch=input_batch,
+            attn_metadata=attn_metadata,
+            slot_mappings_by_layer=slot_mappings_by_layer,
+            hidden_states=hidden_states,
+            aux_hidden_states=None,
+            finished_req_ids=scheduler_output.finished_req_ids,
+            dp_sync=dp_sync,
+            ec_connector_output=ec_connector_output,
+            routed_experts=routed_experts,
+        )
+
+        assert isinstance(hidden_states, torch.Tensor)
+        return None
+
+    # ------------------------------------------------------------------
+    # Request lifecycle: update intermediate buffer from cached requests
+    # ------------------------------------------------------------------
+
+    def update_requests(self, scheduler_output: SchedulerOutput) -> None:
+        """Merge updated additional_information into intermediate_buffer.
+
+        In async_chunk mode, chunk_transfer_adapter attaches updated
+        additional_information (e.g. thinker_decode_embeddings) to
+        OmniCachedRequestData for cached requests every schedule step.
+        Upstream GPUModelRunner.update_requests does not handle this
+        field, so we merge it into the intermediate buffer here.
+        """
+        super().update_requests(scheduler_output)
+
+        cached = scheduler_output.scheduled_cached_reqs
+        addl_info = getattr(cached, "additional_information", None)
+        if not addl_info:
+            return
+        for req_id, info in addl_info.items():
+            if info is None:
+                continue
+            req_idx = self.req_states.req_id_to_index.get(req_id)
+            if req_idx is None:
+                continue
+            resolved = _resolve_additional_information(info)
+            if resolved:
+                gpu_keys: set[tuple[str, str]] = getattr(self.model, "gpu_resident_buffer_keys", set())
+                self.model_state.intermediate_buffer.update(req_idx, resolved, gpu_keys)
+
+    # ------------------------------------------------------------------
+    # Request lifecycle: clean up intermediate buffer on finish
+    # ------------------------------------------------------------------
+
+    def finish_requests(self, scheduler_output: SchedulerOutput) -> None:
+        # IMPORTANT: Must query req_id_to_index BEFORE super().finish_requests()
+        # because super() calls req_states.remove_request(req_id) which pops the
+        # mapping and returns the slot index to free_indices.
+        finished = scheduler_output.finished_req_ids
+        on_finished = getattr(self.model, "on_requests_finished", None)
+        if finished and callable(on_finished):
+            # Request-owned state outlives generation slots and chunk boundaries.
+            # Notify even if the last chunk already released its runner slot.
+            on_finished(finished)
+        preempted = scheduler_output.preempted_req_ids
+        all_done = finished | preempted if preempted else finished
+        for req_id in all_done:
+            idx = self.req_states.req_id_to_index.get(req_id)
+            if idx is not None:
+                self.model_state.remove_request(idx)
+        super().finish_requests(scheduler_output)
diff --git a/vllm_omni/worker_v2/output_snapshot.py b/vllm_omni/worker_v2/output_snapshot.py
new file mode 100644
index 000000000..31187ddf7
--- /dev/null
+++ b/vllm_omni/worker_v2/output_snapshot.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Owned, dtype-grouped snapshots for asynchronous runner outputs."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Callable
+from typing import Any
+
+import torch
+from torch.utils._pytree import tree_flatten, tree_unflatten
+
+
+class PackedOutputSnapshot(dict):
+    """A normal payload mapping with an internal batched-copy plan.
+
+    The runner's snapshot-slot event protects the device slabs until D2H is
+    complete. Host slabs are allocated per output, so downstream consumers can
+    retain their views without depending on reuse of the device ring slot.
+    """
+
+    def __init__(self, leaves: list[Any], spec: Any, groups: list[tuple[list[int], torch.Tensor]]) -> None:
+        super().__init__(tree_unflatten(leaves, spec))
+        self._leaves = leaves
+        self._spec = spec
+        self._groups = groups
+
+    def copy_to_cpu(self, copy_tensor: Callable[[torch.Tensor], torch.Tensor]) -> dict[str, Any]:
+        leaves = list(self._leaves)
+        for indices, slab in self._groups:
+            cpu = copy_tensor(slab)
+            offset = 0
+            for index in indices:
+                value = leaves[index]
+                size = value.numel()
+                leaves[index] = cpu.narrow(0, offset, size).view(value.shape)
+                offset += size
+        return tree_unflatten(leaves, self._spec)
+
+
+def pack_output_snapshot(
+    payload: dict[str, Any], slot: dict[tuple[Any, ...], torch.Tensor], *, max_buckets: int
+) -> PackedOutputSnapshot | None:
+    """Copy tensor leaves once per dtype/device, retaining their exact values.
+
+    No CUDA synchronization is introduced here. The caller must select the
+    producer stream and wait for the previous consumer before reusing a slot.
+    """
+    leaves, spec = tree_flatten(payload)
+    grouped: dict[tuple[Any, ...], list[int]] = defaultdict(list)
+    for index, value in enumerate(leaves):
+        if isinstance(value, torch.Tensor):
+            # Preserve the existing per-tensor path for unusual layouts.
+            if value.layout != torch.strided or value.is_quantized:
+                return None
+            grouped[(value.dtype, value.device)].append(index)
+    groups = []
+    for (dtype, device), indices in grouped.items():
+        values = [leaves[index].detach().reshape(-1) for index in indices]
+        size = sum(value.numel() for value in values)
+        key = ("packed-output", dtype, device, size)
+        slab = slot.get(key)
+        if slab is None:
+            slab = torch.empty(size, dtype=dtype, device=device)
+            if len(slot) < max_buckets:
+                slot[key] = slab
+        if len(values) == 1:
+            slab.copy_(values[0])
+        else:
+            torch.cat(values, out=slab)
+        offset = 0
+        for index, value in zip(indices, values):
+            shape = leaves[index].shape
+            leaves[index] = slab.narrow(0, offset, value.numel()).view(shape)
+            offset += value.numel()
+        groups.append((indices, slab))
+    return PackedOutputSnapshot(leaves, spec, groups)